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))
