Merge branch 'master' of github.com:alphagov/notifications-admin

app/main/forms.py

@@ -164,13 +164,13 @@ class AddServiceForm(Form):
     name = StringField(
         'Service name',
         validators=[
-            DataRequired(message='Service name can not be empty')
+            DataRequired(message='Service name can’t be empty')
         ]
     )
 
     def validate_name(self, a):
         if a.data in self._names_func():
-            raise ValidationError('Service name already exists')
+            raise ValidationError('This service name is already in use')
 
 
 class ServiceNameForm(Form):

app/main/views/add_service.py

@@ -11,39 +11,15 @@ from app.main.forms import AddServiceForm
 @login_required
 def add_service():
     form = AddServiceForm(services_dao.find_all_service_names)
-    services = services_dao.get_services(current_user.id)
-    if len(services['data']) == 0:
-        heading = 'Which service do you want to set up notifications for?'
-    else:
-        heading = 'Add a new service'
+    heading = 'Which service do you want to set up notifications for?'
     if form.validate_on_submit():
         session['service_name'] = form.name.data
-        return redirect(url_for('main.add_from_address'))
+        user = users_dao.get_user_by_id(session['user_id'])
+        service_id = services_dao.insert_new_service(session['service_name'], user.id)
+        return redirect(url_for('main.service_dashboard', service_id=service_id))
     else:
         return render_template(
             'views/add-service.html',
             form=form,
             heading=heading
         )
-
-
-@main.route("/confirm-add-service", methods=['GET', 'POST'])
-@login_required
-def add_from_address():
-    if request.method == 'POST':
-        user = users_dao.get_user_by_id(session['user_id'])
-        service_id = services_dao.insert_new_service(session['service_name'], user.id)
-        return redirect(url_for('main.service_dashboard', service_id=service_id))
-    else:
-        return render_template(
-            'views/add-from-address.html',
-            service_name=session['service_name'],
-            from_address="{}@notifications.service.gov.uk".format(_email_safe(session['service_name']))
-        )
-
-
-def _email_safe(string):
-    return "".join([
-        character.lower() if character.isalnum() or character == "." else ""
-        for character in re.sub("\s+", ".", string.strip())
-    ])

app/main/views/api_keys.py

@@ -3,6 +3,7 @@ from flask_login import login_required
 from app.main import main
 from app.main.forms import CreateKeyForm
 from app import api_key_api_client
+from app.utils import user_has_permissions
 
 
 @main.route("/services/<service_id>/documentation")
@@ -13,6 +14,7 @@ def documentation(service_id):
 
 @main.route("/services/<service_id>/api-keys")
 @login_required
+@user_has_permissions('manage_api_keys')
 def api_keys(service_id):
     return render_template(
         'views/api-keys.html',
@@ -23,6 +25,7 @@ def api_keys(service_id):
 
 @main.route("/services/<service_id>/api-keys/create", methods=['GET', 'POST'])
 @login_required
+@user_has_permissions('manage_api_keys')
 def create_api_key(service_id):
     key_names = [
         key['name'] for key in api_key_api_client.get_api_keys(service_id=service_id)['apiKeys']
@@ -41,6 +44,7 @@ def create_api_key(service_id):
 
 @main.route("/services/<service_id>/api-keys/revoke/<int:key_id>", methods=['GET', 'POST'])
 @login_required
+@user_has_permissions('manage_api_keys')
 def revoke_api_key(service_id, key_id):
     key_name = api_key_api_client.get_api_keys(service_id=service_id, key_id=key_id)['apiKeys'][0]['name']
     if request.method == 'GET':

app/main/views/dashboard.py

@@ -23,6 +23,7 @@ def service_dashboard(service_id):
     try:
         service = get_service_by_id(service_id)
         session['service_name'] = service['data']['name']
+        session['service_id'] = service['data']['id']
     except HTTPError as e:
         if e.status_code == 404:
             abort(404)

app/main/views/jobs.py

@@ -13,6 +13,7 @@ from notification_utils.template import Template
 from app import job_api_client
 from app.main import main
 from app.main.dao import templates_dao
+from app.main.dao import services_dao
 
 now = time.strftime('%H:%M')
 
@@ -37,6 +38,7 @@ def view_jobs(service_id):
 @main.route("/services/<service_id>/jobs/<job_id>")
 @login_required
 def view_job(service_id, job_id):
+    service = services_dao.get_service_by_id_or_404(service_id)
     try:
         job = job_api_client.get_job(service_id, job_id)['data']
         messages = []
@@ -56,9 +58,11 @@ def view_job(service_id, job_id):
             uploaded_file_name=job['original_file_name'],
             uploaded_file_time=job['created_at'],
             template=Template(
-                templates_dao.get_service_template_or_404(service_id, job['template'])['data']
+                templates_dao.get_service_template_or_404(service_id, job['template'])['data'],
+                prefix=service['name']
             ),
-            service_id=service_id
+            service_id=service_id,
+            service=service
         )
     except HTTPError as e:
         if e.status_code == 404:

app/main/views/manage_users.py

@@ -7,13 +7,18 @@ from flask import (
     flash
 )
 
-from flask_login import login_required, current_user
+from flask_login import (
+    login_required,
+    current_user
+)
+
+from notifications_python_client.errors import HTTPError
 
 from app.main import main
-from app.main.dao import users_dao
 from app.main.forms import InviteUserForm
 from app.main.dao.services_dao import get_service_by_id_or_404
 from app import user_api_client
+from app import invite_api_client
 
 fake_users = [
     {
@@ -29,14 +34,19 @@ fake_users = [
 @main.route("/services/<service_id>/users")
 @login_required
 def manage_users(service_id):
-    users = user_api_client.get_users_for_service(service_id=service_id)
-    return render_template(
-        'views/manage-users.html',
-        service_id=service_id,
-        users=users,
-        current_user=current_user,
-        invited_users=[]
-    )
+    try:
+        users = user_api_client.get_users_for_service(service_id=service_id)
+        invited_users = invite_api_client.get_invites_for_service(service_id=service_id)
+        return render_template('views/manage-users.html',
+                               service_id=service_id,
+                               users=users,
+                               current_user=current_user,
+                               invited_users=invited_users)
+    except HTTPError as e:
+        if e.status_code == 404:
+            abort(404)
+        else:
+            raise e
 
 
 @main.route("/services/<service_id>/users/invite", methods=['GET', 'POST'])
@@ -44,10 +54,19 @@ def manage_users(service_id):
 def invite_user(service_id):
 
     form = InviteUserForm()
-
     if form.validate_on_submit():
-        flash('Invite sent to {}'.format(form.email_address.data), 'default_with_tick')
-        return redirect(url_for('.manage_users', service_id=service_id))
+        email_address = form.email_address.data
+        permissions = _get_permissions(request.form)
+        try:
+            resp = invite_api_client.create_invite(current_user.id, service_id, email_address, permissions)
+            flash('Invite sent to {}'.format(resp['email_address']), 'default_with_tick')
+            return redirect(url_for('.manage_users', service_id=service_id))
+
+        except HTTPError as e:
+            if e.status_code == 404:
+                abort(404)
+            else:
+                raise e
 
     return render_template(
         'views/invite-user.html',
@@ -95,3 +114,14 @@ def delete_user(service_id, user_id):
         service=get_service_by_id_or_404(service_id),
         service_id=service_id
     )
+
+
+def _get_permissions(form):
+    permissions = []
+    if form.get('send_messages') and form['send_messages'] == 'yes':
+        permissions.append('send_messages')
+    if form.get('manage_service') and form['manage_service'] == 'yes':
+        permissions.append('manage_service')
+    if form.get('manage_api_keys') and form['manage_api_keys'] == 'yes':
+        permissions.append('manage_api_keys')
+    return ','.join(permissions)

app/main/views/send.py

@@ -1,9 +1,6 @@
 import csv
 import io
 import uuid
-import botocore
-
-from datetime import date
 
 from flask import (
     request,
@@ -17,7 +14,6 @@ from flask import (
 )
 
 from flask_login import login_required, current_user
-from werkzeug import secure_filename
 from notifications_python_client.errors import HTTPError
 from utils.template import Template, NeededByTemplateError, NoPlaceholderForDataError
 
@@ -32,16 +28,23 @@ from app.main.dao import services_dao
 from app import job_api_client
 from app.utils import validate_recipient, InvalidPhoneError, InvalidEmailError
 
-first_column_header = {
-    'email': 'email',
-    'sms': 'phone'
+page_headings = {
+    'email': 'Send emails',
+    'sms': 'Send text messages'
 }
 
 
+@main.route("/services/<service_id>/send/letters", methods=['GET'])
+def letters_stub(service_id):
+    return render_template(
+        'views/letters.html', service_id=service_id
+    )
+
+
 @main.route("/services/<service_id>/send/<template_type>", methods=['GET'])
 def choose_template(service_id, template_type):
 
-    services_dao.get_service_by_id_or_404(service_id)
+    service = services_dao.get_service_by_id_or_404(service_id)
 
     if template_type not in ['email', 'sms']:
         abort(404)
@@ -53,11 +56,17 @@ def choose_template(service_id, template_type):
         else:
             raise e
     return render_template(
-        'views/choose-{}-template.html'.format(template_type),
+        'views/choose-template.html',
         templates=[
-            Template(template) for template in templates_dao.get_service_templates(service_id)['data']
+            Template(
+                template,
+                prefix=service['name']
+            ) for template in templates_dao.get_service_templates(service_id)['data']
             if template['template_type'] == template_type
         ],
+        template_type=template_type,
+        page_heading=page_headings[template_type],
+        service=service,
         has_jobs=len(jobs),
         service_id=service_id
     )
@@ -70,7 +79,7 @@ def send_messages(service_id, template_id):
     form = CsvUploadForm()
     if form.validate_on_submit():
         try:
-            csv_file = form.file.data
+            csv_file = form.file
             filedata = _get_filedata(csv_file)
             upload_id = str(uuid.uuid4())
             s3upload(upload_id, service_id, filedata, current_app.config['AWS_REGION'])
@@ -79,19 +88,20 @@ def send_messages(service_id, template_id):
                                     service_id=service_id,
                                     upload_id=upload_id))
         except ValueError as e:
-            flash('There was a problem uploading: {}'.format(csv_file.filename))
+            flash('There was a problem uploading: {}'.format(csv_file.data.filename))
             flash(str(e))
             return redirect(url_for('.send_messages', service_id=service_id, template_id=template_id))
 
     service = services_dao.get_service_by_id_or_404(service_id)
     template = Template(
-        templates_dao.get_service_template_or_404(service_id, template_id)['data']
+        templates_dao.get_service_template_or_404(service_id, template_id)['data'],
+        prefix=service['name']
     )
 
     return render_template(
         'views/send.html',
         template=template,
-        column_headers=[first_column_header[template.template_type]] + template.placeholders_as_markup,
+        column_headers=['to'] + template.placeholders_as_markup,
         form=form,
         service=service,
         service_id=service_id
@@ -105,10 +115,14 @@ def get_example_csv(service_id, template_id):
     placeholders = list(Template(template).placeholders)
     output = io.StringIO()
     writer = csv.writer(output)
-    writer.writerow([first_column_header[template['template_type']]] + placeholders)
-    writer.writerow([current_user.mobile_number] + ["test {}".format(header) for header in placeholders])
-
-    return(output.getvalue(), 200, {'Content-Type': 'text/csv; charset=utf-8'})
+    writer.writerow(['to'] + placeholders)
+    writer.writerow([
+        {
+            'email': current_user.email_address,
+            'sms': current_user.mobile_number
+        }[template['template_type']]
+    ] + ["test {}".format(header) for header in placeholders])
+    return output.getvalue(), 200, {'Content-Type': 'text/csv; charset=utf-8'}
 
 
 @main.route("/services/<service_id>/send/<template_id>/to-self", methods=['GET'])
@@ -118,7 +132,7 @@ def send_message_to_self(service_id, template_id):
     placeholders = list(Template(template).placeholders)
     output = io.StringIO()
     writer = csv.writer(output)
-    writer.writerow([first_column_header[template['template_type']]] + placeholders)
+    writer.writerow(['to'] + placeholders)
     writer.writerow([current_user.mobile_number] + ["test {}".format(header) for header in placeholders])
     filedata = {
         'file_name': 'Test run',
@@ -140,29 +154,30 @@ def check_messages(service_id, upload_id):
 
     upload_data = session['upload_data']
     template_id = upload_data.get('template_id')
+    service = services_dao.get_service_by_id_or_404(service_id)
 
     if request.method == 'GET':
         contents = s3download(service_id, upload_id)
         if not contents:
             flash('There was a problem reading your upload file')
         raw_template = templates_dao.get_service_template_or_404(service_id, template_id)['data']
-        recipient_type = first_column_header[raw_template['template_type']]
         upload_result = _get_rows(contents, raw_template)
         session['upload_data']['notification_count'] = len(upload_result['rows'])
         template = Template(
             raw_template,
             values=upload_result['rows'][0] if upload_result['valid'] else {},
-            drop_values={recipient_type}
+            drop_values={'to'},
+            prefix=service['name']
         )
         return render_template(
-            'views/check-sms.html',
+            'views/check.html',
             upload_result=upload_result,
             template=template,
-            column_headers=[recipient_type] + list(
-                template.placeholders if upload_result['valid'] else template.placeholders_as_markup
-            ),
+            page_heading=page_headings[template.template_type],
+            column_headers=['to'] + list(template.placeholders_as_markup),
             original_file_name=upload_data.get('original_file_name'),
             service_id=service_id,
+            service=service,
             form=CsvUploadForm()
         )
     elif request.method == 'POST':
@@ -184,17 +199,34 @@ def check_messages(service_id, upload_id):
 
 
 def _get_filedata(file):
-    lines = file.read().decode('utf-8').splitlines()
-    if len(lines) < 2:  # must be at least header and one line
-        message = 'The file {} contained no data'.format(file.filename)
+    import itertools
+    reader = csv.reader(
+        file.data.getvalue().decode('utf-8').splitlines(),
+        quoting=csv.QUOTE_NONE,
+        skipinitialspace=True
+    )
+    lines = []
+    for row in reader:
+        non_empties = itertools.dropwhile(lambda x: x.strip() == '', row)
+        has_content = []
+        for item in non_empties:
+            has_content.append(item)
+        if has_content:
+            lines.append(row)
+
+    if len(lines) < 2:  # must be header row and at least one data row
+        message = 'The file {} contained no data'.format(file.data.filename)
         raise ValueError(message)
-    return {'file_name': file.filename, 'data': lines}
+
+    content_lines = []
+    for row in lines:
+        content_lines.append(','.join(row).rstrip(','))
+    return {'file_name': file.data.filename, 'data': content_lines}
 
 
 def _get_rows(contents, raw_template):
     reader = csv.DictReader(
         contents.split('\n'),
-        lineterminator='\n',
         quoting=csv.QUOTE_NONE,
         skipinitialspace=True
     )
@@ -203,12 +235,11 @@ def _get_rows(contents, raw_template):
     for row in reader:
         rows.append(row)
         try:
-            recipient_column = first_column_header[raw_template['template_type']]
             validate_recipient(
-                row[recipient_column],
+                row.get('to', ''),
                 template_type=raw_template['template_type']
             )
-            Template(raw_template, values=row, drop_values={recipient_column}).replaced
+            Template(raw_template, values=row, drop_values={'to'}).replaced
         except (InvalidEmailError, InvalidPhoneError, NeededByTemplateError, NoPlaceholderForDataError):
             valid = False
     return {"valid": valid, "rows": rows}