def verify_fhir_instance(self, fhir_obj):
self.assertEqual(1, len(fhir_obj.name))
human_name = fhir_obj.name[0]
self.assertTrue(isinstance(human_name, HumanName))
self.assertEqual(self._TEST_OTHER_NAME, human_name.given[0])
self.assertEqual(self._TEST_LAST_NAME, human_name.family)
self.assertEqual(NameUse.USUAL.value, human_name.use)
for identifier in fhir_obj.identifier:
self.assertTrue(isinstance(identifier, Identifier))
code = PatientConverter.get_first_coding_from_codeable_concept(identifier.type).code
if code == Stu3IdentifierConfig.get_fhir_chfid_type_code():
self.assertEqual(self._TEST_CHF_ID, identifier.value)
elif code == Stu3IdentifierConfig.get_fhir_uuid_type_code() and not isinstance(identifier.value, UUID):
self.assertEqual(self._TEST_UUID, identifier.value)
elif code == Stu3IdentifierConfig.get_fhir_passport_type_code():
self.assertEqual(self._TEST_PASSPORT, identifier.value)
self.assertEqual(self._TEST_DOB, fhir_obj.birthDate)
self.assertEqual(AdministrativeGender.MALE.value, fhir_obj.gender)
marital_code = PatientConverter.get_first_coding_from_codeable_concept(fhir_obj.maritalStatus).code
self.assertEqual(Stu3MaritalConfig.get_fhir_divorced_code(), marital_code)
self.assertEqual(2, len(fhir_obj.telecom))
for telecom in fhir_obj.telecom:
self.assertTrue(isinstance(telecom, ContactPoint))
if telecom.system == ContactPointSystem.PHONE.value:
self.assertEqual(self._TEST_PHONE, telecom.value)
elif telecom.system == ContactPointSystem.EMAIL.value:
self.assertEqual(self._TEST_EMAIL, telecom.value)
self.assertEqual(2, len(fhir_obj.address))
for adddress in fhir_obj.address:
self.assertTrue(isinstance(adddress, Address))
if adddress.type == AddressType.PHYSICAL.value:
self.assertEqual(self._TEST_ADDRESS, adddress.text)
elif adddress.type == AddressType.BOTH.value:
self.assertEqual(self._TEST_GEOLOCATION, adddress.text)
def create_test_fhir_instance(self):
self.setUp()
fhir_reqest = EligibilityRequest()
fhir_reqest.patient = PatientConverter.build_fhir_resource_reference(self._TEST_INSUREE)
fhir_reqest.benefitCategory = PatientConverter.build_codeable_concept(
Config.get_fhir_service_code(), system=None, text=self._TEST_SERVICE_CODE)
fhir_reqest.benefitSubCategory = PatientConverter.build_codeable_concept(
Config.get_fhir_item_code(), system=None, text=self._TEST_ITEM_CODE)
return fhir_reqest
def test_to_imis_obj(self, mock_gender):
self.setUp()
mock_gender.get.return_value = self._TEST_GENDER
fhir_patient = self.create_test_fhir_instance()
imis_insuree = PatientConverter.to_imis_obj(fhir_patient, None)
self.verify_imis_instance(imis_insuree)
def build_imis_uuid(cls, fhir_eligibility_request):
uuid = None
patient_reference = fhir_eligibility_request.patient
if patient_reference:
uuid = PatientConverter.get_resource_id_from_reference(
patient_reference)
return uuid
def build_imis_patient(cls, imis_claim, fhir_claim, errors):
if fhir_claim.patient:
insuree = PatientConverter.get_imis_obj_by_fhir_reference(
fhir_claim.patient)
if insuree:
imis_claim.insuree = insuree
imis_claim.insuree_chf_code = insuree.chf_id
cls.valid_condition(imis_claim.insuree is None,
gettext('Missing the patient reference'), errors)
def create_test_fhir_instance(self):
fhir_claim = FHIRClaim()
fhir_claim.id = self._TEST_CODE
fhir_claim.patient = PatientConverter.build_fhir_resource_reference(
self._TEST_INSUREE)
claim_code = ClaimConverter.build_fhir_identifier(
self._TEST_CODE,
Stu3IdentifierConfig.get_fhir_identifier_type_system(),
Stu3IdentifierConfig.get_fhir_claim_code_type())
fhir_claim.identifier = [claim_code]
billable_period = Period()
billable_period.start = self._TEST_DATE_FROM
billable_period.end = self._TEST_DATE_TO
fhir_claim.billablePeriod = billable_period
diagnoses = []
ClaimConverter.build_fhir_diagnosis(diagnoses,
self._TEST_DIAGNOSIS_CODE.code,
ImisClaimIcdTypes.ICD_0.value)
fhir_claim.diagnosis = diagnoses
total = Money()
total.value = self._TEST_CLAIMED
fhir_claim.total = total
fhir_claim.created = self._TEST_DATE_CLAIMED
fhir_claim.facility = LocationConverter.build_fhir_resource_reference(
self._TEST_HF)
information = []
guarantee_id_code = Stu3ClaimConfig.get_fhir_claim_information_guarantee_id_code(
)
ClaimConverter.build_fhir_string_information(information,
guarantee_id_code,
self._TEST_GUARANTEE_ID)
explanation_code = Stu3ClaimConfig.get_fhir_claim_information_explanation_code(
)
ClaimConverter.build_fhir_string_information(information,
explanation_code,
self._TEST_EXPLANATION)
fhir_claim.information = information
fhir_claim.enterer = PractitionerConverter.build_fhir_resource_reference(
self._TEST_CLAIM_ADMIN)
fhir_claim.type = ClaimConverter.build_simple_codeable_concept(
self._TEST_VISIT_TYPE)
type = Stu3ClaimConfig.get_fhir_claim_item_code()
ClaimConverter.build_fhir_item(fhir_claim, self._TEST_ITEM_CODE, type,
self._TEST_ITEM)
type = Stu3ClaimConfig.get_fhir_claim_service_code()
ClaimConverter.build_fhir_item(fhir_claim, self._TEST_SERVICE_CODE,
type, self._TEST_SERVICE)
return fhir_claim
def to_fhir_obj(cls, imis_claim):
fhir_claim = FHIRClaim()
cls.build_fhir_pk(fhir_claim, imis_claim.code)
fhir_claim.created = imis_claim.date_claimed.isoformat()
fhir_claim.facility = LocationConverter.build_fhir_resource_reference(
imis_claim.health_facility)
cls.build_fhir_identifiers(fhir_claim, imis_claim)
fhir_claim.patient = PatientConverter.build_fhir_resource_reference(
imis_claim.insuree)
cls.build_fhir_billable_period(fhir_claim, imis_claim)
cls.build_fhir_diagnoses(fhir_claim, imis_claim)
cls.build_fhir_total(fhir_claim, imis_claim)
fhir_claim.enterer = PractitionerConverter.build_fhir_resource_reference(
imis_claim.admin)
cls.build_fhir_type(fhir_claim, imis_claim)
cls.build_fhir_information(fhir_claim, imis_claim)
cls.build_fhir_items(fhir_claim, imis_claim)
return fhir_claim
def create_test_fhir_instance(self):
fhir_patient = Patient()
name = HumanName()
name.family = self._TEST_LAST_NAME
name.given = [self._TEST_OTHER_NAME]
name.use = NameUse.USUAL.value
fhir_patient.name = [name]
identifiers = []
chf_id = PatientConverter.build_fhir_identifier(
self._TEST_CHF_ID,
Stu3IdentifierConfig.get_fhir_identifier_type_system(),
Stu3IdentifierConfig.get_fhir_chfid_type_code())
identifiers.append(chf_id)
passport = PatientConverter.build_fhir_identifier(
self._TEST_PASSPORT,
Stu3IdentifierConfig.get_fhir_identifier_type_system(),
Stu3IdentifierConfig.get_fhir_passport_type_code())
identifiers.append(passport)
fhir_patient.identifier = identifiers
fhir_patient.birthDate = self._TEST_DOB
fhir_patient.gender = AdministrativeGender.MALE.value
fhir_patient.maritalStatus = PatientConverter.build_codeable_concept(
Stu3MaritalConfig.get_fhir_divorced_code(),
Stu3MaritalConfig.get_fhir_marital_status_system())
telecom = []
phone = PatientConverter.build_fhir_contact_point(
self._TEST_PHONE, ContactPointSystem.PHONE.value,
ContactPointUse.HOME.value)
telecom.append(phone)
email = PatientConverter.build_fhir_contact_point(
self._TEST_EMAIL, ContactPointSystem.EMAIL.value,
ContactPointUse.HOME.value)
telecom.append(email)
fhir_patient.telecom = telecom
addresses = []
current_address = PatientConverter.build_fhir_address(
self._TEST_ADDRESS, AddressUse.HOME.value,
AddressType.PHYSICAL.value)
addresses.append(current_address)
geolocation = PatientConverter.build_fhir_address(
self._TEST_GEOLOCATION, AddressUse.HOME.value,
AddressType.BOTH.value)
addresses.append(geolocation)
fhir_patient.address = addresses
return fhir_patient
class PatientSerializer(BaseFHIRSerializer):
fhirConverter = PatientConverter()
def create(self, validated_data):
chf_id = validated_data.get('chf_id')
if Insuree.objects.filter(chf_id=chf_id).count() > 0:
raise FHIRException(
'Exists patient with following chfid `{}`'.format(chf_id))
copied_data = copy.deepcopy(validated_data)
del copied_data['_state']
return Insuree.objects.create(**copied_data)
def update(self, instance, validated_data):
# TODO the familyid isn't covered because that value is missing in the model
# TODO the photoId isn't covered because that value is missing in the model
# TODO the typeofid isn't covered because that value is missing in the model
# TODO the head isn't covered in the current version of API
# TODO the card_issued isn't covered in the current version of API
instance.last_name = validated_data.get('last_name',
instance.last_name)
instance.other_names = validated_data.get('other_names',
instance.other_names)
instance.chf_id = validated_data.get('chf_id', instance.chf_id)
instance.passport = validated_data.get('passport', instance.passport)
instance.dob = validated_data.get('dob', instance.dob)
gender_code = validated_data.get('gender_id', instance.gender.code)
instance.gender = Gender.objects.get(pk=gender_code)
instance.marital = validated_data.get('marital', instance.marital)
instance.phone = validated_data.get('phone', instance.phone)
instance.email = validated_data.get('email', instance.email)
instance.current_address = validated_data.get('current_address',
instance.current_address)
instance.geolocation = validated_data.get('geolocation',
instance.geolocation)
instance.audit_user_id = self.get_audit_user_id()
instance.save()
return instance
def test_to_fhir_obj(self):
self.setUp()
imis_insuree = self.create_test_imis_instance()
fhir_patient = PatientConverter.to_fhir_obj(imis_insuree)
self.verify_fhir_instance(fhir_patient)
