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_senders_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
check_service_over_daily_message_limit(KEY_TYPE_NORMAL, service)
try:
# this task is used by two main things... process_job and process_sms_or_email_notification
# if the data is not present in the encrypted data then fallback on whats needed for process_job
saved_notification = persist_notification(
notification_id=notification.get("id", notification_id),
template_id=notification["template"],
template_version=notification["template_version"],
recipient=notification["to"],
service=service,
personalisation=notification.get("personalisation"),
notification_type=SMS_TYPE,
simulated=notification.get("simulated", None),
api_key_id=notification.get("api_key", None),
key_type=notification.get("key_type", KEY_TYPE_NORMAL),
created_at=datetime.utcnow(),
job_id=notification.get("job", None),
job_row_number=notification.get("row_number", None),
reply_to_text=reply_to_text,
)
send_notification_to_queue(
saved_notification,
service.research_mode,
queue=notification.get("queue") or template.queue_to_use(),
)
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 service_can_send_to_recipient(send_to, key_type, service, allow_whitelisted_recipients=True):
if not service_allowed_to_send_to(send_to, service, key_type, allow_whitelisted_recipients):
if key_type == KEY_TYPE_TEAM:
message = 'Can’t send to this recipient using a team-only API key'
else:
message = (
'Can’t send to this recipient when service is in trial mode '
'– see https://www.notifications.service.gov.uk/trial-mode'
)
raise BadRequestError(message=message)
def _service_allowed_to_send_to(notification, service):
if not service_allowed_to_send_to(notification['to'], service,
api_user.key_type):
if api_user.key_type == KEY_TYPE_TEAM:
message = 'Can’t send to this recipient using a team-only API key'
else:
message = (
'Can’t send to this recipient when service is in trial mode '
'– see https://www.notifications.service.gov.uk/trial-mode')
raise InvalidRequest({'to': [message]}, status_code=400)
def service_can_send_to_recipient(send_to, key_type, service):
if not service_allowed_to_send_to(send_to, service, key_type):
if key_type == KEY_TYPE_TEAM:
message = 'Can’t send to this recipient using a team-only API key'
else:
message = (
'Can’t send to this recipient when service is in trial mode '
'– see https://www.notifications.service.gov.uk/trial-mode'
)
raise BadRequestError(message=message)
def save_sms(self,
service_id,
notification_id,
encrypted_notification,
sender_id=None):
notification = encryption.decrypt(encrypted_notification)
service = SerialisedService.from_id(service_id)
template = SerialisedTemplate.from_id_and_service_id(
notification['template'],
service_id=service.id,
version=notification['template_version'],
)
if sender_id:
reply_to_text = dao_get_service_sms_senders_by_id(service_id, sender_id).sms_sender
else:
reply_to_text = template.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 send_sms(
self, service_id, notification_id, encrypted_notification, created_at, api_key_id=None, key_type=KEY_TYPE_NORMAL
):
notification = encryption.decrypt(encrypted_notification)
service = dao_fetch_service_by_id(service_id)
if not service_allowed_to_send_to(notification["to"], service, key_type):
current_app.logger.info("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_id=service.id,
personalisation=notification.get("personalisation"),
notification_type=SMS_TYPE,
api_key_id=api_key_id,
key_type=key_type,
created_at=created_at,
job_id=notification.get("job", None),
job_row_number=notification.get("row_number", None),
notification_id=notification_id,
)
provider_tasks.deliver_sms.apply_async(
[str(saved_notification.id)], queue="send-sms" if not service.research_mode else "research-mode"
)
current_app.logger.info(
"SMS {} created at {} for job {}".format(saved_notification.id, created_at, notification.get("job", None))
)
except SQLAlchemyError as e:
if not get_notification_by_id(notification_id):
# Sometimes, SQS plays the same message twice. We should be able to catch an IntegrityError, but it seems
# SQLAlchemy is throwing a FlushError. So we check if the notification id already exists then do not
# send to the retry queue.
current_app.logger.error(
"RETRY: send_sms notification for job {} row number {} and notification id {}".format(
notification.get("job", None), notification.get("row_number", None), notification_id
)
)
current_app.logger.exception(e)
try:
raise self.retry(queue="retry", exc=e)
except self.MaxRetriesExceededError:
current_app.logger.error(
"RETRY FAILED: send_sms notification for job {} row number {} and notification id {}".format(
notification.get("job", None), notification.get("row_number", None), notification_id
)
)
current_app.logger.exception(e)
def service_can_send_to_recipient(send_to, key_type, service, allow_safelisted_recipients=True):
if not service_allowed_to_send_to(send_to, service, key_type, allow_safelisted_recipients):
# FIXME: hard code it for now until we can get en/fr specific links and text
if key_type == KEY_TYPE_TEAM:
message = 'Can’t send to this recipient using a team-only API key '\
f'- see {get_document_url("en", "keys.html#team-and-safelist")}'
else:
message = (
'Can’t send to this recipient when service is in trial mode '
f'– see {get_document_url("en", "keys.html#live")}'
)
raise BadRequestError(message=message)
def _service_allowed_to_send_to(notification, service):
if not service_allowed_to_send_to(notification['to'], service,
api_user.key_type):
# FIXME: hard code it for now until we can get en/fr specific links and text
if api_user.key_type == KEY_TYPE_TEAM:
message = 'Can’t send to this recipient using a team-only API key '\
f'- see {get_document_url("en", "keys.html#team-and-safelist")}'
else:
message = (
'Can’t send to this recipient when service is in trial mode '
f'– see {get_document_url("en", "keys.html#live")}')
raise InvalidRequest({'to': [message]}, status_code=400)
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_senders_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)
send_notification_to_queue(saved_notification, service.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 save_email(self,
service_id,
notification_id,
encrypted_notification,
api_key_id=None,
key_type=KEY_TYPE_NORMAL):
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 not service_allowed_to_send_to(notification['to'], service, key_type):
current_app.logger.info(
"Email {} 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=EMAIL_TYPE,
api_key_id=api_key_id,
key_type=key_type,
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=template.get_reply_to_text())
provider_tasks.deliver_email.apply_async(
[str(saved_notification.id)],
queue=QueueNames.SEND_EMAIL
if not service.research_mode else QueueNames.RESEARCH_MODE)
current_app.logger.debug("Email {} created at {}".format(
saved_notification.id, saved_notification.created_at))
except SQLAlchemyError as e:
handle_exception(self, notification, notification_id, e)