def test_should_generate_unique_questionnaire_code(self):
patcher = patch("datawinners.project.helper.models")
models_mock = patcher.start()
patcher1 = patch("datawinners.project.helper.get_form_model_by_code")
form_code_mock = patcher1.start()
dbm = Mock(spec=DatabaseManager)
form_code_mock.side_effect = FormModelDoesNotExistsException('')
models_mock.count_projects.return_value = 0
self.assertEqual(helper.generate_questionnaire_code(dbm), "001")
models_mock.count_projects.return_value = 1
self.assertEqual(helper.generate_questionnaire_code(dbm), "002")
patcher.stop()
patcher1.stop()
def test_should_generate_next_questionnaire_code_if_code_already_exists(self):
patcher = patch("datawinners.project.helper.models")
models_mock = patcher.start()
patcher1 = patch("datawinners.project.helper.get_form_model_by_code")
form_code_mock = patcher1.start()
dbm = Mock(spec=DatabaseManager)
myproject = Mock(spec=Project)
models_mock.get_all_projects.return_value = [myproject]
def expected_side_effect(*args, **kwargs):
code = kwargs.get('code') or args[1]
if code == "003":
raise FormModelDoesNotExistsException('')
if code == "002":
return Mock(spec=FormModel)
form_code_mock.side_effect = expected_side_effect
self.assertEqual(helper.generate_questionnaire_code(dbm), "003")
patcher.stop()
patcher1.stop()
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 test_should_generate_unique_questionnaire_code(self):
patcher = patch("datawinners.project.helper.models")
models_mock = patcher.start()
patcher1 = patch("datawinners.project.helper.get_form_model_by_code")
form_code_mock = patcher1.start()
dbm = Mock(spec=DatabaseManager)
form_code_mock.side_effect = FormModelDoesNotExistsException('')
models_mock.get_all_projects.return_value = []
self.assertEqual(helper.generate_questionnaire_code(dbm), "001")
myproject = Mock(spec=Project)
models_mock.get_all_projects.return_value = [myproject]
self.assertEqual(helper.generate_questionnaire_code(dbm), "002")
patcher.stop()
patcher1.stop()
def create_project(request):
manager = get_database_manager(request.user)
org = get_organization(request)
is_active, project_active_id, project_active_name = get_active_form_model_name_and_id(
manager)
has_permission_on_active_project = True
ngo_admin_email = get_ngo_admin_user_profiles_for(org)[0].user.email
if is_active:
user_permission = get_user_permission(user_id=request.user.id,
dbm=manager)
if user_permission is not None and project_active_id not in user_permission.project_ids:
has_permission_on_active_project = False
if request.method == 'GET':
cancel_link = reverse('dashboard') if request.GET.get(
'prev', None) == 'dash' else reverse('alldata_index')
return render_to_response('project/create_project.html', {
'preview_links':
get_preview_and_instruction_links(),
'questionnaire_code':
helper.generate_questionnaire_code(manager),
'is_edit':
'false',
'is_pro_sms':
org.is_pro_sms,
'active_language':
request.LANGUAGE_CODE,
'post_url':
reverse(create_project),
'unique_id_types':
json.dumps([
unique_id_type.capitalize()
for unique_id_type in get_unique_id_types(manager)
]),
'has_permission_on_active_project':
has_permission_on_active_project,
'ngo_admin_email':
ngo_admin_email,
'cancel_link':
cancel_link,
'is_active':
is_active,
'project_active_id':
project_active_id,
'project_active_name':
project_active_name
},
context_instance=RequestContext(request))
if request.method == 'POST':
response_dict = _create_project_post_response(request, manager)
return HttpResponse(json.dumps(response_dict))
def __init__(self, request, questionnaire_code=None, project_name=None, xls_form=None, xls_parser_response=None):
self.request = request
self.user = request.user
user_profile = NGOUserProfile.objects.get(user=self.user)
self.reporter_id = user_profile.reporter_id
self.manager = get_database_manager(self.user)
self.entity_type = ['reporter']
self.questionnaire_code = questionnaire_code if questionnaire_code else generate_questionnaire_code(
self.manager)
self.name = 'Xlsform-Project-' + self.questionnaire_code if not project_name else project_name
self.language = 'en'
self.xform = xls_parser_response.xform_as_string
self.xform_with_form_code = self.add_form_code(self.questionnaire_code)
self.json_xform_data = xls_parser_response.json_xform_data
self.xls_form = xls_form
def test_should_verify_xform_is_stored_when_project_created(self):
manager = get_database_manager(self.user)
questionnaire_code = generate_questionnaire_code(manager)
project_name = 'xform-' + questionnaire_code
xls_parser_response = XlsFormParser(self.REPEAT, u"My questionnairé").parse()
mangrove_service = MangroveService(self.mock_request, project_name=project_name, xls_parser_response=xls_parser_response)
mangrove_service.create_project()
questionnaire_code = mangrove_service.questionnaire_code
mgr = mangrove_service.manager
from_model = get_form_model_by_code(mgr, questionnaire_code)
self.assertIsNotNone(from_model.xform)
def create_project(request):
manager = get_database_manager(request.user)
if request.method == 'GET':
cancel_link = reverse('dashboard') if request.GET.get('prev', None) == 'dash' else reverse('alldata_index')
return render_to_response('project/create_project.html',
{'preview_links': get_preview_and_instruction_links(),
'questionnaire_code': helper.generate_questionnaire_code(manager),
'is_edit': 'false',
'active_language': request.LANGUAGE_CODE,
'post_url': reverse(create_project),
'unique_id_types': json.dumps([unique_id_type.capitalize() for unique_id_type in
get_unique_id_types(manager)]),
'cancel_link': cancel_link}, context_instance=RequestContext(request))
if request.method == 'POST':
response_dict = _create_project_post_response(request, manager)
return HttpResponse(json.dumps(response_dict))
def post(self, request):
file_content = None
tmp_file = None
try:
file_content = request.raw_post_data
file_errors, file_extension = _perform_file_validations(request)
tmp_file = NamedTemporaryFile(delete=True, suffix=file_extension)
if file_errors:
logger.info(
"User: %s. Upload File validation failed: %s. File name: %s, size: %d",
request.user.username, json.dumps(file_errors),
request.GET.get("qqfile"),
int(request.META.get('CONTENT_LENGTH')))
return HttpResponse(json.dumps({
'success': False,
'error_msg': file_errors
}),
content_type='application/json')
tmp_file.write(file_content)
tmp_file.seek(0)
project_name = request.GET['pname'].strip()
manager = get_database_manager(request.user)
questionnaire_code = generate_questionnaire_code(manager)
xls_parser_response = XlsFormParser(tmp_file, project_name,
manager).parse()
send_email_if_unique_id_type_question_has_no_registered_unique_ids(
xls_parser_response, request, project_name)
profile = request.user.get_profile()
organization = Organization.objects.get(org_id=profile.org_id)
if xls_parser_response.is_multiple_languages:
logger.info(
"Creating Questionnaire %s with Multi Language support for organization : %s(%s) and email: %s",
project_name, organization.name, profile.org_id,
profile.user.email)
if xls_parser_response.errors:
error_list = list(xls_parser_response.errors)
logger.info("User: %s. Upload Errors: %s",
request.user.username, json.dumps(error_list))
return HttpResponse(
content_type='application/json',
content=json.dumps({
'success':
False,
'error_msg':
error_list,
'message_prefix':
_("Sorry! Current version of DataWinners does not support"
),
'message_suffix':
_("Update your XLSForm and upload again.")
}))
tmp_file.seek(0)
mangrove_service = MangroveService(
request,
questionnaire_code=questionnaire_code,
project_name=project_name,
xls_form=tmp_file,
xls_parser_response=xls_parser_response)
questionnaire_id, form_code = mangrove_service.create_project()
except PyXFormError as e:
logger.info("User: %s. Upload Error: %s", request.user.username,
e.message)
message = transform_error_message(e.message)
if 'name_type_error' in message or 'choice_name_type_error' in message:
if 'choice_name_type_error' in message:
message_prefix = _(
"On your \"choices\" sheet the first and second column must be \"list_name\" and \"name\". Possible errors:"
)
else:
message_prefix = _(
"On your \"survey\" sheet the first and second column must be \"type\" and \"name\". Possible errors:"
)
return HttpResponse(
content_type='application/json',
content=json.dumps({
'success':
False,
'error_msg': [
_("Columns are missing"),
_("Column name is misspelled"),
_("Additional space in column name")
],
'message_prefix':
message_prefix,
'message_suffix':
_("Update your XLSForm and upload again.")
}))
else:
return HttpResponse(
content_type='application/json',
content=json.dumps({
'success':
False,
'error_msg': [
message if message else ugettext(
"all XLSForm features. Please check the list of unsupported features."
)
]
}))
except QuestionAlreadyExistsException as e:
logger.info("User: %s. Upload Error: %s", request.user.username,
e.message)
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.")
}))
except UnicodeDecodeError as e:
logger.info("User: %s. Upload Error: %s", request.user.username,
e.message)
return HttpResponse(
content_type='application/json',
content=json.dumps({
'success':
False,
'error_msg': [
_("Check your columns for errors.<br>There are missing symbols (like $ for relevant or calculate) or incorrect characters<br>"
) + _("Update your XLSForm and upload again.")
],
}))
except Exception as e:
message = e.message if e.message else _("Errors in excel")
logger.info("User: %s. Upload Exception message: %s",
request.user.username, e.message)
odk_message = ''
if not 'ODK Validate Errors:' in e.message:
send_email_on_exception(
request.user,
"Questionnaire Create",
traceback.format_exc(),
additional_details={'file_contents': file_content})
else:
odk_message = translate_odk_message(e.message)
message = odk_message if odk_message else message
return HttpResponse(content_type='application/json',
content=json.dumps({
'success': False,
'error_msg': [message],
}))
finally:
if tmp_file:
tmp_file.close()
if not questionnaire_id:
org = get_organization(request)
if org.is_pro_sms:
message = _(
"Questionnaire or Poll with same name already exists.Upload was cancelled."
)
else:
message = _(
"Questionnaire with same name already exists.Upload was cancelled."
)
return HttpResponse(json.dumps({
'success': False,
'duplicate_project_name': True,
'error_msg': [message]
}),
content_type='application/json')
return HttpResponse(json.dumps({
"success": True,
"project_name": project_name,
"project_id": questionnaire_id,
"form_code": form_code
}),
content_type='application/json')
def create_project(request):
manager = get_database_manager(request.user)
entity_list = get_all_entity_types(manager)
entity_list = helper.remove_reporter(entity_list)
all_projects_name = get_all_project_names(get_database_manager(request.user))
name = generate_project_name(all_projects_name)
project_summary = dict(name=name)
ngo_admin = NGOUserProfile.objects.get(user=request.user)
if request.method == 'GET':
form = CreateProject(entity_list=entity_list, initial={'name': name})
activity_report_questions = json.dumps(helper.get_activity_report_questions(manager), default=field_to_json)
subject_report_questions = json.dumps(helper.get_subject_report_questions(manager), default=field_to_json)
return render_to_response('project/create_project.html',
{'form': form, "activity_report_questions": repr(activity_report_questions),
'subject_report_questions': repr(subject_report_questions),
'preview_links': get_preview_and_instruction_links(),
'existing_questions': repr(activity_report_questions), 'project': project_summary,
'questionnaire_code': helper.generate_questionnaire_code(manager),
'is_edit': 'false',
'post_url': reverse(create_project)}, context_instance=RequestContext(request))
if request.method == 'POST':
project_info = json.loads(request.POST['profile_form'])
form = CreateProject(entity_list, data=project_info)
if form.is_valid():
project = Project(name=form.cleaned_data['name'], goals=form.cleaned_data['goals'],
project_type='survey', entity_type=form.cleaned_data['entity_type'],
activity_report=form.cleaned_data['activity_report'],
state=request.POST['project_state'], devices=[u'sms', u'web', u'smartPhone'],
language=form.cleaned_data['language'])
if ngo_admin.reporter_id is not None:
project.data_senders.append(ngo_admin.reporter_id)
try:
questionnaire = create_questionnaire(post=request.POST, manager=manager,
entity_type=form.cleaned_data['entity_type'],
name=form.cleaned_data['name'],
language=form.cleaned_data['language'])
except (QuestionCodeAlreadyExistsException, QuestionAlreadyExistsException,
EntityQuestionAlreadyExistsException) as ex:
return HttpResponse(
json.dumps({'success': False, 'error_message': _(ex.message), 'error_in_project_section': False}))
try:
project.qid = questionnaire.save()
except DataObjectAlreadyExists:
return HttpResponse(json.dumps(
{'success': False, 'error_message': "Questionnaire with this code already exists",
'error_in_project_section': False}))
try:
project.save(manager)
UserActivityLog().log(request, action=CREATED_PROJECT, project=project.name, detail=project.name)
except DataObjectAlreadyExists as ex:
questionnaire.delete()
message = _("%s with %s = %s already exists.") % (_(ex.data[2]), _(ex.data[0]), "'%s'" % project.name)
return HttpResponse(
json.dumps({'success': False, 'error_message': message, 'error_in_project_section': True}))
return HttpResponse(json.dumps({'success': True, 'project_id': project.id}))
def create_project(request):
manager = get_database_manager(request.user)
ngo_admin = NGOUserProfile.objects.get(user=request.user)
active_language = request.LANGUAGE_CODE
if request.method == 'GET':
cancel_link = reverse('dashboard') if request.GET.get(
'prev', None) == 'dash' else reverse('index')
return render_to_response('project/create_project.html', {
'preview_links':
get_preview_and_instruction_links(),
'questionnaire_code':
helper.generate_questionnaire_code(manager),
'is_edit':
'false',
'active_language':
active_language,
'post_url':
reverse(create_project),
'unique_id_types':
json.dumps([
unique_id_type.capitalize()
for unique_id_type in get_unique_id_types(manager)
]),
'cancel_link':
cancel_link
},
context_instance=RequestContext(request))
if request.method == 'POST':
project_info = json.loads(request.POST['profile_form'])
try:
questionnaire = create_questionnaire(
post=request.POST,
manager=manager,
name=project_info.get('name'),
language=project_info.get('language', active_language),
reporter_id=ngo_admin.reporter_id)
except (QuestionCodeAlreadyExistsException,
QuestionAlreadyExistsException,
EntityQuestionAlreadyExistsException) as ex:
return HttpResponse(
json.dumps({
'success': False,
'error_message': _(ex.message),
'error_in_project_section': False
}))
code_has_errors, name_has_errors = False, False
error_message = {}
if not questionnaire.is_form_code_unique():
code_has_errors = True
error_message["code"] = _(
"Questionnaire with same code already exists.")
if not questionnaire.is_project_name_unique():
name_has_errors = True
error_message["name"] = _(
"Questionnaire with same name already exists.")
if not code_has_errors and not name_has_errors:
_associate_account_users_to_project(manager, questionnaire)
questionnaire.update_doc_and_save()
UserActivityLog().log(request,
action=CREATED_PROJECT,
project=questionnaire.name,
detail=questionnaire.name)
return HttpResponse(
json.dumps({
'success': True,
'project_id': questionnaire.id
}))
return HttpResponse(
json.dumps({
'success': False,
'error_message': error_message,
'error_in_project_section': False,
'code_has_errors': code_has_errors,
'name_has_errors': name_has_errors
}))
