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)