def show(self):
key = "ds_{}".format(self.state['dataset'])
if Store.exists(key):
sections = Store.get(key)
if self.state['section'] in sections.keys():
data_elements = sections[
self.state['section']]['data_elements']
data_element_index = int(self.state['data_element_index'])
if data_element_index < len(data_elements):
# append the category option combination name is not default, then append it to the data element
# name
menu_text = data_elements[data_element_index][
'data_element_name']
cat_opt_combo_name = data_elements[data_element_index][
'category_option_combo_name']
menu_text += " - {}".format(
cat_opt_combo_name
) if cat_opt_combo_name != 'default' else ""
return self.ussd_proceed(menu_text)
else:
self.next()
return self.ussd_end("No data sets found")
def cache_datasets_with_their_data_elements():
for dataset in Dataset.objects.all():
dataset_sections = {}
for i, section in enumerate(dataset.section_set.all()):
dataset_sections[i + 1] = {
'name': section.name,
'id': section.section_id,
'data_elements': []
}
for sec_de in section.sectiondataelement_set.all():
de = sec_de.data_element
for coc in de.category_combo.categoryoptioncombo_set.all():
dataset_sections[i + 1]['data_elements'].append({
'data_element_name':
de.name,
'data_element_id':
de.data_element_id,
'category_option_combo_name':
coc.name,
'category_option_combo_id':
coc.category_option_combo_id,
'data_element_value_type':
de.value_type
})
Store.set("ds_{}".format(dataset.dataset_id), dataset_sections)
logger.info(
'Caching datasets with sections, data elements and category combos ............ Done'
)
def validate(self):
key = "usr_{}".format(self.state['passcode'])
if Store.exists(key):
org_units = Store.get(key)
if self.user_response in org_units.keys():
self.state['org_unit'] = org_units[self.user_response]['id']
self.save()
return True
return False
def show(self):
key = "ou_{}".format(self.state['org_unit'])
if Store.exists(key):
datasets = Store.get(key)
menu_text = "Data set:\n"
for key, value in datasets.items():
menu_text += "{}. {}\n".format(key, value['name'])
return self.ussd_proceed(menu_text)
return self.ussd_end("No data set found.")
def show(self):
key = "ds_{}".format(self.state['dataset'])
if Store.exists(key):
sections = Store.get(key)
menu_text = "Section:\n"
for key, value in sections.items():
menu_text += "{}. {}\n".format(key, value['name'])
return self.ussd_proceed(menu_text)
return self.ussd_end("No sections found.")
def show(self):
key = "usr_{}".format(self.state['passcode'])
if Store.exists(key):
org_units = Store.get(key)
menu_text = "Org unit:\n"
for key, value in org_units.items():
menu_text += "{}. {}\n".format(key, value['name'])
return self.ussd_proceed(menu_text)
return self.ussd_end("No org unit found.")
def next(self):
key = "usr_state_{}".format(
self.state['passcode']) # used to restore an expired session
if Store.exists(key) and Store.get(key) != self.session_id:
from apps.dhis.ussd.screen import RestoreSessionScreen
return RestoreSessionScreen(session_id=self.session_id,
phone_number=self.phone_number).show()
else:
from apps.dhis.ussd.screen import OrgUnitScreen
return OrgUnitScreen(session_id=self.session_id,
phone_number=self.phone_number).show()
def validate(self):
key = "ds_{}".format(self.state['dataset'])
if Store.exists(key):
sections = Store.get(key)
if self.user_response in sections.keys():
# self.state['section'] = sections[self.user_response]['id']
self.state['section'] = self.user_response
# Always reset the data element index in the selected section to 0 to show the first data element.
self.state['data_element_index'] = 0
self.save()
return True
return False
def validate(self):
key = "ou_{}".format(self.state['org_unit'])
if Store.exists(key):
datasets = Store.get(key)
if self.user_response in datasets.keys():
self.state['dataset'] = datasets[self.user_response]['id']
self.state['period_type'] = datasets[
self.user_response]['period_type']
self.state['open_future_periods'] = datasets[
self.user_response]['open_future_periods']
self.save()
return True
return False
def cache_users_with_their_assigned_org_units() -> List[dict]:
org_units_to_cache = []
for user in DHIS2User.objects.all():
user_ou = {}
for i, ou in enumerate(user.org_units.all()):
user_ou[i + 1] = {'name': ou.name, 'id': ou.org_unit_id}
if ou.org_unit_id not in org_units_to_cache:
org_units_to_cache.append(ou.org_unit_id)
Store.set("usr_{}".format(user.passcode), user_ou)
logger.info('Caching user with their assigned org units ............ Done')
return org_units_to_cache
def cache_org_units_with_their_datasets(org_units_to_cache):
for ou in org_units_to_cache:
org_unit = OrgUnit.objects.get_or_none(org_unit_id=ou)
if org_unit is not None:
datasets = org_unit.dataset_set.all()
org_unit_datasets = {}
for i, dataset in enumerate(datasets):
org_unit_datasets[i + 1] = {
'name': dataset.name,
'id': dataset.dataset_id,
'period_type': dataset.period_type,
'open_future_periods': dataset.open_future_periods
}
Store.set("ou_{}".format(org_unit.org_unit_id), org_unit_datasets)
logger.info('Caching org units with their datasets ............ Done')
def validate(self):
key = "ds_{}".format(self.state['dataset'])
if Store.exists(key):
sections = Store.get(key)
if self.state['section'] in sections.keys():
# if the current section selected is not in the section visited list, add it
if self.state['section'] not in self.state['sections_visited']:
self.state['sections_visited'].append(
self.state['section'])
data_elements = sections[
self.state['section']]['data_elements']
data_element_index = int(self.state['data_element_index'])
data_element_value_type = data_elements[data_element_index][
'data_element_value_type']
# validate the data element
result = validate_data_element_by_value_type(
data_element_value_type, self.user_response)
if result[0]:
data_element = data_elements[data_element_index][
'data_element_id']
category_option_combo = data_elements[data_element_index][
'category_option_combo_id']
# save the value that is received from the user in the state. The key is a concatenation of
# data element and category option combo ids.
key = "{}-{}".format(data_element, category_option_combo)
self.state['data_element_values'][key] = result[1]
self.save()
# save into database
save_values_to_database.delay(
self.state['dataset'], data_element,
category_option_combo, self.state['org_unit'],
self.state['passcode'], self.state['period'],
result[1], self.phone_number, self.session_id)
return True
return False
def next(self):
key = "ds_{}".format(self.state['dataset'])
if Store.exists(key):
sections = Store.get(key)
if self.state['section'] in sections.keys():
data_elements = sections[
self.state['section']]['data_elements']
data_element_index = int(self.state['data_element_index'])
data_element_index += 1
# If all data elements in the selected sections are visited, increment the index and loop
if data_element_index < len(data_elements):
# save state
self.state['data_element_index'] = data_element_index
self.save()
return self.show()
else:
# reset the data element index
self.state['data_element_index'] = 0
# If all sections are visited, show the save options screen
if len(sections.keys()) == len(
self.state['sections_visited']):
from apps.dhis.ussd.screen import SaveOptionsScreen
return SaveOptionsScreen(
session_id=self.session_id,
phone_number=self.phone_number).show()
# to fix circular dependency
from apps.dhis.ussd.screen import SectionScreen
# all sections are not visited so show section screen
return SectionScreen(
session_id=self.session_id,
phone_number=self.phone_number).show()
return self.ussd_end("No data sets are found")
def __init__(self, session_id, phone_number=None, user_response=None, level=Level.LOGIN):
self.session_id = session_id
self.phone_number = phone_number
self.user_response = user_response
self.level = level
self.state = {
'passcode': '',
'level': Level.LOGIN,
'org_unit': '',
'period': '',
'dataset': '',
'period_type': '',
'open_future_periods': '',
'section': '',
'begin_period': '',
'direction': '-',
'direction_change': False,
'data_element_index': 0,
'data_element_values': {},
'sections_visited': []
}
if Store.exists(self.session_id):
self.state = Store.get(self.session_id)
def next(self):
key = "usr_state_{}".format(self.state['passcode'])
if self.user_response == '1':
# restore the previous session
previous_session_id = Store.get(key)
self.state = Store.get(previous_session_id)
self.save(self.state['level'])
# store the current user state and session id
Store.set(key, self.session_id)
# delete the previous session state and user state which stores the previous session id
Store.delete(previous_session_id)
return get_screen(self.session_id, self.phone_number,
self.user_response, self.state['level']).show()
else:
Store.delete(key)
from apps.dhis.ussd.screen import OrgUnitScreen
return OrgUnitScreen(session_id=self.session_id,
phone_number=self.phone_number).show()
def ussd_end(self, display_text):
Store.delete(self.session_id)
Store.delete(key="usr_state_{}".format(self.state['passcode']))
display_text = "END {}".format(display_text)
return HttpResponse(display_text)
def invalidate_dataset_cache():
for dataset in Dataset.objects.all():
Store.unlink("ds_{}".format(dataset.dataset_id))
logger.info("Invalidating datasets from cache ............ Done")
def invalidate_org_units_cache():
for user in DHIS2User.objects.all():
for ou in user.org_units.all():
Store.unlink("ou_{}".format(ou.org_unit_id))
logger.info("Invalidating org units from cache ............ Done")
def save(self, level=None):
self.state['level'] = self.level if level is None else level
Store.set(self.session_id, self.state)
def invalidate_users_cache():
for user in DHIS2User.objects.all():
Store.unlink("usr_{}".format(user.passcode))
logger.info("Invalidating users from cache ............ Done")
def __init__(self, session_id, phone_number, user_response=None):
super().__init__(session_id, phone_number, user_response,
Level.ORG_UNITS)
# store the current user state and session id
Store.set("usr_state_{}".format(self.state['passcode']),
self.session_id)
def validate(self):
if Store.exists("usr_{}".format(self.user_response)):
self.state['passcode'] = self.user_response
self.save()
return True
return False
