Added DiagnosticTestHasOutcomeOfResult mapping class and filtering logic for test outcome-of-result criteria

Author: Andyg79

classes/diagnostic_test_has_outcome_of_result.py

@@ -0,0 +1,32 @@
+class DiagnosticTestHasOutcomeOfResult:
+    """
+    Maps outcome-of-result descriptions to logical flags or valid value IDs.
+    """
+
+    YES = "yes"
+    NO = "no"
+
+    _label_to_id = {
+        "referred": 9101,
+        "treated": 9102,
+        "not required": 9103,
+        # Extend as needed
+    }
+
+    _valid_flags = {YES, NO}
+
+    @classmethod
+    def from_description(cls, description: str):
+        key = description.strip().lower()
+        if key in cls._valid_flags:
+            return key
+        if key in cls._label_to_id:
+            return cls._label_to_id[key]
+        raise ValueError(f"Unknown outcome-of-result description: '{description}'")
+
+    @classmethod
+    def get_id(cls, description: str) -> int:
+        key = description.strip().lower()
+        if key not in cls._label_to_id:
+            raise ValueError(f"No ID available for outcome: '{description}'")
+        return cls._label_to_id[key]

utils/oracle/mock_selection_builder.py

@@ -7,9 +7,9 @@
 
 
 # Add helper class stubs below
-class DiagnosticTestHasResult:
+class DiagnosticTestHasOutcomeOfResult:
     """
-    Resolves whether a diagnostic test has a result, or maps to a specific result ID.
+    Maps outcome-of-result criteria values to either flags or valid value IDs.
     """
 
     YES = "yes"
@@ -18,24 +18,24 @@ class DiagnosticTestHasResult:
     _mapping = {
         "yes": YES,
         "no": NO,
-        "positive": 9001,
-        "negative": 9002,
-        "indeterminate": 9003,
+        "referred": 9101,
+        "treated": 9102,
+        "not required": 9103,
     }
 
     @classmethod
     def from_description(cls, description: str):
         key = description.strip().lower()
         if key not in cls._mapping:
-            raise ValueError(f"Unknown test result description: '{description}'")
+            raise ValueError(f"Unknown outcome description: '{description}'")
         return cls._mapping[key]
 
     @classmethod
     def get_id(cls, description: str) -> int:
         val = cls.from_description(description)
         if isinstance(val, int):
             return val
-        raise ValueError(f"No ID associated with: '{description}'")
+        raise ValueError(f"No ID associated with outcome: '{description}'")
 
 
 class MockSelectionBuilder:
@@ -85,25 +85,25 @@ def _add_join_to_latest_episode(self) -> None:
     # Replace this with the one you want to test,
     # then use utils/oracle/test_subject_criteria_dev.py to run your scenarios
 
-    def _add_criteria_diagnostic_test_has_result(self) -> None:
+    def _add_criteria_diagnostic_test_has_outcome_of_result(self) -> None:
         """
-        Adds WHERE clause to check whether a diagnostic test has a result (IS NULL / NOT NULL / = result_id).
+        Adds WHERE clause filtering on whether the diagnostic test has an outcome-of-result.
         """
         try:
             idx = getattr(self, "criteria_index", 0)
             xt = f"xt{idx}"
             value = self.criteria_value.strip().lower()
-            result = DiagnosticTestHasResult.from_description(value)
+            outcome = DiagnosticTestHasOutcomeOfResult.from_description(value)
 
-            self.sql_where.append(f"AND {xt}.result_id ")
+            self.sql_where.append(f"AND {xt}.outcome_of_result_id ")
 
-            if result == DiagnosticTestHasResult.YES:
+            if outcome == DiagnosticTestHasOutcomeOfResult.YES:
                 self.sql_where.append("IS NOT NULL")
-            elif result == DiagnosticTestHasResult.NO:
+            elif outcome == DiagnosticTestHasOutcomeOfResult.NO:
                 self.sql_where.append("IS NULL")
             else:
-                result_id = DiagnosticTestHasResult.get_id(value)
-                self.sql_where.append(f"= {result_id}")
+                outcome_id = DiagnosticTestHasOutcomeOfResult.get_id(value)
+                self.sql_where.append(f"= {outcome_id}")
 
         except Exception:
             raise SelectionBuilderException(self.criteria_key_name, self.criteria_value)

utils/oracle/subject_selection_query_builder.py

@@ -31,6 +31,9 @@
 from classes.diagnostic_test_type import DiagnosticTestType
 from classes.diagnostic_test_is_void import DiagnosticTestIsVoid
 from classes.diagnostic_test_has_result import DiagnosticTestHasResult
+from classes.diagnostic_test_has_outcome_of_result import (
+    DiagnosticTestHasOutcomeOfResult,
+)
 
 
 class SubjectSelectionQueryBuilder:
@@ -1771,6 +1774,29 @@ def _add_criteria_diagnostic_test_has_result(self) -> None:
         except Exception:
             raise SelectionBuilderException(self.criteria_key_name, self.criteria_value)
 
+    def _add_criteria_diagnostic_test_has_outcome_of_result(self) -> None:
+        """
+        Adds WHERE clause filtering on whether the diagnostic test has an outcome-of-result.
+        """
+        try:
+            idx = getattr(self, "criteria_index", 0)
+            xt = f"xt{idx}"
+            value = self.criteria_value.strip().lower()
+            outcome = DiagnosticTestHasOutcomeOfResult.from_description(value)
+
+            self.sql_where.append(f"AND {xt}.outcome_of_result_id ")
+
+            if outcome == DiagnosticTestHasOutcomeOfResult.YES:
+                self.sql_where.append("IS NOT NULL")
+            elif outcome == DiagnosticTestHasOutcomeOfResult.NO:
+                self.sql_where.append("IS NULL")
+            else:
+                outcome_id = DiagnosticTestHasOutcomeOfResult.get_id(value)
+                self.sql_where.append(f"= {outcome_id}")
+
+        except Exception:
+            raise SelectionBuilderException(self.criteria_key_name, self.criteria_value)
+
     # ------------------------------------------------------------------------
     # 🧬 CADS Clinical Dataset Filters
     # ------------------------------------------------------------------------

utils/oracle/test_subject_criteria_dev.py

@@ -37,20 +37,22 @@ def make_builder(key, value, index=0):
     return b
 
 
-# === Test: DIAGNOSTIC_TEST_HAS_RESULT (yes) ===
-b = make_builder(SubjectSelectionCriteriaKey.DIAGNOSTIC_TEST_HAS_RESULT, "yes")
-b._add_criteria_diagnostic_test_has_result()
-print("=== DIAGNOSTIC_TEST_HAS_RESULT (yes) ===")
+# === Test: DIAGNOSTIC_TEST_HAS_OUTCOME (yes) ===
+b = make_builder(SubjectSelectionCriteriaKey.DIAGNOSTIC_TEST_HAS_OUTCOME, "yes")
+b._add_criteria_diagnostic_test_has_outcome_of_result()
+print("=== DIAGNOSTIC_TEST_HAS_OUTCOME (yes) ===")
 print(b.dump_sql(), end="\n\n")
 
-# === Test: DIAGNOSTIC_TEST_HAS_RESULT (no) ===
-b = make_builder(SubjectSelectionCriteriaKey.DIAGNOSTIC_TEST_HAS_RESULT, "no")
-b._add_criteria_diagnostic_test_has_result()
-print("=== DIAGNOSTIC_TEST_HAS_RESULT (no) ===")
+# === Test: DIAGNOSTIC_TEST_HAS_OUTCOME (no) ===
+b = make_builder(SubjectSelectionCriteriaKey.DIAGNOSTIC_TEST_HAS_OUTCOME, "no", index=1)
+b._add_criteria_diagnostic_test_has_outcome_of_result()
+print("=== DIAGNOSTIC_TEST_HAS_OUTCOME (no) ===")
 print(b.dump_sql(), end="\n\n")
 
-# === Test: DIAGNOSTIC_TEST_HAS_RESULT (positive) ===
-b = make_builder(SubjectSelectionCriteriaKey.DIAGNOSTIC_TEST_HAS_RESULT, "positive")
-b._add_criteria_diagnostic_test_has_result()
-print("=== DIAGNOSTIC_TEST_HAS_RESULT (positive) ===")
+# === Test: DIAGNOSTIC_TEST_HAS_OUTCOME (treated) ===
+b = make_builder(
+    SubjectSelectionCriteriaKey.DIAGNOSTIC_TEST_HAS_OUTCOME, "treated", index=2
+)
+b._add_criteria_diagnostic_test_has_outcome_of_result()
+print("=== DIAGNOSTIC_TEST_HAS_OUTCOME (treated) ===")
 print(b.dump_sql(), end="\n\n")