def test_should_update_project(self): self.project1 = Project.get(self.manager, self.project1_id) self.project1.update( dict(name=project1_name, devices=['web', 'sms'], goals="New goals")) project1_id = self.project1.save() project = Project.get(self.manager, project1_id) self.assertEquals(project.name, project1_name) self.assertEquals(project.goals, 'New goals') self.assertEquals(project.devices, ['web', 'sms'])
def test_should_delete_datasender_from_project(self): self.project1 = Project.get(self.manager, self.project1_id) self.project1.data_senders = ['rep1', 'rep2'] datasender_to_be_deleted = 'rep1' with patch( "datawinners.search.datasender_index.update_datasender_index_by_id" ) as update_datasender_index_by_id: update_datasender_index_by_id.return_value = None self.project1.delete_datasender(self.manager, datasender_to_be_deleted) self.project1 = Project.get(self.manager, self.project1_id) expected_data_senders = ['rep2'] self.assertEqual(self.project1.data_senders, expected_data_senders)
def delete(request, project_id): dbm = get_database_manager(request.user) questionnaire = Project.get(dbm, project_id) dashboard_page = settings.HOME_PAGE + "?deleted=true" if questionnaire.is_void(): return HttpResponseRedirect(dashboard_page) survey_response_ids = get_survey_response_ids_from_request(dbm, request, questionnaire) received_times = [] for survey_response_id in survey_response_ids: survey_response = SurveyResponse.get(dbm, survey_response_id) received_times.append(datetime.datetime.strftime(survey_response.submitted_on, "%d/%m/%Y %X")) feeds_dbm = get_feeds_database(request.user) additional_feed_dictionary = get_project_details_dict_for_feed(questionnaire) delete_response = WebPlayerV2(dbm, feeds_dbm).delete_survey_response(survey_response, additional_feed_dictionary, websubmission_logger) mail_feed_errors(delete_response, dbm.database_name) if survey_response.data_record: ReportRouter().delete(get_organization(request).org_id, survey_response.form_code, survey_response.data_record.id) if len(received_times): UserActivityLog().log(request, action=DELETED_DATA_SUBMISSION, project=questionnaire.name, detail=json.dumps({"Date Received": "[%s]" % ", ".join(received_times)})) response = encode_json({'success_message': ugettext("The selected records have been deleted"), 'success': True}) else: response = encode_json({'error_message': ugettext("No records deleted"), 'success': False}) return HttpResponse(response)
def sent_reminders(request, project_id): dbm = get_database_manager(request.user) dashboard_page = settings.HOME_PAGE + "?deleted=true" questionnaire = Project.get(dbm, project_id) if questionnaire.is_void(): return HttpResponseRedirect(dashboard_page) organization = Organization.objects.get( org_id=request.user.get_profile().org_id) is_trial_account = organization.in_trial_mode html = 'project/sent_reminders_trial.html' if organization.in_trial_mode else 'project/sent_reminders.html' return render_to_response(html, { 'project': questionnaire, "project_links": make_project_links(questionnaire), 'is_quota_reached': is_quota_reached(request, organization=organization), 'reminders': get_all_reminder_logs_for_project(project_id, dbm), 'in_trial_mode': is_trial_account, 'questionnaire_code': questionnaire.form_code }, context_instance=RequestContext(request))
def questionnaire(request, project_id): manager = get_database_manager(request.user) if request.method == 'GET': questionnaire = Project.get(manager, project_id) if questionnaire.is_void(): return HttpResponseRedirect(settings.HOME_PAGE + "?deleted=true") fields = questionnaire.fields existing_questions = json.dumps(fields, default=field_to_json) project_links = make_project_links(questionnaire) success, error = submission_stats(manager, questionnaire.form_code) project_has_submissions = (success + error > 0) in_trial_mode = _in_trial_mode(request) is_success = False active_language = request.LANGUAGE_CODE if "success" in [m.message for m in messages.get_messages(request)]: is_success = True return render_to_response( 'project/questionnaire.html', { "existing_questions": repr(existing_questions), 'questionnaire_code': questionnaire.form_code, 'project': questionnaire, 'project_has_submissions': project_has_submissions, 'project_links': project_links, 'is_quota_reached': is_quota_reached(request), 'in_trial_mode': in_trial_mode, 'is_success': is_success, 'active_language': active_language, 'post_url': reverse(edit_project, args=[project_id]), 'unique_id_types': get_unique_id_types(manager), 'preview_links': get_preview_and_instruction_links() }, 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 questionnaire_preview(request, project_id=None, sms_preview=False): manager = get_database_manager(request.user) if request.method == 'GET': dashboard_page = settings.HOME_PAGE + "?deleted=true" questionnaire = Project.get(manager, project_id) if questionnaire.is_void(): return HttpResponseRedirect(dashboard_page) #if form_model.is_entity_type_reporter(): # fields = helper.hide_entity_question(form_model.fields) project_links = make_project_links(questionnaire) questions = [] fields = questionnaire.fields for field in fields: question = helper.get_preview_for_field(field) questions.append(question) example_sms = "%s" % (questionnaire.form_code) example_sms += get_example_sms(fields) template = 'project/questionnaire_preview.html' if sms_preview else 'project/questionnaire_preview_list.html' return render_to_response( template, { "questions": questions, 'questionnaire_code': questionnaire.form_code, 'project': questionnaire, 'project_links': project_links, 'is_quota_reached': is_quota_reached(request), 'example_sms': example_sms, 'org_number': get_organization_telephone_number(request) }, context_instance=RequestContext(request))
def get_project_info(manager, project): project_id = project['value']['_id'] questionnaire = Project.get(manager, project_id) questionnaire_code = questionnaire.form_code analysis, disabled, log = get_project_analysis_and_log_link(project_id, questionnaire_code) web_submission_link = reverse("web_questionnaire", args=[project_id]) web_submission_link_disabled = 'disable_link' if 'web' in project['value']['devices']: web_submission_link_disabled = "" create_subjects_links = {} for entity_type in questionnaire.entity_type: create_subjects_links.update({entity_type: append_query_strings_to_url(reverse("create_subject", args=[entity_type]), web_view=True)}) project_info = dict(project_id=project_id, name=project['value']['name'], qid=questionnaire_code, created=project['value']['created'], link=(reverse('project-overview', args=[project_id])), log=log, analysis=analysis, disabled=disabled, web_submission_link=web_submission_link, web_submission_link_disabled=web_submission_link_disabled, create_subjects_link=create_subjects_links, entity_type=questionnaire.entity_type, encoded_name=urlquote(project['value']['name']), import_template_file_name=slugify(project['value']['name'])) return project_info
def subject_registration_form_preview(request, project_id=None, 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) if not entity_type: entity_type = questionnaire.entity_type[0] if request.method == "GET": fields, project_links, questions, registration_questionnaire = _get_registration_form( manager, questionnaire, entity_type) example_sms = get_example_sms_message( fields, registration_questionnaire.form_code) return render_to_response( 'project/questionnaire_preview_list.html', { "questions": questions, 'questionnaire_code': registration_questionnaire.form_code, 'project': questionnaire, 'project_links': project_links, 'is_quota_reached': is_quota_reached(request), 'example_sms': example_sms, 'org_number': get_organization_telephone_number(request) }, context_instance=RequestContext(request))
def rename_project(request, project_id): manager = get_database_manager(request.user) questionnaire = Project.get(manager, project_id) new_project_name = request.POST.get('data', '').strip() if len(new_project_name) == 0: return HttpResponse(json.dumps({ "status": "error", "message": ugettext("This field is required.") }), content_type='application/json') if (questionnaire.name != new_project_name): questionnaire.name = new_project_name try: questionnaire.save(process_post_update=True) UserActivityLog().log(request, action=RENAMED_PROJECT, project=questionnaire.name) return HttpResponse(json.dumps({"status": "success"}), content_type='application/json') except DataObjectAlreadyExists as e: return HttpResponse(json.dumps({ "status": "error", "message": ugettext("Questionnaire with same name already exists.") }), content_type='application/json') return HttpResponse(json.dumps({"status": "success"}), content_type='application/json')
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 _get_projects(self, manager, request): project_ids = request.POST.get('project_id').split(';') questionnaires = [] for project_id in project_ids: questionnaire = Project.get(manager, project_id) if questionnaire is not None: questionnaires.append(questionnaire) return questionnaires
def __init__(self, request, project_id=None): self.request = request self.manager = get_database_manager(self.request.user) self.questionnaire = Project.get(self.manager, project_id) self.form_code = self.questionnaire.form_code self.feeds_dbm = get_feeds_database(request.user) self.is_data_sender = self.request.user.get_profile().reporter self.disable_link_class, self.hide_link_class = get_visibility_settings_for( self.request.user)
def wrapper(*args, **kw): request = args[0] user = request.user dbm = get_database_manager(user) project_id = kw["project_id"] questionnaire = Project.get(dbm, project_id) if "web" not in questionnaire.devices: referer = django_settings.HOME_PAGE return HttpResponseRedirect(referer) return f(*args, **kw)
def registered_datasenders(request, project_id): manager = get_database_manager(request.user) questionnaire = Project.get(manager, project_id) project_links = get_project_link(questionnaire) dashboard_page = settings.HOME_PAGE + "?deleted=true" if questionnaire.is_void(): return HttpResponseRedirect(dashboard_page) if request.method == 'GET': in_trial_mode = _in_trial_mode(request) user_rep_id_name_dict = rep_id_name_dict_of_users(manager) return render_to_response( 'project/registered_datasenders.html', { 'project': questionnaire, 'project_links': project_links, 'questionnaire_code': questionnaire.form_code, 'current_language': translation.get_language(), 'is_quota_reached': is_quota_reached(request), 'in_trial_mode': in_trial_mode, 'user_dict': json.dumps(user_rep_id_name_dict) }, context_instance=RequestContext(request)) if request.method == 'POST': error_message, failure_imports, success_message, successful_imports = import_module.import_data( request, manager, default_parser=XlsDatasenderParser) imported_data_senders = parse_successful_imports(successful_imports) imported_datasenders_ids = [ imported_data_sender["id"] for imported_data_sender in imported_data_senders ] _add_imported_datasenders_to_project(imported_datasenders_ids, manager, questionnaire) if len(imported_datasenders_ids): UserActivityLog().log(request, action=IMPORTED_DATA_SENDERS, detail=json.dumps( dict({ "Unique ID": "[%s]" % ", ".join(imported_datasenders_ids) })), project=questionnaire.name) 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': imported_data_senders }))
def delete_projects(request, project_id): 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) helper.delete_project(manager, questionnaire) undelete_link = reverse(undelete_projects, args=[project_id]) if len(get_all_projects(manager)) > 0: messages.info(request, undelete_link) UserActivityLog().log(request, action=DELETED_PROJECT, project=questionnaire.name) return HttpResponseRedirect(reverse(index))
def _initialize(self, project_id, entity_type=None): self.manager = get_database_manager(self.request.user) self.questionnaire = Project.get(self.manager, project_id) if self.questionnaire.is_void(): return HttpResponseRedirect(settings.HOME_PAGE + "?deleted=true") self.is_data_sender = self.request.user.get_profile().reporter self.disable_link_class, self.hide_link_class = get_visibility_settings_for( self.request.user) #self.form_code = self.questionnaire.form_code self.entity_type = entity_type self.form_model = _get_subject_form_model(self.manager, entity_type) self.subject_registration_code = get_form_code_by_entity_type( self.manager, [entity_type])
def get_questionnaire_ajax(request, project_id): manager = get_database_manager(request.user) project = Project.get(manager, project_id) existing_questions = project.fields return HttpResponse(json.dumps( { 'name': project.name, 'language': project.language, 'questions': existing_questions, 'datasenders': project.data_senders, 'reminder_and_deadline': project.reminder_and_deadline }, default=field_to_json), content_type='application/json')
def post(self, request, *args, **kwargs): entity_links = { 'registered_datasenders_link': reverse("all_datasenders") } dbm = get_database_manager(request.user) org_id = request.user.get_profile().org_id form = ReporterRegistrationForm(org_id=org_id, data=request.POST) try: reporter_id, message = process_create_data_sender_form( dbm, form, org_id) except DataObjectAlreadyExists as e: message = _( "Data Sender with Unique Identification Number (ID) = %s already exists." ) % e.data[1] if len(form.errors) == 0 and form.requires_web_access( ) and reporter_id: email_id = form.cleaned_data['email'] create_single_web_user(org_id=org_id, email_address=email_id, reporter_id=reporter_id, language_code=request.LANGUAGE_CODE) if message is not None and reporter_id: if form.cleaned_data['project_id'] != "": questionnaire = Project.get(dbm, form.cleaned_data['project_id']) questionnaire.associate_data_sender_to_project( dbm, reporter_id) questionnaire = questionnaire.name else: questionnaire = "" if not len(form.errors): UserActivityLog().log(request, action=REGISTERED_DATA_SENDER, detail=json.dumps( dict({"Unique ID": reporter_id})), project=questionnaire) form = ReporterRegistrationForm( initial={'project_id': form.cleaned_data['project_id']}) return render_to_response( 'datasender_form.html', { 'form': form, 'message': message, 'success': reporter_id is not None, 'project_inks': entity_links, 'current_language': translation.get_language(), 'registration_link': '/entity/datasender/register/', }, context_instance=RequestContext(request))
def get_submissions_about_project(request, project_id): dbm = get_database_manager(request.user) questionnaire = Project.get(dbm, project_id) rows = dbm.load_all_rows_in_view('undeleted_survey_response', reduce=False, descending=True, startkey=[questionnaire.form_code, {}], endkey=[questionnaire.form_code], limit=7) submission_list = [] for row in rows: reporter = _find_reporter_name(dbm, row) message = _make_message(row) submission = dict(message=message, created=row.value["submitted_on"].strftime("%B %d %y %H:%M"), reporter=reporter, status=row.value["status"]) submission_list.append(submission) submission_response = json.dumps(submission_list) return HttpResponse(submission_response)
def send_reminders_for_an_organization(org, on_date, sms_client, from_number, dbm): """ Sends out all reminders for an organization, scheduled for the given date. """ reminders_grouped_by_proj = _get_reminders_grouped_by_project_for_organization(org.org_id) logger.info("Projects with reminders:- %d" % len(reminders_grouped_by_proj)) for project_id, reminders in reminders_grouped_by_proj.items(): try: project = Project.get(dbm, project_id) if not project.has_deadline(): continue #send reminders to next projects in the queue if their is any error while sending reminders to previous project _, total_sms_sent = send_reminders_on(project, reminders, on_date, sms_client, from_number, dbm) org.increment_message_count_for(sent_reminders_count=total_sms_sent) except Exception: logger.exception("Exception while sending reminders for this project")
def post(self, request, project_id): dbm = get_database_manager(request.user) questionnaire = Project.get(dbm, project_id) try: questionnaire.activeLanguages = [request.POST['selected_language']] questionnaire.is_outgoing_sms_replies_enabled = request.POST[ 'enable_sms_replies'] == 'true' questionnaire.save() is_success = True if 'resp_message' in request.GET: messages.info(request, ugettext('Your changes have been saved.'), extra_tags='success') except: is_success = False return HttpResponse(json.dumps({'success': is_success}), mimetype='application/json', content_type='application/json')
def geo_json_for_project(request, project_id, entity_type=None): dbm = get_database_manager(request.user) location_list = [] try: if entity_type: first_geocode_field = _get_first_geocode_field_for_entity_type(dbm, entity_type) if first_geocode_field: unique_ids = get_all_entities(dbm, [entity_type], limit=1000) location_list.extend(get_location_list_for_entities(first_geocode_field, unique_ids)) else: questionnaire = Project.get(dbm, project_id) unique_ids = by_short_codes(dbm, questionnaire.data_senders, ["reporter"], limit=1000) location_list.extend(get_location_list_for_datasenders(unique_ids)) except DataObjectNotFound: pass location_geojson = {"type": "FeatureCollection", "features": location_list} return HttpResponse(json.dumps(location_geojson))
def get(self, request, project_id): dbm = get_database_manager(request.user) questionnaire = Project.get(dbm, project_id) languages_list = get_available_project_languages(dbm) current_project_language = questionnaire.language return self.render_to_response({ 'project': questionnaire, 'project_links': make_project_links(questionnaire), 'languages_list': json.dumps(languages_list), 'languages_link': reverse('languages'), 'current_project_language': current_project_language, 'post_url': reverse("project-language", args=[project_id]) })
def analysis_results(request, project_id=None, questionnaire_code=None): manager = get_database_manager(request.user) org_id = helper.get_org_id_by_user(request.user) if request.method == 'GET': questionnaire = Project.get(manager, project_id) dashboard_page = settings.HOME_PAGE + "?deleted=true" if questionnaire.is_void(): return HttpResponseRedirect(dashboard_page) filterable_fields = _get_filterable_fields(questionnaire) first_filterable_fields = filterable_fields.pop(0) if filterable_fields else None result_dict = { "is_quota_reached": is_quota_reached(request, org_id=org_id), "first_filterable_field": first_filterable_fields, "filterable_fields": filterable_fields } result_dict.update(project_info(request, questionnaire, questionnaire_code)) return render_to_response('project/analysis_results.html', result_dict, context_instance=RequestContext(request))
def broadcast_message(request, project_id): dbm = get_database_manager(request.user) questionnaire = Project.get(dbm, project_id) dashboard_page = settings.HOME_PAGE + "?deleted=true" if questionnaire.is_void(): return HttpResponseRedirect(dashboard_page) number_associated_ds = len(questionnaire.data_senders) number_of_ds = len( import_module.load_all_entities_of_type(dbm, type=REPORTER)[0]) - 1 organization = utils.get_organization(request) account_type = organization.account_type if (account_type == 'Pro'): account_type = True if request.method == 'GET': form = BroadcastMessageForm(associated_ds=number_associated_ds, number_of_ds=number_of_ds) html = 'project/broadcast_message_trial.html' if organization.in_trial_mode else 'project/broadcast_message.html' return render_to_response(html, { 'project': questionnaire, "project_links": make_project_links(questionnaire), 'is_quota_reached': is_quota_reached(request, organization=organization), "form": form, "ong_country": organization.country, "success": None, 'questionnaire_code': questionnaire.form_code }, context_instance=RequestContext(request)) if request.method == 'POST': form = BroadcastMessageForm(associated_ds=number_associated_ds, number_of_ds=number_of_ds, data=request.POST) if form.is_valid(): no_smsc = False data_senders = _get_data_senders(dbm, form, questionnaire) organization_setting = OrganizationSetting.objects.get( organization=organization) current_month = datetime.date(datetime.datetime.now().year, datetime.datetime.now().month, 1) message_tracker = organization._get_message_tracker(current_month) other_numbers = form.cleaned_data['others'] failed_numbers = [] try: failed_numbers = helper.broadcast_message( data_senders, form.cleaned_data['text'], organization_setting.get_organisation_sms_number()[0], other_numbers, message_tracker, country_code=organization.get_phone_country_code()) except NoSMSCException as e: no_smsc = True success = not no_smsc and len(failed_numbers) == 0 if success: form = BroadcastMessageForm(associated_ds=number_associated_ds, number_of_ds=number_of_ds) else: form = BroadcastMessageForm(associated_ds=number_associated_ds, number_of_ds=number_of_ds, data=request.POST) return render_to_response('project/broadcast_message.html', { 'project': questionnaire, "project_links": make_project_links(questionnaire), 'is_quota_reached': is_quota_reached(request, organization=organization), "form": form, "account_type": account_type, "ong_country": organization.country, "no_smsc": no_smsc, 'failed_numbers': ",".join(failed_numbers), "success": success }, context_instance=RequestContext(request)) return render_to_response('project/broadcast_message.html', { 'project': questionnaire, "project_links": make_project_links(questionnaire), "form": form, 'is_quota_reached': is_quota_reached(request, organization=organization), 'success': None, "ong_country": organization.country }, context_instance=RequestContext(request))
def create_data_sender_and_web_user(request, project_id): manager = get_database_manager(request.user) questionnaire = Project.get(manager, project_id) project_links = get_project_link(questionnaire) dashboard_page = settings.HOME_PAGE + "?deleted=true" if questionnaire.is_void(): return HttpResponseRedirect(dashboard_page) in_trial_mode = _in_trial_mode(request) if request.method == 'GET': form = ReporterRegistrationForm(initial={'project_id': project_id}) return render_to_response( 'project/register_datasender.html', { 'project': questionnaire, 'project_links': project_links, 'is_quota_reached': is_quota_reached(request), 'form': form, 'in_trial_mode': in_trial_mode, 'questionnaire_code': questionnaire.form_code, 'current_language': translation.get_language() }, context_instance=RequestContext(request)) if request.method == 'POST': org_id = request.user.get_profile().org_id form = ReporterRegistrationForm(org_id=org_id, data=request.POST) reporter_id = None try: reporter_id, message = process_create_data_sender_form( manager, form, org_id) except DataObjectAlreadyExists as e: message = _( "Data Sender with Unique Identification Number (ID) = %s already exists." ) % e.data[1] if not len(form.errors) and reporter_id: project = questionnaire project.associate_data_sender_to_project(manager, reporter_id) if form.requires_web_access(): email_id = request.POST['email'] create_single_web_user(org_id=org_id, email_address=email_id, reporter_id=reporter_id, language_code=request.LANGUAGE_CODE) UserActivityLog().log(request, action=REGISTERED_DATA_SENDER, detail=json.dumps( dict({"Unique ID": reporter_id})), project=questionnaire.name) if message is not None and reporter_id: form = ReporterRegistrationForm( initial={'project_id': form.cleaned_data['project_id']}) context = { 'form': form, 'message': message, 'in_trial_mode': in_trial_mode, 'success': reporter_id is not None } return render_to_response('datasender_form.html', context, context_instance=RequestContext(request))
def project_overview(request, project_id): 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) number_of_questions = len(questionnaire.fields) questionnaire_code = questionnaire.form_code project_links = make_project_links(questionnaire) map_api_key = get_map_key(request.META['HTTP_HOST']) number_data_sender = len(questionnaire.data_senders) number_records = survey_response_count(manager, questionnaire_code, None, None) number_reminders = Reminder.objects.filter( project_id=questionnaire.id).count() links = { 'registered_data_senders': reverse("registered_datasenders", args=[project_id]), 'web_questionnaire_list': reverse('web_questionnaire', args=[project_id]) } add_subjects_to_see_on_map_msg = "" if not is_empty(questionnaire.entity_type): subject_links = {} for entity_type in questionnaire.entity_type: subject_links.update({ entity_type: append_query_strings_to_url(reverse( "subject_questionnaire", args=[project_id, entity_type]), web_view=True) }) links.update({'create_subjects_links': subject_links}) add_subjects_to_see_on_map_msg = _( "Register %s to see them on this map" ) % questionnaire.entity_type[0] if get_entity_count_for_type( manager, questionnaire.entity_type[0]) == 0 else "" entity_type = "" has_multiple_unique_id = False in_trial_mode = _in_trial_mode(request) unique_id_header_text = "" if len(questionnaire.entity_type) == 1: entity_type = questionnaire.entity_type[0] unique_id_header_text = "%s %s &" % (ugettext("My"), entity_type.capitalize()) if len(questionnaire.entity_type) > 1: has_multiple_unique_id = True unique_id_header_text = "%s &" % ugettext("My Identification Numbers") return render_to_response( 'project/overview.html', RequestContext( request, { 'project': questionnaire, 'project_links': project_links, 'is_quota_reached': is_quota_reached(request), 'number_of_questions': number_of_questions, 'map_api_key': map_api_key, 'number_data_sender': number_data_sender, 'number_records': number_records, 'number_reminders': number_reminders, 'links': links, 'add_subjects_to_see_on_map_msg': add_subjects_to_see_on_map_msg, 'in_trial_mode': in_trial_mode, 'questionnaire_code': questionnaire_code, 'has_multiple_unique_id': has_multiple_unique_id, 'entity_type': json.dumps(entity_type), 'unique_id_header_text': unique_id_header_text, 'org_number': get_organization_telephone_number(request) }))
def undelete_project(request, project_id): manager = get_database_manager(request.user) questionnaire = Project.get(manager, project_id) helper.delete_project(manager, questionnaire, void=False) return HttpResponseRedirect(reverse(views.index))
def test_get_one_project(self): self.assertEquals( Project.get(self.manager, self.project1_id).id, self.project1_id)