renalware-core 2.0.145 → 2.0.151

data/app/models/renalware/letters.rb

@@ -27,5 +27,11 @@ module Renalware
 
     module Delivery
     end
+
+    module Mailshots
+      def self.table_name_prefix
+        "letter_mailshot_"
+      end
+    end
   end
 end

data/app/models/renalware/letters/draft_letter.rb

@@ -18,6 +18,7 @@ module Renalware
         letter.save!
         letter.reload
         broadcast(:draft_letter_successful, letter)
+        letter
       rescue ActiveRecord::RecordInvalid
         broadcast(:draft_letter_failed, letter)
       end

data/app/models/renalware/letters/html_renderer.rb

@@ -8,7 +8,7 @@ module Renalware
     class HTMLRenderer
       def call(letter)
         context = LettersController.new
-        context.render_to_string(
+        context.render_to_string_with_wicked_pdf(
           partial: "/renalware/letters/formatted_letters/letter",
           locals: { letter: letter },
           encoding: "UTF-8"

data/app/models/renalware/letters/letter_factory.rb

@@ -54,7 +54,7 @@ module Renalware
         Letter::Draft.new(params.merge!(type: Letter::Draft.name, patient: patient))
       end
 
-      # note both practice and gp need to be present before we can the pcp - we'll use the
+      # note both practice and gp need to be present before we can send to the pcp - we'll use the
       # practice address but the GP's name as the salutation.
       def include_primary_care_physician_as_default_main_recipient
         return if letter.main_recipient.present?

data/app/models/renalware/letters/mailshots/data_source.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/letters"
+
+module Renalware
+  module Letters
+    module Mailshots
+      # A list of SQL views with a name startingwith "letters_mailshot_"
+      # along with some metadata about the view
+      class DataSource < ApplicationRecord
+        self.table_name = "pg_catalog.pg_views"
+
+        default_scope lambda {
+          where(Arel.sql("schemaname like 'renalware%'"))
+          .where(Arel.sql("viewname like 'letter_mailshot_%'"))
+        }
+      end
+    end
+  end
+end

data/app/models/renalware/letters/mailshots/item.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/letters"
+
+module Renalware
+  module Letters
+    module Mailshots
+      class Item < ApplicationRecord
+        belongs_to :letter
+        belongs_to :mailshot
+
+        validates :letter, presence: true
+        validates :mailshot, presence: true
+      end
+    end
+  end
+end

data/app/models/renalware/letters/mailshots/mailshot.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/letters"
+
+module Renalware
+  module Letters
+    module Mailshots
+      class Mailshot < ApplicationRecord
+        include Accountable
+        # This maps to a PG enum called background_job_status
+        enum status: {
+          queued: "queued",
+          processing: "processing",
+          success: "success",
+          failure: "failure"
+        }
+
+        belongs_to :author, class_name: "User"
+        belongs_to :letterhead
+        has_many :items, dependent: :destroy
+        has_many :letters, through: :items
+
+        validates :description, presence: true
+        validates :sql_view_name, presence: true
+        validates :body, presence: true
+        validates :author, presence: true
+        validates :letterhead, presence: true
+
+        # The sql view should ideally only have one column - 'patient_id' because we use this
+        # to filter the patients we want.
+        def recipient_patients
+          @recipient_patients ||= begin
+            return Patient.none if sql_view_name.blank?
+
+            Patient
+              .where(Arel.sql("id in (select distinct patient_id from #{sql_view_name})"))
+              .order(:family_name, :given_name)
+          end
+        end
+
+        # Called usually by a background job, creates all the letters in the mailshot.
+        # The patients to create letters for are defined by the SQL view output.
+        # The other data items required for creating the letters are stored in the mailshot
+        # object
+        def create_letters
+          Mailshot.transaction do
+            recipient_patients.each do |patient|
+              letter = MailshotLetterFactory.new(
+                patient: patient,
+                current_user: created_by,
+                letter_attributes: common_letter_attributes
+              ).create
+              items.create!(letter: letter)
+            end
+          end
+        end
+
+        # These attributes apply to all letters in the mailshot
+        # rubocop:disable Metrics/MethodLength
+        def common_letter_attributes
+          @common_letter_attributes ||= begin
+            {
+              letterhead_id: letterhead_id,
+              description: description,
+              body: body,
+              author_id: author_id,
+              issued_on: Time.zone.now,
+              main_recipient_attributes: {
+                person_role: :patient,
+                id: nil,
+                addressee_id: nil
+              }
+            }
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+      end
+
+      # Factory class responsible for creating a mailshot letter by moving it
+      # through its 'state machine' states until it is approved and ready to print.
+      # Doing it this ways ensures all pub/sub events, callbacks etc happen in
+      # correctly and in order.
+      class MailshotLetterFactory
+        pattr_initialize [:patient!, :current_user!, :letter_attributes!]
+        attr_reader :letter
+
+        def create
+          draft
+          submit_for_review
+          approve
+          letter
+        end
+
+        def draft
+          @letter = LetterFactory
+            .new(patient, letter_attributes)
+            .with_contacts_as_default_ccs
+            .build
+          letter.save_by!(current_user)
+        end
+
+        def submit_for_review
+          letter.submit(by: current_user) # now pending review
+          letter.save!
+          @letter = Letters::Letter::PendingReview.find(letter.id)
+        end
+
+        def approve
+          ApproveLetter
+            .build(letter)
+            .broadcasting_to_configured_subscribers
+            .call(by: current_user)
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/letters/printing/duplex_interleaved_pdf_renderer.rb

@@ -24,7 +24,7 @@ module Renalware
           # using a hex digest of the interleaved letter but currently would not be.
           # PdfLetterCache.fetch(letter) do
           WickedPdf.new.pdf_from_string(
-            LettersController.new.render_to_string(
+            LettersController.new.render_to_string_with_wicked_pdf(
               template: "/renalware/letters/printable_letters/show",
               locals: { letter: letter, recipients: PrintableRecipients.for(letter) },
               encoding: "UTF-8"

data/app/models/renalware/letters/recipient_address_pdf_renderer.rb

@@ -13,7 +13,7 @@ module Renalware
           recipient = RecipientPresenter::WithCurrentAddress.new(recipient)
         end
         WickedPdf.new.pdf_from_string(
-          LettersController.new.render_to_string(
+          LettersController.new.render_to_string_with_wicked_pdf(
             partial: "/renalware/letters/formatted_letters/recipient_address_cover_sheet",
             locals: { recipient: recipient },
             encoding: "UTF-8"

data/app/models/renalware/low_clearance/profile.rb

@@ -12,8 +12,11 @@ module Renalware
       belongs_to :patient, touch: true
       belongs_to :referrer
       has_document class_name: "Renalware::LowClearance::ProfileDocument"
-      has_paper_trail class_name: "Renalware::LowClearance::Version",
-                      on: [:create, :update, :destroy]
+
+      has_paper_trail(
+        versions: { class_name: "Renalware::LowClearance::Version" },
+        on: [:create, :update, :destroy]
+      )
     end
   end
 end

data/app/models/renalware/medications.rb

@@ -9,6 +9,8 @@ module Renalware
     end
 
     module Delivery
+      DRUG_TYPE_FILTERS = %i(esa immunosuppressant).freeze
+
       def self.table_name_prefix
         "medication_delivery_"
       end

data/app/models/renalware/medications/delivery/prescriptions_due_for_delivery_query.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/medications"
+
+module Renalware
+  module Medications
+    module Delivery
+      # Find current home delivery prescriptions with a next_delivery_date falling
+      # within the specified range.
+      class PrescriptionsDueForDeliveryQuery
+        attr_reader :drug_type_code, :from, :to, :query, :modality_description_id
+
+        def initialize(
+          drug_type_code: nil,
+          from: nil,
+          to: nil,
+          modality_description_id: nil,
+          query: {}
+        )
+          @from = (from || 4.weeks.ago).beginning_of_day
+          @to = (to || 2.weeks.since).end_of_day
+          @drug_type_code = drug_type_code
+          @query = query
+          @modality_description_id = modality_description_id
+        end
+
+        def call
+          query = search.result
+            .current
+            .includes(:patient)
+            .eager_load(drug: [:classifications, :drug_types])
+            .joins("inner join patient_current_modalities pcm on pcm.patient_id = patients.id")
+            .where(provider: :home_delivery)
+            .where(next_delivery_date: (from..to))
+            .order(next_delivery_date: :asc)
+
+          if drug_type_code.present?
+            query = query.where("lower(drug_types.code) = ?", drug_type_code)
+          end
+
+          if modality_description_id.present?
+            query = query.where("pcm.modality_description_id = ?", modality_description_id)
+          end
+          query
+        end
+
+        def search
+          @search ||= Medications::Prescription.ransack(query)
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/medications/prescription.rb

@@ -10,8 +10,10 @@ module Renalware
 
       attr_accessor :drug_select
 
-      has_paper_trail class_name: "Renalware::Medications::PrescriptionVersion",
-                      on: [:create, :update]
+      has_paper_trail(
+        versions: { class_name: "Renalware::Medications::PrescriptionVersion" },
+        on: [:create, :update]
+      )
 
       belongs_to :patient, touch: true
 

data/app/models/renalware/pathology/code_group.rb

@@ -30,10 +30,12 @@ module Renalware
     #         M.position_within_subgroup;
     class CodeGroup < ApplicationRecord
       include Accountable
+
       has_paper_trail(
-        class_name: "Renalware::Pathology::Version",
+        versions: { class_name: "Renalware::Pathology::Version" },
         on: [:create, :update, :destroy]
       )
+
       validates :name, presence: true, uniqueness: true
       validates :description, presence: true
       has_many(

data/app/models/renalware/pathology/code_group_membership.rb

@@ -11,7 +11,10 @@ module Renalware
     # determines its order in the subgroup.
     class CodeGroupMembership < ApplicationRecord
       include Accountable
-      has_paper_trail class_name: "Renalware::Pathology::Version", on: [:create, :update, :destroy]
+      has_paper_trail(
+        versions: { class_name: "Renalware::Pathology::Version" },
+        on: [:create, :update, :destroy]
+      )
       validates :position_within_subgroup, presence: true
       validates :subgroup, presence: true
       belongs_to :code_group

data/app/models/renalware/pathology/nearest_observations_query.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/pathology"
+
+module Renalware
+  module Pathology
+    class NearestObservationsQuery
+      pattr_initialize [:patient!, :date!, :code_group!, look_behind_days!: 2]
+
+      # rubocop:disable Metrics/MethodLength
+      def call
+        pathology_patient
+          .observations
+          .joins(:description)
+          .where(description_id: observation_description_ids)
+          .where("observed_at >= ?", (date - look_behind_days.days).beginning_of_day)
+          .select(
+            :observed_at,
+            :result,
+            :description_id,
+            "pathology_observation_descriptions.code as code"
+          )
+          .map do |row|
+            {
+              code: row.code,
+              observed_on: row.observed_at.to_date,
+              result: row.result
+            }
+          end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      private
+
+      def pathology_patient
+        Pathology.cast_patient(patient)
+      end
+
+      def observation_description_ids
+        @observation_description_ids ||= code_group.memberships.pluck(:observation_description_id)
+      end
+    end
+  end
+end

data/app/models/renalware/pathology/observations_jsonb_serializer.rb

@@ -34,7 +34,7 @@ module Renalware
 
       def observation_hash_or_hash_element_for(code, suffix)
         obs_hash = self[code]
-        return nil if obs_hash.blank? # the patient may not have this code in the set, or it might be {}
+        return nil if obs_hash.blank? # patient may not have this code in the set, or it might be {}
         return obs_hash[:result] if suffix == "_result"
         return Date.parse(obs_hash[:observed_at]) if suffix == "_observed_at"
 

data/app/models/renalware/patient.rb

@@ -18,6 +18,7 @@ module Renalware
     # is a default new uuid value on the secure_id column
     before_create { self.secure_id ||= SecureRandom.uuid }
     before_save :upcase_local_patient_ids
+    # before_validation :strip_spaces_from_nhs_number
     friendly_id :secure_id, use: [:finders]
 
     # For compactness in urls, remove the dashes, so that
@@ -34,7 +35,10 @@ module Renalware
 
     enumerize :marital_status, in: %i(married single divorced widowed)
 
-    has_paper_trail class_name: "Renalware::Patients::Version", on: [:create, :update, :destroy]
+    has_paper_trail(
+      versions: { class_name: "Renalware::Patients::Version" },
+      on: [:create, :update, :destroy]
+    )
 
     serialize :sex, Gender
 
@@ -73,6 +77,10 @@ module Renalware
             -> { order(started_on: :desc).where(state: "current") },
             class_name: "Modalities::Modality"
 
+    has_one :previous_modality,
+            -> { order(ended_on: :desc, created_at: :desc).where.not(ended_on: nil) },
+            class_name: "Modalities::Modality"
+
     has_one :modality_description,
             through: :current_modality,
             class_name: "Modalities::Description",
@@ -83,9 +91,10 @@ module Renalware
     accepts_nested_attributes_for :current_address
 
     validates :nhs_number,
-              length: { minimum: 10, maximum: 10 },
+              "renalware/patients/nhs_number" => true,
               uniqueness: { case_sensitive: false },
               allow_blank: true
+
     validates :local_patient_id, uniqueness: { case_sensitive: false }, allow_blank: true
     validates :local_patient_id_2, uniqueness: { case_sensitive: false }, allow_blank: true
     validates :local_patient_id_3, uniqueness: { case_sensitive: false }, allow_blank: true
@@ -100,6 +109,7 @@ module Renalware
     validates :email, email: true, allow_blank: true
 
     attr_accessor :skip_death_validations
+
     with_options if: :validate_death_attributes?, on: :update do
       validates :died_on, presence: true
       validates :died_on, timeliness: { type: :date }
@@ -118,6 +128,12 @@ module Renalware
       document&.diabetes&.diagnosis == true
     end
 
+    # Add spacing to an NHS number e.g. "7465613493" => "746 561 3493"
+    # Although this is arguably a view concern, formati
+    def nhs_number_formatted
+      nhs_number&.gsub(/(\d{3})(\d{3})(\d{4})/, '\1 \2 \3')
+    end
+
     # Overrides Personable mixin
     def to_s(format = :default)
       title_suffix = " (#{title})" if has_title?
@@ -158,6 +174,12 @@ module Renalware
 
     private
 
+    def strip_spaces_from_nhs_number
+      return if nhs_number.blank?
+
+      self.nhs_number = nhs_number.delete(" ")
+    end
+
     # Before saving, convert all the local patient ids to upper case
     # TODO: Use a constant for the max number of local patient ids
     def upcase_local_patient_ids