ELI-615 | wip

Author: Karthikeyannhs

src/eligibility_signposting_api/services/calculators/eligibility_calculator.py

@@ -81,13 +81,13 @@ def get_the_best_cohort_memberships(
 
         return best_status, best_cohorts
 
-    def get_eligibility_status(self, include_actions: str, conditions: list[str], 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_requested_grouped_campaigns(
-            self.campaign_configs, conditions, category
+        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)

src/eligibility_signposting_api/services/processors/campaign_evaluator.py

@@ -15,29 +15,43 @@ 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_requested_grouped_campaigns(
-        self, campaign_configs: Collection[CampaignConfig], conditions: list[str], category: str
-    ) -> Iterator[tuple[eligibility_status.ConditionName, list[CampaignConfig]]]:
+    def get_latest_campaign(self, campaign_group: list[CampaignConfig]):
+        if not campaign_group:
+            return None
+
+        latest_date = max(c.start_date for c in campaign_group)
+
+        latest = [c for c in campaign_group if c.start_date == latest_date]
+
+        if len(latest) == 1:
+            return latest[0]
+
+        if len(latest) > 1:
+            raise ValueError(
+                f"Multiple campaigns share the latest start_date: {latest_date}")  # TODO handle it in FHIR format
+
+        return None
+
+    def get_campaign_with_latest_active_iteration_per_target(
+        self, campaign_configs: Collection[CampaignConfig], conditions: list[str], requested_category: str
+    ) -> Iterator[tuple[eligibility_status.ConditionName, CampaignConfig]]:
         mapping = {
             "ALL": {"V", "S"},
             "VACCINATIONS": {"V"},
             "SCREENING": {"S"},
         }
 
-        allowed_types = mapping.get(category, set())
+        allowed_types = mapping.get(requested_category, set())
 
         filter_all_conditions = "ALL" in conditions
 
-        active_campaigns = self.get_active_campaigns(campaign_configs)
+        allowed_campaigns = [c for c in campaign_configs if c.type in allowed_types]
+        active_campaigns = self.get_active_campaigns(allowed_campaigns)
 
         for condition_name, campaign_group in groupby(
             sorted(active_campaigns, key=attrgetter("target")),
             key=attrgetter("target"),
         ):
-            campaigns = list(campaign_group)
-            if (
-                campaigns
-                and campaigns[0].type in allowed_types
-                and (filter_all_conditions or str(condition_name) in conditions)
-            ):
-                yield condition_name, campaigns
+            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)

tests/unit/services/processors/test_campaign_evaluator.py

@@ -33,12 +33,12 @@ 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_requested_grouped_campaigns([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))
 
 
 def test_campaigns_grouped_by_condition_name_with_no_campaigns(campaign_evaluator):
-    result = campaign_evaluator.get_requested_grouped_campaigns([], ["RSV"], "VACCINATIONS")
+    result = campaign_evaluator.get_campaign_with_latest_active_iteration_per_target([], ["RSV"], "VACCINATIONS")
     assert_that(list(result), is_([]))
 
 
@@ -47,7 +47,7 @@ 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_requested_grouped_campaigns([campaign], ["RSV"], "VACCINATIONS")
+    result = campaign_evaluator.get_campaign_with_latest_active_iteration_per_target([campaign], ["RSV"], "VACCINATIONS")
     assert_that(list(result), is_([]))
 
 
@@ -63,15 +63,15 @@ 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_requested_grouped_campaigns([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"))
 
 
 def test_campaigns_grouped_by_condition_name_with_empty_conditions_filter(campaign_evaluator):
     campaign = rule.CampaignConfigFactory.build(target="RSV", type="V")
-    result = campaign_evaluator.get_requested_grouped_campaigns([campaign], [], "VACCINATIONS")
+    result = campaign_evaluator.get_campaign_with_latest_active_iteration_per_target([campaign], [], "VACCINATIONS")
     assert_that(list(result), is_([]))
 
 
@@ -84,7 +84,7 @@ def test_campaigns_grouped_by_condition_name_groups_multiple_campaigns_for_same_
     )
 
     all_campaigns = [campaign1, campaign2, campaign3, inactive_campaign]
-    result = list(campaign_evaluator.get_requested_grouped_campaigns(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 +105,13 @@ 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_requested_grouped_campaigns([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_requested_grouped_campaigns([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))