VED-320: BugFixes-Delta-postcode (#539)

Akol125 · web-flow · commit f90c55f6377d · 2025-05-29T12:34:02.000+01:00
Delta Postcode Fix
diff --git a/backend/src/models/utils/pre_validator_utils.py b/backend/src/models/utils/pre_validator_utils.py
@@ -114,13 +114,13 @@ def for_date_time(field_value: str, field_location: str):
             raise TypeError(f"{field_location} must be a string")
 
         error_message = (
-            f"{field_location} must be a valid datetime in one of the following formats:\n"
-            "- 'YYYY-MM-DD' — Full date only\n"
-            "- 'YYYY-MM-DDThh:mm:ss' — Full date and time without milliseconds\n"
-            "- 'YYYY-MM-DDThh:mm:ss.f' — Full date and time with milliseconds (any level of precision)\n"
-            "- 'YYYY-MM-DDThh:mm:ss%z' — Full date and time with timezone (e.g. +00:00 or +01:00)\n"
-            "- 'YYYY-MM-DDThh:mm:ss.f%z' — Full date and time with milliseconds and timezone\n\n"
-            "Only '+00:00' and '+01:00' are accepted as valid timezone offsets.\n"
+            f"{field_location} must be a valid datetime in one of the following formats:"
+            "- 'YYYY-MM-DD' — Full date only"
+            "- 'YYYY-MM-DDThh:mm:ss' — Full date and time without milliseconds"
+            "- 'YYYY-MM-DDThh:mm:ss.f' — Full date and time with milliseconds (any level of precision)"
+            "- 'YYYY-MM-DDThh:mm:ss%z' — Full date and time with timezone (e.g. +00:00 or +01:00)"
+            "- 'YYYY-MM-DDThh:mm:ss.f%z' — Full date and time with milliseconds and timezone"
+            "Only '+00:00' and '+01:00' are accepted as valid timezone offsets."
             f"Note that partial dates are not allowed for {field_location} in this service."
         )
 
diff --git a/backend/tests/utils/pre_validation_test_utils.py b/backend/tests/utils/pre_validation_test_utils.py
@@ -350,13 +350,13 @@ def test_date_time_value(
             )
 
         expected_error_message = (
-            f"{field_location} must be a valid datetime in one of the following formats:\n"
-            "- 'YYYY-MM-DD' — Full date only\n"
-            "- 'YYYY-MM-DDThh:mm:ss' — Full date and time without milliseconds\n"
-            "- 'YYYY-MM-DDThh:mm:ss.f' — Full date and time with milliseconds (any level of precision)\n"
-            "- 'YYYY-MM-DDThh:mm:ss%z' — Full date and time with timezone (e.g. +00:00 or +01:00)\n"
-            "- 'YYYY-MM-DDThh:mm:ss.f%z' — Full date and time with milliseconds and timezone\n\n"
-            "Only '+00:00' and '+01:00' are accepted as valid timezone offsets.\n"
+            f"{field_location} must be a valid datetime in one of the following formats:"
+            "- 'YYYY-MM-DD' — Full date only"
+            "- 'YYYY-MM-DDThh:mm:ss' — Full date and time without milliseconds"
+            "- 'YYYY-MM-DDThh:mm:ss.f' — Full date and time with milliseconds (any level of precision)"
+            "- 'YYYY-MM-DDThh:mm:ss%z' — Full date and time with timezone (e.g. +00:00 or +01:00)"
+            "- 'YYYY-MM-DDThh:mm:ss.f%z' — Full date and time with milliseconds and timezone"
+            "Only '+00:00' and '+01:00' are accepted as valid timezone offsets."
             f"Note that partial dates are not allowed for {field_location} in this service."
         )
 
diff --git a/delta_backend/src/extractor.py b/delta_backend/src/extractor.py
@@ -254,6 +254,9 @@ def extract_person_gender(self):
                 return ""
         return ""
 
+    def normalize(self, value):
+        return value.lower() if isinstance(value, str) else value
+
     def extract_valid_address(self):
         occurrence_time = self._get_occurance_date_time()
         patient = self._get_patient()
@@ -262,21 +265,23 @@ def extract_valid_address(self):
         if not isinstance(addresses, list) or not addresses:
             return self.DEFAULT_POSTCODE
 
-        valid_addresses = [a for a in addresses if "postalCode" in a and self._is_current_period(a, occurrence_time)]
-        
-        if len(valid_addresses) > 0:
-            selected_address = next(
-                (a for a in valid_addresses if a.get("use") == "home" and a.get("type") != "postal"),
-                next(
-                    (a for a in valid_addresses if a.get("use") != "old" and a.get("type") != "postal"),
-                    next((a for a in valid_addresses if a.get("use") != "old"), valid_addresses[0]),
-                ),
-            )
-            post_code = selected_address.get("postalCode", self.DEFAULT_POSTCODE)
-            if post_code: 
-                return post_code
-            
-        return addresses[0].get("postalCode", self.DEFAULT_POSTCODE) if addresses else self.DEFAULT_POSTCODE
+        if len(addresses) == 1:
+            return addresses[0].get("postalCode") or self.DEFAULT_POSTCODE
+
+        if not (valid_addresses := [
+            addr for addr in addresses
+            if addr.get("postalCode") and self._is_current_period(addr, occurrence_time)
+        ]):
+            return self.DEFAULT_POSTCODE
+
+        selected_address = (
+            next((a for a in valid_addresses if self.normalize(a.get("use")) == "home" and self.normalize(a.get("type")) != "postal"), None)
+            or next((a for a in valid_addresses if self.normalize(a.get("use")) != "old" and self.normalize(a.get("type")) != "postal"), None)
+            or next((a for a in valid_addresses if self.normalize(a.get("use")) != "old"), None)
+            or valid_addresses[0]
+        )
+
+        return selected_address.get("postalCode") or self.DEFAULT_POSTCODE
     
     def extract_date_time(self) -> str: 
         date = self.fhir_json_data.get("occurrenceDateTime","")
diff --git a/delta_backend/tests/sample_data/fhir_sample.json b/delta_backend/tests/sample_data/fhir_sample.json
@@ -30,13 +30,41 @@
       "gender": "other",
       "birthDate": "2026-03-10",
       "address": [
-        {
-          "use": "home",
-          "line": ["123 High Street"],
-          "city": "London",
-          "postalCode": "SW1A 1AA"
-        }
-      ]
+    {
+      "use": "work",
+      "type": "both",
+      "text": "Validate Obf",
+      "line": [
+        "1, work_2"
+      ],
+      "city": "work_3",
+      "district": "work_4",
+      "state": "work_5",
+      "country": "work_7",
+      "postalCode": "LS8 4ED",
+      "period": {
+        "start": "2000-01-01",
+        "end": "2030-01-01"
+      }
+    },
+    {
+      "use": "Home",
+      "type": "Physical",
+      "text": "Validate Obf",
+      "line": [
+        "1, obf_2"
+      ],
+      "city": "obf_3",
+      "district": "obf_4",
+      "state": "obf_5",
+      "postalCode": "WF8 4ED",
+      "country": "obf_7",
+      "period": {
+        "start": "2000-01-01",
+        "end": "2030-01-01"
+      }
+    }
+  ]
     }
   ],
   "extension": [
diff --git a/delta_backend/tests/test_convert_post_code.py b/delta_backend/tests/test_convert_post_code.py
@@ -24,6 +24,12 @@ def test_person_postal_code_single_address(self):
                 "type": "physical",
                 "period": {"start": "2018-01-01", "end": "2020-12-31"},
         }]
+
+    def test_person_postal_code_single_address_only_postal_code(self):
+        """Test case where only one address instance exists with one postalCode"""
+        self.request_json_data["contained"][1]["address"] = [{
+            "postalCode": "AB12 3CD",
+        }]
         
         expected_postal_code = "AB12 3CD"
         self._run_postal_code_test(expected_postal_code)
@@ -94,6 +100,25 @@ def test_person_postal_code_fallback_first_non_old(self):
         expected_postal_code = "KK20 2KK"
         self._run_postal_code_test(expected_postal_code)
 
+    def test_person_postal_code_case_insensitive_match(self):
+        """Test case where 'use' and 'type' values require case-insensitive comparison"""
+        self.request_json_data["contained"][1]["address"] = [
+            {
+                "postalCode": "LS8 4ED",
+                "use": "work",
+                "type": "both",
+                "period": {"start": "2000-01-01", "end": "2023-01-01"},
+            },
+            {
+                "postalCode": "WF8 4ED",
+                "use": "Home",  # capital H
+                "type": "Physical",  # capital P
+                "period": {"start": "2000-01-01", "end": "2023-01-01"},
+            }
+        ]
+        expected_postal_code = "WF8 4ED"
+        self._run_postal_code_test(expected_postal_code)
+
     def test_person_postal_code_default_to_ZZ99_3CZ(self):
         """Test case where no valid postalCode is found, should default to ZZ99 3CZ"""
         self.request_json_data["contained"][1]["address"] = [
@@ -103,6 +128,22 @@ def test_person_postal_code_default_to_ZZ99_3CZ(self):
         expected_postal_code = "ZZ99 3CZ"
         self._run_postal_code_test(expected_postal_code)
 
+    def test_person_postal_code_blank_string_should_fallback(self):
+        """Test case where postalCode is an empty string — should fallback to ZZ99 3CZ"""
+        self.request_json_data["contained"][1]["address"] = [
+            {"postalCode": "", 
+             "use": "home", 
+             "type": "physical",
+             "period": {"start": "2018-01-01", "end": "2030-12-31"},
+             },
+        ]
+        expected_postal_code = "ZZ99 3CZ"
+        self._run_postal_code_test(expected_postal_code)
+        assert "postalCode" in self.request_json_data["contained"][1]["address"][0]
+        assert self.request_json_data["contained"][1]["address"][0]["postalCode"] == ""
+
+
+   
     def _run_postal_code_test(self, expected_postal_code):
         """Helper function to run the test"""
         self.converter = Converter(json.dumps(self.request_json_data))
