def test_dao_get_service_sms_senders_id_raises_exception_with_archived_sms_sender(
notify_db_session):
service = create_service()
archived_sms_sender = create_service_sms_sender(service=service,
sms_sender="second",
is_default=False,
archived=True)
with pytest.raises(expected_exception=SQLAlchemyError):
dao_get_service_sms_sender_by_id(
service_id=service.id,
service_sms_sender_id=archived_sms_sender.id)
def check_service_sms_sender_id(service_id, sms_sender_id, notification_type):
if sms_sender_id:
try:
return dao_get_service_sms_sender_by_id(service_id, sms_sender_id).sms_sender
except NoResultFound:
message = 'sms_sender_id {} does not exist in database for service id {}'\
.format(sms_sender_id, service_id)
raise BadRequestError(message=message)
def test_dao_get_service_sms_sender_by_id(notify_db_session):
service = create_service()
second_sender = dao_add_sms_sender_for_service(service_id=service.id,
sms_sender='second',
is_default=False,
inbound_number_id=None)
result = dao_get_service_sms_sender_by_id(
service_id=service.id, service_sms_sender_id=second_sender.id)
assert result.sms_sender == "second"
assert not result.is_default
def save_sms(self,
service_id,
notification_id,
encrypted_notification,
sender_id=None):
notification = encryption.decrypt(encrypted_notification)
service = dao_fetch_service_by_id(service_id)
template = dao_get_template_by_id(notification['template'],
version=notification['template_version'])
if sender_id:
reply_to_text = dao_get_service_sms_sender_by_id(
service_id, sender_id).sms_sender
else:
reply_to_text = template.get_reply_to_text()
if not service_allowed_to_send_to(notification['to'], service,
KEY_TYPE_NORMAL):
current_app.logger.debug(
"SMS {} failed as restricted service".format(notification_id))
return
try:
saved_notification = persist_notification(
template_id=notification['template'],
template_version=notification['template_version'],
recipient=notification['to'],
service=service,
personalisation=notification.get('personalisation'),
notification_type=SMS_TYPE,
api_key_id=None,
key_type=KEY_TYPE_NORMAL,
created_at=datetime.utcnow(),
job_id=notification.get('job', None),
job_row_number=notification.get('row_number', None),
notification_id=notification_id,
reply_to_text=reply_to_text)
provider_tasks.deliver_sms.apply_async(
[str(saved_notification.id)],
queue=QueueNames.SEND_SMS
if not service.research_mode else QueueNames.RESEARCH_MODE)
current_app.logger.debug("SMS {} created at {} for job {}".format(
saved_notification.id, saved_notification.created_at,
notification.get('job', None)))
except SQLAlchemyError as e:
handle_exception(self, notification, notification_id, e)
def get_reply_to_text(notification_type, sender_id, service, template):
reply_to = None
if sender_id:
try:
if notification_type == EMAIL_TYPE:
message = 'Reply to email address not found'
reply_to = dao_get_reply_to_by_id(service.id,
sender_id).email_address
elif notification_type == SMS_TYPE:
message = 'SMS sender not found'
reply_to = dao_get_service_sms_sender_by_id(
service.id, sender_id).get_reply_to_text()
except NoResultFound:
raise BadRequestError(message=message)
else:
reply_to = template.get_reply_to_text()
return reply_to
def get_service_sms_sender_by_id(service_id, sms_sender_id):
sms_sender = dao_get_service_sms_sender_by_id(
service_id=service_id, service_sms_sender_id=sms_sender_id)
return jsonify(sms_sender.serialize()), 200
def test_dao_get_service_sms_sender_by_id_raise_exception_when_not_found(
notify_db_session):
service = create_service()
with pytest.raises(expected_exception=SQLAlchemyError):
dao_get_service_sms_sender_by_id(service_id=service.id,
service_sms_sender_id=uuid.uuid4())