feat: conferences summary endpoint + indexes (Phase 0 + Phase 1 of #20) (#24)

* feat: add GET /v1/conferences/summary endpoint for dashboard charts

Returns conference counts grouped by day, bucketed into
success/warning/error/ongoing. This replaces the pattern of downloading
all conferences to the browser and aggregating client-side.

Observed benefit on local test data (2,573 conferences, 1.1 MB response):
- Full list: 1,139,816 bytes
- Summary:   854 bytes  (1335x smaller)

Supports appId, created_at_gte, created_at_lte query params. Handles
both Python 3.8 native ISO format and the Z suffix that JavaScript
toISOString produces.

Implementation uses a CASE expression to classify each conference as
ongoing/error/warning/success (mutually exclusive stacks the chart
renders), then groups by (day, status). Works around Postgres's
restriction that correlated subqueries (Exists) aren't allowed inside
COUNT(...) FILTER clauses.

Phase 1 of #20.

* feat: add Phase 0 indexes for dashboard aggregation queries

Prerequisite for the summary endpoint (Phase 1) to scale on production.
Without these, the aggregation query still runs a full table scan on
42K+ conferences.

- conference(app, -created_at): filter + order for summary endpoint
- issue(conference, type): speeds up the Exists subqueries that
  classify conferences as has_error / has_warning
- app_genericevent(app, -created_at): future event summary endpoints
  and cleanup queries

Per the phased plan in #20 and #15.

* fix: declare dashboard indexes in model Meta.indexes

Addresses review feedback. The indexes were only defined in the
migration's AddIndex operations; the models didn't declare them in
Meta.indexes. That created a state mismatch where future
makemigrations runs would generate RemoveIndex operations for these
performance-critical indexes during unrelated schema work.

Verified: `python manage.py makemigrations --dry-run` now reports
"No changes detected" after the model updates.

Author: Boanerges1996

app/migrations/0004_dashboard_indexes.py

@@ -0,0 +1,44 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    """
+    Phase 0 indexes for the dashboard aggregation work (#20).
+
+    Targets the queries run by the new /v1/conferences/summary endpoint
+    and similar time-range dashboard queries:
+
+    - conference(app_id, created_at): filter + GROUP BY for the summary
+    - issue(conference_id, type): speeds up the EXISTS subqueries that
+      classify conferences as has_error / has_warning
+    - app_genericevent(app_id, created_at): future summary endpoints that
+      group events by day (also helps cleanup_stale_conferences)
+    """
+
+    dependencies = [
+        ('app', '0003_conference_unique_together'),
+    ]
+
+    operations = [
+        migrations.AddIndex(
+            model_name='conference',
+            index=models.Index(
+                fields=['app', '-created_at'],
+                name='idx_conf_app_created',
+            ),
+        ),
+        migrations.AddIndex(
+            model_name='issue',
+            index=models.Index(
+                fields=['conference', 'type'],
+                name='idx_issue_conf_type',
+            ),
+        ),
+        migrations.AddIndex(
+            model_name='genericevent',
+            index=models.Index(
+                fields=['app', '-created_at'],
+                name='idx_genevent_app_created',
+            ),
+        ),
+    ]

app/models/conference.py

@@ -38,6 +38,9 @@ class Conference(BaseModel):
     class Meta:
         db_table = 'conference'
         unique_together = (('conference_id', 'app'),)
+        indexes = [
+            models.Index(fields=['app', '-created_at'], name='idx_conf_app_created'),
+        ]
 
     cache_keys = (
         sorted(('id',)),

app/models/generic_event.py

@@ -32,6 +32,11 @@ class GenericEvent(BaseModel):
         data: the data of the event
     """
 
+    class Meta:
+        indexes = [
+            models.Index(fields=['app', '-created_at'], name='idx_genevent_app_created'),
+        ]
+
     id = models.UUIDField(primary_key=True, default=uuid.uuid4)
     conference = models.ForeignKey('Conference', on_delete=models.CASCADE, null=False, related_name='events')
     participant = models.ForeignKey('Participant', on_delete=models.CASCADE, null=False, related_name='events')

app/models/issue.py

@@ -86,6 +86,11 @@ class Issue(BaseModel):
     """
     TYPES_OF_ISSUES = TYPES_OF_ISSUES
 
+    class Meta:
+        indexes = [
+            models.Index(fields=['conference', 'type'], name='idx_issue_conf_type'),
+        ]
+
     cache_keys = (
         sorted(('id',)),
     )

app/urls.py

@@ -5,6 +5,7 @@
 from .views.apps_view import AppsView
 from .views.browser_event_view import BrowserEventView
 from .views.conference_view import ConferencesView
+from .views.conference_summary_view import ConferenceSummaryView
 from .views.connection_event_view import ConnectionEventView
 from .views.connection_view import ConnectionView
 from .views.issue_view import IssueView
@@ -55,6 +56,7 @@
     path('apps/<uuid:pk>/reset-key', AppsResetApiKeyView.as_view(), name='app-reset-key'),
 
     path('conferences', ConferencesView.as_view(), name='conferences'),
+    path('conferences/summary', ConferenceSummaryView.as_view(), name='conferences-summary'),
     path('conferences/<uuid:pk>', ConferencesView.as_view(), name='conference'),
     path('conferences/<uuid:pk>/events', ConferenceEventsView.as_view(), name='conference-events'),
     path('conferences/<uuid:pk>/graphs', ConferenceGraphView.as_view(), name='conference-graphs'),

app/views/conference_summary_view.py

@@ -0,0 +1,95 @@
+import datetime
+from collections import defaultdict
+
+from django.core.exceptions import ValidationError
+from django.db.models import Case, CharField, Count, Exists, OuterRef, Value, When
+from django.db.models.functions import TruncDate
+
+from ..errors import INVALID_PARAMETERS, MISSING_PARAMETERS, PMError
+from ..utils import JSONHttpResponse
+from ..models.conference import Conference
+from ..models.issue import Issue
+from .generic_view import GenericView
+
+
+def _parse_iso(value):
+    # Python 3.8 fromisoformat doesn't accept the Z suffix that JS toISOString produces.
+    if value.endswith('Z'):
+        value = value[:-1] + '+00:00'
+    return datetime.datetime.fromisoformat(value)
+
+
+class ConferenceSummaryView(GenericView):
+    """
+    Returns conference counts grouped by day, with each day's conferences
+    bucketed into success/warning/error/ongoing. Replaces the pattern of
+    downloading all conferences to the browser and aggregating client-side.
+    """
+
+    @classmethod
+    def get(cls, request):
+        app_id = request.GET.get('appId')
+        if not app_id:
+            raise PMError(status=400, app_error=MISSING_PARAMETERS)
+
+        filters = {'app_id': app_id, 'is_active': True}
+
+        created_at_gte = request.GET.get('created_at_gte')
+        if created_at_gte:
+            try:
+                filters['created_at__gte'] = _parse_iso(created_at_gte)
+            except ValueError:
+                raise PMError(status=400, app_error=INVALID_PARAMETERS)
+
+        created_at_lte = request.GET.get('created_at_lte')
+        if created_at_lte:
+            try:
+                filters['created_at__lte'] = _parse_iso(created_at_lte)
+            except ValueError:
+                raise PMError(status=400, app_error=INVALID_PARAMETERS)
+
+        try:
+            rows = (Conference.objects
+                .filter(**filters)
+                .annotate(
+                    day=TruncDate('created_at'),
+                    has_error=Exists(
+                        Issue.objects.filter(conference=OuterRef('pk'), type='e', is_active=True)
+                    ),
+                    has_warning=Exists(
+                        Issue.objects.filter(conference=OuterRef('pk'), type='w', is_active=True)
+                    ),
+                )
+                .annotate(
+                    status=Case(
+                        When(ongoing=True, then=Value('ongoing')),
+                        When(has_error=True, then=Value('error')),
+                        When(has_warning=True, then=Value('warning')),
+                        default=Value('success'),
+                        output_field=CharField(),
+                    ),
+                )
+                .values('day', 'status')
+                .annotate(count=Count('id'))
+                .order_by('day'))
+        except ValidationError:
+            raise PMError(status=400, app_error=INVALID_PARAMETERS)
+
+        buckets = defaultdict(lambda: {'success': 0, 'warning': 0, 'error': 0, 'ongoing': 0})
+        for row in rows:
+            day_key = row['day'].isoformat() if row['day'] else None
+            buckets[day_key][row['status']] = row['count']
+
+        data = [
+            {
+                'date': day,
+                'success': counts['success'],
+                'warning': counts['warning'],
+                'error': counts['error'],
+                'ongoing': counts['ongoing'],
+                'total': counts['success'] + counts['warning'] + counts['error'] + counts['ongoing'],
+            }
+            for day, counts in sorted(buckets.items(), key=lambda x: x[0] or '')
+        ]
+
+        return JSONHttpResponse({'data': data})