def send_uploaded_letter(service_id, file_id):
if not (current_service.has_permission('letter')
and current_service.has_permission('upload_letters')):
abort(403)
metadata = get_letter_metadata(service_id, file_id)
if metadata.get('status') != 'valid':
abort(403)
postal_address = PostalAddress(metadata.get('recipient'))
form = LetterUploadPostageForm(postage_zone=postal_address.postage)
if not form.validate_on_submit():
return uploaded_letter_preview(service_id, file_id)
notification_api_client.send_precompiled_letter(
service_id,
metadata.get('filename'),
file_id,
form.postage.data,
postal_address.raw_address,
)
return redirect(
url_for(
'.view_notification',
service_id=service_id,
notification_id=file_id,
))
def service_set_channel(service_id, channel):
if channel not in {'email', 'sms', 'letter'}:
abort(404)
if current_service.has_permission('broadcast'):
abort(403)
form = ServiceSwitchChannelForm(
channel=channel,
enabled=current_service.has_permission(channel)
)
if form.validate_on_submit():
current_service.force_permission(
channel,
on=form.enabled.data,
)
return redirect(
url_for(".service_settings", service_id=service_id)
)
return render_template(
'views/service-settings/set-{}.html'.format(channel),
form=form,
)
def send_uploaded_letter(service_id):
if not (current_service.has_permission('letter') and current_service.has_permission('upload_letters')):
abort(403)
form = LetterUploadPostageForm()
file_id = form.file_id.data
if not form.validate_on_submit():
return uploaded_letter_preview(service_id, file_id)
postage = form.postage.data
metadata = get_letter_metadata(service_id, file_id)
filename = metadata.get('filename')
recipient_address = metadata.get('recipient')
if metadata.get('status') != 'valid':
abort(403)
notification_api_client.send_precompiled_letter(service_id, filename, file_id, postage, recipient_address)
return redirect(url_for(
'.view_notification',
service_id=service_id,
notification_id=file_id,
))
def invite_user(service_id, user_id=None):
if current_service.has_permission('broadcast'):
form_class = BroadcastInviteUserForm
else:
form_class = InviteUserForm
form = form_class(
invalid_email_address=current_user.email_address,
all_template_folders=current_service.all_template_folders,
folder_permissions=[
f['id'] for f in current_service.all_template_folders
])
if user_id:
user_to_invite = User.from_id(user_id)
if user_to_invite.belongs_to_service(current_service.id):
return render_template(
'views/user-already-team-member.html',
user_to_invite=user_to_invite,
)
if current_service.invite_pending_for(user_to_invite.email_address):
return render_template(
'views/user-already-invited.html',
user_to_invite=user_to_invite,
)
if not user_to_invite.default_organisation:
abort(403)
if user_to_invite.default_organisation.id != current_service.organisation_id:
abort(403)
form.email_address.data = user_to_invite.email_address
else:
user_to_invite = None
service_has_email_auth = current_service.has_permission('email_auth')
if not service_has_email_auth:
form.login_authentication.data = 'sms_auth'
if form.validate_on_submit():
email_address = form.email_address.data
invited_user = InvitedUser.create(
current_user.id,
service_id,
email_address,
form.permissions,
form.login_authentication.data,
form.folder_permissions.data,
)
flash('Invite sent to {}'.format(invited_user.email_address),
'default_with_tick')
return redirect(url_for('.manage_users', service_id=service_id))
return render_template(
'views/invite-user.html',
form=form,
service_has_email_auth=service_has_email_auth,
mobile_number=True,
user_to_invite=user_to_invite,
)
def get_dashboard_partials(service_id):
all_statistics = template_statistics_client.get_template_statistics_for_service(
service_id, limit_days=7)
template_statistics = aggregate_template_usage(all_statistics)
scheduled_jobs, immediate_jobs = [], []
if job_api_client.has_jobs(service_id):
scheduled_jobs = job_api_client.get_scheduled_jobs(service_id)
immediate_jobs = [
add_rate_to_job(job)
for job in job_api_client.get_immediate_jobs(service_id)
]
stats = aggregate_notifications_stats(all_statistics)
column_width, max_notifiction_count = get_column_properties(
number_of_columns=(
3 if current_service.has_permission('letter') else 2))
dashboard_totals = get_dashboard_totals(stats),
highest_notification_count = max(
sum(value[key] for key in {'requested', 'failed', 'delivered'})
for key, value in dashboard_totals[0].items())
return {
'upcoming':
render_template('views/dashboard/_upcoming.html',
scheduled_jobs=scheduled_jobs),
'inbox':
render_template(
'views/dashboard/_inbox.html',
inbound_sms_summary=(
service_api_client.get_inbound_sms_summary(service_id)
if current_service.has_permission('inbound_sms') else None),
),
'totals':
render_template(
'views/dashboard/_totals.html',
service_id=service_id,
statistics=dashboard_totals[0],
column_width=column_width,
smaller_font_size=(highest_notification_count >
max_notifiction_count),
),
'template-statistics':
render_template(
'views/dashboard/template-statistics.html',
template_statistics=template_statistics,
most_used_template_count=max(
[row['count'] for row in template_statistics] or [0]),
),
'has_template_statistics':
bool(template_statistics),
'jobs':
render_template('views/dashboard/_jobs.html', jobs=immediate_jobs),
'has_jobs':
bool(immediate_jobs)
}
def get_inbox_partials(service_id):
page = int(request.args.get('page', 1))
if not current_service.has_permission('inbound_sms'):
abort(403)
inbound_messages_data = service_api_client.get_most_recent_inbound_sms(
service_id, page=page)
inbound_messages = inbound_messages_data['data']
if not inbound_messages:
inbound_number = current_service.inbound_number
else:
inbound_number = None
prev_page = None
if page > 1:
prev_page = generate_previous_dict('main.inbox', service_id, page)
next_page = None
if inbound_messages_data['has_next']:
next_page = generate_next_dict('main.inbox', service_id, page)
return {
'messages':
render_template('views/dashboard/_inbox_messages.html',
messages=inbound_messages,
inbound_number=inbound_number,
prev_page=prev_page,
next_page=next_page)
}
def invite_user(service_id):
form = InviteUserForm(
invalid_email_address=current_user.email_address,
all_template_folders=current_service.all_template_folders,
folder_permissions=[
f['id'] for f in current_service.all_template_folders
])
service_has_email_auth = current_service.has_permission('email_auth')
if not service_has_email_auth:
form.login_authentication.data = 'sms_auth'
if form.validate_on_submit():
email_address = form.email_address.data
invited_user = InvitedUser.create(
current_user.id,
service_id,
email_address,
form.permissions,
form.login_authentication.data,
form.folder_permissions.data,
)
flash('{} {}'.format(_l('Invite sent to'), invited_user.email_address),
'default_with_tick')
return redirect(url_for('.manage_users', service_id=service_id))
return render_template(
'views/invite-user.html',
form=form,
service_has_email_auth=service_has_email_auth,
mobile_number=True,
)
def create_api_key(service_id):
form = CreateKeyForm(current_service.api_keys)
form.key_type.choices = [
(KEY_TYPE_NORMAL, _l("Live – sends to anyone")),
(KEY_TYPE_TEAM, _l("Team and safelist – limits who you can send to")),
(KEY_TYPE_TEST, _l("Test – pretends to send messages")),
]
disabled_options, option_hints = [], {}
if current_service.trial_mode:
disabled_options = [KEY_TYPE_NORMAL]
option_hints[KEY_TYPE_NORMAL] = Markup(
_l("Not available because your service is in trial mode."))
if current_service.has_permission("letter"):
option_hints[KEY_TYPE_TEAM] = ""
if form.validate_on_submit():
if form.key_type.data in disabled_options:
abort(400)
secret = api_key_api_client.create_api_key(
service_id=service_id,
key_name=form.key_name.data,
key_type=form.key_type.data,
)
return render_template(
"views/api/keys/show.html",
secret=secret,
service_id=service_id,
key_name=email_safe(form.key_name.data, whitespace="_"),
)
return render_template(
"views/api/keys/create.html",
form=form,
disabled_options=disabled_options,
option_hints=option_hints,
)
def usage(service_id):
if current_service.has_permission(
'view_activity') or current_user.platform_admin:
return redirect(url_for('.service_dashboard', service_id=service_id))
return redirect(url_for('main.index', service_id=service_id))
def usage(service_id):
year, current_financial_year = requested_and_current_financial_year(
request)
free_sms_allowance = billing_api_client.get_free_sms_fragment_limit_for_year(
service_id, year)
units = billing_api_client.get_billable_units_ft(service_id, year)
yearly_usage = billing_api_client.get_service_usage_ft(service_id, year)
usage_template = 'views/usage.html'
if current_service.has_permission('letter'):
usage_template = 'views/usage-with-letters.html'
return render_template(usage_template,
months=list(
get_free_paid_breakdown_for_billable_units(
year, free_sms_allowance, units)),
selected_year=year,
years=get_tuples_of_financial_years(
partial(url_for,
'.usage',
service_id=service_id),
start=current_financial_year - 1,
end=current_financial_year + 1,
),
**calculate_usage(yearly_usage, free_sms_allowance))
def create_api_key(service_id):
form = CreateKeyForm(current_service.api_keys)
form.key_type.choices = [
(KEY_TYPE_NORMAL, 'Live – sends to anyone'),
(KEY_TYPE_TEAM, 'Team and whitelist – limits who you can send to'),
(KEY_TYPE_TEST, 'Test – pretends to send messages'),
]
disabled_options, option_hints = [], {}
if current_service.trial_mode:
disabled_options = [KEY_TYPE_NORMAL]
option_hints[KEY_TYPE_NORMAL] = Markup(
'Not available because your service is in '
'<a href="/features/trial-mode">trial mode</a>')
if current_service.has_permission('letter'):
option_hints[KEY_TYPE_TEAM] = 'Cannot be used to send letters'
if form.validate_on_submit():
if form.key_type.data in disabled_options:
abort(400)
secret = api_key_api_client.create_api_key(service_id=service_id,
key_name=form.key_name.data,
key_type=form.key_type.data)
return render_template('views/api/keys/show.html',
secret=secret,
service_id=service_id,
key_name=email_safe(form.key_name.data,
whitespace='_'))
return render_template('views/api/keys/create.html',
form=form,
disabled_options=disabled_options,
option_hints=option_hints)
def edit_user_permissions(service_id, user_id):
service_has_email_auth = current_service.has_permission('email_auth')
# TODO we should probably using the service id here in the get user
# call as well. eg. /user/<user_id>?&service=service_id
user = user_api_client.get_user(user_id)
user_has_no_mobile_number = user.mobile_number is None
form = PermissionsForm.from_user(user, service_id)
if form.validate_on_submit():
user_api_client.set_user_permissions(
user_id,
service_id,
permissions=form.permissions,
)
if service_has_email_auth:
user_api_client.update_user_attribute(
user_id, auth_type=form.login_authentication.data)
return redirect(url_for('.manage_users', service_id=service_id))
return render_template('views/edit-user-permissions.html',
user=user,
form=form,
service_has_email_auth=service_has_email_auth,
user_has_no_mobile_number=user_has_no_mobile_number)
def usage(service_id):
if current_service.has_permission(
"view_activity") or current_user.platform_admin:
return redirect(url_for(".service_dashboard", service_id=service_id))
return redirect(url_for(".main.index", service_id=service_id))
def send_one_off_letter_address(service_id, template_id):
if {'recipient', 'placeholders'} - set(session.keys()):
# if someone has come here via a bookmark or back button they might have some stuff still in their session
return redirect(url_for('.send_one_off', service_id=service_id, template_id=template_id))
db_template = current_service.get_template_with_user_permission_or_403(template_id, current_user)
template = get_template(
db_template,
current_service,
show_recipient=True,
letter_preview_url=url_for(
'no_cookie.send_test_preview',
service_id=service_id,
template_id=template_id,
filetype='png',
),
page_count=get_page_count_for_letter(db_template),
email_reply_to=None,
sms_sender=None
)
current_session_address = PostalAddress.from_personalisation(
get_normalised_placeholders_from_session()
)
form = LetterAddressForm(
address=current_session_address.normalised,
allow_international_letters=current_service.has_permission('international_letters'),
)
if form.validate_on_submit():
session['placeholders'].update(PostalAddress(form.address.data).as_personalisation)
placeholders = fields_to_fill_in(template)
if all_placeholders_in_session(placeholders):
return get_notification_check_endpoint(service_id, template)
first_non_address_placeholder_index = len(address_lines_1_to_7_keys)
return redirect(url_for(
'main.send_one_off_step',
service_id=service_id,
template_id=template_id,
step_index=first_non_address_placeholder_index,
))
return render_template(
'views/send-one-off-letter-address.html',
page_title=get_send_test_page_title(
template_type='letter',
entering_recipient=True,
name=template.name,
),
template=template,
form=form,
back_link=get_back_link(service_id, template, 0),
link_to_upload=True,
)
def api_integration(service_id):
callbacks_link = ('.api_callbacks'
if current_service.has_permission('inbound_sms') else
'.delivery_status_callback')
return render_template('views/api/index.html',
callbacks_link=callbacks_link,
api_notifications=notification_api_client.
get_api_notifications_for_service(service_id))
def choose_template(service_id, template_type="all", template_folder_id=None):
template_folder = current_service.get_template_folder(template_folder_id)
user_has_template_folder_permission = current_user.has_template_folder_permission(
template_folder)
template_list = TemplateList(current_service, template_type,
template_folder_id, current_user)
templates_and_folders_form = TemplateAndFoldersSelectionForm(
all_template_folders=current_service.get_user_template_folders(
current_user),
template_list=template_list,
template_type=template_type,
allow_adding_letter_template=current_service.has_permission("letter"),
allow_adding_copy_of_template=(current_service.all_templates
or len(current_user.service_ids) > 1),
)
option_hints = {template_folder_id: "current folder"}
if request.method == "POST" and templates_and_folders_form.validate_on_submit(
):
if not current_user.has_permissions("manage_templates"):
abort(403)
try:
return process_folder_management_form(templates_and_folders_form,
template_folder_id)
except HTTPError as e:
flash(e.message)
if "templates_and_folders" in templates_and_folders_form.errors:
flash(_("Select at least one template or folder"))
initial_state = request.args.get("initial_state")
if request.method == "GET" and initial_state:
templates_and_folders_form.op = initial_state
sending_view = request.args.get("view") == "sending"
return render_template(
"views/templates/choose.html",
current_template_folder_id=template_folder_id,
template_folder_path=current_service.get_template_folder_path(
template_folder_id),
template_list=template_list,
show_search_box=current_service.count_of_templates_and_folders > 7,
show_template_nav=(current_service.has_multiple_template_types
and (len(current_service.all_templates) > 2)),
sending_view=sending_view,
template_nav_items=get_template_nav_items(template_folder_id,
sending_view),
template_type=template_type,
search_form=SearchByNameForm(),
templates_and_folders_form=templates_and_folders_form,
move_to_children=templates_and_folders_form.move_to.children(),
user_has_template_folder_permission=user_has_template_folder_permission,
option_hints=option_hints,
)
def api_integration(service_id):
callbacks_link = ".api_callbacks" if current_service.has_permission(
"inbound_sms") else ".delivery_status_callback"
return render_template(
"views/api/index.html",
callbacks_link=callbacks_link,
api_notifications=notification_api_client.
get_api_notifications_for_service(service_id),
)
def get_dashboard_partials(service_id):
all_statistics = template_statistics_client.get_template_statistics_for_service(
service_id, limit_days=7)
template_statistics = aggregate_template_usage(all_statistics)
stats = aggregate_notifications_stats(all_statistics)
column_width, max_notifiction_count = get_column_properties(3)
dashboard_totals = get_dashboard_totals(stats),
highest_notification_count = max(
sum(value[key] for key in {'requested', 'failed', 'delivered'})
for key, value in dashboard_totals[0].items())
free_sms_allowance = billing_api_client.get_free_sms_fragment_limit_for_year(
current_service.id,
get_current_financial_year(),
)
yearly_usage = billing_api_client.get_service_usage(
service_id,
get_current_financial_year(),
)
return {
'upcoming':
render_template('views/dashboard/_upcoming.html', ),
'inbox':
render_template(
'views/dashboard/_inbox.html',
inbound_sms_summary=(
service_api_client.get_inbound_sms_summary(service_id)
if current_service.has_permission('inbound_sms') else None),
),
'totals':
render_template(
'views/dashboard/_totals.html',
service_id=service_id,
statistics=dashboard_totals[0],
column_width=column_width,
smaller_font_size=(highest_notification_count >
max_notifiction_count),
),
'template-statistics':
render_template(
'views/dashboard/template-statistics.html',
template_statistics=template_statistics,
most_used_template_count=max(
[row['count'] for row in template_statistics] or [0]),
),
'jobs':
render_template(
'views/dashboard/_jobs.html',
jobs=current_service.immediate_jobs,
),
'usage':
render_template(
'views/dashboard/_usage.html',
column_width=column_width,
**calculate_usage(yearly_usage, free_sms_allowance),
),
}
def view_notification(service_id, notification_id):
notification = notification_api_client.get_notification(
service_id, str(notification_id))
notification['template'].update(
{'reply_to_text': notification['reply_to_text']})
if notification['template']['is_precompiled_letter']:
file_contents = view_letter_notification_as_preview(
service_id, notification_id, "pdf")
page_count = pdf_page_count(io.BytesIO(file_contents))
else:
page_count = get_page_count_for_letter(notification['template'])
template = get_template(
notification['template'],
current_service,
letter_preview_url=url_for(
'.view_letter_notification_as_preview',
service_id=service_id,
notification_id=notification_id,
filetype='png',
),
page_count=page_count,
show_recipient=True,
redact_missing_personalisation=True,
)
template.values = get_all_personalisation_from_notification(notification)
if notification['job']:
job = job_api_client.get_job(service_id,
notification['job']['id'])['data']
else:
job = None
return render_template(
'views/notifications/notification.html',
finished=(notification['status']
in (DELIVERED_STATUSES + FAILURE_STATUSES)),
uploaded_file_name='Report',
template=template,
job=job,
updates_url=url_for(".view_notification_updates",
service_id=service_id,
notification_id=notification['id'],
status=request.args.get('status'),
help=get_help_argument()),
partials=get_single_notification_partials(notification),
created_by=notification.get('created_by'),
created_at=notification['created_at'],
help=get_help_argument(),
estimated_letter_delivery_date=get_letter_timings(
notification['created_at']).earliest_delivery,
notification_id=notification['id'],
can_receive_inbound=(current_service.has_permission('inbound_sms')),
is_precompiled_letter=notification['template']
['is_precompiled_letter'])
def manage_users(service_id):
return render_template(
'views/manage-users.html',
users=current_service.team_members,
current_user=current_user,
show_search_box=(len(current_service.team_members) > 7),
form=SearchUsersForm(),
permissions=(broadcast_permissions
if current_service.has_permission('broadcast') else
permissions),
)
def edit_user_permissions(service_id, user_id):
service_has_email_auth = current_service.has_permission('email_auth')
user = current_service.get_team_member(user_id)
mobile_number = None
if user.mobile_number:
mobile_number = redact_mobile_number(user.mobile_number, " ")
if current_service.has_permission('broadcast'):
form_class = BroadcastPermissionsForm
else:
form_class = PermissionsForm
form = form_class.from_user(
user,
service_id,
folder_permissions=None if user.platform_admin else [
f['id'] for f in current_service.all_template_folders
if user.has_template_folder_permission(f)
],
all_template_folders=None
if user.platform_admin else current_service.all_template_folders)
if form.validate_on_submit():
user.set_permissions(
service_id,
permissions=form.permissions,
folder_permissions=form.folder_permissions.data,
)
if service_has_email_auth:
user.update(auth_type=form.login_authentication.data)
return redirect(url_for('.manage_users', service_id=service_id))
return render_template(
'views/edit-user-permissions.html',
user=user,
form=form,
service_has_email_auth=service_has_email_auth,
mobile_number=mobile_number,
delete=request.args.get('delete'),
)
def api_callbacks(service_id):
if not current_service.has_permission('inbound_sms'):
return redirect(url_for('.delivery_status_callback', service_id=service_id))
delivery_status_callback, received_text_messages_callback = get_apis()
return render_template(
'views/api/callbacks.html',
received_text_messages_callback=received_text_messages_callback['url']
if received_text_messages_callback else None,
delivery_status_callback=delivery_status_callback['url'] if delivery_status_callback else None
)
def add_template_by_type(service_id):
form = ChooseTemplateType(
include_letters=current_service.has_permission('letter'),
include_copy=any((
service_api_client.count_service_templates(service_id) > 0,
len(user_api_client.get_service_ids_for_user(current_user)) > 1,
)),
)
if form.validate_on_submit():
if form.template_type.data == 'copy-existing':
return redirect(
url_for(
'.choose_template_to_copy',
service_id=service_id,
))
if form.template_type.data == 'letter':
blank_letter = service_api_client.create_service_template(
'Untitled',
'letter',
'Body',
service_id,
'Main heading',
'normal',
)
return redirect(
url_for(
'.view_template',
service_id=service_id,
template_id=blank_letter['data']['id'],
))
if email_or_sms_not_enabled(form.template_type.data,
current_service.permissions):
return redirect(
url_for('.action_blocked',
service_id=service_id,
notification_type=form.template_type.data,
return_to='add_new_template',
template_id='0'))
else:
return redirect(
url_for(
'.add_service_template',
service_id=service_id,
template_type=form.template_type.data,
))
return render_template('views/templates/add.html', form=form)
def get_dashboard_partials(service_id):
all_statistics = template_statistics_client.get_template_statistics_for_service(
service_id, limit_days=7)
template_statistics = aggregate_template_usage(all_statistics)
scheduled_jobs, immediate_jobs = [], []
if job_api_client.has_jobs(service_id):
scheduled_jobs = job_api_client.get_scheduled_jobs(service_id)
immediate_jobs = [
add_rate_to_job(job)
for job in job_api_client.get_immediate_jobs(service_id)
]
stats = aggregate_notifications_stats(all_statistics)
column_width, max_notifiction_count = get_column_properties(
number_of_columns=(
3 if current_service.has_permission("letter") else 2))
dashboard_totals = (get_dashboard_totals(stats), )
highest_notification_count = max(
sum(value[key] for key in {"requested", "failed", "delivered"})
for key, value in dashboard_totals[0].items())
return {
"upcoming":
render_template("views/dashboard/_upcoming.html",
scheduled_jobs=scheduled_jobs),
"totals":
render_template(
"views/dashboard/_totals.html",
service_id=service_id,
statistics=dashboard_totals[0],
column_width=column_width,
smaller_font_size=(highest_notification_count >
max_notifiction_count),
),
"template-statistics":
render_template(
"views/dashboard/template-statistics.html",
template_statistics=template_statistics,
most_used_template_count=max(
[row["count"] for row in template_statistics] or [0]),
),
"has_template_statistics":
bool(template_statistics),
"jobs":
render_template("views/dashboard/_jobs.html", jobs=immediate_jobs),
"has_jobs":
bool(immediate_jobs),
"has_scheduled_jobs":
bool(scheduled_jobs),
}
def delivery_status_callback(service_id):
delivery_status_callback = get_delivery_status_callback_details()
back_link = (
'.api_callbacks' if current_service.has_permission('inbound_sms')
else '.api_integration'
)
form = ServiceDeliveryStatusCallbackForm(
url=delivery_status_callback.get('url') if delivery_status_callback else '',
bearer_token=dummy_bearer_token if delivery_status_callback else ''
)
if form.validate_on_submit():
if delivery_status_callback and form.url.data:
if (
delivery_status_callback.get('url') != form.url.data or
form.bearer_token.data != dummy_bearer_token
):
service_api_client.update_service_callback_api(
service_id,
url=form.url.data,
bearer_token=check_token_against_dummy_bearer(form.bearer_token.data),
user_id=current_user.id,
callback_api_id=delivery_status_callback.get('id')
)
elif delivery_status_callback and not form.url.data:
service_api_client.delete_service_callback_api(
service_id,
delivery_status_callback['id'],
)
elif form.url.data:
service_api_client.create_service_callback_api(
service_id,
url=form.url.data,
bearer_token=form.bearer_token.data,
user_id=current_user.id
)
else:
# If no callback is set up and the user chooses to continue
# having no callback (ie both fields empty) then there’s
# nothing for us to do here
pass
return redirect(url_for(back_link, service_id=service_id))
return render_template(
'views/api/callbacks/delivery-status-callback.html',
back_link=back_link,
form=form,
)
def api_callbacks(service_id):
if not current_service.has_permission("inbound_sms"):
return redirect(
url_for(".delivery_status_callback", service_id=service_id))
delivery_status_callback, received_text_messages_callback = get_apis()
return render_template(
"views/api/callbacks.html",
received_text_messages_callback=received_text_messages_callback["url"]
if received_text_messages_callback else None,
delivery_status_callback=delivery_status_callback["url"]
if delivery_status_callback else None,
)
def choose_template(service_id, template_type='all'):
templates = service_api_client.get_service_templates(service_id)['data']
letters_available = current_service.has_permission('letter')
available_template_types = list(
filter(None, (
'email',
'sms',
'letter' if letters_available else None,
)))
templates = [
template for template in templates
if template['template_type'] in available_template_types
]
has_multiple_template_types = len(
{template['template_type']
for template in templates}) > 1
template_nav_items = [
(label, key,
url_for('.choose_template',
service_id=current_service.id,
template_type=key), '')
for label, key in filter(None, [
('All', 'all'),
('Text message', 'sms'),
('Email', 'email'),
('Letter', 'letter') if letters_available else None,
])
]
templates_on_page = [
template for template in templates
if (template_type in ['all', template['template_type']]
and template['template_type'] in available_template_types)
]
return render_template(
'views/templates/choose.html',
templates=templates_on_page,
show_search_box=(len(templates_on_page) > 7),
show_template_nav=has_multiple_template_types and (len(templates) > 2),
template_nav_items=template_nav_items,
template_type=template_type,
search_form=SearchTemplatesForm(),
)
def service_settings(service_id):
letter_branding_organisations = email_branding_client.get_letter_email_branding()
organisation = organisations_client.get_service_organisation(service_id).get('name', None)
if current_service.email_branding:
email_branding = email_branding_client.get_email_branding(current_service.email_branding)['email_branding']
else:
email_branding = None
inbound_number = inbound_number_client.get_inbound_sms_number_for_service(service_id)
disp_inbound_number = inbound_number['data'].get('number', '')
reply_to_email_addresses = service_api_client.get_reply_to_email_addresses(service_id)
reply_to_email_address_count = len(reply_to_email_addresses)
default_reply_to_email_address = next(
(x['email_address'] for x in reply_to_email_addresses if x['is_default']), "Not set"
)
letter_contact_details = service_api_client.get_letter_contacts(service_id)
letter_contact_details_count = len(letter_contact_details)
default_letter_contact_block = next(
(Field(x['contact_block'], html='escape') for x in letter_contact_details if x['is_default']), "Not set"
)
sms_senders = service_api_client.get_sms_senders(service_id)
sms_sender_count = len(sms_senders)
default_sms_sender = next(
(Field(x['sms_sender'], html='escape') for x in sms_senders if x['is_default']), "None"
)
free_sms_fragment_limit = billing_api_client.get_free_sms_fragment_limit_for_year(service_id)
data_retention = service_api_client.get_service_data_retention(service_id)
return render_template(
'views/service-settings.html',
email_branding=email_branding,
letter_branding=letter_branding_organisations.get(
current_service.get('dvla_organisation', '001')
),
can_receive_inbound=(current_service.has_permission('inbound_sms')),
inbound_number=disp_inbound_number,
default_reply_to_email_address=default_reply_to_email_address,
reply_to_email_address_count=reply_to_email_address_count,
default_letter_contact_block=default_letter_contact_block,
letter_contact_details_count=letter_contact_details_count,
default_sms_sender=default_sms_sender,
sms_sender_count=sms_sender_count,
free_sms_fragment_limit=free_sms_fragment_limit,
prefix_sms=current_service.prefix_sms,
organisation=organisation,
data_retention=data_retention,
)
def add_service_template(service_id, template_type, template_folder_id=None):
if not current_service.has_permission('letter') and template_type == 'letter':
abort(403)
form = form_objects[template_type]()
if form.validate_on_submit():
if form.process_type.data == 'priority':
abort_403_if_not_admin_user()
try:
new_template = service_api_client.create_service_template(
form.name.data,
template_type,
form.template_content.data,
service_id,
form.subject.data if hasattr(form, 'subject') else None,
form.process_type.data,
template_folder_id
)
except HTTPError as e:
if (
e.status_code == 400
and 'content' in e.message
and any(['character count greater than' in x for x in e.message['content']])
):
form.template_content.errors.extend(e.message['content'])
else:
raise e
else:
return redirect(
url_for('.view_template', service_id=service_id, template_id=new_template['data']['id'])
)
if email_or_sms_not_enabled(template_type, current_service.permissions):
return redirect(url_for(
'.action_blocked',
service_id=service_id,
notification_type=template_type,
template_folder_id=template_folder_id,
return_to='templates',
))
else:
return render_template(
'views/edit-{}-template.html'.format(template_type),
form=form,
template_type=template_type,
template_folder_id=template_folder_id,
heading_action='New',
)
def service_set_international_letters(service_id):
form = ServiceOnOffSettingForm(
'Send letters to international addresses',
enabled=current_service.has_permission('international_letters'),
)
if form.validate_on_submit():
current_service.force_permission(
'international_letters',
on=form.enabled.data,
)
return redirect(url_for(".service_settings", service_id=service_id))
return render_template(
'views/service-settings/set-international-letters.html',
form=form,
)
