def _check_and_queue_callback_task(notification):
# queue callback task only if the service_callback_api exists
service_callback_api = get_service_delivery_status_callback_api_for_service(service_id=notification.service_id)
if service_callback_api:
notification_data = create_delivery_status_callback_data(notification, service_callback_api)
send_delivery_status_to_service.apply_async([str(notification.id), notification_data],
queue=QueueNames.CALLBACKS)
def test_ses_callback_should_update_notification_status(
client, notify_db_session, sample_email_template, mocker):
with freeze_time('2001-01-01T12:00:00'):
mocker.patch('app.statsd_client.incr')
mocker.patch('app.statsd_client.timing_with_dates')
send_mock = mocker.patch(
'app.celery.service_callback_tasks.send_delivery_status_to_service.apply_async'
)
notification = create_notification(
template=sample_email_template,
status='sending',
reference='ref',
)
callback_api = create_service_callback_api(
service=sample_email_template.service,
url="https://original_url.com")
assert get_notification_by_id(notification.id).status == 'sending'
assert process_ses_results(ses_notification_callback(reference='ref'))
assert get_notification_by_id(notification.id).status == 'delivered'
statsd_client.timing_with_dates.assert_any_call(
"callback.ses.elapsed-time", datetime.utcnow(),
notification.sent_at)
statsd_client.incr.assert_any_call("callback.ses.delivered")
updated_notification = Notification.query.get(notification.id)
encrypted_data = create_delivery_status_callback_data(
updated_notification, callback_api)
send_mock.assert_called_once_with(
[str(notification.id), encrypted_data], queue="service-callbacks")
def test_outcome_statistics_called_for_successful_callback(
sample_notification, mocker):
mocker.patch(
'app.notifications.process_client_response.notifications_dao.update_notification_status_by_id',
return_value=sample_notification)
send_mock = mocker.patch(
'app.celery.service_callback_tasks.send_delivery_status_to_service.apply_async'
)
callback_api = create_service_callback_api(
service=sample_notification.service,
url="https://original_url.com",
notification_statuses=NOTIFICATION_STATUS_TYPES)
reference = str(uuid.uuid4())
success, error = process_sms_client_response(status='3',
provider_reference=reference,
client_name='MMG')
assert success == "MMG callback succeeded. reference {} updated".format(
str(reference))
assert error is None
encrypted_data = create_delivery_status_callback_data(
sample_notification, callback_api)
send_mock.assert_called_once_with(
[str(sample_notification.id), encrypted_data],
queue="service-callbacks")
def process_service_callback(notification):
if notification.status != NOTIFICATION_PENDING:
service_callback_api = get_service_delivery_status_callback_api_for_service(service_id=notification.service_id)
# queue callback task only if the service_callback_api exists
if service_callback_api:
encrypted_notification = create_delivery_status_callback_data(notification, service_callback_api)
send_delivery_status_to_service.apply_async([notification.id, encrypted_notification],
queue=QueueNames.CALLBACKS)
def test_outcome_statistics_called_for_successful_callback(sample_notification, mocker):
send_mock = mocker.patch(
'app.celery.service_callback_tasks.send_delivery_status_to_service.apply_async'
)
callback_api = create_service_callback_api(service=sample_notification.service, url="https://original_url.com")
reference = str(sample_notification.id)
process_sms_client_response('3', reference, 'MMG')
encrypted_data = create_delivery_status_callback_data(sample_notification, callback_api)
send_mock.assert_called_once_with([reference, encrypted_data],
queue="service-callbacks")
def test_timeout_notifications_sends_status_update_to_service(client, sample_template, mocker):
callback_api = create_service_callback_api(service=sample_template.service)
mocked = mocker.patch('app.celery.service_callback_tasks.send_delivery_status_to_service.apply_async')
notification = create_notification(
template=sample_template,
status='sending',
created_at=datetime.utcnow() - timedelta(
seconds=current_app.config.get('SENDING_NOTIFICATIONS_TIMEOUT_PERIOD') + 10))
timeout_notifications()
encrypted_data = create_delivery_status_callback_data(notification, callback_api)
mocked.assert_called_once_with([str(notification.id), encrypted_data], queue=QueueNames.CALLBACKS)
def _process_for_status(notification_status,
client_name,
provider_reference,
detailed_status_code=None):
# record stats
if client_name == 'Twilio':
notification = notifications_dao.update_notification_status_by_reference(
reference=provider_reference, status=notification_status)
else:
notification = notifications_dao.update_notification_status_by_id(
notification_id=provider_reference,
status=notification_status,
sent_by=client_name.lower(),
detailed_status_code=detailed_status_code)
if not notification:
return
statsd_client.incr('callback.{}.{}'.format(client_name.lower(),
notification_status))
if notification.sent_at:
statsd_client.timing_with_dates(
'callback.{}.elapsed-time'.format(client_name.lower()),
datetime.utcnow(), notification.sent_at)
if notification.billable_units == 0:
service = notification.service
template_model = dao_get_template_by_id(notification.template_id,
notification.template_version)
template = SMSMessageTemplate(
template_model.__dict__,
values=notification.personalisation,
prefix=service.name,
show_prefix=service.prefix_sms,
)
notification.billable_units = template.fragment_count
notifications_dao.dao_update_notification(notification)
if notification_status != NOTIFICATION_PENDING:
service_callback_api = get_service_delivery_status_callback_api_for_service(
service_id=notification.service_id)
# queue callback task only if the service_callback_api exists
if service_callback_api:
encrypted_notification = create_delivery_status_callback_data(
notification, service_callback_api)
send_delivery_status_to_service.apply_async(
[str(notification.id), encrypted_notification],
queue=QueueNames.CALLBACKS)
def check_for_callback_and_send_delivery_status_to_service(notification):
service_callback_api = get_service_delivery_status_callback_api_for_service(
service_id=notification.service_id)
# If a status callback was provided on the notification or if the service
# has a service_callback_api record, then queue the callback task.
if (notification.status_callback_url and
notification.status_callback_bearer_token) or service_callback_api:
encrypted_notification = create_delivery_status_callback_data(
notification, service_callback_api)
send_delivery_status_to_service.apply_async(
[str(notification.id), encrypted_notification],
queue=QueueNames.CALLBACKS,
)
def timeout_notifications():
technical_failure_notifications, temporary_failure_notifications = \
dao_timeout_notifications(current_app.config.get('SENDING_NOTIFICATIONS_TIMEOUT_PERIOD'))
notifications = technical_failure_notifications + temporary_failure_notifications
for notification in notifications:
# queue callback task only if the service_callback_api exists
service_callback_api = get_service_delivery_status_callback_api_for_service(service_id=notification.service_id)
if service_callback_api:
encrypted_notification = create_delivery_status_callback_data(notification, service_callback_api)
send_delivery_status_to_service.apply_async([str(notification.id), encrypted_notification],
queue=QueueNames.CALLBACKS)
current_app.logger.info(
"Timeout period reached for {} notifications, status has been updated.".format(len(notifications)))
if technical_failure_notifications:
message = "{} notifications have been updated to technical-failure because they " \
"have timed out and are still in created.Notification ids: {}".format(
len(technical_failure_notifications), [str(x.id) for x in technical_failure_notifications])
raise NotificationTechnicalFailureException(message)
def check_for_callback_and_send_delivery_status_to_service(notification):
service_callback_api = get_service_delivery_status_callback_api_for_service(
service_id=notification.service_id)
# If a status callback was provided on the notification or if the service
# has a service_callback_api record, then queue the callback task.
if (notification.status_callback_url and
notification.status_callback_bearer_token) or service_callback_api:
if dao_service_callbacks_are_failing(notification.service_id):
current_app.logger.warning(
f"send_delivery_status_to_service not called for notification_id: {notification.id} due to failing service_id: {notification.service_id}"
)
return
encrypted_notification = create_delivery_status_callback_data(
notification, service_callback_api)
send_delivery_status_to_service.apply_async(
[str(notification.id), encrypted_notification],
queue=QueueNames.CALLBACKS,
)
def test_delivery_status_callback_calls_for_notification_with_callback(
sample_notification_with_callback, mocker):
mocker.patch(
'app.notifications.process_client_response.notifications_dao.update_notification_status_by_id',
return_value=sample_notification_with_callback)
send_mock = mocker.patch(
'app.celery.service_callback_tasks.send_delivery_status_to_service.apply_async'
)
reference = str(uuid.uuid4())
success, error = process_sms_client_response(status='delivered',
provider_reference=reference,
client_name='twilio')
assert success == "twilio callback succeeded. reference {} updated".format(
str(reference))
assert error is None
encrypted_data = create_delivery_status_callback_data(
sample_notification_with_callback, None)
send_mock.assert_called_once_with(
[str(sample_notification_with_callback.id), encrypted_data],
queue="service-callbacks",
)
def test_ses_callback_should_call_send_delivery_status_to_service(
client, sample_email_template, mocker):
send_mock = mocker.patch(
'app.celery.service_callback_tasks.send_delivery_status_to_service.apply_async'
)
notification = create_notification(
template=sample_email_template,
status='sending',
reference='ref',
)
callback_api = create_service_callback_api(
service=sample_email_template.service, url="https://original_url.com")
mocked_callback_api = mocker.Mock(url=callback_api.url,
bearer_token=callback_api.bearer_token)
process_ses_receipts_tasks.process_ses_results(
ses_notification_callback(reference='ref'))
updated_notification = Notification.query.get(notification.id)
encrypted_data = create_delivery_status_callback_data(
updated_notification, mocked_callback_api)
send_mock.assert_called_once_with([str(notification.id), encrypted_data],
queue="service-callbacks")
def replay_service_callbacks(file_name, service_id):
print("Start send service callbacks for service: ", service_id)
callback_api = get_service_delivery_status_callback_api_for_service(
service_id=service_id)
if not callback_api:
print("Callback api was not found for service: {}".format(service_id))
return
errors = []
notifications = []
file = open(file_name)
for ref in file:
try:
notification = Notification.query.filter_by(
client_reference=ref.strip()).one()
notifications.append(notification)
except NoResultFound:
errors.append(
"Reference: {} was not found in notifications.".format(ref))
for e in errors:
print(e)
if errors:
raise Exception(
"Some notifications for the given references were not found")
for n in notifications:
encrypted_status_update = create_delivery_status_callback_data(
n, callback_api)
send_delivery_status_to_service.apply_async(
[str(n.id), encrypted_status_update], queue=QueueNames.CALLBACKS)
print(
"Replay service status for service: {}. Sent {} notification status updates to the queue"
.format(service_id, len(notifications)))
def _process_for_status(notification_status, client_name, provider_reference):
# record stats
notification = notifications_dao.update_notification_status_by_id(
provider_reference, notification_status)
if not notification:
current_app.logger.warning(
"{} callback failed: notification {} either not found or already updated "
"from sending. Status {}".format(client_name, provider_reference,
notification_status))
return
statsd_client.incr('callback.{}.{}'.format(client_name.lower(),
notification_status))
if not notification.sent_by:
set_notification_sent_by(notification, client_name.lower())
if notification.sent_at:
statsd_client.timing_with_dates(
'callback.{}.elapsed-time'.format(client_name.lower()),
datetime.utcnow(), notification.sent_at)
# queue callback task only if the service_callback_api exists
service_callback_api = get_service_delivery_status_callback_api_for_service(
service_id=notification.service_id)
if service_callback_api:
encrypted_notification = create_delivery_status_callback_data(
notification, service_callback_api)
send_delivery_status_to_service.apply_async(
[str(notification.id), encrypted_notification],
queue=QueueNames.CALLBACKS)
success = "{} callback succeeded. reference {} updated".format(
client_name, provider_reference)
return success
def _set_up_data_for_status_update(callback_api, notification):
return create_delivery_status_callback_data(notification, callback_api)
