Merge pull request #3860 from nhsuk/manual-consent-reminders

Manual consent reminders

Author: thomasleese

app/components/app_session_actions_component.rb

@@ -50,8 +50,13 @@ def no_consent_response_row
     count =
       patient_sessions.has_consent_status(status, programme: programmes).count
     href = session_consent_path(session, consent_statuses: [status])
-
-    generate_row(:children_with_no_consent_response, count:, href:)
+    actions = [
+      {
+        text: "Send reminders",
+        href: session_manage_consent_reminders_path(session)
+      }
+    ]
+    generate_row(:children_with_no_consent_response, count:, href:, actions:)
   end
 
   def conflicting_consent_row
@@ -140,7 +145,7 @@ def ready_for_vaccinator_row
     }
   end
 
-  def generate_row(key, count:, href: nil)
+  def generate_row(key, count:, href: nil, actions: nil)
     return nil if count.zero?
 
     {
@@ -150,7 +155,8 @@ def generate_row(key, count:, href: nil)
       value: {
         text:
           (href ? helpers.link_to(I18n.t(key, count:), href).html_safe : text)
-      }
+      },
+      actions:
     }
   end
 end

app/controllers/sessions/manage_consent_reminders_controller.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class Sessions::ManageConsentRemindersController < ApplicationController
+  before_action :set_session
+
+  def create
+    SendManualSchoolConsentRemindersJob.perform_now(@session, current_user:)
+
+    redirect_to session_path(@session),
+                flash: {
+                  success: "Manual consent reminders sent."
+                }
+  end
+
+  private
+
+  def set_session
+    @session = policy_scope(Session).find_by!(slug: params[:session_slug])
+  end
+end

app/jobs/concerns/send_school_consent_notification_concern.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module SendSchoolConsentNotificationConcern
+  extend ActiveSupport::Concern
+
+  included do
+    self.queue_adapter = :sidekiq unless Rails.env.test?
+
+    queue_as :notifications
+  end
+
+  def patient_programmes_eligible_for_notification(session:)
+    return unless session.school? && session.open_for_consent?
+
+    session
+      .patient_sessions
+      .includes_programmes
+      .includes(patient: %i[consent_notifications consents vaccination_records])
+      .find_each do |patient_session|
+        ProgrammeGrouper
+          .call(patient_session.programmes)
+          .each_value do |programmes|
+            patient = patient_session.patient
+            next unless patient.send_notifications?
+
+            programmes_that_need_response =
+              get_programmes_that_need_consent(patient:, session:, programmes:)
+            next if programmes_that_need_response.empty?
+
+            yield patient, programmes_that_need_response
+          end
+      end
+  end
+
+  def get_programmes_that_need_consent(patient:, session:, programmes:)
+    academic_year = session.academic_year
+
+    programmes.select do |programme|
+      patient.consent_status(programme:, academic_year:).no_response? &&
+        patient.vaccination_status(programme:, academic_year:).none_yet?
+    end
+  end
+
+  def reminder_notification_type(patient:, programmes:)
+    sent_initial_reminder =
+      programmes.all? do |programme|
+        patient
+          .consent_notifications
+          .select { it.programmes.include?(programme) }
+          .any?(&:initial_reminder?)
+      end
+
+    sent_initial_reminder ? :subsequent_reminder : :initial_reminder
+  end
+end

app/jobs/enqueue_school_consent_reminders_job.rb

@@ -8,7 +8,7 @@ def perform
       Session.send_consent_reminders.joins(:location).merge(Location.school)
 
     sessions.find_each do |session|
-      SendSchoolConsentRemindersJob.perform_later(session)
+      SendAutomaticSchoolConsentRemindersJob.perform_later(session)
     end
   end
 end

app/jobs/send_automatic_school_consent_reminders_job.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+class SendAutomaticSchoolConsentRemindersJob < ApplicationJob
+  include SendSchoolConsentNotificationConcern
+
+  def perform(session)
+    patient_programmes_eligible_for_notification(
+      session:
+    ) do |patient, programmes|
+      next unless should_send_notification?(patient:, session:, programmes:)
+
+      ConsentNotification.create_and_send!(
+        patient:,
+        session:,
+        programmes:,
+        type: notification_type(patient:, programmes:),
+        current_user: nil
+      )
+    end
+  end
+
+  def should_send_notification?(patient:, session:, programmes:)
+    programmes.any? do |programme|
+      initial_request = initial_request(patient:, programme:)
+      return false if initial_request.nil?
+
+      date_to_send_reminder =
+        earliest_date_to_send_reminder(
+          patient:,
+          session:,
+          programme:,
+          initial_request_date: initial_request.sent_at.to_date
+        )
+      next false if date_to_send_reminder.nil?
+
+      Date.current >= date_to_send_reminder
+    end
+  end
+
+  def initial_request(patient:, programme:)
+    patient
+      .consent_notifications
+      .sort_by(&:sent_at)
+      .find { it.request? && it.programmes.include?(programme) }
+  end
+
+  def earliest_date_to_send_reminder(
+    patient:,
+    session:,
+    programme:,
+    initial_request_date:
+  )
+    session_dates_after_request =
+      session.dates.select { it > initial_request_date }
+
+    scheduled_automatic_reminder_dates =
+      session_dates_after_request.map do
+        it - session.days_before_consent_reminders.days
+      end
+
+    date_index_to_send_reminder_for =
+      already_sent_automatic_consent_reminders_count(patient:, programme:) +
+        manual_consent_reminders_replacing_automatic_count(
+          patient:,
+          programme:,
+          scheduled_automatic_reminder_dates:
+        )
+
+    if date_index_to_send_reminder_for >=
+         scheduled_automatic_reminder_dates.length
+      return nil
+    end
+
+    scheduled_automatic_reminder_dates[date_index_to_send_reminder_for]
+  end
+
+  def notification_type(patient:, programmes:)
+    reminder_notification_type(patient:, programmes:)
+  end
+
+  def already_sent_automatic_consent_reminders_count(patient:, programme:)
+    patient.consent_notifications.count do
+      it.automated_reminder? && it.programmes.include?(programme)
+    end
+  end
+
+  def manual_consent_reminders_replacing_automatic_count(
+    patient:,
+    programme:,
+    scheduled_automatic_reminder_dates:
+  )
+    patient.consent_notifications.count do |notification|
+      notification.manual_reminder? &&
+        notification.programmes.include?(programme) &&
+        scheduled_automatic_reminder_dates.any? do |scheduled_automatic_reminder_date|
+          notification.sent_at < scheduled_automatic_reminder_date &&
+            notification.sent_at >= scheduled_automatic_reminder_date - 3.days
+        end
+    end
+  end
+end

app/jobs/send_manual_school_consent_reminders_job.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class SendManualSchoolConsentRemindersJob < ApplicationJob
+  include SendSchoolConsentNotificationConcern
+
+  def perform(session, current_user:)
+    patient_programmes_eligible_for_notification(
+      session:
+    ) do |patient, programmes|
+      ConsentNotification.create_and_send!(
+        patient:,
+        session:,
+        programmes:,
+        type: notification_type(patient:, programmes:),
+        current_user:
+      )
+    end
+  end
+
+  def notification_type(patient:, programmes:)
+    reminder_notification_type(patient:, programmes:)
+  end
+end