Merge branch 'feature/PI-577-create_message_set_drd' into release/2024-10-29

Author: jaklinger

infrastructure/swagger/05_paths.yaml

@@ -339,6 +339,49 @@ paths:
         - ${authoriser_name}: []
         - app-level0: []
 
+  ? /ProductTeam/{product_team_id}/Product/{product_id}/DeviceReferenceData/MhsMessageSet
+  : post:
+      operationId: createDeviceReferenceDataMessageSet
+      summary: createDeviceReferenceDataMessageSet endpoint for APIGEE integration
+      parameters:
+        - name: product_team_id
+          in: path
+          required: true
+          description: logical identifier
+          schema:
+            type: string
+        - name: product_id
+          in: path
+          required: true
+          description: logical identifier
+          schema:
+            type: string
+        - *RequestHeaderVersion
+        - *RequestHeaderRequestId
+        - *RequestHeaderCorrelationId
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                questionnaire_responses:
+                  type: object
+                  description: Questionnaire Responses for MHS Message Set questionnaire
+      responses:
+        responses:
+        "201":
+          <<: *Response201
+        "4XX":
+          <<: *Response4XX
+      x-amazon-apigateway-integration:
+        <<: *ApiGatewayIntegration
+        uri: ${method_createDeviceReferenceDataMessageSet}
+      security:
+        - ${authoriser_name}: []
+        - app-level0: []
+
   ? /ProductTeam/{product_team_id}/Product/{product_id}/DeviceReferenceData/{device_reference_data_id}
   : get:
       operationId: readDeviceReferenceData

pyproject.toml

@@ -27,6 +27,7 @@ urllib3 = "<3"
 orjson = "^3.9.15"
 attrs = "^24.2.0"
 locust = "^2.29.1"
+jsonschema = "^4.23.0"
 
 [tool.poetry.group.dev.dependencies]
 pre-commit = "^4.0.0"

src/api/createDeviceReferenceDataMessageSet/index.py

@@ -0,0 +1,26 @@
+from api_utils.api_step_chain import execute_step_chain
+from event.aws.client import dynamodb_client
+from event.environment import BaseEnvironment
+from event.logging.logger import setup_logger
+
+from .src.v1.steps import steps as v1_steps
+
+
+class Environment(BaseEnvironment):
+    DYNAMODB_TABLE: str
+
+
+versioned_steps = {"1": v1_steps}
+cache = {
+    **Environment.build().dict(),
+    "DYNAMODB_CLIENT": dynamodb_client(),
+}
+
+
+def handler(event: dict, context=None):
+    setup_logger(service_name=__file__)
+    return execute_step_chain(
+        event=event,
+        cache=cache,
+        versioned_steps=versioned_steps,
+    )

src/api/createDeviceReferenceDataMessageSet/make/make.py

@@ -0,0 +1,4 @@
+from builder.lambda_build import build
+
+if __name__ == "__main__":
+    build(__file__)

src/api/createDeviceReferenceDataMessageSet/policies/dynamodb.json

@@ -0,0 +1,6 @@
+[
+  "dynamodb:Query",
+  "dynamodb:PutItem",
+  "dynamodb:GetItem",
+  "dynamodb:UpdateItem"
+]

src/api/createDeviceReferenceDataMessageSet/policies/kms.json

@@ -0,0 +1 @@
+["kms:Decrypt"]

src/api/createDeviceReferenceDataMessageSet/src/v1/steps.py

@@ -0,0 +1,129 @@
+from http import HTTPStatus
+
+from domain.api.common_steps.general import parse_event_body
+from domain.api.common_steps.read_product import (
+    parse_path_params,
+    read_product,
+    read_product_team,
+)
+from domain.core.cpm_product.v1 import CpmProduct
+from domain.core.device_reference_data.v1 import DeviceReferenceData
+from domain.core.error import ConfigurationError
+from domain.core.product_key.v1 import ProductKeyType
+from domain.core.questionnaire.v3 import Questionnaire, QuestionnaireResponse
+from domain.repository.device_reference_data_repository.v1 import (
+    DeviceReferenceDataRepository,
+)
+from domain.repository.errors import AlreadyExistsError
+from domain.repository.questionnaire_repository.v2 import QuestionnaireRepository
+from domain.repository.questionnaire_repository.v2.questionnaires import (
+    QuestionnaireInstance,
+)
+from domain.request_models.v1 import CreateDeviceReferenceMessageSetsDataParams
+from domain.response.validation_errors import mark_validation_errors_as_inbound
+
+
+@mark_validation_errors_as_inbound
+def parse_device_reference_data_for_epr_payload(
+    data, cache
+) -> CreateDeviceReferenceMessageSetsDataParams:
+    payload: dict = data[parse_event_body]
+    return CreateDeviceReferenceMessageSetsDataParams(**payload)
+
+
+def get_party_key(data, cache) -> str:
+    product: CpmProduct = data[read_product]
+    party_keys = [
+        key.key_value
+        for key in product.keys
+        if key.key_type is ProductKeyType.PARTY_KEY
+    ]
+    try:
+        (party_key,) = party_keys
+    except ValueError:
+        raise ConfigurationError(
+            "Cannot create Message Set in Product without exactly one Party Key"
+        )
+    return party_key
+
+
+def require_no_existing_message_sets_device_reference_data(
+    data, cache
+) -> list[QuestionnaireResponse]:
+    product: CpmProduct = data[read_product]
+    repo = DeviceReferenceDataRepository(
+        table_name=cache["DYNAMODB_TABLE"], dynamodb_client=cache["DYNAMODB_CLIENT"]
+    )
+    results = repo.search(
+        product_team_id=product.product_team_id, product_id=product.id
+    )
+    if len(results) > 0:
+        raise AlreadyExistsError(
+            "Message Sets Device Reference Data already exists for this Product"
+        )
+
+
+def read_questionnaire(data, cache) -> Questionnaire:
+    return QuestionnaireRepository().read(QuestionnaireInstance.SPINE_MHS_MESSAGE_SETS)
+
+
+def validate_questionnaire_responses(data, cache) -> list[QuestionnaireResponse]:
+    questionnaire: Questionnaire = data[read_questionnaire]
+    payload: CreateDeviceReferenceMessageSetsDataParams = data[
+        parse_device_reference_data_for_epr_payload
+    ]
+    raw_questionnaire_responses = payload.questionnaire_responses[
+        QuestionnaireInstance.SPINE_MHS_MESSAGE_SETS
+    ]
+    return [questionnaire.validate(data=qr) for qr in raw_questionnaire_responses]
+
+
+def create_message_set_device_reference_data(data, cache) -> DeviceReferenceData:
+    product: CpmProduct = data[read_product]
+    party_key: str = data[get_party_key]
+    return product.create_device_reference_data(name=f"{party_key} - MHS Message Set")
+
+
+def add_questionnaire_response(data, cache) -> list[QuestionnaireResponse]:
+    questionnaire_responses: list[QuestionnaireResponse] = data[
+        validate_questionnaire_responses
+    ]
+    device_reference_data: DeviceReferenceData = data[
+        create_message_set_device_reference_data
+    ]
+    for qr in questionnaire_responses:
+        device_reference_data.add_questionnaire_response(qr)
+
+
+def write_device_reference_data(data: dict[str, CpmProduct], cache) -> CpmProduct:
+    device_reference_data: DeviceReferenceData = data[
+        create_message_set_device_reference_data
+    ]
+    repo = DeviceReferenceDataRepository(
+        table_name=cache["DYNAMODB_TABLE"], dynamodb_client=cache["DYNAMODB_CLIENT"]
+    )
+    return repo.write(device_reference_data)
+
+
+def set_http_status(data, cache) -> tuple[HTTPStatus, str]:
+    device_reference_data: DeviceReferenceData = data[
+        create_message_set_device_reference_data
+    ]
+    return HTTPStatus.CREATED, device_reference_data.state()
+
+
+steps = [
+    parse_event_body,
+    parse_path_params,
+    parse_device_reference_data_for_epr_payload,
+    read_product_team,
+    read_product,
+    get_party_key,
+    require_no_existing_message_sets_device_reference_data,
+    read_questionnaire,
+    validate_questionnaire_responses,
+    create_message_set_device_reference_data,
+    add_questionnaire_response,
+    write_device_reference_data,
+    set_http_status,
+]

src/api/createDeviceReferenceDataMessageSet/tests/test_index.py

@@ -0,0 +1,162 @@
+import json
+import os
+from contextlib import contextmanager
+from datetime import datetime
+from types import ModuleType
+from typing import Any, Generator
+from unittest import mock
+
+from domain.core.cpm_product.v1 import CpmProduct
+from domain.core.cpm_system_id.v1 import PartyKeyId, ProductId
+from domain.core.device_reference_data.v1 import DeviceReferenceData
+from domain.core.product_key.v1 import ProductKeyType
+from domain.core.root.v3 import Root
+from domain.repository.cpm_product_repository.v3 import CpmProductRepository
+from domain.repository.device_reference_data_repository.v1 import (
+    DeviceReferenceDataRepository,
+)
+from domain.repository.product_team_repository.v2 import ProductTeamRepository
+from event.json import json_loads
+
+from test_helpers.dynamodb import mock_table
+
+TABLE_NAME = "hiya"
+
+ODS_CODE = "AAA"
+PRODUCT_ID = ProductId.create()
+PRODUCT_NAME = "My Product"
+VERSION = 1
+
+
+@contextmanager
+def mock_product() -> Generator[tuple[ModuleType, CpmProduct], Any, None]:
+    org = Root.create_ods_organisation(ods_code=ODS_CODE)
+    product_team = org.create_product_team(name=PRODUCT_NAME)
+
+    with mock_table(table_name=TABLE_NAME) as client, mock.patch.dict(
+        os.environ,
+        {"DYNAMODB_TABLE": TABLE_NAME, "AWS_DEFAULT_REGION": "eu-west-2"},
+        clear=True,
+    ):
+        product_team_repo = ProductTeamRepository(
+            table_name=TABLE_NAME, dynamodb_client=client
+        )
+        product_team_repo.write(entity=product_team)
+
+        product = product_team.create_cpm_product(
+            name=PRODUCT_NAME, product_id=PRODUCT_ID
+        )
+        product.add_key(
+            key_type=ProductKeyType.PARTY_KEY,
+            key_value=str(PartyKeyId.create(current_number=100000, ods_code="AAA")),
+        )
+        product_repo = CpmProductRepository(
+            table_name=TABLE_NAME, dynamodb_client=client
+        )
+        product_repo.write(entity=product)
+
+        import api.createDeviceReferenceDataMessageSet.index as index
+
+        index.cache["DYNAMODB_CLIENT"] = client
+
+        yield index, product
+
+
+def test_index_without_questionnaire() -> None:
+    with mock_product() as (index, product):
+        # Execute the lambda
+        response = index.handler(
+            event={
+                "headers": {"version": VERSION},
+                "body": json.dumps({}),
+                "pathParameters": {
+                    "product_team_id": str(product.product_team_id),
+                    "product_id": str(product.id),
+                },
+            }
+        )
+
+        # Validate that the response indicates that a resource was created
+        assert response["statusCode"] == 201
+
+        _device_reference_data = json_loads(response["body"])
+        device_reference_data = DeviceReferenceData(**_device_reference_data)
+        assert device_reference_data.product_id == product.id
+        assert device_reference_data.product_team_id == product.product_team_id
+        assert device_reference_data.name == "AAA-100001 - MHS Message Set"
+        assert device_reference_data.ods_code == ODS_CODE
+        assert device_reference_data.created_on.date() == datetime.today().date()
+        assert device_reference_data.updated_on is None
+        assert device_reference_data.deleted_on is None
+        assert device_reference_data.questionnaire_responses == {}
+
+        # Retrieve the created resource
+        repo = DeviceReferenceDataRepository(
+            table_name=TABLE_NAME, dynamodb_client=index.cache["DYNAMODB_CLIENT"]
+        )
+
+        created_device_reference_data = repo.read(
+            product_team_id=device_reference_data.product_team_id,
+            product_id=device_reference_data.product_id,
+            device_reference_data_id=device_reference_data.id,
+        )
+        assert created_device_reference_data == device_reference_data
+
+
+def test_index_with_questionnaire() -> None:
+    questionnaire_data = {
+        "Interaction ID": "foo",
+        "MHS SN": "bar",
+        "MHS IN": "baz",
+    }
+
+    with mock_product() as (index, product):
+        # Execute the lambda
+        response = index.handler(
+            event={
+                "headers": {"version": VERSION},
+                "body": json.dumps(
+                    {
+                        "questionnaire_responses": {
+                            "spine_mhs_message_sets": [questionnaire_data]
+                        }
+                    }
+                ),
+                "pathParameters": {
+                    "product_team_id": str(product.product_team_id),
+                    "product_id": str(product.id),
+                },
+            }
+        )
+
+        # Validate that the response indicates that a resource was created
+        assert response["statusCode"] == 201
+
+        _device_reference_data = json_loads(response["body"])
+        device_reference_data = DeviceReferenceData(**_device_reference_data)
+        assert device_reference_data.product_id == product.id
+        assert device_reference_data.product_team_id == product.product_team_id
+        assert device_reference_data.name == "AAA-100001 - MHS Message Set"
+        assert device_reference_data.ods_code == ODS_CODE
+        assert device_reference_data.created_on.date() == datetime.today().date()
+        assert device_reference_data.updated_on.date() == datetime.today().date()
+        assert device_reference_data.deleted_on is None
+
+        questionnaire_responses = device_reference_data.questionnaire_responses[
+            "spine_mhs_message_sets/1"
+        ]
+        assert len(questionnaire_responses) == 1
+        questionnaire_response = questionnaire_responses[0]
+        assert questionnaire_response.data == questionnaire_data
+
+        # Retrieve the created resource
+        repo = DeviceReferenceDataRepository(
+            table_name=TABLE_NAME, dynamodb_client=index.cache["DYNAMODB_CLIENT"]
+        )
+
+        created_device_reference_data = repo.read(
+            product_team_id=device_reference_data.product_team_id,
+            product_id=device_reference_data.product_id,
+            device_reference_data_id=device_reference_data.id,
+        )
+        assert created_device_reference_data == device_reference_data