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 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 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_get_service_delivery_status_callback_api_for_service(sample_service):
service_callback_api = create_service_callback_api(service=sample_service)
result = get_service_delivery_status_callback_api_for_service(sample_service.id)
assert result.id == service_callback_api.id
assert result.url == service_callback_api.url
assert result.bearer_token == service_callback_api.bearer_token
assert result.created_at == service_callback_api.created_at
assert result.updated_at == service_callback_api.updated_at
assert result.updated_by_id == service_callback_api.updated_by_id
def test_no_service_delivery_status_callback_api_by_status(
sample_service, saved_notification_statuses, query_notification_statuses
):
create_service_callback_api(
service=sample_service, notification_statuses=saved_notification_statuses
)
for notification_status in query_notification_statuses:
result = get_service_delivery_status_callback_api_for_service(
sample_service.id,
notification_status=notification_status
)
assert result is None
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 test_existing_service_delivery_status_callback_api_by_status(sample_service, notification_statuses):
service_callback_api = create_service_callback_api(
service=sample_service, notification_statuses=notification_statuses
)
for notification_status in notification_statuses:
result = get_service_delivery_status_callback_api_for_service(
sample_service.id,
notification_status=notification_status
)
assert result.id == service_callback_api.id
assert result.url == service_callback_api.url
assert result.bearer_token == service_callback_api.bearer_token
assert result.created_at == service_callback_api.created_at
assert result.updated_at == service_callback_api.updated_at
assert result.updated_by_id == service_callback_api.updated_by_id
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:
data = {
"notification_id": str(n.id),
"notification_client_reference": n.client_reference,
"notification_to": n.to,
"notification_status": n.status,
"notification_created_at": n.created_at.strftime(DATETIME_FORMAT),
"notification_updated_at": n.updated_at.strftime(DATETIME_FORMAT),
"notification_sent_at": n.sent_at.strftime(DATETIME_FORMAT),
"notification_type": n.notification_type,
"service_callback_api_url": callback_api.url,
"service_callback_api_bearer_token": callback_api.bearer_token,
}
encrypted_status_update = encryption.encrypt(data)
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 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 _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_encrypted_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 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_shortnumber_keyword_client_response(service, short_number, from_number, body, received_at,
provider_ref, client_name):
success = None
errors = None
parsed_datetime = iso8601.parse_date(received_at).replace(tzinfo=None)
parsed_datetime = convert_local_timezone_to_utc(parsed_datetime)
inbound = create_inbound_sms_keyword_object(service=service,
content=body,
from_number=from_number,
provider_ref=provider_ref,
date_received=parsed_datetime,
provider_name=client_name)
service_callback_api = get_service_delivery_status_callback_api_for_service(service_id=service.id)
# queue callback task only if the service_callback_api exists
if service_callback_api:
encrypted_data = create_shortnumber_keyword_status_callback_data(inbound, service_callback_api)
send_keyword_status_to_service.apply_async([encrypted_data],
queue=QueueNames.CALLBACKS)
success = "{} callback succeeded. keyword stored".format(client_name)
return success, errors
