fix: address PR review — sparkline order, periodic_task 500, N+1 queries, imports

- Sparkline: fetch newest 10 runs (order_by -end_time) then reverse for chart
- Fix HTTP 500 for unscheduled jobs: use captured `periodic` variable
  instead of re-accessing task.periodic_task in response dict
- Batch user queries: single User.objects.filter(id__in=...) instead of
  per-row User.objects.get() in get_triggered_by
- Use Window(RowNumber) for run_number instead of loading all run IDs
- Deduplicate parse_datetime import — moved to top-level

Author: wicky-zipstack

backend/backend/core/scheduler/serializer.py

@@ -1,4 +1,6 @@
 from django.contrib.auth import get_user_model
+from django.db.models import Window, F
+from django.db.models.functions import RowNumber
 from rest_framework import serializers
 
 from backend.core.scheduler.models import TaskRunHistory
@@ -19,6 +21,21 @@ class Meta:
         model = TaskRunHistory
         fields = "__all__"
 
+    def _get_user_cache(self):
+        """Batch-load users for all runs in one query, cached per serializer instance."""
+        if not hasattr(self, "_user_cache"):
+            user_ids = set()
+            for obj in self.instance if hasattr(self.instance, '__iter__') else [self.instance]:
+                if obj and obj.kwargs and obj.kwargs.get("user_id"):
+                    user_ids.add(obj.kwargs["user_id"])
+            if user_ids:
+                self._user_cache = {
+                    str(u.id): u for u in User.objects.filter(id__in=user_ids)
+                }
+            else:
+                self._user_cache = {}
+        return self._user_cache
+
     def get_duration(self, obj):
         """Human-readable duration string."""
         if obj.start_time and obj.end_time:
@@ -46,32 +63,34 @@ def get_run_number(self, obj):
             self._run_number_cache = {}
         task_detail_id = obj.user_task_detail_id
         if task_detail_id not in self._run_number_cache:
-            # Get all run IDs for this job ordered by start_time ASC
-            run_ids = list(
+            annotated = (
                 TaskRunHistory.objects.filter(user_task_detail_id=task_detail_id)
-                .order_by("start_time")
-                .values_list("id", flat=True)
+                .annotate(
+                    row_num=Window(
+                        expression=RowNumber(),
+                        order_by=F("start_time").asc(),
+                    )
+                )
+                .values_list("id", "row_num")
             )
-            self._run_number_cache[task_detail_id] = {
-                rid: idx + 1 for idx, rid in enumerate(run_ids)
-            }
+            self._run_number_cache[task_detail_id] = dict(annotated)
         return self._run_number_cache[task_detail_id].get(obj.id, 0)
 
     def get_triggered_by(self, obj):
-        """Resolve user_id from kwargs to username."""
+        """Resolve user_id from kwargs to username using batch-loaded cache."""
         if not obj.kwargs:
             return None
         user_id = obj.kwargs.get("user_id")
         if not user_id:
             return None
-        try:
-            user = User.objects.get(id=user_id)
+        cache = self._get_user_cache()
+        user = cache.get(str(user_id))
+        if user:
             return {
                 "id": str(user.id),
                 "username": user.get_full_name() or user.username or user.email,
             }
-        except (User.DoesNotExist, ValueError):
-            return {"id": str(user_id), "username": str(user_id)}
+        return {"id": str(user_id), "username": str(user_id)}
 
     def get_model_count(self, obj):
         """Total model count from result."""

backend/backend/core/scheduler/views.py

@@ -4,6 +4,7 @@
 from datetime import timedelta
 
 from django.utils import timezone
+from django.utils.dateparse import parse_datetime
 from django_celery_beat.models import CrontabSchedule, IntervalSchedule, PeriodicTask
 from rest_framework import status
 from rest_framework.decorators import api_view, permission_classes
@@ -632,16 +633,18 @@ def run_stats(request, project_id, user_task_id):
             expected_duration_ms = int(sum(durations) / len(durations))
 
         # Duration trend (last 10 completed runs for sparkline)
-        recent_runs = runs.filter(
+        recent_runs = list(runs.filter(
             start_time__isnull=False, end_time__isnull=False
-        ).order_by("end_time")[:10]
+        ).order_by("-end_time")[:10])
+        recent_runs.reverse()  # chronological order for sparkline
         duration_trend = [
             int((r.end_time - r.start_time).total_seconds() * 1000) for r in recent_runs
         ]
 
         # Schedule info
         schedule_type = None
         schedule_label = None
+        periodic = None
         try:
             periodic = task.periodic_task
             if periodic:
@@ -653,7 +656,7 @@ def run_stats(request, project_id, user_task_id):
                     schedule_type = "interval"
                     schedule_label = f"Every {periodic.interval.every} {periodic.interval.period}"
         except Exception:
-            pass
+            periodic = None
 
         return Response({
             "success": True,
@@ -676,7 +679,7 @@ def run_stats(request, project_id, user_task_id):
                 },
                 "schedule_type": schedule_type,
                 "schedule_label": schedule_label,
-                "schedule_enabled": task.periodic_task.enabled if task.periodic_task else False,
+                "schedule_enabled": periodic.enabled if periodic else False,
             },
         }, status=status.HTTP_200_OK)
     except UserTaskDetails.DoesNotExist:
@@ -714,13 +717,11 @@ def task_run_history(request, project_id, user_task_id):
         if status_filter:
             runs = runs.filter(status=status_filter)
         if date_from:
-            from django.utils.dateparse import parse_datetime
             dt = parse_datetime(date_from)
             if dt:
                 runs = runs.filter(start_time__gte=dt)
         if date_to:
-            from django.utils.dateparse import parse_datetime as parse_dt
-            dt = parse_dt(date_to)
+            dt = parse_datetime(date_to)
             if dt:
                 runs = runs.filter(start_time__lte=dt)
         if search: