ELI-441: Fix Sonar code smells (#358)

Author: shweta-nhs

src/eligibility_signposting_api/services/processors/action_rule_handler.py

@@ -50,13 +50,14 @@ def _handle(self, person: Person, best_active_iteration: Iteration, rule_type: R
         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 = [
+
+            all_rules_matched = all(
                 RuleCalculator(person=person, rule=rule).evaluate_exclusion()[1].matcher_matched
                 for rule in rule_group_list
-            ]
+            )
 
             comms_routing = rule_group_list[0].comms_routing
-            if comms_routing and all(matcher_matched_list):
+            if comms_routing and all_rules_matched:
                 rule_actions = self._get_actions_from_comms(action_mapper, comms_routing)
                 if rule_actions and len(rule_actions) > 0:
                     actions = rule_actions

src/eligibility_signposting_api/services/processors/token_processor.py

@@ -71,45 +71,64 @@ def replace_token(text: str, person: Person) -> str:
 
         pattern = r"\[\[.*?\]\]"
         all_tokens = re.findall(pattern, text, re.IGNORECASE)
-        present_attributes = [attribute.get("ATTRIBUTE_TYPE") for attribute in person.data]
+        present_attributes = {attribute.get("ATTRIBUTE_TYPE") for attribute in person.data}
 
         for token in all_tokens:
-            parsed_token = TokenParser.parse(token)
-            found_attribute, key_to_replace, replace_with = None, None, None
-
-            attribute_level_map = {
-                TARGET_ATTRIBUTE_LEVEL: parsed_token.attribute_value,
-                PERSON_ATTRIBUTE_LEVEL: parsed_token.attribute_name,
-            }
-
-            key_to_find = attribute_level_map.get(parsed_token.attribute_level)
-
-            if (
-                parsed_token.attribute_level == TARGET_ATTRIBUTE_LEVEL
-                and parsed_token.attribute_name in ALLOWED_CONDITIONS.__args__
-                and parsed_token.attribute_value in ALLOWED_TARGET_ATTRIBUTES
-                and parsed_token.attribute_name not in present_attributes
-            ):
-                replace_with = ""
-
-            if replace_with != "":
-                for attribute in person.data:
-                    is_person_attribute = attribute.get("ATTRIBUTE_TYPE") == PERSON_ATTRIBUTE_LEVEL
-                    is_allowed_target = parsed_token.attribute_name.upper() in ALLOWED_CONDITIONS.__args__
-                    is_correct_target = parsed_token.attribute_name.upper() == attribute.get("ATTRIBUTE_TYPE")
-
-                    if ((is_allowed_target and is_correct_target) or is_person_attribute) and key_to_find in attribute:
-                        found_attribute = attribute
-                        key_to_replace = key_to_find
-                        break
-
-                if not found_attribute or key_to_replace is None:
-                    TokenProcessor.handle_token_not_found(parsed_token, token)
-
-                replace_with = TokenProcessor.apply_formatting(found_attribute, key_to_replace, parsed_token.format)
-            text = text.replace(token, str(replace_with))
+            replacement = TokenProcessor.get_token_replacement(token, person.data, present_attributes)
+            text = text.replace(token, str(replacement))
         return text
 
+    @staticmethod
+    def get_token_replacement(token: str, person_data: list[dict], present_attributes: set) -> str:
+        parsed_token = TokenParser.parse(token)
+
+        if TokenProcessor.should_replace_with_empty(parsed_token, present_attributes):
+            return ""
+
+        found_attribute, key_to_replace = TokenProcessor.find_matching_attribute(parsed_token, person_data)
+
+        if not found_attribute or not key_to_replace:
+            TokenProcessor.handle_token_not_found(parsed_token, token)
+
+        return TokenProcessor.apply_formatting(found_attribute, key_to_replace, parsed_token.format)
+
+    @staticmethod
+    def should_replace_with_empty(parsed_token: ParsedToken, present_attributes: set) -> bool:
+        is_target_level = parsed_token.attribute_level == TARGET_ATTRIBUTE_LEVEL
+        is_allowed_condition = parsed_token.attribute_name in ALLOWED_CONDITIONS.__args__
+        is_allowed_target_attr = parsed_token.attribute_value in ALLOWED_TARGET_ATTRIBUTES
+        is_attr_not_present = parsed_token.attribute_name not in present_attributes
+
+        return all([is_target_level, is_allowed_condition, is_allowed_target_attr, is_attr_not_present])
+
+    @staticmethod
+    def find_matching_attribute(parsed_token: ParsedToken, person_data: list[dict]) -> tuple[dict | None, str | None]:
+        attribute_level_map = {
+            TARGET_ATTRIBUTE_LEVEL: parsed_token.attribute_value,
+            PERSON_ATTRIBUTE_LEVEL: parsed_token.attribute_name,
+        }
+        key_to_find = attribute_level_map.get(parsed_token.attribute_level)
+
+        for attribute in person_data:
+            if TokenProcessor.attribute_match(attribute, parsed_token, key_to_find):
+                return attribute, key_to_find
+
+        return None, None
+
+    @staticmethod
+    def attribute_match(attribute: dict, parsed_token: ParsedToken, key_to_find: str | None) -> bool:
+        if not key_to_find or key_to_find not in attribute:
+            return False
+
+        is_person_attribute = attribute.get("ATTRIBUTE_TYPE") == PERSON_ATTRIBUTE_LEVEL
+        if is_person_attribute:
+            return True
+
+        is_allowed_target = parsed_token.attribute_name.upper() in ALLOWED_CONDITIONS.__args__
+        is_correct_target = parsed_token.attribute_name.upper() == attribute.get("ATTRIBUTE_TYPE")
+
+        return is_allowed_target and is_correct_target
+
     @staticmethod
     def handle_token_not_found(parsed_token: ParsedToken, token: str) -> Never:
         if parsed_token.attribute_level == TARGET_ATTRIBUTE_LEVEL: