def test_should_create_hidden_field_for_entity_id_question_code(self):
form_model = self._get_form_model()
questionnaire_form_class = WebQuestionnaireFormCreator(
None, form_model=form_model).create()
web_text_field = questionnaire_form_class().fields['form_code']
self.assertEqual(CharField, type(web_text_field))
self.assertEqual(self.form_code, web_text_field.initial)
def test_should_create_django_phone_number_field(self):
form_model = self._get_form_model()
form_model.add_field(self._get_telephone_number_field())
questionnaire_form_class = WebQuestionnaireFormCreator(
None, form_model=form_model).create()
django_phone_number_field = questionnaire_form_class().fields['m']
self.assertEqual(PhoneNumberField, type(django_phone_number_field))
def test_should_create_web_questionnaire_form_model_field(self):
form_model = self._get_form_model()
questionnaire_form_class = WebQuestionnaireFormCreator(
None, form_model=form_model).create()
web_questionnaire = questionnaire_form_class()
self.assertEqual(form_model, web_questionnaire.form_model)
def test_should_give_short_code_question_field_name_for_subject_registration_questionnaire(
self):
form_model = self._get_form_model(is_registration_form=True)
subject_code = "subject_code"
form_model.add_field(self._get_text_field(True, True, subject_code))
questionnaire_form_class = WebQuestionnaireFormCreator(
subject_question_creator=None, form_model=form_model).create()
self.assertEqual(subject_code,
questionnaire_form_class().short_code_question_code)
def test_should_create_django_integer_number_field(self):
form_model = self._get_form_model()
form_model.add_field(self._get_integer_field())
questionnaire_form_class = WebQuestionnaireFormCreator(
None, form_model=form_model).create()
django_integer_field = questionnaire_form_class().fields['ag']
self.assertEqual(django.forms.fields.FloatField,
type(django_integer_field))
self.assertEqual(django_integer_field.max_value, 100)
self.assertEqual(django_integer_field.min_value, 18)
def test_should_short_code_question_class_for_subject_registration_questionnaire(
self):
form_model = self._get_form_model(is_registration_form=True)
subject_code = "subject_code"
form_model.add_field(self._get_text_field(True, True, subject_code))
questionnaire_form_class = WebQuestionnaireFormCreator(
subject_question_creator=None, form_model=form_model).create()
self.assertEqual(
'subject_field',
questionnaire_form_class().fields[subject_code].widget.
attrs['class'])
def test_should_append_country_in_location_field(self):
form_model = self._get_form_model()
form_model.add_field(self._get_location_field())
questionnaire_form_class = WebQuestionnaireFormCreator(
subject_question_creator=None, form_model=form_model).create()
post_data = {
LOCATION_TYPE_FIELD_CODE: 'pune',
'form_code': 'something'
}
web_form = questionnaire_form_class(country="India", data=post_data)
web_form.is_valid()
self.assertEqual("pune,India",
web_form.cleaned_data[LOCATION_TYPE_FIELD_CODE])
def test_should_create_web_questionnaire_for_char_field_for_french_language(
self):
form_model = self._get_form_model()
is_required = True
form_model.activeLanguages = [FRENCH_LANGUAGE]
form_model.add_field(self._get_text_field(is_required, False))
questionnaire_form_class = WebQuestionnaireFormCreator(
None, form_model=form_model).create()
web_text_field = questionnaire_form_class().fields[
self.text_field_code]
self.assertEqual(CharField, type(web_text_field))
self.assertEqual(self.field_name, web_text_field.label)
self.assertEqual(web_text_field.max_length, 20)
self.assertEqual(web_text_field.min_length, 1)
def test_should_create_web_questionnaire_for_location_field(self):
form_model = self._get_form_model()
form_model.add_field(self._get_location_field())
questionnaire_form_class = WebQuestionnaireFormCreator(
None, form_model=form_model).create()
web_location_field = questionnaire_form_class(
).fields[LOCATION_TYPE_FIELD_CODE]
self.assertEqual(CharField, type(web_location_field))
self.assertTrue(
web_location_field.widget.attrs['watermark'] is not None)
self.assertEqual('padding-top: 7px;',
web_location_field.widget.attrs['style'])
self.assertEqual('location_field',
web_location_field.widget.attrs['class'])
def test_should_create_web_questionnaire_for_char_field(self):
form_model = self._get_form_model()
is_required = True
form_model.add_field(self._get_text_field(is_required, False))
questionnaire_form_class = WebQuestionnaireFormCreator(
None, form_model=form_model).create()
web_text_field = questionnaire_form_class().fields[
self.text_field_code]
self.assertEqual(CharField, type(web_text_field))
self.assertEqual(self.field_name, web_text_field.label)
self.assertEqual(self.instruction, web_text_field.help_text)
self.assertEqual(is_required, web_text_field.required)
self.assertTrue(web_text_field.widget.attrs['watermark'] is not None)
self.assertEqual('padding-top: 7px;',
web_text_field.widget.attrs['style'])
def test_should_create_regex_field_for_short_code_question_if_registration(
self):
form_model = self._get_form_model(True)
is_required = True
form_model.add_field(self._get_text_field(is_required, False))
with patch.object(WebQuestionnaireFormCreator,
'_get_short_code_question_code'
) as get_short_code_qestion_code:
get_short_code_qestion_code.return_value = {
u'short_code_question_code': self.text_field_code
}
questionnaire_form_class = WebQuestionnaireFormCreator(
None, form_model=form_model).create()
web_text_field = questionnaire_form_class().fields[
self.text_field_code]
self.assertEqual(RegexField, type(web_text_field))
def test_should_create_web_questionnaire_for_multiple_choice_select_field(
self):
form_model = self._get_form_model()
is_required = False
expected_choices, text_field = self._get_select_field(
is_required, False)
form_model.add_field(text_field)
questionnaire_form_class = WebQuestionnaireFormCreator(
None, form_model=form_model).create()
web_text_field = questionnaire_form_class().fields[
self.select_field_code]
self.assertEqual(MultipleChoiceField, type(web_text_field))
self.assertEqual(self.field_name, web_text_field.label)
self.assertEqual(is_required, web_text_field.required)
self.assertEqual(expected_choices, web_text_field.choices)
def test_should_create_web_questionnaire_for_single_choice_select_field(
self):
form_model = self._get_form_model()
is_required = False
expected_choices, text_field = self._get_select_field(
is_required, single_select_flag=True)
form_model.add_field(text_field)
expected_choices = [('', '--None--'), ("a", "Red"), ("b", "Green"),
("c", "Blue")]
questionnaire_form_class = WebQuestionnaireFormCreator(
None, form_model=form_model).create()
web_text_field = questionnaire_form_class().fields[
self.select_field_code]
self.assertEqual(ChoiceField, type(web_text_field))
self.assertEqual(self.field_name, web_text_field.label)
self.assertEqual(is_required, web_text_field.required)
self.assertEqual(expected_choices, web_text_field.choices)
def get_web_preview_context(manager, post, project_info):
form_model = get_questionnaire_form_model(manager, project_info, post)
project = Project(name=unicode(project_info['name']),
goals=unicode(project_info['goals']),
project_type='survey',
entity_type=unicode(project_info['entity_type']),
activity_report=unicode(project_info['activity_report']),
state=post['project_state'],
devices=[u'sms', u'web', u'smartPhone'],
language=unicode(project_info['language']))
QuestionnaireForm = WebQuestionnaireFormCreator(
SubjectQuestionFieldCreator(manager,
project), form_model=form_model).create()
questionnaire_form = QuestionnaireForm()
return {
'project': project_info,
'questionnaire_form': questionnaire_form,
'add_link': add_link_context(project),
}
def test_should_create_web_questionnaire(self):
form_model = self._get_form_model()
subject_code = "subject_code"
subject_question_code = 'subject_question_code'
field1 = self._get_text_field(True, True, subject_code)
form_model.add_field(field1)
field2 = self._get_text_field(False, False)
form_model.add_field(field2)
field3 = self._get_select_field(False, False, 'test 2')[1]
form_model.add_field(field3)
subject_question_creator_mock = Mock(spec=SubjectQuestionFieldCreator)
subject_question_creator_mock.create.return_value = ChoiceField()
subject_question_creator_mock.create_code_hidden_field.return_value = {
subject_question_code: CharField()
}
questionnaire_form_class = WebQuestionnaireFormCreator(
subject_question_creator=subject_question_creator_mock,
form_model=form_model).create()
web_form = questionnaire_form_class()
self.assertEqual(5, len(web_form.fields))
form_code_hidden_field = web_form.fields[self.form_code]
self.assertEqual(CharField, type(form_code_hidden_field))
subject_field = web_form.fields[subject_code]
self.assertEqual(ChoiceField, type(subject_field))
subject_field = web_form.fields[subject_question_code]
self.assertEqual(CharField, type(subject_field))
simple_text_field = web_form.fields[self.text_field_code]
self.assertEqual(CharField, type(simple_text_field))
multiple_choice_field = web_form.fields[self.select_field_code]
self.assertEqual(MultipleChoiceField, type(multiple_choice_field))
def edit_subject(request, entity_type, entity_id, project_id=None):
manager = get_database_manager(request.user)
form_model = get_form_model_by_entity_type(manager, [entity_type.lower()])
subject = get_by_short_code(manager, entity_id, [entity_type.lower()])
if project_id is not None:
back_link = '/project/registered_subjects/%s/' % project_id
else:
back_link = reverse(all_subjects)
for field in form_model.fields:
if field.name == LOCATION_TYPE_FIELD_NAME:
field.value = ','.join(subject.location_path)
elif field.name == GEO_CODE_FIELD_NAME:
field.value = ','.join(map(str, subject.geometry['coordinates']))
elif field.name == SHORT_CODE_FIELD:
field.value = subject.short_code
else:
field.value = subject.data[
field.name]['value'] if field.name in subject.data.keys(
) else None
field.value = field._to_str()
QuestionnaireForm = WebQuestionnaireFormCreator(
None, form_model=form_model).create()
web_questionnaire_template = get_template(request.user)
disable_link_class, hide_link_class = get_visibility_settings_for(
request.user)
if request.method == 'GET':
questionnaire_form = QuestionnaireForm()
form_context = _make_form_context(questionnaire_form, entity_type,
disable_link_class, hide_link_class,
True, back_link)
return render_to_response(web_questionnaire_template,
form_context,
context_instance=RequestContext(request))
if request.method == 'POST':
post_data = QueryDict(request.raw_post_data, mutable=True)
post_data[
QuestionnaireForm.short_code_question_code] = subject.short_code
questionnaire_form = QuestionnaireForm(
country=get_organization_country(request), data=post_data)
if not questionnaire_form.is_valid():
form_context = _make_form_context(questionnaire_form, entity_type,
disable_link_class,
hide_link_class, True, back_link)
return render_to_response(web_questionnaire_template,
form_context,
context_instance=RequestContext(request))
success_message = None
error_message = None
try:
from datawinners.project.helper import create_request
response = WebPlayer(
manager,
LocationBridge(
location_tree=get_location_tree(),
get_loc_hierarchy=get_location_hierarchy)).accept(
create_request(questionnaire_form,
request.user.username,
is_update=True))
if response.success:
success_message = _("Your changes have been saved.")
questionnaire_form = QuestionnaireForm(
country=get_organization_country(request), data=post_data)
else:
from datawinners.project.helper import errors_to_list
questionnaire_form._errors = errors_to_list(
response.errors, form_model.fields)
form_context = _make_form_context(questionnaire_form,
entity_type,
disable_link_class,
hide_link_class, True,
back_link)
return render_to_response(
web_questionnaire_template,
form_context,
context_instance=RequestContext(request))
except DataObjectNotFound:
message = exception_messages.get(DataObjectNotFound).get(WEB)
error_message = _(message) % (form_model.entity_type[0],
form_model.entity_type[0])
except Exception as exception:
error_message = _(
get_exception_message_for(exception=exception,
channel=Channel.WEB))
subject_context = _make_form_context(questionnaire_form, entity_type,
disable_link_class,
hide_link_class, True, back_link)
subject_context.update({
'success_message': success_message,
'error_message': error_message
})
return render_to_response(web_questionnaire_template,
subject_context,
context_instance=RequestContext(request))
def create_subject(request, entity_type=None):
manager = get_database_manager(request.user)
form_model = get_form_model_by_entity_type(manager, [entity_type.lower()])
QuestionnaireForm = WebQuestionnaireFormCreator(
None, form_model=form_model).create()
web_questionnaire_template = get_template(request.user)
disable_link_class, hide_link_class = get_visibility_settings_for(
request.user)
if request.method == 'GET':
questionnaire_form = QuestionnaireForm()
form_context = _make_form_context(questionnaire_form, entity_type,
disable_link_class, hide_link_class)
return render_to_response(web_questionnaire_template,
form_context,
context_instance=RequestContext(request))
if request.method == 'POST':
questionnaire_form = QuestionnaireForm(
country=get_organization_country(request), data=request.POST)
if not questionnaire_form.is_valid():
form_context = _make_form_context(questionnaire_form, entity_type,
disable_link_class,
hide_link_class)
return render_to_response(web_questionnaire_template,
form_context,
context_instance=RequestContext(request))
success_message = None
error_message = None
try:
from datawinners.project.helper import create_request
response = WebPlayer(
manager,
LocationBridge(
location_tree=get_location_tree(),
get_loc_hierarchy=get_location_hierarchy)).accept(
create_request(questionnaire_form,
request.user.username),
logger=websubmission_logger)
if response.success:
ReportRouter().route(
get_organization(request).org_id, response)
success_message = (_(
"Successfully submitted. Unique identification number(ID) is:"
) + " %s") % (response.short_code, )
detail_dict = dict({
"Subject Type": entity_type.capitalize(),
"Unique ID": response.short_code
})
UserActivityLog().log(request,
action=REGISTERED_SUBJECT,
detail=json.dumps(detail_dict))
questionnaire_form = QuestionnaireForm()
else:
from datawinners.project.helper import errors_to_list
questionnaire_form._errors = errors_to_list(
response.errors, form_model.fields)
form_context = _make_form_context(questionnaire_form,
entity_type,
disable_link_class,
hide_link_class)
return render_to_response(
web_questionnaire_template,
form_context,
context_instance=RequestContext(request))
except DataObjectNotFound:
message = exception_messages.get(DataObjectNotFound).get(WEB)
error_message = _(message) % (form_model.entity_type[0],
form_model.entity_type[0])
except DataObjectAlreadyExists as exception:
error_message = _(
"Entity with Unique Identification Number (ID) = %s already exists."
) % exception.data[1]
except Exception as exception:
error_message = _(
get_exception_message_for(exception=exception,
channel=Channel.WEB))
subject_context = _make_form_context(questionnaire_form, entity_type,
disable_link_class,
hide_link_class)
subject_context.update({
'success_message': success_message,
'error_message': error_message
})
return render_to_response(web_questionnaire_template,
subject_context,
context_instance=RequestContext(request))
