def get_parent_of_case(domain, case_id, parent_case_type):
case_accessor = CaseAccessors(domain)
try:
if not isinstance(case_id, basestring):
case_id = case_id.case_id
child_case = case_accessor.get_case(case_id)
except CaseNotFound:
raise ENikshayCaseNotFound("Couldn't find case: {}".format(case_id))
parent_case_ids = [
indexed_case.referenced_id for indexed_case in child_case.indices
if indexed_case.referenced_type == parent_case_type
]
parent_cases = case_accessor.get_cases(parent_case_ids)
open_parent_cases = [
occurrence_case for occurrence_case in parent_cases
if not occurrence_case.closed
]
if not open_parent_cases:
raise ENikshayCaseNotFound(
"Couldn't find any open {} cases for id: {}".format(
parent_case_type, case_id))
return open_parent_cases[0]
def get_open_episode_case_from_person(domain, person_case_id):
"""
Gets the first open 'episode' case for the person
Assumes the following case structure:
Person <--ext-- Occurrence <--ext-- Episode
"""
case_accessor = CaseAccessors(domain)
occurrence_cases = case_accessor.get_reverse_indexed_cases(
[person_case_id])
open_occurrence_cases = [
case for case in occurrence_cases
if not case.closed and case.type == CASE_TYPE_OCCURRENCE
]
if not open_occurrence_cases:
raise ENikshayCaseNotFound(
"Person with id: {} exists but has no open occurrence cases".
format(person_case_id))
occurrence_case = open_occurrence_cases[0]
episode_cases = case_accessor.get_reverse_indexed_cases(
[occurrence_case.case_id])
open_episode_cases = [
case for case in episode_cases
if not case.closed and case.type == CASE_TYPE_EPISODE and
case.dynamic_case_properties().get('episode_type') == "confirmed_tb"
]
if open_episode_cases:
return open_episode_cases[0]
else:
raise ENikshayCaseNotFound(
"Person with id: {} exists but has no open episode cases".format(
person_case_id))
def get_associated_episode_case_for_test(test_case, occurrence_case_id):
"""
get associated episode case set on the test case for new structure
if has a new_episode_id (for diagnostic -> confirmed_tb or dstb -> drtb episode transition)
return that episode which should be a confirmed_tb/confirmed_drtb case
elif has a episode_case_id (for follow up test cases)
return the associated episode case only
which should be a confirmed_tb/confirmed_drtb case
else
fallback to finding the open confirmed tb episode case
"""
test_case_properties = test_case.dynamic_case_properties()
test_case_episode_id = (test_case_properties.get('new_episode_case_id')
or test_case_properties.get('episode_case_id'))
if test_case_episode_id:
accessor = CaseAccessors(test_case.domain)
try:
return accessor.get_case(test_case_episode_id)
except CaseNotFound:
raise ENikshayCaseNotFound(
"Could not find episode case %s associated with test %s" %
(test_case_episode_id, test_case.get_id))
return get_open_episode_case_from_occurrence(test_case.domain,
occurrence_case_id)
def get_lab_referral_from_test(domain, test_case_id):
case_accessor = CaseAccessors(domain)
lab_referral_cases = case_accessor.get_reverse_indexed_cases(
[test_case_id], case_types=[CASE_TYPE_LAB_REFERRAL])
if lab_referral_cases:
return lab_referral_cases[0]
else:
raise ENikshayCaseNotFound(
"test with id: {} exists but has no lab referral cases".format(
test_case_id))
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)
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, episode_case
def get_first_parent_of_case(domain, case_id, parent_case_type):
parent_cases = get_all_parents_of_case(domain, case_id)
case_type_parent_cases = [
parent_case for parent_case in parent_cases if parent_case.type == parent_case_type
]
if not case_type_parent_cases:
raise ENikshayCaseNotFound(
"Couldn't find any {} cases for id: {}".format(parent_case_type, case_id)
)
return case_type_parent_cases[0]
def get_open_occurrence_case_from_person(domain, person_case_id):
"""
Gets the first open 'occurrence' case for the person
Assumes the following case structure:
Person <--ext-- Occurrence
"""
open_occurrence_cases = CaseAccessors(domain).get_reverse_indexed_cases(
[person_case_id], case_types=[CASE_TYPE_OCCURRENCE], is_closed=False)
if not open_occurrence_cases:
raise ENikshayCaseNotFound(
"Person with id: {} exists but has no open occurrence cases".
format(person_case_id))
return open_occurrence_cases[0]
def get_open_drtb_hiv_case_from_episode(domain, episode_case_id):
"""
Gets the first open 'drtb-hiv-referral' case for the episode
Assumes the following case structure:
episode <--ext-- drtb-hiv-referral
"""
case_accessor = CaseAccessors(domain)
open_drtb_cases = case_accessor.get_reverse_indexed_cases(
[episode_case_id], case_types=[CASE_TYPE_DRTB_HIV_REFERRAL], is_closed=False)
if open_drtb_cases:
return open_drtb_cases[0]
else:
raise ENikshayCaseNotFound(
"Occurrence with id: {} exists but has no open episode cases".format(episode_case_id)
)
def get_all_parents_of_case(domain, case_id):
case_accessor = CaseAccessors(domain)
try:
if not isinstance(case_id, basestring):
case_id = case_id.case_id
child_case = case_accessor.get_case(case_id)
except CaseNotFound:
raise ENikshayCaseNotFound("Couldn't find case: {}".format(case_id))
parent_case_ids = [
indexed_case.referenced_id for indexed_case in child_case.indices
]
parent_cases = case_accessor.get_cases(parent_case_ids)
return parent_cases
def get_open_occurrence_case_from_person(domain, person_case_id):
"""
Gets the first open 'occurrence' case for the person
Assumes the following case structure:
Person <--ext-- Occurrence
"""
case_accessor = CaseAccessors(domain)
occurrence_cases = case_accessor.get_reverse_indexed_cases([person_case_id])
open_occurrence_cases = [case for case in occurrence_cases
if not case.closed and case.type == CASE_TYPE_OCCURRENCE]
if not open_occurrence_cases:
raise ENikshayCaseNotFound(
"Person with id: {} exists but has no open occurrence cases".format(person_case_id)
)
return open_occurrence_cases[0]
def _get_voucher_parent(domain, voucher_case_id):
prescription = None
test = None
try:
prescription = get_first_parent_of_case(domain, voucher_case_id, CASE_TYPE_PRESCRIPTION)
except ENikshayCaseNotFound:
pass
try:
test = get_first_parent_of_case(domain, voucher_case_id, CASE_TYPE_TEST)
except ENikshayCaseNotFound:
pass
if not (prescription or test):
raise ENikshayCaseNotFound(
"Couldn't find any open parent prescription or test cases for id: {}".format(voucher_case_id)
)
assert not (prescription and test), "Didn't expect voucher to have prescription AND test parent"
return test or prescription
Assumes the following case structure:
Occurrence <--ext-- Episode
"""
open_episode_cases = CaseAccessors(domain).get_reverse_indexed_cases(
[occurrence_case_id], case_types=[CASE_TYPE_EPISODE], is_closed=False)
confirmed_episode_cases = [
case for case in open_episode_cases
if case.dynamic_case_properties().get('episode_type') == "confirmed_tb"
]
if confirmed_episode_cases:
return confirmed_episode_cases[0]
else:
raise ENikshayCaseNotFound(
"Occurrence with id: {} exists but has no open episode cases".
format(occurrence_case_id))
def get_open_drtb_hiv_case_from_episode(domain, episode_case_id):
"""
Gets the first open 'drtb-hiv-referral' case for the episode
Assumes the following case structure:
episode <--ext-- drtb-hiv-referral
"""
case_accessor = CaseAccessors(domain)
open_drtb_cases = case_accessor.get_reverse_indexed_cases(
[episode_case_id],
case_types=[CASE_TYPE_DRTB_HIV_REFERRAL],
is_closed=False)
@hqnottest
def get_lab_referral_from_test(domain, test_case_id):
case_accessor = CaseAccessors(domain)
reverse_indexed_cases = case_accessor.get_reverse_indexed_cases(
[test_case_id])
lab_referral_cases = [
case for case in reverse_indexed_cases
if case.type == CASE_TYPE_LAB_REFERRAL
]
if lab_referral_cases:
return lab_referral_cases[0]
else:
raise ENikshayCaseNotFound(
"test with id: {} exists but has no lab referral cases".format(
test_case_id))
def get_adherence_cases_by_day(domain, episode_case_id):
indexed_cases = CaseAccessors(domain).get_reverse_indexed_cases(
[episode_case_id])
adherence_cases = [
case for case in indexed_cases if case.type == CASE_TYPE_ADHERENCE
]
adherence = defaultdict(list) # datetime.date -> list of adherence cases
for case in adherence_cases:
# adherence_date is in India timezone
adherence_datetime = parse(
