def sample_email_notification(notify_db, notify_db_session):
created_at = datetime.utcnow()
service = sample_service(notify_db, notify_db_session)
template = sample_email_template(notify_db, notify_db_session, service=service)
job = sample_job(notify_db, notify_db_session, service=service, template=template)
notification_id = uuid.uuid4()
to = '*****@*****.**'
data = {
'id': notification_id,
'to': to,
'job_id': job.id,
'job': job,
'service_id': service.id,
'service': service,
'template': template,
'template_version': template.version,
'status': 'created',
'reference': None,
'created_at': created_at,
'billable_units': 0,
'personalisation': None,
'notification_type': template.template_type,
'api_key_id': None,
'key_type': KEY_TYPE_NORMAL,
'job_row_number': 1
}
notification = Notification(**data)
dao_create_notification(notification)
return notification
def sample_email_notification(notify_db_session):
created_at = datetime.utcnow()
service = create_service(check_if_service_exists=True)
template = create_template(service, template_type=EMAIL_TYPE)
job = create_job(template)
notification_id = uuid.uuid4()
to = '*****@*****.**'
data = {
'id': notification_id,
'to': to,
'job_id': job.id,
'job': job,
'service_id': service.id,
'service': service,
'template_id': template.id,
'template_version': template.version,
'status': 'created',
'reference': None,
'created_at': created_at,
'billable_units': 0,
'personalisation': None,
'notification_type': template.template_type,
'api_key_id': None,
'key_type': KEY_TYPE_NORMAL,
'job_row_number': 1
}
notification = Notification(**data)
dao_create_notification(notification)
return notification
def persist_notification(template_id,
template_version,
recipient,
service_id,
personalisation,
notification_type,
api_key_id,
key_type,
created_at=None,
job_id=None,
job_row_number=None,
reference=None,
notification_id=None):
notification = Notification(
id=notification_id,
template_id=template_id,
template_version=template_version,
to=recipient,
service_id=service_id,
personalisation=personalisation,
notification_type=notification_type,
api_key_id=api_key_id,
key_type=key_type,
created_at=created_at or datetime.utcnow(),
job_id=job_id,
job_row_number=job_row_number,
client_reference=reference
)
dao_create_notification(notification)
redis_store.incr(redis.daily_limit_cache_key(service_id))
return notification
def sample_email_notification(notify_db, notify_db_session):
created_at = datetime.utcnow()
service = create_service(check_if_service_exists=True)
template = sample_email_template(notify_db, notify_db_session, service=service)
job = sample_job(notify_db, notify_db_session, service=service, template=template)
notification_id = uuid.uuid4()
to = "*****@*****.**"
data = {
"id": notification_id,
"to": to,
"job_id": job.id,
"job": job,
"service_id": service.id,
"service": service,
"template_id": template.id,
"template_version": template.version,
"status": "created",
"provider_response": None,
"reference": None,
"created_at": created_at,
"billable_units": 0,
"personalisation": None,
"notification_type": template.template_type,
"api_key_id": None,
"key_type": KEY_TYPE_NORMAL,
"job_row_number": 1,
}
notification = Notification(**data)
dao_create_notification(notification)
return notification
def test_should_return_none_if_no_statistics_for_a_service_for_a_day(sample_template, mmg_provider):
data = _notification_json(sample_template)
notification = Notification(**data)
dao_create_notification(notification)
assert not dao_get_notification_statistics_for_service_and_day(
sample_template.service.id, (datetime.utcnow() - timedelta(days=1)).date())
def test_should_by_able_to_update_status_by_id_from_pending_to_delivered(sample_template, sample_job):
data = _notification_json(sample_template, job_id=sample_job.id, status='sending')
notification = Notification(**data)
dao_create_notification(notification)
assert Notification.query.get(notification.id).status == 'sending'
assert update_notification_status_by_id(notification_id=notification.id, status='pending')
assert Notification.query.get(notification.id).status == 'pending'
assert update_notification_status_by_id(notification.id, 'delivered')
assert Notification.query.get(notification.id).status == 'delivered'
def test_should_by_able_to_update_status_by_id_from_sending_to_permanent_failure(sample_template, sample_job):
data = _notification_json(sample_template, job_id=sample_job.id, status='sending')
notification = Notification(**data)
dao_create_notification(notification)
assert Notification.query.get(notification.id).status == 'sending'
assert update_notification_status_by_id(
notification.id,
status='permanent-failure'
)
assert Notification.query.get(notification.id).status == 'permanent-failure'
def test_should_by_able_to_update_status_by_reference(sample_email_template, ses_provider):
data = _notification_json(sample_email_template, status='sending')
notification = Notification(**data)
dao_create_notification(notification)
assert Notification.query.get(notification.id).status == "sending"
notification.reference = 'reference'
dao_update_notification(notification)
updated = update_notification_status_by_reference('reference', 'delivered')
assert updated.status == 'delivered'
assert Notification.query.get(notification.id).status == 'delivered'
def test_should_delete_notification_and_notification_history_for_id(notify_db, notify_db_session, sample_template):
data = _notification_json(sample_template)
notification = Notification(**data)
dao_create_notification(notification)
assert Notification.query.count() == 1
assert NotificationHistory.query.count() == 1
dao_delete_notifications_and_history_by_id(notification.id)
assert Notification.query.count() == 0
assert NotificationHistory.query.count() == 0
def test_save_notification(sample_template, sample_job, mmg_provider):
assert Notification.query.count() == 0
data = _notification_json(sample_template, sample_job.id)
notification_1 = Notification(**data)
notification_2 = Notification(**data)
dao_create_notification(notification_1)
assert Notification.query.count() == 1
dao_create_notification(notification_2)
assert Notification.query.count() == 2
def test_creating_notification_adds_to_notification_history(sample_template):
data = _notification_json(sample_template)
notification = Notification(**data)
dao_create_notification(notification)
assert Notification.query.count() == 1
hist = NotificationHistory.query.one()
assert hist.id == notification.id
assert hist.created_at == notification.created_at
assert hist.status == notification.status
assert not hasattr(hist, 'to')
assert not hasattr(hist, '_personalisation')
def test_not_save_notification_and_not_create_stats_on_commit_error(sample_template, sample_job, mmg_provider):
random_id = str(uuid.uuid4())
assert Notification.query.count() == 0
data = _notification_json(sample_template, job_id=random_id)
notification = Notification(**data)
with pytest.raises(SQLAlchemyError):
dao_create_notification(notification)
assert Notification.query.count() == 0
assert Job.query.get(sample_job.id).notifications_sent == 0
assert NotificationStatistics.query.count() == 0
assert TemplateStatistics.query.count() == 0
def test_should_by_able_to_update_status_by_id(sample_template, sample_job, mmg_provider):
with freeze_time('2000-01-01 12:00:00'):
data = _notification_json(sample_template, job_id=sample_job.id, status='sending')
notification = Notification(**data)
dao_create_notification(notification)
assert Notification.query.get(notification.id).status == 'sending'
with freeze_time('2000-01-02 12:00:00'):
updated = update_notification_status_by_id(notification.id, 'delivered')
assert updated.status == 'delivered'
assert updated.updated_at == datetime(2000, 1, 2, 12, 0, 0)
assert Notification.query.get(notification.id).status == 'delivered'
assert notification.updated_at == datetime(2000, 1, 2, 12, 0, 0)
def test_save_notification_no_job_id(sample_template, mmg_provider):
assert Notification.query.count() == 0
data = _notification_json(sample_template)
notification = Notification(**data)
dao_create_notification(notification)
assert Notification.query.count() == 1
notification_from_db = Notification.query.all()[0]
assert notification_from_db.id
assert data['to'] == notification_from_db.to
assert data['service'] == notification_from_db.service
assert data['template'] == notification_from_db.template
assert data['template_version'] == notification_from_db.template_version
assert notification_from_db.status == 'created'
assert data.get('job_id') is None
def sample_notification(notify_db_session):
created_at = datetime.utcnow()
service = create_service(check_if_service_exists=True)
template = create_template(service=service)
api_key = ApiKey.query.filter(ApiKey.service == template.service,
ApiKey.key_type == KEY_TYPE_NORMAL).first()
if not api_key:
api_key = create_api_key(template.service, key_type=KEY_TYPE_NORMAL)
notification_id = uuid.uuid4()
to = '+447700900855'
data = {
'id': notification_id,
'to': to,
'job_id': None,
'job': None,
'service_id': service.id,
'service': service,
'template_id': template.id,
'template_version': template.version,
'status': 'created',
'reference': None,
'created_at': created_at,
'sent_at': None,
'billable_units': 1,
'personalisation': None,
'notification_type': template.template_type,
'api_key': api_key,
'api_key_id': api_key and api_key.id,
'key_type': api_key.key_type,
'sent_by': None,
'updated_at': None,
'client_reference': None,
'rate_multiplier': 1.0,
'normalised_to': None,
'postage': None,
}
notification = Notification(**data)
dao_create_notification(notification)
return notification
def test_save_notification_and_create_email(sample_email_template, sample_job, ses_provider):
assert Notification.query.count() == 0
assert NotificationStatistics.query.count() == 0
assert TemplateStatistics.query.count() == 0
data = _notification_json(sample_email_template, job_id=sample_job.id)
notification = Notification(**data)
dao_create_notification(notification)
assert Notification.query.count() == 1
notification_from_db = Notification.query.all()[0]
assert notification_from_db.id
assert data['to'] == notification_from_db.to
assert data['job_id'] == notification_from_db.job_id
assert data['service'] == notification_from_db.service
assert data['template'] == notification_from_db.template
assert data['template_version'] == notification_from_db.template_version
assert data['created_at'] == notification_from_db.created_at
assert notification_from_db.status == 'created'
def test_should_delete_no_notifications_or_notification_historys_if_no_matching_ids(
notify_db,
notify_db_session,
sample_template
):
id_1 = uuid.uuid4()
id_2 = uuid.uuid4()
data_1 = _notification_json(sample_template, id=id_1)
notification_1 = Notification(**data_1)
dao_create_notification(notification_1)
assert Notification.query.count() == 1
assert NotificationHistory.query.count() == 1
dao_delete_notifications_and_history_by_id(id_2)
assert Notification.query.count() == 1
assert NotificationHistory.query.count() == 1
def test_save_notification_and_increment_job(sample_template, sample_job, mmg_provider):
assert Notification.query.count() == 0
data = _notification_json(sample_template, job_id=sample_job.id)
notification = Notification(**data)
dao_create_notification(notification)
assert Notification.query.count() == 1
notification_from_db = Notification.query.all()[0]
assert notification_from_db.id
assert data['to'] == notification_from_db.to
assert data['job_id'] == notification_from_db.job_id
assert data['service'] == notification_from_db.service
assert data['template'] == notification_from_db.template
assert data['template_version'] == notification_from_db.template_version
assert data['created_at'] == notification_from_db.created_at
assert notification_from_db.status == 'created'
notification_2 = Notification(**data)
dao_create_notification(notification_2)
assert Notification.query.count() == 2
def test_should_delete_only_notification_and_notification_history_with_id(notify_db, notify_db_session,
sample_template):
id_1 = uuid.uuid4()
id_2 = uuid.uuid4()
data_1 = _notification_json(sample_template, id=id_1)
data_2 = _notification_json(sample_template, id=id_2)
notification_1 = Notification(**data_1)
notification_2 = Notification(**data_2)
dao_create_notification(notification_1)
dao_create_notification(notification_2)
assert Notification.query.count() == 2
assert NotificationHistory.query.count() == 2
dao_delete_notifications_and_history_by_id(notification_1.id)
assert Notification.query.count() == 1
assert NotificationHistory.query.count() == 1
assert Notification.query.first().id == notification_2.id
assert NotificationHistory.query.first().id == notification_2.id
def test_save_notification_and_increment_correct_job(notify_db, notify_db_session, sample_template, mmg_provider):
from tests.app.conftest import sample_job
job_1 = sample_job(notify_db, notify_db_session, sample_template.service)
job_2 = sample_job(notify_db, notify_db_session, sample_template.service)
assert Notification.query.count() == 0
data = _notification_json(sample_template, job_id=job_1.id)
notification = Notification(**data)
dao_create_notification(notification)
assert Notification.query.count() == 1
notification_from_db = Notification.query.all()[0]
assert notification_from_db.id
assert data['to'] == notification_from_db.to
assert data['job_id'] == notification_from_db.job_id
assert data['service'] == notification_from_db.service
assert data['template'] == notification_from_db.template
assert data['template_version'] == notification_from_db.template_version
assert data['created_at'] == notification_from_db.created_at
assert notification_from_db.status == 'created'
assert job_1.id != job_2.id
def test_should_be_able_to_get_all_statistics_for_a_service(sample_template, mmg_provider):
data = _notification_json(sample_template)
notification_1 = Notification(**data)
notification_2 = Notification(**data)
notification_3 = Notification(**data)
dao_create_notification(notification_1)
dao_create_notification(notification_2)
dao_create_notification(notification_3)
def sample_notification(
notify_db,
notify_db_session,
service=None,
template=None,
job=None,
job_row_number=None,
to_field=None,
status="created",
provider_response=None,
reference=None,
created_at=None,
sent_at=None,
billable_units=1,
personalisation=None,
api_key=None,
key_type=KEY_TYPE_NORMAL,
sent_by=None,
international=False,
client_reference=None,
rate_multiplier=1.0,
scheduled_for=None,
normalised_to=None,
postage=None,
):
if created_at is None:
created_at = datetime.utcnow()
if service is None:
service = create_service(check_if_service_exists=True)
if template is None:
template = create_template(service=service)
if job is None and api_key is None:
# we didn't specify in test - lets create it
api_key = ApiKey.query.filter(ApiKey.service == template.service, ApiKey.key_type == key_type).first()
if not api_key:
api_key = create_api_key(template.service, key_type=key_type)
notification_id = uuid.uuid4()
if to_field:
to = to_field
else:
to = "+16502532222"
data = {
"id": notification_id,
"to": to,
"job_id": job.id if job else None,
"job": job,
"service_id": service.id,
"service": service,
"template_id": template.id,
"template_version": template.version,
"status": status,
"provider_response": provider_response,
"reference": reference,
"created_at": created_at,
"sent_at": sent_at,
"billable_units": billable_units,
"personalisation": personalisation,
"notification_type": template.template_type,
"api_key": api_key,
"api_key_id": api_key and api_key.id,
"key_type": api_key.key_type if api_key else key_type,
"sent_by": sent_by,
"updated_at": created_at if status in NOTIFICATION_STATUS_TYPES_COMPLETED else None,
"client_reference": client_reference,
"rate_multiplier": rate_multiplier,
"normalised_to": normalised_to,
"postage": postage,
}
if job_row_number is not None:
data["job_row_number"] = job_row_number
notification = Notification(**data)
dao_create_notification(notification)
if scheduled_for:
scheduled_notification = ScheduledNotification(
id=uuid.uuid4(),
notification_id=notification.id,
scheduled_for=datetime.strptime(scheduled_for, "%Y-%m-%d %H:%M"),
)
if status != "created":
scheduled_notification.pending = False
db.session.add(scheduled_notification)
db.session.commit()
return notification
def persist_notification(
*,
template_id,
template_version,
recipient,
service,
personalisation,
notification_type,
api_key_id,
key_type,
created_at=None,
job_id=None,
job_row_number=None,
reference=None,
client_reference=None,
notification_id=None,
simulated=False,
created_by_id=None,
status=NOTIFICATION_CREATED,
reply_to_text=None,
status_callback_url=None,
status_callback_bearer_token=None,
):
notification_created_at = created_at or datetime.utcnow()
if not notification_id:
notification_id = uuid.uuid4()
notification = Notification(
id=notification_id,
template_id=template_id,
template_version=template_version,
to=recipient,
service_id=service.id,
service=service,
personalisation=personalisation,
notification_type=notification_type,
api_key_id=api_key_id,
key_type=key_type,
created_at=notification_created_at,
job_id=job_id,
job_row_number=job_row_number,
client_reference=client_reference,
reference=reference,
created_by_id=created_by_id,
status=status,
reply_to_text=reply_to_text,
status_callback_url=status_callback_url,
status_callback_bearer_token=status_callback_bearer_token,
)
if notification_type == SMS_TYPE:
formatted_recipient = validate_and_format_phone_number_and_allow_international(
recipient)
recipient_info = get_international_phone_info(formatted_recipient)
notification.normalised_to = formatted_recipient
notification.international = recipient_info.international
notification.phone_prefix = recipient_info.country_prefix
notification.rate_multiplier = recipient_info.billable_units
# We can't use a sender name/ID if the text is sending to an
# international number. At the time of writing, this is because Telstra
# won't send to an international number unless sending from the number
# associated with the subscription. Additionally, Twilio can send from a
# sender name/ID, however, it requires configuration and it depends on
# the countries in play.
if notification.international:
notification.reply_to_text = None
elif notification_type == EMAIL_TYPE:
notification.normalised_to = format_email_address(notification.to)
# if simulated create a Notification model to return but do not persist the Notification to the dB
if not simulated:
dao_create_notification(notification)
if key_type != KEY_TYPE_TEST:
if redis_store.get(redis.daily_limit_cache_key(service.id)):
redis_store.incr(redis.daily_limit_cache_key(service.id))
if redis_store.get_all_from_hash(
cache_key_for_service_template_counter(service.id)):
redis_store.increment_hash_value(
cache_key_for_service_template_counter(service.id),
template_id)
increment_template_usage_cache(service.id, template_id,
notification_created_at)
current_app.logger.info("{} {} created at {}".format(
notification_type, notification_id, notification_created_at))
return notification
def persist_notification(*,
template_id,
template_version,
recipient,
service,
personalisation,
notification_type,
api_key_id,
key_type,
created_at=None,
job_id=None,
job_row_number=None,
reference=None,
client_reference=None,
notification_id=None,
simulated=False,
created_by_id=None,
status=NOTIFICATION_CREATED,
reply_to_text=None,
billable_units=None,
postage=None,
document_download_count=None,
updated_at=None):
notification_created_at = created_at or datetime.utcnow()
if not notification_id:
notification_id = uuid.uuid4()
notification = Notification(
id=notification_id,
template_id=template_id,
template_version=template_version,
to=recipient,
service_id=service.id,
personalisation=personalisation,
notification_type=notification_type,
api_key_id=api_key_id,
key_type=key_type,
created_at=notification_created_at,
job_id=job_id,
job_row_number=job_row_number,
client_reference=client_reference,
reference=reference,
created_by_id=created_by_id,
status=status,
reply_to_text=reply_to_text,
billable_units=billable_units,
document_download_count=document_download_count,
updated_at=updated_at)
if notification_type == SMS_TYPE:
formatted_recipient = validate_and_format_phone_number(
recipient, international=True)
recipient_info = get_international_phone_info(formatted_recipient)
notification.normalised_to = formatted_recipient
notification.international = recipient_info.international
notification.phone_prefix = recipient_info.country_prefix
notification.rate_multiplier = recipient_info.billable_units
elif notification_type == EMAIL_TYPE:
notification.normalised_to = format_email_address(notification.to)
elif notification_type == LETTER_TYPE:
notification.postage = postage
notification.international = postage in INTERNATIONAL_POSTAGE_TYPES
notification.normalised_to = ''.join(notification.to.split()).lower()
# if simulated create a Notification model to return but do not persist the Notification to the dB
if not simulated:
dao_create_notification(notification)
# Only keep track of the daily limit for trial mode services.
if service.restricted and key_type != KEY_TYPE_TEST:
if redis_store.get(redis.daily_limit_cache_key(service.id)):
redis_store.incr(redis.daily_limit_cache_key(service.id))
current_app.logger.info("{} {} created at {}".format(
notification_type, notification_id, notification_created_at))
return notification
def create_notification(
template=None,
job=None,
job_row_number=None,
to_field=None,
status='created',
reference=None,
created_at=None,
sent_at=None,
updated_at=None,
billable_units=1,
personalisation=None,
api_key=None,
key_type=KEY_TYPE_NORMAL,
sent_by=None,
client_reference=None,
rate_multiplier=None,
international=False,
phone_prefix=None,
scheduled_for=None,
normalised_to=None,
one_off=False,
reply_to_text=None,
created_by_id=None,
postage=None
):
assert job or template
if job:
template = job.template
if created_at is None:
created_at = datetime.utcnow()
if to_field is None:
to_field = '+16502532222' if template.template_type == SMS_TYPE else '*****@*****.**'
if status != 'created':
sent_at = sent_at or datetime.utcnow()
updated_at = updated_at or datetime.utcnow()
if not one_off and (job is None and api_key is None):
# we didn't specify in test - lets create it
api_key = ApiKey.query.filter(ApiKey.service == template.service, ApiKey.key_type == key_type).first()
if not api_key:
api_key = create_api_key(template.service, key_type=key_type)
if template.template_type == 'letter' and postage is None:
postage = 'second'
data = {
'id': uuid.uuid4(),
'to': to_field,
'job_id': job and job.id,
'job': job,
'service_id': template.service.id,
'service': template.service,
'template_id': template.id,
'template_version': template.version,
'status': status,
'reference': reference,
'created_at': created_at,
'sent_at': sent_at,
'billable_units': billable_units,
'personalisation': personalisation,
'notification_type': template.template_type,
'api_key': api_key,
'api_key_id': api_key and api_key.id,
'key_type': api_key.key_type if api_key else key_type,
'sent_by': sent_by,
'updated_at': updated_at,
'client_reference': client_reference,
'job_row_number': job_row_number,
'rate_multiplier': rate_multiplier,
'international': international,
'phone_prefix': phone_prefix,
'normalised_to': normalised_to,
'reply_to_text': reply_to_text,
'created_by_id': created_by_id,
'postage': postage
}
notification = Notification(**data)
dao_create_notification(notification)
if scheduled_for:
scheduled_notification = ScheduledNotification(id=uuid.uuid4(),
notification_id=notification.id,
scheduled_for=datetime.strptime(scheduled_for,
"%Y-%m-%d %H:%M"))
if status != 'created':
scheduled_notification.pending = False
dao_created_scheduled_notification(scheduled_notification)
return notification
def sample_notification(
notify_db,
notify_db_session,
service=None,
template=None,
job=None,
job_row_number=None,
to_field=None,
status='created',
reference=None,
created_at=None,
sent_at=None,
billable_units=1,
personalisation=None,
api_key=None,
key_type=KEY_TYPE_NORMAL,
sent_by=None,
international=False,
client_reference=None,
rate_multiplier=1.0,
scheduled_for=None,
normalised_to=None,
postage=None,
):
if created_at is None:
created_at = datetime.utcnow()
if service is None:
service = create_service(check_if_service_exists=True)
if template is None:
template = create_template(service=service)
if job is None and api_key is None:
# we didn't specify in test - lets create it
api_key = ApiKey.query.filter(ApiKey.service == template.service,
ApiKey.key_type == key_type).first()
if not api_key:
api_key = create_api_key(template.service, key_type=key_type)
notification_id = uuid.uuid4()
if to_field:
to = to_field
else:
to = '+16502532222'
data = {
'id':
notification_id,
'to':
to,
'job_id':
job.id if job else None,
'job':
job,
'service_id':
service.id,
'service':
service,
'template_id':
template.id,
'template_version':
template.version,
'status':
status,
'reference':
reference,
'created_at':
created_at,
'sent_at':
sent_at,
'billable_units':
billable_units,
'personalisation':
personalisation,
'notification_type':
template.template_type,
'api_key':
api_key,
'api_key_id':
api_key and api_key.id,
'key_type':
api_key.key_type if api_key else key_type,
'sent_by':
sent_by,
'updated_at':
created_at if status in NOTIFICATION_STATUS_TYPES_COMPLETED else None,
'client_reference':
client_reference,
'rate_multiplier':
rate_multiplier,
'normalised_to':
normalised_to,
'postage':
postage,
}
if job_row_number is not None:
data['job_row_number'] = job_row_number
notification = Notification(**data)
dao_create_notification(notification)
if scheduled_for:
scheduled_notification = ScheduledNotification(
id=uuid.uuid4(),
notification_id=notification.id,
scheduled_for=datetime.strptime(scheduled_for, "%Y-%m-%d %H:%M"))
if status != 'created':
scheduled_notification.pending = False
db.session.add(scheduled_notification)
db.session.commit()
return notification
def create_notification(
template=None,
job=None,
job_row_number=None,
to_field=None,
status="created",
reference=None,
created_at=None,
sent_at=None,
updated_at=None,
billable_units=1,
personalisation=None,
api_key=None,
key_type=KEY_TYPE_NORMAL,
sent_by=None,
client_reference=None,
rate_multiplier=None,
international=False,
phone_prefix=None,
scheduled_for=None,
normalised_to=None,
one_off=False,
reply_to_text=None,
created_by_id=None,
postage=None,
):
assert job or template
if job:
template = job.template
if created_at is None:
created_at = datetime.utcnow()
if to_field is None:
to_field = "+16502532222" if template.template_type == SMS_TYPE else "*****@*****.**"
if status != "created":
sent_at = sent_at or datetime.utcnow()
updated_at = updated_at or datetime.utcnow()
if not one_off and (job is None and api_key is None):
# we didn't specify in test - lets create it
api_key = ApiKey.query.filter(ApiKey.service == template.service,
ApiKey.key_type == key_type).first()
if not api_key:
api_key = create_api_key(template.service, key_type=key_type)
if template.template_type == "letter" and postage is None:
postage = "second"
data = {
"id": uuid.uuid4(),
"to": to_field,
"job_id": job and job.id,
"job": job,
"service_id": template.service.id,
"service": template.service,
"template_id": template.id,
"template_version": template.version,
"status": status,
"reference": reference,
"created_at": created_at,
"sent_at": sent_at,
"billable_units": billable_units,
"personalisation": personalisation,
"notification_type": template.template_type,
"api_key": api_key,
"api_key_id": api_key and api_key.id,
"key_type": api_key.key_type if api_key else key_type,
"sent_by": sent_by,
"updated_at": updated_at,
"client_reference": client_reference,
"job_row_number": job_row_number,
"rate_multiplier": rate_multiplier,
"international": international,
"phone_prefix": phone_prefix,
"normalised_to": normalised_to,
"reply_to_text": reply_to_text,
"created_by_id": created_by_id,
"postage": postage,
}
notification = Notification(**data)
dao_create_notification(notification)
if scheduled_for:
scheduled_notification = ScheduledNotification(
id=uuid.uuid4(),
notification_id=notification.id,
scheduled_for=datetime.strptime(scheduled_for, "%Y-%m-%d %H:%M"),
)
if status != "created":
scheduled_notification.pending = False
dao_created_scheduled_notification(scheduled_notification)
return notification
def persist_notification(*,
template_id,
template_version,
recipient=None,
service,
personalisation,
notification_type,
api_key_id,
key_type,
created_at=None,
job_id=None,
job_row_number=None,
reference=None,
client_reference=None,
notification_id=None,
simulated=False,
created_by_id=None,
status=NOTIFICATION_CREATED,
reply_to_text=None,
billable_units=None,
postage=None,
template_postage=None,
recipient_identifier=None):
notification_created_at = created_at or datetime.utcnow()
if not notification_id:
notification_id = uuid.uuid4()
notification = Notification(id=notification_id,
template_id=template_id,
template_version=template_version,
to=recipient,
service_id=service.id,
service=service,
personalisation=personalisation,
notification_type=notification_type,
api_key_id=api_key_id,
key_type=key_type,
created_at=notification_created_at,
job_id=job_id,
job_row_number=job_row_number,
client_reference=client_reference,
reference=reference,
created_by_id=created_by_id,
status=status,
reply_to_text=reply_to_text,
billable_units=billable_units)
if accept_recipient_identifiers_enabled() and recipient_identifier:
_recipient_identifier = RecipientIdentifier(
notification_id=notification_id,
id_type=recipient_identifier['id_type'],
id_value=recipient_identifier['id_value'])
notification.recipient_identifiers.set(_recipient_identifier)
if notification_type == SMS_TYPE and notification.to:
formatted_recipient = validate_and_format_phone_number(
recipient, international=True)
recipient_info = get_international_phone_info(formatted_recipient)
notification.normalised_to = formatted_recipient
notification.international = recipient_info.international
notification.phone_prefix = recipient_info.country_prefix
notification.rate_multiplier = recipient_info.billable_units
elif notification_type == EMAIL_TYPE and notification.to:
notification.normalised_to = format_email_address(notification.to)
elif notification_type == LETTER_TYPE:
notification.postage = postage or template_postage
# if simulated create a Notification model to return but do not persist the Notification to the dB
if not simulated:
dao_create_notification(notification)
if key_type != KEY_TYPE_TEST:
if redis_store.get(redis.daily_limit_cache_key(service.id)):
redis_store.incr(redis.daily_limit_cache_key(service.id))
current_app.logger.info("{} {} created at {}".format(
notification_type, notification_id, notification_created_at))
return notification
def sample_notification(notify_db,
notify_db_session,
service=None,
template=None,
job=None,
job_row_number=None,
to_field=None,
status='created',
reference=None,
created_at=None,
sent_at=None,
billable_units=1,
create=True,
personalisation=None,
api_key_id=None,
key_type=KEY_TYPE_NORMAL,
sent_by=None,
client_reference=None):
if created_at is None:
created_at = datetime.utcnow()
if service is None:
service = sample_service(notify_db, notify_db_session)
if template is None:
template = sample_template(notify_db, notify_db_session, service=service)
notification_id = uuid.uuid4()
if to_field:
to = to_field
else:
to = '+447700900855'
data = {
'id': notification_id,
'to': to,
'job_id': job.id if job else None,
'job': job,
'service_id': service.id,
'service': service,
'template_id': template.id if template else None,
'template': template,
'template_version': template.version,
'status': status,
'reference': reference,
'created_at': created_at,
'sent_at': sent_at,
'billable_units': billable_units,
'personalisation': personalisation,
'notification_type': template.template_type,
'api_key_id': api_key_id,
'key_type': key_type,
'sent_by': sent_by,
'updated_at': created_at if status in NOTIFICATION_STATUS_TYPES_COMPLETED else None,
'client_reference': client_reference
}
if job_row_number:
data['job_row_number'] = job_row_number
notification = Notification(**data)
if create:
dao_create_notification(notification)
return notification
