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)