eli-579 allowing custom target field names and source fields

Author: eddalmond1

src/eligibility_signposting_api/services/processors/derived_values/add_days_handler.py

@@ -48,15 +48,25 @@ def __init__(
         self.default_days = default_days
         self.vaccine_type_days = vaccine_type_days or {}
 
-    def get_source_attribute(self, target_attribute: str) -> str:
+    def get_source_attribute(self, target_attribute: str, function_args: str | None = None) -> str:
         """Get the source attribute for a derived attribute.
 
+        Check if source is provided in function args (e.g., ADD_DAYS(91, SOURCE_FIELD)).
+        If not, fall back to mapping or return target_attribute as default.
+
         Args:
             target_attribute: The derived attribute name (e.g., 'NEXT_DOSE_DUE')
+            function_args: Optional arguments from token (e.g., '91, LAST_SUCCESSFUL_DATE')
 
         Returns:
             The source attribute name (e.g., 'LAST_SUCCESSFUL_DATE')
         """
+        if function_args and "," in function_args:
+            # Extract source from args if present (second argument)
+            parts = [p.strip() for p in function_args.split(",")]
+            if len(parts) > 1 and parts[1]:
+                return parts[1].upper()
+
         return self.DERIVED_ATTRIBUTE_SOURCES.get(target_attribute, target_attribute)
 
     def calculate(self, context: DerivedValueContext) -> str:
@@ -120,11 +130,13 @@ def _get_days_to_add(self, context: DerivedValueContext) -> int:
         """
         # Priority 1: Token argument (if non-empty)
         if context.function_args:
-            try:
-                return int(context.function_args)
-            except ValueError as e:
-                message = f"Invalid days argument '{context.function_args}' for ADD_DAYS function. Expected an integer."
-                raise ValueError(message) from e
+            args = context.function_args.split(",")[0].strip()
+            if args:
+                try:
+                    return int(args)
+                except ValueError as e:
+                    message = f"Invalid days argument '{args}' for ADD_DAYS function. Expected an integer."
+                    raise ValueError(message) from e
 
         # Priority 2: Vaccine-specific configuration
         if context.attribute_name in self.vaccine_type_days:

src/eligibility_signposting_api/services/processors/derived_values/base.py

@@ -53,13 +53,14 @@ def calculate(self, context: DerivedValueContext) -> str:
         """
 
     @abstractmethod
-    def get_source_attribute(self, target_attribute: str) -> str:
+    def get_source_attribute(self, target_attribute: str, function_args: str | None = None) -> str:
         """Get the source attribute name needed for this derived value.
 
         For example, NEXT_DOSE_DUE derives from LAST_SUCCESSFUL_DATE.
 
         Args:
             target_attribute: The target derived attribute name (e.g., 'NEXT_DOSE_DUE')
+            function_args: Optional arguments from the token function call
 
         Returns:
             The source attribute name to use for calculation

src/eligibility_signposting_api/services/processors/derived_values/registry.py

@@ -104,24 +104,26 @@ def is_derived_attribute(self, attribute_value: str) -> bool:
             True if any handler can derive this attribute
         """
         for handler in self._handlers.values():
-            source = handler.get_source_attribute(attribute_value)
+            # Pass None for function_args as we're just checking capability
+            source = handler.get_source_attribute(attribute_value, function_args=None)
             if source != attribute_value:
                 return True
         return False
 
-    def get_source_attribute(self, function_name: str, target_attribute: str) -> str:
+    def get_source_attribute(self, function_name: str, target_attribute: str, function_args: str | None = None) -> str:
         """Get the source attribute for a derived attribute.
 
         Args:
             function_name: The function name of the handler
             target_attribute: The target derived attribute
+            function_args: Optional arguments from the token function call
 
         Returns:
             The source attribute name, or the target if no handler found
         """
         handler = self.get_handler(function_name)
         if handler:
-            return handler.get_source_attribute(target_attribute)
+            return handler.get_source_attribute(target_attribute, function_args)
         return target_attribute
 
     def calculate(

src/eligibility_signposting_api/services/processors/token_processor.py

@@ -153,7 +153,11 @@ def get_derived_value(
 
         try:
             target_attribute = parsed_token.attribute_value or parsed_token.attribute_name
-            source_attribute = registry.get_source_attribute(function_name, target_attribute)
+            source_attribute = registry.get_source_attribute(
+                function_name,
+                target_attribute,
+                parsed_token.function_args,
+            )
 
             context = DerivedValueContext(
                 person_data=person_data,

tests/unit/services/processors/test_derived_values.py

@@ -44,6 +44,93 @@ def test_calculate_with_function_args_override(self):
         # 2025-01-01 + 30 days = 2025-01-31
         assert_that(result, is_(equal_to("20250131")))
 
+    def test_get_source_attribute_from_args(self):
+        """Test that source attribute is extracted from function args."""
+        handler = AddDaysHandler()
+
+        # Test with source attribute provided
+        source = handler.get_source_attribute("target", "91, CUSTOM_SOURCE")
+        assert_that(source, is_(equal_to("CUSTOM_SOURCE")))
+
+        # Test with only days provided (should fallback to default mapping or target)
+        source = handler.get_source_attribute("NEXT_DOSE_DUE", "91")
+        assert_that(source, is_(equal_to("LAST_SUCCESSFUL_DATE")))
+
+        # Test with empty args
+        source = handler.get_source_attribute("NEXT_DOSE_DUE", None)
+        assert_that(source, is_(equal_to("LAST_SUCCESSFUL_DATE")))
+
+    def test_calculate_with_args_source_override(self):
+        """Test calculation with source attribute in args."""
+        handler = AddDaysHandler(default_days=91)
+        # Note: In the real flow, get_source_attribute is called before context creation
+        # to set source_attribute in the context. Checking if calculate handles the complex args correctly
+        # for days parsing.
+
+        context = DerivedValueContext(
+            person_data=[{"ATTRIBUTE_TYPE": "COVID", "CUSTOM_DATE": "20250101"}],
+            attribute_name="COVID",
+            source_attribute="CUSTOM_DATE",  # This would have been resolved by get_source_attribute
+            function_args="30, CUSTOM_DATE",
+            date_format=None,
+        )
+
+        result = handler.calculate(context)
+
+        # 2025-01-01 + 30 days = 2025-01-31
+        assert_that(result, is_(equal_to("20250131")))
+
+    def test_calculate_with_blank_days_and_source_override(self):
+        """Test that blank days arg with override falls back to defaults."""
+        handler = AddDaysHandler(default_days=91)
+        context = DerivedValueContext(
+            person_data=[{"ATTRIBUTE_TYPE": "COVID", "LAST_SUCCESSFUL_DATE": "20250101"}],
+            attribute_name="COVID",
+            source_attribute="LAST_SUCCESSFUL_DATE",
+            function_args=", LAST_SUCCESSFUL_DATE",
+            date_format=None,
+        )
+
+        result = handler.calculate(context)
+
+        # No explicit days provided, so default 91 days should be used
+        assert_that(result, is_(equal_to("20250402")))
+
+    def test_source_override_trims_whitespace_and_case(self):
+        """Test override parsing handles whitespace and lowercase inputs."""
+        handler = AddDaysHandler(default_days=91)
+
+        source = handler.get_source_attribute("DOSE_DUE", " 30 , last_successful_date ")
+        assert_that(source, is_(equal_to("LAST_SUCCESSFUL_DATE")))
+
+        context = DerivedValueContext(
+            person_data=[{"ATTRIBUTE_TYPE": "COVID", "LAST_SUCCESSFUL_DATE": "20250101"}],
+            attribute_name="COVID",
+            source_attribute=source,
+            function_args=" 30 , last_successful_date ",
+            date_format=None,
+        )
+
+        result = handler.calculate(context)
+
+        # 2025-01-01 + 30 days = 2025-01-31
+        assert_that(result, is_(equal_to("20250131")))
+
+    def test_calculate_with_missing_custom_source_returns_empty(self):
+        """Test that missing custom source attribute returns empty string."""
+        handler = AddDaysHandler(default_days=91)
+        context = DerivedValueContext(
+            person_data=[{"ATTRIBUTE_TYPE": "COVID"}],
+            attribute_name="COVID",
+            source_attribute="CUSTOM_DATE",
+            function_args="30, CUSTOM_DATE",
+            date_format=None,
+        )
+
+        result = handler.calculate(context)
+
+        assert_that(result, is_(equal_to("")))
+
     def test_calculate_with_vaccine_specific_days(self):
         """Test that vaccine-specific days are used when configured."""
         handler = AddDaysHandler(

tests/unit/services/processors/test_token_processor_derived.py

@@ -124,6 +124,48 @@ def test_missing_last_successful_date_returns_empty(self):
 
         assert result.status_text == "Next dose: "
 
+    def test_custom_target_without_mapping_returns_empty(self):
+        """Test unknown target without source override returns empty string."""
+        person = Person(
+            [
+                {"ATTRIBUTE_TYPE": "COVID", "LAST_SUCCESSFUL_DATE": "20250101"},
+            ]
+        )
+
+        condition = Condition(
+            condition_name=ConditionName("COVID"),
+            status=Status.actionable,
+            status_text=StatusText("Due: [[TARGET.COVID.DOSE_DUE:ADD_DAYS(91)]]"),
+            cohort_results=[],
+            suitability_rules=[],
+            actions=[],
+        )
+
+        result = TokenProcessor.find_and_replace_tokens(person, condition)
+
+        assert result.status_text == "Due: "
+
+    def test_custom_target_with_source_override_uses_override(self):
+        """Test custom target with explicit source override derives date."""
+        person = Person(
+            [
+                {"ATTRIBUTE_TYPE": "COVID", "CUSTOM_DATE": "20250101"},
+            ]
+        )
+
+        condition = Condition(
+            condition_name=ConditionName("COVID"),
+            status=Status.actionable,
+            status_text=StatusText("Next dose: [[TARGET.COVID.DOSE_DUE:ADD_DAYS(30, CUSTOM_DATE)]]"),
+            cohort_results=[],
+            suitability_rules=[],
+            actions=[],
+        )
+
+        result = TokenProcessor.find_and_replace_tokens(person, condition)
+
+        assert result.status_text == "Next dose: 20250131"
+
     def test_mixed_regular_and_derived_tokens(self):
         """Test mixing regular tokens with derived value tokens."""
         person = Person(