wip

Author: Karthikeyannhs

src/eligibility_signposting_api/services/calculators/eligibility_calculator.py

@@ -4,6 +4,7 @@
 from collections import defaultdict
 from collections.abc import Collection, Iterator, Mapping
 from dataclasses import dataclass, field
+from functools import cached_property
 from itertools import groupby
 from typing import Any
 
@@ -45,6 +46,13 @@ def campaigns_grouped_by_condition_name(
         ):
             yield condition_name, list(campaign_group)
 
+    @cached_property
+    def person_cohorts(self)-> set[str]:
+        cohorts_row: Mapping[str, dict[str, dict[str, dict[str, Any]]]] = next(
+            (row for row in self.person_data if row.get("ATTRIBUTE_TYPE") == "COHORTS"), {}
+        )
+        return set(cohorts_row.get("COHORT_MAP", {}).get("cohorts", {}).get("M", {}).keys())
+
     def evaluate_eligibility(self) -> eligibility.EligibilityStatus:
         """Iterates over campaign groups, evaluates eligibility, and returns a consolidated status."""
 
@@ -78,12 +86,7 @@ def check_base_eligibility(self, iteration: rules.Iteration) -> bool:
         }
         if magic_cohort in iteration_cohorts:
             return True
-
-        cohorts_row: Mapping[str, dict[str, dict[str, dict[str, Any]]]] = next(
-            (row for row in self.person_data if row.get("ATTRIBUTE_TYPE") == "COHORTS"), {}
-        )
-        person_cohorts: set[str] = set(cohorts_row.get("COHORT_MAP", {}).get("cohorts", {}).get("M", {}).keys())
-        return bool(iteration_cohorts & person_cohorts)
+        return bool(iteration_cohorts & self.person_cohorts)
 
     def evaluate_eligibility_by_iteration_rules(
         self, campaign_group: list[rules.CampaignConfig]
@@ -123,8 +126,12 @@ def evaluate_priority_group(
         worst_status_so_far_for_condition: eligibility.Status,
     ) -> tuple[eligibility.Status, list[eligibility.Reason], list[eligibility.Reason]]:
         exclusion_reasons, actionable_reasons = [], []
+
+
         exclude_capable_rules = [
-            ir for ir in iteration_rule_group if ir.type in (rules.RuleType.filter, rules.RuleType.suppression)
+            ir for ir in iteration_rule_group
+            if ir.type in (rules.RuleType.filter, rules.RuleType.suppression)
+               and (ir.cohort_label is None or ir.cohort_label in self.person_cohorts)
         ]
 
         best_status = eligibility.Status.not_eligible if exclude_capable_rules else eligibility.Status.actionable

tests/fixtures/builders/model/rule.py

@@ -75,6 +75,7 @@ class PersonAgeSuppressionRuleFactory(IterationRuleFactory):
     attribute_level = rules.RuleAttributeLevel.PERSON
     attribute_name = rules.RuleAttributeName("DATE_OF_BIRTH")
     comparator = rules.RuleComparator("-75")
+    cohort_label = None
 
 
 class PostcodeSuppressionRuleFactory(IterationRuleFactory):

tests/unit/services/calculators/test_eligibility_calculator.py

@@ -718,3 +718,45 @@ def test_not_actionable_status_on_target_when_last_successful_date_lte_today(
         ),
         test_comment,
     )
+
+
+@pytest.mark.parametrize(
+    ("cohort", "expected_status", "test_comment"),
+    [
+        ("cohort1", Status.not_actionable, "matches the cohort label"),
+        ("cohort2", Status.actionable, "matches the cohort label"),
+    ],
+)
+def test_status_if_iteration_rules_contains_cohort_label(cohort:str, expected_status: Status, test_comment: str, faker: Faker):
+    # Given
+    nhs_number = NHSNumber(faker.nhs_number())
+    date_of_birth = DateOfBirth(faker.date_of_birth(minimum_age=66, maximum_age=74))
+
+    person_rows = person_rows_builder(nhs_number, date_of_birth=date_of_birth, cohorts=["cohort1"])
+    campaign_configs = [
+        rule_builder.CampaignConfigFactory.build(
+            target="RSV",
+            iterations=[
+                rule_builder.IterationFactory.build(
+                    iteration_cohorts=[rule_builder.IterationCohortFactory.build(cohort_label="cohort1"),
+                                       rule_builder.IterationCohortFactory.build(cohort_label="cohort2")],
+                    iteration_rules=[rule_builder.PersonAgeSuppressionRuleFactory.build(cohort_label=cohort)],
+                )
+            ],
+        )
+    ]
+
+    calculator = EligibilityCalculator(person_rows, campaign_configs)
+
+    # When
+    actual = calculator.evaluate_eligibility()
+
+    # Then
+    assert_that(
+        actual,
+        is_eligibility_status().with_conditions(
+            has_items(
+                is_condition().with_condition_name(ConditionName("RSV")).and_status(expected_status)
+            )
+        ),
+    )