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 create_180_treatment_payload(cls, episode_case):
episode_case_properties = episode_case.dynamic_case_properties()
person_case = get_person_case_from_episode(episode_case.domain,
episode_case.case_id)
pcp_location = cls._get_location(person_case.owner_id,
field_name="owner_id",
related_case_type="person",
related_case_id=person_case.case_id)
treatment_outcome_date = string_to_date_or_None(
episode_case_properties.get(TREATMENT_OUTCOME_DATE))
if treatment_outcome_date is None:
treatment_outcome_date = datetime.utcnow().date()
return cls(
EventID=TREATMENT_180_EVENT,
EventOccurDate=treatment_outcome_date,
BeneficiaryUUID=episode_case_properties.get(
LAST_VOUCHER_CREATED_BY_ID),
BeneficiaryType="mbbs",
EpisodeID=episode_case.case_id,
Location=person_case.owner_id,
DTOLocation=_get_district_location_id(pcp_location),
PersonId=person_case.get_case_property('person_id'),
AgencyId=cls._get_agency_id(
episode_case), # not migrated from UATBC, so we're good
# Incentives are not yet approved in eNikshay
EnikshayApprover=None,
EnikshayRole=None,
EnikshayApprovalDate=None,
)
def get_payload(self, repeat_record, episode_case):
"""
https://docs.google.com/document/d/1yUWf3ynHRODyVVmMrhv5fDhaK_ufZSY7y0h9ke5rBxU/edit#heading=h.6zwqb0ms7iz9
"""
person_case = get_person_case_from_episode(episode_case.domain,
episode_case.get_id)
episode_case_properties = episode_case.dynamic_case_properties()
base_properties = self._base_properties(repeat_record, person_case)
base_properties.update({
"PatientID":
episode_case_properties.get("nikshay_id"),
"OutcomeDate":
episode_case_properties.get(TREATMENT_OUTCOME_DATE),
"Outcome":
treatment_outcome.get(
episode_case_properties.get(TREATMENT_OUTCOME)),
"MO":
u"{} {}".format(
episode_case_properties.get(TREATMENT_SUPPORTER_FIRST_NAME),
episode_case_properties.get(TREATMENT_SUPPORTER_LAST_NAME),
),
"MORemark":
"None Collected in eNikshay",
})
return json.dumps(base_properties)
def create_ayush_referral_payload(cls, episode_case):
episode_case_properties = episode_case.dynamic_case_properties()
person_case = get_person_case_from_episode(episode_case.domain,
episode_case.case_id)
location = cls._get_location(
episode_case_properties.get("registered_by"),
field_name="registered_by",
related_case_type="episode",
related_case_id=episode_case.case_id,
)
if not location.user_id:
raise NikshayLocationNotFound(
"Location {} does not have a virtual location user".format(
location.location_id))
return cls(
EventID=AYUSH_REFERRAL_EVENT,
EventOccurDate=string_to_date_or_None(
episode_case.get_case_property(
FIRST_PRESCRIPTION_VOUCHER_REDEEMED_DATE)),
BeneficiaryUUID=location.user_id,
BeneficiaryType='ayush_other',
EpisodeID=episode_case.case_id,
Location=episode_case_properties.get("registered_by"),
DTOLocation=_get_district_location_id(location),
PersonId=person_case.get_case_property('person_id'),
AgencyId=cls._get_agency_id(
episode_case), # not migrated from UATBC, so we're good
# Incentives are not yet approved in eNikshay
EnikshayApprover=None,
EnikshayRole=None,
EnikshayApprovalDate=None,
)
def create_diagnosis_and_notification_payload(cls, episode_case):
person_case = get_person_case_from_episode(episode_case.domain,
episode_case.case_id)
location = cls._get_location(
person_case.owner_id,
field_name="owner_id",
related_case_type="person",
related_case_id=person_case.case_id,
)
return cls(
EventID=DIAGNOSIS_AND_NOTIFICATION_EVENT,
EventOccurDate=string_to_date_or_None(
episode_case.get_case_property(
FIRST_PRESCRIPTION_VOUCHER_REDEEMED_DATE)),
BeneficiaryUUID=episode_case.dynamic_case_properties().get(
NOTIFYING_PROVIDER_USER_ID),
BeneficiaryType=LOCATION_TYPE_MAP[location.location_type.code],
EpisodeID=episode_case.case_id,
Location=person_case.owner_id,
DTOLocation=_get_district_location_id(location),
PersonId=person_case.get_case_property('person_id'),
AgencyId=cls._get_agency_id(
episode_case), # not migrated from UATBC, so we're good
# Incentives are not yet approved in eNikshay
EnikshayApprover=None,
EnikshayRole=None,
EnikshayApprovalDate=None,
)
def is_valid_episode_submission(episode_case):
try:
person_case = get_person_case_from_episode(episode_case.domain,
episode_case)
except ENikshayCaseNotFound:
return False
return not _is_submission_from_test_location(person_case)
def __init__(self, *args, **kwargs):
super(HistoricalAdherenceReport, self).__init__(*args, **kwargs)
self.episode = CaseAccessors(self.domain).get_case(
self.episode_case_id)
self.episode_properties = self.episode.dynamic_case_properties()
self.person = get_person_case_from_episode(self.domain,
self.episode_case_id)
def create_successful_treatment_payload(cls, episode_case):
person_case = get_person_case_from_episode(episode_case.domain,
episode_case.case_id)
if person_case.owner_id == ARCHIVED_CASE_OWNER_ID:
owner_id = person_case.dynamic_case_properties().get('last_owner')
location = cls._get_location(
person_case.dynamic_case_properties().get('last_owner'),
field_name="last_owner",
related_case_type="person",
related_case_id=person_case.case_id,
)
else:
owner_id = person_case.owner_id
location = cls._get_location(person_case.owner_id,
field_name="owner_id",
related_case_type="person",
related_case_id=person_case.case_id)
return cls(
EventID=SUCCESSFUL_TREATMENT_EVENT,
EventOccurDate=cls._get_successful_treatment_date(episode_case),
BeneficiaryUUID=person_case.case_id,
BeneficiaryType="patient",
EpisodeID=episode_case.case_id,
Location=owner_id,
DTOLocation=_get_district_location_id(location),
PersonId=person_case.get_case_property('person_id'),
AgencyId=cls._get_agency_id(
episode_case), # we don't have this for migrated cases
# Incentives are not yet approved in eNikshay
EnikshayApprover=None,
EnikshayRole=None,
EnikshayApprovalDate=None,
)
def create_drug_refill_payload(cls, episode_case, n):
episode_case_properties = episode_case.dynamic_case_properties()
person_case = get_person_case_from_episode(episode_case.domain,
episode_case.case_id)
event_date = string_to_date_or_None(
episode_case_properties.get(
PRESCRIPTION_TOTAL_DAYS_THRESHOLD.format(n)))
pcp_location = cls._get_location(
person_case.owner_id,
field_name="owner_id",
related_case_type="person",
related_case_id=person_case.case_id,
)
return cls(
EventID=DRUG_REFILL_EVENT,
EventOccurDate=event_date,
BeneficiaryUUID=person_case.case_id,
BeneficiaryType="patient",
EpisodeID=episode_case.case_id,
Location=person_case.owner_id,
DTOLocation=_get_district_location_id(pcp_location),
PersonId=person_case.get_case_property('person_id'),
AgencyId=cls._get_agency_id(
episode_case), # we don't have this for migrated cases
# Incentives are not yet approved in eNikshay
EnikshayApprover=None,
EnikshayRole=None,
EnikshayApprovalDate=None,
)
def _add_row(self,
episode_id,
episode_case,
episode_case_properties,
should_be_forwarded,
error_message=None):
person_case = get_person_case_from_episode(DOMAIN, episode_id)
person_enikshay_id = person_case.dynamic_case_properties().get(
'person_id')
if error_message:
# add blanks for pending columns to append correctly for repeat record attempts later
row = [
person_enikshay_id, episode_id, should_be_forwarded,
error_message, '', '', '', ''
]
else:
row = [
person_enikshay_id,
episode_id,
should_be_forwarded,
episode_case_properties.get('nikshay_registered'),
episode_case_properties.get('private_nikshay_registered'),
episode_case_properties.get('nikshay_id'),
episode_case.external_id,
'->'.join(self._nikshay_id_update_history(episode_case)),
episode_case_properties.get('nikshay_error'),
episode_case_properties.get('private_nikshay_error'),
]
self._add_report_record_attempts(row, episode_id)
self.ws.append(row)
def __init__(self, *args, **kwargs):
super(HistoricalAdherenceReport, self).__init__(*args, **kwargs)
try:
self.episode = CaseAccessors(self.domain).get_case(self.episode_case_id)
except CaseNotFound:
raise BadRequestError()
self.episode_properties = self.episode.dynamic_case_properties()
self.person = get_person_case_from_episode(self.domain, self.episode_case_id)
def is_valid_episode_submission(episode_case):
try:
person_case = get_person_case_from_episode(episode_case.domain, episode_case)
except ENikshayCaseNotFound:
return False
if person_case.dynamic_case_properties().get('case_version') == PERSON_CASE_2B_VERSION:
return person_case.dynamic_case_properties().get('dataset') == REAL_DATASET_PROPERTY_VALUE
return not _is_submission_from_test_location(person_case.case_id, person_case.owner_id)
def is_valid_case(self, domain, episode):
if episode.get_case_property('datamigration_interim_outcome') != 'yes':
# Filter and skip private cases
try:
person = get_person_case_from_episode(domain, episode.case_id)
except ENikshayCaseNotFound:
return False
return person.get_case_property(ENROLLED_IN_PRIVATE) != 'true'
return False
def is_valid_archived_submission(episode_case):
try:
person_case = get_person_case_from_episode(episode_case.domain, episode_case)
except ENikshayCaseNotFound:
return False
owner_id = person_case.owner_id
if owner_id == ARCHIVED_CASE_OWNER_ID:
owner_id = person_case.dynamic_case_properties().get('last_owner', None)
return not _is_submission_from_test_location(person_case.case_id, owner_id)
def should_migrate_case(case_id, case_properties, domain):
if (case_properties.get('datamigration_diagnosis_test_information2') !=
'yes'
and case_properties.get('episode_type') == 'confirmed_tb'):
# Filter and skip private cases
try:
person = get_person_case_from_episode(domain, case_id)
except ENikshayCaseNotFound:
return False
if person.get_case_property(ENROLLED_IN_PRIVATE) != 'true':
return True
return False
def get_person(self, adherence):
assert adherence.type in [CASE_TYPE_ADHERENCE, CASE_TYPE_EPISODE], \
"Unexpected Case type instead of %s and %s" % (CASE_TYPE_ADHERENCE, CASE_TYPE_EPISODE)
if 'person' not in self.context:
if adherence.type == CASE_TYPE_EPISODE:
episode = adherence
else:
episode = self.get_episode(adherence)
self.context['person'] = get_person_case_from_episode(
DOMAIN, episode.case_id)
return self.context['person']
def is_valid_archived_submission(episode_case):
try:
person_case = get_person_case_from_episode(episode_case.domain, episode_case)
except ENikshayCaseNotFound:
return False
if person_case.dynamic_case_properties().get('case_version') == PERSON_CASE_2B_VERSION:
return person_case.dynamic_case_properties().get('dataset') == REAL_DATASET_PROPERTY_VALUE
owner_id = person_case.owner_id
if owner_id == ARCHIVED_CASE_OWNER_ID:
owner_id = person_case.dynamic_case_properties().get('last_owner', None)
return not _is_submission_from_test_location(person_case.case_id, owner_id)
def _should_be_forwarded(episode_case, episode_case_properties):
"""
This would add False for cases that have already been forwarded but
is a good to have for other cases that are expected to be notified
"""
person_case = get_person_case_from_episode(DOMAIN, episode_case)
return (not episode_case_properties.get('nikshay_registered', 'false')
== 'true' and not episode_case_properties.get(
'nikshay_registered', 'false') == 'true'
and not episode_case_properties.get('nikshay_id', False)
and episode_case_properties.get('episode_type')
== DSTB_EPISODE_TYPE
and is_valid_person_submission(person_case))
def _get_open_episode_cases(self, case_ids):
case_accessor = CaseAccessors(self.domain)
episode_cases = case_accessor.iter_cases(case_ids)
for episode_case in episode_cases:
# if this episode is part of a deleted or archived person, don't update
try:
person_case = get_person_case_from_episode(self.domain, episode_case.case_id)
except ENikshayCaseNotFound:
continue
if person_case.owner_id == ARCHIVED_CASE_OWNER_ID:
continue
if person_case.closed:
continue
yield episode_case
def allowed_to_forward(self, episode_case):
# When case property episode.episode_pending_registration transitions from 'yes' to 'no',
# and (episode.nikshay_registered != 'true' or episode.nikshay_id != '')
allowed_case_types_and_users = self._allowed_case_type(episode_case) and self._allowed_user(episode_case)
if allowed_case_types_and_users:
episode_case_properties = episode_case.dynamic_case_properties()
person_case = get_person_case_from_episode(episode_case.domain, episode_case.get_id)
return (
not episode_case_properties.get('nikshay_registered', 'false') == 'true' and
not episode_case_properties.get('nikshay_id', False) and
case_properties_changed(episode_case, [EPISODE_PENDING_REGISTRATION]) and
episode_case_properties.get(EPISODE_PENDING_REGISTRATION, 'yes') == 'no' and
not test_submission(person_case)
)
else:
return False
def create_180_treatment_payload(cls, episode_case):
episode_case_properties = episode_case.dynamic_case_properties()
person_case = get_person_case_from_episode(episode_case.domain,
episode_case.case_id)
location = cls._get_location(person_case.owner_id,
field_name="owner_id",
related_case_type="person",
related_case_id=person_case.case_id)
return cls(
EventID=TREATMENT_180_EVENT,
EventOccurDate=episode_case_properties.get(TREATMENT_OUTCOME_DATE),
BeneficiaryUUID=episode_case_properties.get(
LAST_VOUCHER_CREATED_BY_ID),
BeneficiaryType="patient",
EpisodeID=episode_case.case_id,
Location=location.metadata["nikshay_code"],
)
def allowed_to_forward(self, episode_case):
allowed_case_types_and_users = self._allowed_case_type(episode_case) and self._allowed_user(episode_case)
if not allowed_case_types_and_users:
return False
try:
person_case = get_person_case_from_episode(episode_case.domain, episode_case.get_id)
except ENikshayCaseNotFound:
return False
episode_case_properties = episode_case.dynamic_case_properties()
return (
episode_case_properties.get('private_nikshay_registered', 'false') == 'false' and
not episode_case_properties.get('nikshay_id') and
valid_nikshay_patient_registration(episode_case_properties, private_registration=True) and
case_properties_changed(episode_case, [PRIVATE_PATIENT_EPISODE_PENDING_REGISTRATION]) and
is_valid_person_submission(person_case)
)
def create_successful_treatment_payload(cls, episode_case):
episode_case_properties = episode_case.dynamic_case_properties()
person_case = get_person_case_from_episode(episode_case.domain,
episode_case.case_id)
location = cls._get_location(
person_case.dynamic_case_properties().get('last_owner'),
field_name="last_owner",
related_case_type="person",
related_case_id=person_case.case_id,
)
return cls(
EventID=SUCCESSFUL_TREATMENT_EVENT,
EventOccurDate=episode_case_properties[TREATMENT_OUTCOME_DATE],
BeneficiaryUUID=person_case.case_id,
BeneficiaryType="patient",
EpisodeID=episode_case.case_id,
Location=location.metadata["nikshay_code"],
)
def create_diagnosis_and_notification_payload(cls, episode_case):
person_case = get_person_case_from_episode(episode_case.domain,
episode_case.case_id)
location = cls._get_location(
person_case.owner_id,
field_name="owner_id",
related_case_type="person",
related_case_id=person_case.case_id,
)
return cls(
EventID=DIAGNOSIS_AND_NOTIFICATION_EVENT,
EventOccurDate=cls._india_now(),
BeneficiaryUUID=episode_case.dynamic_case_properties().get(
NOTIFYING_PROVIDER_USER_ID),
BeneficiaryType=LOCATION_TYPE_MAP[location.location_type],
EpisodeID=episode_case.case_id,
Location=location.metadata["nikshay_code"],
)
def create_drug_refill_payload(cls, episode_case, n):
episode_case_properties = episode_case.dynamic_case_properties()
person_case = get_person_case_from_episode(episode_case.domain,
episode_case.case_id)
event_date = episode_case_properties.get(
PRESCRIPTION_TOTAL_DAYS_THRESHOLD.format(n))
pcp_location = cls._get_location(
person_case.owner_id,
field_name="owner_id",
related_case_type="person",
related_case_id=person_case.case_id,
)
return cls(EventID=DRUG_REFILL_EVENT,
EventOccurDate=event_date,
BeneficiaryUUID=person_case.case_id,
BeneficiaryType="patient",
EpisodeID=episode_case.case_id,
Location=person_case.owner_id,
DTOLocation=_get_district_location(pcp_location))
def _get_open_episode_cases(self, case_ids):
case_accessor = CaseAccessors(self.domain)
episode_cases = case_accessor.iter_cases(case_ids)
for episode_case in episode_cases:
# only run on private sector
if episode_case.get_case_property(ENROLLED_IN_PRIVATE) != 'true':
continue
# if this episode is part of a deleted or archived person, don't update
try:
person_case = get_person_case_from_episode(
self.domain, episode_case.case_id)
except ENikshayCaseNotFound:
continue
if person_case.owner_id == ARCHIVED_CASE_OWNER_ID:
continue
if person_case.closed:
continue
yield episode_case
def create_180_treatment_payload(cls, episode_case):
episode_case_properties = episode_case.dynamic_case_properties()
person_case = get_person_case_from_episode(episode_case.domain,
episode_case.case_id)
pcp_location = cls._get_location(person_case.owner_id,
field_name="owner_id",
related_case_type="person",
related_case_id=person_case.case_id)
treatment_outcome_date = episode_case_properties.get(
TREATMENT_OUTCOME_DATE, None)
if treatment_outcome_date is None:
treatment_outcome_date = datetime.utcnow().strftime("%Y-%m-%d")
return cls(
EventID=TREATMENT_180_EVENT,
EventOccurDate=treatment_outcome_date,
BeneficiaryUUID=episode_case_properties.get(
LAST_VOUCHER_CREATED_BY_ID),
BeneficiaryType="mbbs",
EpisodeID=episode_case.case_id,
Location=person_case.owner_id,
DTOLocation=_get_district_location(pcp_location),
)
def test_get_person_case_from_episode(self):
self.assertEqual(
get_person_case_from_episode(self.domain, self.episode_id).case_id,
self.person_id)
def get_person(self, episode):
if 'person' not in self.context:
self.context['person'] = get_person_case_from_episode(
DOMAIN, episode.case_id)
return self.context['person']
def _get_person_case(self, episode_case):
return get_person_case_from_episode(episode_case.domain,
episode_case.get_id)
