Add customisations to Notifier::Patient

This adds two new options when sending clinic invitations for a patient
that allows users of this method to decide how the invitations should be
sent.

In particular, we'll be using this in a follow up commit to enable
sending bulk invitations, but only for programmes that have not already
received an invitation, using the new
`include_already_invited_programmes` parameter.

Jira-Issue: MAV-3886

Author: thomasleese

app/controllers/patients_controller.rb

@@ -75,7 +75,7 @@ def invite_to_clinic
     end
 
     @patient.notifier.send_clinic_invitation(
-      programme_types: current_team.programme_types,
+      current_team.programmes,
       team: current_team,
       academic_year:,
       sent_by: current_user

app/controllers/sessions/invite_to_clinic_controller.rb

@@ -17,7 +17,7 @@ def update
 
     @patients_to_invite.each do |patient|
       patient.notifier.send_clinic_invitation(
-        programme_types: @session.programmes_for(patient:).map(&:type),
+        @session.programmes_for(patient:),
         team: @session.team,
         academic_year: @session.academic_year,
         sent_by: current_user

app/lib/notifier/patient.rb

@@ -7,25 +7,41 @@ def initialize(patient)
     @patient = patient
   end
 
-  def send_clinic_invitation(programme_types:, team:, academic_year:, sent_by:)
+  ##
+  # Send a clinic initiation email and SMS to the parents of this patient.
+  #
+  # This determines the correct type of invitation to use (either an initial
+  # invitation or a subsequent invitation) based on the previous invitations
+  # which have been sent:
+  #
+  # +include_vaccinated_programmes+ allows for the sending of invitations for
+  # programmes where the patient has already been vaccinated.
+  #
+  # +include_already_invited_programmes+ allows for the sending of invitations
+  # for programmes where the patient has already been invited for in the past.
+  #
+  def send_clinic_invitation(
+    programmes,
+    team:,
+    academic_year:,
+    sent_by:,
+    include_vaccinated_programmes: false,
+    include_already_invited_programmes: true
+  )
     return unless send_notification?(team:)
 
-    programme_types.reject! do |programme_type|
-      patient.programme_status(
-        Programme.find(programme_type),
-        academic_year:
-      ).vaccinated_fully?
-    end
+    programme_types =
+      programme_types_to_send_for(
+        programmes,
+        team:,
+        academic_year:,
+        include_vaccinated_programmes:,
+        include_already_invited_programmes:
+      )
 
     return if programme_types.empty?
 
-    already_sent =
-      patient.clinic_notifications.any? do
-        it.team_id == team.id && it.academic_year == academic_year &&
-          (programme_types - it.programme_types).empty? # is subset
-      end
-
-    type = already_sent ? :subsequent_invitation : :initial_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
@@ -41,7 +57,7 @@ def send_clinic_invitation(programme_types:, team:, academic_year:, sent_by:)
       sent_by:
     )
 
-    template_name = determine_template_name(type, team:)
+    template_name = find_template_name(type, team:)
 
     params = { academic_year:, patient:, programme_types:, sent_by:, team: }
 
@@ -64,7 +80,56 @@ def parents
     @parents ||= patient.parents.select(&:contactable?).uniq
   end
 
-  def determine_template_name(type, team:)
+  def programme_types_to_send_for(
+    programmes,
+    team:,
+    academic_year:,
+    include_vaccinated_programmes: false,
+    include_already_invited_programmes: true
+  )
+    programmes_to_send_for =
+      programmes.select do |programme|
+        unless include_vaccinated_programmes
+          is_vaccinated =
+            patient.programme_status(programme, academic_year:).vaccinated?
+
+          next false if is_vaccinated
+        end
+
+        unless include_already_invited_programmes
+          already_invited =
+            patient.clinic_notifications.any? do
+              it.team_id == team.id && it.academic_year == academic_year &&
+                it.programme_types.include?(programme.type)
+            end
+
+          next false if already_invited
+        end
+
+        true
+      end
+
+    programmes_to_send_for.map(&:type)
+  end
+
+  def clinic_invitation_type(programme_types, team:, academic_year:)
+    already_sent_initial_invitation_to_all_programmes =
+      programme_types.all? do |programme_type|
+        patient.clinic_notifications.any? do
+          it.team_id == team.id && it.academic_year == academic_year &&
+            it.initial_invitation? &&
+            it.programme_types.include?(programme_type)
+        end
+      end
+
+    if already_sent_initial_invitation_to_all_programmes
+      :subsequent_invitation
+    else
+      :initial_invitation
+    end
+  end
+
+  def find_template_name(type, team:)
     template_names = [
       :"clinic_#{type}_#{team.organisation.ods_code.downcase}",
       :"clinic_#{type}"

spec/lib/notifier/patient_spec.rb

@@ -9,10 +9,12 @@
     subject(:send_clinic_invitation) do
       travel_to(today) do
         notifier.send_clinic_invitation(
-          programme_types:,
+          programmes,
           team:,
           academic_year:,
-          sent_by:
+          sent_by:,
+          include_vaccinated_programmes:,
+          include_already_invited_programmes:
         )
       end
     end
@@ -21,12 +23,13 @@
 
     let(:parents) { create_list(:parent, 2) }
     let(:patient) { create(:patient, parents:, year_group: 10) }
-    let(:programme) { Programme.td_ipv }
-    let(:programmes) { [programme] }
+    let(:programmes) { [Programme.td_ipv] }
     let(:programme_types) { programmes.map(&:type) }
     let(:team) { create(:team, programmes:) }
     let(:location) { create(:school, team:) }
     let(:academic_year) { AcademicYear.current }
+    let(:include_vaccinated_programmes) { false }
+    let(:include_already_invited_programmes) { true }
 
     context "without an invitation already" do
       it "creates a record" do
@@ -281,5 +284,152 @@
         end
       end
     end
+
+    context "when already invited to one of two possible programmes" do
+      let(:programmes) { [Programme.flu, Programme.hpv] }
+
+      before do
+        create(
+          :clinic_notification,
+          :initial_invitation,
+          patient:,
+          team:,
+          academic_year:,
+          programmes: [Programme.flu]
+        )
+      end
+
+      it "creates a record" do
+        expect { send_clinic_invitation }.to change(
+          ClinicNotification,
+          :count
+        ).by(1)
+
+        clinic_notification = ClinicNotification.last
+        expect(clinic_notification).to be_initial_invitation
+        expect(clinic_notification.team).to eq(team)
+        expect(clinic_notification.patient).to eq(patient)
+        expect(clinic_notification.sent_at).to eq(today)
+      end
+
+      it "enqueues an email per parent" do
+        expect { send_clinic_invitation }.to have_delivered_email(
+          :clinic_initial_invitation
+        ).with(
+          parent: parents.first,
+          patient:,
+          programme_types:,
+          team:,
+          academic_year:,
+          sent_by:
+        ).and have_delivered_email(:clinic_initial_invitation).with(
+                parent: parents.second,
+                patient:,
+                programme_types:,
+                team:,
+                academic_year:,
+                sent_by:
+              )
+      end
+
+      it "enqueues a text per parent" do
+        expect { send_clinic_invitation }.to have_delivered_sms(
+          :clinic_initial_invitation
+        ).with(
+          parent: parents.first,
+          patient:,
+          programme_types:,
+          team:,
+          academic_year:,
+          sent_by:
+        ).and have_delivered_sms(:clinic_initial_invitation).with(
+                parent: parents.second,
+                patient:,
+                programme_types:,
+                team:,
+                academic_year:,
+                sent_by:
+              )
+      end
+
+      context "when parent doesn't want to receive updates by text" do
+        let(:parent) { parents.first }
+
+        before { parent.update!(phone_receive_updates: false) }
+
+        it "still enqueues a text" do
+          expect { send_clinic_invitation }.to have_delivered_sms(
+            :clinic_initial_invitation
+          ).with(
+            parent:,
+            patient:,
+            programme_types:,
+            team:,
+            academic_year:,
+            sent_by:
+          )
+        end
+      end
+
+      context "and not including already invited programmes" do
+        let(:include_already_invited_programmes) { false }
+
+        it "creates a record" do
+          expect { send_clinic_invitation }.to change(
+            ClinicNotification,
+            :count
+          ).by(1)
+
+          clinic_notification = ClinicNotification.last
+          expect(clinic_notification).to be_initial_invitation
+          expect(clinic_notification.team).to eq(team)
+          expect(clinic_notification.patient).to eq(patient)
+          expect(clinic_notification.sent_at).to eq(today)
+          expect(clinic_notification.programmes).to contain_exactly(
+            Programme.hpv
+          )
+        end
+
+        it "enqueues an email per parent" do
+          expect { send_clinic_invitation }.to have_delivered_email(
+            :clinic_initial_invitation
+          ).with(
+            parent: parents.first,
+            patient:,
+            programme_types: %w[hpv],
+            team:,
+            academic_year:,
+            sent_by:
+          ).and have_delivered_email(:clinic_initial_invitation).with(
+                  parent: parents.second,
+                  patient:,
+                  programme_types: %w[hpv],
+                  team:,
+                  academic_year:,
+                  sent_by:
+                )
+        end
+
+        it "enqueues a text per parent" do
+          expect { send_clinic_invitation }.to have_delivered_sms(
+            :clinic_initial_invitation
+          ).with(
+            parent: parents.first,
+            patient:,
+            programme_types: %w[hpv],
+            team:,
+            academic_year:,
+            sent_by:
+          ).and have_delivered_sms(:clinic_initial_invitation).with(
+                  parent: parents.second,
+                  patient:,
+                  programme_types: %w[hpv],
+                  team:,
+                  academic_year:,
+                  sent_by:
+                )
+        end
+      end
+    end
   end
 end