def test_serializing_deserialing_infant_death(self): InfantBirthFactory( registered_subject=self.registered_subject_infant, maternal_labour_del=self.maternal_labour_del) appointment = Appointment.objects.get( registered_subject=self.registered_subject_infant, visit_definition__code='2000') infant_visit = InfantVisitFactory( appointment=appointment) infant_death = InfantDeathReport.objects.create( infant_visit=infant_visit, report_datetime=timezone.now(), death_date=date(2015, 12, 15), cause_id=5, cause_category_id=2, illness_duration=2, diagnosis_code_id=2, medical_responsibility_id=1, registered_subject=self.registered_subject_infant ) out_tx = SerializeToTransaction().serialize( infant_death.__class__, infant_death, False, True, 'default') serialized_objects = serializers.deserialize("json", FieldCryptor('aes', 'local').decrypt(out_tx.tx)) for transaction in serialized_objects: self.assertEqual(transaction.object.pk, infant_death.pk)
def test_serialize_deserialize(self): """Confirms all models have a get_by_natural_key manager method.""" maternal_eligibility = MaternalEligibilityFactory() maternal_consent = MaternalConsentFactory( registered_subject=maternal_eligibility.registered_subject) specimen_consent = SpecimenConsentFactory( registered_subject=maternal_consent.registered_subject) antenatal_enrollment = AntenatalEnrollmentFactory( registered_subject=specimen_consent.registered_subject, current_hiv_status=POS, evidence_hiv_status=YES, rapid_test_done=NO) appointment = Appointment.objects.get( registered_subject=antenatal_enrollment.registered_subject, visit_definition__code='1000M') maternal_visit = MaternalVisitFactory(appointment=appointment) maternal_locator = MaternalLocatorFactory( maternal_visit=maternal_visit, registered_subject=antenatal_enrollment.registered_subject, ) maternal_demographics = MaternalDemographics.objects.create( maternal_visit=maternal_visit, report_datetime=timezone.now(), marital_status='Single', ethnicity='Black African', highest_education='Tertiary', current_occupation='Student', provides_money='Mother', money_earned='P1001-5000 per month / P212 - 1157 per week', own_phone=YES, house_electrified=YES, house_fridge=YES, cooking_method='Gas or electric stove', toilet_facility='Indoor toilet', house_people_number=1, house_type='Formal: Tin-roofed, concrete walls') instances = [] instances.append(maternal_eligibility) instances.append(maternal_consent) instances.append(specimen_consent) instances.append(antenatal_enrollment) instances.append(maternal_visit) instances.append(maternal_locator) instances.append(maternal_demographics) for obj in instances: natural_key = obj.natural_key() get_obj = obj.__class__.objects.get_by_natural_key(*natural_key) self.assertEqual(obj.pk, get_obj.pk) for obj in instances: outgoing_transaction = SerializeToTransaction().serialize( obj.__class__, obj, False, True, 'default') for transaction in serializers.deserialize( "json", FieldCryptor('aes', 'local').decrypt(outgoing_transaction.tx)): self.assertEqual(transaction.object.pk, obj.pk)
def test_serializing_deserialing_infant_birth(self): infant_birth = InfantBirthFactory( registered_subject=self.registered_subject_infant, maternal_labour_del=self.maternal_labour_del) outgoing_tx = SerializeToTransaction().serialize( infant_birth.__class__, infant_birth, False, True, 'default') for transaction in serializers.deserialize("json", FieldCryptor('aes', 'local').decrypt(outgoing_tx.tx)): self.assertEqual(transaction.object.pk, infant_birth.pk)
def view_transaction(request, **kwargs): cryptor = FieldCryptor('aes', 'local') app_label = kwargs.get('app_label', 'sync') model_name = kwargs.get('model_name') pk = kwargs.get('pk') model = get_model(app_label, model_name) model_instance = model.objects.get(pk=pk) textfields = {} charfields = {} for field in model_instance._meta.fields: if isinstance(field, (TextField, EncryptedTextField)): value = getattr(model_instance, field.name) if (cryptor.is_encrypted(value)): cipher = cryptor.decrypt(value) textfields.update({field.name: cipher}) else: textfields.update({field.name: value}) else: charfields.update({field.name: getattr(model_instance, field.name)}) return render_to_response('transaction.html', { 'charfields': charfields, 'textfields': textfields}, context_instance=RequestContext(request))
def update_model_crypts(self, mld_cls_instances): """Grabs all crypt objects of models being dispatched. """ crypt_objs_instances = [] crypt_objs_instance = [] if not isinstance(mld_cls_instances, (list, QuerySet)): mld_cls_instances = [mld_cls_instances] for mld_cls_instance in mld_cls_instances: # eg plot # Get model model_cls = mld_cls_instance.__class__ if '_meta' not in dir(model_cls): continue fields = model_cls._meta.fields for f in fields: if issubclass(f.__class__, BaseEncryptedField): crypt = FieldCryptor('rsa', 'local') hash_value = crypt.get_hash(getattr(mld_cls_instance, f.name)) #if hash_value: if Crypt.objects.filter(hash=hash_value).exists(): crypt_objs_instance = Crypt.objects.filter(hash=hash_value) else: crypt = FieldCryptor('rsa', 'restricted') hash_value = crypt.get_hash(getattr(mld_cls_instance, f.name)) if Crypt.objects.filter(hash=hash_value).exists(): crypt_objs_instance = Crypt.objects.filter(hash=hash_value) else: crypt = FieldCryptor('aes', 'local') hash_value = crypt.get_hash(getattr(mld_cls_instance, f.name)) if Crypt.objects.filter(hash=hash_value).exists(): crypt_objs_instance = Crypt.objects.filter(hash=hash_value) else: if hash_value: raise TypeError('Could not get a secret for field={}, of model={}, using hash={}'.format(str(f), str(model_cls), hash)) else: pass if len(crypt_objs_instance) > 0: crypt_objs_instances.append(crypt_objs_instance[0]) # if crypt_objs_instance:hash # # Successfully pulled a crypt record using hash generated from RSA instance. # crypt_objs_instances.append(crypt_objs_instance[0]) # elif not crypt_objs_instance: # crypt = FieldCryptor('rsa', 'restricted') # hash_value = crypt.get_hash(getattr(mld_cls_instance, f.name)) # #if hash_value: # crypt_objs_instance = Crypt.objects.filter(hash=hash_value) # crypt_objs_instances.append(crypt_objs_instance[0]) # else: # # RSA hash dis not work, now we try AES generated hash # crypt = FieldCryptor('aes', 'local') # hash_value = crypt.get_hash(getattr(mld_cls_instance, f.name)) # if hash_value: # crypt_objs_instance = Crypt.objects.filter(hash=hash_value) # if crypt_objs_instance: # crypt_objs_instances.append(crypt_objs_instance[0]) crypt_objs_instances_unique = {} for crypt in crypt_objs_instances: crypt_objs_instances_unique[crypt.hash] = crypt crypt_objs_instances = crypt_objs_instances_unique.values() return crypt_objs_instances
def test_serializing_deserialing_infant_visit(self): InfantBirthFactory( registered_subject=self.registered_subject_infant, maternal_labour_del=self.maternal_labour_del) appointment = Appointment.objects.get( registered_subject=self.registered_subject_infant, visit_definition__code='2000') infant_visit = InfantVisitFactory( appointment=appointment) outgoing_tx = SerializeToTransaction().serialize( infant_visit.__class__, infant_visit, False, True, 'default') for transaction in serializers.deserialize("json", FieldCryptor('aes', 'local').decrypt(outgoing_tx.tx)): self.assertEqual(transaction.object.pk, infant_visit.pk)
def test_serializing_deserialing_visit_models_2000(self): InfantBirthFactory( registered_subject=self.registered_subject_infant, maternal_labour_del=self.maternal_labour_del) appointment = Appointment.objects.get( registered_subject=self.registered_subject_infant, visit_definition__code='2000') infant_visit = InfantVisitFactory( appointment=appointment) visit_model_classes = [ InfantBirthExam, InfantBirthFeedVaccine, InfantStoolCollection, InfantCongenitalAnomalies] for visit_model_class in visit_model_classes: visit_model = visit_model_class.objects.create( infant_visit=infant_visit, report_datetime=timezone.now() ) outgoing_tx = SerializeToTransaction().serialize( visit_model.__class__, visit_model, False, True, 'default') for transaction in serializers.deserialize("json", FieldCryptor('aes', 'local').decrypt(outgoing_tx.tx)): self.assertEqual(transaction.object.pk, visit_model.pk)
def test_serializing_deserialing_infant_offstudy(self): InfantBirthFactory( registered_subject=self.registered_subject_infant, maternal_labour_del=self.maternal_labour_del) appointment = Appointment.objects.get( registered_subject=self.registered_subject_infant, visit_definition__code='2000') infant_visit = InfantVisitFactory( appointment=appointment, reason=COMPLETED_PROTOCOL_VISIT) infant_offstudy = InfantOffStudy.objects.create( infant_visit=infant_visit, report_datetime=timezone.now(), registered_subject=self.registered_subject_infant, offstudy_date=date(2015, 12, 12), ) outgoing_tx = SerializeToTransaction().serialize( infant_offstudy.__class__, infant_offstudy, False, True, 'default') for transaction in serializers.deserialize("json", FieldCryptor('aes', 'local').decrypt(outgoing_tx.tx)): self.assertEqual(transaction.object.pk, infant_offstudy.pk)
def test_p3(self): survey = Survey.objects.all()[0] from bhp066.apps.bcpp_household.models import HouseholdStructure plot = PlotFactory(community='test_community6', household_count=1, status='residential_habitable') household = Household.objects.get(plot=plot) signals.post_save.disconnect(household_on_post_save, weak=False, dispatch_uid="post_save_on_household") signals.post_save.disconnect( household_structure_on_post_save, weak=False, dispatch_uid="household_structure_on_post_save") household_structure = HouseholdStructure.objects.get( household=household, survey=survey) representative_eligibility = RepresentativeEligibilityFactory( household_structure=household_structure) signals.post_save.connect(household_on_post_save, weak=False, dispatch_uid="post_save_on_household") signals.post_save.connect( household_structure_on_post_save, weak=False, dispatch_uid="household_structure_on_post_save") household_member = HouseholdMemberFactory( age_in_years=16, household_structure=household_structure, survey=survey) #loss = EnrollmentLossFactory(household_member = household_member) print 'get registered subject' registered_subject = RegisteredSubject.objects.get( subject_identifier=household_member.registered_subject. subject_identifier) from .factories import SubjectRefusalFactory household_member.member_status = 'REFUSED' subject_refusal = SubjectRefusalFactory( household_member=household_member) SubjectRefusal.objects.get(household_member=household_member).delete() subject_refusal_history = SubjectRefusalHistory.objects.get( household_member=household_member) self.assertEquals(EnrollmentLoss.objects.all().count(), 0) household_member.member_status = 'BHS_SCREEN' enrollment_checklist = EnrollmentChecklistFactory( household_member=household_member, initials=household_member.initials, has_identity='No') self.assertEquals(EnrollmentLoss.objects.all().count(), 1) #loss = EnrollmentLoss.objects.get(household_member=household_member) household_member.member_status = 'HTC_ELIGIBLE' subject_htc = SubjectHtcFactory(household_member=household_member) self.assertRaises( ValidationError, lambda: HouseholdInfoFactory( household_structure=household_structure, household_member=household_member)) household_member.age_in_years = 19 household_head_eligibility = HeadHouseholdEligibilityFactory( household_member=household_member) household_info = HouseholdInfoFactory( household_structure=household_structure, household_member=household_member) subject_absentee = SubjectAbsenteeFactory( household_member=household_member, registered_subject=registered_subject) self.assertEquals(EnrollmentChecklist.objects.all().count(), 0) subject_undecided = SubjectUndecidedFactory( household_member=household_member, registered_subject=registered_subject) subject_moved = SubjectMovedFactory( household_member=household_member, registered_subject=registered_subject) subject_absentee_entry = SubjectAbsenteeEntryFactory( subject_absentee=subject_absentee, report_datetime=date.today()) subject_undecided_entry = SubjectUndecidedEntryFactory( subject_undecided=subject_undecided, report_datetime=date.today()) subject_absentee_entry1 = SubjectAbsenteeEntryFactory( subject_absentee=subject_absentee, report_datetime=date.today() + timedelta(days=int(2))) subject_undecided_entry1 = SubjectUndecidedEntryFactory( subject_undecided=subject_undecided, report_datetime=date.today() + timedelta(days=int(2))) instances = [] instances.append(household_member) instances.append(registered_subject) #instances.append(enrollment_checklist) instances.append(household_structure) instances.append(household_info) #instances.append(subject_refusal) instances.append(subject_htc) instances.append(subject_refusal_history) #instances.append(loss) instances.append(household_head_eligibility) instances.append(subject_moved) instances.append(subject_absentee_entry) instances.append(subject_undecided_entry) instances.append(subject_absentee_entry1) instances.append(subject_undecided_entry1) print 'INSTANCE: ' + str(instances) for obj in instances: print 'test natural key on {0}'.format(obj._meta.object_name) natural_key = obj.natural_key() get_obj = obj.__class__.objects.get_by_natural_key(*natural_key) self.assertEqual(obj.pk, get_obj.pk) # pp = pprint.PrettyPrinter(indent=4) for obj in instances: print 'test serializing/deserializing {0}'.format( obj._meta.object_name) outgoing_transaction = SerializeToTransaction().serialize( obj.__class__, obj, False, True, 'default') # pp.pprint(FieldCryptor('aes', 'local').decrypt(outgoing_transaction.tx)) for transaction in serializers.deserialize( "json", FieldCryptor('aes', 'local').decrypt(outgoing_transaction.tx)): self.assertEqual(transaction.object.pk, obj.pk)
def test_p3(self): instances = [] plot = PlotFactory(community='test_community6', household_count=1, status='residential_habitable') household = Household.objects.get(plot=plot) household_structure = HouseholdStructure.objects.get( survey=Survey.objects.all()[0]) representative_eligibility = RepresentativeEligibilityFactory( household_structure=household_structure) household_member = HouseholdMemberFactory( household_structure=household_structure) enrollment_checklist = EnrollmentChecklistFactory( household_member=household_member, initials=household_member.initials, has_identity='Yes', dob=date(1989, 01, 01)) self.assertTrue(enrollment_checklist.is_eligible) instances.append(enrollment_checklist) self.assertEqual(RegisteredSubject.objects.all().count(), 1) registered_subject = RegisteredSubject.objects.all()[0] site = StudySite.objects.all()[0] subject_consent = SubjectConsentFactory( study_site=site, household_member=household_member, registered_subject=household_member.registered_subject, dob=enrollment_checklist.dob, initials=enrollment_checklist.initials) instances.append(subject_consent) self.assertEqual(Appointment.objects.all().count(), 1) appointment = Appointment.objects.get( registered_subject=registered_subject) subject_visit = SubjectVisitFactory(household_member=household_member, appointment=appointment) instances.append(subject_visit) aliquot_type = AliquotType.objects.all()[0] panel = Panel.objects.all()[0] subjects_requisition = SubjectRequisitionFactory( subject_visit=subject_visit, panel=panel, site=site, aliquot_type=aliquot_type, ) self.assertEqual(Aliquot.objects.all().count(), 0) subjects_requisition.is_receive = True subjects_requisition.is_receive_datetime = datetime.now() subjects_requisition.save() lab_profile = site_lab_profiles.get( subjects_requisition._meta.object_name) lab_profile().receive(subjects_requisition) receive = Receive.objects.all()[0] self.assertEqual(Aliquot.objects.all().count(), 1) aliquot = Aliquot.objects.all()[0] processing = ProcessingFactory(profile=AliquotProfile.objects.all()[0], aliquot=aliquot) for al in Aliquot.objects.all(): instances.append(al) instances.append(processing) instances.append(receive) self.assertEqual(PackingListItem.objects.all().count(), 0) packing_list = PackingListFactory( list_items=aliquot.aliquot_identifier) instances.append(packing_list) packing_list.list_items = al.aliquot_identifier print packing_list.list_items packing_list.save() #self.assertEquals(PackingListItem.objects.all().count(), 1) #instances.append(PackingListItem.objects.all()[0]) print 'INSTANCE: ' + str(instances) for obj in instances: print 'test natural key on {0}'.format(obj._meta.object_name) natural_key = obj.natural_key() get_obj = obj.__class__.objects.get_by_natural_key(*natural_key) self.assertEqual(obj.pk, get_obj.pk) # pp = pprint.PrettyPrinter(indent=4) for obj in instances: print 'test serializing/deserializing {0}'.format( obj._meta.object_name) outgoing_transaction = SerializeToTransaction().serialize( obj.__class__, obj, False, True, 'default') for transaction in serializers.deserialize( "json", FieldCryptor('aes', 'local').decrypt(outgoing_transaction.tx)): self.assertEqual(transaction.object.pk, obj.pk)
def test_p2(self): """Confirms all models have a get_by_natural_key manager method.""" self.startup() print 'get a community name from the mapper classes' site_mappers.autodiscover() mapper = site_mappers.get(site_mappers.get_as_list()[0]) print 'No. of SURVEY = ' + str(Survey.objects.all().count()) plot = PlotFactory(community=mapper().get_map_area(), status='residential_habitable') plot.save() print 'No. of HOUSEHOLDS = ' + str(Household.objects.all().count()) household = Household.objects.get(plot=plot) self.assertEquals(HouseholdStructure.objects.all().count(), 3) self.assertEquals(Survey.objects.all().count(), 3) household_structure = HouseholdStructure.objects.get( survey=Survey.objects.all()[0]) print 'No. of HOUSEHOLDS_STRUCTURE = ' + str( HouseholdStructure.objects.all().count()) HouseholdRefusalFactory(household_structure=household_structure) print 'No. of HOUSEHOLDS_REFUSALS = ' + str( HouseholdRefusal.objects.all().count()) print 'HOUSEHOLD_REFUSAL=' + str(HouseholdRefusal.objects.all()[0]) HouseholdRefusal.objects.get( household_structure=household_structure).delete() print 'No. of HOUSEHOLDS_REFUSALS = ' + str( HouseholdRefusal.objects.all().count()) household_structure.failed_enumeration_attempts = 3 household_assesment = HouseholdAssessmentFactory( household_structure=household_structure) household_log = HouseholdLog.objects.get( household_structure=household_structure) household_log_entry1 = HouseholdLogEntryFactory( household_log=household_log, report_datetime=date.today()) household_log_entry2 = HouseholdLogEntryFactory( household_log=household_log, report_datetime=date.today() + timedelta(days=1)) plot_log = PlotLogFactory(plot=plot) plot_log_entry1 = PlotLogEntryFactory(plot_log=plot_log, report_datetime=datetime.now()) plot_log_entry2 = PlotLogEntryFactory(plot_log=plot_log, report_datetime=datetime.now() + timedelta(days=1)) instances = [] instances.append(plot) instances.append(household) instances.append(household_structure) instances.append(household_assesment) instances.append(household_log) instances.append(plot_log_entry1) instances.append(plot_log_entry2) instances.append(plot_log) instances.append(household_log_entry1) instances.append(household_log_entry2) print 'INSTANCE: ' + str(instances) for obj in instances: print 'test natural key on {0}'.format(obj._meta.object_name) natural_key = obj.natural_key() get_obj = obj.__class__.objects.get_by_natural_key(*natural_key) self.assertEqual(obj.pk, get_obj.pk) # pp = pprint.PrettyPrinter(indent=4) for obj in instances: print 'test serializing/deserializing {0}'.format( obj._meta.object_name) outgoing_transaction = SerializeToTransaction().serialize( obj.__class__, obj, False, True, 'default') # pp.pprint(FieldCryptor('aes', 'local').decrypt(outgoing_transaction.tx)) for transaction in serializers.deserialize( "json", FieldCryptor('aes', 'local').decrypt(outgoing_transaction.tx)): self.assertEqual(transaction.object.pk, obj.pk)
def test_p3(self): RegisteredSubject.objects.all().delete() instances = [] self.assertEqual(ClinicEnrollmentLoss.objects.all().count(), 0) self.assertEqual(RegisteredSubject.objects.all().count(), 0) clinic_eligibility = ClinicEligibilityFactory() self.assertEqual(RegisteredSubject.objects.all().count(), 1) self.assertTrue(clinic_eligibility.is_eligible) clinic_eligibility.legal_marriage = 'No' clinic_eligibility.has_identity = 'No' clinic_eligibility.save() self.assertFalse(clinic_eligibility.is_eligible) self.assertEqual(ClinicEnrollmentLoss.objects.all().count(), 1) #clinic_loss = ClinicEnrollmentLoss.objects.all()[0] #instances.append(clinic_loss) clinic_eligibility.legal_marriage = 'Yes' clinic_eligibility.has_identity = 'Yes' clinic_eligibility.save() self.assertTrue(clinic_eligibility.is_eligible) instances.append(clinic_eligibility) self.assertEqual(RegisteredSubject.objects.all().count(), 1) clinic_consent = ClinicConsentFactory( registered_subject=clinic_eligibility.household_member. registered_subject, identity=clinic_eligibility.identity, dob=clinic_eligibility.dob, gender=clinic_eligibility.gender, first_name=clinic_eligibility.first_name, initials=clinic_eligibility.initials) self.assertEqual(Appointment.objects.all().count(), 1) instances.append(clinic_consent) self.assertEqual(RegisteredSubject.objects.all().count(), 1) registered_subject = RegisteredSubject.objects.get( dob=clinic_eligibility.dob, gender=clinic_eligibility.gender, first_name=clinic_eligibility.first_name, initials=clinic_eligibility.initials) appointment = Appointment.objects.get( registered_subject=registered_subject) clinic_visit = ClinicVisitFactory( appointment=appointment, household_member=clinic_eligibility.household_member) instances.append(clinic_visit) clinic_subject_locator = ClinicLocatorFactory( clinic_visit=clinic_visit) instances.append(clinic_subject_locator) questionnaire = QuestionnaireFactory(clinic_visit=clinic_visit) instances.append(questionnaire) # clinic_eligibility.has_identity = 'No' # clinic_eligibility.save() # self.assertFalse(clinic_eligibility.is_eligible) print 'INSTANCE: ' + str(instances) for obj in instances: print 'test natural key on {0}'.format(obj._meta.object_name) natural_key = obj.natural_key() get_obj = obj.__class__.objects.get_by_natural_key(*natural_key) self.assertEqual(obj.pk, get_obj.pk) #pp = pprint.PrettyPrinter(indent=4) for obj in instances: print 'test serializing/deserializing {0}'.format( obj._meta.object_name) outgoing_transaction = SerializeToTransaction().serialize( obj.__class__, obj, False, True, 'default') #print repr(FieldCryptor('aes', 'local').decrypt(outgoing_transaction.tx)) for transaction in serializers.deserialize( "json", FieldCryptor('aes', 'local').decrypt(outgoing_transaction.tx)): self.assertEqual(transaction.object.pk, obj.pk)