darkhelm/notifications-admin
1
0
Fork 0
mirror of https://github.com/GSA/notifications-admin.git synced 2026-08-24 16:24:08 -04:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #3251 from alphagov/job-model

Browse Source 
Make models for individual jobs and collections of jobs
This commit is contained in:
Chris Hill-Scott
2020-01-16 15:52:21 +00:00
committed by GitHub
parent 861a29ddd3 cbf0d905e3
commit 721134dc17
20 changed files with 385 additions and 304 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
app/main/views/dashboard.py
View File

@@ -20,12 +20,11 @@ from app import (
current_service,
format_date_numeric,
format_datetime_numeric,
job_api_client,
service_api_client,
template_statistics_client,
)
from app.main import main
from app.statistics_utils import add_rate_to_job, get_formatted_percentage
from app.statistics_utils import get_formatted_percentage
from app.utils import (
DELIVERED_STATUSES,
FAILURE_STATUSES,
@@ -281,14 +280,6 @@ def get_dashboard_partials(service_id):
all_statistics = template_statistics_client.get_template_statistics_for_service(service_id, limit_days=7)
template_statistics = aggregate_template_usage(all_statistics)
scheduled_jobs, immediate_jobs = [], []
if job_api_client.has_jobs(service_id):
scheduled_jobs = job_api_client.get_scheduled_jobs(service_id)
immediate_jobs = [
add_rate_to_job(job)
for job in job_api_client.get_immediate_jobs(service_id)
]
stats = aggregate_notifications_stats(all_statistics)
column_width, max_notifiction_count = get_column_properties(3)
@@ -310,7 +301,6 @@ def get_dashboard_partials(service_id):
return {
'upcoming': render_template(
'views/dashboard/_upcoming.html',
scheduled_jobs=scheduled_jobs
),
'inbox': render_template(
'views/dashboard/_inbox.html',
@@ -337,9 +327,8 @@ def get_dashboard_partials(service_id):
),
'jobs': render_template(
'views/dashboard/_jobs.html',
jobs=immediate_jobs
jobs=current_service.immediate_jobs,
),
'has_jobs': bool(immediate_jobs),
'usage': render_template(
'views/dashboard/_usage.html',
column_width=column_width,

158
app/main/views/jobs.py
View File

@@ -1,7 +1,5 @@
# -*- coding: utf-8 -*-
from datetime import datetime
from flask import (
Response,
abort,
@@ -15,24 +13,18 @@ from flask import (
)
from flask_login import current_user
from notifications_python_client.errors import HTTPError
from notifications_utils.letter_timings import (
CANCELLABLE_JOB_LETTER_STATUSES,
get_letter_timings,
letter_can_be_cancelled,
)
from notifications_utils.template import Template, WithSubjectTemplate
from app import (
current_service,
format_datetime_short,
format_thousands,
job_api_client,
notification_api_client,
service_api_client,
)
from app.main import main
from app.main.forms import SearchNotificationsForm
from app.statistics_utils import add_rate_to_job
from app.models.job import Job
from app.utils import (
generate_next_dict,
generate_notifications_csv,
@@ -50,31 +42,25 @@ from app.utils import (
@main.route("/services/<uuid:service_id>/jobs")
@user_has_permissions()
def view_jobs(service_id):
page = int(request.args.get('page', 1))
jobs_response = job_api_client.get_page_of_jobs(service_id, page=page)
jobs = [
add_rate_to_job(job) for job in jobs_response['data']
]
jobs = current_service.get_page_of_jobs(page=request.args.get('page'))
prev_page = None
if jobs_response['links'].get('prev', None):
prev_page = generate_previous_dict('main.view_jobs', service_id, page)
if jobs.prev_page:
prev_page = generate_previous_dict('main.view_jobs', service_id, jobs.current_page)
next_page = None
if jobs_response['links'].get('next', None):
next_page = generate_next_dict('main.view_jobs', service_id, page)
if jobs.next_page:
next_page = generate_next_dict('main.view_jobs', service_id, jobs.current_page)
scheduled_jobs = ''
if not current_user.has_permissions('view_activity') and page == 1:
if not current_user.has_permissions('view_activity') and jobs.current_page == 1:
scheduled_jobs = render_template(
'views/dashboard/_upcoming.html',
scheduled_jobs=job_api_client.get_scheduled_jobs(service_id),
hide_heading=True,
)
return render_template(
'views/jobs/jobs.html',
jobs=jobs,
page=page,
prev_page=prev_page,
next_page=next_page,
scheduled_jobs=scheduled_jobs,
@@ -84,61 +70,41 @@ def view_jobs(service_id):
@main.route("/services/<uuid:service_id>/jobs/<uuid:job_id>")
@user_has_permissions()
def view_job(service_id, job_id):
job = job_api_client.get_job(service_id, job_id)['data']
if job['job_status'] == 'cancelled':
job = Job.from_id(job_id, service_id=current_service.id)
if job.cancelled:
abort(404)
filter_args = parse_filter_args(request.args)
filter_args['status'] = set_status_filters(filter_args)
total_notifications = job.get('notification_count', 0)
processed_notifications = job.get('notifications_delivered', 0) + job.get('notifications_failed', 0)
template = service_api_client.get_service_template(
service_id=service_id,
template_id=job['template'],
version=job['template_version']
)['data']
just_sent_message = 'Your {} been sent. Printing starts {} at 5:30pm.'.format(
'letter has' if job['notification_count'] == 1 else 'letters have',
'letter has' if job.notification_count == 1 else 'letters have',
printing_today_or_tomorrow()
)
partials = get_job_partials(job, template)
can_cancel_letter_job = partials["can_letter_job_be_cancelled"]
return render_template(
'views/jobs/job.html',
finished=(total_notifications == processed_notifications),
uploaded_file_name=job['original_file_name'],
template_id=job['template'],
job_id=job_id,
job=job,
status=request.args.get('status', ''),
updates_url=url_for(
".view_job_updates",
service_id=service_id,
job_id=job['id'],
job_id=job.id,
status=request.args.get('status', ''),
),
partials=partials,
partials=get_job_partials(job),
just_sent=bool(
request.args.get('just_sent') == 'yes'
and template['template_type'] == 'letter'
and job.template_type == 'letter'
),
just_sent_message=just_sent_message,
can_cancel_letter_job=can_cancel_letter_job,
)
@main.route("/services/<uuid:service_id>/jobs/<uuid:job_id>.csv")
@user_has_permissions('view_activity')
def view_job_csv(service_id, job_id):
job = job_api_client.get_job(service_id, job_id)['data']
template = service_api_client.get_service_template(
service_id=service_id,
template_id=job['template'],
version=job['template_version']
)['data']
job = Job.from_id(job_id, service_id=service_id)
filter_args = parse_filter_args(request.args)
filter_args['status'] = set_status_filters(filter_args)
@@ -151,14 +117,14 @@ def view_job_csv(service_id, job_id):
page=request.args.get('page', 1),
page_size=5000,
format_for_csv=True,
template_type=template['template_type'],
template_type=job.template_type,
)
),
mimetype='text/csv',
headers={
'Content-Disposition': 'inline; filename="{} - {}.csv"'.format(
template['name'],
format_datetime_short(job['created_at'])
job.template['name'],
format_datetime_short(job.created_at)
)
}
)
@@ -167,7 +133,7 @@ def view_job_csv(service_id, job_id):
@main.route("/services/<uuid:service_id>/jobs/<uuid:job_id>", methods=['POST'])
@user_has_permissions('send_messages')
def cancel_job(service_id, job_id):
job_api_client.cancel_job(service_id, job_id)
Job.from_id(job_id, service_id=service_id).cancel()
return redirect(url_for('main.service_dashboard', service_id=service_id))
@@ -175,20 +141,18 @@ def cancel_job(service_id, job_id):
@user_has_permissions()
def cancel_letter_job(service_id, job_id):
if request.method == 'POST':
job = job_api_client.get_job(service_id, job_id)['data']
notification_count = notification_api_client.get_notification_count_for_job_id(
service_id=service_id, job_id=job_id
)
if job['job_status'] != 'finished' or notification_count < job['notification_count']:
job = Job.from_id(job_id, service_id=service_id)
if job.status != 'finished' or job.notifications_created < job.notification_count:
flash("We are still processing these letters, please try again in a minute.", 'try again')
return view_job(service_id, job_id)
try:
number_of_letters = job_api_client.cancel_letter_job(current_service.id, job_id)
number_of_letters = job.cancel()
except HTTPError as e:
flash(e.message, 'dangerous')
return redirect(url_for('main.view_job', service_id=service_id, job_id=job_id))
flash("Cancelled {} letters from {}".format(
format_thousands(number_of_letters), job['original_file_name']
format_thousands(number_of_letters), job.original_file_name
), 'default_with_tick')
return redirect(url_for('main.service_dashboard', service_id=service_id))
@@ -200,16 +164,9 @@ def cancel_letter_job(service_id, job_id):
@user_has_permissions()
def view_job_updates(service_id, job_id):
job = job_api_client.get_job(service_id, job_id)['data']
job = Job.from_id(job_id, service_id=service_id)
return jsonify(**get_job_partials(
job,
service_api_client.get_service_template(
service_id=current_service.id,
template_id=job['template'],
version=job['template_version']
)['data'],
))
return jsonify(**get_job_partials(job))
@main.route('/services/<uuid:service_id>/notifications', methods=['GET', 'POST'])
@@ -386,61 +343,46 @@ def get_status_filters(service, message_type, statistics):
def _get_job_counts(job):
sending = 0 if job['job_status'] == 'scheduled' else (
job.get('notification_count', 0) -
job.get('notifications_delivered', 0) -
job.get('notifications_failed', 0)
)
return [
(
label,
query_param,
url_for(
".view_job",
service_id=job['service'],
job_id=job['id'],
service_id=job.service,
job_id=job.id,
status=query_param,
),
count
) for label, query_param, count in [
[
'total', '',
job.get('notification_count', 0)
job.notification_count
],
[
'sending', 'sending',
sending
job.notifications_sending
],
[
'delivered', 'delivered',
job.get('notifications_delivered', 0)
job.notifications_delivered
],
[
'failed', 'failed',
job.get('notifications_failed', 0)
job.notifications_failed
]
]
]
def get_job_partials(job, template):
def get_job_partials(job):
filter_args = parse_filter_args(request.args)
filter_args['status'] = set_status_filters(filter_args)
notifications = notification_api_client.get_notifications_for_service(
job['service'], job['id'], status=filter_args['status']
)
if template['template_type'] == 'letter':
# there might be no notifications if the job has only just been created and the tasks haven't run yet
if notifications['notifications']:
postage = notifications['notifications'][0]['postage']
else:
postage = template['postage']
notifications = job.get_notifications(status=filter_args['status'])
if job.template_type == 'letter':
counts = render_template(
'partials/jobs/count-letters.html',
total=job.get('notification_count', 0),
delivery_estimate=get_letter_timings(job['created_at'], postage=postage).earliest_delivery,
job=job,
)
else:
counts = render_template(
@@ -448,22 +390,11 @@ def get_job_partials(job, template):
counts=_get_job_counts(job),
status=filter_args['status'],
notifications_deleted=(
job['job_status'] == 'finished' and not notifications['notifications']
job.status == 'finished' and not notifications['notifications']
),
)
service_data_retention_days = current_service.get_days_of_retention(template['template_type'])
can_letter_job_be_cancelled = False
if template["template_type"] == "letter":
not_cancellable = [
n for n in notifications["notifications"] if n["status"] not in CANCELLABLE_JOB_LETTER_STATUSES
]
job_created = job["created_at"][:-6]
if not letter_can_be_cancelled(
"created", datetime.strptime(job_created, '%Y-%m-%dT%H:%M:%S.%f')
) or len(not_cancellable) != 0:
can_letter_job_be_cancelled = False
else:
can_letter_job_be_cancelled = True
service_data_retention_days = current_service.get_days_of_retention(job.template_type)
return {
'counts': counts,
'notifications': render_template(
@@ -472,26 +403,21 @@ def get_job_partials(job, template):
add_preview_of_content_to_notifications(notifications['notifications'])
),
more_than_one_page=bool(notifications.get('links', {}).get('next')),
percentage_complete=(job['notifications_requested'] / job['notification_count'] * 100),
download_link=url_for(
'.view_job_csv',
service_id=current_service.id,
job_id=job['id'],
job_id=job.id,
status=request.args.get('status')
),
time_left=get_time_left(job['created_at'], service_data_retention_days=service_data_retention_days),
time_left=get_time_left(job.created_at, service_data_retention_days=service_data_retention_days),
job=job,
template=template,
template_version=job['template_version'],
service_data_retention_days=service_data_retention_days,
),
'status': render_template(
'partials/jobs/status.html',
job=job,
template_type=template["template_type"],
letter_print_day=get_letter_printing_statement("created", job["created_at"])
letter_print_day=get_letter_printing_statement("created", job.created_at)
),
'can_letter_job_be_cancelled': can_letter_job_be_cancelled,
}

21
app/main/views/uploads.py
View File

@@ -16,12 +16,7 @@ from notifications_utils.pdf import pdf_page_count
from PyPDF2.utils import PdfReadError
from requests import RequestException
from app import (
current_service,
job_api_client,
notification_api_client,
service_api_client,
)
from app import current_service, notification_api_client, service_api_client
from app.extensions import antivirus_client
from app.main import main
from app.main.forms import LetterUploadPostageForm, PDFUploadForm
@@ -48,20 +43,18 @@ MAX_FILE_UPLOAD_SIZE = 2 * 1024 * 1024 # 2MB
def uploads(service_id):
# No tests have been written, this has been quickly prepared for user research.
# It's also very like that a new view will be created to show uploads.
page = int(request.args.get('page', 1))
uploads_response = job_api_client.get_uploads(service_id, page=page)
uploads = current_service.get_page_of_uploads(page=request.args.get('page'))
prev_page = None
if uploads_response['links'].get('prev', None):
prev_page = generate_previous_dict('main.uploads', service_id, page)
if uploads.next_page:
prev_page = generate_previous_dict('main.uploads', service_id, uploads.current_page)
next_page = None
if uploads_response['links'].get('next', None):
next_page = generate_next_dict('main.uploads', service_id, page)
if uploads.prev_page:
next_page = generate_next_dict('main.uploads', service_id, uploads.current_page)
return render_template(
'views/jobs/jobs.html',
jobs=uploads_response['data'],
page=page,
jobs=uploads,
prev_page=prev_page,
next_page=next_page,
scheduled_jobs='',

206
app/models/job.py Normal file
View File

@@ -0,0 +1,206 @@
from datetime import datetime
from notifications_utils.letter_timings import (
CANCELLABLE_JOB_LETTER_STATUSES,
get_letter_timings,
letter_can_be_cancelled,
)
from werkzeug.utils import cached_property
from app.models import JSONModel, ModelList
from app.notify_client.job_api_client import job_api_client
from app.notify_client.notification_api_client import notification_api_client
from app.notify_client.service_api_client import service_api_client
from app.utils import set_status_filters
class Job(JSONModel):
ALLOWED_PROPERTIES = {
'id',
'service',
'template',
'template_version',
'original_file_name',
'created_at',
'notification_count',
'job_status',
'created_by',
'scheduled_for',
}
@classmethod
def from_id(cls, job_id, service_id):
return cls(job_api_client.get_job(service_id, job_id)['data'])
@property
def status(self):
return self.job_status
@property
def cancelled(self):
return self.status == 'cancelled'
@property
def scheduled(self):
return self.status == 'scheduled'
def _aggregate_statistics(self, *statuses):
return sum(
outcome['count'] for outcome in self._dict['statistics']
if not statuses or outcome['status'] in statuses
)
@property
def notifications_delivered(self):
return self._aggregate_statistics('delivered', 'sent')
@property
def notifications_failed(self):
return self._aggregate_statistics(
'failed', 'technical-failure', 'temporary-failure',
'permanent-failure', 'cancelled',
)
@property
def notifications_requested(self):
return self._aggregate_statistics()
@property
def notifications_sent(self):
return self.notifications_delivered + self.notifications_failed
@property
def notifications_sending(self):
if self.scheduled:
return 0
return self.notification_count - self.notifications_sent
@property
def notifications_created(self):
return notification_api_client.get_notification_count_for_job_id(
service_id=self.service, job_id=self.id
)
@property
def still_processing(self):
return (
self.percentage_complete < 100 and self.status != 'finished'
)
@cached_property
def finished_processing(self):
return self.notification_count == self.notifications_sent
@property
def template_id(self):
return self._dict['template']
@cached_property
def template(self):
return service_api_client.get_service_template(
service_id=self.service,
template_id=self.template_id,
version=self.template_version,
)['data']
@property
def template_type(self):
return self.template['template_type']
@property
def percentage_complete(self):
return self.notifications_requested / self.notification_count * 100
@property
def letter_job_can_be_cancelled(self):
if self.template['template_type'] != 'letter':
return False
if any(self.uncancellable_notifications):
return False
if not letter_can_be_cancelled(
'created', datetime.strptime(self.created_at[:-6], '%Y-%m-%dT%H:%M:%S.%f')
):
return False
return True
@cached_property
def all_notifications(self):
return self.get_notifications(set_status_filters({}))['notifications']
@property
def uncancellable_notifications(self):
return (
n for n in self.all_notifications
if n['status'] not in CANCELLABLE_JOB_LETTER_STATUSES
)
@cached_property
def postage(self):
# There might be no notifications if the job has only just been
# created and the tasks haven't run yet
try:
return self.all_notifications[0]['postage']
except IndexError:
return self.template['postage']
@property
def letter_timings(self):
return get_letter_timings(self.created_at, postage=self.postage)
@property
def failure_rate(self):
if not self.notifications_delivered:
return 100 if self.notifications_failed else 0
return (
self.notifications_failed / (
self.notifications_failed + self.notifications_delivered
) * 100
)
@property
def high_failure_rate(self):
return self.failure_rate > 30
def get_notifications(self, status):
return notification_api_client.get_notifications_for_service(
self.service, self.id, status=status,
)
def cancel(self):
if self.template_type == 'letter':
return job_api_client.cancel_letter_job(self.service, self.id)
else:
return job_api_client.cancel_job(self.service, self.id)
class ImmediateJobs(ModelList):
client = job_api_client.get_immediate_jobs
model = Job
class ScheduledJobs(ImmediateJobs):
client = job_api_client.get_scheduled_jobs
class PaginatedJobs(ImmediateJobs):
client = job_api_client.get_page_of_jobs
def __init__(self, service_id, page=None):
try:
self.current_page = int(page)
except TypeError:
self.current_page = 1
response = self.client(service_id, page=self.current_page)
self.items = response['data']
self.prev_page = response.get('links', {}).get('prev', None)
self.next_page = response.get('links', {}).get('next', None)
class PaginatedUploads(PaginatedJobs):
client = job_api_client.get_uploads

24
app/models/service.py
View File

@@ -5,6 +5,12 @@ from notifications_utils.take import Take
from werkzeug.utils import cached_property
from app.models import JSONModel
from app.models.job import (
ImmediateJobs,
PaginatedJobs,
PaginatedUploads,
ScheduledJobs,
)
from app.models.organisation import Organisation
from app.models.user import InvitedUsers, User, Users
from app.notify_client.api_key_api_client import api_key_api_client
@@ -103,10 +109,28 @@ class Service(JSONModel):
def has_permission(self, permission):
return permission in self.permissions
def get_page_of_jobs(self, page):
return PaginatedJobs(self.id, page=page)
def get_page_of_uploads(self, page):
return PaginatedUploads(self.id, page=page)
@cached_property
def has_jobs(self):
return job_api_client.has_jobs(self.id)
@cached_property
def immediate_jobs(self):
if not self.has_jobs:
return []
return ImmediateJobs(self.id)
@cached_property
def scheduled_jobs(self):
if not self.has_jobs:
return []
return ScheduledJobs(self.id)
@cached_property
def invited_users(self):
return InvitedUsers(self.id)

58
app/notify_client/job_api_client.py
View File

@@ -1,5 +1,3 @@
from collections import defaultdict
from app.extensions import redis_client
from app.notify_client import NotifyAdminAPIClient, _attach_current_user, cache
@@ -19,28 +17,9 @@ class JobApiClient(NotifyAdminAPIClient):
NON_SCHEDULED_JOB_STATUSES = JOB_STATUSES - {'scheduled', 'cancelled'}
@staticmethod
def __convert_statistics(job):
results = defaultdict(int)
for outcome in job['statistics']:
if outcome['status'] in ['failed', 'technical-failure', 'temporary-failure',
'permanent-failure', 'cancelled']:
results['failed'] += outcome['count']
if outcome['status'] in ['sending', 'pending', 'created']:
results['sending'] += outcome['count']
if outcome['status'] in ['delivered', 'sent']:
results['delivered'] += outcome['count']
results['requested'] += outcome['count']
return results
def get_job(self, service_id, job_id):
params = {}
job = self.get(url='/service/{}/job/{}'.format(service_id, job_id), params=params)
stats = self.__convert_statistics(job['data'])
job['data']['notifications_sent'] = stats['delivered'] + stats['failed']
job['data']['notifications_delivered'] = stats['delivered']
job['data']['notifications_failed'] = stats['failed']
job['data']['notifications_requested'] = stats['requested']
return job
@@ -51,29 +30,13 @@ class JobApiClient(NotifyAdminAPIClient):
if statuses is not None:
params['statuses'] = ','.join(statuses)
jobs = self.get(url='/service/{}/job'.format(service_id), params=params)
for job in jobs['data']:
stats = self.__convert_statistics(job)
job['notifications_sent'] = stats['delivered'] + stats['failed']
job['notifications_delivered'] = stats['delivered']
job['notifications_failed'] = stats['failed']
job['notifications_requested'] = stats['requested']
return jobs
return self.get(url='/service/{}/job'.format(service_id), params=params)
def get_uploads(self, service_id, limit_days=None, page=1):
params = {'page': page}
if limit_days is not None:
params['limit_days'] = limit_days
uploads = self.get(url='/service/{}/upload'.format(service_id), params=params)
for upload in uploads['data']:
stats = self.__convert_statistics(upload)
upload['notifications_sent'] = stats['delivered'] + stats['failed']
upload['notifications_delivered'] = stats['delivered']
upload['notifications_failed'] = stats['failed']
upload['notifications_requested'] = stats['requested']
return uploads
return self.get(url='/service/{}/upload'.format(service_id), params=params)
def has_sent_previously(self, service_id, template_id, template_version, original_file_name):
return (
@@ -125,30 +88,15 @@ class JobApiClient(NotifyAdminAPIClient):
ex=cache.TTL,
)
stats = self.__convert_statistics(job['data'])
job['data']['notifications_sent'] = stats['delivered'] + stats['failed']
job['data']['notifications_delivered'] = stats['delivered']
job['data']['notifications_failed'] = stats['failed']
job['data']['notifications_requested'] = stats['requested']
return job
@cache.delete('has_jobs-{service_id}')
def cancel_job(self, service_id, job_id):
job = self.post(
return self.post(
url='/service/{}/job/{}/cancel'.format(service_id, job_id),
data={}
)
stats = self.__convert_statistics(job['data'])
job['data']['notifications_sent'] = stats['delivered'] + stats['failed']
job['data']['notifications_delivered'] = stats['delivered']
job['data']['notifications_failed'] = stats['failed']
job['data']['notifications_requested'] = stats['requested']
return job
@cache.delete('has_jobs-{service_id}')
def cancel_letter_job(self, service_id, job_id):
return self.post(

16
app/statistics_utils.py
View File

@@ -78,19 +78,3 @@ def statistics_by_state(statistics):
'failed': statistics['emails_failed']
}
}
def get_failure_rate_for_job(job):
if not job.get('notifications_delivered'):
return 1 if job.get('notifications_failed') else 0
return (
job.get('notifications_failed', 0) /
(job.get('notifications_failed', 0) + job.get('notifications_delivered', 0))
)
def add_rate_to_job(job):
return dict(
failure_rate=(get_failure_rate_for_job(job)) * 100,
**job
)

6
app/templates/partials/jobs/count-letters.html
View File

@@ -5,8 +5,8 @@
<div class="column-half">
<div class="keyline-block">
{{ big_number(
total,
message_count_label(total, 'letter', suffix='')|capitalize,
job.notification_count,
message_count_label(job.notification_count, 'letter', suffix='')|capitalize,
smaller=True
)}}
</div>
@@ -14,7 +14,7 @@
<div class="column-half">
<div class="keyline-block">
{{ big_number(
delivery_estimate|string|format_date_short,
job.letter_timings.earliest_delivery|string|format_date_short,
'Estimated delivery date',
smaller=True
)}}

12
app/templates/partials/jobs/notifications.html
View File

@@ -3,11 +3,11 @@
{% from "components/form.html" import form_wrapper %}
<div class="ajax-block-container" aria-labelledby='pill-selected-item'>
{% if job.job_status == 'scheduled' %}
{% if job.scheduled %}
<p>
Sending
<a href="{{ url_for('.view_template_version', service_id=current_service.id, template_id=template.id, version=template_version) }}">{{ template.name }}</a>
<a href="{{ url_for('.view_template_version', service_id=current_service.id, template_id=job.template.id, version=job.template_version) }}">{{ job.template.name }}</a>
{{ job.scheduled_for|format_datetime_relative }}
</p>
<div class="page-footer">
@@ -28,12 +28,12 @@
{% if template.template_type == 'letter' %}
<div class="keyline-block bottom-gutter-1-2">
{% endif %}
{% if percentage_complete < 100 and job.job_status != 'finished' %}
<p class="{% if template.template_type != 'letter' %}bottom-gutter{% endif %} hint">
Report is {{ "{:.0f}%".format(percentage_complete * 0.99) }} complete…
{% if job.still_processing %}
<p class="{% if job.template.template_type != 'letter' %}bottom-gutter{% endif %} hint">
Report is {{ "{:.0f}%".format(job.percentage_complete * 0.99) }} complete…
</p>
{% elif notifications %}
<p class="{% if template.template_type != 'letter' %}bottom-gutter{% endif %}">
<p class="{% if job.template.template_type != 'letter' %}bottom-gutter{% endif %}">
<a href="{{ download_link }}" download class="heading-small">Download this report</a>
&emsp;
<span id="time-left">{{ time_left }}</span>

4
app/templates/partials/jobs/status.html
View File

@@ -3,7 +3,7 @@
{% if job.scheduled_for %}
{% if job.processing_started %}
Sent by {{ job.created_by.name }} on {{ job.processing_started|format_datetime_short }}
{% if template_type == "letter" %}
{% if job.template.template_type == "letter" %}
<p id="printing-info">
{{ letter_print_day }}
</p>
@@ -13,7 +13,7 @@
{% endif %}
{% else %}
Sent by {{ job.created_by.name }} on {{ job.created_at|format_datetime_short }}
{% if template_type == "letter" %}
{% if job.template.template_type == "letter" %}
<p id="printing-info">
{{ letter_print_day }}
</p>

10
app/templates/views/dashboard/_jobs.html
View File

@@ -26,22 +26,22 @@
{% endif %}
<span class="file-list-hint">
Sent {{
(item.scheduled_for if item.scheduled_for else item.created_at)|format_datetime_relative
(item.scheduled_for or item.created_at)|format_datetime_relative
}}
</span>
</div>
{% endcall %}
{% call field() %}
{{ big_number(
item.get('notification_count', 0) - item.get('notifications_delivered', 0) - item.get('notifications_failed', 0),
item.notifications_sending,
smallest=True
) }}
{% endcall %}
{% call field() %}
{{ big_number(item.get('notifications_delivered', 0), smallest=True) }}
{{ big_number(item.notifications_delivered, smallest=True) }}
{% endcall %}
{% call field(status='error' if item.get('failure_rate', 0) > 3 else '') %}
{{ big_number(item.get('notifications_failed', 0), smallest=True) }}
{% call field(status='error' if item.high_failure_rate else '') %}
{{ big_number(item.notifications_failed, smallest=True) }}
{% endcall %}
{% endcall %}
</div>

4
app/templates/views/dashboard/_upcoming.html
View File

@@ -3,7 +3,7 @@
{% from "components/show-more.html" import show_more %}
<div class="ajax-block-container">
{% if scheduled_jobs %}
{% if current_service.scheduled_jobs %}
<div class='dashboard-table'>
{% if not hide_heading %}
<h2 class="heading-medium heading-upcoming-jobs">
@@ -11,7 +11,7 @@
</h2>
{% endif %}
{% call(item, row_number) list_table(
scheduled_jobs,
current_service.scheduled_jobs,
caption="In the next few days",
caption_visible=False,
empty_message='Nothing to see here',

2
app/templates/views/dashboard/dashboard.html
View File

@@ -35,7 +35,7 @@
{{ ajax_block(partials, updates_url, 'template-statistics', interval=5) }}
{% if partials['has_jobs'] %}
{% if current_service.immediate_jobs %}
{{ ajax_block(partials, updates_url, 'jobs', interval=5) }}
{{ show_more(
url_for('.view_jobs', service_id=current_service.id),

14
app/templates/views/jobs/job.html
View File

@@ -4,28 +4,28 @@
{% from "components/page-footer.html" import page_footer %}
{% block service_page_title %}
{{ uploaded_file_name }}
{{ job.original_file_name }}
{% endblock %}
{% block maincolumn_content %}
<h1 class="heading-large">
{{ uploaded_file_name }}
{{ job.original_file_name }}
</h1>
{% if just_sent %}
{{ banner(just_sent_message, type='default', with_tick=True) }}
{% else %}
{{ ajax_block(partials, updates_url, 'status', finished=finished) }}
{{ ajax_block(partials, updates_url, 'status', finished=job.processing_finished) }}
{% endif %}
{{ ajax_block(partials, updates_url, 'counts', finished=finished) }}
{{ ajax_block(partials, updates_url, 'notifications', finished=finished) }}
{{ ajax_block(partials, updates_url, 'counts', finished=job.processing_finished) }}
{{ ajax_block(partials, updates_url, 'notifications', finished=job.processing_finished) }}
{% if can_cancel_letter_job %}
{% if job.letter_job_can_be_cancelled %}
<div class="js-stick-at-bottom-when-scrolling">
<div class="page-footer">
<span class="page-footer-delete-link page-footer-delete-link-without-button">
<a href="{{ url_for('main.cancel_letter_job', service_id=current_service.id, job_id=job_id) }}">Cancel sending these letters</a>
<a href="{{ url_for('main.cancel_letter_job', service_id=current_service.id, job_id=job.id) }}">Cancel sending these letters</a>
</span>
{% else %}
<div>&nbsp;</div>