Bugfix to change response grouping from name to priority

src/eligibility_signposting_api/model/eligibility_status.py

@@ -113,6 +113,7 @@ class Condition:
     condition_name: ConditionName
     status: Status
     cohort_results: list[CohortGroupResult]
+    suitability_rules: list[Reason]
     status_text: StatusText
     actions: list[SuggestedAction] | None = None
 

src/eligibility_signposting_api/services/calculators/eligibility_calculator.py

@@ -3,6 +3,7 @@
 import logging
 from collections import defaultdict
 from dataclasses import dataclass, field
+from itertools import chain
 from typing import TYPE_CHECKING
 
 from wireup import service
@@ -16,6 +17,7 @@
     ConditionName,
     EligibilityStatus,
     IterationResult,
+    Reason,
     Status,
 )
 from eligibility_signposting_api.services.processors.action_rule_handler import ActionRuleHandler
@@ -100,8 +102,10 @@ def get_eligibility_status(self, include_actions: str, conditions: list[str], ca
             condition_results[condition_name] = best_iteration_result.iteration_result
             condition_results[condition_name].actions = matched_action_detail.actions
 
-            condition_result = self.build_condition_results(condition_results[condition_name], condition_name)
-            final_result.append(condition_result)
+            condition: Condition = self.build_condition(
+                iteration_result=condition_results[condition_name], condition_name=condition_name
+            )
+            final_result.append(condition)
 
             AuditContext.append_audit_condition(
                 condition_name,
@@ -150,39 +154,61 @@ def get_iteration_results(self, campaign_group: list[CampaignConfig]) -> dict[It
         return iteration_results
 
     @staticmethod
-    def build_condition_results(iteration_result: IterationResult, condition_name: ConditionName) -> Condition:
+    def build_condition(iteration_result: IterationResult, condition_name: ConditionName) -> Condition:
         grouped_cohort_results = defaultdict(list)
 
         for cohort_result in iteration_result.cohort_results:
             if iteration_result.status == cohort_result.status:
                 grouped_cohort_results[cohort_result.cohort_code].append(cohort_result)
 
-        deduplicated_cohort_results = []
-
-        for group_cohort_code, group in grouped_cohort_results.items():
-            if group:
-                unique_rule_codes = set()
-                deduplicated_reasons = []
-                for cohort in group:
-                    for reason in cohort.reasons:
-                        if reason.rule_name not in unique_rule_codes and reason.rule_description:
-                            unique_rule_codes.add(reason.rule_name)
-                            deduplicated_reasons.append(reason)
-
-                non_empty_description = next((c.description for c in group if c.description), group[0].description)
-                cohort_group_result = CohortGroupResult(
-                    cohort_code=group_cohort_code,
-                    status=group[0].status,
-                    reasons=deduplicated_reasons,
-                    description=non_empty_description,
-                    audit_rules=[],
-                )
-                deduplicated_cohort_results.append(cohort_group_result)
+        deduplicated_cohort_results: list[CohortGroupResult] = EligibilityCalculator.deduplicate_cohort_results(
+            grouped_cohort_results
+        )
+
+        overall_deduplicated_reasons_for_condition = EligibilityCalculator.deduplicate_reasons(
+            deduplicated_cohort_results
+        )
 
         return Condition(
             condition_name=condition_name,
             status=iteration_result.status,
             cohort_results=list(deduplicated_cohort_results),
+            suitability_rules=list(overall_deduplicated_reasons_for_condition),
             actions=iteration_result.actions,
             status_text=iteration_result.status.get_status_text(condition_name),
         )
+
+    @staticmethod
+    def deduplicate_cohort_results(
+        grouped_cohort_results: dict[str, list[CohortGroupResult]],
+    ) -> list[CohortGroupResult]:
+        results = []
+
+        for cohort_code, group_results in grouped_cohort_results.items():
+            if not group_results:
+                continue
+
+            deduped_reasons: list[Reason] = EligibilityCalculator.deduplicate_reasons(group_results)
+
+            description = next((c.description for c in group_results if c.description), group_results[0].description)
+
+            results.append(
+                CohortGroupResult(
+                    cohort_code=cohort_code,
+                    status=group_results[0].status,
+                    reasons=list(deduped_reasons),
+                    description=description,
+                    audit_rules=[],
+                )
+            )
+
+        return results
+
+    @staticmethod
+    def deduplicate_reasons(group_results: list[CohortGroupResult]) -> list[Reason]:
+        all_reasons = chain.from_iterable(group_result.reasons for group_result in group_results)
+        deduped = {}
+        for reason in all_reasons:
+            key = (reason.rule_type, reason.rule_priority)
+            deduped.setdefault(key, reason)
+        return list(deduped.values())

src/eligibility_signposting_api/views/eligibility.py

@@ -158,22 +158,15 @@ def build_eligibility_cohorts(condition: Condition) -> list[eligibility_response
 
 
 def build_suitability_results(condition: Condition) -> list[eligibility_response.SuitabilityRule]:
-    """Make only one entry if there are duplicate rules"""
     if condition.status != Status.not_actionable:
         return []
 
-    suitability_results = []
-
-    for cohort_result in condition.cohort_results:
-        if cohort_result.status == Status.not_actionable:
-            suitability_results.extend(
-                eligibility_response.SuitabilityRule(
-                    ruleType=eligibility_response.RuleType(reason.rule_type.value),
-                    ruleCode=eligibility_response.RuleCode(reason.rule_name),
-                    ruleText=eligibility_response.RuleText(reason.rule_description),
-                )
-                for reason in cohort_result.reasons
-                if reason.rule_description
-            )
-
-    return suitability_results
+    return [
+        eligibility_response.SuitabilityRule(
+            ruleType=eligibility_response.RuleType(reason.rule_type.value),
+            ruleCode=eligibility_response.RuleCode(reason.rule_name),
+            ruleText=eligibility_response.RuleText(reason.rule_description),
+        )
+        for reason in condition.suitability_rules
+        if reason.rule_description
+    ]

tests/fixtures/builders/model/eligibility.py

@@ -33,6 +33,7 @@ class CohortResultFactory(DataclassFactory[eligibility_status.CohortGroupResult]
 class ConditionFactory(DataclassFactory[eligibility_status.Condition]):
     actions = Use(SuggestedActionFactory.batch, size=2)
     cohort_results = Use(CohortResultFactory.batch, size=2)
+    suitability_rules = Use(ReasonFactory.batch, size=2)
 
 
 class EligibilityStatusFactory(DataclassFactory[eligibility_status.EligibilityStatus]):