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'
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 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 post(self, request, project_id):
data = request.POST['data']
file_type = request.POST['file_type']
is_draft = request.POST['is_draft']
try:
excel_as_dict = json.loads(data, object_pairs_hook=OrderedDict)
if is_draft and is_draft.lower().strip() == 'true':
manager = get_database_manager(request.user)
questionnaire = Project.get(manager, project_id)
_save_questionnaire_as_dict_for_builder(
questionnaire, excel_as_dict=excel_as_dict)
return HttpResponse(json.dumps({
"status": "success",
"project_id": project_id,
'reason': 'Successfully updated',
'details': ''
}),
content_type='application/json')
excel_raw_stream = convert_json_to_excel(excel_as_dict, file_type)
excel_file = _temp_file(request, excel_raw_stream, file_type)
return _edit_questionnaire(request, project_id, excel_file,
excel_as_dict)
except Exception as e:
logger.exception('Unable to save questionnaire from builder')
return HttpResponse(
json.dumps({
"status": "error",
"project_id": project_id,
'reason': 'Unable to save', # TODO: i18n translation
'details': e.message
}),
content_type='application/json')
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.fields, [])
first_filterable_fields = filterable_fields.pop(
0) if filterable_fields else None
result_dict = {
"xform": questionnaire.xform,
"user_email": request.user.email,
"is_quota_reached": is_quota_reached(request, org_id=org_id),
"first_filterable_field": first_filterable_fields,
"filterable_fields": filterable_fields,
'is_pro_sms': get_organization(request).is_pro_sms,
"is_media_field_present":
questionnaire.is_media_type_fields_present
# first 3 columns are additional submission data fields (ds_is, ds_name and submission_status
}
result_dict.update(
project_info(request, questionnaire, questionnaire_code))
return render_to_response('project/analysis_results.html',
result_dict,
context_instance=RequestContext(request))
def send_reminders_for_an_organization(org,
on_date,
sms_client,
from_number,
dbm,
charged_sms=False):
"""
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)
increment_dict = {'sent_reminders_count': total_sms_sent}
if charged_sms:
increment_dict.update(
{'sent_reminders_charged_count': total_sms_sent})
org.increment_message_count_for(**increment_dict)
except Exception:
logger.exception(
"Exception while sending reminders for this project")
def post(self, request):
project_name = request.GET['pname'].strip()
manager = get_database_manager(request.user)
try:
xls_parser_response = _try_parse_xls(manager, request,
project_name)
if isinstance(xls_parser_response, HttpResponse):
return xls_parser_response
send_email_if_unique_id_type_question_has_no_registered_unique_ids(
xls_parser_response, request, project_name)
questionnaire_code = generate_questionnaire_code(manager)
excel_file = _temp_file(request)
mangrove_service = MangroveService(
request,
questionnaire_code=questionnaire_code,
project_name=project_name,
xls_form=excel_file,
xls_parser_response=xls_parser_response)
questionnaire_id, form_code = mangrove_service.create_project()
if not questionnaire_id:
logger.info("User: %s. Upload Error: %s",
request.user.username,
"Questionnaire must be unique")
return HttpResponse(
content_type='application/json',
content=json.dumps({
'success':
False,
'error_msg': [
_("Duplicate labels. All questions (labels) must be unique."
)
],
'message_prefix':
_("Sorry! Current version of DataWinners does not support"
),
'message_suffix':
_("Update your XLSForm and upload again.")
}))
questionnaire = Project.get(manager, questionnaire_id)
_save_questionnaire_as_dict_for_builder(questionnaire,
excel_file=excel_file)
except QuestionAlreadyExistsException as e:
return HttpResponse(content_type='application/json',
content=json.dumps({
'success': False,
'error_msg': [_(e.message)]
}))
return HttpResponse(json.dumps({
"success": True,
"project_name": project_name,
"project_id": questionnaire_id,
"form_code": form_code
}),
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_submission_breakup(request, project_id):
dbm = get_database_manager(request.user)
questionnaire = Project.get(dbm, project_id)
submission_success, submission_errors = submission_stats(
dbm, questionnaire.id)
response = json.dumps([submission_success, submission_errors])
return HttpResponse(response)
def my_poll_recipients_count(request, project_id):
dbm = get_database_manager(request.user)
questionnaire = Project.get(dbm, project_id)
contact_dict = _get_poll_recipients(dbm, questionnaire)
return HttpResponse(content_type='application/json',
content=json.dumps(
{'my_poll_recipients': contact_dict}))
def make_user_data_sender_with_project(manager, reporter_id, project_id):
questionnaire = Project.get(manager, project_id)
reporters_to_associate = [reporter_id]
questionnaire.associate_data_sender_to_project(manager,
reporters_to_associate)
for data_senders_code in reporters_to_associate:
update_datasender_index_by_id(data_senders_code, manager)
def edit_xform_submission_post(request, survey_response_id):
manager = get_database_manager(request.user)
survey_response = get_survey_response_by_id(manager, survey_response_id)
activity_log = UserActivityLog()
questionnaire = Project.get(manager, survey_response.form_model_id)
old_data = survey_response._doc.values
try:
response = XFormWebSubmissionHandler(request=request). \
update_submission_response(survey_response_id)
new_survey_response = get_survey_response_by_id(
manager, survey_response_id)
new_data = new_survey_response._doc.values
edit_details = _details_for_activity_log(new_data, old_data,
questionnaire)
activity_log.log(request,
action=EDITED_DATA_SUBMISSION_ADV_QUEST,
project=questionnaire.name,
detail=json.dumps(edit_details))
return response
except Exception as e:
logger.exception("Exception in submission : \n%s" % e)
send_email_on_exception(request.user,
"Edit Web Submission",
traceback.format_exc(),
additional_details={
'survey_response_id': survey_response_id,
'submitted-data': request.POST['form_data']
})
return HttpResponseBadRequest()
def _associate_datasender_to_poll_questionnaire(self, current_project_id,
dbm, short_codes):
questionnaire = Project.get(dbm, current_project_id)
questionnaire.associate_data_sender_to_project(dbm, short_codes)
questionnaire.save()
for short_code in short_codes:
update_datasender_index_by_id(short_code, dbm)
def _associate_datasender_to_questionnaire(self, dbm, reporter_id, questionnaire_id):
questionnaire = Project.get(dbm, questionnaire_id)
reporters_to_associate = [reporter_id]
questionnaire.associate_data_sender_to_project(dbm, reporters_to_associate)
for data_senders_code in reporters_to_associate:
update_datasender_index_by_id(data_senders_code, dbm)
return questionnaire.name
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 remove_user_as_datasender_for_projects(manager, project_ids,
selected_questionnaires,
reporter_id):
removed_questionnaires = list(
set(project_ids) - set(selected_questionnaires))
for questionnaire in removed_questionnaires:
project = Project.get(manager, questionnaire)
project.delete_datasender(manager, reporter_id)
update_datasender_index_by_id(reporter_id, manager)
def associate_user_with_existing_project(manager, reporter_id):
rows = get_all_projects(manager)
for row in rows:
project_id = row['value']['_id']
questionnaire = Project.get(manager, project_id)
reporters_to_associate = [reporter_id]
questionnaire.associate_data_sender_to_project(manager, reporters_to_associate)
for data_senders_code in reporters_to_associate:
update_datasender_index_by_id(data_senders_code, manager)
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 delete_datasenders_from_project(manager, data_sender_ids):
from datawinners.search.datasender_index import update_datasender_index_by_id
for entity_id in data_sender_ids:
associated_projects = get_all_projects(manager,
data_sender_id=entity_id)
for associated_project in associated_projects:
project = Project.get(manager, associated_project['value']['_id'])
project.delete_datasender(manager, entity_id)
update_datasender_index_by_id(entity_id, manager)
def deactivate_poll(request, project_id):
if request.method == 'POST':
manager = get_database_manager(request.user)
questionnaire = Project.get(manager, project_id)
if questionnaire:
_change_questionnaire_status(questionnaire, "deactivated")
UserActivityLog().log(request,
action=DEACTIVATE_POLL,
project=questionnaire.name,
detail=questionnaire.name)
return HttpResponse(json.dumps({'success': True}))
return HttpResponse(json.dumps({'success': False}))
def reminder_settings(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)
if questionnaire.is_poll:
return HttpResponseRedirect('/project/'+ project_id + '/results/'+questionnaire.form_code)
from datawinners.project.views.views import make_project_links
project_links = make_project_links(questionnaire)
active_language = request.LANGUAGE_CODE
org_id = (NGOUserProfile.objects.get(user=request.user)).org_id
organization = Organization.objects.get(org_id=org_id)
is_reminder_disabled = is_empty(questionnaire.data_senders)
url_to_my_datasender = project_links['registered_datasenders_link']
html = 'project/reminders_trial.html' if organization.in_trial_mode else 'project/reminder_settings.html'
if request.method == 'GET':
data = (_reminder_info_about_project(questionnaire))
return render_to_response(html,
{'project_links': project_links,
'is_quota_reached': is_quota_reached(request, organization=organization),
'project': questionnaire,
'reminder_data': repr(json.dumps(data)),
'questionnaire_code': questionnaire.form_code,
'is_reminder_disabled': is_reminder_disabled,
'active_language': active_language,
'no_of_my_datasenders': len(questionnaire.data_senders),
'is_pro_sms': get_organization(request).is_pro_sms,
'url_to_my_datasender': url_to_my_datasender,
'post_url': reverse(reminder_settings, args=[project_id])
}, context_instance=RequestContext(request))
if request.method == 'POST':
post_data = request.POST.copy()
post_data['should_send_reminder_to_all_ds'] = not post_data['whom_to_send_message'] == 'true'
post_data = _populate_week_month_data(post_data)
org_id = NGOUserProfile.objects.get(user=request.user).org_id
organization = Organization.objects.get(org_id=org_id)
reminder_list = Reminder.objects.filter(project_id=questionnaire.id)
action = _get_activity_log_action(reminder_list, post_data)
questionnaire, set_deadline = _add_reminder_info_to_project(post_data, questionnaire, organization,
reminder_list=reminder_list)
questionnaire.save()
if action is not None:
UserActivityLog().log(request, action=action, project=questionnaire.name)
if set_deadline:
UserActivityLog().log(request, action=SET_DEADLINE, project=questionnaire.name)
response = {'success_message': ugettext("Reminder settings saved successfully."), 'success': True, 'is_pro_sms': get_organization(request).is_pro_sms,}
return HttpResponse(json.dumps(response))
def activate_poll(request, project_id):
if request.method == 'POST':
manager = get_database_manager(request.user)
questionnaire = Project.get(manager, project_id)
if questionnaire:
response_dict = _create_reponse_for_activated_poll(
manager, questionnaire, request)
return HttpResponse(json.dumps(response_dict))
return HttpResponse(
json.dumps({
'success': False,
'message': "No Such questionnaire"
}))
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)
organization = get_organization(request)
local_time_delta = get_country_time_delta(organization.country)
survey_response_ids = get_survey_response_ids_from_request(
dbm, request, questionnaire, local_time_delta)
received_times = []
for survey_response_id in survey_response_ids:
survey_response = SurveyResponse.get(dbm, survey_response_id)
received_times.append(
datetime.datetime.strftime(
convert_utc_to_localized(local_time_delta,
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, questionnaire.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 submissions have been deleted"),
'success':
True
})
else:
response = encode_json({
'error_message': ugettext("No records deleted"),
'success': False
})
return HttpResponse(response)
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, 'is_pro_sms': get_organization(request).is_pro_sms}), mimetype='application/json', content_type='application/json')
def my_poll_recipients_count(request, project_id):
dbm = get_database_manager(request.user)
questionnaire = Project.get(dbm, project_id)
datasender_ids = questionnaire.data_senders
contact_dict = {}
for datasender_id in datasender_ids:
contact = contact_by_short_code(dbm, datasender_id)
if contact.name != '':
contact_dict[contact.name] = contact.short_code
else:
contact_dict[contact.data.get('mobile_number')
['value']] = contact.short_code
return HttpResponse(content_type='application/json',
content=json.dumps(
{'my_poll_recipients': contact_dict}))
def get_poll_info(request, project_id):
manager = get_database_manager(request.user)
questionnaire = Project.get(manager, project_id)
project_links = get_project_link(questionnaire)
questionnaire_active, active_poll_id, active_poll_name = get_active_form_model_name_and_id(
manager)
from_date = questionnaire.modified.date()
to_date = questionnaire.end_date.date()
languages_list = get_available_project_languages(manager)
current_project_language = questionnaire.language
num_of_recipients = _get_number_of_recipients_(project_id)
return render_to_response(
'project/poll.html',
RequestContext(
request, {
'project':
questionnaire,
'message_text':
questionnaire.form_fields[0]['label'],
'project_links':
project_links,
'is_active':
questionnaire.active,
'from_date':
from_date,
'is_pro_sms':
get_organization(request).is_pro_sms,
'to_date':
to_date,
'questionnaire_id':
active_poll_id,
'questionnaire_name':
active_poll_name,
'languages_list':
json.dumps(languages_list),
'languages_link':
reverse('languages'),
'current_project_language':
current_project_language,
'post_url':
reverse("project-language", args=[questionnaire.id]),
'get_poll_sent_messages':
reverse("get_poll_sent_messages", args=[questionnaire.id]),
'questionnaire_code':
questionnaire.form_code,
'num_of_recipients':
num_of_recipients,
}))
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("subject_questionnaire",
args=[project_id,
entity_type]),
web_view=True)
})
if questionnaire.is_poll:
project_link = reverse("submissions",
args=[project_id, questionnaire_code])
else:
project_link = reverse('project-overview', args=[project_id])
project_info = dict(
project_id=project_id,
name=project['value']['name'],
qid=questionnaire_code,
created=project['value']['created'],
is_advanced_questionnaire=bool(project['value'].get('xform')),
link=project_link,
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']),
is_poll=bool(questionnaire.is_poll))
return project_info
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(
RequestContext(
request, {
'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]),
'questionnaire_code': questionnaire.form_code
}))
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.id, {}],
endkey=[questionnaire.id], 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 edit_project(request, project_id):
manager = get_database_manager(request.user)
dashboard_page = settings.HOME_PAGE + "?deleted=true"
questionnaire = Project.get(manager, project_id)
if questionnaire.is_void():
return HttpResponseRedirect(dashboard_page)
if request.method == 'GET':
return render_to_response('project/create_project.html',
{'preview_links': get_preview_and_instruction_links(),
'questionnaire_code': questionnaire.form_code,
'is_pro_sms': get_organization(request).is_pro_sms,
'is_edit': 'true',
'post_url': reverse(edit_project, args=[project_id])},
context_instance=RequestContext(request))
if request.method == 'POST':
project_info = json.loads(request.POST['profile_form'])
detail = _get_changed_data(questionnaire , project_info)
if detail.get("Name"):
detail.pop("Name")
try:
old_fields = questionnaire.fields
old_form_code = questionnaire.form_code
old_field_codes = questionnaire.field_codes()
questionnaire = update_questionnaire(questionnaire, request.POST, manager)
changed_questions = get_changed_questions(old_fields, questionnaire.fields, subject=False)
detail.update(changed_questions)
questionnaire.save()
deleted_question_codes = _get_deleted_question_codes(old_codes=old_field_codes,
new_codes=questionnaire.field_codes())
update_associated_submissions.delay(manager.database_name,
questionnaire.id,
deleted_question_codes)
UserActivityLog().log(request, project=questionnaire.name, action=EDITED_QUESTIONNAIRE, detail=json.dumps(detail))
except (QuestionCodeAlreadyExistsException, QuestionAlreadyExistsException,
EntityQuestionAlreadyExistsException) as ex:
return HttpResponse(
json.dumps({'success': False, 'error_in_project_section': False, 'error_message': _(ex.message)}))
except DataObjectAlreadyExists:
return HttpResponse(json.dumps({'success': False, 'error_in_project_section': False, "code_has_error":True,
'error_message': ugettext('Questionnaire with same code already exists.')}))
if request.POST['has_callback'] == 'false':
messages.add_message(request,messages.INFO,"success")
return HttpResponse(json.dumps({'success': True, 'project_id': project_id, 'is_pro_sms': get_organization(request).is_pro_sms,}))
def calculate_usage(db_name, log_file_path):
dbm = get_db_manager(db_name)
rows = dbm.view.all_media_details(reduce=True)
total_size_in_mb = rows[0][u"value"] if rows else 0
if total_size_in_mb > 0:
organization = OrganizationSetting.objects.get(
document_store=db_name).organization
text = "%s(%s) \nTotal used: %.2f mb\n" % (
organization.name, organization.org_id, total_size_in_mb)
usage_per_questionnaire = dbm.view.all_media_details(reduce=True,
group=True)
for row in usage_per_questionnaire:
project = Project.get(dbm, row['key'])
text += "%s (%s): Used: %.2f mb\n" % (project.name, project.id,
row['value'])
with open(log_file_path, "a") as log_file:
log_file.write(text)
