added polyp and episode completion filters to builder

Andyg79 · Andyg79 · commit 0cfd2b5caabd · 2025-06-18T11:09:39.000+01:00
diff --git a/utils/oracle/mock_selection_builder.py b/utils/oracle/mock_selection_builder.py
@@ -26,6 +26,7 @@ def __init__(self, criteria_key, criteria_value, criteria_comparator=">="):
         self.criteria_value = criteria_value
         self.criteria_comparator = criteria_comparator
         self.sql_where = []
+        self.sql_from = []
 
     # Don't delete this method; it is used to inspect the SQL fragments
     def dump_sql(self):
@@ -35,26 +36,35 @@ def dump_sql(self):
     # 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_has_referral_date(self) -> None:
+    def _add_criteria_has_diagnostic_test_containing_polyp(self) -> None:
         """
-        Adds a filter for the presence or timing of referral_date in the latest episode.
-        Accepts values: yes, no, past, more_than_28_days_ago, within_the_last_28_days.
+        Adds logic to filter based on whether a diagnostic test has a recorded polyp.
+        'Yes' joins polyp tables; 'No' checks for absence via NOT EXISTS.
         """
         try:
             value = self.criteria_value.strip().lower()
 
-            clause_map = {
-                "yes": "ep.referral_date IS NOT NULL",
-                "no": "ep.referral_date IS NULL",
-                "past": "ep.referral_date < trunc(sysdate)",
-                "more_than_28_days_ago": "(ep.referral_date + 28) < trunc(sysdate)",
-                "within_the_last_28_days": "(ep.referral_date + 28) > trunc(sysdate)",
-            }
-
-            if value not in clause_map:
-                raise ValueError(f"Unknown referral date condition: {value}")
-
-            self.sql_where.append(f"AND {clause_map[value]}")
+            if value == "yes":
+                self.sql_from.append(
+                    "INNER JOIN external_tests_t ext ON ep.subject_epis_id = ext.subject_epis_id\n"
+                    "INNER JOIN ds_colonoscopy_t dsc ON ext.ext_test_id = dsc.ext_test_id\n"
+                    "INNER JOIN ds_polyp_t dst ON ext.ext_test_id = dst.ext_test_id"
+                )
+                self.sql_where.append(
+                    "AND ext.void = 'N'\n"
+                    "AND dst.deleted_flag = 'N'"
+                )
+            elif value == "no":
+                self.sql_where.append(
+                    """AND NOT EXISTS (
+        SELECT 'ext'
+        FROM external_tests_t ext
+        LEFT JOIN ds_polyp_t dst ON ext.ext_test_id = dst.ext_test_id
+        WHERE ext.subject_epis_id = ep.subject_epis_id
+    )"""
+                )
+            else:
+                raise ValueError(f"Unknown value for diagnostic test containing polyp: {value}")
 
         except Exception:
             raise SelectionBuilderException(self.criteria_key_name, self.criteria_value)
diff --git a/utils/oracle/subject_selection_query_builder.py b/utils/oracle/subject_selection_query_builder.py
@@ -1107,8 +1107,159 @@ def _add_criteria_has_referral_date(self) -> None:
 
         except Exception:
             raise SelectionBuilderException(self.criteria_key_name, self.criteria_value)
-        
-#TODO: Add methods below for other criteria keys as needed
+
+    # TODO: Add methods below for other criteria keys as needed
+
+    def _add_criteria_has_diagnosis_date(self) -> None:
+        """
+        Adds a filter to check if the latest episode has a diagnosis_date set,
+        and whether it matches the subject's date of death if specified.
+        Accepts values: yes, no, yes_date_of_death
+        """
+        try:
+            value = self.criteria_value.strip().lower()
+
+            if value == "yes":
+                self.sql_where.append("AND ep.diagnosis_date IS NOT NULL")
+            elif value == "no":
+                self.sql_where.append("AND ep.diagnosis_date IS NULL")
+            elif value == "yes_date_of_death":
+                self.sql_where.append("AND ep.diagnosis_date IS NOT NULL")
+                self.sql_where.append("AND ep.diagnosis_date = c.date_of_death")
+            else:
+                raise ValueError(f"Unknown condition for diagnosis date: {value}")
+
+        except Exception:
+            raise SelectionBuilderException(self.criteria_key_name, self.criteria_value)
+
+    def _add_criteria_has_diagnostic_test(self, latest_episode_only: bool) -> None:
+        """
+        Adds a filter checking if the subject has (or doesn't have) a diagnostic test.
+        Void tests are excluded. The `latest_episode_only` flag limits scope to the latest episode.
+        Accepts criteria value: "yes" or "no".
+        """
+        try:
+            value = self.criteria_value.strip().lower()
+
+            if value == "no":
+                prefix = "AND NOT "
+            elif value == "yes":
+                prefix = "AND "
+            else:
+                raise ValueError(f"Invalid diagnostic test condition: {value}")
+
+            subquery = [
+                "EXISTS (",
+                "  SELECT 1",
+                "  FROM external_tests_t lesxt",
+                "  WHERE lesxt.screening_subject_id = ss.screening_subject_id",
+                "    AND lesxt.void = 'N'",
+            ]
+            if latest_episode_only:
+                subquery.append("    AND lesxt.subject_epis_id = ep.subject_epis_id")
+            subquery.append(")")
+
+            self.sql_where.append(prefix + "\n".join(subquery))
+
+        except Exception:
+            raise SelectionBuilderException(self.criteria_key_name, self.criteria_value)
+
+    def _add_criteria_diagnosis_date_reason(self) -> None:
+        """
+        Adds a filter on ep.diagnosis_date_reason_id.
+        Supports symbolic matches (via ID) and special values: NULL, NOT_NULL.
+        """
+        try:
+            value = self.criteria_value.strip().lower()
+            comparator = self.criteria_comparator
+
+            # Simulated DiagnosisDateReasonType
+            reason_map = {
+                "patient informed": 900,
+                "clinician notified": 901,
+                "screening outcome": 902,
+                "null": "NULL",
+                "not_null": "NOT NULL",
+                # Extend as needed
+            }
+
+            if value not in reason_map:
+                raise ValueError(f"Unknown diagnosis date reason: {value}")
+
+            resolved = reason_map[value]
+            if resolved in ("NULL", "NOT NULL"):
+                self.sql_where.append(f"AND ep.diagnosis_date_reason_id IS {resolved}")
+            else:
+                self.sql_where.append(
+                    f"AND ep.diagnosis_date_reason_id {comparator} {resolved}"
+                )
+
+        except Exception:
+            raise SelectionBuilderException(self.criteria_key_name, self.criteria_value)
+
+    def _add_criteria_latest_episode_completed_satisfactorily(self) -> None:
+        """
+        Adds a filter to check whether the latest episode completed satisfactorily or not.
+        Checks for presence/absence of interruption events or disqualifying result codes.
+        """
+        try:
+            value = self.criteria_value.strip().lower()
+
+            if value == "yes":
+                exists_prefix = "AND NOT EXISTS"
+            elif value == "no":
+                exists_prefix = "AND EXISTS"
+            else:
+                raise ValueError(f"Invalid completion flag: {value}")
+
+            self.sql_where.append(
+                f"""{exists_prefix} (
+        SELECT 'ev'
+        FROM ep_events_t ev
+        WHERE ev.subject_epis_id = ep.subject_epis_id
+        AND (
+            ev.event_status_id IN (11237, 20188)
+            OR ep.episode_result_id IN (605002, 605003, 605004, 605007)
+        )
+    )"""
+            )
+
+        except Exception:
+            raise SelectionBuilderException(self.criteria_key_name, self.criteria_value)
+
+    def _add_criteria_has_diagnostic_test_containing_polyp(self) -> None:
+        """
+        Adds logic to filter based on whether a diagnostic test has a recorded polyp.
+        'Yes' joins polyp tables; 'No' checks for absence via NOT EXISTS.
+        """
+        try:
+            value = self.criteria_value.strip().lower()
+
+            if value == "yes":
+                self.sql_from.append(
+                    "INNER JOIN external_tests_t ext ON ep.subject_epis_id = ext.subject_epis_id\n"
+                    "INNER JOIN ds_colonoscopy_t dsc ON ext.ext_test_id = dsc.ext_test_id\n"
+                    "INNER JOIN ds_polyp_t dst ON ext.ext_test_id = dst.ext_test_id"
+                )
+                self.sql_where.append(
+                    "AND ext.void = 'N'\n" "AND dst.deleted_flag = 'N'"
+                )
+            elif value == "no":
+                self.sql_where.append(
+                    """AND NOT EXISTS (
+        SELECT 'ext'
+        FROM external_tests_t ext
+        LEFT JOIN ds_polyp_t dst ON ext.ext_test_id = dst.ext_test_id
+        WHERE ext.subject_epis_id = ep.subject_epis_id
+    )"""
+                )
+            else:
+                raise ValueError(
+                    f"Unknown value for diagnostic test containing polyp: {value}"
+                )
+
+        except Exception:
+            raise SelectionBuilderException(self.criteria_key_name, self.criteria_value)
 
     def _add_criteria_subject_hub_code(self, user: "User") -> None:
         hub_code = None
diff --git a/utils/oracle/test_subject_criteria_dev.py b/utils/oracle/test_subject_criteria_dev.py
@@ -30,44 +30,18 @@
 # === Example usage ===
 # Replace the examples below with the method you want to test
 
-# === Test: LATEST_EPISODE_HAS_REFERRAL_DATE — yes ===
+# === Test: HAS_DIAGNOSTIC_TEST_CONTAINING_POLYP — yes ===
 builder = MockSelectionBuilder(
-    SubjectSelectionCriteriaKey.LATEST_EPISODE_HAS_REFERRAL_DATE, "yes"
+    SubjectSelectionCriteriaKey.HAS_DIAGNOSTIC_TEST_CONTAINING_POLYP, "yes"
 )
-builder._add_criteria_has_referral_date()
-print("=== LATEST_EPISODE_HAS_REFERRAL_DATE — yes ===")
+builder._add_criteria_has_diagnostic_test_containing_polyp()
+print("=== HAS_DIAGNOSTIC_TEST_CONTAINING_POLYP — yes ===")
 print(builder.dump_sql(), end="\n\n")
 
-# === Test: LATEST_EPISODE_HAS_REFERRAL_DATE — no ===
+# === Test: HAS_DIAGNOSTIC_TEST_CONTAINING_POLYP — no ===
 builder = MockSelectionBuilder(
-    SubjectSelectionCriteriaKey.LATEST_EPISODE_HAS_REFERRAL_DATE, "no"
+    SubjectSelectionCriteriaKey.HAS_DIAGNOSTIC_TEST_CONTAINING_POLYP, "no"
 )
-builder._add_criteria_has_referral_date()
-print("=== LATEST_EPISODE_HAS_REFERRAL_DATE — no ===")
-print(builder.dump_sql(), end="\n\n")
-
-# === Test: LATEST_EPISODE_HAS_REFERRAL_DATE — past ===
-builder = MockSelectionBuilder(
-    SubjectSelectionCriteriaKey.LATEST_EPISODE_HAS_REFERRAL_DATE, "past"
-)
-builder._add_criteria_has_referral_date()
-print("=== LATEST_EPISODE_HAS_REFERRAL_DATE — past ===")
-print(builder.dump_sql(), end="\n\n")
-
-# === Test: LATEST_EPISODE_HAS_REFERRAL_DATE — more_than_28_days_ago ===
-builder = MockSelectionBuilder(
-    SubjectSelectionCriteriaKey.LATEST_EPISODE_HAS_REFERRAL_DATE,
-    "more_than_28_days_ago",
-)
-builder._add_criteria_has_referral_date()
-print("=== LATEST_EPISODE_HAS_REFERRAL_DATE — more_than_28_days_ago ===")
-print(builder.dump_sql(), end="\n\n")
-
-# === Test: LATEST_EPISODE_HAS_REFERRAL_DATE — within_the_last_28_days ===
-builder = MockSelectionBuilder(
-    SubjectSelectionCriteriaKey.LATEST_EPISODE_HAS_REFERRAL_DATE,
-    "within_the_last_28_days",
-)
-builder._add_criteria_has_referral_date()
-print("=== LATEST_EPISODE_HAS_REFERRAL_DATE — within_the_last_28_days ===")
+builder._add_criteria_has_diagnostic_test_containing_polyp()
+print("=== HAS_DIAGNOSTIC_TEST_CONTAINING_POLYP — no ===")
 print(builder.dump_sql(), end="\n\n")
