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 get_header_dict(self):
header_dict = OrderedDict()
header_dict.update(self.update_static_header_info())
def key_attribute(field):
return field.code
if isinstance(self.form_model, EntityFormModel):
entity_questions = self.form_model.base_entity_questions
else:
entity_questions = self.form_model.entity_questions
entity_question_dict = dict(
(self._get_entity_question_path(field), field)
for field in entity_questions)
headers = header_fields(self.form_model, key_attribute)
for field_code, val in headers.items():
if field_code in entity_question_dict.keys():
self.add_unique_id_field(entity_question_dict.get(field_code),
header_dict)
else:
key = es_questionnaire_field_name(field_code.replace(".", " "),
self.form_model.id)
header_dict.update({key: val})
return header_dict
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 _subject_short_codes_to_delete(request, form_model, 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)
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 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 data_sender_short_codes(request, manager):
if request.POST.get("all_selected") == 'true':
search_text = request.POST.get('search_query')
datasender_list = []
project_name = request.POST.get("project_name", None)
if project_name:
datasender_list = MyDataSenderQuery().query_by_project_name(request.user, project_name, search_text)
else:
datasender_list = DatasenderQuery().query(request.user, search_text)
form_model = get_form_model_by_code(manager, 'reg')
fields = header_fields(form_model).keys()
fields.remove("entity_type")
short_code_index = fields.index("short_code")
return [ds[short_code_index].lower() for ds in datasender_list]
return request.POST['ids'].lower().split(';')
def get_header_dict(self):
header_dict = OrderedDict()
header_dict.update(self.update_static_header_info())
def key_attribute(field):
return field.code.lower()
headers = header_fields(self.form_model, key_attribute)
for field_code, val in headers.items():
key = es_field_name(field_code, self.form_model.id)
if not header_dict.has_key(key): header_dict.update({key: val})
if self.form_model.is_entity_type_reporter():
# For summary projects there will be an extra datasender info question(code eid).
# This condition removes that extra question.
header_dict.pop(
es_field_name(self.form_model.entity_question.code,
self.form_model.id))
header_dict.pop('entity_short_code')
return header_dict
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_response(dbm, form_code, user, response_limit):
"""
:param dbm: database-manager
:param form_code: questionnaire-code
:param user: authenticated-usr
:param response_limit: limit the number of unique-id returned
:return: tuple of unique-ids and questionnaire details
unique-ids is a list of dicts where each dict consist of question-name: question-label
questionnaire details is a dict of question-name:question-label
"""
try:
form_model = get_form_model_by_code(dbm, form_code)
if not form_model.is_entity_registration_form():
return None, None
except FormModelDoesNotExistsException:
return None, None
header_dict = header_fields(form_model)
required_field_names = SubjectQuery().get_headers(
user, form_model.entity_type[0])
query = _create_elastic_search_query(form_model.entity_type[0], dbm,
response_limit)
unique_ids = _create_response(required_field_names, query, header_dict)
return unique_ids, header_dict
