ELI-615 | wip

Author: Karthikeyannhs

src/eligibility_signposting_api/services/calculators/eligibility_calculator.py

@@ -81,16 +81,18 @@ def get_the_best_cohort_memberships(
 
         return best_status, best_cohorts
 
-    def get_eligibility_status(self, include_actions: str, conditions: list[str], requested_category: str) -> EligibilityStatus:
+    def get_eligibility_status(
+        self, include_actions: str, conditions: list[str], requested_category: str
+    ) -> EligibilityStatus:
         include_actions_flag = include_actions.upper() == "Y"
         condition_results: dict[ConditionName, IterationResult] = {}
         final_result = []
 
         requested_grouped_campaigns = self.campaign_evaluator.get_campaign_with_latest_active_iteration_per_target(
             self.campaign_configs, conditions, requested_category
         )
-        for condition_name, campaign_group in requested_grouped_campaigns:
-            best_iteration_result = self.get_best_iteration_result(campaign_group)
+        for condition_name, campaign in requested_grouped_campaigns:
+            best_iteration_result = self.get_best_iteration_result(campaign)
 
             if best_iteration_result is None:
                 continue
@@ -123,23 +125,8 @@ def get_eligibility_status(self, include_actions: str, conditions: list[str], re
         # Consolidate all the results and return
         return eligibility_status.EligibilityStatus(conditions=final_result)
 
-    def get_best_iteration_result(self, campaign_group: list[CampaignConfig]) -> BestIterationResult | None:
-        iteration_results = self.get_iteration_results(campaign_group)
 
-        if not iteration_results:
-            return None
-
-        (_best_iteration_name, best_iteration_result) = max(
-            iteration_results.items(),
-            key=lambda item: next(iter(item[1].cohort_results.values())).status.value
-            # Below handles the case where there are no cohort results
-            if item[1].cohort_results
-            else -1,
-        )
-
-        return best_iteration_result
-
-    def get_iteration_results(self, campaign_group: list[CampaignConfig]) -> dict[IterationName, BestIterationResult]:
+    def get_iteration_results(self, campaign_group: CampaignConfig) -> dict[IterationName, BestIterationResult]:
         iteration_results: dict[IterationName, BestIterationResult] = {}
 
         for cc in campaign_group:

src/eligibility_signposting_api/services/processors/campaign_evaluator.py

@@ -15,22 +15,35 @@ class CampaignEvaluator:
     def get_active_campaigns(self, campaign_configs: Collection[CampaignConfig]) -> list[CampaignConfig]:
         return [cc for cc in campaign_configs if cc.campaign_live]
 
-    def get_latest_campaign(self, campaign_group: list[CampaignConfig]):
-        if not campaign_group:
-            return None
+    def get_campaign_with_latest_iteration(self, active_campaigns: list[CampaignConfig]) -> CampaignConfig:
+
+        """
+            Returns the campaign with the latest active iteration date.
 
-        latest_date = max(c.start_date for c in campaign_group)
+            1. Collect all campaigns with an active iteration.
+            2. Sort by iteration date (descending).
+            3. Extract the lead campaign, throwing an error if a tie for the latest date exists.
+        """
+
+        if not active_campaigns:
+            return None
 
-        latest = [c for c in campaign_group if c.start_date == latest_date]
+        valid_items = [
+            (cc.current_iteration.iteration_date, cc)
+            for cc in active_campaigns if cc.current_iteration
+        ]
 
-        if len(latest) == 1:
-            return latest[0]
+        if not valid_items:
+            latest_date, latest_campaign = None, None
+        else:
+            max_date = max(item[0] for item in valid_items)
+            cc_with_max_iteration_date = [item for item in valid_items if item[0] == max_date]
+            if len(cc_with_max_iteration_date) > 1:
+                raise ValueError(f"Ambiguous result: {len(cc_with_max_iteration_date)} campaigns found for date {max_date}")
 
-        if len(latest) > 1:
-            raise ValueError(
-                f"Multiple campaigns share the latest start_date: {latest_date}")  # TODO handle it in FHIR format
+            latest_date, latest_campaign = cc_with_max_iteration_date[0]
 
-        return None
+        return latest_campaign
 
     def get_campaign_with_latest_active_iteration_per_target(
         self, campaign_configs: Collection[CampaignConfig], conditions: list[str], requested_category: str
@@ -52,6 +65,6 @@ def get_campaign_with_latest_active_iteration_per_target(
             sorted(active_campaigns, key=attrgetter("target")),
             key=attrgetter("target"),
         ):
-            campaigns = [c for c in allowed_campaigns if filter_all_conditions or str(condition_name) in conditions]
+            filtered_campaigns = [c for c in allowed_campaigns if filter_all_conditions or str(condition_name) in conditions]
 
-            yield condition_name, self.get_latest_campaign(campaigns)
+            yield condition_name, self.get_campaign_with_latest_iteration(filtered_campaigns)

tests/unit/services/processors/test_campaign_evaluator.py

@@ -33,7 +33,9 @@ def test_campaigns_grouped_by_condition_name_filters_correctly(  # noqa: PLR0913
 ):
     campaign = rule.CampaignConfigFactory.build(target=campaign_target, type=campaign_type)
 
-    result = campaign_evaluator.get_campaign_with_latest_active_iteration_per_target([campaign], conditions_filter, category_filter)
+    result = campaign_evaluator.get_campaign_with_latest_active_iteration_per_target(
+        [campaign], conditions_filter, category_filter
+    )
     assert_that([(str(name), group[0].type) for name, group in result], is_(expected_result))
 
 
@@ -47,7 +49,9 @@ def test_campaigns_grouped_by_condition_name_with_no_active_campaigns(campaign_e
         target="RSV", type="V", start_date=datetime.date(2025, 4, 20), end_date=datetime.date(2025, 4, 21)
     )
 
-    result = campaign_evaluator.get_campaign_with_latest_active_iteration_per_target([campaign], ["RSV"], "VACCINATIONS")
+    result = campaign_evaluator.get_campaign_with_latest_active_iteration_per_target(
+        [campaign], ["RSV"], "VACCINATIONS"
+    )
     assert_that(list(result), is_([]))
 
 
@@ -63,7 +67,9 @@ def test_campaigns_grouped_by_condition_name_with_various_categories(
     campaign_evaluator, category_filter, campaign_type, expected_count
 ):
     campaign = rule.CampaignConfigFactory.build(target="COVID", type=campaign_type)
-    result = list(campaign_evaluator.get_campaign_with_latest_active_iteration_per_target([campaign], ["COVID"], category_filter))
+    result = list(
+        campaign_evaluator.get_campaign_with_latest_active_iteration_per_target([campaign], ["COVID"], category_filter)
+    )
     assert_that(len(result), is_(expected_count))
     if expected_count > 0:
         assert_that(str(result[0][0]), is_("COVID"))
@@ -84,7 +90,11 @@ def test_campaigns_grouped_by_condition_name_groups_multiple_campaigns_for_same_
     )
 
     all_campaigns = [campaign1, campaign2, campaign3, inactive_campaign]
-    result = list(campaign_evaluator.get_campaign_with_latest_active_iteration_per_target(all_campaigns, ["COVID", "FLU"], "VACCINATIONS"))
+    result = list(
+        campaign_evaluator.get_campaign_with_latest_active_iteration_per_target(
+            all_campaigns, ["COVID", "FLU"], "VACCINATIONS"
+        )
+    )
 
     assert_that(len(result), is_(2))
 
@@ -105,13 +115,17 @@ def test_campaign_grouping_is_affected_by_order_for_mixed_types(campaign_evaluat
 
     evaluator_s_first = campaign_evaluator
     result_s_first = list(
-        evaluator_s_first.get_campaign_with_latest_active_iteration_per_target([campaign_s, campaign_v], ["RSV"], "VACCINATIONS")
+        evaluator_s_first.get_campaign_with_latest_active_iteration_per_target(
+            [campaign_s, campaign_v], ["RSV"], "VACCINATIONS"
+        )
     )
     assert_that(result_s_first, is_([]))
 
     evaluator_v_first = campaign_evaluator
     result_v_first = list(
-        evaluator_v_first.get_campaign_with_latest_active_iteration_per_target([campaign_v, campaign_s], ["RSV"], "VACCINATIONS")
+        evaluator_v_first.get_campaign_with_latest_active_iteration_per_target(
+            [campaign_v, campaign_s], ["RSV"], "VACCINATIONS"
+        )
     )
     assert_that(len(result_v_first), is_(1))
     assert_that(len(result_v_first[0][1]), is_(2))