save broadcast events when sending a message, also send cancel messages

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
+    )

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),
+
         }

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,