feat(emergency): add previous data on field report and dref ops update

Author: susilnem

api/drf_views.py

@@ -1583,23 +1583,31 @@ class EmergencyViewset(
     def get_queryset(self):
         today = timezone.now().date()
 
-        active_appeal_qs = Appeal.objects.filter(
-            event=OuterRef("pk"),
-            status=AppealStatus.ACTIVE,
+        appeal_priority_qs = (
+            Appeal.objects.filter(
+                event=OuterRef("pk"),
+                status__in=[AppealStatus.ACTIVE, AppealStatus.CLOSED],
+            )
+            .annotate(
+                priority=Case(
+                    When(status=AppealStatus.ACTIVE, then=Value(1)),
+                    When(status=AppealStatus.CLOSED, then=Value(2)),
+                    output_field=IntegerField(),
+                )
+            )
+            .order_by("priority", "-start_date")
         )
 
-        active_dref_appeal_qs = active_appeal_qs.filter(
+        active_dref_appeal_qs = appeal_priority_qs.filter(
             atype=AppealType.DREF,
         )
 
-        active_emergency_appeal_qs = active_appeal_qs.filter(
+        active_emergency_appeal_qs = appeal_priority_qs.filter(
             atype=AppealType.APPEAL,
         )
 
         field_report_qs = FieldReport.objects.filter(event=OuterRef("pk"))
 
-        latest_appeal_qs = active_emergency_appeal_qs.order_by("-start_date")
-
         approved_dref_qs = Dref.objects.filter(
             event=OuterRef("pk"),
             status=Dref.Status.APPROVED,
@@ -1657,7 +1665,7 @@ def get_queryset(self):
                         then=Value(EventStage.DREF_APPLICATION),
                     ),
                     # If there is an active appeal of DREF type, but no approved DREF yet,
-                    # we consider the emergency to be in the Emergency Appeal stage.
+                    # we consider the emergency to be in the Dref Appeal only stage.
                     # Reaches here only if no approved DREF/ops-update/final-report exists
                     # So an active appeal type DREF appeal with no approved DREF = DREF_APPEAL_ONLY stage.
                     When(
@@ -1677,11 +1685,12 @@ def get_queryset(self):
                 # to avoid extra queries in serializer.
                 stage_appeal_id=Case(
                     When(
-                        stage__in=[
-                            EventStage.EMERGENCY_APPEAL,
-                            EventStage.DREF_APPEAL_ONLY,
-                        ],
-                        then=Subquery(latest_appeal_qs.values("id")[:1]),
+                        stage=EventStage.EMERGENCY_APPEAL,
+                        then=Subquery(active_emergency_appeal_qs.values("id")[:1]),
+                    ),
+                    When(
+                        stage=EventStage.DREF_APPEAL_ONLY,
+                        then=Subquery(active_dref_appeal_qs.values("id")[:1]),
                     ),
                     default=Value(None),
                     output_field=IntegerField(null=True),
@@ -1712,7 +1721,10 @@ def get_queryset(self):
                 ),
                 stage_ops_update_id=Case(
                     When(
-                        stage=EventStage.DREF_OPERATIONAL_UPDATE,
+                        stage__in=[
+                            EventStage.DREF_OPERATIONAL_UPDATE,
+                            EventStage.DREF_FINAL_REPORT,
+                        ],
                         then=Subquery(
                             DrefOperationalUpdate.objects.filter(
                                 dref__id=OuterRef("stage_dref_id"), status=Dref.Status.APPROVED

api/migrations/0232_remove_event_auto_generated_source_event_source_and_more.py

@@ -46,7 +46,7 @@ def migrate_sources(apps, _):
                 source = 160 # NEW_FIELD_REPORT
             else:
                 # Using title for backward compatibility, as some events have auto_generated_source empty but title containing "GDACS"
-                if obj.title and obj.title.lower().startswith("gdacs"):
+                if obj.name and obj.name.lower().startswith("gdacs"):
                     source = 110  # GDACS
                 else:
                     source = 100  # MANUAL_INPUT

api/serializers.py

@@ -2142,6 +2142,22 @@ class Meta:
 
 # NOTE: Using this specific serializer for emergency page schema
 # Contains information from latest field report mostly and some fields from first field report
+class EmergencyPreviousFieldReportSerializer(
+    serializers.ModelSerializer,
+):
+    class Meta:
+        model = FieldReport
+        fields = (
+            "id",
+            "event_id",
+            "fr_num",
+            "start_date",
+            "report_date",
+            "created_at",
+            "updated_at",
+        )
+
+
 class EmergencyFieldReportSerializer(
     serializers.ModelSerializer,
 ):
@@ -2783,6 +2799,17 @@ class Meta:
         fields = "__all__"
 
 
+class TimelineEmergencyFieldReportSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = FieldReport
+        fields = (
+            "id",
+            "report_date",
+            "fr_num",
+            "start_date",
+        )
+
+
 class DetailEmergencySerializer(ModelSerializer):
     from dref.serializers import EmergencyDrefSerializer
 
@@ -2815,6 +2842,8 @@ class DetailEmergencySerializer(ModelSerializer):
     first_field_report_created_at = serializers.DateTimeField(read_only=True)
     latest_field_report_created_at = serializers.DateTimeField(read_only=True)
 
+    timeline_field_reports = serializers.SerializerMethodField()
+
     class Meta:
         model = Event
         fields = (
@@ -2868,15 +2897,29 @@ class Meta:
             "dref",
             "first_field_report_created_at",
             "latest_field_report_created_at",
+            "timeline_field_reports",
         )
 
-    def _get_stage_instance(self, event):
-        if hasattr(self, "_stage_instance_cache"):
-            return self._stage_instance_cache
+    @extend_schema_field(TimelineEmergencyFieldReportSerializer(many=True))
+    def get_timeline_field_reports(self, event):
+        field_reports = (
+            FieldReport.objects.filter(event=event)
+            .order_by(
+                "-updated_at",
+                "-fr_num",
+            )
+            .values(
+                "id",
+                "report_date",
+                "fr_num",
+                "start_date",
+            )
+        )
+        serializer = TimelineEmergencyFieldReportSerializer(field_reports, many=True)
+        return serializer.data
 
+    def _get_stage_instance(self, event):
         stage = getattr(event, "stage")
-        instance = None
-
         if stage == EventStage.FIELD_REPORT and event.stage_field_report_id:
             _first_field_report_queryset = FieldReport.objects.filter(event_id=OuterRef("event_id")).order_by(
                 "created_at", "fr_num"
@@ -2891,16 +2934,17 @@ def _get_stage_instance(self, event):
                     first_fr_request_assistance=Subquery(_first_field_report_queryset.values("request_assistance")[:1]),
                 )
                 .prefetch_related(
-                    Prefetch("countries", queryset=Country.objects.select_related("region")),
-                    Prefetch("districts", queryset=District.objects.select_related("country")),
+                    "contacts",
+                    "countries",
+                    "districts",
                     Prefetch(
                         "actions_taken",
                         queryset=ActionsTaken.objects.prefetch_related("actions"),
                     ),
-                    "contacts",
                 )
                 .get(pk=event.stage_field_report_id)
             )
+            return instance
 
         elif (
             stage
@@ -2911,6 +2955,7 @@ def _get_stage_instance(self, event):
             and event.stage_appeal_id
         ):
             instance = Appeal.objects.get(pk=event.stage_appeal_id)
+            return instance
         elif (
             stage
             in [
@@ -2938,7 +2983,7 @@ def _get_stage_instance(self, event):
                     ),
                 )
                 .prefetch_related(
-                    Prefetch("district", queryset=District.objects.select_related("country")),
+                    "district",
                     Prefetch(
                         "planned_interventions",
                         queryset=PlannedIntervention.objects.prefetch_related("indicators"),
@@ -2950,8 +2995,7 @@ def _get_stage_instance(self, event):
                 )
                 .get(pk=event.stage_dref_id)
             )
-        self._stage_instance_cache = instance
-        return instance
+            return instance
 
     def get_stage_display(self, event):
         stage = getattr(event, "stage", None)

api/test_views.py

@@ -1340,13 +1340,31 @@ def test_inactive_appeal_does_not_trigger_emergency_appeal_stage(self):
         AppealFactory.create(
             event=event,
             dtype=self.disaster_type,
-            status=AppealStatus.CLOSED,
+            status=AppealStatus.ARCHIVED,
             atype=AppealType.APPEAL,
         )
 
         data = self._get(event).data
         self.assertNotEqual(data["stage"], EventStage.EMERGENCY_APPEAL)
 
+        # CLOSED one also considered but ACTIVE takes over
+        AppealFactory.create(
+            event=event,
+            dtype=self.disaster_type,
+            status=AppealStatus.CLOSED,
+            atype=AppealType.APPEAL,
+        )
+        data = self._get(event).data
+        self.assertEqual(data["stage"], EventStage.EMERGENCY_APPEAL)
+        self.assertEqual(data["appeal"]["status"], AppealStatus.CLOSED)
+
+        self._active_emergency_appeal(event)
+        data = self._get(event).data
+        self.assertEqual(data["stage"], EventStage.EMERGENCY_APPEAL)
+
+        # Active should take priority over closed and archived
+        self.assertEqual(data["appeal"]["status"], AppealStatus.ACTIVE)
+
     def test_emergency_appeal_takes_priority_over_entire_dref_chain(self):
         event = EventFactory.create(dtype=self.disaster_type)
         dref = self._approved_dref(event)
@@ -1466,3 +1484,47 @@ def fallback_to_dref_appeal_for_no_approved_dref(self):
 
         self.assertEqual(parse_datetime(data["first_field_report_created_at"]), first_fr.created_at)
         self.assertEqual(parse_datetime(data["latest_field_report_created_at"]), latest_fr.created_at)
+
+    def test_field_report_with_timeline_field_reports(self):
+        event = EventFactory.create(dtype=self.disaster_type)
+        FieldReportFactory.create_batch(
+            3,
+            event=event,
+            dtype=self.disaster_type,
+        )
+        data = self._get(event).data
+        self.assertEqual(data["stage"], EventStage.FIELD_REPORT, data)
+        self.assertIsNotNone(data["field_report"], data)
+        self.assertEqual(len(data["timeline_field_reports"]), 3)
+
+    def test_dref_operational_update_with_timeline_ops_updates(self):
+        event = EventFactory.create(dtype=self.disaster_type)
+        dref = self._approved_dref(event)
+        DrefOperationalUpdateFactory.create_batch(
+            3,
+            dref=dref,
+            status=Dref.Status.APPROVED,
+            disaster_type=self.disaster_type,
+            country=self.country,
+        )
+        data = self._get(event).data
+        self.assertEqual(data["stage"], EventStage.DREF_OPERATIONAL_UPDATE, data)
+
+        dref_data = data.get("dref")
+        self.assertIsNotNone(dref_data, data)
+
+        self.assertEqual(len(dref_data["timeline_operational_updates"]), 3)
+
+        # NOTE: if Final report is created, stage should be DREF_FINAL_REPORT and previous operational updates should also show
+        DrefFinalReportFactory.create(
+            dref=dref,
+            status=Dref.Status.APPROVED,
+            disaster_type=self.disaster_type,
+            country=self.country,
+        )
+        data = self._get(event).data
+        self.assertEqual(data["stage"], EventStage.DREF_FINAL_REPORT)
+        dref_data = data.get("dref")
+        self.assertIsNotNone(dref_data)
+        self.assertIsNotNone(dref_data["final_report_details"])
+        self.assertEqual(len(dref_data["timeline_operational_updates"]), 3)