def _invalid_form_code(request, form_code):
try:
dbm = get_database_manager(request.user)
get_form_model_by_code(dbm, form_code)
return False
except FormModelDoesNotExistsException as e:
return True
def test_should_save_snapshots_when_questionnaires_field_modified(self):
self._create_form_model()
form_model = get_form_model_by_code(self.manager, FORM_CODE_1)
original_fields = form_model._doc.json_fields
revision = form_model._doc['_rev']
post = [{
"title": "q1",
"type": "text",
"choices": [],
"is_entity_question": False,
"code": "q1",
"min_length": 1,
"max_length": ""
}, {
"title": "q2",
"type": "integer",
"choices": [],
"is_entity_question": False,
"code": "q2",
"range_min": 0,
"range_max": 100
}]
QuestionnaireBuilder(
form_model, self.manager).update_questionnaire_with_questions(post)
form_model.save()
form_model = get_form_model_by_code(self.manager, FORM_CODE_1)
self.assertEqual(1, len(form_model.snapshots))
self.assertEqual(revision, form_model.snapshots.keys()[-1])
expect = [(each['code'], each['label']) for each in original_fields]
self.assertListEqual(expect,
[(each.code, each.label)
for each in form_model.snapshots[revision]])
def SaveQuestionnaire(dbm):
entity_type = ['school']
if not entity_type_already_defined(dbm, entity_type):
define_type(dbm, entity_type)
#default_ddtype
default_ddtype = DataDictType(dbm, name='Default String Datadict Type', slug='string_default',
primitive_type='string')
#questions
question0 = TextField(name="Q0", code="ID", label="What is your id?", entity_question_flag=True,
ddtype=default_ddtype)
question1 = TextField(name="Q1", code="FIRSTNAME", label="What is your first name?", entity_question_flag=False,
ddtype=default_ddtype)
question2 = TextField(name="Q2", code="LASTNAME", label="What is your last name?", entity_question_flag=False,
ddtype=default_ddtype)
question3 = DateField(name="Q3", code="BIRTHDATE", date_format='mm.yyyy', label="What is your birth date?",
ddtype=default_ddtype)
question4 = TextField(name="Q4", code="COMMENT", label="What do you want to add?", entity_question_flag=False,
ddtype=default_ddtype)
#form_model
form_model = FormModel(dbm, entity_type=entity_type, name="Personal information Survey", label="Basic Info Survey",
form_code="PISurvey", type='survey', fields=[question0, question1, question2, question3, question4])
try:
qid = form_model.save()
except DataObjectAlreadyExists as e:
get_form_model_by_code(dbm, "PISurvey").delete()
qid = form_model.save()
return form_model
def test_should_not_save_snapshots_when_questionnaires_field_not_changed(
self):
self._create_form_model()
form_model = get_form_model_by_code(self.manager, FORM_CODE_1)
post = [{
"title": "What is associated entity",
"options": {
"ddtype": self.default_ddtype.to_json()
},
"type": "text",
"is_entity_question": True,
"code": "ID",
"name": "entity_question"
}, {
"title": "What is your name",
"options": {
"ddtype": self.default_ddtype.to_json()
},
"type": "text",
"is_entity_question": False,
"code": "Q1",
"range_min": 5,
"range_max": 10
}]
QuestionnaireBuilder(
form_model, self.manager).update_questionnaire_with_questions(post)
form_model.save()
form_model = get_form_model_by_code(self.manager, FORM_CODE_1)
self.assertEqual(0, len(form_model.snapshots))
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 generate_questionnaire_code(dbm):
all_projects_count = models.count_projects(dbm)
code = all_projects_count + 1
code = "%03d" % (code,)
while True:
try:
get_form_model_by_code(dbm, code)
code = int(code) + 1
code = "%03d" % (code,)
except FormModelDoesNotExistsException:
break
return code
def _get_form_model(self, rows):
form_model = None
if len(rows) > 0:
(form_code, values) = rows[0]
form_model = get_form_model_by_code(self.dbm, form_code)
if self.form_code is not None and form_code != self.form_code:
form_model = get_form_model_by_code(self.dbm, self.form_code)
raise FormCodeDoesNotMatchException(ugettext(
'Some unexpected error happened. Please check the excel file or download the latest template and import again.'
) % form_model.entity_type[0],
form_code=form_code)
return form_model
def aggregate_for_form(dbm, form_code, aggregates=None, aggregate_on=None, filter=None, starttime=None, endtime=None):
assert is_string(form_code)
result = {}
aggregates = {} if aggregates is None else aggregates
form = get_form_model_by_code(dbm, form_code)
aggregate, group_level = _get_aggregate_strategy(aggregate_on, for_form_code=True)
values = aggregate(dbm, form.entity_type, group_level, aggregate_on)
interested_keys = _get_interested_keys_for_form_code(values, form_code)
_parse_key = _get_key_strategy(aggregate_on, {'form_code': form_code})
for key, val in values:
result_key, field, filter_key = _parse_key(key)
# if filter and filter_key not in interested_keys:
if filter_key not in interested_keys:
continue
interested_aggregate = None
if field in aggregates:
interested_aggregate = aggregates.get(field)
# * overrides field specific aggregation, returns the aggregation for all fields.
if "*" in aggregates:
interested_aggregate = aggregates.get("*")
if interested_aggregate:
try:
result.setdefault(result_key, {})[field] = val[interested_aggregate]
except KeyError:
raise AggregationNotSupportedForTypeException(field, interested_aggregate)
return result
def get_customized_message_for_questionnaire(dbm,
request,
message_code,
form_code,
placeholder_dict=None,
form_model=None):
if form_model is None:
try:
form_model = get_form_model_by_code(dbm, form_code)
except:
pass
if form_model is None or isinstance(
form_model, EntityFormModel): #For UniqueId registration
message = _get_customized_message_for_language(
dbm,
request.get('organization').language, message_code)
else: # For questionnaire submission
project = Project.from_form_model(form_model)
message = _get_customized_message_for_language(dbm, project.language,
message_code)
request[
'is_outgoing_reply_sms_enabled'] = project.is_outgoing_sms_replies_enabled
if placeholder_dict:
message = _replace_placeholders_in_message(message, placeholder_dict)
return message
def migration_to_add_email_data_for_web_users_in_couch(db_name):
logger = logging.getLogger(db_name)
logger.info('Starting Migration')
mark_as_completed(db_name)
manager = get_db_manager(db_name)
email_field_code = "email"
try:
form_model = get_form_model_by_code(manager, REGISTRATION_FORM_CODE)
except FormModelDoesNotExistsException as f:
logger.warning(f.message)
return
email_field_label = form_model._get_field_by_code(email_field_code).name
email_ddtype = form_model._get_field_by_code(email_field_code).ddtype
org_id = OrganizationSetting.objects.get(
document_store=manager.database_name).organization_id
user_profiles = NGOUserProfile.objects.filter(org_id=org_id)
for user_profile in user_profiles:
try:
short_code = user_profile.reporter_id
email_value = user_profile.user.email
data = (email_field_label, email_value, email_ddtype)
if short_code:
add_email_data_to_entity_document(manager, short_code, data,
logger)
except DataObjectAlreadyExists as e:
logger.warning(e.message)
except Exception as e:
logger.exception("FAILED to migrate: %s" % short_code)
def get_stats(request, form_code):
dbm = get_database_manager(request.user)
form_model = get_form_model_by_code(dbm, form_code)
search_parameters = {}
search_parameters.update({"start_result_number": 0})
search_parameters.update({"number_of_results": 0})
filter_type = "success"
search_parameters.update({"filter": filter_type})
search_parameters.update({"sort_field": "ds_id"})
search_parameters.update(
{"order": "-" if request.POST.get('sSortDir_0') == "desc" else ""})
search_filters = json.loads(request.POST.get('search_filters'))
search_parameters.update({"search_filters": search_filters})
search_text = search_filters.get("search_text", '')
search_parameters.update({"search_text": search_text})
user = request.user
entity_headers, paginated_query, query_with_criteria = SubmissionQuery(
form_model,
search_parameters).query_to_be_paginated(form_model.id, user)
facet_results = get_facet_response_for_choice_fields(
query_with_criteria, form_model.choice_fields, form_model.id)
#total success submission count irrespective of current fields being present or not
total_submissions = query_with_criteria.count()
return HttpResponse(json.dumps({
'result':
create_statistics_response(facet_results, form_model),
'total':
total_submissions
}),
content_type='application/json')
def get_submissions(request, form_code):
dbm = get_database_manager(request.user)
form_model = get_form_model_by_code(dbm, form_code)
search_parameters = {}
search_parameters.update(
{"start_result_number": int(request.POST.get('iDisplayStart'))})
search_parameters.update(
{"number_of_results": int(request.POST.get('iDisplayLength'))})
filter_type = request.GET['type']
search_parameters.update({"filter": filter_type})
search_parameters.update({
"sort_field":
_get_field_to_sort_on(request.POST, form_model, filter_type)
})
search_parameters.update(
{"order": "-" if request.POST.get('sSortDir_0') == "desc" else ""})
search_filters = json.loads(request.POST.get('search_filters'))
search_parameters.update({"search_filters": search_filters})
search_text = search_filters.get("search_text", '')
search_parameters.update({"search_text": search_text})
user = request.user
query_count, search_count, submissions = SubmissionQuery(
form_model, search_parameters).paginated_query(user, form_model.id)
return HttpResponse(jsonpickle.encode(
{
'data': submissions,
'iTotalDisplayRecords': query_count,
'iDisplayStart': int(request.POST.get('iDisplayStart')),
"iTotalRecords": search_count,
'iDisplayLength': int(request.POST.get('iDisplayLength'))
},
unpicklable=False),
content_type='application/json')
def accept(self, request):
assert isinstance(request, SubmissionRequest)
form_code = request.form_code
values = request.submission
submission_id = self.logger.create_submission_log(request)
form = get_form_model_by_code(self.dbm, form_code)
if form.entity_defaults_to_reporter():
self._set_entity_short_code(request.reporter.short_code, values)
try:
cleaned_data, data_record_id, short_code, status, errors = self.submit(form, values, submission_id)
except InactiveFormModelException:
self.logger.update_submission_log(submission_id, False, 'Inactive form_model')
raise
except MangroveException as e:
self.logger.update_submission_log(submission_id=submission_id,status=False,errors = e.message, in_test_mode=form.is_in_test_mode())
raise
self.logger.update_submission_log(submission_id=submission_id, data_record_id=data_record_id,
status=status, errors=errors, in_test_mode=form.is_in_test_mode())
return SubmissionResponse(status, submission_id, errors, data_record_id, short_code=short_code,
processed_data=cleaned_data,is_registration = form.is_registration_form())
def export(request):
if request.method == 'GET': #To handle django error #3480
return HttpResponse(status=405)
project_name = request.POST.get(u"project_name")
submission_type = request.GET.get(u'type')
search_filters = json.loads(request.POST.get('search_filters'))
questionnaire_code = request.POST.get(u'questionnaire_code')
manager = get_database_manager(request.user)
form_model = get_form_model_by_code(manager, questionnaire_code)
query_params = {"search_filters": search_filters,
"start_result_number": 0,
"number_of_results": 50000,
"order": "",
"sort_field": "date"
}
search_text = search_filters.get("search_text", '')
query_params.update({"search_text": search_text})
query_params.update({"filter": submission_type})
return SubmissionExporter(form_model, project_name, request.user) \
.create_excel_response(submission_type, query_params)
def _get_response_message(response, dbm):
if response.success:
form_model = get_form_model_by_code(dbm, response.form_code)
message = _get_success_message(response, form_model)
else:
message = get_submission_error_message_for(response.errors)
return message
def put_email_information_to_entity(dbm, entity, email):
email_field_code = "email"
form_model = get_form_model_by_code(dbm, REGISTRATION_FORM_CODE)
email_field_label = form_model._get_field_by_code(email_field_code).name
email_ddtype = form_model._get_field_by_code(email_field_code).ddtype
data = (email_field_label, email, email_ddtype)
entity.update_latest_data([data])
def CreateFormModel(self):
question1 = TextField(name="entity_question", code="ID", label="What is the school reported on?", language="eng",entity_question_flag=True, ddtype=self.default_ddtype)
question2 = TextField(name="Your Name", code="Q1", label="What is your name", defaultValue="some default value", language="eng", ddtype=self.default_ddtype)
question3 = IntegerField(name="Your Age", code="Q2", label="What is your age", ddtype=self.default_ddtype)
question4 = SelectField(name="Color", code="Q3", label="What is your favourite color", options=[("RED", 1), ("YELLOW", 2)], ddtype=self.integer_ddtype)
form_code = "form001"
self.form_model = FormModel(self.manager, entity_type=self.entity_type, name="SCHOOL_FORM_MODEL", label="School form_model", form_code=form_code, type='survey',fields=[question1, question2, question3, question4])
try:
qid = self.form_model.save()
except DataObjectAlreadyExists as e:
get_form_model_by_code(self.manager, form_code).delete()
qid = self.form_model.save()
return form_code, qid
def post(self, request, form_code):
manager = get_database_manager(request.user)
feeds_dbm = get_feeds_database(request.user)
project_id = request.GET["project_id"]
project = Project.load(manager.database, project_id)
form_model = get_form_model_by_code(manager, form_code)
user_profile = NGOUserProfile.objects.get(user=request.user)
organization = Organization.objects.get(org_id=user_profile.org_id)
submission_importer = SubmissionImporter(
manager, feeds_dbm, request.user, form_model, project,
SubmissionQuotaService(organization))
response = submission_importer.import_submission(request)
return HttpResponse(
json.dumps({
"success":
self._successful(response),
"question_map":
self._get_question_code_map(form_model, request),
"success_submissions":
response.saved_entries,
"errored_submission_details":
response.errored_entrie_details,
"message":
response.message,
"total_submissions":
response.total_submissions,
"quota_over":
self._is_submission_quota_over(response)
}))
def get_response_message(response, dbm, request):
form_model = get_form_model_by_code(dbm, response.form_code) if response.form_code else None
if response.success:
message = _get_success_message(response, form_model, dbm, request)
else:
message = get_submission_error_message_for(response, form_model, dbm, request)
return message
def update_submission_search_index(submission_doc, dbm, refresh_index=True):
es = get_elasticsearch_handle()
form_model = get_form_model_by_code(dbm, submission_doc.form_code)
#submission_doc = SurveyResponseDocument.load(dbm.database, feed_submission_doc.id)
search_dict = _meta_fields(submission_doc, dbm)
_update_with_form_model_fields(dbm, submission_doc, search_dict, form_model)
es.index(dbm.database_name, form_model.id, search_dict, id=submission_doc.id, refresh=refresh_index)
def process(self, form_code, submission_values, extra_data=[]):
if len(extra_data):
return self._get_wrong_number_of_question_response()
form_model = get_form_model_by_code(self.dbm, form_code)
processor_func = self._get_handlers(form_model)
return processor_func(form_model,submission_values)
def process(self, form_code, submission_values, extra_data=[]):
form_model = get_form_model_by_code(self.dbm, form_code)
processor_func = self._get_handlers(form_model)
response = processor_func(form_model, submission_values)
if len(extra_data) or (response and not response.success):
self.request['exception'] = SMSParserWrongNumberOfAnswersException(form_code)
def process(self, form_code, submission_values):
self.request[FORM_CODE] = form_code
form_model = get_form_model_by_code(self.dbm, form_code)
if not isinstance(form_model, EntityFormModel):
translation.activate(form_model.activeLanguages[0])
else:
self.request['is_registration'] = True
def import_subjects_from_project_wizard(request, form_code):
manager = get_database_manager(request.user)
error_message, failure_imports, success_message, short_code_subject_details_dict = import_module.import_data(
request, manager, default_parser=XlsOrderedParser, form_code=form_code)
subject_details = {}
if len(short_code_subject_details_dict) != 0:
detail_dict = dict()
form_model = get_form_model_by_code(manager, form_code)
entity_type = form_model.entity_type[0]
short_codes = []
for short_code in short_code_subject_details_dict.keys():
short_codes.append(short_code)
subject_details = _format_imported_subjects_datetime_field_to_str(
form_model, short_code_subject_details_dict)
detail_dict.update({entity_type: "[%s]" % ", ".join(short_codes)})
UserActivityLog().log(request,
action=IMPORTED_IDENTIFICATION_NUMBER,
detail=json.dumps(detail_dict))
return HttpResponse(
json.dumps({
'success':
error_message is None and is_empty(failure_imports),
'message':
success_message,
'error_message':
error_message,
'failure_imports':
failure_imports,
'successful_imports':
subject_details,
}))
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 create_search_indices_for_deleted_datasender(db_name):
logger = logging.getLogger(db_name)
try:
logger.info('Starting indexing')
dbm = get_db_manager(db_name)
es = get_elasticsearch_handle(timeout=600)
form_model = get_form_model_by_code(dbm, REGISTRATION_FORM_CODE)
datasenders = []
for entity in get_all_entities_include_voided(dbm,
REPORTER_ENTITY_TYPE):
if not entity.data:
continue
if entity.is_void() or entity.short_code == 'test':
datasender_dict = _create_datasender_dict(
dbm, entity, REPORTER, form_model)
datasender_dict.update({'id': entity.id})
datasenders.append(datasender_dict)
if datasenders:
es.bulk_index(dbm.database_name, REPORTER, datasenders)
logger.info('Created index for datasenders with ids :' +
str([a.get('id') for a in datasenders]))
logger.info('Completed Indexing')
mark_as_successful(db_name)
except Exception as e:
logger.exception(e.message)
def migration_to_add_email_data_for_web_users_in_couch(db_name):
logger = logging.getLogger(db_name)
logger.info('Starting Migration')
mark_as_completed(db_name)
manager = get_db_manager(db_name)
try:
form_model = get_form_model_by_code(manager, REGISTRATION_FORM_CODE)
except FormModelDoesNotExistsException as f:
logger.warning(f.message)
return
email_field = TextField(name=EMAIL_FIELD,
code=EMAIL_FIELD,
label="What is the subject's email",
defaultValue="",
instruction="Enter email id",
constraints=[TextLengthConstraint(max=50)],
required=False)
try:
form_model.add_field(email_field)
form_model.save()
logger.info("Migrated registration form")
except QuestionCodeAlreadyExistsException as e:
logger.warning('email field is present' + e.message)
except Exception as e:
logger.exception(e.message)
def parse(self, message):
submission_dict = xmltodict.parse(message, 'utf-8').values()[0]
# xform elements don't have namespace information since it's being default, so form_code don't include namespace
form_code = submission_dict.pop('form_code')
form_model = get_form_model_by_code(self.dbm, form_code)
self.__format_response_fields(form_model, submission_dict)
return form_code, self._fetch_string_value(submission_dict)
def feed_entries(request, form_code):
user = request.user
try:
if not settings.FEEDS_ENABLED:
return HttpResponse(404)
if invalid_date(request.GET.get('start_date')):
return convert_to_json_response(
{"ERROR_CODE": 102, "ERROR_MESSAGE": 'Invalid Start Date provided'}, 400)
if invalid_date(request.GET.get('end_date')):
return convert_to_json_response(
{"ERROR_CODE": 102, "ERROR_MESSAGE": 'Invalid End Date provided'}, 400)
if lesser_end_date(request.GET.get('end_date'), request.GET.get('start_date')):
return convert_to_json_response(
{"ERROR_CODE": 103, "ERROR_MESSAGE": 'End Date provided is less than Start Date'}, 400)
if _invalid_form_code(request, form_code):
return convert_to_json_response({"ERROR_CODE": 101, "ERROR_MESSAGE": 'Invalid form code provided'}, 400)
dbm = get_database_manager(user)
form_model = get_form_model_by_code(dbm, form_code)
questionnaire_id = form_model.id
if user.is_ngo_admin() or user.is_extended_user() or \
(user.is_project_manager() and has_permission(dbm, user.id, questionnaire_id)):
feed_dbm = get_feeds_database(request.user)
start_date = _parse_date(request.GET['start_date'])
end_date = _parse_date(request.GET['end_date'])
return HttpResponse(stream_feeds(feed_dbm, startkey=[form_code, start_date], endkey=[form_code, end_date]),
content_type='application/json; charset=utf-8')
return convert_to_json_response({"ERROR_CODE": 104, "ERROR_MESSAGE": "You don't have access to this feed"}, 403)
except Exception as e:
logger = logging.getLogger('datawinners')
logger.exception(e)
return HttpResponse(content='Internal Server Error', status=500)
def _load_submissions(current_page,
manager,
questionnaire_code,
pagination=True,
start_time=None,
end_time=None):
form_model = get_form_model_by_code(manager, questionnaire_code)
questionnaire = (questionnaire_code, form_model.name)
fields = form_model.fields
if form_model.entity_defaults_to_reporter():
fields = form_model.fields[1:]
questions = helper.get_code_and_title(fields)
count = get_submission_count_for_form(manager, questionnaire_code,
start_time, end_time)
results = {'questionnaire': questionnaire, 'questions': questions}
if count:
submissions, ids = _get_submissions_for_display(current_page - 1,
manager,
questionnaire_code,
copy(questions),
pagination,
start_time=start_time,
end_time=end_time)
results.update(submissions=zip(submissions, ids))
return count, results
def project_data(request, project_id=None, questionnaire_code=None):
manager = get_database_manager(request)
project = models.get_project(project_id, dbm=manager)
form_model = get_form_model_by_code(manager, questionnaire_code)
project_links = _make_project_links(project, questionnaire_code)
if request.method == "GET":
data_dictionary = data.aggregate_for_form(
manager,
form_code=questionnaire_code,
aggregates={"*": data.reduce_functions.LATEST},
aggregate_on=EntityAggregration())
response_string, header_list, type_list = _format_data_for_presentation(
data_dictionary, form_model)
return render_to_response('project/data_analysis.html', {
"entity_type": form_model.entity_type[0],
"data_list": repr(response_string),
"header_list": header_list,
"type_list": type_list,
'project_links': project_links,
'project': project
},
context_instance=RequestContext(request))
if request.method == "POST":
data_dictionary = _load_data(form_model, manager, questionnaire_code,
request)
response_string, header_list, type_list = _format_data_for_presentation(
data_dictionary, form_model)
return HttpResponse(response_string)
def datasenders(request, project_id=None):
manager = get_database_manager(request)
project, project_links = _get_project_and_project_link(manager, project_id)
reg_form = get_form_model_by_code(manager, REGISTRATION_FORM_CODE)
_format_field_description_for_data_senders(reg_form.fields)
cleaned_up_fields = _get_questions_for_datasenders_registration_for_print_preview(reg_form.fields)
return render_to_response('project/datasenders.html', {'fields': cleaned_up_fields, 'project':project, 'project_links':project_links}, context_instance=RequestContext(request))
def select_form_model(self, form_code):
try:
form_model = get_form_model_by_code(self.dbm, form_code)
check_if_form_code_is_poll(self, form_model)
except FormModelDoesNotExistsException:
form_model = get_active_form_model(self.dbm, form_code)
return form_model
def submit(self, submission, reporter_id):
try:
form_code, values, extra_data = SMSParserFactory().getSMSParser(submission, self.dbm).parse(submission)
form_model = get_form_model_by_code(self.dbm, form_code)
if self.organization.has_exceeded_quota_and_notify_users():
return False, "Exceeded Submission Limit"
if isinstance(form_model, EntityFormModel):
response = self._create_identification_number(form_code, values, extra_data)
else:
response = self._create_survey_response(form_model, reporter_id, values, extra_data)
except FormModelDoesNotExistsException as e:
request = {"form_code": e.data[0],
"incoming_message": submission,
"organization": self.organization,
"transport_info": TransportInfo("api", "", "")}
create_failure_log("Form Code is not valid.", request)
return False, "Form Code is not valid."
except DataObjectAlreadyExists:
return False, "Duplicate unique id"
except SMSParserInvalidFormatException:
return False, "Wrong number of answers"
except MangroveException as e:
return False, e.message
if response.success:
return True, 'submitted successfully'
else:
return False, response.errors.values()[0]
def edit_my_subject_questionnaire(request, project_id, entity_type=None):
manager = get_database_manager(request.user)
questionnaire = Project.get(manager, project_id)
if not entity_type:
entity_type = questionnaire.entity_type[0]
project_links = get_project_link(questionnaire, entity_type)
dashboard_page = settings.HOME_PAGE + "?deleted=true"
if questionnaire.is_void():
return HttpResponseRedirect(dashboard_page)
reg_form = _get_subject_form_model(manager, entity_type)
if reg_form is None:
reg_form = form_model.get_form_model_by_code(manager,
REGISTRATION_FORM_CODE)
fields = reg_form.fields
existing_questions = json.dumps(fields, default=field_to_json)
subject = get_entity_type_info(entity_type, manager=manager)
return render_to_response('project/subject_questionnaire.html', {
'project': questionnaire,
'entity_type': entity_type,
'project_links': project_links,
'is_quota_reached': is_quota_reached(request),
'existing_questions': repr(existing_questions),
'questionnaire_code': reg_form.form_code,
'language': reg_form.activeLanguages[0],
'project_id': questionnaire.id,
'subject': subject,
'post_url': reverse(subject_save_questionnaire)
},
context_instance=RequestContext(request))
def aggregate_by_form_code_python(dbm, form_code, aggregates=None, aggregate_on=None, filter=None,
starttime=None, endtime=None):
assert is_string(form_code)
aggregates = [] if aggregates is None else aggregates
form = get_form_model_by_code(dbm, form_code)
values = _map(dbm, form.entity_type, BY_VALUES_FORM_CODE_INDEX, form_code, starttime, endtime)
return _reduce(aggregates, values)
def export_data(request):
questionnaire_code = request.POST.get("questionnaire_code")
manager = get_database_manager(request)
form_model = get_form_model_by_code(manager, questionnaire_code)
data_dictionary = _load_data(form_model, manager, questionnaire_code, request)
response_string, header_list, type_list = _format_data_for_presentation(data_dictionary, form_model)
raw_data_list = json.loads(response_string)
raw_data_list.insert(0, header_list)
file_name = request.POST.get(u"project_name")+'_analysis'
return _create_excel_response(raw_data_list, file_name)
def _get_registration_form(manager, project, project_id, type_of_subject='subject'):
previous_link = reverse(subjects_wizard, args=[project_id])
registration_questionnaire = form_model.get_form_model_by_code(manager, REGISTRATION_FORM_CODE)
fields = registration_questionnaire.fields
project_links = _make_project_links(project, registration_questionnaire.form_code)
questions = []
for field in fields:
question = _get_preview_for_field_in_registration_questionnaire(field)
question = {k:v.replace('subject', type_of_subject) for (k,v) in question.items()}
questions.append(question)
return fields, previous_link, project_links, questions, registration_questionnaire
def _load_submissions(current_page, manager, questionnaire_code, pagination=True, start_time=None, end_time=None):
form_model = get_form_model_by_code(manager, questionnaire_code)
questionnaire = (questionnaire_code, form_model.name)
fields = form_model.fields
if form_model.entity_defaults_to_reporter():
fields = form_model.fields[1:]
questions = helper.get_code_and_title(fields)
count = get_submission_count_for_form(manager, questionnaire_code, start_time, end_time)
results = {'questionnaire': questionnaire,
'questions': questions}
if count:
submissions, ids = _get_submissions_for_display(current_page - 1, manager, questionnaire_code, copy(questions),
pagination, start_time=start_time, end_time=end_time)
results.update(submissions=zip(submissions, ids))
return count, results
def subjects_wizard(request, project_id=None):
if request.method == 'GET':
manager = get_database_manager(request)
reg_form = get_form_model_by_code(manager, REGISTRATION_FORM_CODE)
previous_link = reverse(edit_profile, args=[project_id])
entity_types = get_all_entity_types(manager)
project = models.get_project(project_id, manager)
helper.remove_reporter(entity_types)
import_subject_form = SubjectUploadForm()
return render_to_response('project/subjects_wizard.html',
{'fields': reg_form.fields, "previous": previous_link, "entity_types": entity_types,
'import_subject_form': import_subject_form,
'post_url': reverse(import_subjects_from_project_wizard), 'project': project, 'step': 'subjects'},
context_instance=RequestContext(request))
if request.method == 'POST':
return HttpResponseRedirect(reverse(questionnaire_wizard, args=[project_id]))
def datasenders_wizard(request, project_id=None):
if request.method == 'GET':
manager = get_database_manager(request)
reg_form = get_form_model_by_code(manager, REGISTRATION_FORM_CODE)
previous_link = reverse(questionnaire_wizard, args=[project_id])
project = models.get_project(project_id, manager)
import_reporter_form = ReporterRegistrationForm()
_format_field_description_for_data_senders(reg_form.fields)
cleaned_up_fields = _get_questions_for_datasenders_registration_for_wizard(reg_form.fields)
return render_to_response('project/datasenders_wizard.html',
{'fields': cleaned_up_fields, "previous": previous_link,
'form': import_reporter_form,
'post_url': reverse(import_subjects_from_project_wizard), 'project': project, 'step': 'datasenders'},
context_instance=RequestContext(request))
if request.method == 'POST':
return HttpResponseRedirect(reverse(finish, args=[project_id]))
def project_data(request, project_id=None, questionnaire_code=None):
manager = get_database_manager(request)
project = models.get_project(project_id, dbm=manager)
form_model = get_form_model_by_code(manager, questionnaire_code)
project_links = _make_project_links(project, questionnaire_code)
if request.method == "GET":
data_dictionary = data.aggregate_for_form(manager, form_code=questionnaire_code,
aggregates={"*": data.reduce_functions.LATEST},
aggregate_on=EntityAggregration())
response_string, header_list, type_list = _format_data_for_presentation(data_dictionary, form_model)
return render_to_response('project/data_analysis.html',
{"entity_type": form_model.entity_type[0], "data_list": repr(response_string),
"header_list": header_list, "type_list": type_list, 'project_links': project_links, 'project': project}
,
context_instance=RequestContext(request))
if request.method == "POST":
data_dictionary = _load_data(form_model, manager, questionnaire_code, request)
response_string, header_list, type_list = _format_data_for_presentation(data_dictionary, form_model)
return HttpResponse(response_string)
def create_clinic_projects(CLINIC_ENTITY_TYPE, manager):
name_type = create_data_dict(manager, name='Name', slug='Name', primitive_type='string')
# Entity id is a default type in the system.
entity_id_type = get_datadict_type_by_slug(manager, slug='entity_id')
age_type = create_data_dict(manager, name='Age Type', slug='age', primitive_type='integer')
date_type = create_data_dict(manager, name='Report Date', slug='date', primitive_type='date')
select_type = create_data_dict(manager, name='Choice Type', slug='choice', primitive_type='select')
geo_code_type = create_data_dict(manager, name='GeoCode Type', slug='geo_code', primitive_type='geocode')
question1 = TextField(label="entity_question", code="EID", name="What is associated entity?",
language="eng", entity_question_flag=True, ddtype=entity_id_type,
length=TextConstraint(min=1, max=12))
question2 = TextField(label="Name", code="NA", name="What is your name?",
length=TextConstraint(min=1, max=10),
defaultValue="some default value", language="eng", ddtype=name_type)
question3 = IntegerField(label="Father age", code="FA", name="What is age of father?",
range=NumericConstraint(min=18, max=100), ddtype=age_type)
question4 = DateField(label="Report date", code="RD", name="What is reporting date?",
date_format="dd.mm.yyyy", ddtype=date_type)
question5 = SelectField(label="Blood Group", code="BG", name="What is your blood group?",
options=[("O+", "a"), ("O-", "b"), ("AB", "c"), ("B+", "d")], single_select_flag=True,
ddtype=select_type)
question6 = SelectField(label="Symptoms", code="SY", name="What are symptoms?",
options=[("Rapid weight loss", "a"), ("Dry cough", "b"), ("Pneumonia", "c"),
("Memory loss", "d"), ("Neurological disorders ", "e")], single_select_flag=False,
ddtype=select_type)
question7 = GeoCodeField(name="What is the GPS code for clinic", code="GPS", label="What is the GPS code for clinic?",
language="eng", ddtype=geo_code_type)
form_model = FormModel(manager, name="AIDS", label="Aids form_model",
form_code="cli001", type='survey',
fields=[question1, question2, question3, question4, question5, question6, question7],
entity_type=CLINIC_ENTITY_TYPE
)
try:
qid = form_model.save()
except DataObjectAlreadyExists as e:
get_form_model_by_code(manager, "cli001").delete()
qid = form_model.save()
project = Project(name="Clinic Test Project", goals="This project is for automation", project_type="survey",
entity_type=CLINIC_ENTITY_TYPE[-1], devices=["sms"], activity_report='no',sender_group="close")
project.qid = qid
project.state = ProjectState.ACTIVE
try:
project.save(manager)
except Exception:
pass
form_model2 = FormModel(manager, name="AIDS", label="Aids form_model",
form_code="cli002", type='survey',
fields=[question1, question2, question3, question4, question5, question6, question7],
entity_type=CLINIC_ENTITY_TYPE)
try:
qid2 = form_model2.save()
except DataObjectAlreadyExists as e:
get_form_model_by_code(manager, "cli002").delete()
qid2 = form_model2.save()
project2 = Project(name="Clinic2 Test Project", goals="This project is for automation", project_type="survey",
entity_type=CLINIC_ENTITY_TYPE[-1], devices=["sms"], activity_report='no', sender_group="close")
project2.qid = qid2
project2.state = ProjectState.ACTIVE
try:
project2.save(manager)
except Exception:
pass
def subjects(request, project_id=None):
manager = get_database_manager(request)
project, project_links = _get_project_and_project_link(manager, project_id)
reg_form = get_form_model_by_code(manager, REGISTRATION_FORM_CODE)
return render_to_response('project/subjects.html', {'fields': reg_form.fields, 'project':project, 'project_links':project_links}, context_instance=RequestContext(request))
try:
qid = form_model.save()
except DataObjectAlreadyExists as e:
get_form_model_by_code(dbm, "PISurvey").delete()
qid = form_model.save()
return form_model
form_model = SaveQuestionnaire(dbm)
#exit(0)
answers = OrderedDict({"ID" : "111", "FIRSTNAME":"Qingshan", "LASTNAME":"Zhuan", "BIRTHDATE" : "2000000","COMMENT":"Learning mangrove now."})
cleaned_values, errors = form_model.validate_submission(answers)
for i in cleaned_values:
print "cleaned value:", i
for i in errors:
print "error:", i
form = get_form_model_by_code(dbm, form_model.form_code)
print "form id is:", form.id
for field in form.fields:
print field.name, field.label, field.type, field.code
form_submission = FormSubmissionFactory().get_form_submission(form, answers)
form_submission.save(dbm)
def _handle_registration_form(self, dbm, form_code, values):
form_model = get_form_model_by_code(dbm, form_code)
if form_model.is_registration_form():
_generate_short_code_if_registration_form(dbm, form_model, values)
self._get_location_data(values)
def _delete_reg_form_if_exists(manager):
try:
form_model = get_form_model_by_code(manager, REGISTRATION_FORM_CODE)
form_model.delete()
except FormModelDoesNotExistsException:
pass
def CreateSchoolByGlobalFormModel(self):
global_form = get_form_model_by_code(self.manager, REGISTRATION_FORM_CODE)
submission = OrderedDict({"t": self.entity_type, "n": "beihang-global", "s": "bh-g", "l": ["Global","China"],"m": "12345678987654321","g":(1,1)})
# GlobalRegistrationFormSubmission(global_form, submission, errors=None).save(self.manager)
FormSubmissionFactory().get_form_submission(global_form, submission).save(self.manager)
def test_create_form_model(self):
form_code, qid = self.CreateFormModel()
form = get_form_model_by_code(self.manager, form_code)
self.assertTrue(qid)
self.assertEqual(form.form_code, form_code)
