[PRMP-1475] Implement GetUserInformation Lambda

.github/workflows/base-lambdas-reusable-deploy-all.yml

@@ -880,3 +880,18 @@ jobs:
       lambda_layer_names: "core_lambda_layer"
     secrets:
       AWS_ASSUME_ROLE: ${{ secrets.AWS_ASSUME_ROLE }}
+
+  deploy_get_user_information_lambda:
+    name: Deploy Concurrency Controller Lambda
+    uses: ./.github/workflows/base-lambdas-reusable-deploy.yml
+    with:
+      environment: ${{ inputs.environment }}
+      python_version: ${{ inputs.python_version }}
+      build_branch: ${{ inputs.build_branch }}
+      sandbox: ${{ inputs.sandbox }}
+      lambda_handler_name: get_user_information_handler
+      lambda_aws_name: GetUserInformation
+      lambda_layer_names: "core_lambda_layer"
+      lambda_handler_path: user_restrictions
+    secrets:
+      AWS_ASSUME_ROLE: ${{ secrets.AWS_ASSUME_ROLE }}

lambdas/enums/lambda_error.py

@@ -662,6 +662,19 @@ def create_error_body(
 
     EdgeNoClient = {"err_code": "CE_4001", "message": "Document not found"}
 
+    """
+        Errors for User Restrictions feature
+    """
+    UserRestrictionInvalidEvent = {
+        "err_code": "UR_4001",
+        "message": "Malformed user restriction event",
+    }
+
+    UserRestrictionModelValidationError = {
+        "err_code": "UR_5001",
+        "message": "Malformed user restriction model error",
+    }
+
     """
        Errors with no exception
     """

lambdas/handlers/user_restrictions/get_user_information_handler.py

@@ -0,0 +1,55 @@
+import json
+
+from enums.lambda_error import LambdaError
+from services.user_restrictions.utilites import get_healthcare_worker_api_service
+from utils.audit_logging_setup import LoggingService
+from utils.decorators.ensure_env_var import ensure_environment_variables
+from utils.decorators.handle_lambda_exceptions import handle_lambda_exceptions
+from utils.exceptions import (
+    HealthcareWorkerAPIException,
+    HealthcareWorkerPractitionerModelException,
+)
+from utils.lambda_response import ApiGatewayResponse
+
+logger = LoggingService(__name__)
+
+
+@ensure_environment_variables(
+    names=[
+        "HEALTHCARE_WORKER_API_URL",
+        "USE_MOCK_HEALTHCARE_SERVICE",
+    ],
+)
+@handle_lambda_exceptions
+def lambda_handler(event, context):
+    try:
+        logger.info("Processing request to retrieve user information.")
+        identifier = event.get("querystringParameters", {}).get("identifier")
+
+        if not identifier:
+            logger.error("No identifier provided.")
+            return ApiGatewayResponse(
+                400,
+                LambdaError.UserRestrictionInvalidEvent.create_error_body(),
+                "GET",
+            ).create_api_gateway_response()
+
+        healthcare_worker_api_service = get_healthcare_worker_api_service()
+
+        practitioner_information = healthcare_worker_api_service.get_practitioner(
+            identifier=identifier,
+        )
+        logger.info("Returning user information.")
+        return ApiGatewayResponse(
+            200,
+            json.dumps(practitioner_information.model_dump_camel_case()),
+            "GET",
+        ).create_api_gateway_response()
+    except HealthcareWorkerAPIException as e:
+        return ApiGatewayResponse(502, e.message, "GET").create_api_gateway_response()
+    except HealthcareWorkerPractitionerModelException:
+        return ApiGatewayResponse(
+            500,
+            LambdaError.UserRestrictionModelValidationError.create_error_body(),
+            "GET",
+        ).create_api_gateway_response()

lambdas/models/user_restrictions/practitioner.py

@@ -1,7 +1,15 @@
 from pydantic import BaseModel
+from pydantic.alias_generators import to_camel
 
 
 class Practitioner(BaseModel):
     first_name: str
     last_name: str
     smartcard_id: str
+
+    def model_dump_camel_case(self, *args, **kwargs):
+        model_dump_results = self.model_dump(*args, **kwargs)
+        camel_case_model_dump_results = {}
+        for key in model_dump_results:
+            camel_case_model_dump_results[to_camel(key)] = model_dump_results[key]
+        return camel_case_model_dump_results

lambdas/services/authoriser_service.py

@@ -155,6 +155,9 @@ def deny_access_policy(self, path, http_verb, user_role, nhs_number: str = None)
                     not patient_access_is_allowed or is_user_gp_clinical or is_user_pcse
                 )
 
+            case "/UserRestriction/SearchUser":
+                deny_resource = False
+
             case _:
                 deny_resource = not patient_access_is_allowed
 

lambdas/services/user_restrictions/healthcare_worker_service.py

@@ -48,20 +48,20 @@ def get_practitioner(self, identifier: str) -> Practitioner:
             body = response.json()
             return self.build_practitioner(body)
 
-        except requests.exceptions.HTTPError as err:
+        except requests.exceptions.HTTPError as e:
             raise HealthcareWorkerAPIException(
-                status_code=err.response.status_code,
+                status_code=e.response.status_code,
             )
-        except (ValidationError, KeyError) as err:
-            logger.error(err)
+        except (ValidationError, KeyError) as e:
+            logger.error(e)
             raise HealthcareWorkerPractitionerModelException
 
     def build_practitioner(self, response: dict) -> Practitioner:
         if response["total"] > 1:
             logger.info("Received more than on entry for practitioner.")
             raise HealthcareWorkerPractitionerModelException
 
-        logger.info("Getting practitioner model.")
+        logger.info("Creating practitioner model with user information.")
         entry = response["entry"][0]
 
         practitioner_id = entry["resource"]["id"]

lambdas/tests/unit/conftest.py

@@ -255,6 +255,7 @@ def set_env(monkeypatch):
     monkeypatch.setenv("EDGE_REFERENCE_TABLE", MOCK_EDGE_REFERENCE_TABLE)
     monkeypatch.setenv("REVIEW_SQS_QUEUE_URL", REVIEW_SQS_QUEUE_URL)
     monkeypatch.setenv("HEALTHCARE_WORKER_API_URL", HEALTHCARE_WORKER_API_URL)
+    monkeypatch.setenv("USE_MOCK_HEALTHCARE_SERVICE", "true")
 
 
 EXPECTED_PARSED_PATIENT_BASE_CASE = PatientDetails(

lambdas/tests/unit/handlers/user_restrictions/test_get_user_information_handler.py

@@ -0,0 +1,143 @@
+import json
+
+import pytest
+
+from enums.lambda_error import LambdaError
+from handlers.user_restrictions.get_user_information_handler import lambda_handler
+from services.mock_data.user_restrictions.build_mock_data import (
+    build_mock_response_and_practitioner,
+)
+from tests.unit.services.user_restriction.conftest import MOCK_IDENTIFIER
+from utils.exceptions import (
+    HealthcareWorkerAPIException,
+    HealthcareWorkerPractitionerModelException,
+)
+from utils.lambda_response import ApiGatewayResponse
+
+
+@pytest.fixture
+def mock_healthcare_worker_api_service(mocker):
+    mocked_class = mocker.patch(
+        "handlers.user_restrictions.get_user_information_handler.get_healthcare_worker_api_service",
+    )
+    mocked_instance = mocked_class.return_value
+    yield mocked_instance
+
+
+@pytest.fixture
+def mock_valid_event(event):
+    event["querystringParameters"] = {
+        "identifier": MOCK_IDENTIFIER,
+    }
+    yield event
+
+
+@pytest.fixture
+def mock_invalid_event_missing_identifier(event):
+    event["querystringParameters"] = {
+        "no_identifier": "abcdef",
+    }
+    yield event
+
+
+@pytest.fixture
+def mock_invalid_event_empty_querystring(event):
+    event["querystringParameters"] = {}
+    yield event
+
+
+def test_lambda_handler_happy_path(
+    mock_healthcare_worker_api_service,
+    monkeypatch,
+    context,
+    mock_valid_event,
+    set_env,
+):
+    _, _, mock_practitioner = build_mock_response_and_practitioner(MOCK_IDENTIFIER)
+    mock_healthcare_worker_api_service.get_practitioner.return_value = mock_practitioner
+
+    expected = ApiGatewayResponse(
+        200,
+        json.dumps(mock_practitioner.model_dump_camel_case()),
+        "GET",
+    ).create_api_gateway_response()
+
+    actual = lambda_handler(mock_valid_event, context)
+
+    mock_healthcare_worker_api_service.get_practitioner.assert_called_with(
+        identifier=MOCK_IDENTIFIER,
+    )
+    assert actual == expected
+
+
+def test_lambda_handler_returns_400_invalid_event(
+    mock_healthcare_worker_api_service,
+    context,
+    event,
+    mock_invalid_event_missing_identifier,
+    mock_invalid_event_empty_querystring,
+    set_env,
+):
+
+    invalid_events = [
+        event,
+        mock_invalid_event_missing_identifier,
+        mock_invalid_event_empty_querystring,
+    ]
+    expected_body = LambdaError.UserRestrictionInvalidEvent.create_error_body()
+
+    expected = ApiGatewayResponse(
+        400,
+        expected_body,
+        "GET",
+    ).create_api_gateway_response()
+
+    for invalid_event in invalid_events:
+        actual = lambda_handler(invalid_event, context)
+
+        assert expected == actual
+
+
+@pytest.mark.parametrize("status_code", [400, 404, 500, 403, 401])
+def test_lambda_handler_handles_non_200_response_from_get_practitioner(
+    mock_healthcare_worker_api_service,
+    mock_valid_event,
+    context,
+    status_code,
+    set_env,
+):
+    api_error = HealthcareWorkerAPIException(status_code=status_code)
+
+    mock_healthcare_worker_api_service.get_practitioner.side_effect = api_error
+    expected_body = api_error.message
+
+    expected = ApiGatewayResponse(
+        502,
+        expected_body,
+        "GET",
+    ).create_api_gateway_response()
+
+    actual = lambda_handler(mock_valid_event, context)
+
+    assert actual == expected
+
+
+def test_lambda_handler_handles_validation_error_from_get_practitioner(
+    mock_healthcare_worker_api_service,
+    mock_valid_event,
+    context,
+    set_env,
+):
+    mock_healthcare_worker_api_service.get_practitioner.side_effect = (
+        HealthcareWorkerPractitionerModelException
+    )
+
+    expected = ApiGatewayResponse(
+        500,
+        LambdaError.UserRestrictionModelValidationError.create_error_body(),
+        "GET",
+    ).create_api_gateway_response()
+
+    actual = lambda_handler(mock_valid_event, context)
+
+    assert actual == expected

lambdas/tests/unit/services/user_restriction/test_healthcare_work_service.py

@@ -162,10 +162,6 @@ def test_get_practitioner_handles_key_error(mocker, mock_service, mock_get):
         mock_service.get_practitioner(MOCK_IDENTIFIER)
 
 
-def test_service_calls_ssm_for_token_each_call_to_api(mock_service):
-    pass
-
-
 def test_build_practitioner_returns_practitioner_model_instance(mock_service):
     _, mock_response, expected = build_mock_response_and_practitioner(MOCK_IDENTIFIER)
 

lambdas/utils/lambda_exceptions.py

@@ -132,3 +132,7 @@ class UpdateDocumentReviewException(LambdaException):
 
 class ReportDistributionException(LambdaException):
     pass
+
+
+class UserRestrictionsException(LambdaException):
+    pass