darkhelm/notifications-admin
1
0
Fork 0
mirror of https://github.com/GSA/notifications-admin.git synced 2026-08-15 15:28:50 -04:00
Code Issues Packages Projects Releases Wiki Activity
Files
529d7df5f5fbf43c8d4eddba2570ef6907dcd69f
notifications-admin/app/main/views/templates.py

913 lines
32 KiB
Python
Raw Normal View History

Add warning message showing date template last used when deleting
2016-06-06 11:09:46 +01:00
from datetime import datetime, timedelta
Make example on send look more like a spreadsheet Now that the example on the breaking changes page looks more like a spreadsheet, we should do the same thing for the downloadable example on the send page.
2016-05-31 14:18:35 +01:00
from string import ascii_uppercase
Warn users a template change will break things When a user adds or removes placeholders in their template we should consider this a ‘breaking change’ and warn them accordingly. Implementing this mostly relies on using https://github.com/alphagov/notifications-utils/pull/37 Temporarily storing the new template until the user confirms that they want to make the changes in done using hidden fields. This is a bit hacky, but the complexity of making sessions interact with WTForms was just too much to handle. This commit also changes the example spreadsheet that we show on this page to look more like a spreadsheet.
2016-05-27 16:21:29 +01:00
Enforce order and style of imports Done using isort[1], with the following command: ``` isort -rc ./app ./tests ``` Adds linting to the `run_tests.sh` script to stop badly-sorted imports getting re-introduced. Chosen style is ‘Vertical Hanging Indent’ with trailing commas, because I think it gives the cleanest diffs, eg: ``` from third_party import ( lib1, lib2, lib3, lib4, ) ``` 1. https://pypi.python.org/pypi/isort
2018-02-20 11:22:17 +00:00
from dateutil.parser import parse
Remove anything to do with DVLA format letters
2018-03-02 14:03:32 +00:00
from flask import abort, flash, redirect, render_template, request, url_for
Enforce order and style of imports Done using isort[1], with the following command: ``` isort -rc ./app ./tests ``` Adds linting to the `run_tests.sh` script to stop badly-sorted imports getting re-introduced. Chosen style is ‘Vertical Hanging Indent’ with trailing commas, because I think it gives the cleanest diffs, eg: ``` from third_party import ( lib1, lib2, lib3, lib4, ) ``` 1. https://pypi.python.org/pypi/isort
2018-02-20 11:22:17 +00:00
from flask_login import current_user, login_required
Allow letter templates to select the default contact block from the list
2018-01-03 10:44:36 +00:00
from markupsafe import Markup
Enforce order and style of imports Done using isort[1], with the following command: ``` isort -rc ./app ./tests ``` Adds linting to the `run_tests.sh` script to stop badly-sorted imports getting re-introduced. Chosen style is ‘Vertical Hanging Indent’ with trailing commas, because I think it gives the cleanest diffs, eg: ``` from third_party import ( lib1, lib2, lib3, lib4, ) ``` 1. https://pypi.python.org/pypi/isort
2018-02-20 11:22:17 +00:00
from notifications_python_client.errors import HTTPError
Allow letter templates to select the default contact block from the list
2018-01-03 10:44:36 +00:00
from notifications_utils.formatters import nl2br
Handle multi-column recipients Implements https://github.com/alphagov/notifications-utils/pull/81 Handles addresses as multiple columns: - in ‘Send yourself a test’ - in example CSV files - in validating that a CSV file has recipients (eg at least an ‘address line 1’ and ‘postcode’ column) - when showing the contents of a CSV file As few UI changes as possible, once we have the thing working end-to-end we can think about how the UI might need to work differently.
2016-11-10 13:39:05 +00:00
from notifications_utils.recipients import first_column_headings
Add view for a single template > At the moment, we have an all email templates page, and an edit an > individual page. > > This gets messy when we refer to templates like the dashboard and the > activity views. We solve this currently by using anchor links to the > list page, but this is clunky. > > So lets add it, then update the links on the dash and activity to the > new view page. > > Should be a link from the view a single template page, to the template > hub page. https://www.pivotaltracker.com/story/show/117349227
2016-04-12 09:55:51 +01:00
Add option to copy existing template when adding Sometimes when setting up a service you might have a few very similar templates, in which only a small amount of content. Or you might even have a few of services, which are used by different teams but have similar templates. Copy and pasting, especially from one service to another, is a pain. This commit makes it easier by allowing users to copy an existing template when choosing to add a new one, instead of starting from scratch.
2018-07-19 12:30:04 +01:00
from app import (
current_service,
service_api_client,
show list of template folders on the choose templates page Not linking anywhere yet. Also not sorted, and not filtered by parent_id.
2018-11-01 17:11:58 +00:00
template_folder_api_client,
Add option to copy existing template when adding Sometimes when setting up a service you might have a few very similar templates, in which only a small amount of content. Or you might even have a few of services, which are used by different teams but have similar templates. Copy and pasting, especially from one service to another, is a pain. This commit makes it easier by allowing users to copy an existing template when choosing to add a new one, instead of starting from scratch.
2018-07-19 12:30:04 +01:00
template_statistics_client,
user_api_client,
)
Add routing and pages for managing templates So that users can see what it the flow is like to: - add new templates - edit existing templates
2015-12-20 00:00:01 +00:00
from app.main import main
Add find-as-you-type on the choose template page Not everyone knows how to use `ctrl` + `f`, and it’s not scoped to just the list of templates. The template you want to work with is often not the first one in the list, but ordering by created at is useful for other reasons (mainly around first time use). This commit adds a find as you type control which aims to give users a quick way of getting to the template they want to work with.
2017-03-14 10:46:38 +00:00
from app.main.forms import (
ChooseTemplateType,
EmailTemplateForm,
LetterTemplateForm,
Edit template postage from a separate view
2019-01-29 15:43:59 +00:00
LetterTemplatePostageForm,
Add find-as-you-type on the choose template page Not everyone knows how to use `ctrl` + `f`, and it’s not scoped to just the list of templates. The template you want to work with is often not the first one in the list, but ordering by created at is useful for other reasons (mainly around first time use). This commit adds a find as you type control which aims to give users a quick way of getting to the template they want to work with.
2017-03-14 10:46:38 +00:00
SearchTemplatesForm,
Allow letter templates to select the default contact block from the list
2018-01-03 10:44:36 +00:00
SetTemplateSenderForm,
Enforce order and style of imports Done using isort[1], with the following command: ``` isort -rc ./app ./tests ``` Adds linting to the `run_tests.sh` script to stop badly-sorted imports getting re-introduced. Chosen style is ‘Vertical Hanging Indent’ with trailing commas, because I think it gives the cleanest diffs, eg: ``` from third_party import ( lib1, lib2, lib3, lib4, ) ``` 1. https://pypi.python.org/pypi/isort
2018-02-20 11:22:17 +00:00
SMSTemplateForm,
Show form elements for templates and folders This commit adds: - checkboxes to let you select a template or folder - radio buttons to let you select where to move those template(s) and/or folder(s) to It only does the `get` part of this work; handling the `post` and calling API will be done in a subsequent commit.
2018-11-08 11:56:29 +00:00
TemplateAndFoldersSelectionForm,
show list of template folders on the choose templates page Not linking anywhere yet. Also not sorted, and not filtered by parent_id.
2018-11-01 17:11:58 +00:00
TemplateFolderForm,
Add find-as-you-type on the choose template page Not everyone knows how to use `ctrl` + `f`, and it’s not scoped to just the list of templates. The template you want to work with is often not the first one in the list, but ordering by created at is useful for other reasons (mainly around first time use). This commit adds a find as you type control which aims to give users a quick way of getting to the template they want to work with.
2017-03-14 10:46:38 +00:00
)
Allow letter templates to select the default contact block from the list
2018-01-03 10:44:36 +00:00
from app.main.views.send import get_example_csv_rows, get_sender_details
Use service model for the copy page The view here is rebuilding a pseudo-service object. Now that service objects have templates it’s cleaner to use the actual service object. Requires a small change to the `templates_by_type` method so that it can filter by one or many template types (a user should be able to copy any template whose type is enabled for their service, and the service they’re copying from).
2018-10-26 16:30:37 +01:00
from app.models.service import Service
Allow users to navigate folders when copying We already have a pattern for navigation folders and searching for templates – let’s use it for the copy page too. And I reckon we can represent services as folders if the user has multiple services they could copy a template from.
2019-01-07 14:49:33 +00:00
from app.models.template_list import TemplateList, TemplateLists
Enforce order and style of imports Done using isort[1], with the following command: ``` isort -rc ./app ./tests ``` Adds linting to the `run_tests.sh` script to stop badly-sorted imports getting re-introduced. Chosen style is ‘Vertical Hanging Indent’ with trailing commas, because I think it gives the cleanest diffs, eg: ``` from third_party import ( lib1, lib2, lib3, lib4, ) ``` 1. https://pypi.python.org/pypi/isort
2018-02-20 11:22:17 +00:00
from app.template_previews import TemplatePreview, get_page_count_for_letter
from app.utils import (
email_or_sms_not_enabled,
get_template,
Fix ‘Back’ link from first step of fix one off If you skip past the templates page (because you don’t have the edit permission) but then click back you end up in a loop which redirects you to the page you’re already on. This commit makes sure that you’re sent back a step further, so you don’t get stuck in that loop.
2018-08-09 16:29:51 +01:00
should_skip_template_page,
Enforce order and style of imports Done using isort[1], with the following command: ``` isort -rc ./app ./tests ``` Adds linting to the `run_tests.sh` script to stop badly-sorted imports getting re-introduced. Chosen style is ‘Vertical Hanging Indent’ with trailing commas, because I think it gives the cleanest diffs, eg: ``` from third_party import ( lib1, lib2, lib3, lib4, ) ``` 1. https://pypi.python.org/pypi/isort
2018-02-20 11:22:17 +00:00
user_has_permissions,
)
Add routing and pages for managing templates So that users can see what it the flow is like to: - add new templates - edit existing templates
2015-12-20 00:00:01 +00:00
Add basic flow for adding email _or_ sms templates Templates now have: - a type (email or sms) - a subject (if they are email templates) We don’t want two completely separate view files for email and SMS, because they would have an enormous amount of repetition. So this commit adds - different templates for SMS and email templates - different form objects for SMS and email templates …and wires them up.
2016-02-22 14:45:13 +00:00
form_objects = {
'email': EmailTemplateForm,
Sprinkle `letter` throughout the app Let users create/edit/delete letter templates. Let them upload a CSV file or send a test against a letter template. Big assumption at the moment is that addresses only have one line, and therefore one column in the CSV file.
2016-11-08 13:12:07 +00:00
'sms': SMSTemplateForm,
'letter': LetterTemplateForm
Add basic flow for adding email _or_ sms templates Templates now have: - a type (email or sms) - a subject (if they are email templates) We don’t want two completely separate view files for email and SMS, because they would have an enormous amount of repetition. So this commit adds - different templates for SMS and email templates - different form objects for SMS and email templates …and wires them up.
2016-02-22 14:45:13 +00:00
}
Add routing and pages for managing templates So that users can see what it the flow is like to: - add new templates - edit existing templates
2015-12-20 00:00:01 +00:00
Make list of templates filterable by type When users are trying to find a template there’s a fair chance that they know whether or not it’s an email/text message/(letter) that they’re looking for. Making them scroll past a whole bunch of templates of a different type means it will take them longer to find the template they are looking for. We already have search on the templates page, but this is only good for where they can remember the name of the template. This will be sometimes but not always. This commit adds some navigation to filter down the list of templates to only show one type at a time. By default it will show all templates. It adapts the pattern we use for filtering notifications by sending/failed/delivered, but without the counts of how many things are in each bucket (I don’t think there’s any value in knowing you have X text message templates; on this page you only really care about the one template you’re looking for). _Note: required re-arranging the functions in `templates.py`. The route for `/template/:uuid` needs to come before the route for `template/:string` otherwise Flask tries to interpret a template’s ID as its type.
2017-06-13 15:28:33 +01:00
@main.route("/services/<service_id>/templates/<uuid:template_id>")
Add view for a single template > At the moment, we have an all email templates page, and an edit an > individual page. > > This gets messy when we refer to templates like the dashboard and the > activity views. We solve this currently by using anchor links to the > list page, but this is clunky. > > So lets add it, then update the links on the dash and activity to the > new view page. > > Should be a link from the view a single template page, to the template > hub page. https://www.pivotaltracker.com/story/show/117349227
2016-04-12 09:55:51 +01:00
@login_required
Let users with empty permissions see certain pages We’re going to make it possible for some users to be members of a service, but not have any permissions (not even `view_activity`). There are some pages that these users should still be able to see These are the pages that a user with ‘basic view’ would have been able to see, excluding those that let them send messages.
2018-08-06 11:09:57 +01:00
@user_has_permissions()
Add view for a single template > At the moment, we have an all email templates page, and an edit an > individual page. > > This gets messy when we refer to templates like the dashboard and the > activity views. We solve this currently by using anchor links to the > list page, but this is clunky. > > So lets add it, then update the links on the dash and activity to the > new view page. > > Should be a link from the view a single template page, to the template > hub page. https://www.pivotaltracker.com/story/show/117349227
2016-04-12 09:55:51 +01:00
def view_template(service_id, template_id):
Don’t skip template page for letters It’s too jarring to go straight from the list of templates to the upload addresses page. So while we don’t have sending a one-off letter as a thing, let’s keep the template page.
2018-08-07 11:43:33 +01:00
template = service_api_client.get_service_template(service_id, str(template_id))['data']
Fix ‘Back’ link from first step of fix one off If you skip past the templates page (because you don’t have the edit permission) but then click back you end up in a loop which redirects you to the page you’re already on. This commit makes sure that you’re sent back a step further, so you don’t get stuck in that loop.
2018-08-09 16:29:51 +01:00
if should_skip_template_page(template['template_type']):
Let caseworkers send one off messages The main task that we think ‘caseworker’ users do is send one off messages. So this commit: - makes sure users who don’t have the `view_activity` permission (ie not ‘admin’ users) can still send messages - adds navigation so that these users have a place to go from which to start the process of sending a one off message
2018-06-12 16:17:20 +01:00
return redirect(url_for(
'.send_one_off', service_id=service_id, template_id=template_id
))
Add multiple letter contact blocks for services from Admin app
2017-10-05 15:47:12 +01:00
if template["template_type"] == "letter":
letter_contact_details = service_api_client.get_letter_contacts(service_id)
default_letter_contact_block_id = next(
Fix bug when editing letter contact block from letter template page When viewing a letter template, there is a button to edit the letter contact block. This should take the user to the page to edit the letter contact block, but if a service has not set any letter contact blocks, the button was returning a 404 error. The code has now been changed so that if the service has no letter contact blocks the edit button will link to the page to add a letter contact block. Pivotal story: https://www.pivotaltracker.com/story/show/152881444
2017-12-12 12:16:17 +00:00
(x['id'] for x in letter_contact_details if x['is_default']), None
Add flake8 linting to project The GDS Way™[1] recommends using Flake8 to lint Python projects. This commit takes the Flake8 config from Digital Marketplace API[2] and removes the bits we don’t need. It changes the `max_complexity` setting to 14, which is the most complex code we have in this repo currently (we shouldn’t be writing code _more_ complex than what we already have). This commit also fixes the errors found by Flake8, which includes 6(!) tests which were never getting run because they had the same names as existing tests. Here is a full list of the errors that were found and fixed: ``` ./app/__init__.py:2:1: F401 're' imported but unused ./app/__init__.py:4:1: F401 'json' imported but unused ./app/__init__.py:8:1: F401 'dateutil' imported but unused ./app/__init__.py:11:1: F401 'flask.escape' imported but unused ./app/__init__.py:41:1: F401 'app.proxy_fix' imported but unused ./app/__init__.py:129:5: F821 undefined name 'proxy_fix' ./app/__init__.py:221:19: F821 undefined name 'highlight' ./app/__init__.py:221:35: F821 undefined name 'JavascriptLexer' ./app/__init__.py:221:54: F821 undefined name 'HtmlFormatter' ./app/config.py:2:1: F401 'datetime.timedelta' imported but unused ./app/event_handlers.py:2:1: F401 'flask_login.current_user' imported but unused ./app/utils.py:11:1: F401 'dateutil.parser' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.two_factor' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.notifications' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.add_service' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.forgot_password' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.inbound_number' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.styleguide' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.organisations' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.letter_jobs' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.verify' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.conversation' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.api_keys' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.send' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.dashboard' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.jobs' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.manage_users' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.sign_in' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.sign_out' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.code_not_received' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.invites' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.platform_admin' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.providers' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.service_settings' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.index' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.new_password' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.user_profile' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.feedback' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.choose_service' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.templates' imported but unused ./app/main/__init__.py:5:1: F401 'app.main.views.register' imported but unused ./app/main/forms.py:12:1: F401 'wtforms.SelectField' imported but unused ./app/main/views/api_keys.py:37:29: E241 multiple spaces after ':' ./app/main/views/feedback.py:3:1: F401 'flask.flash' imported but unused ./app/main/views/feedback.py:122:17: E123 closing bracket does not match indentation of opening bracket's line ./app/main/views/inbound_number.py:1:1: F401 'flask.url_for' imported but unused ./app/main/views/inbound_number.py:1:1: F401 'flask.session' imported but unused ./app/main/views/inbound_number.py:1:1: F401 'flask.redirect' imported but unused ./app/main/views/inbound_number.py:1:1: F401 'flask.request' imported but unused ./app/main/views/inbound_number.py:13:1: F401 'flask.jsonify' imported but unused ./app/main/views/jobs.py:31:1: F401 'app.utils.get_template' imported but unused ./app/main/views/letter_jobs.py:1:1: F401 'datetime' imported but unused ./app/main/views/letter_jobs.py:6:1: F401 'app.format_datetime_24h' imported but unused ./app/main/views/manage_users.py:111:9: E123 closing bracket does not match indentation of opening bracket's line ./app/main/views/notifications.py:121:5: F841 local variable 'status_args' is assigned to but never used ./app/main/views/organisations.py:1:1: F401 'flask.request' imported but unused ./app/main/views/service_settings.py:77:9: E123 closing bracket does not match indentation of opening bracket's line ./app/main/views/service_settings.py:82:9: E123 closing bracket does not match indentation of opening bracket's line ./app/main/views/service_settings.py:420:13: E123 closing bracket does not match indentation of opening bracket's line ./app/main/views/sign_in.py:12:1: F401 'flask_login.confirm_login' imported but unused ./app/main/views/sign_in.py:17:1: F401 'app.service_api_client' imported but unused ./app/main/views/sign_in.py:62:13: E123 closing bracket does not match indentation of opening bracket's line ./app/main/views/templates.py:4:1: F401 'flask.json' imported but unused ./app/main/views/templates.py:17:1: F401 'notifications_utils.formatters.escape_html' imported but unused ./app/main/views/templates.py:23:1: F401 'app.utils.get_help_argument' imported but unused ./app/main/views/templates.py:64:13: E123 closing bracket does not match indentation of opening bracket's line ./app/notify_client/service_api_client.py:6:1: F401 '.notification_api_client' imported but unused ./app/notify_client/user_api_client.py:1:1: F401 'uuid' imported but unused ./app/notify_client/user_api_client.py:3:1: F401 'flask.session' imported but unused ./tests/__init__.py:1:1: F401 'csv' imported but unused ./tests/app/main/test_asset_fingerprinter.py:2:1: F401 'os' imported but unused ./tests/app/main/test_asset_fingerprinter.py:4:1: F401 'unittest.mock' imported but unused ./tests/app/main/test_asset_fingerprinter.py:98:9: F841 local variable 'string_with_unicode_character' is assigned to but never used ./tests/app/main/test_errorhandlers.py:2:1: F401 'flask.url_for' imported but unused ./tests/app/main/test_permissions.py:26:13: F841 local variable 'response' is assigned to but never used ./tests/app/main/test_placeholder_form.py:3:1: F401 'wtforms.Label' imported but unused ./tests/app/main/test_placeholder_form.py:11:10: F841 local variable 'req' is assigned to but never used ./tests/app/main/test_two_factor_form.py:10:67: F841 local variable 'req' is assigned to but never used ./tests/app/main/test_two_factor_form.py:23:65: F841 local variable 'req' is assigned to but never used ./tests/app/main/test_two_factor_form.py:37:48: F841 local variable 'req' is assigned to but never used ./tests/app/main/test_two_factor_form.py:51:67: F841 local variable 'req' is assigned to but never used ./tests/app/main/test_two_factor_form.py:65:67: F841 local variable 'req' is assigned to but never used ./tests/app/main/views/test_accept_invite.py:356:5: F841 local variable 'element' is assigned to but never used ./tests/app/main/views/test_activity.py:11:1: F811 redefinition of unused 'mock_get_notifications' from line 11 ./tests/app/main/views/test_activity.py:18:1: F401 'datetime.datetime' imported but unused ./tests/app/main/views/test_activity.py:102:5: F841 local variable 'content' is assigned to but never used ./tests/app/main/views/test_activity.py:104:5: F841 local variable 'notification' is assigned to but never used ./tests/app/main/views/test_activity.py:337:5: F841 local variable '_notifications_mock' is assigned to but never used ./tests/app/main/views/test_activity.py:373:13: E126 continuation line over-indented for hanging indent ./tests/app/main/views/test_activity.py:378:9: E121 continuation line under-indented for hanging indent ./tests/app/main/views/test_activity.py:404:13: E126 continuation line over-indented for hanging indent ./tests/app/main/views/test_activity.py:407:9: E121 continuation line under-indented for hanging indent ./tests/app/main/views/test_api_keys.py:354:5: F841 local variable 'response' is assigned to but never used ./tests/app/main/views/test_conversation.py:5:1: F401 'bs4.BeautifulSoup' imported but unused ./tests/app/main/views/test_conversation.py:198:5: F841 local variable 'mock_get_inbound_sms' is assigned to but never used ./tests/app/main/views/test_dashboard.py:53:5: F841 local variable 'mock_template_stats' is assigned to but never used ./tests/app/main/views/test_dashboard.py:72:5: F841 local variable 'mock_template_stats' is assigned to but never used ./tests/app/main/views/test_jobs.py:2:1: F401 'uuid' imported but unused ./tests/app/main/views/test_jobs.py:3:1: F401 'urllib.parse.urlparse' imported but unused ./tests/app/main/views/test_jobs.py:3:1: F401 'urllib.parse.quote' imported but unused ./tests/app/main/views/test_jobs.py:3:1: F401 'urllib.parse.parse_qs' imported but unused ./tests/app/main/views/test_jobs.py:9:1: F401 'app.main.views.jobs.get_status_filters' imported but unused ./tests/app/main/views/test_jobs.py:10:1: F401 'tests.notification_json' imported but unused ./tests/app/main/views/test_letters.py:6:1: F401 'tests.service_json' imported but unused ./tests/app/main/views/test_notifications.py:5:1: F401 'app.utils.REQUESTED_STATUSES' imported but unused ./tests/app/main/views/test_notifications.py:5:1: F401 'app.utils.DELIVERED_STATUSES' imported but unused ./tests/app/main/views/test_notifications.py:5:1: F401 'app.utils.SENDING_STATUSES' imported but unused ./tests/app/main/views/test_notifications.py:5:1: F401 'app.utils.FAILURE_STATUSES' imported but unused ./tests/app/main/views/test_platform_admin.py:242:13: E126 continuation line over-indented for hanging indent ./tests/app/main/views/test_platform_admin.py:247:13: E126 continuation line over-indented for hanging indent ./tests/app/main/views/test_send.py:3:1: F401 'unittest.mock.Mock' imported but unused ./tests/app/main/views/test_send.py:18:1: F811 redefinition of unused 'mock_get_service' from line 18 ./tests/app/main/views/test_send.py:18:1: F401 'tests.conftest.multiple_letter_contact_blocks' imported but unused ./tests/app/main/views/test_send.py:18:1: F401 'tests.conftest.no_sms_senders' imported but unused ./tests/app/main/views/test_send.py:18:1: F401 'tests.conftest.multiple_sms_senders' imported but unused ./tests/app/main/views/test_send.py:18:1: F401 'tests.conftest.no_letter_contact_blocks' imported but unused ./tests/app/main/views/test_send.py:102:5: F841 local variable 'response' is assigned to but never used ./tests/app/main/views/test_send.py:870:5: F841 local variable 'response' is assigned to but never used ./tests/app/main/views/test_send.py:1367:5: F841 local variable 'service_id' is assigned to but never used ./tests/app/main/views/test_send.py:1451:13: E126 continuation line over-indented for hanging indent ./tests/app/main/views/test_send.py:1620:80: E226 missing whitespace around arithmetic operator ./tests/app/main/views/test_send.py:1909:13: E126 continuation line over-indented for hanging indent ./tests/app/main/views/test_send.py:1912:9: E121 continuation line under-indented for hanging indent ./tests/app/main/views/test_service_settings.py:13:1: F811 redefinition of unused 'no_reply_to_email_addresses' from line 13 ./tests/app/main/views/test_service_settings.py:13:1: F401 'tests.conftest.single_reply_to_email_address' imported but unused ./tests/app/main/views/test_service_settings.py:28:5: E123 closing bracket does not match indentation of opening bracket's line ./tests/app/main/views/test_service_settings.py:104:1: F811 redefinition of unused 'single_reply_to_email_address' from line 13 ./tests/app/main/views/test_service_settings.py:166:1: F811 redefinition of unused 'single_reply_to_email_address' from line 13 ./tests/app/main/views/test_service_settings.py:186:5: F841 local variable 'mocked_get_fn' is assigned to but never used ./tests/app/main/views/test_service_settings.py:217:1: F811 redefinition of unused 'single_reply_to_email_address' from line 13 ./tests/app/main/views/test_service_settings.py:237:1: F811 redefinition of unused 'single_reply_to_email_address' from line 13 ./tests/app/main/views/test_service_settings.py:257:1: F811 redefinition of unused 'single_reply_to_email_address' from line 13 ./tests/app/main/views/test_service_settings.py:307:1: F811 redefinition of unused 'single_reply_to_email_address' from line 13 ./tests/app/main/views/test_service_settings.py:340:1: F811 redefinition of unused 'single_reply_to_email_address' from line 13 ./tests/app/main/views/test_service_settings.py:466:1: F811 redefinition of unused 'single_reply_to_email_address' from line 13 ./tests/app/main/views/test_service_settings.py:555:1: F811 redefinition of unused 'single_reply_to_email_address' from line 13 ./tests/app/main/views/test_service_settings.py:615:1: F811 redefinition of unused 'single_reply_to_email_address' from line 13 ./tests/app/main/views/test_service_settings.py:719:1: F811 redefinition of unused 'single_reply_to_email_address' from line 13 ./tests/app/main/views/test_service_settings.py:874:5: F841 local variable 'page' is assigned to but never used ./tests/app/main/views/test_service_settings.py:902:5: F841 local variable 'page' is assigned to but never used ./tests/app/main/views/test_service_settings.py:954:5: F841 local variable 'page' is assigned to but never used ./tests/app/main/views/test_service_settings.py:986:5: F841 local variable 'page' is assigned to but never used ./tests/app/main/views/test_service_settings.py:1101:1: F811 redefinition of unused 'single_reply_to_email_address' from line 13 ./tests/app/main/views/test_service_settings.py:1121:1: F811 redefinition of unused 'single_reply_to_email_address' from line 13 ./tests/app/main/views/test_service_settings.py:1271:1: F811 redefinition of unused 'test_set_letter_contact_block_saves' from line 1189 ./tests/app/main/views/test_service_settings.py:1433:5: F841 local variable 'page' is assigned to but never used ./tests/app/main/views/test_service_settings.py:1495:5: F841 local variable 'mocked_get_fn' is assigned to but never used ./tests/app/main/views/test_service_settings.py:1540:5: F841 local variable 'mocked_get_fn' is assigned to but never used ./tests/app/main/views/test_service_settings.py:1570:1: F811 redefinition of unused 'single_reply_to_email_address' from line 13 ./tests/app/main/views/test_service_settings.py:1589:1: F811 redefinition of unused 'single_reply_to_email_address' from line 13 ./tests/app/main/views/test_service_settings.py:1621:1: F811 redefinition of unused 'single_reply_to_email_address' from line 13 ./tests/app/main/views/test_service_settings.py:1641:1: F811 redefinition of unused 'single_reply_to_email_address' from line 13 ./tests/app/main/views/test_service_settings.py:1658:1: F811 redefinition of unused 'single_reply_to_email_address' from line 13 ./tests/app/main/views/test_service_settings.py:1676:1: F811 redefinition of unused 'single_reply_to_email_address' from line 13 ./tests/app/main/views/test_service_settings.py:1697:1: F811 redefinition of unused 'single_reply_to_email_address' from line 13 ./tests/app/main/views/test_service_settings.py:1759:1: F811 redefinition of unused 'single_reply_to_email_address' from line 13 ./tests/app/main/views/test_service_settings.py:1775:1: F811 redefinition of unused 'single_reply_to_email_address' from line 13 ./tests/app/main/views/test_templates.py:3:1: F401 'uuid' imported but unused ./tests/app/main/views/test_templates.py:11:1: F401 'tests.conftest.mock_get_user' imported but unused ./tests/app/main/views/test_templates.py:514:1: F811 redefinition of unused 'mock_get_user' from line 11 ./tests/app/main/views/test_templates.py:672:1: F811 redefinition of unused 'mock_get_user' from line 11 ./tests/app/main/views/test_templates.py:795:1: F811 redefinition of unused 'mock_get_user' from line 11 ./tests/app/main/views/test_templates.py:835:1: F811 redefinition of unused 'mock_get_user' from line 11 ./tests/app/main/views/test_two_factor.py:67:13: E126 continuation line over-indented for hanging indent ./tests/app/notify_client/test_notification_client.py:79:5: F841 local variable 'mock_post' is assigned to but never used ``` 1. https://gds-way.cloudapps.digital/manuals/programming-languages/python/linting.html#how-to-use-flake8 2. https://github.com/alphagov/digitalmarketplace-api/blob/d5ab8afef4a0472f9d266d94ab4ffe1333a9aaad/.flake8
2017-10-18 14:51:26 +01:00
)
Add multiple letter contact blocks for services from Admin app
2017-10-05 15:47:12 +01:00
else:
default_letter_contact_block_id = None
Add view for a single template > At the moment, we have an all email templates page, and an edit an > individual page. > > This gets messy when we refer to templates like the dashboard and the > activity views. We solve this currently by using anchor links to the > list page, but this is clunky. > > So lets add it, then update the links on the dash and activity to the > new view page. > > Should be a link from the view a single template page, to the template > hub page. https://www.pivotaltracker.com/story/show/117349227
2016-04-12 09:55:51 +01:00
return render_template(
'views/templates/template.html',
Incorporate breaking utils changes Brings in: - [ ] https://github.com/alphagov/notifications-utils/pull/94
2016-12-08 11:50:59 +00:00
template=get_template(
Show all pages of a letter in the app In research we’ve seen two problems with the click-to-see-PDF thing: - it’s not very intuitive that the letter is clickable, or what you can expect when clicking the letter - people get lost of stuck in the PDF view because it opens in the same tab, or they open it in a new tab and then get find their way back, or … So this commit changes the show template page to show the entire contents of the letter, same as we do for emails and text messages. Right now it only does it on the view template page. I think we’ll have to work out a way of showing some kind of truncated version on the _Send yourself a test_ and _Preview_ pages. But that’s for later.
2017-04-20 10:40:15 +01:00
template,
Incorporate breaking utils changes Brings in: - [ ] https://github.com/alphagov/notifications-utils/pull/94
2016-12-08 11:50:59 +00:00
current_service,
Add remaining endpoints for PDFs and PNGs Right now we can show what a letter template looks like as a PDF or PNG. This commit completes the work so this is also possible when: - showing a template with the placeholders replaced - showing any version of a template Also removes dependency on `Exception().message`, which was deprecated in Python 2.6. See https://github.com/alphagov/notifications-utils/commit/97f82d565f3112926752ae382e723b0808a3135d for full details.
2016-12-20 14:38:34 +00:00
expand_emails=True,
Update utils with to make letters unclickable Brings in: - [ ] https://github.com/alphagov/notifications-utils/pull/159 Means: - renaming a bunch of things - removing any CSS that targeted the link, and making it target the containing element too
2017-04-28 16:04:52 +01:00
letter_preview_url=url_for(
'.view_letter_template_preview',
service_id=service_id,
template_id=template_id,
filetype='png',
),
Show recipient emails on individual template page Because we have space there’s no need to hide this now. Makes it less confusing to have parts of the email appear/disappear as you’re clicking through the flow.
2017-03-10 17:39:38 +00:00
show_recipient=True,
Show all pages of a letter everywhere Right now showing all the pages in full is the only way we have of showing a letter that makes sense to our users. Maybe in the future we show some kind of truncated version, but the end of the first page is not a good place to truncate the letter. This commit just extracts the code for showing multiple pages from the template view, refactors it for reuse, and includes it in the send views.
2017-05-11 12:01:51 +01:00
page_count=get_page_count_for_letter(template),
Show all pages of a letter in the app In research we’ve seen two problems with the click-to-see-PDF thing: - it’s not very intuitive that the letter is clickable, or what you can expect when clicking the letter - people get lost of stuck in the PDF view because it opens in the same tab, or they open it in a new tab and then get find their way back, or … So this commit changes the show template page to show the entire contents of the letter, same as we do for emails and text messages. Right now it only does it on the view template page. I think we’ll have to work out a way of showing some kind of truncated version on the _Send yourself a test_ and _Preview_ pages. But that’s for later.
2017-04-20 10:40:15 +01:00
),
Show postage on template page if service can choose postage and postage set on the template.
2018-12-18 15:43:36 +00:00
template_postage=template["postage"],
Allow one-off email sending to select the reply-to address
2017-10-16 16:35:35 +01:00
default_letter_contact_block_id=default_letter_contact_block_id,
Add view for a single template > At the moment, we have an all email templates page, and an edit an > individual page. > > This gets messy when we refer to templates like the dashboard and the > activity views. We solve this currently by using anchor links to the > list page, but this is clunky. > > So lets add it, then update the links on the dash and activity to the > new view page. > > Should be a link from the view a single template page, to the template > hub page. https://www.pivotaltracker.com/story/show/117349227
2016-04-12 09:55:51 +01:00
)
Change step 1 of tour to only show the template We’ve made a few changes to the tour recently, without changing the help text on the left hand side of the screen. So the stuff you see on the right side of the screen doesn’t quite sync up any more. This commit adds an extra, introductory page that just shows the template and a next button, which better matches the ‘every message starts with a template’ help text.
2017-06-29 10:02:53 +01:00
@main.route("/services/<service_id>/start-tour/<uuid:template_id>")
@login_required
remove admin_override from all has_permissions usage as previously pointed out, it's not used anywhere.
2018-03-01 10:30:17 +00:00
@user_has_permissions('view_activity')
Change step 1 of tour to only show the template We’ve made a few changes to the tour recently, without changing the help text on the left hand side of the screen. So the stuff you see on the right side of the screen doesn’t quite sync up any more. This commit adds an extra, introductory page that just shows the template and a next button, which better matches the ‘every message starts with a template’ help text.
2017-06-29 10:02:53 +01:00
def start_tour(service_id, template_id):
template = service_api_client.get_service_template(service_id, str(template_id))['data']
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',
)
Post to the API when moving folders and templates This commit adds logic to: - take the list of selected folders and templates - split it into two lists (of folders and templates) - `POST` that data to the API, to effect the movement of said folders and templates I’ve tried to architect it in such a way that we can easily add more template ‘operations’ in the future, as we add more forms to the choose template page.
2018-11-08 14:46:18 +00:00
@main.route("/services/<service_id>/templates", methods=['GET', 'POST'])
@main.route("/services/<service_id>/templates/folders/<template_folder_id>", methods=['GET', 'POST'])
@main.route("/services/<service_id>/templates/<template_type>", methods=['GET', 'POST'])
@main.route("/services/<service_id>/templates/<template_type>/folders/<template_folder_id>", methods=['GET', 'POST'])
Make list of templates filterable by type When users are trying to find a template there’s a fair chance that they know whether or not it’s an email/text message/(letter) that they’re looking for. Making them scroll past a whole bunch of templates of a different type means it will take them longer to find the template they are looking for. We already have search on the templates page, but this is only good for where they can remember the name of the template. This will be sometimes but not always. This commit adds some navigation to filter down the list of templates to only show one type at a time. By default it will show all templates. It adapts the pattern we use for filtering notifications by sending/failed/delivered, but without the counts of how many things are in each bucket (I don’t think there’s any value in knowing you have X text message templates; on this page you only really care about the one template you’re looking for). _Note: required re-arranging the functions in `templates.py`. The route for `/template/:uuid` needs to come before the route for `template/:string` otherwise Flask tries to interpret a template’s ID as its type.
2017-06-13 15:28:33 +01:00
@login_required
Let users with empty permissions see certain pages We’re going to make it possible for some users to be members of a service, but not have any permissions (not even `view_activity`). There are some pages that these users should still be able to see These are the pages that a user with ‘basic view’ would have been able to see, excluding those that let them send messages.
2018-08-06 11:09:57 +01:00
@user_has_permissions()
Link template folders to their contents Clicking on template folder navigates to a page that displays that folder's contents. This reuses the existing choose template view by adding a filter based on optional `template_folder_id` argument. Service model methods are rewritten to match `all_templates` and `get_template`. New `get_template_folder_path` method returns a list of folders (from root to the current one) that the selected folder is nested inside.
2018-11-05 16:25:19 +00:00
def choose_template(service_id, template_type='all', template_folder_id=None):
Only show template navigation when it’s useful There are lots of services that only send emails, or only send text messages. For these services, being able to filter the list of templates but type is pointless – it won’t cut the list down at all. This commit adds some logic to only show the navigation if the service has some variety of template types.
2017-06-13 15:27:29 +01:00
Allow any sub-items to be moved from a folder Since you can now see them when searching you should also be able to select and move them. Which means that they needed to be included in the `Form`’s list of possible choices of things to move.
2018-11-23 16:29:21 +00:00
template_list = TemplateList(current_service, template_type, template_folder_id)
Add helper function for filtering templates by type This code was making the view method more cluttered than it needed to be. Moving it will help make space for the `post` request handling code.
2018-11-08 14:16:46 +00:00
templates_and_folders_form = TemplateAndFoldersSelectionForm(
Allow any sub-items to be moved from a folder Since you can now see them when searching you should also be able to select and move them. Which means that they needed to be included in the `Form`’s list of possible choices of things to move.
2018-11-23 16:29:21 +00:00
all_template_folders=current_service.all_template_folders,
template_list=template_list,
Add helper function for filtering templates by type This code was making the view method more cluttered than it needed to be. Moving it will help make space for the `post` request handling code.
2018-11-08 14:16:46 +00:00
template_type=template_type,
Let users add new template from the choose page Since we’re letting users add new folders directly from the choose page it makes sense that they should also be able to add templates from there. This resolves the problem we saw in user research where people found it hard to know where to go to add a new folder when they were all behind one green button.
2018-11-28 13:48:13 +00:00
allow_adding_letter_template=current_service.has_permission('letter'),
allow_adding_copy_of_template=(
current_service.all_templates or
len(user_api_client.get_service_ids_for_user(current_user)) > 1
),
Add helper function for filtering templates by type This code was making the view method more cluttered than it needed to be. Moving it will help make space for the `post` request handling code.
2018-11-08 14:16:46 +00:00
)
Change move folder form to not have default radio btn and to show hint Updated the move folder form to add a hint for the radio button for the current folder saying 'current folder'. This hint does not get shown if you are viewing all folders (so you are not inside a folder). Also stopped a default radio button from being selected on the form.
2019-01-02 17:12:18 +00:00
option_hints = {template_folder_id: 'current folder'}
Display the template folders nested on the move template/folder form Before, all the folders were displayed in a list which was ordered but not nested. This changes the move form to nest the template folders.
2018-12-18 14:40:53 +00:00
split out new folder into two separate forms move_to_new_folder and add_new_folder are now two separate html fields and form items - so that we can more easily manipulate them on the front end
2018-11-20 18:03:57 +00:00
if request.method == 'POST' and templates_and_folders_form.validate_on_submit():
if not can_manage_folders():
abort(403)
flash error message when moving folder to itself
2018-12-05 11:30:47 +00:00
try:
return process_folder_management_form(templates_and_folders_form, template_folder_id)
only catch HTTPError also add tests
2018-12-17 15:24:24 +00:00
except HTTPError as e:
flash error message when moving folder to itself
2018-12-05 11:30:47 +00:00
flash(e.message)
add new folder from the choose template page
2018-11-14 17:30:22 +00:00
fix being able to add template without selecting a radio button
2018-12-07 16:38:48 +00:00
if 'templates_and_folders' in templates_and_folders_form.errors:
flash('Select at least one template or folder')
Make list of templates filterable by type When users are trying to find a template there’s a fair chance that they know whether or not it’s an email/text message/(letter) that they’re looking for. Making them scroll past a whole bunch of templates of a different type means it will take them longer to find the template they are looking for. We already have search on the templates page, but this is only good for where they can remember the name of the template. This will be sometimes but not always. This commit adds some navigation to filter down the list of templates to only show one type at a time. By default it will show all templates. It adapts the pattern we use for filtering notifications by sending/failed/delivered, but without the counts of how many things are in each bucket (I don’t think there’s any value in knowing you have X text message templates; on this page you only really care about the one template you’re looking for). _Note: required re-arranging the functions in `templates.py`. The route for `/template/:uuid` needs to come before the route for `template/:string` otherwise Flask tries to interpret a template’s ID as its type.
2017-06-13 15:28:33 +01:00
return render_template(
'views/templates/choose.html',
Create new folders inside the current folder When adding a new folder it is created inside the currently active one. The user is returned to the previously active folder page, which shows the added folder. This adds a new route to the add template/folder views. Thankfully, `url_for` recognizes when `template_folder_id` is `None` and will use the URL without `/folders/...`, so users without folder permissions should be unaffected by this change.
2018-11-06 13:06:35 +00:00
current_template_folder_id=template_folder_id,
Post to the API when moving folders and templates This commit adds logic to: - take the list of selected folders and templates - split it into two lists (of folders and templates) - `POST` that data to the API, to effect the movement of said folders and templates I’ve tried to architect it in such a way that we can easily add more template ‘operations’ in the future, as we add more forms to the choose template page.
2018-11-08 14:46:18 +00:00
can_manage_folders=can_manage_folders(),
Link template folders to their contents Clicking on template folder navigates to a page that displays that folder's contents. This reuses the existing choose template view by adding a filter based on optional `template_folder_id` argument. Service model methods are rewritten to match `all_templates` and `get_template`. New `get_template_folder_path` method returns a list of folders (from root to the current one) that the selected folder is nested inside.
2018-11-05 16:25:19 +00:00
template_folder_path=current_service.get_template_folder_path(template_folder_id),
Allow any sub-items to be moved from a folder Since you can now see them when searching you should also be able to select and move them. Which means that they needed to be included in the `Form`’s list of possible choices of things to move.
2018-11-23 16:29:21 +00:00
template_list=template_list,
Make search box appear based on all templates We reckon it’s jarring to have the search box appear and disappear as you navigate through the folders. Instead it should appear whenever your service has more things (templates or folders) than you can easily keep in your head (let’s go with 7 for now). This keeps the bahviour the same for current services that don’t have any folders.
2018-11-20 12:18:18 +00:00
show_search_box=current_service.count_of_templates_and_folders > 7,
Put templates on service model We do a lot of logic around choosing which templates to show. This logic is all inside one view method. It makes it cleaner to break this logic up into functions. But this would mean passing around variables from one function to another. Putting these methods onto a class (the service model) means that there’s a place to store this data (rather than having to pass it around a lot). Making this code more manageable is important so that when we have templates and folders it’s easy to encapsulate the logic around combining the two.
2018-10-25 07:59:50 +01:00
show_template_nav=(
current_service.has_multiple_template_types
Add Service.get_templates method with filters by type and folder With the addition of template folders we need to filter templates based on a combination of type and parent folder ID. This replaces the existing `templates_by_type` method with `get_templates`, which supports both type and parent folder filters, avoiding a need to create specific methods for each use case. We still need the templates property to exist in some way in order to cache it, but it needs to be clear that it's different from `.get_templates`. One option was to make it "private" (i.e. `_templates`), and always use `.get_templates` in the rest of the code, but this requires adding "include all folders" to `.get_templates`, which doesn't have an obvious interface since `parent_folder_id=None` already means "top-level only". This will probably come up again when we need to look into adding templates from nested folders into the page for live search, but for now renaming `Service.templates` to `.all_templates` makes it clear what the property contains.
2018-11-05 15:26:59 +00:00
and (len(current_service.all_templates) > 2)
Put templates on service model We do a lot of logic around choosing which templates to show. This logic is all inside one view method. It makes it cleaner to break this logic up into functions. But this would mean passing around variables from one function to another. Putting these methods onto a class (the service model) means that there’s a place to store this data (rather than having to pass it around a lot). Making this code more manageable is important so that when we have templates and folders it’s easy to encapsulate the logic around combining the two.
2018-10-25 07:59:50 +01:00
),
Add helper function for filtering templates by type This code was making the view method more cluttered than it needed to be. Moving it will help make space for the `post` request handling code.
2018-11-08 14:16:46 +00:00
template_nav_items=get_template_nav_items(template_folder_id),
Make list of templates filterable by type When users are trying to find a template there’s a fair chance that they know whether or not it’s an email/text message/(letter) that they’re looking for. Making them scroll past a whole bunch of templates of a different type means it will take them longer to find the template they are looking for. We already have search on the templates page, but this is only good for where they can remember the name of the template. This will be sometimes but not always. This commit adds some navigation to filter down the list of templates to only show one type at a time. By default it will show all templates. It adapts the pattern we use for filtering notifications by sending/failed/delivered, but without the counts of how many things are in each bucket (I don’t think there’s any value in knowing you have X text message templates; on this page you only really care about the one template you’re looking for). _Note: required re-arranging the functions in `templates.py`. The route for `/template/:uuid` needs to come before the route for `template/:string` otherwise Flask tries to interpret a template’s ID as its type.
2017-06-13 15:28:33 +01:00
template_type=template_type,
search_form=SearchTemplatesForm(),
change operations to kebab-case so that they better align with the front-end, where they'll be used in data attributes. Also, making the kebab case is nice because it doesn't give favouritism to either JS or python naming conventions
2018-12-04 14:47:05 +00:00
templates_and_folders_form=templates_and_folders_form,
Change move folder form to not have default radio btn and to show hint Updated the move folder form to add a hint for the radio button for the current folder saying 'current folder'. This hint does not get shown if you are viewing all folders (so you are not inside a folder). Also stopped a default radio button from being selected on the form.
2019-01-02 17:12:18 +00:00
move_to_children=templates_and_folders_form.move_to.children(),
option_hints=option_hints
Make list of templates filterable by type When users are trying to find a template there’s a fair chance that they know whether or not it’s an email/text message/(letter) that they’re looking for. Making them scroll past a whole bunch of templates of a different type means it will take them longer to find the template they are looking for. We already have search on the templates page, but this is only good for where they can remember the name of the template. This will be sometimes but not always. This commit adds some navigation to filter down the list of templates to only show one type at a time. By default it will show all templates. It adapts the pattern we use for filtering notifications by sending/failed/delivered, but without the counts of how many things are in each bucket (I don’t think there’s any value in knowing you have X text message templates; on this page you only really care about the one template you’re looking for). _Note: required re-arranging the functions in `templates.py`. The route for `/template/:uuid` needs to come before the route for `template/:string` otherwise Flask tries to interpret a template’s ID as its type.
2017-06-13 15:28:33 +01:00
)
move add new folder and move to folder into one dialog box this lets us combine the two actions to create "Move to a new folder". If the user hits enter rather than clicking a button, there is a hidden submit button that (for now) prevents them from taking any action. A future commit will try and understand what the user might be doing based on which fields are populated/selected.
2018-11-15 17:31:07 +00:00
def process_folder_management_form(form, current_folder_id):
new_folder_id = None
Let users add new template from the choose page Since we’re letting users add new folders directly from the choose page it makes sense that they should also be able to add templates from there. This resolves the problem we saw in user research where people found it hard to know where to go to add a new folder when they were all behind one green button.
2018-11-28 13:48:13 +00:00
if form.is_add_template_op:
return _add_template_by_type(
form.add_template_by_template_type.data,
current_folder_id,
)
if form.is_add_folder_op:
move add new folder and move to folder into one dialog box this lets us combine the two actions to create "Move to a new folder". If the user hits enter rather than clicking a button, there is a hidden submit button that (for now) prevents them from taking any action. A future commit will try and understand what the user might be doing based on which fields are populated/selected.
2018-11-15 17:31:07 +00:00
new_folder_id = template_folder_api_client.create_template_folder(
current_service.id,
split out new folder into two separate forms move_to_new_folder and add_new_folder are now two separate html fields and form items - so that we can more easily manipulate them on the front end
2018-11-20 18:03:57 +00:00
name=form.get_folder_name(),
move add new folder and move to folder into one dialog box this lets us combine the two actions to create "Move to a new folder". If the user hits enter rather than clicking a button, there is a hidden submit button that (for now) prevents them from taking any action. A future commit will try and understand what the user might be doing based on which fields are populated/selected.
2018-11-15 17:31:07 +00:00
parent_id=current_folder_id
)
if form.is_move_op:
# if we've just made a folder, we also want to move there
move_to_id = new_folder_id or form.move_to.data
current_service.move_to_folder(
ids_to_move=form.templates_and_folders.data,
move_to=move_to_id
)
Post to the API when moving folders and templates This commit adds logic to: - take the list of selected folders and templates - split it into two lists (of folders and templates) - `POST` that data to the API, to effect the movement of said folders and templates I’ve tried to architect it in such a way that we can easily add more template ‘operations’ in the future, as we add more forms to the choose template page.
2018-11-08 14:46:18 +00:00
move add new folder and move to folder into one dialog box this lets us combine the two actions to create "Move to a new folder". If the user hits enter rather than clicking a button, there is a hidden submit button that (for now) prevents them from taking any action. A future commit will try and understand what the user might be doing based on which fields are populated/selected.
2018-11-15 17:31:07 +00:00
return redirect(request.url)
Post to the API when moving folders and templates This commit adds logic to: - take the list of selected folders and templates - split it into two lists (of folders and templates) - `POST` that data to the API, to effect the movement of said folders and templates I’ve tried to architect it in such a way that we can easily add more template ‘operations’ in the future, as we add more forms to the choose template page.
2018-11-08 14:46:18 +00:00
Move labels of template types out of model The model shouldn’t have to care about how things are labelled in the UI, it should only care about the data.
2018-11-12 09:16:14 +00:00
def get_template_nav_label(value):
return {
'all': 'All',
'sms': 'Text message',
'email': 'Email',
'letter': 'Letter',
}[value]
Add helper function for filtering templates by type This code was making the view method more cluttered than it needed to be. Moving it will help make space for the `post` request handling code.
2018-11-08 14:16:46 +00:00
def get_template_nav_items(template_folder_id):
return [
(
Move labels of template types out of model The model shouldn’t have to care about how things are labelled in the UI, it should only care about the data.
2018-11-12 09:16:14 +00:00
get_template_nav_label(key),
Add helper function for filtering templates by type This code was making the view method more cluttered than it needed to be. Moving it will help make space for the `post` request handling code.
2018-11-08 14:16:46 +00:00
key,
url_for(
'.choose_template', service_id=current_service.id,
template_type=key, template_folder_id=template_folder_id
),
''
)
Move labels of template types out of model The model shouldn’t have to care about how things are labelled in the UI, it should only care about the data.
2018-11-12 09:16:14 +00:00
for key in ['all'] + current_service.available_template_types
Add helper function for filtering templates by type This code was making the view method more cluttered than it needed to be. Moving it will help make space for the `post` request handling code.
2018-11-08 14:16:46 +00:00
]
Post to the API when moving folders and templates This commit adds logic to: - take the list of selected folders and templates - split it into two lists (of folders and templates) - `POST` that data to the API, to effect the movement of said folders and templates I’ve tried to architect it in such a way that we can easily add more template ‘operations’ in the future, as we add more forms to the choose template page.
2018-11-08 14:46:18 +00:00
def can_manage_folders():
return (
current_service.has_permission('edit_folders') and
current_user.has_permissions('manage_templates')
)
remove pdf/png code from admin app entirely while PDFs work on paas, they only do that because it turns out the python buildpack happens to have imagemagick preinstalled - if that ever changes then it'd break. so move those to the template preview service. This also means we can get rid of weazyprint and wand dependencies
2017-04-10 17:25:08 +01:00
@main.route("/services/<service_id>/templates/<template_id>.<filetype>")
Add an endpoint for generating a PDF of a letter Previewing a letter is different to previewing an email or text message because: - a letter has a layout - the layout is fixed, ie it doesn’t depend on the user’s device - the ‘send yourself a test’ feature won’t be as useful because it has a lead time, so the feedback loop will be much longer For these reasons a HTML-only preview of the letter won’t be enough (we don’t think). A PDF is more appropriate because: - it can replicate the layout of the letter exactly - it is a print format, so the user could even print themselves a copy locally to get a feel for how it will look This commit makes use of Flask WeasyPrint [1] to take a HTML representation of the letter, convert it to a PDF and serve it back to the user. The actual work to generate the HTML and specify the layout is done in utils, same as we do for rendering other messages. 1. https://pythonhosted.org/Flask-WeasyPrint/
2016-11-27 18:10:18 +00:00
@login_required
Let users with empty permissions see certain pages We’re going to make it possible for some users to be members of a service, but not have any permissions (not even `view_activity`). There are some pages that these users should still be able to see These are the pages that a user with ‘basic view’ would have been able to see, excluding those that let them send messages.
2018-08-06 11:09:57 +01:00
@user_has_permissions()
Add cloudfoundry config values also added tests
2017-04-10 18:12:00 +01:00
def view_letter_template_preview(service_id, template_id, filetype):
don't allow bad filetypes to preview
2017-04-12 12:12:11 +01:00
if filetype not in ('pdf', 'png'):
abort(404)
Add an endpoint for generating a PDF of a letter Previewing a letter is different to previewing an email or text message because: - a letter has a layout - the layout is fixed, ie it doesn’t depend on the user’s device - the ‘send yourself a test’ feature won’t be as useful because it has a lead time, so the feedback loop will be much longer For these reasons a HTML-only preview of the letter won’t be enough (we don’t think). A PDF is more appropriate because: - it can replicate the layout of the letter exactly - it is a print format, so the user could even print themselves a copy locally to get a feel for how it will look This commit makes use of Flask WeasyPrint [1] to take a HTML representation of the letter, convert it to a PDF and serve it back to the user. The actual work to generate the HTML and specify the layout is done in utils, same as we do for rendering other messages. 1. https://pythonhosted.org/Flask-WeasyPrint/
2016-11-27 18:10:18 +00:00
remove pdf/png code from admin app entirely while PDFs work on paas, they only do that because it turns out the python buildpack happens to have imagemagick preinstalled - if that ever changes then it'd break. so move those to the template preview service. This also means we can get rid of weazyprint and wand dependencies
2017-04-10 17:25:08 +01:00
db_template = service_api_client.get_service_template(service_id, template_id)['data']
Allow letter templates to select the default contact block from the list
2018-01-03 10:44:36 +00:00
Show all pages of a letter in the app In research we’ve seen two problems with the click-to-see-PDF thing: - it’s not very intuitive that the letter is clickable, or what you can expect when clicking the letter - people get lost of stuck in the PDF view because it opens in the same tab, or they open it in a new tab and then get find their way back, or … So this commit changes the show template page to show the entire contents of the letter, same as we do for emails and text messages. Right now it only does it on the view template page. I think we’ll have to work out a way of showing some kind of truncated version on the _Send yourself a test_ and _Preview_ pages. But that’s for later.
2017-04-20 10:40:15 +01:00
return TemplatePreview.from_database_object(db_template, filetype, page=request.args.get('page'))
Add endpoint for generating an image of a letter The PDF preview is all good, but it’s hard, finickeity and feels dirty to embed a PDF in a web page. It’s a more natural thing to embed an image in a web page. So this commit adds another endpoint to return an image of a letter template. It generates this image from the PDF preview, so the stack looks like: 1. `template.png` (generated in admin) 2. `template.pdf` (generated in admin) 3. HTML preview (generated by a `Renderer` in utils) 4. `Template` instance 5. serialised template from API 6. Template stored in database The library used to convert the PDF to an image is Wand[1], which binds to ImageMagick underneath. So in order to get this working locally on a Mac you will probably need to do: `brew install imagemagick ghostscript cairo pango`. To get it working on Ubuntu/EC2 is an exercise left to the reader… 1. http://docs.wand-py.org/en/0.4.4/
2016-11-28 11:01:39 +00:00
Split endpoints that use templates We’ll need to reuse the logic for viewing images and PDFs of templates, so let’s have it in a shared method which the HTML endpoint then calls.
2016-12-20 11:56:22 +00:00
def _view_template_version(service_id, template_id, version, letters_as_pdf=False):
return dict(template=get_template(
Add remaining endpoints for PDFs and PNGs Right now we can show what a letter template looks like as a PDF or PNG. This commit completes the work so this is also possible when: - showing a template with the placeholders replaced - showing any version of a template Also removes dependency on `Exception().message`, which was deprecated in Python 2.6. See https://github.com/alphagov/notifications-utils/commit/97f82d565f3112926752ae382e723b0808a3135d for full details.
2016-12-20 14:38:34 +00:00
service_api_client.get_service_template(service_id, template_id, version=version)['data'],
Split endpoints that use templates We’ll need to reuse the logic for viewing images and PDFs of templates, so let’s have it in a shared method which the HTML endpoint then calls.
2016-12-20 11:56:22 +00:00
current_service,
expand_emails=True,
Add remaining endpoints for PDFs and PNGs Right now we can show what a letter template looks like as a PDF or PNG. This commit completes the work so this is also possible when: - showing a template with the placeholders replaced - showing any version of a template Also removes dependency on `Exception().message`, which was deprecated in Python 2.6. See https://github.com/alphagov/notifications-utils/commit/97f82d565f3112926752ae382e723b0808a3135d for full details.
2016-12-20 14:38:34 +00:00
letter_preview_url=url_for(
Update utils with to make letters unclickable Brings in: - [ ] https://github.com/alphagov/notifications-utils/pull/159 Means: - renaming a bunch of things - removing any CSS that targeted the link, and making it target the containing element too
2017-04-28 16:04:52 +01:00
'.view_template_version_preview',
Add remaining endpoints for PDFs and PNGs Right now we can show what a letter template looks like as a PDF or PNG. This commit completes the work so this is also possible when: - showing a template with the placeholders replaced - showing any version of a template Also removes dependency on `Exception().message`, which was deprecated in Python 2.6. See https://github.com/alphagov/notifications-utils/commit/97f82d565f3112926752ae382e723b0808a3135d for full details.
2016-12-20 14:38:34 +00:00
service_id=service_id,
template_id=template_id,
version=version,
Update utils with to make letters unclickable Brings in: - [ ] https://github.com/alphagov/notifications-utils/pull/159 Means: - renaming a bunch of things - removing any CSS that targeted the link, and making it target the containing element too
2017-04-28 16:04:52 +01:00
filetype='png',
Add remaining endpoints for PDFs and PNGs Right now we can show what a letter template looks like as a PDF or PNG. This commit completes the work so this is also possible when: - showing a template with the placeholders replaced - showing any version of a template Also removes dependency on `Exception().message`, which was deprecated in Python 2.6. See https://github.com/alphagov/notifications-utils/commit/97f82d565f3112926752ae382e723b0808a3135d for full details.
2016-12-20 14:38:34 +00:00
) if not letters_as_pdf else None
Split endpoints that use templates We’ll need to reuse the logic for viewing images and PDFs of templates, so let’s have it in a shared method which the HTML endpoint then calls.
2016-12-20 11:56:22 +00:00
))
Update all dates to use utc, only in the template is it converted to british time. Template versions and template version pages added. Fix merge changes.
2016-05-11 11:20:45 +01:00
@main.route("/services/<service_id>/templates/<template_id>/version/<int:version>")
@login_required
Let users with empty permissions see certain pages We’re going to make it possible for some users to be members of a service, but not have any permissions (not even `view_activity`). There are some pages that these users should still be able to see These are the pages that a user with ‘basic view’ would have been able to see, excluding those that let them send messages.
2018-08-06 11:09:57 +01:00
@user_has_permissions()
Update all dates to use utc, only in the template is it converted to british time. Template versions and template version pages added. Fix merge changes.
2016-05-11 11:20:45 +01:00
def view_template_version(service_id, template_id, version):
return render_template(
'views/templates/template_history.html',
Split endpoints that use templates We’ll need to reuse the logic for viewing images and PDFs of templates, so let’s have it in a shared method which the HTML endpoint then calls.
2016-12-20 11:56:22 +00:00
**_view_template_version(service_id=service_id, template_id=template_id, version=version)
Update all dates to use utc, only in the template is it converted to british time. Template versions and template version pages added. Fix merge changes.
2016-05-11 11:20:45 +01:00
)
remove pdf/png code from admin app entirely while PDFs work on paas, they only do that because it turns out the python buildpack happens to have imagemagick preinstalled - if that ever changes then it'd break. so move those to the template preview service. This also means we can get rid of weazyprint and wand dependencies
2017-04-10 17:25:08 +01:00
@main.route("/services/<service_id>/templates/<template_id>/version/<int:version>.<filetype>")
Add remaining endpoints for PDFs and PNGs Right now we can show what a letter template looks like as a PDF or PNG. This commit completes the work so this is also possible when: - showing a template with the placeholders replaced - showing any version of a template Also removes dependency on `Exception().message`, which was deprecated in Python 2.6. See https://github.com/alphagov/notifications-utils/commit/97f82d565f3112926752ae382e723b0808a3135d for full details.
2016-12-20 14:38:34 +00:00
@login_required
Let users with empty permissions see certain pages We’re going to make it possible for some users to be members of a service, but not have any permissions (not even `view_activity`). There are some pages that these users should still be able to see These are the pages that a user with ‘basic view’ would have been able to see, excluding those that let them send messages.
2018-08-06 11:09:57 +01:00
@user_has_permissions()
remove pdf/png code from admin app entirely while PDFs work on paas, they only do that because it turns out the python buildpack happens to have imagemagick preinstalled - if that ever changes then it'd break. so move those to the template preview service. This also means we can get rid of weazyprint and wand dependencies
2017-04-10 17:25:08 +01:00
def view_template_version_preview(service_id, template_id, version, filetype):
db_template = service_api_client.get_service_template(service_id, template_id, version=version)['data']
return TemplatePreview.from_database_object(db_template, filetype)
Add remaining endpoints for PDFs and PNGs Right now we can show what a letter template looks like as a PDF or PNG. This commit completes the work so this is also possible when: - showing a template with the placeholders replaced - showing any version of a template Also removes dependency on `Exception().message`, which was deprecated in Python 2.6. See https://github.com/alphagov/notifications-utils/commit/97f82d565f3112926752ae382e723b0808a3135d for full details.
2016-12-20 14:38:34 +00:00
Merge email, text message + letter templates pages Right now we have separate pages for email and text message templates. In the future we will also have a separate page for letter templates. This commit changes Notify to only have one page for all templates. What is the problem? --- The left-hand navigation is getting quite crowded, at 8 items for a service that can send letters. Research suggests that the number of objects an average human can hold in working memory is 7 ± 2 [1]. So we’re at the limit of how many items the navigation should have. In the future we will need to search/sort/filter templates by attributes other than type, for example: - show me the ‘confirmation’ templates - show me the most recently used templates - show me all templates containing the placeholder `((ref_no))` These are hypothetical for now, but these needs (or others) may become real in the future. At this point pre-filtering the list of templates by type would restrict what searches a user could do. So by making this change now we’re in a better position to iterate the design in the future. What’s the change? --- This commit replaces the ‘Email templates’, ‘Text message templates’ and ‘Letter templates’ pages with one page called ‘Templates’. This new templates page shows all the templates for the service, sorted by most recently created first (as before). To add a new template there is a new page with a form asking you what kind of template you want to create. This is necessary because in the past we knew what kind of template you wanted to create based on the kind you were looking at. What’s the impact of this change on new users? --- This change alters the onboarding process slightly. We still want to take people through the empty templates page from the call-to-action on the dashboard because it helps them understand that to send a message using Notify you need a template. But because we don’t have separate pages for emails/text messages we will have to send users through the extra step of choosing what kind of template to create. This is a bit clunkier on first use but: - it still gets the point across - it takes them through the actual flow they will be using to create new templates in the future (ie they’re learning how to use Notify, not just being taken through a special onboarding route) I’m not too worried about this change in terms of the experience for new users. Furthermore, by making it now we get to validate whether it’s causing any problems in the lab research booked for next week. What’s the impact of this change on current services? --- Looking at the top 15 services by number of templates[2], most are using either text messages or emails. So this change would not have a significant impact on these services because the page will not get any longer. In other words we wouldn’t be making it worse for them. Those services who do use both are not using as many templates. The worst-case scenario is SSCS, who have 16 templates, evenly split between email and text messages. So they would go from having 8 templates per page to 16, which is still less than half the number that HMPO or Digital Marketplace are managing. References --- 1. https://en.wikipedia.org/wiki/The_Magical_Number_Seven,_Plus_or_Minus_Two 2. Template usage by service Service name | Template count | Template types ---------------------------------------|----------------|--------------- Her Majesty's Passport Office | 40 | sms Digital Marketplace | 40 | email GovWifi-Staging | 19 | sms GovWifi | 18 | sms Digital Apprenticeship Service | 16 | email SSCS | 16 | both Crown Commercial Service MI Collection | 15 | email Help with Prison Visits | 12 | both Digital Future | 12 | email Export Licensing Service | 11 | email Civil Money Claims | 9 | both DVLA Drivers Medical Service | 9 | sms GOV.UK Notify | 8 | both Manage your benefit overpayments | 8 | both Tax Renewals | 8 | both
2017-02-28 12:16:35 +00:00
@main.route("/services/<service_id>/templates/add", methods=['GET', 'POST'])
Create new folders inside the current folder When adding a new folder it is created inside the currently active one. The user is returned to the previously active folder page, which shows the added folder. This adds a new route to the add template/folder views. Thankfully, `url_for` recognizes when `template_folder_id` is `None` and will use the URL without `/folders/...`, so users without folder permissions should be unaffected by this change.
2018-11-06 13:06:35 +00:00
@main.route("/services/<service_id>/templates/folders/<template_folder_id>/add", methods=['GET', 'POST'])
Merge email, text message + letter templates pages Right now we have separate pages for email and text message templates. In the future we will also have a separate page for letter templates. This commit changes Notify to only have one page for all templates. What is the problem? --- The left-hand navigation is getting quite crowded, at 8 items for a service that can send letters. Research suggests that the number of objects an average human can hold in working memory is 7 ± 2 [1]. So we’re at the limit of how many items the navigation should have. In the future we will need to search/sort/filter templates by attributes other than type, for example: - show me the ‘confirmation’ templates - show me the most recently used templates - show me all templates containing the placeholder `((ref_no))` These are hypothetical for now, but these needs (or others) may become real in the future. At this point pre-filtering the list of templates by type would restrict what searches a user could do. So by making this change now we’re in a better position to iterate the design in the future. What’s the change? --- This commit replaces the ‘Email templates’, ‘Text message templates’ and ‘Letter templates’ pages with one page called ‘Templates’. This new templates page shows all the templates for the service, sorted by most recently created first (as before). To add a new template there is a new page with a form asking you what kind of template you want to create. This is necessary because in the past we knew what kind of template you wanted to create based on the kind you were looking at. What’s the impact of this change on new users? --- This change alters the onboarding process slightly. We still want to take people through the empty templates page from the call-to-action on the dashboard because it helps them understand that to send a message using Notify you need a template. But because we don’t have separate pages for emails/text messages we will have to send users through the extra step of choosing what kind of template to create. This is a bit clunkier on first use but: - it still gets the point across - it takes them through the actual flow they will be using to create new templates in the future (ie they’re learning how to use Notify, not just being taken through a special onboarding route) I’m not too worried about this change in terms of the experience for new users. Furthermore, by making it now we get to validate whether it’s causing any problems in the lab research booked for next week. What’s the impact of this change on current services? --- Looking at the top 15 services by number of templates[2], most are using either text messages or emails. So this change would not have a significant impact on these services because the page will not get any longer. In other words we wouldn’t be making it worse for them. Those services who do use both are not using as many templates. The worst-case scenario is SSCS, who have 16 templates, evenly split between email and text messages. So they would go from having 8 templates per page to 16, which is still less than half the number that HMPO or Digital Marketplace are managing. References --- 1. https://en.wikipedia.org/wiki/The_Magical_Number_Seven,_Plus_or_Minus_Two 2. Template usage by service Service name | Template count | Template types ---------------------------------------|----------------|--------------- Her Majesty's Passport Office | 40 | sms Digital Marketplace | 40 | email GovWifi-Staging | 19 | sms GovWifi | 18 | sms Digital Apprenticeship Service | 16 | email SSCS | 16 | both Crown Commercial Service MI Collection | 15 | email Help with Prison Visits | 12 | both Digital Future | 12 | email Export Licensing Service | 11 | email Civil Money Claims | 9 | both DVLA Drivers Medical Service | 9 | sms GOV.UK Notify | 8 | both Manage your benefit overpayments | 8 | both Tax Renewals | 8 | both
2017-02-28 12:16:35 +00:00
@login_required
remove admin_override from all has_permissions usage as previously pointed out, it's not used anywhere.
2018-03-01 10:30:17 +00:00
@user_has_permissions('manage_templates')
Create new folders inside the current folder When adding a new folder it is created inside the currently active one. The user is returned to the previously active folder page, which shows the added folder. This adds a new route to the add template/folder views. Thankfully, `url_for` recognizes when `template_folder_id` is `None` and will use the URL without `/folders/...`, so users without folder permissions should be unaffected by this change.
2018-11-06 13:06:35 +00:00
def add_template_by_type(service_id, template_folder_id=None):
Merge email, text message + letter templates pages Right now we have separate pages for email and text message templates. In the future we will also have a separate page for letter templates. This commit changes Notify to only have one page for all templates. What is the problem? --- The left-hand navigation is getting quite crowded, at 8 items for a service that can send letters. Research suggests that the number of objects an average human can hold in working memory is 7 ± 2 [1]. So we’re at the limit of how many items the navigation should have. In the future we will need to search/sort/filter templates by attributes other than type, for example: - show me the ‘confirmation’ templates - show me the most recently used templates - show me all templates containing the placeholder `((ref_no))` These are hypothetical for now, but these needs (or others) may become real in the future. At this point pre-filtering the list of templates by type would restrict what searches a user could do. So by making this change now we’re in a better position to iterate the design in the future. What’s the change? --- This commit replaces the ‘Email templates’, ‘Text message templates’ and ‘Letter templates’ pages with one page called ‘Templates’. This new templates page shows all the templates for the service, sorted by most recently created first (as before). To add a new template there is a new page with a form asking you what kind of template you want to create. This is necessary because in the past we knew what kind of template you wanted to create based on the kind you were looking at. What’s the impact of this change on new users? --- This change alters the onboarding process slightly. We still want to take people through the empty templates page from the call-to-action on the dashboard because it helps them understand that to send a message using Notify you need a template. But because we don’t have separate pages for emails/text messages we will have to send users through the extra step of choosing what kind of template to create. This is a bit clunkier on first use but: - it still gets the point across - it takes them through the actual flow they will be using to create new templates in the future (ie they’re learning how to use Notify, not just being taken through a special onboarding route) I’m not too worried about this change in terms of the experience for new users. Furthermore, by making it now we get to validate whether it’s causing any problems in the lab research booked for next week. What’s the impact of this change on current services? --- Looking at the top 15 services by number of templates[2], most are using either text messages or emails. So this change would not have a significant impact on these services because the page will not get any longer. In other words we wouldn’t be making it worse for them. Those services who do use both are not using as many templates. The worst-case scenario is SSCS, who have 16 templates, evenly split between email and text messages. So they would go from having 8 templates per page to 16, which is still less than half the number that HMPO or Digital Marketplace are managing. References --- 1. https://en.wikipedia.org/wiki/The_Magical_Number_Seven,_Plus_or_Minus_Two 2. Template usage by service Service name | Template count | Template types ---------------------------------------|----------------|--------------- Her Majesty's Passport Office | 40 | sms Digital Marketplace | 40 | email GovWifi-Staging | 19 | sms GovWifi | 18 | sms Digital Apprenticeship Service | 16 | email SSCS | 16 | both Crown Commercial Service MI Collection | 15 | email Help with Prison Visits | 12 | both Digital Future | 12 | email Export Licensing Service | 11 | email Civil Money Claims | 9 | both DVLA Drivers Medical Service | 9 | sms GOV.UK Notify | 8 | both Manage your benefit overpayments | 8 | both Tax Renewals | 8 | both
2017-02-28 12:16:35 +00:00
form = ChooseTemplateType(
Make a service model and use for permissions Having the service floating about as JSON is a bit flakey. Could easily introduce a mistake where you mistype the name of a key and silently get `None`. Also means doing awkward things like `if 'permission' in current_service['permissions']`, whereas for users we can do the much cleaner `user.has_permission()`. So this commit: - introduces a model - adds a `.has_permission` method similar to the one we have for users
2018-07-20 08:43:02 +01:00
include_letters=current_service.has_permission('letter'),
Look at other services only if no templates This saves one call to the API or Redis in the common case where the current service does have templates. This is because `any()` evaluates all expressions before running, whereas `or` will only evaluate the second expression if the first returns `False`-y.
2018-12-03 13:19:28 +00:00
include_copy=(
Edit template postage from a separate view
2019-01-29 15:43:59 +00:00
current_service.all_templates or len(user_api_client.get_service_ids_for_user(current_user)) > 1
Look at other services only if no templates This saves one call to the API or Redis in the common case where the current service does have templates. This is because `any()` evaluates all expressions before running, whereas `or` will only evaluate the second expression if the first returns `False`-y.
2018-12-03 13:19:28 +00:00
),
add new template folder The add new templates page now has option to add template folders. Tweaked wording of other options and h1 to clarify options since it's not all about templates any more. Added api client and stuff for it
2018-11-01 15:33:09 +00:00
include_folder=current_service.has_permission('edit_folders')
Merge email, text message + letter templates pages Right now we have separate pages for email and text message templates. In the future we will also have a separate page for letter templates. This commit changes Notify to only have one page for all templates. What is the problem? --- The left-hand navigation is getting quite crowded, at 8 items for a service that can send letters. Research suggests that the number of objects an average human can hold in working memory is 7 ± 2 [1]. So we’re at the limit of how many items the navigation should have. In the future we will need to search/sort/filter templates by attributes other than type, for example: - show me the ‘confirmation’ templates - show me the most recently used templates - show me all templates containing the placeholder `((ref_no))` These are hypothetical for now, but these needs (or others) may become real in the future. At this point pre-filtering the list of templates by type would restrict what searches a user could do. So by making this change now we’re in a better position to iterate the design in the future. What’s the change? --- This commit replaces the ‘Email templates’, ‘Text message templates’ and ‘Letter templates’ pages with one page called ‘Templates’. This new templates page shows all the templates for the service, sorted by most recently created first (as before). To add a new template there is a new page with a form asking you what kind of template you want to create. This is necessary because in the past we knew what kind of template you wanted to create based on the kind you were looking at. What’s the impact of this change on new users? --- This change alters the onboarding process slightly. We still want to take people through the empty templates page from the call-to-action on the dashboard because it helps them understand that to send a message using Notify you need a template. But because we don’t have separate pages for emails/text messages we will have to send users through the extra step of choosing what kind of template to create. This is a bit clunkier on first use but: - it still gets the point across - it takes them through the actual flow they will be using to create new templates in the future (ie they’re learning how to use Notify, not just being taken through a special onboarding route) I’m not too worried about this change in terms of the experience for new users. Furthermore, by making it now we get to validate whether it’s causing any problems in the lab research booked for next week. What’s the impact of this change on current services? --- Looking at the top 15 services by number of templates[2], most are using either text messages or emails. So this change would not have a significant impact on these services because the page will not get any longer. In other words we wouldn’t be making it worse for them. Those services who do use both are not using as many templates. The worst-case scenario is SSCS, who have 16 templates, evenly split between email and text messages. So they would go from having 8 templates per page to 16, which is still less than half the number that HMPO or Digital Marketplace are managing. References --- 1. https://en.wikipedia.org/wiki/The_Magical_Number_Seven,_Plus_or_Minus_Two 2. Template usage by service Service name | Template count | Template types ---------------------------------------|----------------|--------------- Her Majesty's Passport Office | 40 | sms Digital Marketplace | 40 | email GovWifi-Staging | 19 | sms GovWifi | 18 | sms Digital Apprenticeship Service | 16 | email SSCS | 16 | both Crown Commercial Service MI Collection | 15 | email Help with Prison Visits | 12 | both Digital Future | 12 | email Export Licensing Service | 11 | email Civil Money Claims | 9 | both DVLA Drivers Medical Service | 9 | sms GOV.UK Notify | 8 | both Manage your benefit overpayments | 8 | both Tax Renewals | 8 | both
2017-02-28 12:16:35 +00:00
)
if form.validate_on_submit():
Let users add new template from the choose page Since we’re letting users add new folders directly from the choose page it makes sense that they should also be able to add templates from there. This resolves the problem we saw in user research where people found it hard to know where to go to add a new folder when they were all behind one green button.
2018-11-28 13:48:13 +00:00
return _add_template_by_type(form.template_type.data, template_folder_id)
Make blank letter template on adding When adding a letter it’s hard to know how the stuff you’re typing is going to look. So rather than go straight to the edit form let’s show users a blank letter. They can then choose which part of it they want to edit first. And will have a better idea of how their changes are going to show up. In research we also saw nervousness around saving a template and wanting to ‘preview’ it first. Hopefully this flow will make people feel less precious about saving a template because they’ve already done it once just by creating the template.
2017-03-15 10:53:24 +00:00
Let users add new template from the choose page Since we’re letting users add new folders directly from the choose page it makes sense that they should also be able to add templates from there. This resolves the problem we saw in user research where people found it hard to know where to go to add a new folder when they were all behind one green button.
2018-11-28 13:48:13 +00:00
return render_template('views/templates/add.html', form=form)
Make blank letter template on adding When adding a letter it’s hard to know how the stuff you’re typing is going to look. So rather than go straight to the edit form let’s show users a blank letter. They can then choose which part of it they want to edit first. And will have a better idea of how their changes are going to show up. In research we also saw nervousness around saving a template and wanting to ‘preview’ it first. Hopefully this flow will make people feel less precious about saving a template because they’ve already done it once just by creating the template.
2017-03-15 10:53:24 +00:00
Merge email, text message + letter templates pages Right now we have separate pages for email and text message templates. In the future we will also have a separate page for letter templates. This commit changes Notify to only have one page for all templates. What is the problem? --- The left-hand navigation is getting quite crowded, at 8 items for a service that can send letters. Research suggests that the number of objects an average human can hold in working memory is 7 ± 2 [1]. So we’re at the limit of how many items the navigation should have. In the future we will need to search/sort/filter templates by attributes other than type, for example: - show me the ‘confirmation’ templates - show me the most recently used templates - show me all templates containing the placeholder `((ref_no))` These are hypothetical for now, but these needs (or others) may become real in the future. At this point pre-filtering the list of templates by type would restrict what searches a user could do. So by making this change now we’re in a better position to iterate the design in the future. What’s the change? --- This commit replaces the ‘Email templates’, ‘Text message templates’ and ‘Letter templates’ pages with one page called ‘Templates’. This new templates page shows all the templates for the service, sorted by most recently created first (as before). To add a new template there is a new page with a form asking you what kind of template you want to create. This is necessary because in the past we knew what kind of template you wanted to create based on the kind you were looking at. What’s the impact of this change on new users? --- This change alters the onboarding process slightly. We still want to take people through the empty templates page from the call-to-action on the dashboard because it helps them understand that to send a message using Notify you need a template. But because we don’t have separate pages for emails/text messages we will have to send users through the extra step of choosing what kind of template to create. This is a bit clunkier on first use but: - it still gets the point across - it takes them through the actual flow they will be using to create new templates in the future (ie they’re learning how to use Notify, not just being taken through a special onboarding route) I’m not too worried about this change in terms of the experience for new users. Furthermore, by making it now we get to validate whether it’s causing any problems in the lab research booked for next week. What’s the impact of this change on current services? --- Looking at the top 15 services by number of templates[2], most are using either text messages or emails. So this change would not have a significant impact on these services because the page will not get any longer. In other words we wouldn’t be making it worse for them. Those services who do use both are not using as many templates. The worst-case scenario is SSCS, who have 16 templates, evenly split between email and text messages. So they would go from having 8 templates per page to 16, which is still less than half the number that HMPO or Digital Marketplace are managing. References --- 1. https://en.wikipedia.org/wiki/The_Magical_Number_Seven,_Plus_or_Minus_Two 2. Template usage by service Service name | Template count | Template types ---------------------------------------|----------------|--------------- Her Majesty's Passport Office | 40 | sms Digital Marketplace | 40 | email GovWifi-Staging | 19 | sms GovWifi | 18 | sms Digital Apprenticeship Service | 16 | email SSCS | 16 | both Crown Commercial Service MI Collection | 15 | email Help with Prison Visits | 12 | both Digital Future | 12 | email Export Licensing Service | 11 | email Civil Money Claims | 9 | both DVLA Drivers Medical Service | 9 | sms GOV.UK Notify | 8 | both Manage your benefit overpayments | 8 | both Tax Renewals | 8 | both
2017-02-28 12:16:35 +00:00
Let users add new template from the choose page Since we’re letting users add new folders directly from the choose page it makes sense that they should also be able to add templates from there. This resolves the problem we saw in user research where people found it hard to know where to go to add a new folder when they were all behind one green button.
2018-11-28 13:48:13 +00:00
def _add_template_by_type(template_type, template_folder_id):
if template_type == 'copy-existing':
return redirect(url_for(
'.choose_template_to_copy',
service_id=current_service.id,
))
if template_type == 'letter':
blank_letter = service_api_client.create_service_template(
'Untitled',
'letter',
'Body',
current_service.id,
'Main heading',
'normal',
template_folder_id
)
return redirect(url_for(
'.view_template',
service_id=current_service.id,
template_id=blank_letter['data']['id'],
))
if email_or_sms_not_enabled(template_type, current_service.permissions):
return redirect(url_for(
'.action_blocked',
service_id=current_service.id,
notification_type=template_type,
return_to='add_new_template',
template_id='0'
))
else:
return redirect(url_for(
'.add_service_template',
service_id=current_service.id,
template_type=template_type,
template_folder_id=template_folder_id,
))
Merge email, text message + letter templates pages Right now we have separate pages for email and text message templates. In the future we will also have a separate page for letter templates. This commit changes Notify to only have one page for all templates. What is the problem? --- The left-hand navigation is getting quite crowded, at 8 items for a service that can send letters. Research suggests that the number of objects an average human can hold in working memory is 7 ± 2 [1]. So we’re at the limit of how many items the navigation should have. In the future we will need to search/sort/filter templates by attributes other than type, for example: - show me the ‘confirmation’ templates - show me the most recently used templates - show me all templates containing the placeholder `((ref_no))` These are hypothetical for now, but these needs (or others) may become real in the future. At this point pre-filtering the list of templates by type would restrict what searches a user could do. So by making this change now we’re in a better position to iterate the design in the future. What’s the change? --- This commit replaces the ‘Email templates’, ‘Text message templates’ and ‘Letter templates’ pages with one page called ‘Templates’. This new templates page shows all the templates for the service, sorted by most recently created first (as before). To add a new template there is a new page with a form asking you what kind of template you want to create. This is necessary because in the past we knew what kind of template you wanted to create based on the kind you were looking at. What’s the impact of this change on new users? --- This change alters the onboarding process slightly. We still want to take people through the empty templates page from the call-to-action on the dashboard because it helps them understand that to send a message using Notify you need a template. But because we don’t have separate pages for emails/text messages we will have to send users through the extra step of choosing what kind of template to create. This is a bit clunkier on first use but: - it still gets the point across - it takes them through the actual flow they will be using to create new templates in the future (ie they’re learning how to use Notify, not just being taken through a special onboarding route) I’m not too worried about this change in terms of the experience for new users. Furthermore, by making it now we get to validate whether it’s causing any problems in the lab research booked for next week. What’s the impact of this change on current services? --- Looking at the top 15 services by number of templates[2], most are using either text messages or emails. So this change would not have a significant impact on these services because the page will not get any longer. In other words we wouldn’t be making it worse for them. Those services who do use both are not using as many templates. The worst-case scenario is SSCS, who have 16 templates, evenly split between email and text messages. So they would go from having 8 templates per page to 16, which is still less than half the number that HMPO or Digital Marketplace are managing. References --- 1. https://en.wikipedia.org/wiki/The_Magical_Number_Seven,_Plus_or_Minus_Two 2. Template usage by service Service name | Template count | Template types ---------------------------------------|----------------|--------------- Her Majesty's Passport Office | 40 | sms Digital Marketplace | 40 | email GovWifi-Staging | 19 | sms GovWifi | 18 | sms Digital Apprenticeship Service | 16 | email SSCS | 16 | both Crown Commercial Service MI Collection | 15 | email Help with Prison Visits | 12 | both Digital Future | 12 | email Export Licensing Service | 11 | email Civil Money Claims | 9 | both DVLA Drivers Medical Service | 9 | sms GOV.UK Notify | 8 | both Manage your benefit overpayments | 8 | both Tax Renewals | 8 | both
2017-02-28 12:16:35 +00:00
Add option to copy existing template when adding Sometimes when setting up a service you might have a few very similar templates, in which only a small amount of content. Or you might even have a few of services, which are used by different teams but have similar templates. Copy and pasting, especially from one service to another, is a pain. This commit makes it easier by allowing users to copy an existing template when choosing to add a new one, instead of starting from scratch.
2018-07-19 12:30:04 +01:00
@main.route("/services/<service_id>/templates/copy")
Allow users to navigate folders when copying We already have a pattern for navigation folders and searching for templates – let’s use it for the copy page too. And I reckon we can represent services as folders if the user has multiple services they could copy a template from.
2019-01-07 14:49:33 +00:00
@main.route("/services/<service_id>/templates/copy/from-folder/<uuid:from_folder>")
@main.route("/services/<service_id>/templates/copy/from-service/<uuid:from_service>")
@main.route("/services/<service_id>/templates/copy/from-service/<uuid:from_service>/from-folder/<uuid:from_folder>")
Add option to copy existing template when adding Sometimes when setting up a service you might have a few very similar templates, in which only a small amount of content. Or you might even have a few of services, which are used by different teams but have similar templates. Copy and pasting, especially from one service to another, is a pain. This commit makes it easier by allowing users to copy an existing template when choosing to add a new one, instead of starting from scratch.
2018-07-19 12:30:04 +01:00
@login_required
@user_has_permissions('manage_templates')
Allow users to navigate folders when copying We already have a pattern for navigation folders and searching for templates – let’s use it for the copy page too. And I reckon we can represent services as folders if the user has multiple services they could copy a template from.
2019-01-07 14:49:33 +00:00
def choose_template_to_copy(
service_id,
from_service=None,
from_folder=None,
):
if from_service:
current_user.belongs_to_service_or_403(from_service)
service = Service(
service_api_client.get_service(from_service)['data']
)
return render_template(
'views/templates/copy.html',
services_templates_and_folders=TemplateList(
service,
template_folder_id=from_folder,
),
template_folder_path=service.get_template_folder_path(from_folder),
from_service=service,
search_form=SearchTemplatesForm(),
)
else:
return render_template(
'views/templates/copy.html',
services_templates_and_folders=TemplateLists([
Service(service) for service in
user_api_client.get_services_for_user(current_user)
]),
search_form=SearchTemplatesForm(),
)
Add option to copy existing template when adding Sometimes when setting up a service you might have a few very similar templates, in which only a small amount of content. Or you might even have a few of services, which are used by different teams but have similar templates. Copy and pasting, especially from one service to another, is a pain. This commit makes it easier by allowing users to copy an existing template when choosing to add a new one, instead of starting from scratch.
2018-07-19 12:30:04 +01:00
@main.route("/services/<service_id>/templates/copy/<uuid:template_id>", methods=['GET', 'POST'])
@login_required
@user_has_permissions('manage_templates')
def copy_template(service_id, template_id):
Allow users to navigate folders when copying We already have a pattern for navigation folders and searching for templates – let’s use it for the copy page too. And I reckon we can represent services as folders if the user has multiple services they could copy a template from.
2019-01-07 14:49:33 +00:00
current_user.belongs_to_service_or_403(request.args.get('from_service'))
Add option to copy existing template when adding Sometimes when setting up a service you might have a few very similar templates, in which only a small amount of content. Or you might even have a few of services, which are used by different teams but have similar templates. Copy and pasting, especially from one service to another, is a pain. This commit makes it easier by allowing users to copy an existing template when choosing to add a new one, instead of starting from scratch.
2018-07-19 12:30:04 +01:00
template = service_api_client.get_service_template(
request.args.get('from_service'),
str(template_id),
)['data']
Edit, don’t duplicate, existing templates
2018-07-31 16:20:10 +01:00
if request.method == 'POST':
return add_service_template(service_id, template['template_type'])
Add option to copy existing template when adding Sometimes when setting up a service you might have a few very similar templates, in which only a small amount of content. Or you might even have a few of services, which are used by different teams but have similar templates. Copy and pasting, especially from one service to another, is a pain. This commit makes it easier by allowing users to copy an existing template when choosing to add a new one, instead of starting from scratch.
2018-07-19 12:30:04 +01:00
template['template_content'] = template['content']
Put ‘copy’ at end of new template name In multiple user research sessions we’ve noticed people edit the auto-generated template name to put something at the end of it. This is fiddly because of the quotes we put around the name: > Copy of ‘Exiting template’ It also means that if they keep our prefix then the template doesn’t sort alongside the one it’s replacing. This commit changes the name of copied templates to better match the behaviour our users are showing. Also adds a bit of auto numbering, just as a nice detail.
2018-11-13 15:06:39 +00:00
template['name'] = _get_template_copy_name(template, current_service.all_templates)
Add option to copy existing template when adding Sometimes when setting up a service you might have a few very similar templates, in which only a small amount of content. Or you might even have a few of services, which are used by different teams but have similar templates. Copy and pasting, especially from one service to another, is a pain. This commit makes it easier by allowing users to copy an existing template when choosing to add a new one, instead of starting from scratch.
2018-07-19 12:30:04 +01:00
form = form_objects[template['template_type']](**template)
return render_template(
'views/edit-{}-template.html'.format(template['template_type']),
form=form,
template_type=template['template_type'],
heading_action='Add',
services=user_api_client.get_service_ids_for_user(current_user),
)
Put ‘copy’ at end of new template name In multiple user research sessions we’ve noticed people edit the auto-generated template name to put something at the end of it. This is fiddly because of the quotes we put around the name: > Copy of ‘Exiting template’ It also means that if they keep our prefix then the template doesn’t sort alongside the one it’s replacing. This commit changes the name of copied templates to better match the behaviour our users are showing. Also adds a bit of auto numbering, just as a nice detail.
2018-11-13 15:06:39 +00:00
def _get_template_copy_name(template, existing_templates):
template_names = [existing['name'] for existing in existing_templates]
for index in reversed(range(1, 10)):
if '{} (copy {})'.format(template['name'], index) in template_names:
return '{} (copy {})'.format(template['name'], index + 1)
if '{} (copy)'.format(template['name']) in template_names:
return '{} (copy 2)'.format(template['name'])
return '{} (copy)'.format(template['name'])
Stop users from editing/adding templates without the correct permission If sending SMS is disabled for a service, it should not be possible to add or modify SMS templates. If a user tries to do this, they should see a different page with a link to go back. The same thing should happen with email templates.
2017-06-30 10:55:59 +01:00
@main.route("/services/<service_id>/templates/action-blocked/<notification_type>/<return_to>/<template_id>")
@login_required
remove admin_override from all has_permissions usage as previously pointed out, it's not used anywhere.
2018-03-01 10:30:17 +00:00
@user_has_permissions('manage_templates')
Stop users from editing/adding templates without the correct permission If sending SMS is disabled for a service, it should not be possible to add or modify SMS templates. If a user tries to do this, they should see a different page with a link to go back. The same thing should happen with email templates.
2017-06-30 10:55:59 +01:00
def action_blocked(service_id, notification_type, return_to, template_id):
if notification_type == 'sms':
notification_type = 'text messages'
elif notification_type == 'email':
notification_type = 'emails'
return render_template(
'views/templates/action_blocked.html',
service_id=service_id,
notification_type=notification_type,
return_to=return_to,
template_id=template_id
)
add new template folder The add new templates page now has option to add template folders. Tweaked wording of other options and h1 to clarify options since it's not all about templates any more. Added api client and stuff for it
2018-11-01 15:33:09 +00:00
@main.route("/services/<service_id>/templates/add-folder", methods=['GET', 'POST'])
Create new folders inside the current folder When adding a new folder it is created inside the currently active one. The user is returned to the previously active folder page, which shows the added folder. This adds a new route to the add template/folder views. Thankfully, `url_for` recognizes when `template_folder_id` is `None` and will use the URL without `/folders/...`, so users without folder permissions should be unaffected by this change.
2018-11-06 13:06:35 +00:00
@main.route("/services/<service_id>/templates/folders/<template_folder_id>/add-folder", methods=['GET', 'POST'])
Build delete folder endpoint that calls template_folders_api_client
2018-11-13 17:56:47 +00:00
@login_required
@user_has_permissions('manage_templates')
Create new folders inside the current folder When adding a new folder it is created inside the currently active one. The user is returned to the previously active folder page, which shows the added folder. This adds a new route to the add template/folder views. Thankfully, `url_for` recognizes when `template_folder_id` is `None` and will use the URL without `/folders/...`, so users without folder permissions should be unaffected by this change.
2018-11-06 13:06:35 +00:00
def add_template_folder(service_id, template_folder_id=None):
add new template folder The add new templates page now has option to add template folders. Tweaked wording of other options and h1 to clarify options since it's not all about templates any more. Added api client and stuff for it
2018-11-01 15:33:09 +00:00
if not current_service.has_permission('edit_folders'):
abort(403)
add template folder form
2018-11-01 16:02:43 +00:00
form = TemplateFolderForm()
add new template folder The add new templates page now has option to add template folders. Tweaked wording of other options and h1 to clarify options since it's not all about templates any more. Added api client and stuff for it
2018-11-01 15:33:09 +00:00
if form.validate_on_submit():
Create new folders inside the current folder When adding a new folder it is created inside the currently active one. The user is returned to the previously active folder page, which shows the added folder. This adds a new route to the add template/folder views. Thankfully, `url_for` recognizes when `template_folder_id` is `None` and will use the URL without `/folders/...`, so users without folder permissions should be unaffected by this change.
2018-11-06 13:06:35 +00:00
template_folder_api_client.create_template_folder(
current_service.id, name=form.name.data, parent_id=template_folder_id
)
add new template folder The add new templates page now has option to add template folders. Tweaked wording of other options and h1 to clarify options since it's not all about templates any more. Added api client and stuff for it
2018-11-01 15:33:09 +00:00
return redirect(
Create new folders inside the current folder When adding a new folder it is created inside the currently active one. The user is returned to the previously active folder page, which shows the added folder. This adds a new route to the add template/folder views. Thankfully, `url_for` recognizes when `template_folder_id` is `None` and will use the URL without `/folders/...`, so users without folder permissions should be unaffected by this change.
2018-11-06 13:06:35 +00:00
url_for('.choose_template', service_id=service_id, template_folder_id=template_folder_id)
add new template folder The add new templates page now has option to add template folders. Tweaked wording of other options and h1 to clarify options since it's not all about templates any more. Added api client and stuff for it
2018-11-01 15:33:09 +00:00
)
add template folder form
2018-11-01 16:02:43 +00:00
return render_template(
'views/templates/add-template-folder.html',
form=form
)
add new template folder The add new templates page now has option to add template folders. Tweaked wording of other options and h1 to clarify options since it's not all about templates any more. Added api client and stuff for it
2018-11-01 15:33:09 +00:00
Add a new endpoint for managing a folder, use it to rename folder - Add a GET / POST view: manage template folder - Add a template for that view, where a user can rename their folder - Add an API client method for updating a folder - Test the new feature, including the test that service without permissions cannot manage a folder
2018-11-12 16:37:37 +00:00
@main.route("/services/<service_id>/templates/folders/<template_folder_id>/manage", methods=['GET', 'POST'])
Build delete folder endpoint that calls template_folders_api_client
2018-11-13 17:56:47 +00:00
@login_required
@user_has_permissions('manage_templates')
Add a new endpoint for managing a folder, use it to rename folder - Add a GET / POST view: manage template folder - Add a template for that view, where a user can rename their folder - Add an API client method for updating a folder - Test the new feature, including the test that service without permissions cannot manage a folder
2018-11-12 16:37:37 +00:00
def manage_template_folder(service_id, template_folder_id):
if not current_service.has_permission('edit_folders'):
abort(403)
Pre-populate rename folder form with current name Often people will be editing the existing name, not changing it completely. This matches what we do when someone wants to rename their template or service.
2018-11-13 16:05:05 +00:00
form = TemplateFolderForm(
name=current_service.get_template_folder(template_folder_id)['name']
)
Add a new endpoint for managing a folder, use it to rename folder - Add a GET / POST view: manage template folder - Add a template for that view, where a user can rename their folder - Add an API client method for updating a folder - Test the new feature, including the test that service without permissions cannot manage a folder
2018-11-12 16:37:37 +00:00
if form.validate_on_submit():
template_folder_api_client.update_template_folder(
current_service.id, template_folder_id, name=form.name.data
)
return redirect(
url_for('.choose_template', service_id=service_id, template_folder_id=template_folder_id)
)
return render_template(
'views/templates/manage-template-folder.html',
form=form,
template_folder_path=current_service.get_template_folder_path(template_folder_id),
Add a delete folder link to manage folder page and basic delete endpoint
2018-11-13 15:49:25 +00:00
current_service_id=current_service.id,
Fix breadcrumbs on manage_template_folder page
2018-11-16 11:21:27 +00:00
template_folder_id=template_folder_id,
template_type="all"
Add a new endpoint for managing a folder, use it to rename folder - Add a GET / POST view: manage template folder - Add a template for that view, where a user can rename their folder - Add an API client method for updating a folder - Test the new feature, including the test that service without permissions cannot manage a folder
2018-11-12 16:37:37 +00:00
)
Build delete folder endpoint that calls template_folders_api_client
2018-11-13 17:56:47 +00:00
@main.route("/services/<service_id>/templates/folders/<template_folder_id>/delete", methods=['GET', 'POST'])
@login_required
@user_has_permissions('manage_templates')
Add a delete folder link to manage folder page and basic delete endpoint
2018-11-13 15:49:25 +00:00
def delete_template_folder(service_id, template_folder_id):
Refactor how we get template folder on delete page It’s a bit obtuse to look it up from the `template_folder_path`, especially now that we have a specific method on the model that does the exact thing.
2018-11-20 10:43:56 +00:00
Add a delete folder link to manage folder page and basic delete endpoint
2018-11-13 15:49:25 +00:00
if not current_service.has_permission('edit_folders'):
abort(403)
Refactor how we get template folder on delete page It’s a bit obtuse to look it up from the `template_folder_path`, especially now that we have a specific method on the model that does the exact thing.
2018-11-20 10:43:56 +00:00
template_folder = current_service.get_template_folder(template_folder_id)
form = TemplateFolderForm(name=template_folder['name'])
Update content of deletion messages following review
2018-11-14 17:07:23 +00:00
Check if folder is empty before calling the api
2018-11-14 15:57:23 +00:00
if len(current_service.get_template_folders_and_templates(
template_type="all", template_folder_id=template_folder_id
)) > 0:
Refactor how we get template folder on delete page It’s a bit obtuse to look it up from the `template_folder_path`, especially now that we have a specific method on the model that does the exact thing.
2018-11-20 10:43:56 +00:00
flash("You must empty this folder before you can delete it".format(template_folder['name']), 'info')
Update content of deletion messages following review
2018-11-14 17:07:23 +00:00
return redirect(
url_for(
'.choose_template', service_id=service_id, template_type="all", template_folder_id=template_folder_id
)
)
Check if folder is empty before calling the api
2018-11-14 15:57:23 +00:00
Add flash messages and error handling to delete folder flow
2018-11-14 12:16:57 +00:00
if request.method == 'POST':
try:
template_folder_api_client.delete_template_folder(current_service.id, template_folder_id)
Build delete folder endpoint that calls template_folders_api_client
2018-11-13 17:56:47 +00:00
Add flash messages and error handling to delete folder flow
2018-11-14 12:16:57 +00:00
return redirect(
Redirect to parent after deleting a folder You lose your place if, after deleting something that’s deeply nested, you return to the root level.
2018-11-20 10:44:09 +00:00
url_for('.choose_template', service_id=service_id, template_folder_id=template_folder['parent_id'])
Add flash messages and error handling to delete folder flow
2018-11-14 12:16:57 +00:00
)
except HTTPError as e:
msg = "Folder is not empty"
if e.status_code == 400 and msg in e.message:
Refactor how we get template folder on delete page It’s a bit obtuse to look it up from the `template_folder_path`, especially now that we have a specific method on the model that does the exact thing.
2018-11-20 10:43:56 +00:00
flash("You must empty this folder before you can delete it", 'info')
Update content of deletion messages following review
2018-11-14 17:07:23 +00:00
return redirect(
url_for(
'.choose_template',
service_id=service_id,
template_type="all",
template_folder_id=template_folder_id
)
)
Add flash messages and error handling to delete folder flow
2018-11-14 12:16:57 +00:00
else:
abort(500, e)
Refactor how we get template folder on delete page It’s a bit obtuse to look it up from the `template_folder_path`, especially now that we have a specific method on the model that does the exact thing.
2018-11-20 10:43:56 +00:00
flash("Are you sure you want to delete the ‘{}’ folder?".format(template_folder['name']), 'delete')
Add flash messages and error handling to delete folder flow
2018-11-14 12:16:57 +00:00
return render_template(
'views/templates/manage-template-folder.html',
form=form,
Refactor how we get template folder on delete page It’s a bit obtuse to look it up from the `template_folder_path`, especially now that we have a specific method on the model that does the exact thing.
2018-11-20 10:43:56 +00:00
template_folder_path=current_service.get_template_folder_path(template_folder_id),
Add flash messages and error handling to delete folder flow
2018-11-14 12:16:57 +00:00
current_service_id=current_service.id,
Fix breadcrumbs on manage_template_folder page
2018-11-16 11:21:27 +00:00
template_folder_id=template_folder_id,
Hide name changing functionality when in folder deletion mode Also add 'back' link Also start work on additional tests for folder deletion flow
2018-11-16 15:10:12 +00:00
template_type="all",
Build delete folder endpoint that calls template_folders_api_client
2018-11-13 17:56:47 +00:00
)
Add a delete folder link to manage folder page and basic delete endpoint
2018-11-13 15:49:25 +00:00
Add basic flow for adding email _or_ sms templates Templates now have: - a type (email or sms) - a subject (if they are email templates) We don’t want two completely separate view files for email and SMS, because they would have an enormous amount of repetition. So this commit adds - different templates for SMS and email templates - different form objects for SMS and email templates …and wires them up.
2016-02-22 14:45:13 +00:00
@main.route("/services/<service_id>/templates/add-<template_type>", methods=['GET', 'POST'])
Create new folders inside the current folder When adding a new folder it is created inside the currently active one. The user is returned to the previously active folder page, which shows the added folder. This adds a new route to the add template/folder views. Thankfully, `url_for` recognizes when `template_folder_id` is `None` and will use the URL without `/folders/...`, so users without folder permissions should be unaffected by this change.
2018-11-06 13:06:35 +00:00
@main.route("/services/<service_id>/templates/folders/<template_folder_id>/add-<template_type>",
methods=['GET', 'POST'])
Add login_required for all endpoints where it makes sense. https://www.pivotaltracker.com/story/show/111240834
2016-01-11 16:03:41 +00:00
@login_required
remove admin_override from all has_permissions usage as previously pointed out, it's not used anywhere.
2018-03-01 10:30:17 +00:00
@user_has_permissions('manage_templates')
Create new folders inside the current folder When adding a new folder it is created inside the currently active one. The user is returned to the previously active folder page, which shows the added folder. This adds a new route to the add template/folder views. Thankfully, `url_for` recognizes when `template_folder_id` is `None` and will use the URL without `/folders/...`, so users without folder permissions should be unaffected by this change.
2018-11-06 13:06:35 +00:00
def add_service_template(service_id, template_type, template_folder_id=None):
Add a selectField to edit and create templates that is only visible for platform admins that makes the template a `priority` template. There is a check that the template can not be created as priority if the user is not a platform admin. There is a check that the template can not change the `priority` unless they are a platform admin.
2017-01-18 15:11:34 +00:00
Sprinkle `letter` throughout the app Let users create/edit/delete letter templates. Let them upload a CSV file or send a test against a letter template. Big assumption at the moment is that addresses only have one line, and therefore one column in the CSV file.
2016-11-08 13:12:07 +00:00
if template_type not in ['sms', 'email', 'letter']:
Add basic flow for adding email _or_ sms templates Templates now have: - a type (email or sms) - a subject (if they are email templates) We don’t want two completely separate view files for email and SMS, because they would have an enormous amount of repetition. So this commit adds - different templates for SMS and email templates - different form objects for SMS and email templates …and wires them up.
2016-02-22 14:45:13 +00:00
abort(404)
Use service model to look up service attributes This is better than just keying into the JSON because it means you get an exception straight away when looking up a key that doesn’t exist (which via mocking you could ordinarily miss).
2018-07-20 08:42:01 +01:00
if not current_service.has_permission('letter') and template_type == 'letter':
Sprinkle `letter` throughout the app Let users create/edit/delete letter templates. Let them upload a CSV file or send a test against a letter template. Big assumption at the moment is that addresses only have one line, and therefore one column in the CSV file.
2016-11-08 13:12:07 +00:00
abort(403)
Add basic flow for adding email _or_ sms templates Templates now have: - a type (email or sms) - a subject (if they are email templates) We don’t want two completely separate view files for email and SMS, because they would have an enormous amount of repetition. So this commit adds - different templates for SMS and email templates - different form objects for SMS and email templates …and wires them up.
2016-02-22 14:45:13 +00:00
form = form_objects[template_type]()
Mapped template actions to the api and mocked tests.
2016-01-19 15:54:12 +00:00
if form.validate_on_submit():
Add a selectField to edit and create templates that is only visible for platform admins that makes the template a `priority` template. There is a check that the template can not be created as priority if the user is not a platform admin. There is a check that the template can not change the `priority` unless they are a platform admin.
2017-01-18 15:11:34 +00:00
if form.process_type.data == 'priority':
abort_403_if_not_admin_user()
Handling template content size error. All tests passing.
2016-04-29 09:38:59 +01:00
try:
Redirect to individual template page after adding When you add a new template the next thing you want to do is probably: - send a test - edit it after seeing what it looks like So let’s redirect you straight to the page where you can do these things. This is especially important for letters where we want to tighten the edit/feedback loop.
2017-03-14 13:39:21 +00:00
new_template = service_api_client.create_service_template(
Handling template content size error. All tests passing.
2016-04-29 09:38:59 +01:00
form.name.data,
template_type,
form.template_content.data,
service_id,
Add a selectField to edit and create templates that is only visible for platform admins that makes the template a `priority` template. There is a check that the template can not be created as priority if the user is not a platform admin. There is a check that the template can not change the `priority` unless they are a platform admin.
2017-01-18 15:11:34 +00:00
form.subject.data if hasattr(form, 'subject') else None,
Create a template in a folder.
2018-11-08 15:53:33 +00:00
form.process_type.data,
template_folder_id
Handling template content size error. All tests passing.
2016-04-29 09:38:59 +01:00
)
except HTTPError as e:
ensure emails still accept emoji
2017-02-15 15:06:47 +00:00
if (
Edit template postage from a separate view
2019-01-29 15:43:59 +00:00
e.status_code == 400
and 'content' in e.message
and any(['character count greater than' in x for x in e.message['content']])
ensure emails still accept emoji
2017-02-15 15:06:47 +00:00
):
form.template_content.errors.extend(e.message['content'])
Handling template content size error. All tests passing.
2016-04-29 09:38:59 +01:00
else:
raise e
else:
return redirect(
Redirect to individual template page after adding When you add a new template the next thing you want to do is probably: - send a test - edit it after seeing what it looks like So let’s redirect you straight to the page where you can do these things. This is especially important for letters where we want to tighten the edit/feedback loop.
2017-03-14 13:39:21 +00:00
url_for('.view_template', service_id=service_id, template_id=new_template['data']['id'])
Handling template content size error. All tests passing.
2016-04-29 09:38:59 +01:00
)
Refactor code to check whether email/sms is enabled
2017-07-04 17:25:35 +01:00
Use service model to look up service attributes This is better than just keying into the JSON because it means you get an exception straight away when looking up a key that doesn’t exist (which via mocking you could ordinarily miss).
2018-07-20 08:42:01 +01:00
if email_or_sms_not_enabled(template_type, current_service.permissions):
Stop users from editing/adding templates without the correct permission If sending SMS is disabled for a service, it should not be possible to add or modify SMS templates. If a user tries to do this, they should see a different page with a link to go back. The same thing should happen with email templates.
2017-06-30 10:55:59 +01:00
return redirect(url_for(
'.action_blocked',
service_id=service_id,
notification_type=template_type,
return_to='templates',
template_id='0'
))
else:
return render_template(
'views/edit-{}-template.html'.format(template_type),
form=form,
template_type=template_type,
heading_action='Add',
)
Add routing and pages for managing templates So that users can see what it the flow is like to: - add new templates - edit existing templates
2015-12-20 00:00:01 +00:00
Add a selectField to edit and create templates that is only visible for platform admins that makes the template a `priority` template. There is a check that the template can not be created as priority if the user is not a platform admin. There is a check that the template can not change the `priority` unless they are a platform admin.
2017-01-18 15:11:34 +00:00
def abort_403_if_not_admin_user():
dont use has_permissions to check for platform admins platform_admin is a separate concept to permissions, so by removing the checks for it from the current_user.has_permissions function, we can simplify things greatly. We already record on the user whether they're a platform admin anyway.
2018-02-27 16:45:20 +00:00
if not current_user.platform_admin:
Add a selectField to edit and create templates that is only visible for platform admins that makes the template a `priority` template. There is a check that the template can not be created as priority if the user is not a platform admin. There is a check that the template can not change the `priority` unless they are a platform admin.
2017-01-18 15:11:34 +00:00
abort(403)
Add view for a single template > At the moment, we have an all email templates page, and an edit an > individual page. > > This gets messy when we refer to templates like the dashboard and the > activity views. We solve this currently by using anchor links to the > list page, but this is clunky. > > So lets add it, then update the links on the dash and activity to the > new view page. > > Should be a link from the view a single template page, to the template > hub page. https://www.pivotaltracker.com/story/show/117349227
2016-04-12 09:55:51 +01:00
@main.route("/services/<service_id>/templates/<template_id>/edit", methods=['GET', 'POST'])
Add login_required for all endpoints where it makes sense. https://www.pivotaltracker.com/story/show/111240834
2016-01-11 16:03:41 +00:00
@login_required
remove admin_override from all has_permissions usage as previously pointed out, it's not used anywhere.
2018-03-01 10:30:17 +00:00
@user_has_permissions('manage_templates')
Mapped template actions to the api and mocked tests.
2016-01-19 15:54:12 +00:00
def edit_service_template(service_id, template_id):
Fixed merge conflicts with master. Code quality fixes.
2016-03-30 10:23:39 +01:00
template = service_api_client.get_service_template(service_id, template_id)['data']
Rename `content` to `template` content WTForms sets the `id` of a `textarea` element to the variable name to which the form control is assigned. This conflicts with the page container, which is styled by targeting `#content`.
2016-01-22 12:15:47 +00:00
template['template_content'] = template['content']
Add basic flow for adding email _or_ sms templates Templates now have: - a type (email or sms) - a subject (if they are email templates) We don’t want two completely separate view files for email and SMS, because they would have an enormous amount of repetition. So this commit adds - different templates for SMS and email templates - different form objects for SMS and email templates …and wires them up.
2016-02-22 14:45:13 +00:00
form = form_objects[template['template_type']](**template)
Mapped template actions to the api and mocked tests.
2016-01-19 15:54:12 +00:00
if form.validate_on_submit():
Add a selectField to edit and create templates that is only visible for platform admins that makes the template a `priority` template. There is a check that the template can not be created as priority if the user is not a platform admin. There is a check that the template can not change the `priority` unless they are a platform admin.
2017-01-18 15:11:34 +00:00
if form.process_type.data != template['process_type']:
abort_403_if_not_admin_user()
Stop template subjects getting saved encoded This is another problem with sanitising HTML, this with with it getting encoded where it shouldn’t be. The result was, when editing a template, the API getting sent an encoded rather than raw version of the subject (for letters and emails). The reason this happened is because BeautifulSoup behaves in an unexpected way. When accessing the `value` attribute of an `input` BeautifulSoup returns an unencoded version of the contents. In other words it returns what the user would see in the page, not what is in the raw HTML of the page. This meant that we were trying too hard to see an `&amp;` instead of a `&` in our tests[1]. So things were actually working fine before adding the call to `escape_html`[2], but from the output of the tests it didn’t look like HTML was getting escaped. So this commit fixes the bug by removing the call to `escape_html` and adding a test that looks at the raw HTML, to complement the existing test which looks at just the `value` attribute. 1. Relevant test added here: https://github.com/alphagov/notifications-admin/pull/1178/files#diff-f2eb304b93cc383727c0ab7fc8fbd464R289 2. Call added here: https://github.com/alphagov/notifications-admin/pull/1178/files#diff-f0af582449ebf426f27f37e38f310057R252
2017-04-14 08:52:02 +01:00
subject = form.subject.data if hasattr(form, 'subject') else None
Change postage while editing template
2018-12-18 18:22:03 +00:00
new_template_data = {
Warn users a template change will break things When a user adds or removes placeholders in their template we should consider this a ‘breaking change’ and warn them accordingly. Implementing this mostly relies on using https://github.com/alphagov/notifications-utils/pull/37 Temporarily storing the new template until the user confirms that they want to make the changes in done using hidden fields. This is a bit hacky, but the complexity of making sessions interact with WTForms was just too much to handle. This commit also changes the example spreadsheet that we show on this page to look more like a spreadsheet.
2016-05-27 16:21:29 +01:00
'name': form.name.data,
'content': form.template_content.data,
'subject': subject,
'template_type': template['template_type'],
Add a selectField to edit and create templates that is only visible for platform admins that makes the template a `priority` template. There is a check that the template can not be created as priority if the user is not a platform admin. There is a check that the template can not change the `priority` unless they are a platform admin.
2017-01-18 15:11:34 +00:00
'id': template['id'],
Allow letter templates to select the default contact block from the list
2018-01-03 10:44:36 +00:00
'process_type': form.process_type.data,
Change postage while editing template
2018-12-18 18:22:03 +00:00
'reply_to_text': template['reply_to_text'],
}
new_template = get_template(new_template_data, current_service)
Incorporate breaking utils changes Brings in: - [ ] https://github.com/alphagov/notifications-utils/pull/94
2016-12-08 11:50:59 +00:00
template_change = get_template(template, current_service).compare_to(new_template)
Make removing placeholders a non-breaking change The CSV upload route has always quietly ignored excess personalisation. We changed the API to do the same here: https://github.com/alphagov/notifications-api/pull/853 This means that removing a placeholder from a template is never a breaking change, because the data that you were providing to populate it is now just ignored. So we don’t need to show the interstitial page in this case.
2017-05-17 13:05:18 +01:00
if template_change.placeholders_added and not request.form.get('confirm'):
Fix no. of column headers on breaking change page The breaking change page wasn’t properly accounting for the fact that letter recipients span multiple columns – it was assuming they’d only take up one column like they do for email and SMS. This commit fixes: - the number of column headers (A, B, C, …) to be correct - the count of columns (you will need X columns in your file) to be correct It then parameterises the test to look at a case where a recipient is in one column (email) and multiple columns (letter).
2017-04-06 10:22:09 +01:00
example_column_headings = (
Edit template postage from a separate view
2019-01-29 15:43:59 +00:00
first_column_headings[new_template.template_type] + list(new_template.placeholders)
Fix no. of column headers on breaking change page The breaking change page wasn’t properly accounting for the fact that letter recipients span multiple columns – it was assuming they’d only take up one column like they do for email and SMS. This commit fixes: - the number of column headers (A, B, C, …) to be correct - the count of columns (you will need X columns in your file) to be correct It then parameterises the test to look at a case where a recipient is in one column (email) and multiple columns (letter).
2017-04-06 10:22:09 +01:00
)
Warn users a template change will break things When a user adds or removes placeholders in their template we should consider this a ‘breaking change’ and warn them accordingly. Implementing this mostly relies on using https://github.com/alphagov/notifications-utils/pull/37 Temporarily storing the new template until the user confirms that they want to make the changes in done using hidden fields. This is a bit hacky, but the complexity of making sessions interact with WTForms was just too much to handle. This commit also changes the example spreadsheet that we show on this page to look more like a spreadsheet.
2016-05-27 16:21:29 +01:00
return render_template(
'views/templates/breaking-change.html',
template_change=template_change,
Fix count of columns on breaking change page For some reason we were rebuilding `new_template` as a dictionary, without the `placeholders` attribute. This meant that we were never actually counting the placeholders, just counting the length of `None` and adding 1 to it. So this commit fixes that, beefs up the tests, and makes sure that everything is pluralised properly.
2017-03-06 13:08:27 +00:00
new_template=new_template,
Fix no. of column headers on breaking change page The breaking change page wasn’t properly accounting for the fact that letter recipients span multiple columns – it was assuming they’d only take up one column like they do for email and SMS. This commit fixes: - the number of column headers (A, B, C, …) to be correct - the count of columns (you will need X columns in your file) to be correct It then parameterises the test to look at a case where a recipient is in one column (email) and multiple columns (letter).
2017-04-06 10:22:09 +01:00
column_headings=list(ascii_uppercase[:len(example_column_headings)]),
Warn users a template change will break things When a user adds or removes placeholders in their template we should consider this a ‘breaking change’ and warn them accordingly. Implementing this mostly relies on using https://github.com/alphagov/notifications-utils/pull/37 Temporarily storing the new template until the user confirms that they want to make the changes in done using hidden fields. This is a bit hacky, but the complexity of making sessions interact with WTForms was just too much to handle. This commit also changes the example spreadsheet that we show on this page to look more like a spreadsheet.
2016-05-27 16:21:29 +01:00
example_rows=[
Fix no. of column headers on breaking change page The breaking change page wasn’t properly accounting for the fact that letter recipients span multiple columns – it was assuming they’d only take up one column like they do for email and SMS. This commit fixes: - the number of column headers (A, B, C, …) to be correct - the count of columns (you will need X columns in your file) to be correct It then parameterises the test to look at a case where a recipient is in one column (email) and multiple columns (letter).
2017-04-06 10:22:09 +01:00
example_column_headings,
Warn users a template change will break things When a user adds or removes placeholders in their template we should consider this a ‘breaking change’ and warn them accordingly. Implementing this mostly relies on using https://github.com/alphagov/notifications-utils/pull/37 Temporarily storing the new template until the user confirms that they want to make the changes in done using hidden fields. This is a bit hacky, but the complexity of making sessions interact with WTForms was just too much to handle. This commit also changes the example spreadsheet that we show on this page to look more like a spreadsheet.
2016-05-27 16:21:29 +01:00
get_example_csv_rows(new_template),
get_example_csv_rows(new_template)
],
form=form
)
Handling template content size error. All tests passing.
2016-04-29 09:38:59 +01:00
try:
service_api_client.update_service_template(
template_id,
form.name.data,
template['template_type'],
form.template_content.data,
service_id,
Add a selectField to edit and create templates that is only visible for platform admins that makes the template a `priority` template. There is a check that the template can not be created as priority if the user is not a platform admin. There is a check that the template can not change the `priority` unless they are a platform admin.
2017-01-18 15:11:34 +00:00
subject,
Change postage while editing template
2018-12-18 18:22:03 +00:00
form.process_type.data,
Handling template content size error. All tests passing.
2016-04-29 09:38:59 +01:00
)
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(
Redirect to single template view after edit When you edit a template, you’re probably going to do something with it straight afterwards, eg send yourself a test. We could make it easy to find the template you’ve just saved by putting it at the top of the pile. This gets confusing for other reasons (order of templates will constantly shift about). So this commit changes the flow to take you to the single page for the template you’ve just edited.
2016-06-06 10:12:21 +01:00
'.view_template',
Handling template content size error. All tests passing.
2016-04-29 09:38:59 +01:00
service_id=service_id,
Redirect to single template view after edit When you edit a template, you’re probably going to do something with it straight afterwards, eg send yourself a test. We could make it easy to find the template you’ve just saved by putting it at the top of the pile. This gets confusing for other reasons (order of templates will constantly shift about). So this commit changes the flow to take you to the single page for the template you’ve just edited.
2016-06-06 10:12:21 +01:00
template_id=template_id
Handling template content size error. All tests passing.
2016-04-29 09:38:59 +01:00
))
Stop users from editing/adding templates without the correct permission If sending SMS is disabled for a service, it should not be possible to add or modify SMS templates. If a user tries to do this, they should see a different page with a link to go back. The same thing should happen with email templates.
2017-06-30 10:55:59 +01:00
db_template = service_api_client.get_service_template(service_id, template_id)['data']
Use service model to look up service attributes This is better than just keying into the JSON because it means you get an exception straight away when looking up a key that doesn’t exist (which via mocking you could ordinarily miss).
2018-07-20 08:42:01 +01:00
if email_or_sms_not_enabled(db_template['template_type'], current_service.permissions):
Stop users from editing/adding templates without the correct permission If sending SMS is disabled for a service, it should not be possible to add or modify SMS templates. If a user tries to do this, they should see a different page with a link to go back. The same thing should happen with email templates.
2017-06-30 10:55:59 +01:00
return redirect(url_for(
'.action_blocked',
service_id=service_id,
notification_type=db_template['template_type'],
return_to='view_template',
template_id=template_id
))
else:
return render_template(
'views/edit-{}-template.html'.format(template['template_type']),
form=form,
template_id=template_id,
template_type=template['template_type'],
Edit, don’t duplicate, existing templates
2018-07-31 16:20:10 +01:00
heading_action='Edit',
Stop users from editing/adding templates without the correct permission If sending SMS is disabled for a service, it should not be possible to add or modify SMS templates. If a user tries to do this, they should see a different page with a link to go back. The same thing should happen with email templates.
2017-06-30 10:55:59 +01:00
)
Add link to delete a template This is a link not a button because: - it’s less prominent—delete is an infrequent action - it’s a two-step process, and only the second part changes any data (so it has a button)
2016-01-14 09:44:06 +00:00
Download CSV option now available. App is updated to use the rebased db.
2016-04-12 14:19:51 +01:00
@main.route("/services/<service_id>/templates/<template_id>/delete", methods=['GET', 'POST'])
Add link to delete a template This is a link not a button because: - it’s less prominent—delete is an infrequent action - it’s a two-step process, and only the second part changes any data (so it has a button)
2016-01-14 09:44:06 +00:00
@login_required
remove admin_override from all has_permissions usage as previously pointed out, it's not used anywhere.
2018-03-01 10:30:17 +00:00
@user_has_permissions('manage_templates')
Mapped template actions to the api and mocked tests.
2016-01-19 15:54:12 +00:00
def delete_service_template(service_id, template_id):
Fixed merge conflicts with master. Code quality fixes.
2016-03-30 10:23:39 +01:00
template = service_api_client.get_service_template(service_id, template_id)['data']
Add link to delete a template This is a link not a button because: - it’s less prominent—delete is an infrequent action - it’s a two-step process, and only the second part changes any data (so it has a button)
2016-01-14 09:44:06 +00:00
Delete template fix.
2016-01-22 11:36:49 +00:00
if request.method == 'POST':
Fixed merge conflicts with master. Code quality fixes.
2016-03-30 10:23:39 +01:00
service_api_client.delete_service_template(service_id, template_id)
Add basic flow for adding email _or_ sms templates Templates now have: - a type (email or sms) - a subject (if they are email templates) We don’t want two completely separate view files for email and SMS, because they would have an enormous amount of repetition. So this commit adds - different templates for SMS and email templates - different form objects for SMS and email templates …and wires them up.
2016-02-22 14:45:13 +00:00
return redirect(url_for(
'.choose_template',
service_id=service_id,
))
Add link to delete a template This is a link not a button because: - it’s less prominent—delete is an infrequent action - it’s a two-step process, and only the second part changes any data (so it has a button)
2016-01-14 09:44:06 +00:00
Using new endpoint for template statistics - gets notifications by template id, returning the most recent to illustrate the last use of that template.
2016-08-22 16:25:35 +01:00
try:
last_used_notification = template_statistics_client.get_template_statistics_for_template(
service_id, template['id']
)
Update content following review
2018-11-16 11:03:16 +00:00
message = 'This template was last used {} ago.'.format(
Update message for last used template on delete: * API now returns an empty response if a template was last used more than seven * days ago * Handle the empty response appropriately
2017-07-26 12:04:07 +01:00
'more than seven days' if not last_used_notification else get_human_readable_delta(
Using new endpoint for template statistics - gets notifications by template id, returning the most recent to illustrate the last use of that template.
2016-08-22 16:25:35 +01:00
parse(last_used_notification['created_at']).replace(tzinfo=None),
Make sure confirmation/danger banners have a H1 This makes errors on all pages have a `<h1>` element, which is important for accessibility. It means a bit of rewriting the messages, but I think they’re better for it.
2017-07-24 14:50:56 +01:00
datetime.utcnow()
)
Using new endpoint for template statistics - gets notifications by template id, returning the most recent to illustrate the last use of that template.
2016-08-22 16:25:35 +01:00
)
Update message for last used template on delete: * API now returns an empty response if a template was last used more than seven * days ago * Handle the empty response appropriately
2017-07-26 12:04:07 +01:00
Using new endpoint for template statistics - gets notifications by template id, returning the most recent to illustrate the last use of that template.
2016-08-22 16:25:35 +01:00
except HTTPError as e:
if e.status_code == 404:
Remove last used message if key’s never been used I don’t think it adds anything to tell you that a key’s never been used. The value of the ‘key was used 3 minutes ago’ message is in stopping you accidentally revoking something you shouldn’t have.
2017-07-24 14:55:39 +01:00
message = None
Raise the exception if not a 404
2016-08-24 11:26:34 +01:00
else:
raise e
Using new endpoint for template statistics - gets notifications by template id, returning the most recent to illustrate the last use of that template.
2016-08-22 16:25:35 +01:00
Make deletion confirmation banner messages consistent across our app Also introduce a way to provide context to a banner / flash message that will be displayed in plain font style.
2018-11-15 17:14:03 +00:00
flash(["Are you sure you want to delete ‘{}’?".format(template['name']), message], 'delete')
Mapped template actions to the api and mocked tests.
2016-01-19 15:54:12 +00:00
return render_template(
Move delete link from edit to view template page Users were having trouble finding the delete template link. It sort of made sense having it on the edit page before we had the view template page. But it doesn’t make sense now – having to choose to ‘edit’ the template before you can delete is counterintuitive. The single template page is where you go to choose an action to perform on your template. Deleting is a good example of an action you can perform on a template. So this commit moves the delete link from the edit template page to the view template page. It also puts the confirm banner on same page as the delete link The idea being that, in order to make a decision about whether to delete the template, it’s useful to be able to see the template you’re deleting. There’s no user need to edit the template before you delete it.
2017-04-18 13:01:58 +01:00
'views/templates/template.html',
template=get_template(
template,
current_service,
expand_emails=True,
Update utils with to make letters unclickable Brings in: - [ ] https://github.com/alphagov/notifications-utils/pull/159 Means: - renaming a bunch of things - removing any CSS that targeted the link, and making it target the containing element too
2017-04-28 16:04:52 +01:00
letter_preview_url=url_for(
'.view_letter_template_preview',
service_id=service_id,
template_id=template['id'],
filetype='png',
),
Move delete link from edit to view template page Users were having trouble finding the delete template link. It sort of made sense having it on the edit page before we had the view template page. But it doesn’t make sense now – having to choose to ‘edit’ the template before you can delete is counterintuitive. The single template page is where you go to choose an action to perform on your template. Deleting is a good example of an action you can perform on a template. So this commit moves the delete link from the edit template page to the view template page. It also puts the confirm banner on same page as the delete link The idea being that, in order to make a decision about whether to delete the template, it’s useful to be able to see the template you’re deleting. There’s no user need to edit the template before you delete it.
2017-04-18 13:01:58 +01:00
show_recipient=True,
Allow one-off email sending to select the reply-to address
2017-10-16 16:35:35 +01:00
),
Move delete link from edit to view template page Users were having trouble finding the delete template link. It sort of made sense having it on the edit page before we had the view template page. But it doesn’t make sense now – having to choose to ‘edit’ the template before you can delete is counterintuitive. The single template page is where you go to choose an action to perform on your template. Deleting is a good example of an action you can perform on a template. So this commit moves the delete link from the edit template page to the view template page. It also puts the confirm banner on same page as the delete link The idea being that, in order to make a decision about whether to delete the template, it’s useful to be able to see the template you’re deleting. There’s no user need to edit the template before you delete it.
2017-04-18 13:01:58 +01:00
)
Update all dates to use utc, only in the template is it converted to british time. Template versions and template version pages added. Fix merge changes.
2016-05-11 11:20:45 +01:00
Split views into GET and POST
2017-06-27 14:35:37 +01:00
@main.route("/services/<service_id>/templates/<template_id>/redact", methods=['GET'])
Add feature to mark a template as redacted Works similarly to the delete template flow, because it’s a destructive, one-way action. Not on the edit template page, because it’s not something you want to be considering every time you’re editing a template. And we saw that people couldn’t find the delete button when it was on this page. Adds a bit more CSS for the `dangerous` banner type, because the content here is quite complicated. Breaking it into a list helps, but the spacing didn’t look right, so needed some tweaking. Can ship independently of the code that shows the redaction, but needs the API first.
2017-06-26 14:41:00 +01:00
@login_required
remove admin_override from all has_permissions usage as previously pointed out, it's not used anywhere.
2018-03-01 10:30:17 +00:00
@user_has_permissions('manage_templates')
Split views into GET and POST
2017-06-27 14:35:37 +01:00
def confirm_redact_template(service_id, template_id):
Allow one-off email sending to select the reply-to address
2017-10-16 16:35:35 +01:00
template = service_api_client.get_service_template(service_id, template_id)['data']
Add feature to mark a template as redacted Works similarly to the delete template flow, because it’s a destructive, one-way action. Not on the edit template page, because it’s not something you want to be considering every time you’re editing a template. And we saw that people couldn’t find the delete button when it was on this page. Adds a bit more CSS for the `dangerous` banner type, because the content here is quite complicated. Breaking it into a list helps, but the spacing didn’t look right, so needed some tweaking. Can ship independently of the code that shows the redaction, but needs the API first.
2017-06-26 14:41:00 +01:00
return render_template(
'views/templates/template.html',
template=get_template(
Allow one-off email sending to select the reply-to address
2017-10-16 16:35:35 +01:00
template,
Add feature to mark a template as redacted Works similarly to the delete template flow, because it’s a destructive, one-way action. Not on the edit template page, because it’s not something you want to be considering every time you’re editing a template. And we saw that people couldn’t find the delete button when it was on this page. Adds a bit more CSS for the `dangerous` banner type, because the content here is quite complicated. Breaking it into a list helps, but the spacing didn’t look right, so needed some tweaking. Can ship independently of the code that shows the redaction, but needs the API first.
2017-06-26 14:41:00 +01:00
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,
),
show_redaction_message=True,
)
Split views into GET and POST
2017-06-27 14:35:37 +01:00
@main.route("/services/<service_id>/templates/<template_id>/redact", methods=['POST'])
@login_required
remove admin_override from all has_permissions usage as previously pointed out, it's not used anywhere.
2018-03-01 10:30:17 +00:00
@user_has_permissions('manage_templates')
Split views into GET and POST
2017-06-27 14:35:37 +01:00
def redact_template(service_id, template_id):
service_api_client.redact_service_template(service_id, template_id)
flash(
'Personalised content will be hidden for messages sent with this template',
'default_with_tick'
)
return redirect(url_for(
'.view_template',
service_id=service_id,
template_id=template_id,
))
Update all dates to use utc, only in the template is it converted to british time. Template versions and template version pages added. Fix merge changes.
2016-05-11 11:20:45 +01:00
@main.route('/services/<service_id>/templates/<template_id>/versions')
@login_required
remove admin_override from all has_permissions usage as previously pointed out, it's not used anywhere.
2018-03-01 10:30:17 +00:00
@user_has_permissions('view_activity')
Update all dates to use utc, only in the template is it converted to british time. Template versions and template version pages added. Fix merge changes.
2016-05-11 11:20:45 +01:00
def view_template_versions(service_id, template_id):
return render_template(
'views/templates/choose_history.html',
Incorporate breaking utils changes Brings in: - [ ] https://github.com/alphagov/notifications-utils/pull/94
2016-12-08 11:50:59 +00:00
versions=[
Add remaining endpoints for PDFs and PNGs Right now we can show what a letter template looks like as a PDF or PNG. This commit completes the work so this is also possible when: - showing a template with the placeholders replaced - showing any version of a template Also removes dependency on `Exception().message`, which was deprecated in Python 2.6. See https://github.com/alphagov/notifications-utils/commit/97f82d565f3112926752ae382e723b0808a3135d for full details.
2016-12-20 14:38:34 +00:00
get_template(
template,
current_service,
expand_emails=True,
letter_preview_url=url_for(
Update utils with to make letters unclickable Brings in: - [ ] https://github.com/alphagov/notifications-utils/pull/159 Means: - renaming a bunch of things - removing any CSS that targeted the link, and making it target the containing element too
2017-04-28 16:04:52 +01:00
'.view_template_version_preview',
Add remaining endpoints for PDFs and PNGs Right now we can show what a letter template looks like as a PDF or PNG. This commit completes the work so this is also possible when: - showing a template with the placeholders replaced - showing any version of a template Also removes dependency on `Exception().message`, which was deprecated in Python 2.6. See https://github.com/alphagov/notifications-utils/commit/97f82d565f3112926752ae382e723b0808a3135d for full details.
2016-12-20 14:38:34 +00:00
service_id=service_id,
template_id=template_id,
version=template['version'],
Update utils with to make letters unclickable Brings in: - [ ] https://github.com/alphagov/notifications-utils/pull/159 Means: - renaming a bunch of things - removing any CSS that targeted the link, and making it target the containing element too
2017-04-28 16:04:52 +01:00
filetype='png',
Add remaining endpoints for PDFs and PNGs Right now we can show what a letter template looks like as a PDF or PNG. This commit completes the work so this is also possible when: - showing a template with the placeholders replaced - showing any version of a template Also removes dependency on `Exception().message`, which was deprecated in Python 2.6. See https://github.com/alphagov/notifications-utils/commit/97f82d565f3112926752ae382e723b0808a3135d for full details.
2016-12-20 14:38:34 +00:00
)
)
Incorporate breaking utils changes Brings in: - [ ] https://github.com/alphagov/notifications-utils/pull/94
2016-12-08 11:50:59 +00:00
for template in service_api_client.get_service_template_versions(service_id, template_id)['data']
]
Update all dates to use utc, only in the template is it converted to british time. Template versions and template version pages added. Fix merge changes.
2016-05-11 11:20:45 +01:00
)
Add warning message showing date template last used when deleting
2016-06-06 11:09:46 +01:00
Allow letter templates to select the default contact block from the list
2018-01-03 10:44:36 +00:00
@main.route('/services/<service_id>/templates/<template_id>/set-template-sender', methods=['GET', 'POST'])
@login_required
remove admin_override from all has_permissions usage as previously pointed out, it's not used anywhere.
2018-03-01 10:30:17 +00:00
@user_has_permissions('manage_templates')
Allow letter templates to select the default contact block from the list
2018-01-03 10:44:36 +00:00
def set_template_sender(service_id, template_id):
template = service_api_client.get_service_template(service_id, template_id)['data']
sender_details = get_template_sender_form_dict(service_id, template)
no_senders = sender_details.get('no_senders', False)
form = SetTemplateSenderForm(
sender=sender_details['current_choice'],
sender_choices=sender_details['value_and_label'],
)
option_hints = {sender_details['default_sender']: '(Default)'}
if form.validate_on_submit():
service_api_client.update_service_template_sender(
service_id,
template_id,
form.sender.data if form.sender.data else None,
)
return redirect(url_for('.view_template', service_id=service_id, template_id=template_id))
return render_template(
'views/templates/set-template-sender.html',
form=form,
template_id=template_id,
no_senders=no_senders,
option_hints=option_hints
)
Edit template postage from a separate view
2019-01-29 15:43:59 +00:00
@main.route('/services/<service_id>/templates/<template_id>/edit-postage', methods=['GET', 'POST'])
@login_required
@user_has_permissions('manage_templates')
def edit_template_postage(service_id, template_id):
template = service_api_client.get_service_template(service_id, template_id)['data']
Remove choose_postage feature flag so everyone can choose postage
2019-02-04 16:55:00 +00:00
if template["template_type"] != "letter":
Edit template postage from a separate view
2019-01-29 15:43:59 +00:00
abort(404)
form = LetterTemplatePostageForm(**template)
if form.validate_on_submit():
postage = form.postage.data
service_api_client.update_service_template_postage(service_id, template_id, postage)
return redirect(url_for('.view_template', service_id=service_id, template_id=template_id))
return render_template(
'views/templates/edit-template-postage.html',
form=form,
service_id=service_id,
template_id=template_id,
template_postage=template["postage"]
)
Allow letter templates to select the default contact block from the list
2018-01-03 10:44:36 +00:00
def get_template_sender_form_dict(service_id, template):
context = {
'email': {
'field_name': 'email_address'
},
'letter': {
'field_name': 'contact_block'
},
'sms': {
'field_name': 'sms_sender'
}
}[template['template_type']]
sender_format = context['field_name']
service_senders = get_sender_details(service_id, template['template_type'])
context['default_sender'] = next(
(x['id'] for x in service_senders if x['is_default']), "Not set"
)
if not service_senders:
context['no_senders'] = True
context['value_and_label'] = [(sender['id'], Markup(nl2br(sender[sender_format]))) for sender in service_senders]
context['value_and_label'].insert(0, ('', 'Blank')) # Add blank option to start of list
context['current_choice'] = template['service_letter_contact'] if template['service_letter_contact'] else ''
return context
only get template statistics for specific template
2016-06-07 14:28:02 +01:00
def get_last_use_message(template_name, template_statistics):
Add warning message showing date template last used when deleting
2016-06-06 11:09:46 +01:00
try:
most_recent_use = max(
tests for last used message also now parsing the datetime correctly and removing its UTC tz info to make comparisons work
2016-06-06 11:42:40 +01:00
parse(template_stats['updated_at']).replace(tzinfo=None)
Add warning message showing date template last used when deleting
2016-06-06 11:09:46 +01:00
for template_stats in template_statistics
)
except ValueError:
tests for last used message also now parsing the datetime correctly and removing its UTC tz info to make comparisons work
2016-06-06 11:42:40 +01:00
return '{} has never been used'.format(template_name)
Add warning message showing date template last used when deleting
2016-06-06 11:09:46 +01:00
return '{} was last used {} ago'.format(
tests for last used message also now parsing the datetime correctly and removing its UTC tz info to make comparisons work
2016-06-06 11:42:40 +01:00
template_name,
get_human_readable_delta(most_recent_use, datetime.utcnow())
Add warning message showing date template last used when deleting
2016-06-06 11:09:46 +01:00
)
def get_human_readable_delta(from_time, until_time):
delta = until_time - from_time
if delta < timedelta(seconds=60):
return 'under a minute'
elif delta < timedelta(hours=1):
minutes = int(delta.seconds / 60)
tests for last used message also now parsing the datetime correctly and removing its UTC tz info to make comparisons work
2016-06-06 11:42:40 +01:00
return '{} minute{}'.format(minutes, '' if minutes == 1 else 's')
Add warning message showing date template last used when deleting
2016-06-06 11:09:46 +01:00
elif delta < timedelta(days=1):
hours = int(delta.seconds / 3600)
tests for last used message also now parsing the datetime correctly and removing its UTC tz info to make comparisons work
2016-06-06 11:42:40 +01:00
return '{} hour{}'.format(hours, '' if hours == 1 else 's')
Add warning message showing date template last used when deleting
2016-06-06 11:09:46 +01:00
else:
days = delta.days
tests for last used message also now parsing the datetime correctly and removing its UTC tz info to make comparisons work
2016-06-06 11:42:40 +01:00
return '{} day{}'.format(days, '' if days == 1 else 's')
Merge email, text message + letter templates pages Right now we have separate pages for email and text message templates. In the future we will also have a separate page for letter templates. This commit changes Notify to only have one page for all templates. What is the problem? --- The left-hand navigation is getting quite crowded, at 8 items for a service that can send letters. Research suggests that the number of objects an average human can hold in working memory is 7 ± 2 [1]. So we’re at the limit of how many items the navigation should have. In the future we will need to search/sort/filter templates by attributes other than type, for example: - show me the ‘confirmation’ templates - show me the most recently used templates - show me all templates containing the placeholder `((ref_no))` These are hypothetical for now, but these needs (or others) may become real in the future. At this point pre-filtering the list of templates by type would restrict what searches a user could do. So by making this change now we’re in a better position to iterate the design in the future. What’s the change? --- This commit replaces the ‘Email templates’, ‘Text message templates’ and ‘Letter templates’ pages with one page called ‘Templates’. This new templates page shows all the templates for the service, sorted by most recently created first (as before). To add a new template there is a new page with a form asking you what kind of template you want to create. This is necessary because in the past we knew what kind of template you wanted to create based on the kind you were looking at. What’s the impact of this change on new users? --- This change alters the onboarding process slightly. We still want to take people through the empty templates page from the call-to-action on the dashboard because it helps them understand that to send a message using Notify you need a template. But because we don’t have separate pages for emails/text messages we will have to send users through the extra step of choosing what kind of template to create. This is a bit clunkier on first use but: - it still gets the point across - it takes them through the actual flow they will be using to create new templates in the future (ie they’re learning how to use Notify, not just being taken through a special onboarding route) I’m not too worried about this change in terms of the experience for new users. Furthermore, by making it now we get to validate whether it’s causing any problems in the lab research booked for next week. What’s the impact of this change on current services? --- Looking at the top 15 services by number of templates[2], most are using either text messages or emails. So this change would not have a significant impact on these services because the page will not get any longer. In other words we wouldn’t be making it worse for them. Those services who do use both are not using as many templates. The worst-case scenario is SSCS, who have 16 templates, evenly split between email and text messages. So they would go from having 8 templates per page to 16, which is still less than half the number that HMPO or Digital Marketplace are managing. References --- 1. https://en.wikipedia.org/wiki/The_Magical_Number_Seven,_Plus_or_Minus_Two 2. Template usage by service Service name | Template count | Template types ---------------------------------------|----------------|--------------- Her Majesty's Passport Office | 40 | sms Digital Marketplace | 40 | email GovWifi-Staging | 19 | sms GovWifi | 18 | sms Digital Apprenticeship Service | 16 | email SSCS | 16 | both Crown Commercial Service MI Collection | 15 | email Help with Prison Visits | 12 | both Digital Future | 12 | email Export Licensing Service | 11 | email Civil Money Claims | 9 | both DVLA Drivers Medical Service | 9 | sms GOV.UK Notify | 8 | both Manage your benefit overpayments | 8 | both Tax Renewals | 8 | both
2017-02-28 12:16:35 +00:00
def should_show_template(template_type):
return (
template_type != 'letter' or
Make a service model and use for permissions Having the service floating about as JSON is a bit flakey. Could easily introduce a mistake where you mistype the name of a key and silently get `None`. Also means doing awkward things like `if 'permission' in current_service['permissions']`, whereas for users we can do the much cleaner `user.has_permission()`. So this commit: - introduces a model - adds a `.has_permission` method similar to the one we have for users
2018-07-20 08:43:02 +01:00
current_service.has_permission('letter')
Merge email, text message + letter templates pages Right now we have separate pages for email and text message templates. In the future we will also have a separate page for letter templates. This commit changes Notify to only have one page for all templates. What is the problem? --- The left-hand navigation is getting quite crowded, at 8 items for a service that can send letters. Research suggests that the number of objects an average human can hold in working memory is 7 ± 2 [1]. So we’re at the limit of how many items the navigation should have. In the future we will need to search/sort/filter templates by attributes other than type, for example: - show me the ‘confirmation’ templates - show me the most recently used templates - show me all templates containing the placeholder `((ref_no))` These are hypothetical for now, but these needs (or others) may become real in the future. At this point pre-filtering the list of templates by type would restrict what searches a user could do. So by making this change now we’re in a better position to iterate the design in the future. What’s the change? --- This commit replaces the ‘Email templates’, ‘Text message templates’ and ‘Letter templates’ pages with one page called ‘Templates’. This new templates page shows all the templates for the service, sorted by most recently created first (as before). To add a new template there is a new page with a form asking you what kind of template you want to create. This is necessary because in the past we knew what kind of template you wanted to create based on the kind you were looking at. What’s the impact of this change on new users? --- This change alters the onboarding process slightly. We still want to take people through the empty templates page from the call-to-action on the dashboard because it helps them understand that to send a message using Notify you need a template. But because we don’t have separate pages for emails/text messages we will have to send users through the extra step of choosing what kind of template to create. This is a bit clunkier on first use but: - it still gets the point across - it takes them through the actual flow they will be using to create new templates in the future (ie they’re learning how to use Notify, not just being taken through a special onboarding route) I’m not too worried about this change in terms of the experience for new users. Furthermore, by making it now we get to validate whether it’s causing any problems in the lab research booked for next week. What’s the impact of this change on current services? --- Looking at the top 15 services by number of templates[2], most are using either text messages or emails. So this change would not have a significant impact on these services because the page will not get any longer. In other words we wouldn’t be making it worse for them. Those services who do use both are not using as many templates. The worst-case scenario is SSCS, who have 16 templates, evenly split between email and text messages. So they would go from having 8 templates per page to 16, which is still less than half the number that HMPO or Digital Marketplace are managing. References --- 1. https://en.wikipedia.org/wiki/The_Magical_Number_Seven,_Plus_or_Minus_Two 2. Template usage by service Service name | Template count | Template types ---------------------------------------|----------------|--------------- Her Majesty's Passport Office | 40 | sms Digital Marketplace | 40 | email GovWifi-Staging | 19 | sms GovWifi | 18 | sms Digital Apprenticeship Service | 16 | email SSCS | 16 | both Crown Commercial Service MI Collection | 15 | email Help with Prison Visits | 12 | both Digital Future | 12 | email Export Licensing Service | 11 | email Civil Money Claims | 9 | both DVLA Drivers Medical Service | 9 | sms GOV.UK Notify | 8 | both Manage your benefit overpayments | 8 | both Tax Renewals | 8 | both
2017-02-28 12:16:35 +00:00
)
Reference in New Issue Copy Permalink