darkhelm/notifications-admin
1
0
Fork 0
mirror of https://github.com/GSA/notifications-admin.git synced 2026-07-15 10:49:37 -04:00
Code Issues Packages Projects Releases Wiki Activity
Files
4d0da6594de60fcf37dc7796279462e32072d7a1
notifications-admin/app/main/views/templates.py

845 lines
30 KiB
Python
Raw Normal View History

Require `return_to` param in `action_blocked` The `action_blocked` endpoint needed a variation of the URL without a `template_id` parameter, because `None` is no longer a valid `template_id` (because it’s not a UUID). This change was made in 265931d21746918c4ddfc19c4ad3f8cb5683c1bf, which also removed the `return_to` parameter, because the back link on the `action blocked` page only ever goes to `add_new_template` if there’s no `template_id` provided. However this was conflating the two things, so I’ve wound it back a bit so that: - there’s still a new route, whose URL doesn’t include `template_id` as a parameter - `return_to` is always required I’ve also refactored the code a bit to move the looking up of the back link from the Jinja into the view layer, so that the related code is in one place and easier to reason about.
2019-11-07 13:31:02 +00:00
from functools import partial
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
Move letter too long banner message over from utils, also refactor
2019-10-01 17:16:15 +01:00
from flask import abort, flash, redirect, render_template, request, url_for
Have permissions decorators check user signed in Rather than force us to write the decorators in a specific order let’s just have one decorator call the other. This should make fewer lines of code, and fewer annoying test failures. It also means that the same way of raising a `401` (through the `current_app` method) is used everywhere.
2019-07-01 15:22:08 +01:00
from flask_login import current_user
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
Move letter length check to utils repo so template-preview can use it, too Update requirements
2019-10-09 14:56:18 +01:00
from notifications_utils import LETTER_MAX_PAGE_COUNT
from notifications_utils.pdf import is_letter_too_long
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,
Update message seen when deleting a template.
2020-02-04 16:00:51 +00:00
format_delta,
fix one more place where senders weren't sanitised make sure everything is using the `nl2br` formatter that properly wraps it in markdown to keep everything sanitised nicely. Also write a couple of tests
2020-01-22 16:13:25 +00:00
nl2br,
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
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,
)
change letter previews to be in the no_cookies blueprint this blueprint should be applied to every endpoint that is loaded async (as in via a src tag on an img, iframe, etc)
2019-11-29 11:40:49 +00:00
from app.main import main, no_cookie
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 (
Allow adding broadcast templates At the moment the page is the same as for text message templates, except: - different H1 - no guidance about personalisation, links, etc (until we decide how these should work) For now you won’t be able to really create a broadcast template, because the API doesn’t support it (the API will respond with a 400). But that’s OK because no real services have the broadcast permission yet. This required a bit of refactoring of how we check which template types a service can use, because there were some hard-coded assumptions about emails and text messages.
2020-07-01 16:43:08 +01:00
BroadcastTemplateForm,
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
EmailTemplateForm,
LetterTemplateForm,
Edit template postage from a separate view
2019-01-29 15:43:59 +00:00
LetterTemplatePostageForm,
remove option for branding to sometimes not show search it wouldn't show search if there were under a certain amount of letter or email branding options - however we know there will always be more than that amount so lets remove some complexity. Also, rename the SearchTemplatesForm because it can search anything - it just prompts you to search by name is all.
2019-02-06 17:32:13 +00:00
SearchByNameForm,
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
)
flake8
2019-11-29 13:03:23 +00:00
from app.main.views.send import 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 (
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,
Show letter branding preview when selecting a brand This adds a preview pane which is visible when updating a letter brand. If JavaScript is enabled, the preview pane shows on the set-letter-branding page, and submitting the form saves updates the letter brand for a service immediately. If Javascript is not enabled, there is a separate 'Preview email branding' page which shows a preview of the brand and has a 'Save' button on it.
2019-02-15 14:47:39 +00:00
user_is_platform_admin,
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
)
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,
Allow adding broadcast templates At the moment the page is the same as for text message templates, except: - different H1 - no guidance about personalisation, links, etc (until we decide how these should work) For now you won’t be able to really create a broadcast template, because the API doesn’t support it (the API will respond with a 400). But that’s OK because no real services have the broadcast permission yet. This required a bit of refactoring of how we check which template types a service can use, because there were some hard-coded assumptions about emails and text messages.
2020-07-01 16:43:08 +01:00
'letter': LetterTemplateForm,
'broadcast': BroadcastTemplateForm,
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
Require IDs to be UUIDs in URLS We mostly rely on the API returning a 404 to generate 404s for trying to get things with non-UUID IDs. This is fine, except our tests often mock these API calls. So it could look like everything is working fine, except the thing your passing in might never be a valid UUID, and thus would 404 in a non-test environment. So this commit: 1. uses the `uuid` URL converter everywhere there’s something that looks like an ID in a URL parameter 2. adds a test which automates checking for 1.
2019-11-04 11:07:55 +00:00
@main.route("/services/<uuid:service_id>/templates/<uuid:template_id>")
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):
Replace sevice api client get template calls with Service methods Instead of using the API client directly views are now calling one of two Service model methods: `get_template` is used for view actions, where the user should see the template page even if they don't have access to the template folder (since all templates are still inked from the dashboard or the sent notifications pages). `get_template_with_user_permission_or_403` will check if the user has access to the template's folder first and return 403 otherwise. This method is used for any endpoints that result in an action: editing template attributes, deleting templates or sending messages.
2019-03-19 16:25:44 +00:00
template = current_service.get_template(template_id)
Hide template and folder action links if user doesn't have folder access Hides action links ('Send', 'Edit', 'Delete' and 'Redact' fro templates and 'Manage' for template folders) and buttons ('New template', 'New folder') if the user doesn't have permission to view current folder or template's parent folder.
2019-03-20 17:27:22 +00:00
template_folder = current_service.get_template_folder(template['folder'])
Remove edit_folder_permissions service setting (feature flag) This removes the edit_folder_permission checks from the code, enabling the folder permissions for all services. This also fixes folder-related tests to set up appropriate user permissions. This should only be merged right after alphagov/notifications-api#2428, when all other permission stories are done.
2019-04-02 15:23:46 +01:00
user_has_template_permission = current_user.has_template_folder_permission(template_folder)
Replace sevice api client get template calls with Service methods Instead of using the API client directly views are now calling one of two Service model methods: `get_template` is used for view actions, where the user should see the template page even if they don't have access to the template folder (since all templates are still inked from the dashboard or the sent notifications pages). `get_template_with_user_permission_or_403` will check if the user has access to the template's folder first and return 403 otherwise. This method is used for any endpoints that result in an action: editing template attributes, deleting templates or sending messages.
2019-03-19 16:25:44 +00:00
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
))
Remove unused variable Presume this is from when we used to render the letter preview in a different way. Removing this saves us an API call every time we’re loading this page.
2019-07-08 11:25:06 +01:00
Harmonise content of error message with the document laid out by our content designer
2019-10-16 13:02:11 +01:00
page_count = get_page_count_for_letter(template)
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,
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(
change letter previews to be in the no_cookies blueprint this blueprint should be applied to every endpoint that is loaded async (as in via a src tag on an img, iframe, etc)
2019-11-29 11:40:49 +00:00
'no_cookie.view_letter_template_preview',
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
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"],
Hide template and folder action links if user doesn't have folder access Hides action links ('Send', 'Edit', 'Delete' and 'Redact' fro templates and 'Manage' for template folders) and buttons ('New template', 'New folder') if the user doesn't have permission to view current folder or template's parent folder.
2019-03-20 17:27:22 +00:00
user_has_template_permission=user_has_template_permission,
Harmonise content of error message with the document laid out by our content designer
2019-10-16 13:02:11 +01:00
letter_too_long=is_letter_too_long(page_count),
Move letter length check to utils repo so template-preview can use it, too Update requirements
2019-10-09 14:56:18 +01:00
letter_max_pages=LETTER_MAX_PAGE_COUNT,
Harmonise content of error message with the document laid out by our content designer
2019-10-16 13:02:11 +01:00
page_count=page_count
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
)
Require IDs to be UUIDs in URLS We mostly rely on the API returning a 404 to generate 404s for trying to get things with non-UUID IDs. This is fine, except our tests often mock these API calls. So it could look like everything is working fine, except the thing your passing in might never be a valid UUID, and thus would 404 in a non-test environment. So this commit: 1. uses the `uuid` URL converter everywhere there’s something that looks like an ID in a URL parameter 2. adds a test which automates checking for 1.
2019-11-04 11:07:55 +00:00
@main.route("/services/<uuid:service_id>/start-tour/<uuid:template_id>")
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):
Replace sevice api client get template calls with Service methods Instead of using the API client directly views are now calling one of two Service model methods: `get_template` is used for view actions, where the user should see the template page even if they don't have access to the template folder (since all templates are still inked from the dashboard or the sent notifications pages). `get_template_with_user_permission_or_403` will check if the user has access to the template's folder first and return 403 otherwise. This method is used for any endpoints that result in an action: editing template attributes, deleting templates or sending messages.
2019-03-19 16:25:44 +00:00
template = current_service.get_template(template_id)
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
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',
)
Add a specific route for template_type=all `all` is not a real template type, so for links to template folders that apply to all template types we have a URL that looks like: ``` /services/<uuid:service_id>/templates ``` However Flask only generates this url when `url_for` is called with `template_type=None`. If called with `template_type=all` then Flask will generate a URL like ``` /services/<uuid:service_id>/templates/all ``` However attempting to load this URL will now 404, since `all` is not a template type recognised by the regex introduced in https://github.com/alphagov/notifications-admin/pull/3176 It would be nice to not have URLs with `all` in them at all, but since people might have bookmarked them we need to support them indefinitely. Also considered but decided against adding `all` to the set of template types because it might cause other problems, for example attempting to create a new template with a type of `all` would never work.
2019-11-13 13:38:02 +00:00
@main.route("/services/<uuid:service_id>/templates/all", methods=['GET', 'POST'])
Prefer shorter URL Flask will pick the first route that matches. Decorators get applied from innermost to outermost. So if the same endpoint is served at `/abc` and `/123` the one used when `url_for` is generating a URL is whichever decorator is lowest (in terms of line number). It doesn’t functionally make a difference, but it’s causing the functional tests to fail at the moment. And shorter URLs are nicer, so I think it makes sense to change here, rather than change the tests.
2019-11-13 15:10:16 +00:00
@main.route("/services/<uuid:service_id>/templates", methods=['GET', 'POST'])
Require IDs to be UUIDs in URLS We mostly rely on the API returning a 404 to generate 404s for trying to get things with non-UUID IDs. This is fine, except our tests often mock these API calls. So it could look like everything is working fine, except the thing your passing in might never be a valid UUID, and thus would 404 in a non-test environment. So this commit: 1. uses the `uuid` URL converter everywhere there’s something that looks like an ID in a URL parameter 2. adds a test which automates checking for 1.
2019-11-04 11:07:55 +00:00
@main.route("/services/<uuid:service_id>/templates/folders/<uuid:template_folder_id>", methods=['GET', 'POST'])
Add URL converters for template and file types Sometimes we manually check that a URL parameter is in a required set. Sometimes we don’t bother. This commit adds a URL converter to do this so that: - we don’t have to re-write the same code every time - it’s easier to apply this check to other endpoints This means endpoints that previously allowed a `template_type` or `message_type` of `None` now 404. So I’ve had to add new routes for with URLs that don’t include such parameters. So this…: ``` /services/128b91b6-2996-4107-bb65-51b7c24a728d/notifications/sms.csv /services/128b91b6-2996-4107-bb65-51b7c24a728d/notifications/None.csv ``` …becomes: ``` /services/128b91b6-2996-4107-bb65-51b7c24a728d/notifications/sms.csv /services/128b91b6-2996-4107-bb65-51b7c24a728d/notifications.csv ``` This matches what we do for the HTML-responding equivalent (see https://github.com/alphagov/notifications-admin/blob/265931d21746918c4ddfc19c4ad3f8cb5683c1bf/app/main/views/jobs.py#L215-L216)
2019-11-04 11:20:08 +00:00
@main.route("/services/<uuid:service_id>/templates/<template_type:template_type>", methods=['GET', 'POST'])
Add a specific route for template_type=all `all` is not a real template type, so for links to template folders that apply to all template types we have a URL that looks like: ``` /services/<uuid:service_id>/templates/folders/<uuid:template_folder_id> ``` However Flask only generates this url when `url_for` is called with `template_type=None`. If called with `template_type=all` then Flask will generate a URL like ``` /services/<uuid:service_id>/templates/all/folders/<uuid:template_folder_id> ``` However attempting to load this URL will now 404, since `all` is not a template type recognised by the regex introduced in https://github.com/alphagov/notifications-admin/pull/3176 It would be nice to not have URLs with `all` in them at all, but since people might have bookmarked them we need to support them indefinitely. Also considered but decided against adding `all` to the set of template types because it might cause other problems, for example attempting to create a new template with a type of `all` would never work.
2019-11-13 12:45:26 +00:00
@main.route("/services/<uuid:service_id>/templates/all/folders/<uuid:template_folder_id>", methods=['GET', 'POST'])
flake8
2019-11-29 13:03:23 +00:00
@main.route(
"/services/<uuid:service_id>/templates/<template_type:template_type>/folders/<uuid:template_folder_id>",
methods=['GET', 'POST']
)
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):
Hide template and folder action links if user doesn't have folder access Hides action links ('Send', 'Edit', 'Delete' and 'Redact' fro templates and 'Manage' for template folders) and buttons ('New template', 'New folder') if the user doesn't have permission to view current folder or template's parent folder.
2019-03-20 17:27:22 +00:00
template_folder = current_service.get_template_folder(template_folder_id)
Remove edit_folder_permissions service setting (feature flag) This removes the edit_folder_permission checks from the code, enabling the folder permissions for all services. This also fixes folder-related tests to set up appropriate user permissions. This should only be merged right after alphagov/notifications-api#2428, when all other permission stories are done.
2019-04-02 15:23:46 +01:00
user_has_template_folder_permission = current_user.has_template_folder_permission(template_folder)
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
Add a user method to check folder permission User model is the most natural place for a permission check method, however this means that we need to pass the full user object to service model methods and TemplateList instead of user_id.
2019-03-11 14:13:56 +00:00
template_list = TemplateList(current_service, template_type, template_folder_id, current_user)
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
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(
Add a user method to check folder permission User model is the most natural place for a permission check method, however this means that we need to pass the full user object to service model methods and TemplateList instead of user_id.
2019-03-11 14:13:56 +00:00
all_template_folders=current_service.get_user_template_folders(current_user),
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,
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,
Allow adding broadcast templates At the moment the page is the same as for text message templates, except: - different H1 - no guidance about personalisation, links, etc (until we decide how these should work) For now you won’t be able to really create a broadcast template, because the API doesn’t support it (the API will respond with a 400). But that’s OK because no real services have the broadcast permission yet. This required a bit of refactoring of how we check which template types a service can use, because there were some hard-coded assumptions about emails and text messages.
2020-07-01 16:43:08 +01:00
available_template_types=current_service.available_template_types,
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_copy_of_template=(
Rename `all_services` property on user For consistency with `.organisations`/`.organisation_ids`. `.services` returns a list of semi-rich dictionaries for each service. `.service_ids` returns service IDs only.
2019-06-07 12:22:15 +01:00
current_service.all_templates or len(current_user.service_ids) > 1
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
),
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():
Remove folders feature flag Every service has this feature now[1] so we don’t need to check whether or not it’s switched on any more. 1. https://github.com/alphagov/notifications-api/pull/2286
2019-02-11 16:06:46 +00:00
if not current_user.has_permissions('manage_templates'):
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
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)
Allow adding broadcast templates At the moment the page is the same as for text message templates, except: - different H1 - no guidance about personalisation, links, etc (until we decide how these should work) For now you won’t be able to really create a broadcast template, because the API doesn’t support it (the API will respond with a 400). But that’s OK because no real services have the broadcast permission yet. This required a bit of refactoring of how we check which template types a service can use, because there were some hard-coded assumptions about emails and text messages.
2020-07-01 16:43:08 +01:00
elif templates_and_folders_form.trying_to_add_unavailable_template_type:
return redirect(url_for(
'.action_blocked',
service_id=current_service.id,
notification_type=templates_and_folders_form.add_template_by_template_type.data,
return_to='add_new_template',
))
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')
Removed links to add_template_by_type_endpoint The endpoint was removed, but was still linked to in a couple of places. Some old links were no longer needed, so have been removed. We do still need a link to `add_template_by_type` on the 'Choose reply' page - this page is used to allow to let someone pick a template to reply to inbound SMS with. Since the link only appears if they have no SMS templates, we now link to `.choose_template` with the templates and folders form already opened at the option to add a template.
2019-02-14 16:27:13 +00:00
initial_state = request.args.get('initial_state')
if request.method == 'GET' and initial_state:
templates_and_folders_form.op = initial_state
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,
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,
remove option for branding to sometimes not show search it wouldn't show search if there were under a certain amount of letter or email branding options - however we know there will always be more than that amount so lets remove some complexity. Also, rename the SearchTemplatesForm because it can search anything - it just prompts you to search by name is all.
2019-02-06 17:32:13 +00:00
search_form=SearchByNameForm(),
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(),
Hide template and folder action links if user doesn't have folder access Hides action links ('Send', 'Edit', 'Delete' and 'Redact' fro templates and 'Manage' for template folders) and buttons ('New template', 'New folder') if the user doesn't have permission to view current folder or template's parent folder.
2019-03-20 17:27:22 +00:00
user_has_template_folder_permission=user_has_template_folder_permission,
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=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):
Add user permission check to template folder actions
2019-03-20 17:26:51 +00:00
current_service.get_template_folder_with_user_permission_or_403(current_folder_id, current_user)
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 = 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',
Allow adding broadcast templates At the moment the page is the same as for text message templates, except: - different H1 - no guidance about personalisation, links, etc (until we decide how these should work) For now you won’t be able to really create a broadcast template, because the API doesn’t support it (the API will respond with a 400). But that’s OK because no real services have the broadcast permission yet. This required a bit of refactoring of how we check which template types a service can use, because there were some hard-coded assumptions about emails and text messages.
2020-07-01 16:43:08 +01:00
'broadcast': 'Broadcast',
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
}[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
]
change letter previews to be in the no_cookies blueprint this blueprint should be applied to every endpoint that is loaded async (as in via a src tag on an img, iframe, etc)
2019-11-29 11:40:49 +00:00
@no_cookie.route("/services/<uuid:service_id>/templates/<uuid:template_id>.<filetype>")
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
Replace sevice api client get template calls with Service methods Instead of using the API client directly views are now calling one of two Service model methods: `get_template` is used for view actions, where the user should see the template page even if they don't have access to the template folder (since all templates are still inked from the dashboard or the sent notifications pages). `get_template_with_user_permission_or_403` will check if the user has access to the template's folder first and return 403 otherwise. This method is used for any endpoints that result in an action: editing template attributes, deleting templates or sending messages.
2019-03-19 16:25:44 +00:00
db_template = current_service.get_template(template_id)
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
change letter previews to be in the no_cookies blueprint this blueprint should be applied to every endpoint that is loaded async (as in via a src tag on an img, iframe, etc)
2019-11-29 11:40:49 +00:00
@no_cookie.route("/templates/letter-preview-image/<filename>")
Show letter branding preview when selecting a brand This adds a preview pane which is visible when updating a letter brand. If JavaScript is enabled, the preview pane shows on the set-letter-branding page, and submitting the form saves updates the letter brand for a service immediately. If Javascript is not enabled, there is a separate 'Preview email branding' page which shows a preview of the brand and has a 'Save' button on it.
2019-02-15 14:47:39 +00:00
@user_is_platform_admin
def letter_branding_preview_image(filename):
template = {
'subject': 'An example letter',
'content': (
'Lorem Ipsum is simply dummy text of the printing and typesetting '
'industry.\n\nLorem Ipsum has been the industry’s standard dummy '
'text ever since the 1500s, when an unknown printer took a galley '
'of type and scrambled it to make a type specimen book.\n\n'
'# History\n\nIt has survived not only\n\n'
'* five centuries\n'
'* but also the leap into electronic typesetting\n\n'
'It was popularised in the 1960s with the release of Letraset '
'sheets containing Lorem Ipsum passages, and more recently with '
'desktop publishing software like Aldus PageMaker including '
'versions of Lorem Ipsum.\n\n'
'The point of using Lorem Ipsum is that it has a more-or-less '
'normal distribution of letters, as opposed to using ‘Content '
'here, content here’, making it look like readable English.'
Fix letter branding preview Template preview requires `template_type` to be passed in now.
2020-04-21 10:59:35 +01:00
),
'template_type': 'letter',
Show letter branding preview when selecting a brand This adds a preview pane which is visible when updating a letter brand. If JavaScript is enabled, the preview pane shows on the set-letter-branding page, and submitting the form saves updates the letter brand for a service immediately. If Javascript is not enabled, there is a separate 'Preview email branding' page which shows a preview of the brand and has a 'Save' button on it.
2019-02-15 14:47:39 +00:00
}
filename = None if filename == 'no-branding' else filename
return TemplatePreview.from_example_template(template, filename)
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(
Replace sevice api client get template calls with Service methods Instead of using the API client directly views are now calling one of two Service model methods: `get_template` is used for view actions, where the user should see the template page even if they don't have access to the template folder (since all templates are still inked from the dashboard or the sent notifications pages). `get_template_with_user_permission_or_403` will check if the user has access to the template's folder first and return 403 otherwise. This method is used for any endpoints that result in an action: editing template attributes, deleting templates or sending messages.
2019-03-19 16:25:44 +00:00
current_service.get_template(template_id, version=version),
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,
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(
change letter previews to be in the no_cookies blueprint this blueprint should be applied to every endpoint that is loaded async (as in via a src tag on an img, iframe, etc)
2019-11-29 11:40:49 +00:00
'no_cookie.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
))
Require IDs to be UUIDs in URLS We mostly rely on the API returning a 404 to generate 404s for trying to get things with non-UUID IDs. This is fine, except our tests often mock these API calls. So it could look like everything is working fine, except the thing your passing in might never be a valid UUID, and thus would 404 in a non-test environment. So this commit: 1. uses the `uuid` URL converter everywhere there’s something that looks like an ID in a URL parameter 2. adds a test which automates checking for 1.
2019-11-04 11:07:55 +00:00
@main.route("/services/<uuid:service_id>/templates/<uuid:template_id>/version/<int:version>")
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
)
change letter previews to be in the no_cookies blueprint this blueprint should be applied to every endpoint that is loaded async (as in via a src tag on an img, iframe, etc)
2019-11-29 11:40:49 +00:00
@no_cookie.route("/services/<uuid:service_id>/templates/<uuid:template_id>/version/<int:version>.<filetype>")
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):
Replace sevice api client get template calls with Service methods Instead of using the API client directly views are now calling one of two Service model methods: `get_template` is used for view actions, where the user should see the template page even if they don't have access to the template folder (since all templates are still inked from the dashboard or the sent notifications pages). `get_template_with_user_permission_or_403` will check if the user has access to the template's folder first and return 403 otherwise. This method is used for any endpoints that result in an action: editing template attributes, deleting templates or sending messages.
2019-03-19 16:25:44 +00:00
db_template = current_service.get_template(template_id, version=version)
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
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
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(
Updated default letter template name To keep the H1/titles of new templates consistent with the sticky menu options. Updated default letter template name from `Untitled` to `New letter template`
2019-02-21 10:51:01 +00:00
'New letter template',
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
'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'],
))
Allow adding broadcast templates At the moment the page is the same as for text message templates, except: - different H1 - no guidance about personalisation, links, etc (until we decide how these should work) For now you won’t be able to really create a broadcast template, because the API doesn’t support it (the API will respond with a 400). But that’s OK because no real services have the broadcast permission yet. This required a bit of refactoring of how we check which template types a service can use, because there were some hard-coded assumptions about emails and text messages.
2020-07-01 16:43:08 +01:00
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
Require IDs to be UUIDs in URLS We mostly rely on the API returning a 404 to generate 404s for trying to get things with non-UUID IDs. This is fine, except our tests often mock these API calls. So it could look like everything is working fine, except the thing your passing in might never be a valid UUID, and thus would 404 in a non-test environment. So this commit: 1. uses the `uuid` URL converter everywhere there’s something that looks like an ID in a URL parameter 2. adds a test which automates checking for 1.
2019-11-04 11:07:55 +00:00
@main.route("/services/<uuid:service_id>/templates/copy")
@main.route("/services/<uuid:service_id>/templates/copy/from-folder/<uuid:from_folder>")
@main.route("/services/<uuid:service_id>/templates/copy/from-service/<uuid:from_service>")
flake8
2019-11-29 13:03:23 +00:00
@main.route(
"/services/<uuid: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
@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,
Add a user method to check folder permission User model is the most natural place for a permission check method, however this means that we need to pass the full user object to service model methods and TemplateList instead of user_id.
2019-03-11 14:13:56 +00:00
user=current_user
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
),
template_folder_path=service.get_template_folder_path(from_folder),
from_service=service,
remove option for branding to sometimes not show search it wouldn't show search if there were under a certain amount of letter or email branding options - however we know there will always be more than that amount so lets remove some complexity. Also, rename the SearchTemplatesForm because it can search anything - it just prompts you to search by name is all.
2019-02-06 17:32:13 +00:00
search_form=SearchByNameForm(),
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
)
else:
return render_template(
'views/templates/copy.html',
Make user model return a service model, not JSON This makes it: - nicer, by having access to sensibly named things like `Service.trial_mode` instead of `service['restricted']`. - less likely to write Jinja code like `service.trail_mode`, which would fail silently if `service` was a dictionary
2019-06-07 12:38:48 +01:00
services_templates_and_folders=TemplateLists(current_user),
remove option for branding to sometimes not show search it wouldn't show search if there were under a certain amount of letter or email branding options - however we know there will always be more than that amount so lets remove some complexity. Also, rename the SearchTemplatesForm because it can search anything - it just prompts you to search by name is all.
2019-02-06 17:32:13 +00:00
search_form=SearchByNameForm(),
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
)
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
Require IDs to be UUIDs in URLS We mostly rely on the API returning a 404 to generate 404s for trying to get things with non-UUID IDs. This is fine, except our tests often mock these API calls. So it could look like everything is working fine, except the thing your passing in might never be a valid UUID, and thus would 404 in a non-test environment. So this commit: 1. uses the `uuid` URL converter everywhere there’s something that looks like an ID in a URL parameter 2. adds a test which automates checking for 1.
2019-11-04 11:07:55 +00:00
@main.route("/services/<uuid:service_id>/templates/copy/<uuid:template_id>", methods=['GET', 'POST'])
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
@user_has_permissions('manage_templates')
def copy_template(service_id, template_id):
fix bug with copying template from folder in other service
2019-04-03 13:59:44 +01:00
from_service = 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
fix bug with copying template from folder in other service
2019-04-03 13:59:44 +01:00
current_user.belongs_to_service_or_403(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
Don’t return UUID objects from the UUID convertor Because it means you often have to cast to string in your application code just to get your tests passing. The method being monkey patched is originally defined here: https://github.com/pallets/werkzeug/blob/b81aa0f18c7336a0421b569d8a5dab8d5c0d7517/src/werkzeug/routing.py#L1272
2019-11-04 12:20:09 +00:00
template = service_api_client.get_service_template(from_service, template_id)['data']
Edit, don’t duplicate, existing templates
2018-07-31 16:20:10 +01:00
fix bug with copying template from folder in other service
2019-04-03 13:59:44 +01:00
template_folder = template_folder_api_client.get_template_folder(from_service, template['folder'])
Remove edit_folder_permissions service setting (feature flag) This removes the edit_folder_permission checks from the code, enabling the folder permissions for all services. This also fixes folder-related tests to set up appropriate user permissions. This should only be merged right after alphagov/notifications-api#2428, when all other permission stories are done.
2019-04-02 15:23:46 +01:00
if not current_user.has_template_folder_permission(template_folder):
Add folder permission check to copy template endpoint Copying a template from another service is one place where we can't use the `current_service` method since the source template can belong to a different service the user has access to, so we're using an API client method.
2019-03-20 16:41:01 +00:00
abort(403)
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,
Add GOV.UK Design System style back links The Design System has standardised on back links being at the top of the page, decorated with a small text-coloured arrow. I think this makes more sense than having them at the bottom, because it suggests, in some way, being able to go back before commiting to any of the forms on the page. Whereas the things at the bottom of the page should be performing actions on what’s in the page. The reason for making this change now is that it de-clutters the area around the green buttons. This was presenting a design challenge where multiple levels of interaction were happening in the same form. Moving these back links to the top of the page should mean that, in these complicated forms, there’s one fewer thing to compete for the user’s attention. I’ve componentised this into a `page_header` macro so that the change is easier to roll out and maintain.
2019-04-29 11:44:05 +01:00
template=template,
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
heading_action='Add',
Rename `all_services` property on user For consistency with `.organisations`/`.organisation_ids`. `.services` returns a list of semi-rich dictionaries for each service. `.service_ids` returns service IDs only.
2019-06-07 12:22:15 +01:00
services=current_user.service_ids,
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
)
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'])
Require IDs to be UUIDs in URLS We mostly rely on the API returning a 404 to generate 404s for trying to get things with non-UUID IDs. This is fine, except our tests often mock these API calls. So it could look like everything is working fine, except the thing your passing in might never be a valid UUID, and thus would 404 in a non-test environment. So this commit: 1. uses the `uuid` URL converter everywhere there’s something that looks like an ID in a URL parameter 2. adds a test which automates checking for 1.
2019-11-04 11:07:55 +00:00
@main.route((
'/services/<uuid:service_id>/templates/action-blocked/'
Require `return_to` param in `action_blocked` The `action_blocked` endpoint needed a variation of the URL without a `template_id` parameter, because `None` is no longer a valid `template_id` (because it’s not a UUID). This change was made in 265931d21746918c4ddfc19c4ad3f8cb5683c1bf, which also removed the `return_to` parameter, because the back link on the `action blocked` page only ever goes to `add_new_template` if there’s no `template_id` provided. However this was conflating the two things, so I’ve wound it back a bit so that: - there’s still a new route, whose URL doesn’t include `template_id` as a parameter - `return_to` is always required I’ve also refactored the code a bit to move the looking up of the back link from the Jinja into the view layer, so that the related code is in one place and easier to reason about.
2019-11-07 13:31:02 +00:00
'<template_type:notification_type>/<return_to>'
Require IDs to be UUIDs in URLS We mostly rely on the API returning a 404 to generate 404s for trying to get things with non-UUID IDs. This is fine, except our tests often mock these API calls. So it could look like everything is working fine, except the thing your passing in might never be a valid UUID, and thus would 404 in a non-test environment. So this commit: 1. uses the `uuid` URL converter everywhere there’s something that looks like an ID in a URL parameter 2. adds a test which automates checking for 1.
2019-11-04 11:07:55 +00:00
))
@main.route((
'/services/<uuid:service_id>/templates/action-blocked/'
Add URL converters for template and file types Sometimes we manually check that a URL parameter is in a required set. Sometimes we don’t bother. This commit adds a URL converter to do this so that: - we don’t have to re-write the same code every time - it’s easier to apply this check to other endpoints This means endpoints that previously allowed a `template_type` or `message_type` of `None` now 404. So I’ve had to add new routes for with URLs that don’t include such parameters. So this…: ``` /services/128b91b6-2996-4107-bb65-51b7c24a728d/notifications/sms.csv /services/128b91b6-2996-4107-bb65-51b7c24a728d/notifications/None.csv ``` …becomes: ``` /services/128b91b6-2996-4107-bb65-51b7c24a728d/notifications/sms.csv /services/128b91b6-2996-4107-bb65-51b7c24a728d/notifications.csv ``` This matches what we do for the HTML-responding equivalent (see https://github.com/alphagov/notifications-admin/blob/265931d21746918c4ddfc19c4ad3f8cb5683c1bf/app/main/views/jobs.py#L215-L216)
2019-11-04 11:20:08 +00:00
'<template_type:notification_type>/<return_to>/<uuid:template_id>'
Require IDs to be UUIDs in URLS We mostly rely on the API returning a 404 to generate 404s for trying to get things with non-UUID IDs. This is fine, except our tests often mock these API calls. So it could look like everything is working fine, except the thing your passing in might never be a valid UUID, and thus would 404 in a non-test environment. So this commit: 1. uses the `uuid` URL converter everywhere there’s something that looks like an ID in a URL parameter 2. adds a test which automates checking for 1.
2019-11-04 11:07:55 +00:00
))
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')
Require `return_to` param in `action_blocked` The `action_blocked` endpoint needed a variation of the URL without a `template_id` parameter, because `None` is no longer a valid `template_id` (because it’s not a UUID). This change was made in 265931d21746918c4ddfc19c4ad3f8cb5683c1bf, which also removed the `return_to` parameter, because the back link on the `action blocked` page only ever goes to `add_new_template` if there’s no `template_id` provided. However this was conflating the two things, so I’ve wound it back a bit so that: - there’s still a new route, whose URL doesn’t include `template_id` as a parameter - `return_to` is always required I’ve also refactored the code a bit to move the looking up of the back link from the Jinja into the view layer, so that the related code is in one place and easier to reason about.
2019-11-07 13:31:02 +00:00
def action_blocked(service_id, notification_type, return_to, template_id=None):
back_link = {
'add_new_template': partial(
url_for, '.choose_template', service_id=current_service.id
),
'templates': partial(
url_for, '.choose_template', service_id=current_service.id
),
'view_template': partial(
url_for, '.view_template', service_id=current_service.id, template_id=template_id
),
}.get(return_to)
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 render_template(
'views/templates/action_blocked.html',
service_id=service_id,
notification_type=notification_type,
Require `return_to` param in `action_blocked` The `action_blocked` endpoint needed a variation of the URL without a `template_id` parameter, because `None` is no longer a valid `template_id` (because it’s not a UUID). This change was made in 265931d21746918c4ddfc19c4ad3f8cb5683c1bf, which also removed the `return_to` parameter, because the back link on the `action blocked` page only ever goes to `add_new_template` if there’s no `template_id` provided. However this was conflating the two things, so I’ve wound it back a bit so that: - there’s still a new route, whose URL doesn’t include `template_id` as a parameter - `return_to` is always required I’ve also refactored the code a bit to move the looking up of the back link from the Jinja into the view layer, so that the related code is in one place and easier to reason about.
2019-11-07 13:31:02 +00:00
back_link=back_link(),
Allow adding broadcast templates At the moment the page is the same as for text message templates, except: - different H1 - no guidance about personalisation, links, etc (until we decide how these should work) For now you won’t be able to really create a broadcast template, because the API doesn’t support it (the API will respond with a 400). But that’s OK because no real services have the broadcast permission yet. This required a bit of refactoring of how we check which template types a service can use, because there were some hard-coded assumptions about emails and text messages.
2020-07-01 16:43:08 +01:00
), 403
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
Require IDs to be UUIDs in URLS We mostly rely on the API returning a 404 to generate 404s for trying to get things with non-UUID IDs. This is fine, except our tests often mock these API calls. So it could look like everything is working fine, except the thing your passing in might never be a valid UUID, and thus would 404 in a non-test environment. So this commit: 1. uses the `uuid` URL converter everywhere there’s something that looks like an ID in a URL parameter 2. adds a test which automates checking for 1.
2019-11-04 11:07:55 +00:00
@main.route("/services/<uuid:service_id>/templates/folders/<uuid: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
@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):
Add user permission check to template folder actions
2019-03-20 17:26:51 +00:00
template_folder = current_service.get_template_folder_with_user_permission_or_403(template_folder_id, current_user)
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(
Add user permission check to template folder actions
2019-03-20 17:26:51 +00:00
name=template_folder['name'],
users_with_permission=template_folder.get('users_with_permission', None),
Show all users in folder viewing permissions, correct users checked
2019-03-18 16:12:12 +00:00
all_service_users=[user for user in current_service.active_users if user.id != current_user.id]
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
)
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():
User permissions section for a folder noy visible if service only has one user If no manage users permission then don't pass user folder permissions to api
2019-04-02 12:26:41 +01:00
if current_user.has_permissions("manage_service") and form.users_with_permission.all_service_users:
users_with_permission = form.users_with_permission.data + [current_user.id]
else:
users_with_permission = None
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
template_folder_api_client.update_template_folder(
Change folder viewing permissions from manage folder page
2019-03-15 17:19:18 +00:00
current_service.id,
template_folder_id,
name=form.name.data,
Show all users in folder viewing permissions, correct users checked
2019-03-18 16:12:12 +00:00
users_with_permission=users_with_permission
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
)
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,
Show checkboxes for users with permission to view the managed folder
2019-03-15 14:13:27 +00:00
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
)
Require IDs to be UUIDs in URLS We mostly rely on the API returning a 404 to generate 404s for trying to get things with non-UUID IDs. This is fine, except our tests often mock these API calls. So it could look like everything is working fine, except the thing your passing in might never be a valid UUID, and thus would 404 in a non-test environment. So this commit: 1. uses the `uuid` URL converter everywhere there’s something that looks like an ID in a URL parameter 2. adds a test which automates checking for 1.
2019-11-04 11:07:55 +00:00
@main.route("/services/<uuid:service_id>/templates/folders/<uuid:template_folder_id>/delete", methods=['GET', 'POST'])
Build delete folder endpoint that calls template_folders_api_client
2018-11-13 17:56:47 +00:00
@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):
Add user permission check to template folder actions
2019-03-20 17:26:51 +00:00
template_folder = current_service.get_template_folder_with_user_permission_or_403(template_folder_id, current_user)
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
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:
This is a fix for delete folder when the service has permission to edit folder permissions.
2019-03-20 17:04:44 +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
)
)
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':
This is a fix for delete folder when the service has permission to edit folder permissions.
2019-03-20 17:04:44 +00:00
Add flash messages and error handling to delete folder flow
2018-11-14 12:16:57 +00:00
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)
This is a fix for delete folder when the service has permission to edit folder permissions.
2019-03-20 17:04:44 +00:00
else:
flash("Are you sure you want to delete the ‘{}’ folder?".format(template_folder['name']), 'delete')
return manage_template_folder(service_id, template_folder_id)
Add a delete folder link to manage folder page and basic delete endpoint
2018-11-13 15:49:25 +00:00
Require IDs to be UUIDs in URLS We mostly rely on the API returning a 404 to generate 404s for trying to get things with non-UUID IDs. This is fine, except our tests often mock these API calls. So it could look like everything is working fine, except the thing your passing in might never be a valid UUID, and thus would 404 in a non-test environment. So this commit: 1. uses the `uuid` URL converter everywhere there’s something that looks like an ID in a URL parameter 2. adds a test which automates checking for 1.
2019-11-04 11:07:55 +00:00
@main.route(
Add URL converters for template and file types Sometimes we manually check that a URL parameter is in a required set. Sometimes we don’t bother. This commit adds a URL converter to do this so that: - we don’t have to re-write the same code every time - it’s easier to apply this check to other endpoints This means endpoints that previously allowed a `template_type` or `message_type` of `None` now 404. So I’ve had to add new routes for with URLs that don’t include such parameters. So this…: ``` /services/128b91b6-2996-4107-bb65-51b7c24a728d/notifications/sms.csv /services/128b91b6-2996-4107-bb65-51b7c24a728d/notifications/None.csv ``` …becomes: ``` /services/128b91b6-2996-4107-bb65-51b7c24a728d/notifications/sms.csv /services/128b91b6-2996-4107-bb65-51b7c24a728d/notifications.csv ``` This matches what we do for the HTML-responding equivalent (see https://github.com/alphagov/notifications-admin/blob/265931d21746918c4ddfc19c4ad3f8cb5683c1bf/app/main/views/jobs.py#L215-L216)
2019-11-04 11:20:08 +00:00
"/services/<uuid:service_id>/templates/add-<template_type:template_type>",
Require IDs to be UUIDs in URLS We mostly rely on the API returning a 404 to generate 404s for trying to get things with non-UUID IDs. This is fine, except our tests often mock these API calls. So it could look like everything is working fine, except the thing your passing in might never be a valid UUID, and thus would 404 in a non-test environment. So this commit: 1. uses the `uuid` URL converter everywhere there’s something that looks like an ID in a URL parameter 2. adds a test which automates checking for 1.
2019-11-04 11:07:55 +00:00
methods=['GET', 'POST'],
)
@main.route(
Add URL converters for template and file types Sometimes we manually check that a URL parameter is in a required set. Sometimes we don’t bother. This commit adds a URL converter to do this so that: - we don’t have to re-write the same code every time - it’s easier to apply this check to other endpoints This means endpoints that previously allowed a `template_type` or `message_type` of `None` now 404. So I’ve had to add new routes for with URLs that don’t include such parameters. So this…: ``` /services/128b91b6-2996-4107-bb65-51b7c24a728d/notifications/sms.csv /services/128b91b6-2996-4107-bb65-51b7c24a728d/notifications/None.csv ``` …becomes: ``` /services/128b91b6-2996-4107-bb65-51b7c24a728d/notifications/sms.csv /services/128b91b6-2996-4107-bb65-51b7c24a728d/notifications.csv ``` This matches what we do for the HTML-responding equivalent (see https://github.com/alphagov/notifications-admin/blob/265931d21746918c4ddfc19c4ad3f8cb5683c1bf/app/main/views/jobs.py#L215-L216)
2019-11-04 11:20:08 +00:00
"/services/<uuid:service_id>/templates/folders/<uuid:template_folder_id>/add-<template_type:template_type>",
Require IDs to be UUIDs in URLS We mostly rely on the API returning a 404 to generate 404s for trying to get things with non-UUID IDs. This is fine, except our tests often mock these API calls. So it could look like everything is working fine, except the thing your passing in might never be a valid UUID, and thus would 404 in a non-test environment. So this commit: 1. uses the `uuid` URL converter everywhere there’s something that looks like an ID in a URL parameter 2. adds a test which automates checking for 1.
2019-11-04 11:07:55 +00:00
methods=['GET', 'POST'],
)
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
Allow adding broadcast templates At the moment the page is the same as for text message templates, except: - different H1 - no guidance about personalisation, links, etc (until we decide how these should work) For now you won’t be able to really create a broadcast template, because the API doesn’t support it (the API will respond with a 400). But that’s OK because no real services have the broadcast permission yet. This required a bit of refactoring of how we check which template types a service can use, because there were some hard-coded assumptions about emails and text messages.
2020-07-01 16:43:08 +01:00
if template_type not in current_service.available_template_types:
return redirect(url_for(
'.action_blocked',
service_id=service_id,
notification_type=template_type,
template_folder_id=template_folder_id,
return_to='templates',
))
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
Allow adding broadcast templates At the moment the page is the same as for text message templates, except: - different H1 - no guidance about personalisation, links, etc (until we decide how these should work) For now you won’t be able to really create a broadcast template, because the API doesn’t support it (the API will respond with a 400). But that’s OK because no real services have the broadcast permission yet. This required a bit of refactoring of how we check which template types a service can use, because there were some hard-coded assumptions about emails and text messages.
2020-07-01 16:43:08 +01:00
return render_template(
'views/edit-{}-template.html'.format(template_type),
form=form,
template_type=template_type,
template_folder_id=template_folder_id,
heading_action='New',
)
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)
Require IDs to be UUIDs in URLS We mostly rely on the API returning a 404 to generate 404s for trying to get things with non-UUID IDs. This is fine, except our tests often mock these API calls. So it could look like everything is working fine, except the thing your passing in might never be a valid UUID, and thus would 404 in a non-test environment. So this commit: 1. uses the `uuid` URL converter everywhere there’s something that looks like an ID in a URL parameter 2. adds a test which automates checking for 1.
2019-11-04 11:07:55 +00:00
@main.route("/services/<uuid:service_id>/templates/<uuid:template_id>/edit", methods=['GET', 'POST'])
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):
Replace sevice api client get template calls with Service methods Instead of using the API client directly views are now calling one of two Service model methods: `get_template` is used for view actions, where the user should see the template page even if they don't have access to the template folder (since all templates are still inked from the dashboard or the sent notifications pages). `get_template_with_user_permission_or_403` will check if the user has access to the template's folder first and return 403 otherwise. This method is used for any endpoints that result in an action: editing template attributes, deleting templates or sending messages.
2019-03-19 16:25:44 +00:00
template = current_service.get_template_with_user_permission_or_403(template_id, current_user)
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)
Only show breaking change page to API users We introduced the ‘breaking change’ page[1] partly to help teach people about the relationship between the placeholders in their template and the data they were providing. Data can be provided either by API or by uploading a spreadsheet. The users who we struggled to communicate this relationship to were the ones using the upload a spreadsheet feature. We made two changes to the context of this feature: 1. Around the same time we introduced the interactive tour[2], which ultimately proved to be the thing that helped people understand the relationship between the data they were providing and the placeholders in the template. 2. We introduced a way for people to send one-off messages without using the API or uploading a spreadsheet[3]. So for this page to say that you’ll need to update a spreadsheet or change an API call if you change the placeholders in your template is no longer accurate. Therefore I think it makes sense to only show this page to teams who are using the API to send messages. The best proxy we have for that is to look at whether they’ve created any API keys. *** 1. https://github.com/alphagov/notifications-admin/pull/631 2. https://github.com/alphagov/notifications-admin/pull/613 3. https://github.com/alphagov/notifications-admin/pull/1293
2019-11-12 16:57:01 +00:00
if (
template_change.placeholders_added and
not request.form.get('confirm') and
current_service.api_keys
):
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,
Remove spreadsheet example from breaking change Since we’re only showing this page to team who are using the API we don’t have to worry about explaining what’s going on in terms of the spreadsheet any more. This makes the page simpler.
2019-11-12 16:59:39 +00:00
form=form,
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
)
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
Allow adding broadcast templates At the moment the page is the same as for text message templates, except: - different H1 - no guidance about personalisation, links, etc (until we decide how these should work) For now you won’t be able to really create a broadcast template, because the API doesn’t support it (the API will respond with a 400). But that’s OK because no real services have the broadcast permission yet. This required a bit of refactoring of how we check which template types a service can use, because there were some hard-coded assumptions about emails and text messages.
2020-07-01 16:43:08 +01:00
if template['template_type'] not in current_service.available_template_types:
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,
Replace sevice api client get template calls with Service methods Instead of using the API client directly views are now calling one of two Service model methods: `get_template` is used for view actions, where the user should see the template page even if they don't have access to the template folder (since all templates are still inked from the dashboard or the sent notifications pages). `get_template_with_user_permission_or_403` will check if the user has access to the template's folder first and return 403 otherwise. This method is used for any endpoints that result in an action: editing template attributes, deleting templates or sending messages.
2019-03-19 16:25:44 +00:00
notification_type=template['template_type'],
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_to='view_template',
template_id=template_id
))
else:
return render_template(
'views/edit-{}-template.html'.format(template['template_type']),
form=form,
Add GOV.UK Design System style back links The Design System has standardised on back links being at the top of the page, decorated with a small text-coloured arrow. I think this makes more sense than having them at the bottom, because it suggests, in some way, being able to go back before commiting to any of the forms on the page. Whereas the things at the bottom of the page should be performing actions on what’s in the page. The reason for making this change now is that it de-clutters the area around the green buttons. This was presenting a design challenge where multiple levels of interaction were happening in the same form. Moving these back links to the top of the page should mean that, in these complicated forms, there’s one fewer thing to compete for the user’s attention. I’ve componentised this into a `page_header` macro so that the change is easier to roll out and maintain.
2019-04-29 11:44:05 +01:00
template=template,
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
Require IDs to be UUIDs in URLS We mostly rely on the API returning a 404 to generate 404s for trying to get things with non-UUID IDs. This is fine, except our tests often mock these API calls. So it could look like everything is working fine, except the thing your passing in might never be a valid UUID, and thus would 404 in a non-test environment. So this commit: 1. uses the `uuid` URL converter everywhere there’s something that looks like an ID in a URL parameter 2. adds a test which automates checking for 1.
2019-11-04 11:07:55 +00:00
@main.route("/services/<uuid:service_id>/templates/<uuid:template_id>/delete", methods=['GET', 'POST'])
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):
Replace sevice api client get template calls with Service methods Instead of using the API client directly views are now calling one of two Service model methods: `get_template` is used for view actions, where the user should see the template page even if they don't have access to the template folder (since all templates are still inked from the dashboard or the sent notifications pages). `get_template_with_user_permission_or_403` will check if the user has access to the template's folder first and return 403 otherwise. This method is used for any endpoints that result in an action: editing template attributes, deleting templates or sending messages.
2019-03-19 16:25:44 +00:00
template = current_service.get_template_with_user_permission_or_403(template_id, current_user)
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,
Return to a template’s folder after deleting it It’s disconcerting going back to the root if a template is in a deeply nested folder. Especially if you’re trying to delete multiple templates.
2019-02-13 17:46:35 +00:00
template_folder_id=template['folder'],
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 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:
Change the content for the delete template confirmation dialog. As per https://www.pivotaltracker.com/story/show/170796514 we want to make the delete template confirmation dialog box more consistent and clear. The API has been updated with a new endpoint that only returns the last-used date, this date is more accurate since it goes to the ft_notification_status table, if the notification table is empty.
2020-02-05 13:52:46 +00:00
last_used_notification = template_statistics_client.get_last_used_date_for_template(
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
service_id, template['id']
)
Update message seen when deleting a template.
2020-02-04 16:00:51 +00:00
message = 'This template has never been used.' if not last_used_notification else \
Change the content for the delete template confirmation dialog. As per https://www.pivotaltracker.com/story/show/170796514 we want to make the delete template confirmation dialog box more consistent and clear. The API has been updated with a new endpoint that only returns the last-used date, this date is more accurate since it goes to the ft_notification_status table, if the notification table is empty.
2020-02-05 13:52:46 +00:00
'This template was last used {}.'.format(format_delta(last_used_notification))
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,
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(
change letter previews to be in the no_cookies blueprint this blueprint should be applied to every endpoint that is loaded async (as in via a src tag on an img, iframe, etc)
2019-11-29 11:40:49 +00:00
'no_cookie.view_letter_template_preview',
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
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
),
Hide template and folder action links if user doesn't have folder access Hides action links ('Send', 'Edit', 'Delete' and 'Redact' fro templates and 'Manage' for template folders) and buttons ('New template', 'New folder') if the user doesn't have permission to view current folder or template's parent folder.
2019-03-20 17:27:22 +00:00
user_has_template_permission=True,
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
Require IDs to be UUIDs in URLS We mostly rely on the API returning a 404 to generate 404s for trying to get things with non-UUID IDs. This is fine, except our tests often mock these API calls. So it could look like everything is working fine, except the thing your passing in might never be a valid UUID, and thus would 404 in a non-test environment. So this commit: 1. uses the `uuid` URL converter everywhere there’s something that looks like an ID in a URL parameter 2. adds a test which automates checking for 1.
2019-11-04 11:07:55 +00:00
@main.route("/services/<uuid:service_id>/templates/<uuid:template_id>/redact", methods=['GET'])
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):
Replace sevice api client get template calls with Service methods Instead of using the API client directly views are now calling one of two Service model methods: `get_template` is used for view actions, where the user should see the template page even if they don't have access to the template folder (since all templates are still inked from the dashboard or the sent notifications pages). `get_template_with_user_permission_or_403` will check if the user has access to the template's folder first and return 403 otherwise. This method is used for any endpoints that result in an action: editing template attributes, deleting templates or sending messages.
2019-03-19 16:25:44 +00:00
template = current_service.get_template_with_user_permission_or_403(template_id, current_user)
Allow one-off email sending to select the reply-to address
2017-10-16 16:35:35 +01:00
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,
letter_preview_url=url_for(
change letter previews to be in the no_cookies blueprint this blueprint should be applied to every endpoint that is loaded async (as in via a src tag on an img, iframe, etc)
2019-11-29 11:40:49 +00:00
'no_cookie.view_letter_template_preview',
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
service_id=service_id,
template_id=template_id,
filetype='png',
),
show_recipient=True,
),
Hide template and folder action links if user doesn't have folder access Hides action links ('Send', 'Edit', 'Delete' and 'Redact' fro templates and 'Manage' for template folders) and buttons ('New template', 'New folder') if the user doesn't have permission to view current folder or template's parent folder.
2019-03-20 17:27:22 +00:00
user_has_template_permission=True,
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
show_redaction_message=True,
)
Require IDs to be UUIDs in URLS We mostly rely on the API returning a 404 to generate 404s for trying to get things with non-UUID IDs. This is fine, except our tests often mock these API calls. So it could look like everything is working fine, except the thing your passing in might never be a valid UUID, and thus would 404 in a non-test environment. So this commit: 1. uses the `uuid` URL converter everywhere there’s something that looks like an ID in a URL parameter 2. adds a test which automates checking for 1.
2019-11-04 11:07:55 +00:00
@main.route("/services/<uuid:service_id>/templates/<uuid:template_id>/redact", methods=['POST'])
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,
))
Require IDs to be UUIDs in URLS We mostly rely on the API returning a 404 to generate 404s for trying to get things with non-UUID IDs. This is fine, except our tests often mock these API calls. So it could look like everything is working fine, except the thing your passing in might never be a valid UUID, and thus would 404 in a non-test environment. So this commit: 1. uses the `uuid` URL converter everywhere there’s something that looks like an ID in a URL parameter 2. adds a test which automates checking for 1.
2019-11-04 11:07:55 +00:00
@main.route('/services/<uuid:service_id>/templates/<uuid:template_id>/versions')
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,
letter_preview_url=url_for(
change letter previews to be in the no_cookies blueprint this blueprint should be applied to every endpoint that is loaded async (as in via a src tag on an img, iframe, etc)
2019-11-29 11:40:49 +00:00
'no_cookie.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
Require IDs to be UUIDs in URLS We mostly rely on the API returning a 404 to generate 404s for trying to get things with non-UUID IDs. This is fine, except our tests often mock these API calls. So it could look like everything is working fine, except the thing your passing in might never be a valid UUID, and thus would 404 in a non-test environment. So this commit: 1. uses the `uuid` URL converter everywhere there’s something that looks like an ID in a URL parameter 2. adds a test which automates checking for 1.
2019-11-04 11:07:55 +00:00
@main.route('/services/<uuid:service_id>/templates/<uuid:template_id>/set-template-sender', methods=['GET', 'POST'])
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):
Replace sevice api client get template calls with Service methods Instead of using the API client directly views are now calling one of two Service model methods: `get_template` is used for view actions, where the user should see the template page even if they don't have access to the template folder (since all templates are still inked from the dashboard or the sent notifications pages). `get_template_with_user_permission_or_403` will check if the user has access to the template's folder first and return 403 otherwise. This method is used for any endpoints that result in an action: editing template attributes, deleting templates or sending messages.
2019-03-19 16:25:44 +00:00
template = current_service.get_template_with_user_permission_or_403(template_id, current_user)
Allow letter templates to select the default contact block from the list
2018-01-03 10:44:36 +00:00
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
)
Require IDs to be UUIDs in URLS We mostly rely on the API returning a 404 to generate 404s for trying to get things with non-UUID IDs. This is fine, except our tests often mock these API calls. So it could look like everything is working fine, except the thing your passing in might never be a valid UUID, and thus would 404 in a non-test environment. So this commit: 1. uses the `uuid` URL converter everywhere there’s something that looks like an ID in a URL parameter 2. adds a test which automates checking for 1.
2019-11-04 11:07:55 +00:00
@main.route('/services/<uuid:service_id>/templates/<uuid:template_id>/edit-postage', methods=['GET', 'POST'])
Edit template postage from a separate view
2019-01-29 15:43:59 +00:00
@user_has_permissions('manage_templates')
def edit_template_postage(service_id, template_id):
Replace sevice api client get template calls with Service methods Instead of using the API client directly views are now calling one of two Service model methods: `get_template` is used for view actions, where the user should see the template page even if they don't have access to the template folder (since all templates are still inked from the dashboard or the sent notifications pages). `get_template_with_user_permission_or_403` will check if the user has access to the template's folder first and return 403 otherwise. This method is used for any endpoints that result in an action: editing template attributes, deleting templates or sending messages.
2019-03-19 16:25:44 +00:00
template = current_service.get_template_with_user_permission_or_403(template_id, current_user)
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
fix one more place where senders weren't sanitised make sure everything is using the `nl2br` formatter that properly wraps it in markdown to keep everything sanitised nicely. Also write a couple of tests
2020-01-22 16:13:25 +00:00
context['value_and_label'] = [(sender['id'], nl2br(sender[sender_format])) for sender in service_senders]
Allow letter templates to select the default contact block from the list
2018-01-03 10:44:36 +00:00
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
Reference in New Issue Copy Permalink