def get_open_episode_case(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 == "occurrence"]
if not open_occurrence_cases:
raise AdherenceException(
message="Person with id: {} exists but has no open occurence cases".format(person_case_id)
)
occurence_case = open_occurrence_cases[0]
episode_cases = case_accessor.get_reverse_indexed_cases([occurence_case.case_id])
open_episode_cases = [case for case in episode_cases
if not case.closed and case.type == "episode" and
case.dynamic_case_properties().get('episode_type') == "confirmed_tb"]
if open_episode_cases:
return open_episode_cases[0]
else:
raise AdherenceException(
message="Person with id: {} exists but has no open episode cases".format(person_case_id)
)
def validate_dates(start_date, end_date):
if start_date is None:
raise AdherenceException("start_date is null")
if end_date is None:
raise AdherenceException("end_date is null")
try:
parse_datetime(start_date).astimezone(pytz.UTC)
parse_datetime(end_date).astimezone(pytz.UTC)
except:
raise AdherenceException("Malformed Date")
def update_episode_adherence_properties(domain, person_id):
try:
episode_case = get_open_episode_case_from_person(domain, person_id)
except ENikshayCaseNotFound as e:
raise AdherenceException(e.message)
try:
updater = EpisodeUpdater(domain)
updater.update_single_case(episode_case)
except Exception as e:
raise AdherenceException(
"Error calculating updates for episode case_id({}): {}".format(
episode_case.case_id, e))
def update_adherence_cases(self, start_date, end_date, confidence_level):
try:
adherence_cases = get_adherence_cases_between_dates(
self.domain, self.person_id, start_date, end_date)
except ENikshayCaseNotFound as e:
raise AdherenceException(e.message)
adherence_case_ids = [case.case_id for case in adherence_cases]
def _parse_adherence_date(self, iso_datestring):
tz = timezone(ENIKSHAY_TIMEZONE)
try:
datetime_from_adherence = parser.parse(iso_datestring)
datetime_in_india = datetime_from_adherence.astimezone(tz)
except ValueError:
raise AdherenceException(
"Adherence date should be an ISO8601 formated string with timezone information."
)
return datetime_in_india.date()
def validate_confidence_level(confidence_level):
valid_confidence_levels = ['low', 'medium', 'high']
if confidence_level not in valid_confidence_levels:
raise AdherenceException(
message="New confidence level invalid. Should be one of {}".format(
valid_confidence_levels))
def validate_adherence_values(adherence_values):
if adherence_values is None or not isinstance(adherence_values, list):
raise AdherenceException("Adherences invalid")
def validate_beneficiary_id(beneficiary_id):
if beneficiary_id is None:
raise AdherenceException("Beneficiary ID is null")
if not isinstance(beneficiary_id, basestring):
raise AdherenceException("Beneficiary ID should be a string")
def _episode_case(self):
try:
return get_open_episode_case_from_person(self.domain,
self._person_case.case_id)
except ENikshayCaseNotFound as e:
raise AdherenceException(e.message)
def _person_case(self):
try:
return self.case_accessor.get_case(self.person_id)
except CaseNotFound:
raise AdherenceException(
"No patient exists with this beneficiary ID")