Merge pull request #6602 from NHSDigital/add-sidekiq-job-for-careplus-export

Add sidekiq job for careplus export

Author: thomasleese

app/jobs/enqueue_automated_careplus_reports_job.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class EnqueueAutomatedCareplusReportsJob
+  include Sidekiq::Job
+
+  sidekiq_options queue: :careplus
+
+  def perform
+    Team.eligible_for_automated_careplus_reports.ids.each do |team_id|
+      SendAutomatedCareplusReportsJob.perform_async(team_id)
+    end
+  end
+end

app/jobs/send_automated_careplus_reports_job.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class SendAutomatedCareplusReportsJob
+  include Sidekiq::Job
+
+  sidekiq_options queue: :careplus, lock: :until_executed
+
+  def perform(team_id)
+    Careplus::AutomatedReportSender.call(team_id:)
+  end
+end

app/lib/careplus/automated_report_sender.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+class Careplus::AutomatedReportSender
+  FailedResponseError = Class.new(StandardError)
+  BATCH_SIZE = 10_000
+
+  def self.call(...) = new(...).call
+
+  def initialize(team_id:)
+    @team = Team.find(team_id)
+  end
+
+  def call
+    return unless team.eligible_for_automated_careplus_reports?
+
+    export_date = Date.yesterday
+    academic_year = export_date.academic_year
+    records_scope =
+      Reports::AutomatedCareplusExporter.vaccination_records_scope(
+        team:,
+        academic_year:,
+        start_date: export_date,
+        end_date: export_date
+      )
+
+    records_scope
+      .unscope(:order)
+      .in_batches(of: BATCH_SIZE) do |batch_scope|
+        batch_records = records_scope.where(id: batch_scope.select(:id))
+        next if batch_records.none?
+
+        send_batch!(
+          vaccination_records: batch_records,
+          academic_year:,
+          date: export_date
+        )
+      end
+  end
+
+  private
+
+  attr_reader :team
+
+  def send_batch!(vaccination_records:, academic_year:, date:)
+    csv =
+      Reports::AutomatedCareplusExporter.from_records(
+        vaccination_records:,
+        team:,
+        academic_year:
+      )
+    programme_types =
+      vaccination_records.unscope(:order).distinct.pluck(:programme_type)
+    careplus_report =
+      create_export!(academic_year:, csv:, date:, programme_types:)
+
+    attach_records!(careplus_report:, vaccination_records:)
+
+    record_send_attempt!(careplus_report:)
+
+    response =
+      Careplus::Client.send_csv(
+        username: team.careplus_username,
+        password: team.careplus_password,
+        namespace: team.careplus_namespace,
+        payload: csv
+      )
+
+    unless response.is_a?(Net::HTTPSuccess)
+      careplus_report.update!(status: :failed)
+
+      raise FailedResponseError,
+            "CarePlus request failed with HTTP #{response.code}: #{response.message}"
+    end
+
+    mark_as_sent!(careplus_report:)
+  rescue StandardError
+    careplus_report&.update!(status: :failed)
+    raise
+  end
+
+  def create_export!(academic_year:, csv:, date:, programme_types:)
+    timestamp = Time.current
+
+    CareplusReport.create!(
+      team:,
+      academic_year:,
+      date_from: date,
+      date_to: date,
+      programme_types:,
+      scheduled_at: timestamp,
+      status: :sending,
+      csv_filename: csv_filename(date:, timestamp:),
+      csv_data: csv
+    )
+  end
+
+  def attach_records!(careplus_report:, vaccination_records:)
+    timestamp = Time.current
+
+    CareplusReportVaccinationRecord.insert_all!(
+      vaccination_records.map do |record|
+        {
+          careplus_report_id: careplus_report.id,
+          vaccination_record_id: record.id,
+          change_type: 0,
+          created_at: timestamp,
+          updated_at: timestamp
+        }
+      end
+    )
+  end
+
+  def record_send_attempt!(careplus_report:)
+    careplus_report.update!(sent_at: Time.current)
+  end
+
+  def mark_as_sent!(careplus_report:)
+    careplus_report.update!(status: :sent)
+  end
+
+  def csv_filename(date:, timestamp:)
+    "#{
+      [
+        "automated-careplus",
+        team.workgroup.parameterize,
+        date.iso8601,
+        timestamp.strftime("%H%M%S%6N")
+      ].join("-")
+    }.csv"
+  end
+end

config/sidekiq.yml

@@ -12,6 +12,7 @@
   - immunisations_api_sync
   - immunisations_api_search
   - third_party_data_imports
+  - careplus
   - metrics
   - default
 
@@ -87,3 +88,7 @@
       cron: "0 13,16,19 * * *"
       class: SendVaccinationConfirmationsJob
       description: Send vaccination confirmation emails to parents
+    automated_careplus_reports:
+      cron: "30 2 * * *"
+      class: EnqueueAutomatedCareplusReportsJob
+      description: Enqueue automated CarePlus reports for teams with CarePlus configured

spec/jobs/enqueue_automated_careplus_reports_job_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+describe EnqueueAutomatedCareplusReportsJob do
+  subject(:perform) { described_class.new.perform }
+
+  let(:eligible_team) do
+    create(:team, :with_careplus_enabled, programmes: Programme.all)
+  end
+  let(:team_without_credentials) do
+    create(
+      :team,
+      :with_careplus_enabled,
+      careplus_username: nil,
+      programmes: Programme.all
+    )
+  end
+  let(:team_without_careplus_report_fields) do
+    create(
+      :team,
+      careplus_username: "careplus_user",
+      careplus_password: "careplus_password",
+      careplus_namespace: "MOCK",
+      programmes: Programme.all
+    )
+  end
+
+  it "enqueues a send job for each team with CarePlus enabled and credentials configured" do
+    eligible_team
+    team_without_credentials
+    team_without_careplus_report_fields
+
+    expect { perform }.to enqueue_sidekiq_job(
+      SendAutomatedCareplusReportsJob
+    ).once.with(eligible_team.id)
+  end
+end

spec/jobs/send_automated_careplus_reports_job_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+describe SendAutomatedCareplusReportsJob do
+  describe "#perform" do
+    it "delegates to Careplus::AutomatedReportSender" do
+      team = create(:team, :with_careplus_enabled, programmes: Programme.all)
+
+      expect(Careplus::AutomatedReportSender).to receive(:call).with(
+        team_id: team.id
+      )
+
+      described_class.new.perform(team.id)
+    end
+  end
+end

spec/lib/careplus/automated_report_sender_spec.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+describe Careplus::AutomatedReportSender do
+  subject(:call) { described_class.call(team_id: team.id) }
+
+  let(:team) do
+    create(:team, :with_careplus_enabled, programmes: Programme.all)
+  end
+  let(:programme) { Programme.hpv }
+  let(:session) { create(:session, team:, programmes: [programme]) }
+  let(:endpoint) do
+    "#{Settings.careplus.base_url}/#{team.careplus_namespace}/soap.SchImms.cls"
+  end
+  let(:response_status) { 200 }
+  let(:response_body) { "<result>OK</result>" }
+  let(:yesterday) { Date.new(2025, 8, 31) }
+  let(:yesterday_academic_year) { yesterday.academic_year }
+
+  before do
+    stub_request(:post, endpoint).to_return(
+      status: response_status,
+      body: response_body
+    )
+  end
+
+  around { |example| travel_to(Date.new(2025, 9, 1)) { example.run } }
+
+  it "creates, sends, and stores a sent report with linked vaccination records" do
+    record =
+      create(
+        :vaccination_record,
+        session:,
+        programme:,
+        performed_at: yesterday,
+        created_at: yesterday,
+        updated_at: yesterday
+      )
+
+    expect { call }.to change(CareplusReport, :count).by(1).and(
+      change(CareplusReportVaccinationRecord, :count).by(1)
+    )
+
+    report = CareplusReport.last
+
+    expect(report).to have_attributes(
+      team:,
+      academic_year: yesterday_academic_year,
+      date_from: yesterday,
+      date_to: yesterday,
+      status: "sent"
+    )
+    expect(report.sent_at).to be_present
+    expect(report.vaccination_records).to contain_exactly(record)
+    expect(WebMock).to have_requested(:post, endpoint).once
+  end
+
+  it "uses yesterday and its academic year for the automated export scope" do
+    create(
+      :vaccination_record,
+      session:,
+      programme:,
+      performed_at: yesterday,
+      created_at: yesterday,
+      updated_at: yesterday
+    )
+
+    expect(Reports::AutomatedCareplusExporter).to receive(
+      :vaccination_records_scope
+    ).with(
+      team:,
+      academic_year: yesterday_academic_year,
+      start_date: yesterday,
+      end_date: yesterday
+    ).and_call_original
+
+    call
+  end
+
+  it "splits yesterday's scope into batches of 10000 records" do
+    stub_const("#{described_class}::BATCH_SIZE", 2)
+    records =
+      Array.new(3) do
+        create(
+          :vaccination_record,
+          session:,
+          programme:,
+          performed_at: yesterday,
+          created_at: yesterday,
+          updated_at: yesterday
+        )
+      end
+
+    expect { call }.to change(CareplusReport, :count).by(2).and(
+      change(CareplusReportVaccinationRecord, :count).by(3)
+    )
+
+    expect(WebMock).to have_requested(:post, endpoint).twice
+    expect(
+      CareplusReport
+        .order(:id)
+        .map { |report| report.vaccination_records.count }
+    ).to eq([2, 1])
+    expect(
+      CareplusReport
+        .joins(:vaccination_records)
+        .distinct
+        .flat_map(&:vaccination_records)
+    ).to match_array(records)
+  end
+
+  context "when CarePlus returns a failure response" do
+    let(:response_status) { 500 }
+    let(:response_body) { "<fault>Error</fault>" }
+
+    it "marks the report as failed, keeps linked vaccination records, and raises for retry" do
+      record =
+        create(
+          :vaccination_record,
+          session:,
+          programme:,
+          performed_at: yesterday,
+          created_at: yesterday,
+          updated_at: yesterday
+        )
+
+      expect { call }.to raise_error(
+        described_class::FailedResponseError,
+        "CarePlus request failed with HTTP 500: "
+      ).and change(CareplusReport, :count).by(1).and(
+              change(CareplusReportVaccinationRecord, :count).by(1)
+            )
+
+      report = CareplusReport.last
+      expect(report).to have_attributes(status: "failed")
+      expect(report.sent_at).to be_present
+      expect(report.vaccination_records).to contain_exactly(record)
+    end
+  end
+
+  context "when CarePlus raises an error" do
+    before { stub_request(:post, endpoint).to_raise(Timeout::Error) }
+
+    it "marks the report as failed and keeps linked vaccination records before re-raising" do
+      record =
+        create(
+          :vaccination_record,
+          session:,
+          programme:,
+          performed_at: yesterday,
+          created_at: yesterday,
+          updated_at: yesterday
+        )
+
+      expect { call }.to raise_error(Timeout::Error)
+
+      report = CareplusReport.last
+      expect(report).to have_attributes(status: "failed")
+      expect(report.sent_at).to be_present
+      expect(report.vaccination_records).to contain_exactly(record)
+    end
+  end
+
+  context "when the team is no longer eligible for automated reports" do
+    before { team.update!(careplus_username: nil) }
+
+    it "does nothing" do
+      expect { call }.not_to change(CareplusReport, :count)
+    end
+  end
+end