def build(cls,
manager,
extension,
default_parser=None,
form_code=None,
is_datasender=False):
channels = dict({
".xls": Channel.XLS,
".xlsx": Channel.XLSX,
".csv": Channel.CSV
})
try:
channel = channels[extension]
except KeyError:
raise InvalidFileFormatException()
if default_parser is not None:
parser = default_parser()
elif extension == '.csv':
parser = CsvParser()
elif extension == '.xls':
parser = XlsParser()
elif extension == '.xlsx':
parser = XlsxParser()
else:
raise InvalidFileFormatException()
location_bridge = LocationBridge(
get_location_tree(), get_loc_hierarchy=get_location_hierarchy)
player = FilePlayer(manager,
parser,
channel,
location_tree=location_bridge,
is_datasender=is_datasender)
player.form_code = form_code
return player
def player_response(self, created_request):
location_bridge = LocationBridge(
location_tree=get_location_tree(),
get_loc_hierarchy=get_location_hierarchy)
return WebPlayer(self.manager,
location_bridge).accept(created_request,
logger=websubmission_logger)
def process_create_data_sender_form(dbm, form, org_id):
message = None
data_sender_id = None
if form.is_valid():
try:
organization = Organization.objects.get(org_id=org_id)
if organization.in_trial_mode:
add_data_sender_to_trial_organization(form.cleaned_data["telephone_number"], org_id)
web_player = WebPlayer(dbm, LocationBridge(location_tree=get_location_tree(), get_loc_hierarchy=get_location_hierarchy))
reporter_id = form.cleaned_data["short_code"] if form.cleaned_data != "" else None
request = Request(message=_get_data(form.cleaned_data, organization.country_name(), reporter_id),
transportInfo=TransportInfo(transport='web', source='web', destination='mangrove'))
response = web_player.accept(request, logger=websubmission_logger)
if response.success:
data_sender_id = response.short_code
message = get_success_msg_for_registration_using(response, "web")
else:
form.update_errors(response.errors)
except MangroveException as exception:
message = exception.message
return data_sender_id,message
def _edit_contact(self, form, manager, organization, reporter_id):
web_player = WebPlayer(manager,
LocationBridge(location_tree=get_location_tree(),
get_loc_hierarchy=get_location_hierarchy))
response = web_player.accept(
Request(message=_get_data(form.cleaned_data, organization.country_name(), reporter_id),
transportInfo=TransportInfo(transport='web', source='web', destination='mangrove'),
is_update=True))
return response
def _create_identification_number(self,form_code, values, extra_data):
if extra_data:
return Response(success=False, errors=_create_error("Wrong number of answers"))
service = IdentificationNumberService(self.dbm)
location_tree = LocationBridge(get_location_tree(), get_location_hierarchy)
response = service.save_identification_number(form_code, values, location_tree)
return response
def test_should_not_import_datasender_when_email_is_not_unique_or_mobile_is_not_unique(
self):
organization = Mock(spec=Organization)
with patch("datawinners.utils.get_organization_from_manager"
) as get_organization_from_dbm_mock:
get_organization_from_dbm_mock.return_value = Mock(
return_value=organization)
with patch.object(XlsDatasenderParser, "parse") as parse_mock:
parse_mock.return_value = [("reg", {
u"email": u'',
u'g': u'-18.13,27.65',
u'l': u'Nairobi',
u'm': u'1234567890',
u'n': u'Thierry Rakoto',
u't': 'reporter'
}),
("reg", {
u"email": u'*****@*****.**',
u'g': u'-18.13,27.65',
u'l': u'Nairobi',
u'm': u'033333333',
u'n': u'Thierry Rakoto',
u't': 'reporter'
}),
("reg", {
u"email": u'a.com',
u'g': u'-18.13,27.65',
u'l': u'Nairobi',
u'm': u'033333333',
u'n': u'Thierry Rakoto',
u't': 'reporter'
})]
with patch.object(UserManager, "values_list") as get_ds_mobile:
get_ds_mobile.return_value = ["*****@*****.**"]
file_player = FilePlayer(
self.manager, XlsDatasenderParser(), Channel.XLS,
LocationBridge(DummyLocationTree(),
dummy_get_location_hierarchy))
responses = file_player.accept(None)
self.assertFalse(responses[0].success)
self.assertEqual(
responses[0].errors['error'],
"Data Sender with Mobile Number = 1234567890 already exists.")
self.assertFalse(responses[1].success)
self.assertEqual(
responses[1].errors['error'],
"User with email address = [email protected] already exists.")
self.assertFalse(responses[2].success)
self.assertEqual(responses[2].errors['error'],
"Invalid email address.")
def process_create_data_sender_form(dbm, form, org_id):
message = None
data_sender_id = None
if form.is_valid():
try:
organization = Organization.objects.get(org_id=org_id)
if organization.in_trial_mode:
_add_data_sender_to_trial_organization(
form.cleaned_data["telephone_number"], org_id)
web_player = WebPlayer(
dbm,
LocationBridge(location_tree=get_location_tree(),
get_loc_hierarchy=get_location_hierarchy))
reporter_id = form.cleaned_data["short_code"].lower(
) if form.cleaned_data != "" else None
request = Request(message=_get_data(form.cleaned_data,
organization.country_name(),
reporter_id),
transportInfo=TransportInfo(
transport='web',
source='web',
destination='mangrove'))
response = web_player.accept(request, logger=websubmission_logger)
if response.success:
data_sender_id = response.short_code
message = get_success_msg_for_ds_registration_using(
response, "web")
else:
form.update_errors(response.errors)
except IntegrityError as e:
form.update_errors({
MOBILE_NUMBER_FIELD_CODE:
_(u'Sorry, the telephone number %s has already been registered.'
) % form.cleaned_data["telephone_number"]
})
except DataObjectAlreadyExists as e:
message = _("%s with %s = %s already exists.") % (
e.data[2],
e.data[0],
e.data[1],
)
except MangroveException as exception:
message = exception.message
return data_sender_id, message
def submit_to_player(incoming_request):
try:
dbm = incoming_request['dbm']
post_sms_parser_processors = [PostSMSProcessorLanguageActivator(dbm, incoming_request),
PostSMSProcessorNumberOfAnswersValidators(dbm, incoming_request)]
sms_player = SMSPlayer(dbm, LocationBridge(get_location_tree(),get_loc_hierarchy=get_location_hierarchy),
post_sms_parser_processors=post_sms_parser_processors)
mangrove_request = Request(message=incoming_request['incoming_message'],
transportInfo=incoming_request['transport_info'])
response = sms_player.accept(mangrove_request, logger=incoming_request.get("logger"))
message = SMSResponse(response).text(dbm)
send_message(incoming_request, response)
except DataObjectAlreadyExists as e:
message = ugettext("%s with %s = %s already exists.") % (ugettext(e.data[2]), ugettext(e.data[0]), e.data[1])
except Exception as exception:
message = handle(exception, incoming_request)
incoming_request['outgoing_message'] = message
return incoming_request
def submit(request):
dbm = get_database_manager(request.user)
post = json.loads(request.POST['data'])
success = True
try:
web_player = WebPlayer(
dbm,
LocationBridge(location_tree=get_location_tree(),
get_loc_hierarchy=get_location_hierarchy))
message = post['message']
message[LOCATION_TYPE_FIELD_CODE] = get_country_appended_location(
message.get(LOCATION_TYPE_FIELD_CODE),
get_organization_country(request))
request = Request(message=message,
transportInfo=TransportInfo(
transport=post.get('transport'),
source=post.get('source'),
destination=post.get('destination')))
response = web_player.accept(request)
if response.success:
message = get_success_msg_for_registration_using(response, "web")
else:
message = get_submission_error_message_for(response.errors)
entity_id = response.datarecord_id
except DataObjectAlreadyExists as exception:
message = _(
"Entity with Unique Identification Number (ID) = %s already exists."
) % exception.data[1]
success, entity_id = False, None
except MangroveException as exception:
message = get_exception_message_for(exception=exception, channel="web")
message = _("Please add subject type and then add a subject"
) if message == "t should be present" else message
success = False
entity_id = None
return HttpResponse(
json.dumps({
'success': success,
'message': message,
'entity_id': entity_id
}))
def post(self, request, reporter_id, *args, **kwargs):
reporter_id = reporter_id.lower()
manager = get_database_manager(request.user)
reporter_entity = ReporterEntity(
get_by_short_code(manager, reporter_id, [REPORTER]))
entity_links = {
'registered_datasenders_link': reverse("all_datasenders")
}
datasender = {'short_code': reporter_id}
get_datasender_user_detail(datasender, request.user)
email = datasender.get(
'email') if datasender.get('email') != '--' else False
org_id = request.user.get_profile().org_id
form = ReporterRegistrationForm(org_id=org_id, data=request.POST)
message = None
if form.is_valid():
try:
org_id = request.user.get_profile().org_id
current_telephone_number = reporter_entity.mobile_number
current_name = reporter_entity.name
organization = Organization.objects.get(org_id=org_id)
web_player = WebPlayer(
manager,
LocationBridge(location_tree=get_location_tree(),
get_loc_hierarchy=get_location_hierarchy))
response = web_player.accept(
Request(message=_get_data(form.cleaned_data,
organization.country_name(),
reporter_id),
transportInfo=TransportInfo(
transport='web',
source='web',
destination='mangrove'),
is_update=True))
if response.success:
if organization.in_trial_mode:
update_data_sender_from_trial_organization(
current_telephone_number,
form.cleaned_data["telephone_number"], org_id)
if email and current_name != form.cleaned_data["name"]:
update_user_name_if_exists(email,
form.cleaned_data["name"])
message = _("Your changes have been saved.")
detail_dict = {"Unique ID": reporter_id}
current_lang = get_language()
activate("en")
field_mapping = dict(mobile_number="telephone_number")
for field in [
"geo_code", "location", "mobile_number", "name"
]:
if getattr(reporter_entity,
field) != form.cleaned_data.get(
field_mapping.get(field, field)):
label = u"%s" % form.fields[field_mapping.get(
field, field)].label
detail_dict.update({
label:
form.cleaned_data.get(
field_mapping.get(field, field))
})
activate(current_lang)
if len(detail_dict) > 1:
detail_as_string = json.dumps(detail_dict)
UserActivityLog().log(request,
action=EDITED_DATA_SENDER,
detail=detail_as_string)
else:
form.update_errors(response.errors)
except MangroveException as exception:
message = exception.message
return render_to_response('edit_datasender_form.html', {
'form': form,
'message': message,
'reporter_id': reporter_id,
'email': email,
'project_links': entity_links
},
context_instance=RequestContext(request))
def edit_data_sender(request, project_id, reporter_id):
manager = get_database_manager(request.user)
reporter_entity = ReporterEntity(
get_by_short_code(manager, reporter_id, [REPORTER]))
project, links = _get_project_and_project_link(manager, project_id,
reporter_id)
user_profile = get_user_profile_by_reporter_id(reporter_id, request.user)
email = user_profile.user.email if user_profile else None
if request.method == 'GET':
location = reporter_entity.location
geo_code = reporter_entity.geo_code
form = ReporterRegistrationForm(
initial={
'project_id': project_id,
'name': reporter_entity.name,
'telephone_number': reporter_entity.mobile_number,
'location': location,
'geo_code': geo_code
})
return render_to_response('project/edit_datasender.html', {
'project': project,
'reporter_id': reporter_id,
'form': form,
'project_links': links,
'in_trial_mode': _in_trial_mode(request),
'email': email
},
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)
message = None
if form.is_valid():
try:
organization = Organization.objects.get(org_id=org_id)
current_telephone_number = reporter_entity.mobile_number
web_player = WebPlayer(
manager,
LocationBridge(location_tree=get_location_tree(),
get_loc_hierarchy=get_location_hierarchy))
response = web_player.accept(
Request(message=_get_data(form.cleaned_data,
organization.country_name(),
reporter_id),
transportInfo=TransportInfo(
transport='web',
source='web',
destination='mangrove'),
is_update=True))
if response.success:
if organization.in_trial_mode:
update_data_sender_from_trial_organization(
current_telephone_number,
form.cleaned_data["telephone_number"], org_id)
message = _("Your changes have been saved.")
detail_dict = {"Unique ID": reporter_id}
current_lang = get_language()
activate("en")
field_mapping = dict(mobile_number="telephone_number")
for field in [
"geo_code", "location", "mobile_number", "name"
]:
if getattr(reporter_entity,
field) != form.cleaned_data.get(
field_mapping.get(field, field)):
label = u"%s" % form.fields[field_mapping.get(
field, field)].label
detail_dict.update({
label:
form.cleaned_data.get(
field_mapping.get(field, field))
})
activate(current_lang)
if len(detail_dict) > 1:
detail_as_string = json.dumps(detail_dict)
UserActivityLog().log(request,
action=EDITED_DATA_SENDER,
detail=detail_as_string,
project=project.name)
else:
form.update_errors(response.errors)
except MangroveException as exception:
message = exception.message
return render_to_response('edit_datasender_form.html', {
'project': project,
'form': form,
'reporter_id': reporter_id,
'message': message,
'project_links': links,
'in_trial_mode': _in_trial_mode(request),
'email': email
},
context_instance=RequestContext(request))
def setUp(self):
MangroveTestCase.setUp(self)
self._create_entities()
self.player = SMSPlayer(self.manager, location_tree=LocationBridge(get_location_tree(), get_loc_hierarchy=get_location_hierarchy))
self.transport = TransportInfo(transport="sms", source="1234", destination="5678")
initializer.run(self.manager)
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()])
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 = SubjectRegistrationForm(form_model)
form_context = _make_form_context(
questionnaire_form,
entity_type,
disable_link_class,
hide_link_class,
form_model.form_code,
get_organization_telephone_number(request),
form_model.fields,
web_view=request.GET.get("web_view", False))
form_context.update(
{'is_pro_sms': get_organization(request).is_pro_sms})
return render_to_response(web_questionnaire_template,
form_context,
context_instance=RequestContext(request))
if request.method == 'POST':
questionnaire_form = SubjectRegistrationForm(
form_model,
data=request.POST,
country=get_organization_country(request))
if not questionnaire_form.is_valid():
form_context = _make_form_context(
questionnaire_form,
entity_type,
disable_link_class,
hide_link_class,
form_model.form_code,
get_organization_telephone_number(request),
form_model.fields,
web_view=True)
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 = _(
"%s with Identification Number %s successfully registered."
) % (entity_type.capitalize(), response.short_code)
detail_dict = dict({
"Subject Type": entity_type.capitalize(),
"Unique ID": response.short_code
})
UserActivityLog().log(request,
action=REGISTERED_IDENTIFICATION_NUMBER,
detail=json.dumps(detail_dict))
questionnaire_form = SubjectRegistrationForm(form_model)
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,
form_model.form_code,
get_organization_telephone_number(request),
form_model.fields,
web_view=True)
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 = _(
"%s with ID Number '%s' already exists or has previously collected data."
) % (exception.data[2], 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,
form_model.form_code,
get_organization_telephone_number(request),
form_model.fields,
web_view=True)
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 submit_to_player(incoming_request):
sent_via_sms_test_questionnaire = incoming_request.get(
'test_sms_questionnaire', False)
organization = incoming_request.get('organization')
organization = organization
try:
dbm = incoming_request['dbm']
mangrove_request = Request(
message=incoming_request['incoming_message'],
transportInfo=incoming_request['transport_info'])
response = _is_datasender_registered(dbm, incoming_request)
if not response:
post_sms_parser_processors = [
PostSMSProcessorLanguageActivator(dbm, incoming_request)
]
if organization.in_trial_mode:
post_sms_parser_processors.append(
PostSMSProcessorCheckLimits(dbm, incoming_request))
post_sms_parser_processors.extend([
PostSMSProcessorNumberOfAnswersValidators(
dbm, incoming_request),
PostSMSProcessorCheckDSIsLinkedToProject(
dbm, incoming_request)
])
sms_player = SMSPlayer(
dbm,
LocationBridge(get_location_tree(),
get_loc_hierarchy=get_location_hierarchy),
post_sms_parser_processors=post_sms_parser_processors,
feeds_dbm=incoming_request['feeds_dbm'])
response = sms_player.accept(
mangrove_request,
logger=incoming_request.get("logger"),
translation_processor=TranslationProcessor)
if response.is_registration:
incoming_request['is_registration'] = True
if not sent_via_sms_test_questionnaire:
organization.increment_message_count_for(
sms_registration_count=1)
if not response.is_registration:
if sent_via_sms_test_questionnaire:
organization.increment_message_count_for(
incoming_web_count=1)
check_quotas_and_update_users(organization, sms_channel=True)
mail_feed_errors(response, dbm.database_name)
message = SMSResponse(response, incoming_request).text(dbm)
send_message(incoming_request, response)
except DataObjectAlreadyExists as e:
message = identification_number_already_exists_handler(
dbm, e.data[1], e.data[2])
if not sent_via_sms_test_questionnaire:
organization.increment_message_count_for(sms_registration_count=1)
except DataObjectNotFound as exception:
if sent_via_sms_test_questionnaire:
organization.increment_message_count_for(incoming_web_count=1)
message = handle(exception, incoming_request)
except FormModelDoesNotExistsException as exception:
if sent_via_sms_test_questionnaire:
organization.increment_message_count_for(incoming_web_count=1)
message = incorrect_questionnaire_code_handler(dbm, exception.data[0])
except SMSParserWrongNumberOfAnswersException as exception:
form_model = sms_player.get_form_model(mangrove_request)
if not form_model.is_entity_registration_form():
organization.increment_message_count_for(
incoming_web_count=1
) if sent_via_sms_test_questionnaire else organization.increment_message_count_for(
incoming_sms_count=1)
message = incorrect_number_of_answers_for_submission_handler(
dbm, form_model.form_code, incoming_request)
elif form_model.is_entity_registration_form():
message = incorrect_number_of_answers_for_uid_registration_handler(
dbm, form_model.form_code, incoming_request)
elif not sent_via_sms_test_questionnaire:
organization.increment_message_count_for(sms_registration_count=1)
except Exception as exception:
if sent_via_sms_test_questionnaire:
organization.increment_message_count_for(incoming_web_count=1)
message = handle(exception, incoming_request)
message = incoming_request.get('error_message', message)
incoming_request['outgoing_message'] = message if incoming_request.get(
'is_outgoing_reply_sms_enabled', True) else ""
if not sent_via_sms_test_questionnaire:
if incoming_request.get('is_outgoing_reply_sms_enabled', True):
organization.increment_message_count_for(outgoing_sms_count=1)
SMS(message=message,
message_id=incoming_request['message_id'],
organization=incoming_request['organization'],
msg_from=mangrove_request.transport.source,
msg_to=mangrove_request.transport.destination,
msg_type=MSG_TYPE_SUBMISSION_REPLY,
status="Submitted").save()
return incoming_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))
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()])
back_link = reverse(all_subjects, args=[entity_type])
web_questionnaire_template = get_template(request.user)
disable_link_class, hide_link_class = get_visibility_settings_for(
request.user)
if request.method == 'GET':
initialize_values(form_model, subject)
questionnaire_form = SubjectRegistrationForm(form_model)
form_context = _make_form_context(
questionnaire_form,
entity_type,
disable_link_class,
hide_link_class,
form_model.form_code,
get_organization_telephone_number(request),
form_model.fields,
is_update=True,
back_link=back_link)
form_context.update(
{'is_pro_sms': get_organization(request).is_pro_sms})
return render_to_response(web_questionnaire_template,
form_context,
context_instance=RequestContext(request))
if request.method == 'POST':
questionnaire_form = SubjectRegistrationForm(
form_model,
data=request.POST,
country=get_organization_country(request))
if not questionnaire_form.is_valid():
form_context = _make_form_context(
questionnaire_form,
entity_type,
disable_link_class,
hide_link_class,
form_model.form_code,
get_organization_telephone_number(request),
form_model.fields,
is_update=True,
back_link=back_link)
return render_to_response(web_questionnaire_template,
form_context,
context_instance=RequestContext(request))
success_message = None
error_message = None
try:
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:
#assumption q6 - unique_id code and q2 - lastname codes cannot be changed
update_submission_search_for_subject_edition(
manager, [entity_type], response.processed_data)
success_message = _("Your changes have been saved.")
questionnaire_form = SubjectRegistrationForm(
form_model,
data=request.POST,
country=get_organization_country(request))
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,
form_model.form_code,
get_organization_telephone_number(request),
form_model.fields,
is_update=True,
back_link=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,
form_model.form_code,
get_organization_telephone_number(request),
form_model.fields,
is_update=True,
back_link=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 submit_to_player(incoming_request):
sent_via_sms_test_questionnaire = incoming_request.get('test_sms_questionnaire', False)
organization = incoming_request.get('organization')
organization = organization
should_increment_incoming_sms_count = True if not sent_via_sms_test_questionnaire else False
response =None
try:
dbm = incoming_request['dbm']
mangrove_request = Request(message=incoming_request['incoming_message'],
transportInfo=incoming_request['transport_info'])
post_sms_parser_processors = [PostSMSProcessorLanguageActivator(dbm, incoming_request),
PostSMSProcessorCheckDSIsRegistered(dbm, incoming_request)]
if organization.in_trial_mode:
post_sms_parser_processors.append(PostSMSProcessorCheckLimits(dbm, incoming_request))
post_sms_parser_processors.extend([PostSMSProcessorNumberOfAnswersValidators(dbm, incoming_request),
PostSMSProcessorCheckDSIsLinkedToProject(dbm, incoming_request)])
sms_player = SMSPlayer(dbm, LocationBridge(get_location_tree(), get_loc_hierarchy=get_location_hierarchy),
post_sms_parser_processors=post_sms_parser_processors,
feeds_dbm=incoming_request['feeds_dbm'])
response = sms_player.accept(mangrove_request, logger=incoming_request.get("logger"),
translation_processor=TranslationProcessor)
if response.is_registration:
incoming_request['is_registration'] = True
if not sent_via_sms_test_questionnaire:
organization.increment_message_count_for(sms_registration_count=1)
else:
if sent_via_sms_test_questionnaire:
organization.increment_message_count_for(incoming_web_count=1)
check_quotas_and_update_users(organization, sms_channel=True)
mail_feed_errors(response, dbm.database_name)
message = SMSResponse(response, incoming_request).text(dbm)
send_message(incoming_request, response)
except DataObjectAlreadyExists as e:
message = identification_number_already_exists_handler(dbm, e.data[1], e.data[2])
if not sent_via_sms_test_questionnaire:
organization.increment_message_count_for(sms_registration_count=1)
except DataObjectNotFound as exception:
if sent_via_sms_test_questionnaire:
organization.increment_message_count_for(incoming_web_count=1)
message = handle(exception, incoming_request)
except FormModelDoesNotExistsException as exception:
if sent_via_sms_test_questionnaire:
organization.increment_message_count_for(incoming_web_count=1)
message = incorrect_questionnaire_code_handler(dbm, exception.data[0], incoming_request)
except SMSParserWrongNumberOfAnswersException:
form_model = sms_player.get_form_model(mangrove_request)
if not form_model.is_entity_registration_form():
if sent_via_sms_test_questionnaire:
organization.increment_message_count_for(incoming_web_count=1)
message = incorrect_number_of_answers_for_submission_handler(dbm, form_model.form_code, incoming_request)
elif form_model.is_entity_registration_form():
message = incorrect_number_of_answers_for_uid_registration_handler(dbm, form_model.form_code, incoming_request)
except (ExceedSubmissionLimitException, ExceedSMSLimitException) as exception:
should_increment_incoming_sms_count = False
message = handle(exception, incoming_request)
except Exception as exception:
if sent_via_sms_test_questionnaire:
organization.increment_message_count_for(incoming_web_count=1)
message = handle(exception, incoming_request)
if should_increment_incoming_sms_count:
organization.increment_incoming_message_count()
if response and not response.is_registration:
check_quotas_and_update_users(organization, )
return post_player_handler(incoming_request, message)
def submit_to_player(incoming_request):
sent_via_sms_test_questionnaire = incoming_request.get(
'test_sms_questionnaire', False)
organization = incoming_request.get('organization')
organization = organization
try:
dbm = incoming_request['dbm']
post_sms_parser_processors = [
PostSMSProcessorLanguageActivator(dbm, incoming_request),
PostSMSProcessorNumberOfAnswersValidators(dbm, incoming_request)
]
sms_player = SMSPlayer(
dbm,
LocationBridge(get_location_tree(),
get_loc_hierarchy=get_location_hierarchy),
post_sms_parser_processors=post_sms_parser_processors,
feeds_dbm=incoming_request['feeds_dbm'])
mangrove_request = Request(
message=incoming_request['incoming_message'],
transportInfo=incoming_request['transport_info'])
response = sms_player.accept(mangrove_request,
logger=incoming_request.get("logger"))
if response.is_registration and not sent_via_sms_test_questionnaire:
organization.increment_message_count_for(sms_registration_count=1)
if not response.is_registration and sent_via_sms_test_questionnaire:
organization.increment_message_count_for(incoming_web_count=1)
mail_feed_errors(response, dbm.database_name)
message = SMSResponse(response).text(dbm)
send_message(incoming_request, response)
except DataObjectAlreadyExists as e:
message = ugettext("The Unique ID Number %s is already used for the %s %s. Register your %s with a different ID.") % \
(e.data[1], e.data[2], e.data[3], e.data[2])
if not sent_via_sms_test_questionnaire:
organization.increment_message_count_for(sms_registration_count=1)
except DataObjectNotFound as exception:
if sent_via_sms_test_questionnaire:
organization.increment_message_count_for(incoming_web_count=1)
message = handle(exception, incoming_request)
except FormModelDoesNotExistsException as exception:
if sent_via_sms_test_questionnaire:
organization.increment_message_count_for(incoming_web_count=1)
message = handle(exception, incoming_request)
except Exception as exception:
message = handle(exception, incoming_request)
incoming_request['outgoing_message'] = message
if not sent_via_sms_test_questionnaire:
SMS(message=message,
message_id=incoming_request['message_id'],
organization=incoming_request['organization'],
msg_from=mangrove_request.transport.source,
msg_to=mangrove_request.transport.destination,
msg_type=MSG_TYPE_SUBMISSION_REPLY,
status="Submitted").save()
return incoming_request
def setUp(self):
MangroveTestCase.setUp(self)
initializer.run(self.manager)
self.entity_type = ["reporter"]
self.telephone_number_type = DataDictType(self.manager, name='telephone_number', slug='telephone_number',
primitive_type='string')
self.entity_id_type = DataDictType(self.manager, name='Entity Id Type', slug='entity_id', primitive_type='string')
self.name_type = DataDictType(self.manager, name='Name', slug='name', primitive_type='string')
self.telephone_number_type.save()
self.name_type.save()
self.reporter = create_entity(self.manager, entity_type=self.entity_type,
location=["India", "Pune"], aggregation_paths=None, short_code="rep1",
)
self.reporter.add_data(data=[(MOBILE_NUMBER_FIELD, '1234', self.telephone_number_type),
(NAME_FIELD, "Test_reporter", self.name_type)], submission=dict(submission_id="1"))
question1 = TextField(name="entity_question", code="EID", label="What is associated entity",
entity_question_flag=True, ddtype=self.entity_id_type)
question2 = TextField(name="Name", code="NAME", label="Clinic Name",
defaultValue="some default value",
ddtype=self.name_type, required=False)
self.form_model = FormModel(self.manager, entity_type=self.entity_type, name="Dengue", label="Dengue form_model",
form_code="clinic", type='survey', fields=[question1,question2])
self.form_model.save()
self.csv_data_for_activity_report = """
FORM_CODE,EID,NAME
clinic,rep1,XYZ
"""
self.csv_data_about_reporter = """
FORM_CODE,t,n,l,d,m
REG,"reporter",Dr. A,Pune,"Description",201
"""
self.csv_data_with_same_mobile_number = """
FORM_CODE,t,n,l,d,m
REG,"reporter",Dr. A,Pune,"Description",201
REG,"reporter",Dr. B,Pune,"Description",201
"""
self.csv_data_with_exception = """
FORM_CODE,t,n,l,d,m
REG,"reporter",Dr. A,Pune,"Description",201
REG,"reporter",Dr. B,Pune,"Description",201
REG,"reporter",Dr. C,Pune,"Description",202
"""
self.csv_data_with_missing_name = """
FORM_CODE,t,n,l,d,m
REG,"reporter",,Pune,"Description",201
"""
self.csv_data_with_missing_type = """
FORM_CODE,t,n,l,d,m
REG,,Dr. A,Pune,"Description",201
"""
self.csv_data_with_incorrect_mobile_number = """
FORM_CODE,t,n,l,d,m
REG,"reporter",Dr. A,Pune,"Description",2014678447676512
REG,"reporter",Dr. A,Pune,"Description",~!@#$%^&*()+|}
REG,"reporter",Dr. A,Pune,"Description",
"""
self.csv_data_with_incorrect_GPS = """
FORM_CODE,t,n,g,d,m
REG,"reporter",Dr. A,18,"Description",201
"""
self.csv_data_with_out_of_range_GPS_value = """
FORM_CODE,t,n,g,d,m
REG,"reporter",Dr. A,-95 48,"Description",201
REG,"reporter",Dr. A,-18 184,"Description",201
"""
self.csv_data_without_form_code= """
FORM_CODE,t,n,g,d,m
,"reporter",Dr. A,-95 48,"Description",201
ABC,"reporter",Dr. A,-95 48,"Description",201
"""
self.parser = CsvParser()
self.file_player = FilePlayer(self.manager,self.parser, Channel.CSV, LocationBridge(DummyLocationTree(),dummy_get_location_hierarchy))
def submission(request):
if request.method != 'POST':
response = HttpResponse(status=204)
response['Location'] = request.build_absolute_uri()
return response
send_to_carbon(create_path('submissions.smartphone'), 1)
request_user = request.user
submission_file = request.FILES.get("xml_submission_file").read()
manager = get_database_manager(request_user)
if not __authorized_to_make_submission_on_requested_form(request_user, submission_file, manager) \
or is_quota_reached(request):
response = HttpResponse(status=403)
return response
player = XFormPlayerV2(manager, get_feeds_database(request_user))
try:
user_profile = NGOUserProfile.objects.get(user=request_user)
mangrove_request = Request(
message=submission_file,
transportInfo=TransportInfo(transport=SMART_PHONE,
source=request_user.email,
destination=''),
media=request.FILES if len(request.FILES) > 1 else [])
form_code, values = XFormParser(manager).parse(
mangrove_request.message)
form_model = get_form_model_by_code(manager, form_code)
if isinstance(
form_model,
EntityFormModel) and form_model.is_entity_registration_form:
location_tree = LocationBridge(
get_location_tree(), get_loc_hierarchy=get_location_hierarchy)
response = player.add_subject(form_model, values, location_tree)
else:
response = player.add_survey_response(mangrove_request,
user_profile.reporter_id,
logger=sp_submission_logger)
mail_feed_errors(response, manager.database_name)
if response.errors:
logger.error("Error in submission : \n%s" %
get_errors(response.errors))
return HttpResponseBadRequest()
except MediaAttachmentNotFoundException as me:
_send_media_error_mail(request, request_user, user_profile, me.message)
return HttpResponseBadRequest()
except DataObjectAlreadyExists as doe:
send_email_for_duplicate_unique_id_registration(
request, doe.data[2], doe.data[1])
return HttpResponseBadRequest()
except Exception as e:
logger.exception("Exception in submission : \n%s" % e)
return HttpResponseBadRequest()
organization = Organization.objects.get(org_id=user_profile.org_id)
organization.increment_message_count_for(incoming_sp_count=1)
check_quotas_and_update_users(organization)
response = HttpResponse(status=201)
response['Location'] = request.build_absolute_uri(request.path)
return response
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))
