VED-348-names (#577)

Akol125 · web-flow · commit 9c1e1f2effd7 · 2025-06-11T11:44:20.000+01:00
Fix name for delta conversion
diff --git a/delta_backend/src/extractor.py b/delta_backend/src/extractor.py
@@ -28,32 +28,29 @@ def _get_patient(self):
         contained = self.fhir_json_data.get("contained", [])
         return next((c for c in contained if isinstance(c, dict) and c.get("resourceType") == "Patient"), "")
 
-    def _get_valid_names(self, names, occurrence_time, resource_type="Patient"):
-        
-        def has_required_fields(name):
-            return "given" in name and "family" in name if resource_type == "Patient" else True
+    def _get_valid_names(self, names, occurrence_time):
         
         official_names = [n for n in names if n.get("use") == "official" and self._is_current_period(n, occurrence_time)]
         if official_names:
-            filtered_official_names = [n for n in official_names if has_required_fields(n)]
-            return filtered_official_names[0]
+            return official_names[0]
 
         valid_names = [n for n in names if self._is_current_period(n, occurrence_time) and n.get("use") != "old"]
-        filtered_valid_names = [n for n in valid_names if has_required_fields(n)]
+        if valid_names:
+            return valid_names[0]
         
-        return filtered_valid_names[0] if filtered_valid_names else names[0]
+        return names[0] 
             
 
 
     def _get_person_names(self):
         occurrence_time = self._get_occurance_date_time()
         patient = self._get_patient()
         names = patient.get("name", [])
-
-        if not isinstance(names, list) or not names:
+        names = [n for n in names if "given" in n and "family" in n]
+        if not names:
             return "", ""
 
-        selected_name = self._get_valid_names(names, occurrence_time, resource_type="Patient")
+        selected_name = self._get_valid_names(names, occurrence_time)
         person_forename = " ".join(selected_name.get("given", []))
         person_surname = selected_name.get("family", "")
 
@@ -74,7 +71,7 @@ def _get_practitioner_names(self):
         if not valid_practitioner_names:
             return "", ""
 
-        selected_practitioner_name = self._get_valid_names(valid_practitioner_names, occurrence_time, resource_type="Practitioner")
+        selected_practitioner_name = self._get_valid_names(valid_practitioner_names, occurrence_time)
         performing_professional_forename = " ".join(selected_practitioner_name.get("given", []))
         performing_professional_surname = selected_practitioner_name.get("family", "")
 
diff --git a/delta_backend/tests/sample_data/fhir_sample.json b/delta_backend/tests/sample_data/fhir_sample.json
@@ -6,11 +6,39 @@
       "resourceType": "Practitioner",
       "id": "Pract1",
       "name": [
-        {
-          "family": "Nightingale",
-          "given": ["Florence"]
-        }
-      ]
+    {
+      "family": "Furlong old 1",
+      "given": [
+        "Darren 2", "old use value"
+      ],
+      "period": {
+        "start": "2000-01-01",
+        "end": "2030-01-01"
+      }
+    },
+    {
+      "family": "Furlong old",
+      "given": [
+        "Darren", "old use value"
+      ],
+      "use": "old",
+      "period": {
+        "start": "2000-01-01",
+        "end": "2030-01-01"
+      }
+    },
+    {
+      "family": "Furlong official",
+      "given": [
+        "Darren", "Official"
+      ],
+      "use": "official",
+      "period": {
+        "start": "2000-01-01",
+        "end": "2030-01-01"
+      }
+    }
+     ]
     },
     {
       "resourceType": "Patient",
@@ -22,11 +50,43 @@
         }
       ],
       "name": [
-        {
-          "family": "Taylor",
-          "given": ["Sarah"]
-        }
-      ],
+            {
+                "use": "home",
+                "text": "hello pat1",
+                "family": "test10 ",
+                "given": [
+                 "test11", "test12", "test13"
+                ],
+                "period":   {
+                    "start" : "2000-01-01",
+                    "end" : "2026-01-01"
+                    }                
+            },
+            {
+                "use": "official",
+                "text": "hello pat2",
+                "family": "test12",
+                "given": [
+                 "test13", "test14", "test15"
+                ],
+                "period":   {
+                    "start" : "2000-01-01",
+                    "end" : "2026-01-01"
+                    }                
+            },
+            {
+                "use": "old",
+                "text": "hello pat3",
+                "family": "test14",
+                "given": [
+                    "test15", "test16", "test17"
+                ],
+                "period":   {
+                    "start" : "2000-01-01",
+                    "end" : "2026-01-01"
+                    }                
+            }                        
+        ],
       "gender": "other",
       "birthDate": "2026-03-10",
       "address": [
@@ -115,7 +175,7 @@
   "patient": {
     "reference": "#Pat1"
   },
-  "occurrenceDateTime": "2025-04-06T13:28:17.271+02:00",
+  "occurrenceDateTime": "2025-03-06T13:28:17.2+01:00",
   "recorded": "2025-01-01T00:00:00.000000",
   "primarySource": "True",
   "manufacturer": {
@@ -129,7 +189,7 @@
     }
   },
   "lotNumber": "4120Z001",
-  "expirationDate": "2024-10-05",
+  "expirationDate": "2025-07-02",
 
   "site": {
     "coding": [
diff --git a/delta_backend/tests/test_convert_person_forename.py b/delta_backend/tests/test_convert_person_forename.py
@@ -6,6 +6,13 @@
 from common.mappings import ConversionFieldName
 
 class TestPersonForenmeToFlatJson(unittest.TestCase):
+    """"
+    Test cases for converting person forename to flat JSON format.
+    ## 1. If there is only one name use that one, else
+    ## 2. Select first name where Use=official with period covering vaccination date, else
+    ## 3. select instance where current name with use!=old at vaccination date
+    ## 4. Fallback to first available name instance
+    """
     
     def setUp(self):
         self.request_json_data = copy.deepcopy(ValuesForTests.json_data)
@@ -104,6 +111,23 @@ def test_person_forename_multiple_given_names_concatenation(self):
         expected_forename = "Alice Marie"
         self._run_test(expected_forename)
 
+    def test_person_forename_where_names_only_exist_when_use_isequal_to_old(self):
+        """Test case where only available name is selected name where use=old"""
+        self.request_json_data["contained"][1]["name"] = [
+            {
+                "use": "official",
+                "period": {"start": "2021-01-01", "end": "2023-01-01"},
+            },
+            {
+                "family": "Doe",
+                "given": ["Alice", "Marie"],
+                "use": "old",
+                "period": {"start": "2021-01-01", "end": "2022-12-31"},
+            },
+        ]
+        expected_forename = "Alice Marie"
+        self._run_test(expected_forename)
+
     def test_person_forename_exists_only(self):
         """Test case where the selected name has multiple given names"""
         self.request_json_data["contained"][1]["name"] = [
diff --git a/delta_backend/tests/test_convert_person_surname.py b/delta_backend/tests/test_convert_person_surname.py
@@ -6,6 +6,13 @@
 from common.mappings import ConversionFieldName
 
 class TestPersonSurnameToFlatJson(unittest.TestCase):
+    """"
+    Test cases for converting person surname to flat JSON format.
+    ## 1. If there is only one name use that one, else
+    ## 2. Select first name where Use=official with period covering vaccination date, else
+    ## 3. select instance where current name with use!=old at vaccination date
+    ## 4. Fallback to first available name instance
+    """
 
     def setUp(self):
         self.request_json_data = copy.deepcopy(ValuesForTests.json_data)
@@ -50,6 +57,23 @@ def test_person_surname_multiple_names_current(self):
         expected_surname = "Manny"
         self._run_test_surname(expected_surname)
 
+    def test_person_surname_where_names_only_exist_when_use_isequal_to_old(self):
+        """Test case where only available name is selected name where use=old"""
+        self.request_json_data["contained"][1]["name"] = [
+            {
+                "use": "official",
+                "period": {"start": "2021-01-01", "end": "2023-01-01"},
+            },
+            {
+                "family": "Manny",
+                "given": ["Alice", "Marie"],
+                "use": "old",
+                "period": {"start": "2021-01-01", "end": "2022-12-31"},
+            },
+        ]
+        expected_surname = "Manny"
+        self._run_test_surname(expected_surname)
+
     def test_person_surname_single_name(self):
         """Test case where only one name instance exists"""
         self.request_json_data["contained"][1]["name"] = [{"family": "Doe", "given": ["Alex"], "use": "nickname"}]
