def all_subjects(request, subject_type): manager = get_database_manager(request.user) form_model = get_form_model_by_entity_type(manager, [subject_type]) if not form_model: all_subject_types_page = '/entity/subjects/' + "?deleted_subject=true" return HttpResponseRedirect(all_subject_types_page) else: header_dict = header_fields(form_model) form_model = get_form_model_by_entity_type(manager, [subject_type]) return render_to_response( 'entity/all_subjects.html', { 'subject_headers': header_dict, 'current_language': translation.get_language(), 'entity_type': subject_type, 'questions': form_model.fields, 'form_code': form_model.form_code, 'is_pro_sms': get_organization(request).is_pro_sms, 'links': { 'create_subject': reverse("create_subject", args=(subject_type, )) + "?web_view=True", 'edit_subject_registration_form': reverse("edit_subject_questionnaire", args=(subject_type, )) } }, context_instance=RequestContext(request))
def registered_subjects(request, project_id, entity_type=None): manager = get_database_manager(request.user) questionnaire = Project.get(manager, project_id) dashboard_page = settings.HOME_PAGE + "?deleted=true" if questionnaire.is_void(): return HttpResponseRedirect(dashboard_page) current_entity_type = entity_type if not current_entity_type: current_entity_type = questionnaire.entity_type[0] subject = get_entity_type_info(current_entity_type, manager=manager) project_links = get_project_link(questionnaire, current_entity_type) subject_form_model = get_form_model_by_entity_type(manager, [current_entity_type]) in_trial_mode = _in_trial_mode(request) return render_to_response( 'project/subjects/registered_subjects_list.html', { 'project': questionnaire, 'project_links': project_links, 'is_quota_reached': is_quota_reached(request), "subject": subject, 'in_trial_mode': in_trial_mode, 'project_id': project_id, 'entity_type': current_entity_type, 'subject_headers': header_fields(subject_form_model), 'questionnaire_code': questionnaire.form_code, 'form_code': subject_form_model.form_code }, context_instance=RequestContext(request))
def add_unique_id_in_header_dict(self, header_dict, field, parent_field_code=None, parent_field_types=[], nested=False): id_number_fields = get_form_model_by_entity_type( self.form_model._dbm, [field.unique_id_type]).fields if field.unique_id_type in parent_field_types: return None #Helps Prevent cyclic Linked ID Nr parent_field_types.append(field.unique_id_type) if not nested: parent_field_code = '_' + parent_field_code + "-" if parent_field_code else "_" prefix = self.form_model.id + parent_field_code + field.code + "_details" else: prefix = parent_field_code + '.' + field.code + '_details' for nested_field in id_number_fields: if nested_field.name != 'entity_type': column_id = prefix + "." + nested_field.code header_dict.update({column_id: nested_field.label}) if nested_field.type in ['unique_id']: self.add_unique_id_in_header_dict( header_dict, nested_field, parent_field_code=prefix, parent_field_types=parent_field_types, nested=True)
def map_admin(request, entity_type=None): form_model = get_form_model_by_entity_type( get_database_manager(request.user), [entity_type.lower()]) entity_preference = get_entity_preference(get_db_manager("public"), _get_organization_id(request), entity_type) filters_in_entity_preference = [] details_in_entity_preference = [] specials_in_entity_preference = [] if entity_preference is not None: filters_in_entity_preference = entity_preference.filters details_in_entity_preference = entity_preference.details specials_in_entity_preference = entity_preference.specials filters = _build_filterable_fields(form_model.form_fields, filters_in_entity_preference) details = _build_details(form_model.form_fields, details_in_entity_preference) specials = _build_specials(form_model.form_fields, specials_in_entity_preference) return render_to_response('entity/map_edit.html', { "entity_type": entity_type, "form_code": form_model.form_code, "filters": json.dumps(filters), "details": json.dumps(details), "specials": json.dumps(specials) }, context_instance=RequestContext(request))
def edit_subject_questionnaire(request, entity_type=None): # edit subject type questionnaire view manager = get_database_manager(request.user) if entity_type is None: return HttpResponseRedirect(reverse(all_subject_types)) form_model = get_form_model_by_entity_type(manager, [entity_type.lower()]) if form_model is None: form_model = get_form_model_by_code(manager, REGISTRATION_FORM_CODE) fields = form_model.fields existing_questions = json.dumps(fields, default=field_to_json) return render_to_response('entity/questionnaire.html', { 'existing_questions': repr(existing_questions), 'questionnaire_code': form_model.form_code, 'language': form_model.activeLanguages[0], 'entity_type': entity_type, 'is_pro_sms': get_organization(request).is_pro_sms, 'post_url': reverse(save_questionnaire), 'unique_id_types': json.dumps([{ "name": unique_id_type.capitalize(), "value": unique_id_type } for unique_id_type in get_unique_id_types(manager) if unique_id_type != entity_type]), }, context_instance=RequestContext(request))
def _add_id_field_details_to_mapping(self, questionnaire_id, all_id_fields): id_field_mapping = {} for id_field in all_id_fields: key = es_unique_id_details_field_name(questionnaire_id + '_' + id_field.code) unique_field_mapping = {} entity_type = get_form_model_by_entity_type( self.dbm, [id_field.unique_id_type]) if entity_type is not None and not isinstance( entity_type, NoneType): for field in entity_type.fields: if field.type is "date": unique_field_mapping.update( {field.code: { 'type': "date" }}) elif field.type is "double": unique_field_mapping.update( {field.code: { 'type': "double" }}) else: unique_field_mapping.update({ field.code: { 'type': "string", 'index_analyzer': 'sort_analyzer' } }) id_field_mapping.update( {key: { 'properties': unique_field_mapping }}) return id_field_mapping
def render_map(request, share_token): entity_preference = get_entity_preference_by_share_token( get_db_manager("public"), share_token) dbm = get_db_manager(entity_preference.org_id) if not _flag_active("idnr_map", entity_preference.org_id.split('_')[-1].upper()): raise Http404 form_model = get_form_model_by_entity_type( dbm, [entity_preference.entity_type.lower()]) return render_to_response('map.html', { "entity_type": entity_preference.entity_type, "filters": _get_filters(form_model, entity_preference.filters), "geo_jsons": geo_jsons(dbm, entity_preference.entity_type, request.GET, entity_preference.details, entity_preference.specials), "fallback_location": entity_preference.fallback_location, "mapbox_api_key": get_mapbox_api_key(request.META['HTTP_HOST']) }, context_instance=RequestContext(request))
def _get_linked_id_details(dbm, field, parent_field_types=[]): try: linked_id_details = [] if field.unique_id_type in parent_field_types: return None #Prevent cyclic Linked ID Nr parent_field_types.append(field.unique_id_type) id_number_fields = get_form_model_by_entity_type(dbm, [field.unique_id_type]).fields linked_id_fields = [child_field for child_field in id_number_fields if child_field.type in ['unique_id']] if linked_id_fields: for linked_id_field in linked_id_fields: if linked_id_field.unique_id_type in parent_field_types: continue linked_id_info = { 'code':field.code, 'type':field.unique_id_type, 'parent_code': field.parent_field_code, 'linked_code':linked_id_field.code, 'linked_type':linked_id_field.unique_id_type } linked_id_info['children'] = _get_linked_id_details(dbm, linked_id_field, parent_field_types=parent_field_types) linked_id_details.append(linked_id_info) return linked_id_details except Exception as e: logger.exception("Exception in constructing linked id hierrachy : \n%s" % e) return None
def export_template(request, entity_type=None): manager = get_database_manager(request.user) if entity_type is None: return HttpResponseRedirect(reverse(all_subjects)) fields, labels, field_codes = import_module.get_entity_type_fields( manager, entity_type) response = HttpResponse(mimetype='application/vnd.ms-excel') response['Content-Disposition'] = 'attachment; filename="%s.xls"' % ( entity_type, ) form_model = get_form_model_by_entity_type(manager, [entity_type.lower()]) wb = get_excel_sheet([labels], entity_type) form_code = form_model.form_code add_codes_sheet(wb, form_code, field_codes) try: index_geocode = fields.index(GEO_CODE_FIELD_NAME) except ValueError: index_geocode = 0 ws = wb.get_sheet(0) style = xlwt.XFStyle() style.num_format_str = '@' gps_col = ws.col(index_geocode) gps_col.set_style(style) wb.save(response) return response
def get_headers(self, user, subject_type): manager = get_database_manager(user) form_model = get_form_model_by_entity_type(manager, [subject_type]) subject_es_headers = [] for code in header_fields(form_model, key_attribute='code').keys(): subject_es_headers.append( es_questionnaire_field_name(code, form_model.id)) return subject_es_headers
def _update_with_id_field_meta(self, field, questionnaire_id, result): if isinstance(field, UniqueIdField): field_name = es_unique_id_details_field_name(questionnaire_id + '_' + field.code) entity_type = get_form_model_by_entity_type( self.dbm, [field.unique_id_type]) if entity_type is not None: self._map_entity_type_in_result(entity_type, field, field_name, result)
def subject_short_codes_to_delete(request, manager, entity_type): if request.POST.get("all_selected") == 'true': search_query = request.POST.get('search_query') subject_list = SubjectQuery().query(request.user, entity_type, search_query) form_model = get_form_model_by_entity_type(manager, [entity_type]) short_code_index = header_fields(form_model).keys().index("short_code") return [s[short_code_index] for s in subject_list] return request.POST['all_ids'].split(';')
def test_should_return_entity_form_model_based_on_entity_type(self): dbm = DatabaseManagerStub() dbm.view.registration_form_model_by_entity_type.return_value = [{ 'doc': { 'is_registration_form': True } }] form_model = get_form_model_by_entity_type(dbm, ['entity_type']) self.assertIsInstance(form_model, EntityFormModel) self.assertTrue(hasattr(form_model, 'entity_type'))
def _get_registration_form(manager, project, type_of_subject='reporter'): if type_of_subject == 'reporter': registration_questionnaire = form_model.get_form_model_by_code(manager, REGISTRATION_FORM_CODE) else: entity_type = [project.entity_type] registration_questionnaire = get_form_model_by_entity_type(manager, entity_type) if registration_questionnaire is None: registration_questionnaire = form_model.get_form_model_by_code(manager, REGISTRATION_FORM_CODE) questions = viewable_questionnaire(registration_questionnaire) project_links = make_project_links(project, registration_questionnaire.form_code) return registration_questionnaire.fields, project_links, questions, registration_questionnaire
def get_entity_type_fields(manager, type=REPORTER): form_model = get_form_model_by_entity_type(manager, _entity_type_as_sequence(type)) form_code = "reg" if form_model is not None: form_code = form_model.form_code form_model_rows = manager.load_all_rows_in_view("questionnaire", key=form_code) fields, labels, codes = get_json_field_infos( form_model_rows[0].value['json_fields']) return fields, labels, codes
def load_entity_registration_data(manager, type=REPORTER, tabulate_function=tabulate_data): entity_type = entity_type_as_sequence('registration' if type == REPORTER else type) form_model = get_form_model_by_entity_type(manager, entity_type) fields, labels, codes = get_entity_type_fields(manager, form_model.form_code) entities = get_all_entities(dbm=manager, entity_type=entity_type_as_sequence(type)) data = [] for entity in entities: data.append(tabulate_function(entity, form_model, codes)) return data, fields, labels
def all_subjects(request, subject_type): manager = get_database_manager(request.user) form_model = get_form_model_by_entity_type(manager, [subject_type]) header_dict = header_fields(form_model) form_model = get_form_model_by_entity_type(manager, [subject_type]) return render_to_response('entity/all_subjects.html', { 'subject_headers': header_dict, 'current_language': translation.get_language(), 'entity_type': subject_type, 'questions': form_model.fields, 'form_code': form_model.form_code, 'links': { 'create_subject': reverse("create_subject", args=(subject_type, )) + "?web_view=True", 'edit_subject_registration_form': reverse("edit_subject_questionnaire", args=(subject_type, )) } }, context_instance=RequestContext(request))
def get_questionnaire_details_ajax(request, entity_type): manager = get_database_manager(request.user) form_model = get_form_model_by_entity_type(manager, [entity_type.lower()]) if form_model is None: form_model = get_form_model_by_code(manager, REGISTRATION_FORM_CODE) fields = form_model.fields existing_questions = json.dumps(fields, default=field_to_json) return HttpResponse(jsonpickle.encode( {'existing_questions': existing_questions, 'questionnaire_code': form_model.form_code}, unpicklable=False), content_type='application/json')
def entity_search_update(entity_doc, dbm): if entity_doc.aggregation_paths['_type'] == REPORTER_ENTITY_TYPE: update_datasender_index(entity_doc, dbm) return es = get_elasticsearch_handle() if entity_doc.data: entity_type = entity_doc.aggregation_paths['_type'][0].lower() form_model = get_form_model_by_entity_type(dbm, [entity_type]) es.index(dbm.database_name, entity_type, subject_dict(entity_type, entity_doc, dbm, form_model), id=entity_doc.id) es.refresh(dbm.database_name)
def get_entity_type_info(entity_type, manager=None): form_code = None names = [] codes = [] labels = [] form_code = '' fields_names, labels, codes = [], [], [] if entity_type: form_model = get_form_model_by_entity_type(manager, entity_type_as_sequence(entity_type)) if form_model: form_code = form_model.form_code names, labels, codes = get_field_infos(form_model.fields) return dict(entity=entity_type, code=form_code, names=names, labels=labels, codes=codes, data=[])
def delete_subjects(request): manager = get_database_manager(request.user) entity_type = request.POST['entity_type'] form_model = get_form_model_by_entity_type(manager, [entity_type]) all_ids = _subject_short_codes_to_delete(request, form_model, entity_type) hard_delete_unique_ids = _get_unique_ids_to_hard_delete( all_ids, entity_type, manager) _hard_delete_unique_ids(hard_delete_unique_ids, manager, form_model, request) unique_ids_to_soft_delete = list( set(all_ids) - set(hard_delete_unique_ids)) _soft_delete_unique_ids(unique_ids_to_soft_delete, entity_type, manager, request) message = get_success_message(entity_type) return HttpResponse(json.dumps({'success': True, 'message': message}))
def _get_linked_qns(dbm, entity_qns): linked_date_qns = [] linked_idnr_qns = [] for field in entity_qns: id_number_fields = get_form_model_by_entity_type(dbm, [field.unique_id_type]).fields for child_field in id_number_fields: if child_field.type == 'unique_id': setattr(child_field, "path", _get_identifier(field)) setattr(child_field, "idnr_type", field.unique_id_type) linked_idnr_qns.append(child_field) elif child_field.type == 'date': setattr(child_field, "path", _get_identifier(field)) setattr(child_field, "idnr_type", field.unique_id_type) linked_date_qns.append(child_field) return linked_idnr_qns, linked_date_qns
def registered_subjects(request, project_id=None): manager = get_database_manager(request.user) project, project_links = _get_project_and_project_link(manager, project_id) subject = get_entity_type_info(project.entity_type, manager=manager) in_trial_mode = _in_trial_mode(request) form_model = get_form_model_by_entity_type(manager, [subject.get('entity')]) return render_to_response('project/subjects/registered_subjects_list.html', {'project': project, 'project_links': project_links, 'is_quota_reached': is_quota_reached(request), "subject": subject, 'in_trial_mode': in_trial_mode, 'project_id': project_id, 'entity_type': subject.get('entity'), 'subject_headers': header_fields(form_model), 'form_code': subject.get('code')}, context_instance=RequestContext(request))
def load_subject_registration_data(manager, filter_entities=exclude_of_type, type=REPORTER, tabulate_function=_tabulate_data): if type == REPORTER: form_model = get_form_model_by_code(manager, 'reg') else: form_model = get_form_model_by_entity_type( manager, _entity_type_as_sequence(type)) fields, labels, codes = get_entity_type_fields(manager, type) entities = get_all_entities(dbm=manager) data = [] for entity in entities: if filter_entities(entity, type): data.append(tabulate_function(entity, form_model, codes)) return data, fields, labels
def delete_subject_types(request): manager = get_database_manager(request.user) subject_types = request.POST.get("all_ids") subject_types = subject_types.split(";") delete_type(manager, subject_types) for subject_type in subject_types: form_model = get_form_model_by_entity_type(manager, [subject_type]) delete_mapping(manager.database_name, subject_type) entities = get_all_entities_include_voided(manager, [subject_type]) for entity in entities: delete_data_record(manager, form_model.form_code, entity.short_code) manager._save_document(EntityActionDocument(form_model.entity_type[0], entity.short_code, HARD_DELETE)) entity.delete() form_model.delete() UserActivityLog().log(request, action=DELETED_IDENTIFICATION_NUMBER, project=form_model.entity_type[0].capitalize()) messages.success(request, _("Identification Number Type(s) successfully deleted.")) return HttpResponse(json.dumps({'success': True}))
def export_subject(request): manager = get_database_manager(request.user) organization = get_organization(request) local_time_delta = get_country_time_delta(organization.country) current_language = get_language() subject_type = request.POST.get('subject_type', '').lower() project_name = subject_type form_model = get_form_model_by_entity_type(manager, [subject_type.lower()]) query_params = { "start_result_number": 0, "number_of_results": 4000, "order": "", "filter": 'identification_number', } return SubmissionExporter(form_model, project_name, manager, local_time_delta, current_language, None) \ .create_excel_response('identification_number', query_params)
def map_data(request, entity_type=None, entity_preference=None): manager = get_database_manager(request.user) form_model = get_form_model_by_entity_type(manager, [entity_type.lower()]) entity_preference = entity_preference or get_entity_preference(get_db_manager("public"), _get_organization_id(request), entity_type) details = entity_preference.details if entity_preference is not None else [] specials = entity_preference.specials if entity_preference is not None else [] fallback_location = entity_preference.fallback_location if entity_preference is not None else {} return render_to_response('map.html', { "entity_type": entity_type, "fallback_location": fallback_location, "filters": [] if entity_preference is None else _get_filters(form_model, entity_preference.filters), "idnr_filters": [] if entity_preference is None else _get_uniqueid_filters(form_model, entity_preference.filters, manager), "geo_jsons": geo_jsons(manager, entity_type, request.GET, details, specials), "mapbox_api_key": get_mapbox_api_key(request.META['HTTP_HOST']) }, context_instance=RequestContext(request))
def subject_autocomplete(request, entity_type): search_text = lower(request.GET["term"] or "") database_name = get_database_name(request.user) dbm = get_database_manager(request.user) form_model = get_form_model_by_entity_type(dbm, [entity_type.lower()]) subject_name_field = get_field_by_attribute_value(form_model, 'name', 'name') es_field_name_for_subject_name = es_questionnaire_field_name(subject_name_field.code, form_model.id) subject_short_code_field = get_field_by_attribute_value(form_model, 'name', 'short_code') es_field_name_for_short_code = es_questionnaire_field_name(subject_short_code_field.code, form_model.id) query = elasticutils.S().es(urls=ELASTIC_SEARCH_URL, timeout=ELASTIC_SEARCH_TIMEOUT).indexes(database_name).doctypes(lower(entity_type)) \ .query(or_={es_field_name_for_subject_name + '__match': search_text, es_field_name_for_subject_name + '_value': search_text, es_field_name_for_short_code + '__match': search_text, es_field_name_for_short_code + '_value': search_text}) \ .values_dict() resp = [{"id": r[es_field_name_for_short_code], "label": r[es_field_name_for_subject_name]} for r in query[:min(query.count(), 50)]] return HttpResponse(json.dumps(resp))
def get_entity_type_info(entity_type, manager=None): if entity_type == 'reporter': form_code = 'reg' form_model = manager.load_all_rows_in_view("questionnaire", key=form_code)[0] names, labels, codes = get_json_field_infos( form_model.value['json_fields']) else: form_model = get_form_model_by_entity_type( manager, _entity_type_as_sequence(entity_type)) form_code = form_model.form_code names, labels, codes = get_field_infos(form_model.fields) return dict(entity=entity_type, code=form_code, names=names, labels=labels, codes=codes, data=[])
def edit_subject_questionnaire(request, entity_type=None): manager = get_database_manager(request.user) if entity_type is None: return HttpResponseRedirect(reverse(all_subjects)) form_model = get_form_model_by_entity_type(manager, [entity_type.lower()]) if form_model is None: form_model = get_form_model_by_code(manager, REGISTRATION_FORM_CODE) fields = form_model.fields existing_questions = json.dumps(fields, default=field_to_json) return render_to_response('entity/questionnaire.html', { 'existing_questions': repr(existing_questions), 'questionnaire_code': form_model.form_code, 'language': form_model.activeLanguages[0], 'entity_type': entity_type, 'post_url': reverse(save_questionnaire) }, context_instance=RequestContext(request))