PDS

cpd

Author: nhsdevws

immunisation-fhir-api.code-workspace

@@ -1,41 +1,41 @@
 {
 	"folders": [
-        {
-            "path": "."
-        },
-        {
-            "path": "backend"
-        },
-        {
-            "path": "filenameprocessor"
-        },
-        {
-            "path": "recordprocessor"
-        },
-        {
-            "path": "ack_backend"
-        },
-        {
-            "path": "delta_backend"
-        },
-        {
-            "path": "mesh_processor"
-        },
-        {
-            "path": "e2e"
-        },
-        {
-            "path": "e2e_batch"
-        },
-        {
-            "path": "redis_sync"
-        },
-        {
-            "path": "lambdas/id_sync"
-        },
-        {
-            "path": "lambdas/shared"
-        }
-    ],
-	"settings": {},
+		{
+			"path": "."
+		},
+		{
+			"path": "backend"
+		},
+		{
+			"path": "filenameprocessor"
+		},
+		{
+			"path": "recordprocessor"
+		},
+		{
+			"path": "ack_backend"
+		},
+		{
+			"path": "delta_backend"
+		},
+		{
+			"path": "mesh_processor"
+		},
+		{
+			"path": "e2e"
+		},
+		{
+			"path": "e2e_batch"
+		},
+		{
+			"path": "redis_sync"
+		},
+		{
+			"path": "lambdas/id_sync"
+		},
+		{
+			"path": "lambdas/shared"
+		}
+	],
+	"settings": {}
 }

lambdas/id_sync/src/clients.py

@@ -0,0 +1,4 @@
+import os
+
+
+pds_env: str = os.getenv("PDS_ENV", "int")

lambdas/id_sync/src/pds_details.py

@@ -0,0 +1,29 @@
+'''
+    record Processor
+'''
+from common.clients import logger, secrets_manager_client
+from clients import pds_env
+from cache import Cache
+from common.pds_service import PdsService
+from common.authentication import AppRestrictedAuth, Service
+
+
+def get_pds_patient_details(id: str) -> dict:
+    try:
+        logger.info(f"Get PDS patient details for {id}")
+
+        cache = Cache(directory="/tmp")
+        authenticator = AppRestrictedAuth(
+            service=Service.PDS,
+            secret_manager_client=secrets_manager_client,
+            environment=pds_env,
+            cache=cache,
+        )
+        pds_service = PdsService(authenticator, pds_env)
+
+        details = pds_service.get_patient_details(id)
+
+        return details.get("id")
+    except Exception:
+        logger.exception(f"Error getting PDS patient details for {id}")
+        return None

lambdas/id_sync/src/record_processor.py

@@ -6,6 +6,7 @@
 import json
 from typing import Optional
 
+
 def process_record(event_record: AwsLambdaSqsEventRecord):
     record = AwsLambdaSqsEventRecord(event_record) if isinstance(event_record, dict) else event_record
     logger.info("Processing record: %s", record)
@@ -14,7 +15,47 @@ def process_record(event_record: AwsLambdaSqsEventRecord):
 
     exists = check_records_exist(id)
 
-    return f"hello world {record}"
+    if exists:
+        # get patient details from PDS
+        patient_details = get_pds_patient_details(id)
+
+        patient_details_id = patient_details.get("id")
+
+        # if patient NHS != id, update patient index of vax events to new number
+        if patient_details_id != id:
+            return update_patient_index(id, patient_details_id)
+        else:
+            return {"status": "success", "message": "No update required"}
+    else:
+        return {"status": "error", "message": f"No records found for ID: {id}"}
+
+
+def check_records_exist(id: str) -> bool:
+    # TODO: Implement logic to check if records exist in the database
+    logger.info(f"TODO Check if records exist for {id}")
+    return False
+
+
+def get_pds_patient_details(id: str) -> dict:
+    # TODO: Implement logic to retrieve patient details from PDS
+    logger.info(f"TODO Get patient details for {id}")
+
+    authenticator = AppRestrictedAuth(
+        service=Service.PDS,
+        secret_manager_client=boto3.client("secretsmanager", config=boto_config),
+        environment=pds_env,
+        cache=cache,
+    )
+    pds_service = PdsService(authenticator, pds_env)
+
+
+    return {"id": id, "name": "Mr Man"}
+
+
+def update_patient_index(old_id: str, new_id: str):
+    # TODO: Implement logic to update patient index in Redis or other data store
+    logger.info(f"TODO Update patient index from {old_id} to {new_id}")
+    return {"status": "success", "message": f"Updated patient idx from {old_id} to {new_id}", "TODO": "Implement logic"}
 
 
 def get_id(event_body) -> Optional[str]:
@@ -26,34 +67,8 @@ def get_id(event_body) -> Optional[str]:
         else:
             data = event_body
         # Navigate through the nested structure
-        entries = data.get("entry", [])
-        if not entries:
-            logger.warning("No entries found in bundle")
-            return None
-
-        # Get the first entry's resource
-        first_entry = entries[0]
-        resource = first_entry.get("resource", {})
-        parameters = resource.get("parameter", [])
-
-        # Find the "additional-context" parameter
-        for param in parameters:
-            if param.get("name") == "additional-context":
-                parts = param.get("part", [])
-
-                # Find the "subject" part within additional-context
-                for part in parts:
-                    if part.get("name") == "subject":
-                        value_ref = part.get("valueReference", {})
-                        identifier = value_ref.get("identifier", {})
-                        subject_id = identifier.get("value")
-
-                        if subject_id:
-                            logger.info("Found subject identifier: %s", subject_id)
-                            return subject_id
-
-        logger.warning("Subject identifier not found in notification event")
-        return None
+        subject = data.get("subject")
+        return subject
 
     except (json.JSONDecodeError, KeyError, AttributeError) as e:
         logger.error("Error extracting subject identifier: %s", e)

lambdas/id_sync/tests/test_pds_details.py

@@ -0,0 +1,171 @@
+import unittest
+from unittest.mock import patch, MagicMock
+from pds_details import get_pds_patient_details
+
+
+class TestGetPdsPatientDetails(unittest.TestCase):
+
+    def setUp(self):
+        """Set up test fixtures and mocks"""
+        # Mock the dependencies
+        self.mock_boto3_client = MagicMock()
+        self.test_patient_id = "9912003888"
+
+        # Patch all external dependencies
+        self.logger_patcher = patch('pds_details.logger')
+        self.mock_logger = self.logger_patcher.start()
+
+        self.secrets_manager_patcher = patch('pds_details.secrets_manager_client')
+        self.mock_secrets_manager = self.secrets_manager_patcher.start()
+
+        self.pds_env_patcher = patch('pds_details.pds_env')
+        self.mock_pds_env = self.pds_env_patcher.start()
+
+        self.cache_patcher = patch('pds_details.Cache')
+        self.mock_cache_class = self.cache_patcher.start()
+        self.mock_cache_instance = MagicMock()
+        self.mock_cache_class.return_value = self.mock_cache_instance
+
+        self.auth_patcher = patch('pds_details.AppRestrictedAuth')
+        self.mock_auth_class = self.auth_patcher.start()
+        self.mock_auth_instance = MagicMock()
+        self.mock_auth_class.return_value = self.mock_auth_instance
+
+        self.pds_service_patcher = patch('pds_details.PdsService')
+        self.mock_pds_service_class = self.pds_service_patcher.start()
+        self.mock_pds_service_instance = MagicMock()
+        self.mock_pds_service_class.return_value = self.mock_pds_service_instance
+
+    def tearDown(self):
+        """Clean up patches"""
+        patch.stopall()
+
+    def test_get_pds_patient_details_success(self):
+        """Test successful retrieval of patient details"""
+        # Arrange
+        expected_patient_data = {
+            "id": "9912003888",
+            "name": "John Doe",
+            "birthDate": "1990-01-01",
+            "gender": "male"
+        }
+        self.mock_pds_service_instance.get_patient_details.return_value = expected_patient_data
+
+        # Act
+        result = get_pds_patient_details(self.test_patient_id, self.mock_boto3_client)
+
+        # Assert
+        self.assertEqual(result, "9912003888")
+
+        # Verify Cache was initialized correctly
+        self.mock_cache_class.assert_called_once_with(directory="/tmp")
+
+        # Verify AppRestrictedAuth was initialized correctly
+        from common.authentication import Service
+        self.mock_auth_class.assert_called_once_with(
+            service=Service.PDS,
+            secret_manager_client=self.mock_secrets_manager,
+            environment=self.mock_pds_env,
+            cache=self.mock_cache_instance
+        )
+
+        # Verify PdsService was initialized correctly
+        self.mock_pds_service_class.assert_called_once_with(
+            self.mock_auth_instance,
+            self.mock_pds_env
+        )
+
+        # Verify get_patient_details was called
+        self.mock_pds_service_instance.get_patient_details.assert_called_once_with(self.test_patient_id)
+
+    def test_get_pds_patient_details_missing_id_in_response(self):
+        """Test when PDS response doesn't contain 'id' field"""
+        # Arrange
+        patient_data_without_id = {
+            "name": "John Doe",
+            "birthDate": "1990-01-01",
+            "gender": "male"
+            # Missing 'id' field
+        }
+        self.mock_pds_service_instance.get_patient_details.return_value = patient_data_without_id
+
+        # Act
+        result = get_pds_patient_details(self.test_patient_id, self.mock_boto3_client)
+
+        # Assert
+        self.assertIsNone(result)
+        self.mock_pds_service_instance.get_patient_details.assert_called_once_with(self.test_patient_id)
+
+    def test_get_pds_patient_details_empty_response(self):
+        """Test when PDS returns empty response"""
+        # Arrange
+        self.mock_pds_service_instance.get_patient_details.return_value = {}
+
+        # Act
+        result = get_pds_patient_details(self.test_patient_id, self.mock_boto3_client)
+
+        # Assert
+        self.assertIsNone(result)
+        self.mock_pds_service_instance.get_patient_details.assert_called_once_with(self.test_patient_id)
+
+    def test_get_pds_patient_details_none_response(self):
+        """Test when PDS returns None"""
+        # Arrange
+        self.mock_pds_service_instance.get_patient_details.return_value = None
+
+        # Act
+        with self.assertRaises(AttributeError):
+            get_pds_patient_details(self.test_patient_id, self.mock_boto3_client)
+
+        # Assert
+        self.mock_pds_service_instance.get_patient_details.assert_called_once_with(self.test_patient_id)
+
+    def test_get_pds_patient_details_pds_service_exception(self):
+        """Test when PdsService.get_patient_details raises an exception"""
+        # Arrange
+        self.mock_pds_service_instance.get_patient_details.side_effect = Exception("PDS API error")
+
+        # Act & Assert
+        with self.assertRaises(Exception) as context:
+            get_pds_patient_details(self.test_patient_id, self.mock_boto3_client)
+
+        self.assertEqual(str(context.exception), "PDS API error")
+        self.mock_pds_service_instance.get_patient_details.assert_called_once_with(self.test_patient_id)
+
+    def test_get_pds_patient_details_cache_initialization_error(self):
+        """Test when Cache initialization fails"""
+        # Arrange
+        self.mock_cache_class.side_effect = OSError("Cannot write to /tmp")
+
+        # Act & Assert
+        with self.assertRaises(OSError) as context:
+            get_pds_patient_details(self.test_patient_id, self.mock_boto3_client)
+
+        self.assertEqual(str(context.exception), "Cannot write to /tmp")
+        self.mock_cache_class.assert_called_once_with(directory="/tmp")
+
+    def test_get_pds_patient_details_auth_initialization_error(self):
+        """Test when AppRestrictedAuth initialization fails"""
+        # Arrange
+        self.mock_auth_class.side_effect = ValueError("Invalid authentication parameters")
+
+        # Act & Assert
+        with self.assertRaises(ValueError) as context:
+            get_pds_patient_details(self.test_patient_id, self.mock_boto3_client)
+
+        self.assertEqual(str(context.exception), "Invalid authentication parameters")
+
+    def test_get_pds_patient_details_exception(self):
+        """Test when an exception occurs"""
+        # Arrange
+        self.mock_logger.info.side_effect = Exception("Logging system failure")
+
+        # Act
+        result = get_pds_patient_details(self.test_patient_id, self.mock_boto3_client)
+
+        # Assert
+        self.assertIsNone(result)
+
+        # Verify logger.exception was called due to the caught exception
+        self.mock_logger.exception.assert_called_once_with(
+            f"Error getting PDS patient details for {self.test_patient_id}")