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)
