From 6fda3707a39089517981effbd2306b740fcf6f02 Mon Sep 17 00:00:00 2001 From: Leo Hemsted Date: Tue, 4 Aug 2020 19:00:10 +0100 Subject: [PATCH] save broadcast events when sending a message, also send cancel messages --- app/broadcast_message/rest.py | 50 +++++++++++++++++++++--- app/models.py | 16 +++++--- tests/app/broadcast_message/test_rest.py | 26 ++++++++++-- 3 files changed, 77 insertions(+), 15 deletions(-) diff --git a/app/broadcast_message/rest.py b/app/broadcast_message/rest.py index c3fe0d3b9..ab9f4f292 100644 --- a/app/broadcast_message/rest.py +++ b/app/broadcast_message/rest.py @@ -13,7 +13,7 @@ from app.dao.broadcast_message_dao import ( ) from app.dao.services_dao import dao_fetch_service_by_id from app.errors import register_errors, InvalidRequest -from app.models import BroadcastMessage, BroadcastStatusType +from app.models import BroadcastMessage, BroadcastStatusType, BroadcastEvent, BroadcastEventMessageType from app.celery.broadcast_message_tasks import send_broadcast_message from app.broadcast_message.broadcast_message_schema import ( create_broadcast_message_schema, @@ -155,10 +155,48 @@ def update_broadcast_message_status(service_id, broadcast_message_id): _update_broadcast_message(broadcast_message, new_status, updating_user) dao_update_broadcast_message(broadcast_message) - if new_status == BroadcastStatusType.BROADCASTING: - send_broadcast_message.apply_async( - kwargs={'broadcast_message_id': str(broadcast_message.id)}, - queue=QueueNames.NOTIFY - ) + if new_status in {BroadcastStatusType.BROADCASTING, BroadcastStatusType.CANCELLED}: + _create_broadcast_event(broadcast_message) return jsonify(broadcast_message.serialize()), 200 + + +def _create_broadcast_event(broadcast_message): + """ + Creates a broadcast event, stores it in the database, and triggers the task to send the CAP XML off + """ + msg_types = { + BroadcastStatusType.BROADCASTING: BroadcastEventMessageType.ALERT, + BroadcastStatusType.CANCELLED: BroadcastEventMessageType.CANCEL, + } + + if broadcast_message.status == BroadcastStatusType.CANCELLED: + transmitted_finishes_at = broadcast_message.cancelled_at + else: + transmitted_finishes_at = broadcast_message.finishes_at + + # TODO: This doesn't support placeholders yet. We shouldn't use BroadcastMessageTemplate when we add placeholders + # as that just outputs XML, we need the raw text. + event = BroadcastEvent( + service=broadcast_message.service, + broadcast_message=broadcast_message, + message_type=msg_types[broadcast_message.status], + transmitted_content={"body": broadcast_message.template.content}, + transmitted_areas=broadcast_message.areas, + # TODO: Probably move this somewhere more standalone too and imply that it shouldn't change. Should it include + # a service based identifier too? eg "flood-warnings@notifications.service.gov.uk" or similar + transmitted_sender='notifications.service.gov.uk', + + # TODO: Should this be set to now? Or the original starts_at? + transmitted_starts_at=broadcast_message.starts_at, + # TODO: When cancelling, do we need to set this to now? Or should we keep it as the original time. + transmitted_finishes_at=transmitted_finishes_at, + ) + + # save to the DB + dao_create_broadcast_message(event) + + send_broadcast_message.apply_async( + kwargs={'broadcast_message_id': str(broadcast_message.id)}, + queue=QueueNames.NOTIFY + ) diff --git a/app/models.py b/app/models.py index 8c241ee08..f2e71ca50 100644 --- a/app/models.py +++ b/app/models.py @@ -2332,10 +2332,13 @@ class BroadcastEvent(db.Model): transmitted_starts_at = db.Column(db.DateTime, nullable=True) transmitted_finishes_at = db.Column(db.DateTime, nullable=True) - # @property - # def reference(self): - # # TODO: write this `from_event` function - # return BroadcastMessageTemplate.from_event(self.serialize()).reference + @property + def reference(self): + return BroadcastMessageTemplate.from_event(self.serialize()).reference + + def get_earlier_message_references(self): + from app.dao.broadcast_message_dao import get_earlier_events_for_broadcast_event + return [event.reference for event in get_earlier_events_for_broadcast_event(self)] def serialize(self): return { @@ -2343,7 +2346,9 @@ class BroadcastEvent(db.Model): 'service_id': self.service_id, - # 'reference': self.reference, + 'reference': self.reference, + + 'previous_event_references': self.get_earlier_message_references(), 'broadcast_message_id': self.broadcast_message_id, 'sent_at': self.sent_at, @@ -2355,4 +2360,5 @@ class BroadcastEvent(db.Model): 'transmitted_starts_at': get_dt_string_or_none(self.transmitted_starts_at), 'transmitted_finishes_at': get_dt_string_or_none(self.transmitted_finishes_at), + } diff --git a/tests/app/broadcast_message/test_rest.py b/tests/app/broadcast_message/test_rest.py index 27053f189..50ee25ea5 100644 --- a/tests/app/broadcast_message/test_rest.py +++ b/tests/app/broadcast_message/test_rest.py @@ -3,7 +3,7 @@ import uuid from freezegun import freeze_time import pytest -from app.models import BROADCAST_TYPE, BroadcastStatusType +from app.models import BROADCAST_TYPE, BroadcastStatusType, BroadcastEvent, BroadcastEventMessageType from tests.app.db import create_broadcast_message, create_template, create_service, create_user @@ -265,11 +265,12 @@ def test_update_broadcast_message_status_doesnt_let_you_update_other_things(admi }] -def test_update_broadcast_message_status_stores_cancelled_by_and_cancelled_at(admin_request, sample_service): - t = create_template(sample_service, BROADCAST_TYPE) +def test_update_broadcast_message_status_stores_cancelled_by_and_cancelled_at(admin_request, sample_service, mocker): + t = create_template(sample_service, BROADCAST_TYPE, content='emergency broadcast') bm = create_broadcast_message(t, status=BroadcastStatusType.BROADCASTING) canceller = create_user(email='canceller@gov.uk') sample_service.users.append(canceller) + mock_task = mocker.patch('app.celery.broadcast_message_tasks.send_broadcast_message.apply_async') response = admin_request.post( 'broadcast_message.update_broadcast_message_status', @@ -282,6 +283,15 @@ def test_update_broadcast_message_status_stores_cancelled_by_and_cancelled_at(ad assert response['status'] == BroadcastStatusType.CANCELLED assert response['cancelled_at'] is not None assert response['cancelled_by_id'] == str(canceller.id) + mock_task.assert_called_once_with(kwargs={'broadcast_message_id': str(bm.id)}, queue='notify-internal-tasks') + + assert len(bm.events) == 1 + cancel_event = bm.events[0] + assert cancel_event.service_id == sample_service.id + assert cancel_event.transmitted_areas == bm.areas + assert cancel_event.message_type == BroadcastEventMessageType.CANCEL + assert cancel_event.transmitted_finishes_at == bm.cancelled_at + assert cancel_event.transmitted_content == {"body": "emergency broadcast"} def test_update_broadcast_message_status_stores_approved_by_and_approved_at_and_queues_task( @@ -289,7 +299,7 @@ def test_update_broadcast_message_status_stores_approved_by_and_approved_at_and_ sample_service, mocker ): - t = create_template(sample_service, BROADCAST_TYPE) + t = create_template(sample_service, BROADCAST_TYPE, content='emergency broadcast') bm = create_broadcast_message(t, status=BroadcastStatusType.PENDING_APPROVAL) approver = create_user(email='approver@gov.uk') sample_service.users.append(approver) @@ -308,6 +318,14 @@ def test_update_broadcast_message_status_stores_approved_by_and_approved_at_and_ assert response['approved_by_id'] == str(approver.id) mock_task.assert_called_once_with(kwargs={'broadcast_message_id': str(bm.id)}, queue='notify-internal-tasks') + assert len(bm.events) == 1 + alert_event = bm.events[0] + assert alert_event.service_id == sample_service.id + assert alert_event.transmitted_areas == bm.areas + assert alert_event.message_type == BroadcastEventMessageType.ALERT + assert alert_event.transmitted_finishes_at == bm.finishes_at + assert alert_event.transmitted_content == {"body": "emergency broadcast"} + def test_update_broadcast_message_status_rejects_approval_from_creator( admin_request,