Feature/eli 295 generic text for not eligible xrules

src/eligibility_signposting_api/audit/audit_context.py

@@ -63,10 +63,10 @@ def append_audit_condition(
         condition_name: ConditionName,
         best_results: tuple[Iteration | None, IterationResult | None, dict[str, CohortGroupResult] | None],
         campaign_details: tuple[CampaignID | None, CampaignVersion | None],
-        redirect_rule_details: tuple[RulePriority | None, RuleName | None],
+        action_rule_details: tuple[RulePriority | None, RuleName | None],
     ) -> None:
-        audit_eligibility_cohorts, audit_eligibility_cohort_groups = [], []
-        audit_filter_rule, audit_suitability_rule = None, None
+        audit_eligibility_cohorts, audit_eligibility_cohort_groups, audit_actions = [], [], []
+        audit_filter_rule, audit_suitability_rule, audit_action_rule = None, None, None
         best_active_iteration = best_results[0]
         best_candidate = best_results[1]
         best_cohort_results = best_results[2]
@@ -88,7 +88,7 @@ def append_audit_condition(
                     audit_filter_rule = AuditContext.create_audit_filter_rule(best_candidate, result)
                     audit_suitability_rule = AuditContext.create_audit_suitability_rule(best_candidate, result)
 
-        audit_redirect_rule = AuditContext.get_audit_redirect_rule(best_candidate, redirect_rule_details)
+        audit_action_rule = AuditContext.add_rule_name_and_priority_to_audit(best_candidate, action_rule_details)
 
         audit_actions = AuditContext.create_audit_actions(suggested_actions)
 
@@ -104,22 +104,26 @@ def append_audit_condition(
             eligibility_cohort_groups=audit_eligibility_cohort_groups,
             filter_rules=audit_filter_rule,
             suitability_rules=audit_suitability_rule,
-            action_rule=audit_redirect_rule,
+            action_rule=audit_action_rule,
             actions=audit_actions,
         )
 
         g.audit_log.response.condition.append(audit_condition)
 
     @staticmethod
-    def get_audit_redirect_rule(
-        best_candidate: IterationResult | None, redirect_rule_details: tuple[RulePriority | None, RuleName | None]
+    def add_rule_name_and_priority_to_audit(
+        best_candidate: IterationResult | None,
+        action_rule_details: tuple[RulePriority | None, RuleName | None] | None,
     ) -> AuditRedirectRule | None:
-        audit_redirect_rule = None
-        if best_candidate and best_candidate.status and best_candidate.status.name == Status.actionable.name:
-            audit_redirect_rule = AuditRedirectRule(
-                rule_priority=str(redirect_rule_details[0]), rule_name=redirect_rule_details[1]
-            )
-        return audit_redirect_rule
+        audit_action_rule = None
+        if best_candidate and best_candidate.status:
+            if action_rule_details is None or (action_rule_details[0] is None and action_rule_details[1] is None):
+                audit_action_rule = None
+            else:
+                audit_action_rule = AuditRedirectRule(
+                    rule_priority=str(action_rule_details[0]), rule_name=action_rule_details[1]
+                )
+        return audit_action_rule
 
     @staticmethod
     def add_response_details(response_id: UUID, last_updated: datetime) -> None:

src/eligibility_signposting_api/model/eligibility.py

@@ -31,6 +31,8 @@ class RuleType(StrEnum):
     filter = "F"
     suppression = "S"
     redirect = "R"
+    not_eligible_actions = "X"
+    not_actionable_actions = "Y"
 
 
 @total_ordering

src/eligibility_signposting_api/model/rules.py

@@ -42,6 +42,8 @@ class RuleType(StrEnum):
     filter = "F"
     suppression = "S"
     redirect = "R"
+    not_eligible_actions = "X"
+    not_actionable_actions = "Y"
 
 
 class RuleOperator(StrEnum):
@@ -153,6 +155,8 @@ class Iteration(BaseModel):
     approval_maximum: int | None = Field(None, alias="ApprovalMaximum")
     type: Literal["A", "M", "S", "O"] = Field(..., alias="Type")
     default_comms_routing: str = Field(..., alias="DefaultCommsRouting")
+    default_not_eligible_routing: str = Field(..., alias="DefaultNotEligibleRouting")
+    default_not_actionable_routing: str = Field(..., alias="DefaultNotActionableRouting")
     iteration_cohorts: list[IterationCohort] = Field(..., alias="IterationCohorts")
     iteration_rules: list[IterationRule] = Field(..., alias="IterationRules")
     actions_mapper: ActionsMapper = Field(..., alias="ActionsMapper")

src/eligibility_signposting_api/services/calculators/eligibility_calculator.py

@@ -19,6 +19,7 @@
         IterationCohort,
         RuleName,
         RulePriority,
+        RuleType,
     )
 
 from wireup import service
@@ -140,23 +141,28 @@ def get_rules_by_type(
         return filter_rules, suppression_rules
 
     @staticmethod
-    def get_redirect_rules(
-        active_iteration: Iteration,
-    ) -> tuple[tuple[rules.IterationRule, ...], ActionsMapper, str]:
-        redirect_rules = tuple(
-            rule for rule in active_iteration.iteration_rules if rule.type in rules.RuleType.redirect
-        )
-        default_comms = active_iteration.default_comms_routing
+    def get_action_rules_components(
+        active_iteration: Iteration, rule_type: RuleType
+    ) -> tuple[tuple[rules.IterationRule, ...], ActionsMapper, str | None]:
+        action_rules = tuple(rule for rule in active_iteration.iteration_rules if rule.type in rule_type)
+
+        routing_map = {
+            rules.RuleType.redirect: active_iteration.default_comms_routing,
+            rules.RuleType.not_eligible_actions: active_iteration.default_not_eligible_routing,
+            rules.RuleType.not_actionable_actions: active_iteration.default_not_actionable_routing,
+        }
+
+        default_comms = routing_map.get(rule_type)
         action_mapper = active_iteration.actions_mapper
-        return redirect_rules, action_mapper, default_comms
+        return action_rules, action_mapper, default_comms
 
     def evaluate_eligibility(
         self, include_actions: str, conditions: list[str], category: str
     ) -> eligibility.EligibilityStatus:
         include_actions_flag = include_actions.upper() == "Y"
         condition_results: dict[ConditionName, IterationResult] = {}
         actions: list[SuggestedAction] | None = []
-        redirect_rule_priority, redirect_rule_name = None, None
+        action_rule_priority, action_rule_name = None, None
 
         for condition_name, campaign_group in self.campaigns_grouped_by_condition_name(conditions, category):
             best_active_iteration: Iteration | None
@@ -188,16 +194,26 @@ def evaluate_eligibility(
 
             condition_results[condition_name] = best_candidate
 
-            if best_candidate.status == Status.actionable and best_active_iteration is not None:
+            status_to_rule_type = {
+                Status.actionable: rules.RuleType.redirect,
+                Status.not_eligible: rules.RuleType.not_eligible_actions,
+                Status.not_actionable: rules.RuleType.not_actionable_actions,
+            }
+
+            if best_candidate.status in status_to_rule_type and best_active_iteration is not None:
                 if include_actions_flag:
-                    actions, matched_r_rule_priority, matched_r_rule_name = self.handle_redirect_rules(
-                        best_active_iteration
+                    rule_type = status_to_rule_type[best_candidate.status]
+                    actions, matched_action_rule_priority, matched_action_rule_name = self.handle_action_rules(
+                        best_active_iteration, rule_type
                     )
-                    redirect_rule_name = matched_r_rule_name
-                    redirect_rule_priority = matched_r_rule_priority
+                    action_rule_name = matched_action_rule_name
+                    action_rule_priority = matched_action_rule_priority
                 else:
                     actions = None
 
+            else:
+                actions = None
+
             if best_candidate.status in (Status.not_eligible, Status.not_actionable) and not include_actions_flag:
                 actions = None
 
@@ -212,7 +228,7 @@ def evaluate_eligibility(
                 condition_name,
                 (best_active_iteration, best_candidate, best_cohort_results),
                 (best_campaign_id, best_campaign_version),
-                (redirect_rule_priority, redirect_rule_name),
+                (action_rule_priority, action_rule_name),
             )
 
         # Consolidate all the results and return
@@ -240,15 +256,16 @@ def get_iteration_results(
             )
         return iteration_results
 
-    def handle_redirect_rules(
-        self, best_active_iteration: Iteration
+    def handle_action_rules(
+        self, best_active_iteration: Iteration, rule_type: RuleType
     ) -> tuple[list[SuggestedAction] | None, RulePriority | None, RuleName | None]:
-        redirect_rules, action_mapper, default_comms = self.get_redirect_rules(best_active_iteration)
+        action_rules, action_mapper, default_comms = self.get_action_rules_components(best_active_iteration, rule_type)
         priority_getter = attrgetter("priority")
-        sorted_rules_by_priority = sorted(redirect_rules, key=priority_getter)
+        sorted_rules_by_priority = sorted(action_rules, key=priority_getter)
+
+        actions: list[SuggestedAction] | None = self.get_actions_from_comms(action_mapper, default_comms)  # pyright: ignore[reportArgumentType]
 
-        actions: list[SuggestedAction] | None = self.get_actions_from_comms(action_mapper, default_comms)
-        matched_redirect_rule_priority, matched_redirect_rule_name = None, None
+        matched_action_rule_priority, matched_action_rule_name = None, None
         for _, rule_group in groupby(sorted_rules_by_priority, key=priority_getter):
             rule_group_list = list(rule_group)
             matcher_matched_list = [
@@ -261,11 +278,11 @@ def handle_redirect_rules(
                 rule_actions = self.get_actions_from_comms(action_mapper, comms_routing)
                 if rule_actions and len(rule_actions) > 0:
                     actions = rule_actions
-                matched_redirect_rule_priority = rule_group_list[0].priority
-                matched_redirect_rule_name = rule_group_list[0].name
+                matched_action_rule_priority = rule_group_list[0].priority
+                matched_action_rule_name = rule_group_list[0].name
                 break
 
-        return actions, matched_redirect_rule_priority, matched_redirect_rule_name
+        return actions, matched_action_rule_priority, matched_action_rule_name
 
     def get_cohort_results(self, active_iteration: rules.Iteration) -> dict[str, CohortGroupResult]:
         cohort_results: dict[str, CohortGroupResult] = {}

src/eligibility_signposting_api/services/calculators/rule_calculator.py

@@ -84,6 +84,8 @@ def evaluate_rule(self, attribute_value: str | None) -> tuple[eligibility.Status
                 rules.RuleType.filter: eligibility.Status.not_eligible,
                 rules.RuleType.suppression: eligibility.Status.not_actionable,
                 rules.RuleType.redirect: eligibility.Status.actionable,
+                rules.RuleType.not_eligible_actions: eligibility.Status.not_eligible,
+                rules.RuleType.not_actionable_actions: eligibility.Status.not_actionable,
             }[self.rule.type]
             return status, str(reason), matcher_matched
         matcher.describe_mismatch(attribute_value, reason)

tests/fixtures/builders/model/rule.py

@@ -173,3 +173,27 @@ class ICBRedirectRuleFactory(IterationRuleFactory):
     attribute_name = rules.RuleAttributeName("ICB")
     comparator = rules.RuleComparator("QE1")
     comms_routing = rules.CommsRouting("ActionCode1")
+
+
+class ICBNonEligibleActionRuleFactory(IterationRuleFactory):
+    type = rules.RuleType.not_eligible_actions
+    name = rules.RuleName("In QE1")
+    description = rules.RuleDescription("In QE1")
+    priority = rules.RulePriority(20)
+    operator = rules.RuleOperator.equals
+    attribute_level = rules.RuleAttributeLevel.PERSON
+    attribute_name = rules.RuleAttributeName("ICB")
+    comparator = rules.RuleComparator("QE1")
+    comms_routing = rules.CommsRouting("ActionCode1")
+
+
+class ICBNonActionableActionRuleFactory(IterationRuleFactory):
+    type = rules.RuleType.not_actionable_actions
+    name = rules.RuleName("In QE1")
+    description = rules.RuleDescription("In QE1")
+    priority = rules.RulePriority(20)
+    operator = rules.RuleOperator.equals
+    attribute_level = rules.RuleAttributeLevel.PERSON
+    attribute_name = rules.RuleAttributeName("ICB")
+    comparator = rules.RuleComparator("QE1")
+    comms_routing = rules.CommsRouting("ActionCode1")

tests/test_data/test_config/test_config.json

@@ -16,11 +16,16 @@
       {
         "ID": "id_100",
         "DefaultCommsRouting": "INTERNALCONTACTGP1",
+        "DefaultNotActionableRouting": "INTERNALCONTACTGP1",
+        "DefaultNotEligibleRouting": "INTERNALCONTACTGP1",
         "ActionsMapper": {
           "INTERNALCONTACTGP1": {"ExternalRoutingCode": "CONTACTGP","ActionDescription":"Contact GP Text1 description", "ActionType":"text1"},
           "INTERNALCONTACTGP2": {"ExternalRoutingCode": "CONTACTGP","ActionDescription":"Contact GP Link description", "ActionType":"link", "UrlLink": "link123", "UrlLabel": "link label"},
           "INTERNALTESCO": {"ExternalRoutingCode": "TESCO","ActionDescription":"Tesco description", "ActionType":"link", "UrlLink": "tesco link", "UrlLabel": "link label"},
-          "INTERNALFINDWALKIN": {"ExternalRoutingCode": "FINDWALKIN","ActionDescription":"Find walkin description", "ActionType":"button"}
+          "INTERNALFINDWALKIN": {"ExternalRoutingCode": "FINDWALKIN","ActionDescription":"Find walkin description", "ActionType":"button"},
+
+          "XRULEID1": {"ExternalRoutingCode": "FINDWALKIN","ActionDescription":"Find walkin description", "ActionType":"button"},
+          "YRULEID1": {"ExternalRoutingCode": "FINDWALKIN","ActionDescription":"Find walkin description", "ActionType":"button"}
         },
         "IterationCohorts": [
           {
@@ -91,6 +96,28 @@
             "Operator": ">",
             "Comparator": "19000101",
             "CommsRouting": "INTERNALCONTACTGP1|INTERNALTESCO"
+          },
+          {
+            "Type": "X",
+            "Name": "Test X Rule for not eligible",
+            "Description": "Test X Rule Desc",
+            "Priority": 20,
+            "AttributeLevel": "PERSON",
+            "AttributeName": "DATE_OF_BIRTH",
+            "Operator": ">",
+            "Comparator": "19000101",
+            "CommsRouting": "XRULEID1|INTERNALTESCO"
+          },
+          {
+            "Type": "Y",
+            "Name": "Test Y Rule for not actionable",
+            "Description": "Test Y Rule Desc",
+            "Priority": 20,
+            "AttributeLevel": "PERSON",
+            "AttributeName": "DATE_OF_BIRTH",
+            "Operator": ">",
+            "Comparator": "19000101",
+            "CommsRouting": "YRULEID1|INTERNALTESCO"
           }
         ],
         "Version": "1",