def _get_cases(self, episode_or_person):
if episode_or_person.type == CASE_TYPE_PERSON:
person_case = episode_or_person
episode_case = get_open_episode_case_from_person(person_case.domain, person_case.case_id)
occurrence_case = get_occurrence_case_from_episode(episode_case.domain, episode_case.case_id)
elif episode_or_person.type == CASE_TYPE_EPISODE:
episode_case = episode_or_person
occurrence_case = get_occurrence_case_from_episode(episode_case.domain, episode_case.case_id)
person_case = get_person_case_from_occurrence(episode_case.domain, occurrence_case.case_id)
else:
raise ENikshayCaseNotFound("wrong case passed to repeater")
return person_case, occurrence_case, episode_case
def get_payload(self, repeat_record, episode_case):
occurence_case = get_occurrence_case_from_episode(
episode_case.domain, episode_case.case_id)
person_case = get_person_case_from_occurrence(episode_case.domain,
occurence_case)
return json.dumps(
PatientPayload.create(person_case, episode_case).to_json())
def get_payload(self, repeat_record, episode_case):
"""
https://docs.google.com/document/d/1yUWf3ynHRODyVVmMrhv5fDhaK_ufZSY7y0h9ke5rBxU/edit#heading=h.a9uhx3ql595c
"""
person_case = get_person_case_from_episode(episode_case.domain, episode_case.get_id)
episode_case_properties = episode_case.dynamic_case_properties()
person_case_properties = person_case.dynamic_case_properties()
occurence_case = None
use_2b_app_structure = self.use_2b_app_structure(person_case)
if use_2b_app_structure:
occurence_case = get_occurrence_case_from_episode(episode_case.domain, episode_case.get_id)
properties_dict = self._base_properties(repeat_record)
properties_dict.update({
"dotcenter": "NA",
"Local_ID": person_case.get_id,
})
try:
properties_dict.update(_get_person_case_properties(
episode_case, person_case, person_case_properties))
except NikshayLocationNotFound as e:
_save_error_message(person_case.domain, person_case.case_id, e)
properties_dict.update(_get_episode_case_properties(
episode_case_properties, occurence_case, person_case, use_2b_app_structure))
return json.dumps(properties_dict)
def _occurrence_case(self):
try:
return get_occurrence_case_from_episode(self.domain,
self._episode_case)
except ENikshayCaseNotFound as e:
raise NinetyNineDotsException(e)
def get_payload(self, repeat_record, payload_doc):
occurence_case = get_occurrence_case_from_episode(payload_doc.domain, payload_doc.case_id)
person_case = get_person_case_from_occurrence(payload_doc.domain, occurence_case)
person_case_properties = person_case.dynamic_case_properties()
data = PatientPayload(
beneficiary_id=person_case.case_id,
phone_numbers=_get_phone_numbers(person_case_properties),
merm_id=person_case_properties.get('merm_id', None),
)
return json.dumps(data.to_json())
def get_payload(self, repeat_record, payload_doc):
occurence_case = get_occurrence_case_from_episode(
payload_doc.domain, payload_doc.case_id)
person_case = get_person_case_from_occurrence(payload_doc.domain,
occurence_case)
person_case_properties = person_case.dynamic_case_properties()
data = PatientPayload(
beneficiary_id=person_case.case_id,
phone_numbers=_get_phone_numbers(person_case_properties),
merm_id=person_case_properties.get('merm_id', None),
)
return json.dumps(data.to_json())
def get_payload(self, repeat_record, episode_case):
domain = episode_case.domain
person_case = get_person_case_from_occurrence(
domain,
get_occurrence_case_from_episode(domain,
episode_case.case_id).case_id)
episode_case_properties = episode_case.dynamic_case_properties()
payload = {
'beneficiary_id': person_case.case_id,
'end_date': episode_case_properties.get(TREATMENT_OUTCOME_DATE),
'treatment_outcome':
episode_case_properties.get(TREATMENT_OUTCOME),
}
return json.dumps(payload)
def get_payload(self, repeat_record, adherence_case):
domain = adherence_case.domain
person_case = get_person_case_from_occurrence(
domain, get_occurrence_case_from_episode(
domain, get_episode_case_from_adherence(domain, adherence_case.case_id).case_id
).case_id
)
adherence_case_properties = adherence_case.dynamic_case_properties()
date = parse_date(adherence_case.dynamic_case_properties().get('adherence_date'))
payload = {
'beneficiary_id': person_case.case_id,
'adherence_date': date.isoformat(),
'adherence_source': adherence_case_properties.get('adherence_source'),
'adherence_value': adherence_case_properties.get('adherence_value'),
}
return json.dumps(payload)
def suspect_case(self):
try:
occurrence = get_occurrence_case_from_episode(self.domain, self.episode.case_id)
except ENikshayCaseNotFound:
return False
cases = CaseAccessors(self.domain).get_reverse_indexed_cases([occurrence.case_id])
suspect_cases = [case for case in cases if
case.type == 'episode'
and case.get_case_property('episode_type') == 'presumptive_tb']
if len(suspect_cases) == 1:
return suspect_cases[0]
else:
# if there is more than one suspect case, also return None, since
# that is an indeterminate case
return None
def get_relevant_test_case(domain, episode_case, error_logger):
try:
occurrence_case = get_occurrence_case_from_episode(domain, episode_case.case_id)
except ENikshayCaseNotFound:
error_logger.writerow([episode_case.case_id])
return None
indexed_cases = CaseAccessors(domain).get_reverse_indexed_cases([occurrence_case.case_id])
test_cases = [
case for case in indexed_cases
if case.type == 'test'
and case.get_case_property('rft_general') == 'diagnosis_dstb'
and case.get_case_property('result') == 'tb_detected'
]
if test_cases:
return sorted(test_cases, key=lambda c: c.get_case_property('date_reported'))[-1]
else:
return None
def get_payload(self, repeat_record, episode_case):
domain = episode_case.domain
person_case = get_person_case_from_occurrence(
domain, get_occurrence_case_from_episode(
domain, episode_case.case_id
).case_id
)
if episode_case.closed:
reason = episode_case.get_case_property('close_reason')
elif episode_case.get_case_property('dots_99_enabled') == 'false':
reason = 'source_changed'
else:
reason = 'unknown'
payload = {
'beneficiary_id': person_case.case_id,
'reason': reason,
}
return json.dumps(payload)
def get_relevant_test_case(domain, episode_case,
test_confirming_diagnosis):
try:
occurrence_case = get_occurrence_case_from_episode(
domain, episode_case.case_id)
except ENikshayCaseNotFound:
return None
indexed_cases = CaseAccessors(domain).get_reverse_indexed_cases(
[occurrence_case.case_id])
test_cases = [
case for case in indexed_cases if case.type == 'test' and (
case.get_case_property('rft_general') == 'diagnosis_dstb'
or case.get_case_property('rft_general') == 'diagnosis_drtb')
and case.get_case_property('result') == 'tb_detected' and case.
get_case_property('test_type_value') == test_confirming_diagnosis
]
if test_cases:
return sorted(
test_cases,
key=lambda c: c.get_case_property('date_reported'))[-1]
else:
return None
def get_occurrence(self, episode):
if 'occurrence' not in self.context:
self.context['occurrence'] = get_occurrence_case_from_episode(DOMAIN, episode.case_id)
return self.context['occurrence']
else:
return get_relevant_episode_case_by_dates(open_active_episode_cases, log_progress=self.log_progress)
def reconcile_cases(self, open_occurrence_cases, person_case_id):
"""
Find the occurrence with most relevant reconciled(if needed) episode case
"""
open_occurrence_case_ids = [case.case_id for case in open_occurrence_cases]
# get reconciled(if needed) episode cases for all open occurrences
all_open_active_episode_cases_for_person = []
for open_occurrence_case_id in open_occurrence_case_ids:
all_open_active_episode_cases_for_person += self.get_open_active_reconciled_episode_cases_for_occurrence(
open_occurrence_case_id)
if all_open_active_episode_cases_for_person:
relevant_episode_case = self.get_relevant_episode_case(all_open_active_episode_cases_for_person)
retain_case = get_occurrence_case_from_episode(DOMAIN, relevant_episode_case)
self.close_cases(open_occurrence_cases, retain_case, person_case_id, "occurrence")
else:
# Log the case where no open and active episode case was found for reconciliation
# This should imply a person with multiple open occurrence cases but none of them with
# an open and active episode case to consider
self.writerow({
"case_type": "occurrence",
"associated_case_id": person_case_id,
"notes": "Found no active open episodes cases to reconcile occurrences for this person"
})
def close_cases(self, all_cases, retain_case, associated_case_id, reconciling_case_type):
# remove duplicates in case ids to remove so that we don't retain and close
# the same case by mistake
all_case_ids = set([case.case_id for case in all_cases])
def test_get_occurrence_case_from_episode(self):
self.assertEqual(
get_occurrence_case_from_episode(self.domain, self.episode_id).case_id,
self.occurrence_id
)
def test_get_occurrence_case_from_episode(self):
self.assertEqual(
get_occurrence_case_from_episode(self.domain,
self.episode_id).case_id,
self.occurrence_id)
def handle(self, commit, domain, log_path, **options):
commit = commit
factory = CaseFactory(domain)
headers = [
'case_id',
'case_type',
'test_date_tested',
'test_result',
'test_interim_outcome',
'episode_interim_outcome',
'episode_interim_outcome_history',
'datamigration_interim_outcome',
]
print("Starting {} migration on {} at {}".format(
"real" if commit else "fake", domain, datetime.datetime.utcnow()))
case_ids = [
hit['_id'] for hit in (CaseSearchES().domain(
domain).case_type("episode").case_property_query(
"episode_type", "confirmed_drtb", "must").run().hits)
]
with open(log_path, "w") as log_file:
writer = csv.writer(log_file)
writer.writerow(headers)
accessor = CaseAccessors(domain=domain)
for episode in accessor.iter_cases(case_ids):
if self.is_valid_case(domain, episode):
# Get all follow up tests with a result
occurrence = get_occurrence_case_from_episode(
domain, episode.case_id)
tests = [
case for case in accessor.get_reverse_indexed_cases(
[occurrence.get_id])
if case.type == CASE_TYPE_TEST and case.
get_case_property('rft_general') == 'follow_up_drtb'
and case.get_case_property('result_recorded') == 'yes'
]
tests = sorted(
tests,
key=lambda test: test.get_case_property('date_tested'))
interim_outcome = ''
interim_outcome_history = ''
for i in range(1, len(tests)):
test_interim_outcome = None
test_interim_outcome_text = None
current_test = tests[i]
current_test_date = datetime.datetime.strptime(
current_test.get_case_property('date_tested'),
"%Y-%m-%d").date()
prev_test = tests[i - 1]
prev_test_date = datetime.datetime.strptime(
prev_test.get_case_property('date_tested'),
"%Y-%m-%d").date()
if (current_test_date - prev_test_date).days >= 30:
if (prev_test.get_case_property('result')
== TEST_RESULT_TB_NOT_DETECTED and
current_test.get_case_property('result')
== TEST_RESULT_TB_NOT_DETECTED and
interim_outcome != 'culture_conversion'):
test_interim_outcome = 'culture_conversion'
test_interim_outcome_text = "Culture Conversion"
elif (prev_test.get_case_property('result')
== TEST_RESULT_TB_DETECTED
and current_test.get_case_property('result')
== TEST_RESULT_TB_DETECTED
and interim_outcome == 'culture_conversion'):
test_interim_outcome = 'culture_reversion'
test_interim_outcome_text = "Culture Reversion"
if test_interim_outcome:
interim_outcome = test_interim_outcome
interim_outcome_history = prev_test_date.strftime("%d/%m/%y") + ": " + \
test_interim_outcome_text + '\n' + interim_outcome_history
writer.writerow([
current_test.case_id, "test",
current_test.get_case_property(
'date_tested'),
current_test.get_case_property('result'),
test_interim_outcome, None, None, "yes"
])
print('Updating {}...'.format(
current_test.case_id))
case_structure = CaseStructure(
case_id=current_test.case_id,
walk_related=False,
attrs={
"create": False,
"update": {
"interim_outcome":
test_interim_outcome,
"datamigration_interim_outcome":
"yes",
},
},
)
if commit:
factory.create_or_update_case(
case_structure)
else:
writer.writerow([
current_test.case_id, "test",
current_test.get_case_property(
'date_tested'),
current_test.get_case_property('result'),
None, None, None, "no"
])
# update episode if needed
if interim_outcome:
writer.writerow([
episode.case_id, "episode", None, None, None,
interim_outcome, interim_outcome_history, "yes"
])
print('Updating {}...'.format(episode.case_id))
case_structure = CaseStructure(
case_id=episode.case_id,
walk_related=False,
attrs={
"create": False,
"update": {
"interim_outcome": interim_outcome,
"interim_outcome_history":
interim_outcome_history,
"datamigration_interim_outcome": "yes",
},
},
)
if commit:
factory.create_or_update_case(case_structure)
else:
writer.writerow([
episode.case_id, "episode", None, None, None, None,
None, "no"
])
print("Migration finished at {}".format(datetime.datetime.utcnow()))
