feature/PI-666-add_asid_to_as_device_key Add ASID to AS device keys

Author: megan-bower4

src/api/createDeviceAccreditedSystem/src/v1/steps.py

@@ -7,11 +7,13 @@
     read_product_team,
 )
 from domain.core.cpm_product import CpmProduct
+from domain.core.cpm_system_id import AsidId
 from domain.core.device import (
     Device,
     DeviceTagAddedEvent,
     QuestionnaireResponseUpdatedEvent,
 )
+from domain.core.device_key.v1 import DeviceKeyType
 from domain.core.device_reference_data import DeviceReferenceData
 from domain.core.error import (
     AccreditedSystemFatalError,
@@ -20,6 +22,7 @@
 )
 from domain.core.product_key import ProductKeyType
 from domain.core.questionnaire import Questionnaire, QuestionnaireResponse
+from domain.repository.cpm_system_id_repository import CpmSystemIdRepository
 from domain.repository.device_reference_data_repository import (
     DeviceReferenceDataRepository,
 )
@@ -85,28 +88,41 @@ def validate_spine_as_questionnaire_response(data, cache) -> QuestionnaireRespon
     )
 
 
+def create_party_key_tag(data, cache) -> DeviceTagAddedEvent:
+    as_device: Device = data[create_as_device]
+    return as_device.add_tag(party_key=data[get_party_key])
+
+
+def create_asid(data, cache) -> AsidId:
+    repository = CpmSystemIdRepository[AsidId](
+        table_name=cache["DYNAMODB_TABLE"],
+        dynamodb_client=cache["DYNAMODB_CLIENT"],
+        model=AsidId,
+    )
+    asid = repository.read()
+    new_asid = AsidId.create(current_number=asid.latest_number)
+    return new_asid
+
+
 def create_as_device(data, cache) -> Device:
     product: CpmProduct = data[read_product]
+    asid: AsidId = data[create_asid]
     payload: CreateAsDeviceIncomingParams = data[parse_as_device_payload]
     party_key: str = data[get_party_key]
 
-    # Create a new Device dictionary excluding 'questionnaire_responses'
-    # Ticket PI-666 adds ASID generation. This will need to be sent across in the arguments instead of an empty string.
     device_payload = payload.dict(exclude={"questionnaire_responses"})
     return product.create_device(
-        name=EprNameTemplate.AS_DEVICE.format(party_key=party_key, asid=""),
+        name=EprNameTemplate.AS_DEVICE.format(party_key=party_key, asid=asid.__root__),
         **device_payload
     )
 
 
-def create_party_key_tag(data, cache) -> DeviceTagAddedEvent:
-    as_device: Device = data[create_as_device]
-    return as_device.add_tag(party_key=data[get_party_key])
-
-
 def create_device_keys(data, cache) -> Device:
-    # We will need to add some keys in the future, ASID?
     as_device: Device = data[create_as_device]
+    asid: AsidId = data[create_asid]
+    as_device.add_key(
+        key_type=DeviceKeyType.ACCREDITED_SYSTEM_ID, key_value=asid.__root__
+    )
     return as_device
 
 
@@ -115,7 +131,7 @@ def add_device_reference_data_id(data, cache) -> Device:
     device_reference_data: DeviceReferenceData = data[read_device_reference_data]
     for drd in device_reference_data:
         as_device.add_device_reference_data_id(
-            device_reference_data_id=str(drd.id), path_to_data=["*.Interaction ID"]
+            device_reference_data_id=str(drd.id), path_to_data=["Interaction ID"]
         )
     return as_device
 
@@ -139,6 +155,16 @@ def write_device(data: dict[str, Device], cache) -> Device:
     return repo.write(as_device)
 
 
+def write_asid(data: dict[str, AsidId], cache) -> str:
+    repository = CpmSystemIdRepository[AsidId](
+        table_name=cache["DYNAMODB_TABLE"],
+        dynamodb_client=cache["DYNAMODB_CLIENT"],
+        model=AsidId,
+    )
+    asid: AsidId = data[create_asid]
+    return repository.create_or_update(asid)
+
+
 def set_http_status(data, cache) -> tuple[HTTPStatus, dict]:
     as_device: Device = data[create_as_device]
     return HTTPStatus.CREATED, as_device.state_exclude_tags()
@@ -170,11 +196,13 @@ def get_party_key(data, cache) -> str:
     read_device_reference_data,
     read_spine_as_questionnaire,
     validate_spine_as_questionnaire_response,
+    create_asid,
     create_as_device,
     create_party_key_tag,
     create_device_keys,
     add_device_reference_data_id,
     add_spine_as_questionnaire_response,
     write_device,
+    write_asid,
     set_http_status,
 ]

src/api/createDeviceAccreditedSystem/tests/test_index.py

@@ -10,6 +10,7 @@
 from domain.core.cpm_product import CpmProduct
 from domain.core.cpm_system_id import ProductId
 from domain.core.device import Device
+from domain.core.device_key.v1 import DeviceKey, DeviceKeyType
 from domain.core.product_key import ProductKeyType
 from domain.core.root import Root
 from domain.repository.cpm_product_repository import CpmProductRepository
@@ -425,7 +426,7 @@ def test_index() -> None:
         device = Device(**_device)
         assert device.product_team_id == product.product_team_id
         assert device.product_id == product.id
-        assert device.name == "ABC1234-987654/ - Accredited System"
+        assert device.name == "ABC1234-987654/200000100000 - Accredited System"
         assert device.ods_code == ODS_CODE
         assert device.created_on.date() == datetime.today().date()
         assert device.updated_on.date() == datetime.today().date()
@@ -451,6 +452,13 @@ def test_index() -> None:
         expected_party_key = (str(ProductKeyType.PARTY_KEY), "abc1234-987654")
         assert any(expected_party_key in tag.__root__ for tag in created_device.tags)
 
+        # Check an ASID is generated and added to the keys.
+        assert isinstance(created_device.keys[0], DeviceKey)
+        assert created_device.keys[0].__dict__ == {
+            "key_type": DeviceKeyType.ACCREDITED_SYSTEM_ID,
+            "key_value": "200000100000",
+        }
+
 
 @pytest.mark.parametrize(
     ["body", "path_parameters", "error_code", "status_code"],

src/api/readDevice/src/v1/steps.py

@@ -74,14 +74,34 @@ def read_device_reference_data(data, cache) -> list[DeviceReferenceData]:
             id=id,
         )
         device_reference_datas.append(drd)
-
     return device_reference_datas
 
 
+def filter_by_jsonpath(data, filters: list) -> dict:
+    response = {}
+    if "*" not in filters:
+        response = {filter_key: data[filter_key] for filter_key in filters}
+        return response
+    return data
+
+
+def filter_device_reference_data(data, cache) -> list[DeviceReferenceData]:
+    device: Device = data[read_device]
+    device_reference_data_list: list[DeviceReferenceData] = data[
+        read_device_reference_data
+    ]
+
+    for drd in device_reference_data_list:
+        filters = device.device_reference_data[str(drd.id)]
+        for questionnaire_response in drd.questionnaire_responses.values():
+            for qr in questionnaire_response:
+                qr.data = filter_by_jsonpath(data=qr.data, filters=filters)
+    return device_reference_data_list
+
+
 def update_device_with_device_reference_data(data, cache) -> Device:
     device: Device = data[read_device]
     device_reference_datas = data[read_device_reference_data]
-
     [
         device.questionnaire_responses.setdefault(key, []).extend(responses)
         for drd in device_reference_datas
@@ -102,6 +122,7 @@ def device_to_dict(data, cache) -> tuple[str, dict]:
     read_product,
     read_device,
     read_device_reference_data,
+    filter_device_reference_data,
     update_device_with_device_reference_data,
     device_to_dict,
 ]