Merge pull request #6187 from NHSDigital/add-consent-to-notifier-patient

Add consent notifications to `Notifier::Patient`

Author: thomasleese

app/controllers/patient_sessions/consents_controller.rb

@@ -38,12 +38,10 @@ def send_request
         .values
         .find { it.include?(@programme) }
 
-    ConsentNotification.create_and_send!(
-      patient: @patient,
-      programmes:,
+    @patient.notifier.send_consent_request(
+      programmes,
       session: @session,
-      type: :request,
-      current_user:
+      sent_by: current_user
     )
 
     redirect_to session_patient_programme_path(@session, @patient, @programme),

app/jobs/concerns/send_school_consent_notification_concern.rb

@@ -34,16 +34,4 @@ def get_programmes_that_need_consent(patient:, session:, programmes:)
       patient.programme_status(programme, academic_year:).needs_consent?
     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/send_automatic_school_consent_reminders_job.rb

@@ -9,13 +9,7 @@ def perform(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
-      )
+      patient.notifier.send_consent_reminder(programmes, session:, sent_by: nil)
     end
   end
 
@@ -74,10 +68,6 @@ def earliest_date_to_send_reminder(
     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)

app/jobs/send_manual_school_consent_reminders_job.rb

@@ -7,17 +7,11 @@ def perform(session, current_user:)
     patient_programmes_eligible_for_notification(
       session:
     ) do |patient, programmes|
-      ConsentNotification.create_and_send!(
-        patient:,
+      patient.notifier.send_consent_reminder(
+        programmes,
         session:,
-        programmes:,
-        type: notification_type(patient:, programmes:),
-        current_user:
+        sent_by: current_user
       )
     end
   end
-
-  def notification_type(patient:, programmes:)
-    reminder_notification_type(patient:, programmes:)
-  end
 end

app/jobs/send_school_consent_requests_job.rb

@@ -5,13 +5,7 @@ class SendSchoolConsentRequestsJob < ApplicationJob
 
   def perform(session)
     patients_and_programmes(session) do |patient, programmes|
-      ConsentNotification.create_and_send!(
-        patient:,
-        session:,
-        programmes:,
-        type: :request,
-        current_user: nil
-      )
+      patient.notifier.send_consent_request(programmes, session:, sent_by: nil)
     end
   end
 

app/lib/notifier/patient.rb

@@ -7,6 +7,32 @@ def initialize(patient)
     @patient = patient
   end
 
+  ##
+  # Send a consent request email and SMS to the parents of this patient.
+  def send_consent_request(programmes, session:, sent_by:)
+    send_consent_notification(programmes, type: :request, session:, sent_by:)
+  end
+
+  ##
+  # Send a consent reminder email and SMS to the parents of this patient.
+  #
+  # This determines whether to send the initial reminder or subsequent
+  # reminder based on what has already been sent to this patient.
+  def send_consent_reminder(programmes, session:, sent_by:)
+    already_sent_initial_reminder =
+      programmes.all? do |programme|
+        patient
+          .consent_notifications
+          .select { it.programmes.include?(programme) }
+          .any?(&:initial_reminder?)
+      end
+
+    type =
+      already_sent_initial_reminder ? :subsequent_reminder : :initial_reminder
+
+    send_consent_notification(programmes, type:, session:, sent_by:)
+  end
+
   ##
   # Send a clinic initiation email and SMS to the parents of this patient.
   #
@@ -31,7 +57,7 @@ def send_clinic_invitation(
     return unless send_notification?(team:)
 
     programme_types =
-      programme_types_to_send_for(
+      programme_types_to_send_clinic_invitation_for(
         programmes,
         team:,
         academic_year:,
@@ -43,10 +69,6 @@ def send_clinic_invitation(
 
     type = clinic_invitation_type(programme_types, team:, academic_year:)
 
-    # We create a record in the database first to avoid sending duplicate emails/texts.
-    # If a problem occurs while the emails/texts are sent, they will be in the job
-    # queue and restarted at a later date.
-
     ClinicNotification.create!(
       patient:,
       programme_types:,
@@ -57,7 +79,7 @@ def send_clinic_invitation(
       sent_by:
     )
 
-    template_name = find_template_name(type, team:)
+    template_name = find_clinic_template_name(type, team:)
 
     params = { academic_year:, patient:, programme_types:, sent_by:, team: }
 
@@ -72,15 +94,128 @@ def send_clinic_invitation(
   attr_reader :patient
 
   def send_notification?(team:)
-    patient.send_notifications?(team:, send_to_archived: true) &&
-      parents.present?
+    patient.send_notifications?(team:) && parents.present?
   end
 
   def parents
     @parents ||= patient.parents.select(&:contactable?).uniq
   end
 
-  def programme_types_to_send_for(
+  def send_consent_notification(programmes, type:, session:, sent_by:)
+    return unless send_notification?(team: session.team)
+
+    ConsentNotification.create!(
+      programmes:,
+      patient:,
+      session:,
+      type:,
+      sent_at: Time.current,
+      sent_by:
+    )
+
+    email_template, sms_template =
+      generate_consent_templates(programmes:, patient:, session:, type:)
+
+    programme_types = programmes.map(&:type)
+    disease_types = programmes.flat_map(&:disease_types).presence
+
+    parents.each do |parent|
+      EmailDeliveryJob.perform_later(
+        email_template,
+        disease_types:,
+        parent:,
+        patient:,
+        programme_types:,
+        session:,
+        sent_by:
+      )
+
+      SMSDeliveryJob.perform_later(
+        sms_template,
+        disease_types:,
+        parent:,
+        patient:,
+        programme_types:,
+        session:,
+        sent_by:
+      )
+    end
+  end
+
+  def generate_consent_templates(programmes:, patient:, session:, type:)
+    is_school = session.location.school?
+    base_template = :"consent_#{is_school ? "school" : "clinic"}_#{type}"
+
+    # We can only handle a single programme group or variant in the template.
+    group = ProgrammeGrouper.call(programmes).keys.sole
+    variant =
+      if programmes.count == 1
+        programmes.sole.variant_for(patient:).variant_type
+      end
+
+    email_template =
+      if is_school
+        template =
+          resolve_consent_template(
+            base_template:,
+            group:,
+            variant:,
+            session:,
+            channel: :email
+          )
+        if template.blank?
+          raise(
+            "Missing email template for consent notification: #{base_template} " \
+              "with group=#{group.inspect} variant=#{variant.inspect} " \
+              "outbreak=#{is_outbreak.inspect}"
+          )
+        end
+        template
+      else
+        base_template
+      end
+
+    sms_template =
+      if type == :request
+        template =
+          resolve_consent_template(
+            base_template:,
+            group:,
+            variant:,
+            session:,
+            channel: :sms
+          )
+        template || base_template
+      elsif is_school
+        :consent_school_reminder
+      end
+
+    [email_template, sms_template]
+  end
+
+  def resolve_consent_template(
+    base_template:,
+    group:,
+    variant:,
+    session:,
+    channel:
+  )
+    renderer = NotifyTemplateRenderer.for(channel)
+    is_outbreak = session.outbreak
+
+    combinations = [([group, :outbreak] if is_outbreak), [group]]
+    if variant.present? && variant != group
+      combinations.prepend(([variant, :outbreak] if is_outbreak), [variant])
+    end
+    combinations.compact!
+
+    combinations
+      .lazy
+      .map { |parts| :"#{base_template}_#{parts.join("_")}" }
+      .detect { renderer.template_exists?(it, source: :any) }
+  end
+
+  def programme_types_to_send_clinic_invitation_for(
     programmes,
     team:,
     academic_year:,
@@ -129,7 +264,7 @@ def clinic_invitation_type(programme_types, team:, academic_year:)
     end
   end
 
-  def find_template_name(type, team:)
+  def find_clinic_template_name(type, team:)
     template_names = [
       :"clinic_#{type}_#{team.organisation.ods_code.downcase}",
       :"clinic_#{type}"