Merge pull request #198 from NHSDigital/schedule-appointments

Schedule appointments

Author: steventux

manage_breast_screening/notifications/api_client.py

@@ -0,0 +1,85 @@
+import os
+import time
+import uuid
+
+import jwt
+import requests
+
+from manage_breast_screening.notifications.models import Message, MessageBatch
+
+EXPIRES_IN_MINUTES = 5
+
+
+class OAuthError(Exception):
+    pass
+
+
+class ApiClient:
+    def send_message_batch(self, message_batch: MessageBatch) -> requests.Response:
+        response = requests.post(
+            os.getenv("API_MESSAGE_BATCH_URL"),
+            headers=self.headers(),
+            json=self.message_batch_request_body(message_batch),
+            timeout=10,
+        )
+
+        return response
+
+    def message_batch_request_body(self, message_batch: MessageBatch) -> dict:
+        return {
+            "data": {
+                "type": "MessageBatch",
+                "attributes": {
+                    "routingPlanId": message_batch.routing_plan_id,
+                    "messageBatchReference": str(message_batch.id),
+                    "messages": [
+                        self.message_request_body(m)
+                        for m in message_batch.messages.all()
+                    ],
+                },
+            }
+        }
+
+    def message_request_body(self, message: Message) -> dict:
+        return {
+            "messageReference": str(message.id),
+            "recipient": {"nhsNumber": message.appointment.nhs_number},
+        }
+
+    def headers(self) -> dict:
+        return {
+            "content-type": "application/vnd.api+json",
+            "accept": "application/vnd.api+json",
+            "x-correlation-id": str(uuid.uuid4()),
+            "authorization": f"Bearer {self.bearer_token()}",
+        }
+
+    def bearer_token(self) -> str:
+        auth_jwt = jwt.encode(
+            {
+                "sub": os.getenv("OAUTH_API_KEY"),
+                "iss": os.getenv("OAUTH_API_KEY"),
+                "jti": str(uuid.uuid4()),
+                "aud": os.getenv("OAUTH_TOKEN_URL"),
+                "exp": int(time.time()) + (EXPIRES_IN_MINUTES * 60),
+            },
+            os.getenv("PRIVATE_KEY"),
+            "RS512",
+            {"alg": "RS512", "typ": "JWT", "kid": os.getenv("OAUTH_API_KID")},
+        )
+
+        response = requests.post(
+            os.getenv("OAUTH_TOKEN_URL"),
+            data={
+                "grant_type": "client_credentials",
+                "client_assertion_type": "urn:ietf:params:oauth:client-assertion-type:jwt-bearer",
+                "client_assertion": auth_jwt,
+            },
+            headers={"Content-Type": "application/x-www-form-urlencoded"},
+            timeout=10,
+        )
+
+        if response.status_code != 200:
+            raise OAuthError(response.text)
+
+        return response.json()["access_token"]

manage_breast_screening/notifications/management/commands/send_message_batch.py

@@ -0,0 +1,92 @@
+from datetime import datetime, timedelta
+from zoneinfo import ZoneInfo
+
+from django.core.management.base import BaseCommand, CommandError
+
+from manage_breast_screening.notifications.api_client import ApiClient
+from manage_breast_screening.notifications.models import (
+    Appointment,
+    Message,
+    MessageBatch,
+)
+
+TZ_INFO = ZoneInfo("Europe/London")
+
+
+class Command(BaseCommand):
+    """
+    Django Admin command which finds Appointment records which need batching up to send
+    to Communication Management API, and creates MessageBatch and Message records for them.
+    """
+
+    def add_arguments(self, parser):
+        parser.add_argument("routing_plan_id")
+
+    def handle(self, *args, **options):
+        try:
+            routing_plan_id = options["routing_plan_id"]
+
+            self.stdout.write("Finding appointments to include in batch...")
+            appointments = Appointment.objects.filter(
+                starts_at__lte=self.schedule_date(), message__isnull=True
+            )
+
+            if not appointments:
+                self.stdout.write("No appointments found to batch.")
+                return
+
+            self.stdout.write(f"Found {appointments.count()} appointments to batch.")
+
+            message_batch = MessageBatch.objects.create(
+                routing_plan_id=routing_plan_id,
+                scheduled_at=datetime.today().replace(tzinfo=TZ_INFO),
+            )
+
+            for appointment in appointments:
+                Message.objects.create(appointment=appointment, batch=message_batch)
+
+            self.stdout.write(
+                f"Created MessageBatch with ID {message_batch.id} containing {appointments.count()} messages."
+            )
+
+            response = ApiClient().send_message_batch(message_batch)
+
+            if response.status_code == 201:
+                self.mark_batch_as_sent(message_batch, response.json())
+                self.stdout.write(f"{message_batch} sent")
+            else:
+                self.mark_batch_as_failed(message_batch)
+                self.stdout.write(
+                    f"Failed to send batch. Status: {response.status_code}"
+                )
+        except Exception as e:
+            raise CommandError(e)
+
+    def mark_batch_as_sent(self, message_batch: MessageBatch, response_json: dict):
+        message_batch.notify_id = response_json["data"]["id"]
+        message_batch.sent_at = datetime.now(tz=TZ_INFO)
+        message_batch.status = "sent"
+        message_batch.save()
+
+        for message_json in response_json["data"]["attributes"]["messages"]:
+            message = Message.objects.get(pk=message_json["messageReference"])
+            if message:
+                message.notify_id = message_json["id"]
+                message.status = "delivered"
+                message.save()
+
+    def mark_batch_as_failed(self, message_batch: MessageBatch):
+        message_batch.status = "failed"
+        message_batch.save()
+
+        for message in message_batch.messages.all():
+            message.status = "failed"
+            message.save()
+
+    # TODO: Check the appointment notification rules here.
+    def schedule_date(self) -> datetime:
+        today = datetime.today()
+        today_end = today.replace(
+            hour=23, minute=59, second=59, microsecond=999999, tzinfo=TZ_INFO
+        )
+        return today_end + timedelta(weeks=4, days=4)

manage_breast_screening/notifications/tests/__init__.py

@@ -0,0 +1,49 @@
+import uuid
+from datetime import datetime, timedelta
+
+from factory import Sequence, SubFactory, post_generation
+from factory.django import DjangoModelFactory
+
+from .. import models
+
+
+class ClinicFactory(DjangoModelFactory):
+    class Meta:
+        model = models.Clinic
+
+    code = "BU001"
+    name = "BREAST CARE UNIT"
+    holding_clinic = False
+
+
+class AppointmentFactory(DjangoModelFactory):
+    class Meta:
+        model = models.Appointment
+
+    clinic = SubFactory(ClinicFactory)
+    nhs_number = Sequence(lambda n: int("999%06d" % n))
+    starts_at = datetime.now() + timedelta(weeks=4, days=4)
+
+
+class MessageFactory(DjangoModelFactory):
+    class Meta:
+        model = models.Message
+
+    appointment = SubFactory(AppointmentFactory)
+
+
+class MessageBatchFactory(DjangoModelFactory):
+    class Meta:
+        model = models.MessageBatch
+
+    routing_plan_id = str(uuid.uuid4())
+    status = "unscheduled"
+
+    @post_generation
+    def messages(self, create, extracted, **kwargs):
+        if not create:
+            return
+
+        if extracted:
+            for message in extracted:
+                self.messages.add(message)

manage_breast_screening/notifications/tests/factories.py

@@ -0,0 +1,135 @@
+import uuid
+from datetime import datetime, timedelta
+from unittest.mock import ANY, MagicMock, patch
+
+import pytest
+import requests
+
+from manage_breast_screening.notifications.api_client import ApiClient
+from manage_breast_screening.notifications.management.commands.send_message_batch import (
+    TZ_INFO,
+    Command,
+    CommandError,
+)
+from manage_breast_screening.notifications.models import Message, MessageBatch
+from manage_breast_screening.notifications.tests.factories import AppointmentFactory
+
+
+@patch.object(
+    ApiClient, "send_message_batch", return_value=MagicMock(spec=requests.Response)
+)
+class TestSendMessageBatch:
+    @pytest.fixture
+    def routing_plan_id(self):
+        return str(uuid.uuid4())
+
+    @pytest.mark.django_db
+    def test_handle_with_a_batch_to_send(
+        self, mock_send_message_batch, routing_plan_id
+    ):
+        """Test sending message batch with valid Appointment data"""
+        mock_send_message_batch.return_value.status_code = 201
+
+        appointment = AppointmentFactory(
+            starts_at=datetime.today().replace(tzinfo=TZ_INFO)
+        )
+
+        subject = Command()
+        mock_mark_batch_as_sent = MagicMock()
+        subject.mark_batch_as_sent = mock_mark_batch_as_sent
+
+        subject.handle(**{"routing_plan_id": routing_plan_id})
+
+        message_batches = MessageBatch.objects.filter(routing_plan_id=routing_plan_id)
+        assert message_batches.count() == 1
+        assert (
+            Message.objects.filter(
+                appointment=appointment, batch=message_batches[0]
+            ).count()
+            == 1
+        )
+        mock_mark_batch_as_sent.assert_called_once_with(message_batches[0], ANY)
+
+    @pytest.mark.django_db
+    def test_handle_with_nothing_to_send(
+        self, mock_send_message_batch, routing_plan_id
+    ):
+        """Test that no MessageBatch or Message records are created when no appointments need notifications"""
+        Command().handle(**{"routing_plan_id": routing_plan_id})
+
+        assert MessageBatch.objects.count() == 0
+        assert Message.objects.count() == 0
+
+    @pytest.mark.django_db
+    def test_handle_with_appointments_inside_schedule_window(
+        self, mock_send_message_batch, routing_plan_id
+    ):
+        """Test that appointments with date inside the schedule period are notified"""
+        mock_send_message_batch.return_value.status_code = 201
+        appointment = AppointmentFactory(
+            starts_at=datetime.now().replace(tzinfo=TZ_INFO)
+            + timedelta(weeks=4, days=4)
+        )
+
+        subject = Command()
+        mock_mark_batch_as_sent = MagicMock()
+        subject.mark_batch_as_sent = mock_mark_batch_as_sent
+
+        subject.handle(**{"routing_plan_id": routing_plan_id})
+
+        message_batches = MessageBatch.objects.filter(routing_plan_id=routing_plan_id)
+        assert message_batches.count() == 1
+        assert (
+            Message.objects.filter(
+                appointment=appointment, batch=message_batches[0]
+            ).count()
+            == 1
+        )
+        mock_mark_batch_as_sent.assert_called_once_with(message_batches[0], ANY)
+
+    @pytest.mark.django_db
+    def test_handle_with_appointments_outside_schedule_window(
+        self, mock_send_message_batch, routing_plan_id
+    ):
+        """Test that appointments with date inside the schedule period are notified"""
+        AppointmentFactory(
+            starts_at=datetime.now().replace(tzinfo=TZ_INFO)
+            + timedelta(weeks=4, days=5)
+        )
+
+        subject = Command()
+        mock_mark_batch_as_sent = MagicMock()
+        subject.mark_batch_as_sent = mock_mark_batch_as_sent
+
+        subject.handle(**{"routing_plan_id": routing_plan_id})
+
+        assert MessageBatch.objects.count() == 0
+        assert Message.objects.count() == 0
+        mock_mark_batch_as_sent.assert_not_called
+
+    @pytest.mark.django_db
+    def test_handle_with_failing_notifications(
+        self, mock_send_message_batch, routing_plan_id
+    ):
+        """Test that message batches which fail to send are marked correctly"""
+        mock_send_message_batch.return_value.status_code = 400
+        appointment = AppointmentFactory(
+            starts_at=datetime.now().replace(tzinfo=TZ_INFO)
+            + timedelta(weeks=4, days=4)
+        )
+
+        Command().handle(**{"routing_plan_id": routing_plan_id})
+
+        message_batches = MessageBatch.objects.filter(routing_plan_id=routing_plan_id)
+        assert message_batches.count() == 1
+        assert message_batches[0].status == "failed"
+        messages = Message.objects.filter(
+            appointment=appointment, batch=message_batches[0]
+        )
+        assert messages.count() == 1
+        assert messages[0].status == "failed"
+
+    def test_handle_with_error(self, mock_send_message_batch, routing_plan_id):
+        """Test that errors are caught and raised as CommandErrors"""
+        with pytest.raises(CommandError):
+            Command().handle()