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