def view_template(service_id, template_id):
template = current_service.get_template(template_id)
template_folder = current_service.get_template_folder(template['folder'])
user_has_template_permission = current_user.has_template_folder_permission(
template_folder)
if should_skip_template_page(template['template_type']):
return redirect(
url_for('.send_one_off',
service_id=service_id,
template_id=template_id))
page_count = get_page_count_for_letter(template)
return render_template(
'views/templates/template.html',
template=get_template(
template,
current_service,
letter_preview_url=url_for(
'no_cookie.view_letter_template_preview',
service_id=service_id,
template_id=template_id,
filetype='png',
),
show_recipient=True,
page_count=get_page_count_for_letter(template),
),
template_postage=template["postage"],
user_has_template_permission=user_has_template_permission,
letter_too_long=is_letter_too_long(page_count),
letter_max_pages=LETTER_MAX_PAGE_COUNT,
page_count=page_count)
def view_template(service_id, template_id):
if not current_user.has_permissions('view_activity'):
return redirect(
url_for('.send_one_off',
service_id=service_id,
template_id=template_id))
template = service_api_client.get_service_template(
service_id, str(template_id))['data']
if template["template_type"] == "letter":
letter_contact_details = service_api_client.get_letter_contacts(
service_id)
default_letter_contact_block_id = next(
(x['id'] for x in letter_contact_details if x['is_default']), None)
else:
default_letter_contact_block_id = None
return render_template(
'views/templates/template.html',
template=get_template(
template,
current_service,
expand_emails=True,
letter_preview_url=url_for(
'.view_letter_template_preview',
service_id=service_id,
template_id=template_id,
filetype='png',
),
show_recipient=True,
page_count=get_page_count_for_letter(template),
),
default_letter_contact_block_id=default_letter_contact_block_id,
)
def get_email_preview_template(template, template_id, service_id):
email_preview_template = get_template(
template,
current_service,
letter_preview_url=url_for(
'.view_letter_template_preview',
service_id=service_id,
template_id=template_id,
filetype='png',
),
show_recipient=True,
page_count=get_page_count_for_letter(template),
)
template_str = str(email_preview_template)
translate = {"From": _("From"), "To": _("To"), "Subject": _("Subject")}
def translate_brackets(x):
g = x.group(0)
english = g[1:-1] # drop brackets
if english not in translate:
return english
return translate[english]
# this regex finds test inside []
template_str = re.sub(r"\[[^]]*\]", translate_brackets, template_str)
email_preview_template.html = template_str
return email_preview_template
def remove_template(template_name, template_folder):
"""Deletes the specified template
Parameters:
template_name (str): The name of the template to delete
template_folder (str): the path of the templates directory
Returns:
dict: indicates the status of the remove operation and a message
"""
is_successful = None
message = None
message_kwargs = dict(template_name=template_name)
if get_template(template_name, template_folder):
delete_status = delete_template(template_name, template_folder)
if delete_status['is_successful']:
message = InfoMessage('template_deleted', **message_kwargs)
is_successful = True
else:
message = ErrorMessage('delete_template', **message_kwargs)
is_successful = False
else:
message = ErrorMessage('template_missing', **message_kwargs)
is_successful = False
return dict(is_successful=is_successful, msg=message.get_message())
def create_template(src, name, clone_function, force, template_folder):
"""Creates a template
Executes the proper clone_function with the scr and dest to create
a template for a file or a directory. For directories the contents are
copied to the new template folder, while files themselves are copied to
the new template folder. Overwriting an existing template is possible with
the force (-f) option.
Parameters:
src (str): the path to create the template from
name (str): the name of the template
clone_function (dict): includes a type (str) and execute (func) to
call the create the template with the correct parameters
force (bool): if truthy overwrite the existing template if one exists
template_folder (str): folder that templates currently live
Returns:
dict: indicates the status of the operation and a result message
"""
message = None
is_successful = None
message_kwargs = dict(template_name=name)
new_template_dir = os.path.join(template_folder, name) \
if clone_function['type'] == 'file' \
else template_folder
if get_template(name, template_folder):
if force:
delete_status = delete_template(name, template_folder)
if not delete_status['is_successful']:
message = ErrorMessage('delete_template', **message_kwargs)
is_successful = False
else:
message = ErrorMessage('template_exists', **message_kwargs)
is_successful = False
if is_successful is not False:
if clone_function['type'] == 'file':
filename = os.path.basename(src)
dest = os.path.join(new_template_dir, filename)
os.mkdir(new_template_dir)
else:
dest = os.path.join(new_template_dir, name)
clone_status = clone_function['execute'](src, dest)
if clone_status['is_successful']:
message = InfoMessage('template_created', template_name=name)
is_successful = True
else:
message = ErrorMessage('create_template', template_name=name)
is_successful = False
return dict(is_successful=is_successful, msg=message.get_message())
def _check_notification(service_id, template_id, exception=None):
db_template = service_api_client.get_service_template(service_id, template_id)['data']
email_reply_to = None
sms_sender = None
if db_template['template_type'] == 'email':
email_reply_to = get_email_reply_to_address_from_session(service_id)
elif db_template['template_type'] == 'sms':
sms_sender = get_sms_sender_from_session(service_id)
template = get_template(
db_template,
current_service,
show_recipient=True,
email_reply_to=email_reply_to,
sms_sender=sms_sender
)
# go back to start of process
back_link = get_back_link(service_id, template_id, 0)
if (
not session.get('recipient') or
not all_placeholders_in_session(template.placeholders)
):
return redirect(back_link)
template.values = get_recipient_and_placeholders_from_session(template.template_type)
return render_template(
'views/notifications/check.html',
template=template,
back_link=back_link,
help=get_help_argument(),
**(get_template_error_dict(exception) if exception else {})
)
def view_job(service_id, job_id):
job = job_api_client.get_job(service_id, job_id)["data"]
if job["job_status"] == "cancelled":
abort(404)
filter_args = _parse_filter_args(request.args)
filter_args["status"] = _set_status_filters(filter_args)
total_notifications = job.get("notification_count", 0)
processed_notifications = job.get("notifications_delivered", 0) + job.get("notifications_failed", 0)
return render_template(
"views/jobs/job.html",
finished=(total_notifications == processed_notifications),
uploaded_file_name=job["original_file_name"],
template=get_template(
service_api_client.get_service_template(
service_id=service_id, template_id=job["template"], version=job["template_version"]
)["data"],
current_service,
),
status=request.args.get("status", ""),
updates_url=url_for(
".view_job_updates",
service_id=service_id,
job_id=job["id"],
status=request.args.get("status", ""),
help=get_help_argument(),
),
partials=get_job_partials(job),
help=get_help_argument(),
)
def begin_tour(service_id, template_id):
db_template = current_service.get_template_with_user_permission_or_403(
template_id, current_user)
if (db_template['template_type'] != 'sms'
or not current_user.mobile_number):
abort(404)
template = get_template(
db_template,
current_service,
show_recipient=True,
)
template.values = {"phone_number": current_user.mobile_number}
session['placeholders'] = {}
return render_template('views/templates/start-tour.html',
template=template,
help='1',
continue_link=url_for('.tour_step',
service_id=service_id,
template_id=template_id,
step_index=1))
def test_get_template_returns_the_template_with_invalid_path(mocker):
"""get_template returns False if the path doesn't exist"""
mocker.patch('os.path.exists', return_value=False)
path = '~/Home'
name = 'test'
assert get_template(name, path) is False
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 view_template_versions(service_id, template_id):
return render_template(
'views/templates/choose_history.html',
versions=[
get_template(template, current_service, expand_emails=True)
for template in service_api_client.get_service_template_versions(service_id, template_id)['data']
]
)
def uploaded_letter_preview(service_id, file_id):
re_upload_form = PDFUploadForm()
try:
metadata = get_letter_metadata(service_id, file_id)
except ClientError as e:
# if the file's not there, it's probably because we've already created the notification and the letter has been
# moved to the normal letters-pdf bucket. So lets just bounce out to the notification page
if e.response['Error']['Code'] == 'NoSuchKey':
return redirect(
url_for(
'.view_notification',
service_id=service_id,
notification_id=file_id,
))
else:
raise
original_filename = metadata.get('filename')
page_count = metadata.get('page_count')
status = metadata.get('status')
error_shortcode = metadata.get('message')
invalid_pages = metadata.get('invalid_pages')
postal_address = PostalAddress(metadata.get('recipient', ''))
if invalid_pages:
invalid_pages = json.loads(invalid_pages)
error_message = get_letter_validation_error(error_shortcode, invalid_pages,
page_count)
template_dict = service_api_client.get_precompiled_template(service_id)
# Override pre compiled letter template postage to none as it has not yet been picked even though
# the pre compiled letter template has its postage set as second class as the DB currently requires
# a non null value of postage for letter templates
template_dict['postage'] = None
form = LetterUploadPostageForm(postage_zone=postal_address.postage)
template = get_template(template_dict,
service_id,
letter_preview_url=url_for(
'.view_letter_upload_as_preview',
service_id=service_id,
file_id=file_id),
page_count=page_count)
return render_template(
'views/uploads/preview.html',
original_filename=original_filename,
template=template,
status=status,
file_id=file_id,
message=error_message,
error_code=error_shortcode,
form=form,
allowed_file_extensions=Spreadsheet.ALLOWED_FILE_EXTENSIONS,
postal_address=postal_address,
re_upload_form=re_upload_form)
def view_template_version(service_id, template_id, version):
return render_template(
'views/templates/template_history.html',
template=get_template(
service_api_client.get_service_template(service_id, template_id, version)['data'],
current_service,
expand_emails=True
)
)
def test_get_template_returns_the_template_with_valid_path(mocker):
""""get_template returns the path if the path exist"""
valid_template_path = '~/Home'
mocker.patch('os.path.exists', return_value=True)
mocker.patch('os.path.join', return_value=valid_template_path)
path = '~/Home'
name = 'test'
assert get_template(name, path) == valid_template_path
def send_messages(service_id, template_id):
session['sender_id'] = None
db_template = service_api_client.get_service_template(service_id, template_id)['data']
if email_or_sms_not_enabled(db_template['template_type'], current_service['permissions']):
return redirect(url_for(
'.action_blocked',
service_id=service_id,
notification_type=db_template['template_type'],
return_to='view_template',
template_id=template_id
))
template = get_template(
db_template,
current_service,
show_recipient=True,
expand_emails=True,
letter_preview_url=url_for(
'.view_letter_template_preview',
service_id=service_id,
template_id=template_id,
filetype='png',
page_count=get_page_count_for_letter(db_template),
),
)
form = CsvUploadForm()
if form.validate_on_submit():
try:
upload_id = s3upload(
service_id,
Spreadsheet.from_file(form.file.data, filename=form.file.data.filename).as_dict,
current_app.config['AWS_REGION']
)
session['upload_data'] = {
"template_id": template_id,
"original_file_name": form.file.data.filename
}
return redirect(url_for('.check_messages',
service_id=service_id,
upload_id=upload_id,
template_type=template.template_type))
except (UnicodeDecodeError, BadZipFile, XLRDError):
flash('Couldn’t read {}. Try using a different file format.'.format(
form.file.data.filename
))
column_headings = first_column_headings[template.template_type] + list(template.placeholders)
return render_template(
'views/send.html',
template=template,
column_headings=list(ascii_uppercase[:len(column_headings)]),
example=[column_headings, get_example_csv_rows(template)],
form=form
)
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 get_example_csv(service_id, template_id):
template = get_template(
service_api_client.get_service_template(service_id, template_id)['data'], current_service
)
return Spreadsheet.from_rows([
first_column_headings[template.template_type] + list(template.placeholders),
get_example_csv_rows(template)
]).as_csv_data, 200, {
'Content-Type': 'text/csv; charset=utf-8',
'Content-Disposition': 'inline; filename="{}.csv"'.format(template.name)
}
def _view_template_version(service_id, template_id, version, letters_as_pdf=False):
return dict(template=get_template(
current_service.get_template(template_id, version=version),
current_service,
letter_preview_url=url_for(
'.view_template_version_preview',
service_id=service_id,
template_id=template_id,
version=version,
filetype='png',
) if not letters_as_pdf else None
))
def _view_template_version(service_id, template_id, version, letters_as_pdf=False):
return dict(template=get_template(
service_api_client.get_service_template(service_id, template_id, version=version)['data'],
current_service,
expand_emails=True,
letter_preview_url=url_for(
'.view_template_version_preview',
service_id=service_id,
template_id=template_id,
version=version,
filetype='png',
) if not letters_as_pdf else None
))
def get_email_preview_template(template, template_id, service_id):
email_preview_template = get_template(
template,
current_service,
letter_preview_url=url_for(
'.view_letter_template_preview',
service_id=service_id,
template_id=template_id,
filetype='png',
),
show_recipient=True,
page_count=get_page_count_for_letter(template),
)
return email_preview_template
def choose_from_contact_list(service_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,
)
return render_template(
'views/send-contact-list.html',
contact_lists=ContactListsAlphabetical(
current_service.id,
template_type=template.template_type,
),
template=template,
)
def delete_service_template(service_id, template_id):
template = current_service.get_template_with_user_permission_or_403(
template_id, current_user)
if request.method == 'POST':
service_api_client.delete_service_template(service_id, template_id)
return redirect(
url_for(
'.choose_template',
service_id=service_id,
template_folder_id=template['folder'],
))
try:
last_used_notification = template_statistics_client.get_template_statistics_for_template(
service_id, template['id'])
message = 'This template was last used {} ago.'.format(
'more than seven days'
if not last_used_notification else get_human_readable_delta(
parse(last_used_notification['created_at']).replace(
tzinfo=None), datetime.utcnow()))
except HTTPError as e:
if e.status_code == 404:
message = None
else:
raise e
flash([
"Are you sure you want to delete ‘{}’?".format(template['name']),
message
], 'delete')
return render_template(
'views/templates/template.html',
template=get_template(
template,
current_service,
expand_emails=True,
letter_preview_url=url_for(
'.view_letter_template_preview',
service_id=service_id,
template_id=template['id'],
filetype='png',
),
show_recipient=True,
),
user_has_template_permission=True,
)
def start_tour(service_id, template_id):
template = current_service.get_template(template_id)
if template["template_type"] != "email":
abort(404)
return render_template(
"views/templates/start-tour.html",
template=get_template(
template,
current_service,
show_recipient=True,
),
help="1",
)
def start_tour(service_id, template_id):
template = current_service.get_template(template_id)
if template['template_type'] != 'sms':
abort(404)
return render_template(
'views/templates/start-tour.html',
template=get_template(
template,
current_service,
show_recipient=True,
),
help='1',
)
def view_template_versions(service_id, template_id):
return render_template(
'views/templates/choose_history.html',
versions=[
get_template(template,
current_service,
letter_preview_url=url_for(
'no_cookie.view_template_version_preview',
service_id=service_id,
template_id=template_id,
version=template['version'],
filetype='png',
))
for template in service_api_client.get_service_template_versions(
service_id, template_id)['data']
])
def _check_notification(service_id, template_id, exception=None):
db_template = current_service.get_template_with_user_permission_or_403(
template_id, current_user)
email_reply_to = None
sms_sender = None
if db_template['template_type'] == 'email':
email_reply_to = get_email_reply_to_address_from_session()
elif db_template['template_type'] == 'sms':
sms_sender = get_sms_sender_from_session()
template = get_template(
db_template,
current_service,
show_recipient=True,
email_reply_to=email_reply_to,
sms_sender=sms_sender,
letter_preview_url=url_for(
'no_cookie.check_notification_preview',
service_id=service_id,
template_id=template_id,
filetype='png',
),
page_count=get_page_count_for_letter(db_template),
)
placeholders = fields_to_fill_in(template)
back_link = get_back_link(service_id, template, len(placeholders),
placeholders)
if ((not session.get('recipient')
and db_template['template_type'] != 'letter')
or not all_placeholders_in_session(template.placeholders)):
raise PermanentRedirect(back_link)
template.values = get_recipient_and_placeholders_from_session(
template.template_type)
page_count = get_page_count_for_letter(db_template, template.values)
template.page_count = page_count
return dict(
template=template,
back_link=back_link,
help=get_help_argument(),
letter_too_long=is_letter_too_long(page_count),
letter_max_pages=LETTER_MAX_PAGE_COUNT,
page_count=page_count,
**(get_template_error_dict(exception) if exception else {}),
)
def uploaded_letter_preview(service_id, file_id):
re_upload_form = PDFUploadForm()
metadata = get_letter_metadata(service_id, file_id)
original_filename = metadata.get('filename')
page_count = metadata.get('page_count')
status = metadata.get('status')
error_shortcode = metadata.get('message')
invalid_pages = metadata.get('invalid_pages')
recipient = format_recipient(metadata.get('recipient', ''))
if invalid_pages:
invalid_pages = json.loads(invalid_pages)
error_message = get_letter_validation_error(error_shortcode, invalid_pages, page_count)
template_dict = service_api_client.get_precompiled_template(service_id)
# Override pre compiled letter template postage to none as it has not yet been picked even though
# the pre compiled letter template has its postage set as second class as the DB currently requires
# a non null value of postage for letter templates
template_dict['postage'] = None
form = LetterUploadPostageForm()
template = get_template(
template_dict,
service_id,
letter_preview_url=url_for(
'.view_letter_upload_as_preview',
service_id=service_id,
file_id=file_id
),
page_count=page_count
)
return render_template(
'views/uploads/preview.html',
original_filename=original_filename,
template=template,
status=status,
file_id=file_id,
message=error_message,
error_code=error_shortcode,
form=form,
recipient=recipient,
re_upload_form=re_upload_form
)
def _check_notification(service_id, template_id, exception=None):
db_template = current_service.get_template_with_user_permission_or_403(
template_id, current_user)
email_reply_to = None
sms_sender = None
if db_template["template_type"] == "email":
email_reply_to = get_email_reply_to_address_from_session()
elif db_template["template_type"] == "sms":
sms_sender = get_sms_sender_from_session()
template = get_template(
db_template,
current_service,
show_recipient=True,
email_reply_to=email_reply_to,
sms_sender=sms_sender,
letter_preview_url=url_for(
".check_notification_preview",
service_id=service_id,
template_id=template_id,
filetype="png",
),
page_count=get_page_count_for_letter(db_template),
)
step_index = len(
fields_to_fill_in(
template,
prefill_current_user=(
session.get("send_step") == "main.send_test_step"),
))
back_link = get_back_link(service_id, template, step_index)
if (not session.get("recipient")
and db_template["template_type"] != "letter"
) or not all_placeholders_in_session(template.placeholders):
raise PermanentRedirect(back_link)
template.values = get_recipient_and_placeholders_from_session(
template.template_type)
return dict(
template=template,
back_link=back_link,
help=get_help_argument(),
**(get_template_error_dict(exception) if exception else {}),
)
def clone_template(dest, name, clone_name, path_function, template_folder):
"""Clones a template
Clones a template to the specified directory with the specified name.
Then builds the template's leaf node (which is the directory's leaf
node for a directory or the file if it's a file) and clones the source
directory to the leaf node.
Parameters:
dest (str): the path to clone the template to
name (str): the name of the template
clone_name (str): the name to call the new template
path_function (str): a reference to the correct path function to
execute.
template_folder (str): the path of the templates directory
Returns:
dict: indicates the status of the clone operation and a message
"""
message = None
is_successful = None
message_kwargs = dict(template_name=name)
src = os.path.join(template_folder, name)
dest = os.path.join(dest, clone_name)
if not get_template(name, template_folder):
message = ErrorMessage('template_missing', **message_kwargs)
is_successful = False
if is_successful is not False:
clone_status = path_function["execute"](src, dest)
if clone_status['is_successful']:
message = InfoMessage('template_cloned',
path=dest,
**message_kwargs)
is_successful = True
else:
message = ErrorMessage('clone_template', **message_kwargs)
is_successful = False
return dict(is_successful=is_successful, msg=message.get_message())
def view_template_versions(service_id, template_id):
return render_template(
"views/templates/choose_history.html",
versions=[
get_template(
template,
current_service,
letter_preview_url=url_for(
".view_template_version_preview",
service_id=service_id,
template_id=template_id,
version=template["version"],
filetype="png",
),
) for template in service_api_client.get_service_template_versions(
service_id, template_id)["data"]
],
)
def count_content_length(service_id, template_type):
if template_type not in {'sms', 'broadcast'}:
abort(404)
error, message = _get_content_count_error_and_message_for_template(
get_template({
'template_type': template_type,
'content': request.form.get('template_content', ''),
}, current_service)
)
return jsonify({
'html': render_template(
'partials/templates/content-count-message.html',
error=error,
message=message,
)
})
def delete_service_template(service_id, template_id):
template = current_service.get_template_with_user_permission_or_403(
template_id, current_user)
if request.method == 'POST':
service_api_client.delete_service_template(service_id, template_id)
return redirect(
url_for(
'.choose_template',
service_id=service_id,
template_folder_id=template['folder'],
))
try:
last_used_notification = template_statistics_client.get_last_used_date_for_template(
service_id, template['id'])
message = 'This template has never been used.' if not last_used_notification else \
'This template was last used {}.'.format(format_delta(last_used_notification))
except HTTPError as e:
if e.status_code == 404:
message = None
else:
raise e
flash([
"Are you sure you want to delete ‘{}’?".format(template['name']),
message
], 'delete')
return render_template(
'views/templates/template.html',
template=get_template(
template,
current_service,
letter_preview_url=url_for(
'no_cookie.view_letter_template_preview',
service_id=service_id,
template_id=template['id'],
filetype='png',
),
show_recipient=True,
),
user_has_template_permission=True,
)
def confirm_redact_template(service_id, template_id):
template = current_service.get_template_with_user_permission_or_403(template_id, current_user)
return render_template(
'views/templates/template.html',
template=get_template(
template,
current_service,
letter_preview_url=url_for(
'.view_letter_template_preview',
service_id=service_id,
template_id=template_id,
filetype='png',
),
show_recipient=True,
),
user_has_template_permission=True,
show_redaction_message=True,
)
def edit_service_template(service_id, template_id):
template = service_api_client.get_service_template(service_id, template_id)['data']
template['template_content'] = template['content']
form = form_objects[template['template_type']](**template)
if form.validate_on_submit():
subject = form.subject.data if hasattr(form, 'subject') else None
new_template = get_template({
'name': form.name.data,
'content': form.template_content.data,
'subject': subject,
'template_type': template['template_type'],
'id': template['id']
}, current_service)
template_change = get_template(template, current_service).compare_to(new_template)
if template_change.has_different_placeholders and not request.form.get('confirm'):
return render_template(
'views/templates/breaking-change.html',
template_change=template_change,
new_template={
'name': form.name.data,
'subject': subject,
'content': form.template_content.data,
},
column_headings=list(ascii_uppercase[:len(new_template.placeholders) + 1]),
example_rows=[
first_column_headings[new_template.template_type] + list(new_template.placeholders),
get_example_csv_rows(new_template),
get_example_csv_rows(new_template)
],
form=form
)
try:
service_api_client.update_service_template(
template_id,
form.name.data,
template['template_type'],
form.template_content.data,
service_id,
subject
)
except HTTPError as e:
if e.status_code == 400:
if '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:
raise e
else:
return redirect(url_for(
'.view_template',
service_id=service_id,
template_id=template_id
))
return render_template(
'views/edit-{}-template.html'.format(template['template_type']),
form=form,
template_id=template_id,
template_type=template['template_type'],
heading_action='Edit'
)
