def send_sms_v2(self, text):
transport_info = TransportInfo(transport="sms",
source="1234",
destination="5678")
response = self.sms_player_v2.add_survey_response(
Request(message=text, transportInfo=transport_info))
return response
def test_edit_survey_response_when_fields_constraints_are_not_satisfied(
self):
survey_response = Mock(spec=SurveyResponse)
with patch(
'mangrove.transport.services.survey_response_service.by_short_code'
) as get_reporter:
with patch(
'mangrove.datastore.entity.by_short_code') as get_entity:
with patch(
'mangrove.transport.services.survey_response_service.get_form_model_by_code'
) as get_form_model:
get_reporter.return_value = Mock(spec=Entity)
get_entity.return_value = Mock(spec=Entity)
get_form_model.return_value = self.form_model()
transport_info = TransportInfo('web', 'src', 'dest')
values = {'form_code': 'aids', 'q1': 'a1', 'q2': '200'}
request = Request(values, transport_info)
response = self.survey_response_service.edit_survey(
'aids', values, [], survey_response)
self.assertFalse(response.success)
self.assertEquals('aids', response.form_code)
self.assertEquals(
OrderedDict([(
'q2',
u'Answer 200 for question q2 is greater than allowed.'
)]), response.errors)
self.assertEquals(['clinic'], response.entity_type)
self.assertEquals(OrderedDict([('q1', 'a1')]),
response.processed_data)
self.assertIsNotNone(response.survey_response_id)
assert not survey_response.update.called
def test_should_raise_exception_for_poll_questionnaire(self):
self.loc_tree.get_location_hierarchy.return_value = None
sms_message = "questionnaire_code question1_answer question2_answer"
request = Request(transportInfo=self.transport, message=sms_message)
contact = MagicMock(Contact)
contact.value.return_value = None
contact.short_code = "short_code"
project = MagicMock(spec=Project)
project.is_poll = True
self.reporter_module.find_reporter_entity.return_value = contact
with patch(
'mangrove.transport.player.new_players.SurveyResponseService'
) as SurveyResponseServiceMock:
with patch('mangrove.form_model.project.get_project_by_code'
) as get_project_by_code:
with patch(
'mangrove.form_model.project.check_if_form_code_is_poll'
) as mock_check_if_form_code_is_poll:
instance_mock = Mock()
SurveyResponseServiceMock.return_value = instance_mock
get_project_by_code.return_value = project
self.assertRaises(ProjectPollCodeDoesNotExistsException,
self.sms_player.add_survey_response,
request)
def test_survey_response_is_saved_with_reporter_id_in_upper_case(self):
test_data = TestData(self.manager)
survey_response_service = SurveyResponseService(self.manager)
values = {'ID': test_data.entity1.short_code, 'Q1': 'name', 'Q2': '80', 'Q3': 'a'}
transport_info = TransportInfo('web', 'src', 'dest')
request = Request(values, transport_info)
response = survey_response_service.save_survey('CL1', values, [], transport_info, 'REP2')
self.assertTrue(response.success)
self.assertEqual(0, response.errors.__len__())
self.assertIsNotNone(response.datarecord_id)
self.assertIsNotNone(response.survey_response_id)
self.assertEqual(test_data.entity_type, response.entity_type)
self.assertEqual('CL1', response.form_code)
self.assertEqual('1', response.short_code)
self.assertDictEqual(OrderedDict([('Q1', 'name'), ('Q3', ['RED']), ('Q2', 80), ('ID', u'1')]),
response.processed_data)
survey_response = SurveyResponse.get(self.manager, response.survey_response_id)
self.assertDictEqual({'Q1': 'name', 'Q3': 'a', 'Q2': '80', 'ID': '1'}, survey_response.values)
self.assertDictEqual({'Q1': 'name', 'Q3': 'a', 'Q2': '80', 'ID': '1'}, survey_response.values)
self.assertEqual(test_data.form_model.revision, survey_response.form_model_revision)
self.assertEqual(True, survey_response.status)
self.assertIsNotNone(survey_response.data_record)
def test_should_call_parser_post_processor_and_continue_for_no_response(
self):
self.loc_tree.get_location_hierarchy.return_value = None
message = 'SOME_FORM_CODE 1'
post_sms_processor_mock = Mock()
post_sms_processors = [post_sms_processor_mock]
sms_player = SMSPlayerV2(self.dbm, post_sms_processors)
with patch("inspect.getargspec") as get_arg_spec_mock:
with patch(
'mangrove.transport.player.new_players.SurveyResponseService.save_survey'
) as save_survey:
with patch('mangrove.form_model.project.get_project_by_code'
) as get_project_by_code:
with patch(
'mangrove.form_model.project.check_if_form_code_is_poll'
) as mock_check_if_form_code_is_poll:
get_arg_spec_mock.return_value = ([
'self', 'form_code', 'submission_values',
'extra_elements'
], )
sms_player.add_survey_response(
Request(message=message,
transportInfo=self.transport))
save_survey.assert_called_once('some_form_code',
{'id': '1'},
[{
'name': '1234'
}], 'sms', message)
post_sms_processor_mock.process.assert_called_once_with(
'some_form_code', {'id': '1'}, [])
def test_should_save_survey_for_a_reporter_with_no_name(self):
self.loc_tree.get_location_hierarchy.return_value = None
sms_message = "questionnaire_code question1_answer question2_answer"
request = Request(transportInfo=self.transport, message=sms_message)
contact = MagicMock(Contact)
contact.value.return_value = None
contact.short_code = "short_code"
self.reporter_module.find_reporter_entity.return_value = contact
with patch(
'mangrove.transport.player.new_players.SurveyResponseService'
) as SurveyResponseServiceMock:
with patch('mangrove.form_model.project.get_project_by_code'
) as get_project_by_code:
with patch(
'mangrove.form_model.project.check_if_form_code_is_poll'
) as mock_check_if_form_code_is_poll:
instance_mock = Mock()
SurveyResponseServiceMock.return_value = instance_mock
self.sms_player.add_survey_response(request)
instance_mock.save_survey.assert_called_with(
'questionnaire_code', {'id': 'question1_answer'},
None,
self.transport,
"short_code",
additional_feed_dictionary=None,
translation_processor=None)
def test_should_accept_ordered_sms_message(self):
self.loc_tree.get_location_hierarchy.return_value = None
sms_message = "questionnaire_code question1_answer question2_answer"
request = Request(transportInfo=self.transport, message=sms_message)
with patch(
'mangrove.transport.services.survey_response_service.SurveyResponseService.save_survey'
) as save_survey:
with patch('mangrove.form_model.project.get_project_by_code'
) as get_project_by_code:
with patch(
'mangrove.form_model.project.check_if_form_code_is_poll'
) as mock_check_if_form_code_is_poll:
mock_form_model = Mock(spec=FormModel)
get_project_by_code.return_value = []
#mock_get_form_model_by_code.return_value = mock_form_model
save_survey.return_value = Mock(spec=Response)
self.sms_player.add_survey_response(request)
save_survey.assert_called_once_with(
'questionnaire_code', {'id': 'question1_answer'},
[{
'name': '1234'
}],
self.transport,
"short_code",
additional_feed_dictionary=None,
translation_processor=None)
def add_survey_response(self, text, reporter_id='rep12'):
transport_info = TransportInfo(transport="web",
source="*****@*****.**",
destination="")
response = self.web_player.add_survey_response(
Request(message=text, transportInfo=transport_info), reporter_id)
return response
def test_should_call_parser_post_processor_and_return_if_there_is_response_from_post_processor(
self):
parser_mock = Mock(spec=OrderSMSParser)
parser_mock.parse.return_value = ('FORM_CODE', {'id': '1'}, [])
parser_mock.parse.return_value = ('FORM_CODE', {'id': '1'}, [])
post_sms_processor_mock = Mock()
expected_response = Response(reporters=None, survey_response_id=None)
post_sms_processor_mock.process.return_value = expected_response
message = 'FORM_CODE 1'
sms_player = SMSPlayerV2(
self.dbm, post_sms_parser_processors=[post_sms_processor_mock])
with patch("inspect.getargspec") as get_arg_spec_mock:
with patch('mangrove.form_model.project.get_project_by_code'
) as get_project_by_code:
with patch(
'mangrove.form_model.project.check_if_form_code_is_poll'
) as mock_check_if_form_code_is_poll:
get_arg_spec_mock.return_value = ([
'self', 'form_code', 'submission_values',
'extra_elements'
], )
response = sms_player.add_survey_response(
Request(message=message, transportInfo=self.transport))
self.assertEqual(expected_response, response)
def send_sms(self, text, player=None):
player = player or self.sms_player
transport_info = TransportInfo(transport="sms",
source=self.phone_number,
destination="5678")
response = player.accept(
Request(message=text, transportInfo=transport_info))
return response
def test_survey_response_is_edited_and_new_submission_and_datarecord_is_created(
self):
test_data = TestData(self.manager)
survey_response_service = SurveyResponseService(self.manager)
values = {
'ID': test_data.entity1.short_code,
'Q1': 'name',
'Q2': '80',
'Q3': 'a'
}
transport_info = TransportInfo('web', 'src', 'dest')
request = Request(values, transport_info)
saved_response = survey_response_service.save_survey(
'CL1', values, [], transport_info, "rep2")
self.assertDictEqual(
OrderedDict([('Q1', 'name'), ('Q3', ['RED']), ('Q2', 80),
('ID', u'1')]), saved_response.processed_data)
new_values = {
'ID': test_data.entity1.short_code,
'Q1': 'new_name',
'Q2': '430',
'Q3': 'b'
}
survey_response_to_edit = SurveyResponse.get(
self.manager, saved_response.survey_response_id)
edited_response = survey_response_service.edit_survey(
'CL1', new_values, [], survey_response_to_edit)
self.assertTrue(edited_response.success)
self.assertEqual(0, edited_response.errors.__len__())
self.assertIsNotNone(edited_response.datarecord_id)
self.assertIsNotNone(edited_response.survey_response_id)
self.assertEqual(test_data.entity_type, edited_response.entity_type)
self.assertEqual('CL1', edited_response.form_code)
self.assertDictEqual(
OrderedDict([('Q1', 'new_name'), ('Q3', ['YELLOW']), ('Q2', 430),
('ID', u'1')]), edited_response.processed_data)
self.assertNotEquals(saved_response.datarecord_id,
edited_response.datarecord_id)
old_data_record = DataRecord.get(self.manager,
saved_response.datarecord_id)
self.assertTrue(old_data_record.voided)
new_data_record = DataRecord.get(self.manager,
edited_response.datarecord_id)
self.assertFalse(new_data_record.voided)
edited_survey_response = SurveyResponse.get(
self.manager, edited_response.survey_response_id)
self.assertEquals(1,
len(edited_survey_response._doc.data_record_history))
self.assertEquals(old_data_record.id,
edited_survey_response._doc.data_record_history[0])
def test_should_submit_if_parsing_is_successful(self):
with patch.object(FormSubmissionFactory,
'get_form_submission') as get_form_submission_mock:
get_form_submission_mock.return_value = self.form_submission_mock
response = self.web_player.accept(
Request(message=self.message, transportInfo=self.transport))
self.form_submission_mock.save.assert_called_once_with(self.dbm)
self.assertEqual('', response.datarecord_id)
self.assertEqual([''], response.entity_type)
def test_response_has_no_error_when_feed_creation_fails(self):
manager = Mock(spec=DatabaseManager)
feed_manager = Mock(spec=DatabaseManager)
values = {'ID': 'short_code', 'Q1': 'name', 'Q2': '80', 'Q3': 'a'}
transport_info = TransportInfo('web', 'src', 'dest')
request = Request(values, transport_info)
additional_dictionary = {
'project': {
'name': 'someproject',
'status': 'active',
'id': 'someid'
}
}
survey_response_service = SurveyResponseService(manager,
feeds_dbm=feed_manager)
with patch(
'mangrove.transport.services.survey_response_service.by_short_code'
) as get_reporter:
with patch(
'mangrove.transport.services.survey_response_service.get_form_model_by_code'
) as get_form_model_by_code:
with patch('mangrove.datastore.entity.by_short_code'
) as by_short_code:
with patch(
'mangrove.transport.services.survey_response_service.DataFormSubmission'
) as data_form_submission:
with patch(
'mangrove.transport.services.survey_response_service.EnrichedSurveyResponseBuilder'
) as builder:
get_reporter.return_value = Mock(spec=Entity)
builder.feed_document.side_effect = Exception(
'Some error')
builder.return_value = builder
instance_mock = data_form_submission.return_value
type(instance_mock).is_valid = PropertyMock(
return_value=True)
type(instance_mock).data_record_id = PropertyMock(
return_value='sdsddsd')
type(instance_mock).errors = PropertyMock(
return_value='')
by_short_code.return_value = Mock(spec=Entity)
mock_form_model = MagicMock(spec=FormModel)
mock_form_model._dbm = manager
mock_form_model._doc = MagicMock()
mock_form_model._data = {}
mock_form_model.validate_submission.return_value = values, ""
get_form_model_by_code.return_value = mock_form_model
response = survey_response_service.save_survey(
'CL1', values, [], transport_info, '',
additional_dictionary)
self.assertFalse(response.errors)
self.assertTrue(response.feed_error_message)
def test_exception_is_raised_for_invalid_short_code_submissions(self):
survey_response_service = SurveyResponseService(self.manager)
with patch(
'mangrove.transport.services.survey_response_service.get_active_form_model') as mock_get_active_form_model:
mock_get_active_form_model.side_effect = FormModelDoesNotExistsException("form_code")
values = {'ID': "invalid", 'Q1': 'name', 'Q2': '80', 'Q3': 'a'}
transport_info = TransportInfo('web', 'src', 'dest')
request = Request(values, transport_info)
self.assertRaises(MangroveException, survey_response_service.save_survey, 'CL1', values, [], transport_info,
'')
def setUp(self):
super(TestXformPlayerIT, self).setUp()
self.org_id = 'SLX364903'
self.player = XFormPlayerV2(self.manager)
message = self.xform_message
self.transport = TransportInfo(transport="xform",
source="*****@*****.**",
destination="5678")
self.request = Request(message=message, transportInfo=self.transport)
TestData(self.manager)
register_datasender(self.manager)
def test_survey_response_event_created_when_survey_response_created(self):
manager = Mock(spec=DatabaseManager)
feed_manager = Mock(spec=DatabaseManager)
survey_response_service = SurveyResponseService(manager,
feeds_dbm=feed_manager)
values = {'ID': 'short_code', 'Q1': 'name', 'Q2': '80', 'Q3': 'a'}
transport_info = TransportInfo('web', 'src', 'dest')
request = Request(values, transport_info)
additional_dictionary = {
'project': {
'name': 'someproject',
'status': 'active',
'id': 'someid'
}
}
with patch(
'mangrove.transport.services.survey_response_service.by_short_code'
) as get_reporter:
with patch(
'mangrove.transport.services.survey_response_service.get_form_model_by_code'
) as get_form_model_by_code:
with patch('mangrove.datastore.entity.by_short_code'
) as by_short_code:
with patch(
'mangrove.transport.services.survey_response_service.EnrichedSurveyResponseBuilder'
) as builder:
with patch(
"mangrove.form_model.form_submission.DataRecordDocument"
) as DataRecordDocumentMock:
get_reporter.return_value = Mock(spec=Entity)
builder.return_value = Mock(
spec=EnrichedSurveyResponseBuilder)
entity_mock = MagicMock(spec=Entity)
entity_mock._doc = EntityDocument()
by_short_code.return_value = entity_mock
mock_form_model = MagicMock(spec=FormModel)
mock_form_model._dbm = manager
mock_form_model._doc = MagicMock()
mock_form_model._data = {}
mock_form_model.validate_submission.return_value = OrderedDict(
values), OrderedDict('')
mock_form_model.is_entity_registration_form.return_value = False
mock_form_model.entity_questions = []
mock_form_model.entity_type = 'sometype'
get_form_model_by_code.return_value = mock_form_model
survey_response_service.save_survey(
'CL1', values, [], transport_info, '',
additional_dictionary)
self.assertEquals(
1, feed_manager._save_document.call_count)
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 [])
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 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 test_should_not_parse_if_two_question_codes(self):
transport = TransportInfo(transport="sms",
source="1234",
destination="5678")
with patch('mangrove.form_model.project.get_project_by_code'
) as get_project_by_code:
with patch('mangrove.form_model.project.check_if_form_code_is_poll'
) as mock_check_if_form_code_is_poll:
with self.assertRaises(
MultipleSubmissionsForSameCodeException):
self.sms_player.add_survey_response(
Request(message="cli001 .na tester1 .na tester2",
transportInfo=transport))
self.assertEqual(
0, self.form_model_mock.validate_submission.call_count)
def test_should_allow_submission_by_unregistered_reporter_for_open_datasender_questionnaire(
self):
self.reporter_module.find_reporter_entity.side_effect = NumberNotRegisteredException(
"1234")
self.form_model_mock.is_open_survey = True
entity_question_field = Mock()
entity_question_field.code = 'q1'
self.form_model_mock.entity_questions = [entity_question_field]
with patch('mangrove.form_model.project.get_project_by_code'
) as get_project_by_code:
with patch('mangrove.form_model.project.check_if_form_code_is_poll'
) as mock_check_if_form_code_is_poll:
response = self.sms_player.add_survey_response(
Request(message=self.message,
transportInfo=self.transport))
self.assertEqual(response.errors, {})
self.assertTrue(response.success)
def test_feeds_created_if_subject_not_found_for_a_submission(self):
manager = Mock(spec=DatabaseManager)
feed_manager = Mock(spec=DatabaseManager)
project = Mock(spec=Project)
values = {'ID': 'short_code', 'Q1': 'name', 'Q2': '80', 'Q3': 'a'}
transport_info = TransportInfo('web', 'src', 'dest')
request = Request(values, transport_info)
additional_dictionary = {'project': {'name': 'someproject', 'status': 'active', 'id': 'someid'}}
survey_response_service = SurveyResponseService(manager, feeds_dbm=feed_manager)
with patch('mangrove.transport.services.survey_response_service.by_short_code') as get_reporter:
with patch(
'mangrove.transport.services.survey_response_service.get_form_model_by_code') as get_form_model_by_code:
with patch('mangrove.datastore.entity.by_short_code') as by_short_code:
with patch(
'mangrove.transport.services.survey_response_service.DataFormSubmission') as data_form_submission:
with patch(
'mangrove.transport.services.survey_response_service.EnrichedSurveyResponseBuilder')as builder:
with patch('mangrove.transport.services.survey_response_service.Project.from_form_model') as from_form_model:
get_reporter.return_value = Mock(spec=Entity)
builder.return_value = Mock(spec=EnrichedSurveyResponseBuilder)
instance_mock = data_form_submission.return_value
type(instance_mock).is_valid = PropertyMock(return_value=True)
type(instance_mock).data_record_id = PropertyMock(return_value='sdsddsd')
instance_mock.save.side_effect = MangroveException("subject not found")
from_form_model.return_value = project
project.data_senders = []
by_short_code.return_value = Mock(spec=Entity)
mock_form_model = MagicMock(spec=FormModel)
mock_form_model._dbm = manager
mock_form_model._doc = MagicMock()
mock_form_model._data = {}
mock_form_model.validate_submission.return_value = values, ""
get_form_model_by_code.return_value = mock_form_model
try:
survey_response_service.save_survey('CL1', values, [], transport_info, '',
additional_dictionary)
self.fail('the subject not found exception should be propagated')
except MangroveException:
feed_manager._save_document.assert_called_once()
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 test_should_throw_error_if_transportInfo_is_none(self):
with self.assertRaises(AssertionError):
Request(transportInfo=None, 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 test_should_throw_error_if_message_is_none(self):
with self.assertRaises(AssertionError):
transport = TransportInfo(transport="", source="", destination="")
Request(transportInfo=transport, message=None)
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 create_request(questionnaire_form, username, is_update=None):
return Request(message=questionnaire_form.cleaned_data,
transportInfo=get_web_transport_info(username),
is_update=is_update,
media=[])
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
