def test_get_parameter_value(self):
op_param_transaction_number = creators.create_parameter_with_binding(
name="some_param_name", value="17")
op = creators.create_operation_definition(
name="some.name",
code="some.code",
date_time="2019-04-23 09:00:04.159338",
parameters=[op_param_transaction_number],
contained=[])
self.assertEqual(finders.get_parameter_value(op, "some_param_name"),
"17")
def test_create_operation_definition(self):
"""
Tests the helper function to create an operation definition
"""
with self.subTest("with no contained resources or parameters"):
op_def = creators.create_operation_definition(name="name.of.operation", code="code.of.operation",
date_time="2019-04-23 09:00:04.159338", parameters=[],
contained=[])
self.assertIsInstance(op_def, OperationDefinition)
self.assertEqual(op_def.name, "name.of.operation")
self.assertEqual(op_def.code, "code.of.operation")
self.assertEqual(op_def.date.as_json(), "2019-04-23 09:00:04.159338")
self.assertEqual(op_def.contained, None)
self.assertEqual(op_def.parameter, None)
with self.subTest("with one parameter"):
some_param = creators.create_parameter_with_binding(name="SOME_NAME", value="SOME_VALUE")
op_def = creators.create_operation_definition(name="name.of.operation", code="code.of.operation",
date_time="2019-04-23 09:00:04.159338",
parameters=[some_param], contained=[])
self.assertEqual(len(op_def.parameter), 1)
self.assertIsInstance(op_def.parameter[0], OperationDefinitionParameter)
with self.subTest("with one contained resource"):
some_resource = creators.create_practitioner_resource(resource_id="some_id",
national_identifier="some_nat_id",
local_identifier="some_local_id")
op_def = creators.create_operation_definition(name="name.of.operation", code="code.of.operation",
date_time="2019-04-23 09:00:04.159338", parameters=[],
contained=[some_resource])
self.assertEqual(len(op_def.contained), 1)
self.assertIsInstance(op_def.contained[0], Practitioner)
def create_operation_definition_for_approval(recipient, transaction_number):
sender_parameter = creators.create_parameter_with_binding(
name="senderCypher", value="XX11", direction="out")
recipient_parameter = creators.create_parameter_with_binding(
name="recipientCypher", value=recipient, direction="out")
transaction_parameter = creators.create_parameter_with_binding(
name="transactionNumber", value=transaction_number, direction="out")
op_def = creators.create_operation_definition(
name="Response-RegisterPatient-Approval",
code="gpc.registerpatient.approval",
date_time="2019-04-29 17:56",
parameters=[
sender_parameter, recipient_parameter, transaction_parameter
])
return op_def
def create_operation_definition_for_death_registration(free_text=None):
practitioner = create_simple_practitioner()
patient = Patient({
'id': 'patient-1',
'identifier': [{
'value': 'NHSNO22222'
}],
'deceasedBoolean': True,
'deceasedDateTime': '2019-04-20 09:00:04.159338'
})
op_param_interchange_sequence = creators.create_parameter_with_binding(
name=ParameterName.INTERCHANGE_SEQ_NO, value="000001")
op_param_message_sequence = creators.create_parameter_with_binding(
name=ParameterName.MESSAGE_SEQ_NO, value="000001")
op_param_nhais_cypher = creators.create_parameter_with_binding(
name=ParameterName.NHAIS_CYPHER, value="XX1")
op_param_sender_cypher = creators.create_parameter_with_binding(
name=ParameterName.SENDER_CYPHER, value="TES5")
op_param_transaction_number = creators.create_parameter_with_binding(
name=ParameterName.TRANSACTION_NO, value="17")
op_param_practitioner = creators.create_parameter_with_resource_ref(
name=ParameterName.REGISTER_PRACTITIONER,
resource_type=ResourceType.PRACTITIONER,
reference="practitioner-1")
op_param_patient = creators.create_parameter_with_resource_ref(
name=ParameterName.REGISTER_PATIENT,
resource_type=ResourceType.PATIENT,
reference="patient-1")
parameters = [
op_param_interchange_sequence, op_param_message_sequence,
op_param_nhais_cypher, op_param_sender_cypher,
op_param_transaction_number, op_param_practitioner, op_param_patient
]
if free_text:
parameters.append(
creators.create_parameter_with_binding(
name=ParameterName.FREE_TEXT, value=free_text))
op_def = creators.create_operation_definition(
name=OperationName.REGISTER_DEATH,
code="gpc.registerpatient",
date_time="2019-04-23 09:00:04.159338",
contained=[practitioner, patient],
parameters=parameters)
return op_def
def create_operation_definition(
self, interchange: Interchange) -> List[Tuple[str, str, str]]:
"""
Create a fhir operation definition from the incoming interchange
:param interchange:
:return: a List of transaction_numbers, recipients and generated fhir operation definition json payloads
"""
sender = interchange.header.sender
recipient = interchange.header.recipient
formatted_date_time = date_formatter.format_date_time(
interchange.header.date_time)
messages = interchange.msgs
op_defs = []
for message in messages:
ref_number = message.message_beginning.reference_number
for transaction in message.transactions:
transaction_number = transaction.transaction_registration.transaction_number
parameters = [
creators.create_parameter_with_binding(
"senderCypher", sender, "out"),
creators.create_parameter_with_binding(
"recipientCypher", recipient, "out"),
creators.create_parameter_with_binding(
"transactionNumber", transaction_number, "out")
]
if transaction.transaction_patient:
nhs_number = transaction.transaction_patient.nhs_number
parameters.append(
creators.create_parameter_with_binding(
"nhsNumber", nhs_number, "out"))
op_def = creators.create_operation_definition(
name=self.reference_dict[ref_number]["name"],
code=self.reference_dict[ref_number]["code"],
date_time=formatted_date_time,
parameters=parameters)
op_defs.append(
(transaction_number, recipient, op_def.as_json()))
return op_defs
def test_find_resource(self):
with self.subTest(
"When practitioner details are found in the operation definition"
):
practitioner = creators.create_practitioner_resource(
resource_id="practitioner-1",
national_identifier="1234567",
local_identifier="111")
op_param_practitioner = creators.create_parameter_with_resource_ref(
name=ParameterName.REGISTER_PRACTITIONER,
resource_type=ResourceType.PRACTITIONER,
reference="practitioner-1")
op_def = creators.create_operation_definition(
name="name.of.operation",
code="code.of.operation",
date_time="2019-04-23 09:00:04.159338",
parameters=[op_param_practitioner],
contained=[practitioner])
found_practitioner = finders.find_resource(
fhir_operation=op_def, resource_type=ResourceType.PRACTITIONER)
compare(found_practitioner, practitioner)
def create_operation_definition_for_birth_registration():
"""
Creates an fhir operation definition for a birth registration
:return: OperationDefinition
"""
op_param_interchange_sequence = creators.create_parameter_with_binding(
name=ParameterName.INTERCHANGE_SEQ_NO, value="000001")
op_param_sender_cypher = creators.create_parameter_with_binding(
name=ParameterName.SENDER_CYPHER, value="TES5")
op_param_message_sequence = creators.create_parameter_with_binding(
name=ParameterName.MESSAGE_SEQ_NO, value="000001")
op_param_nhais_cypher = creators.create_parameter_with_binding(
name=ParameterName.NHAIS_CYPHER, value="XX1")
op_param_transaction_number = creators.create_parameter_with_binding(
name=ParameterName.TRANSACTION_NO, value="17")
practitioner = create_simple_practitioner()
patient = create_simple_patient()
op_param_practitioner = creators.create_parameter_with_resource_ref(
name=ParameterName.REGISTER_PRACTITIONER,
resource_type=ResourceType.PRACTITIONER,
reference="practitioner-1")
op_param_patient = creators.create_parameter_with_resource_ref(
name=ParameterName.REGISTER_PATIENT,
resource_type=ResourceType.PATIENT,
reference="patient-1")
op_def = creators.create_operation_definition(
name=OperationName.REGISTER_BIRTH,
code="gpc.registerpatient",
date_time="2019-04-23 09:00:04.159338",
parameters=[
op_param_interchange_sequence, op_param_sender_cypher,
op_param_message_sequence, op_param_transaction_number,
op_param_nhais_cypher, op_param_practitioner, op_param_patient
],
contained=[practitioner, patient])
return op_def