renalware-core 2.0.109 → 2.0.110

data/app/controllers/renalware/pathology/requests/requests_controller.rb

@@ -38,7 +38,7 @@ module Renalware
             layout: false,
             locals: local_vars.merge(
               all_clinics: Renalware::Pathology::Clinic.for_algorithm,
-              all_consultants: Renalware::Pathology::Consultant.ordered,
+              all_consultants: Renalware::Renal::Consultant.ordered,
               all_templates: Renalware::Pathology::Requests::Request::TEMPLATES
             )
           )

data/app/jobs/renalware/hd/update_rolling_patient_statistics_dj_job.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# When executed this job updates rolling statistics for a patient's
+# last past 12 HD sessions.
+# Because this job will be triggered again the next time an HD Sessions is
+# created, it is not crucial to keep each event around - ie they have a short
+# shelf-life. For this reason we only retry 3 times then delete failed jobs.
+module Renalware
+  module HD
+    UpdateRollingPatientStatisticsDjJob = Struct.new(:patient_id) do
+      def perform
+        patient = Renalware::HD::Patient.find(patient_id)
+        UpdateRollingPatientStatistics.new(patient: patient).call
+      end
+
+      def max_attempts
+        3
+      end
+
+      def queue_name
+        "hd_patient_statistics"
+      end
+
+      def priority
+        4
+      end
+
+      def destroy_failed_jobs?
+        true
+      end
+
+      # Retry at intervals of 1, 2, 3 hours
+      def reschedule_at(current_time, attempts)
+        current_time + attempts.hours
+      end
+    end
+  end
+end

data/app/jobs/renalware/hd/update_rolling_patient_statistics_job.rb

@@ -2,12 +2,14 @@
 
 # When executed this job updates rolling statistics for a patient's
 # last past 12 HD sessions.
-
+# Because this job will be triggered again the next time an HD Sessions is
+# created, it is not crucial to keep each event around - ie they have a short
+# shelf-life. For this reason we only retry 3 times then delete failed jobs.
 module Renalware
   module HD
     class UpdateRollingPatientStatisticsJob < ApplicationJob
       queue_as :hd_patient_statistics
-      queue_with_priority 1
+      queue_with_priority 4
 
       # :reek:UtilityFunction
       def perform(patient)

data/app/jobs/renalware/letters/printing/batch_print_job.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/letters"
+require "attr_extras"
+
+module Renalware
+  module Letters
+    module Printing
+      class BatchPrintJob < ApplicationJob
+        include UsingTempFolder
+
+        # Returns the name of a temp file containing the pdf data
+        def perform(batch, user)
+          in_a_temporary_folder do |dir|
+            Dir.chdir(dir) do
+              BatchCompilePdfs.call(batch, user)
+            end
+          end
+        end
+
+        def max_attempts
+          2
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/renalware/patients_ransack_helper.rb

@@ -6,7 +6,7 @@ module Renalware
   module PatientsRansackHelper
     extend ActiveSupport::Concern
 
-    UUID_REGEXP = /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/
+    UUID_REGEXP = /[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}/.freeze
 
     included do
       class_eval do

data/app/models/concerns/renalware/using_temp_folder.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Renalware
+  module UsingTempFolder
+    extend ActiveSupport::Concern
+
+    def in_a_temporary_folder
+      Dir.mktmpdir(nil, Rails.root.join("tmp").to_s) do |dir|
+        yield Pathname(dir)
+        # temp dir removed here
+      end
+    end
+  end
+end

data/app/models/renalware/clinics/appointment.rb

@@ -5,15 +5,14 @@ require_dependency "renalware/clinics"
 module Renalware
   module Clinics
     class Appointment < ApplicationRecord
+      include Accountable
       belongs_to :patient, touch: true
       belongs_to :clinic
-      belongs_to :user
+      belongs_to :consultant, class_name: "Renal::Consultant"
 
       validates :starts_at, presence: true
       validates :patient_id, presence: true
       validates :clinic_id, presence: true
-      validates :user, presence: true
-
       validates :starts_at, timeliness: { type: :datetime }
 
       def starts_on

data/app/models/renalware/clinics/appointment_query.rb

@@ -13,7 +13,11 @@ module Renalware
       end
 
       def call
-        search.result.includes(:user, :clinic, patient: [current_modality: [:description]])
+        search.result.includes(
+          :clinic,
+          :consultant,
+          patient: [current_modality: [:description]]
+        )
       end
 
       def search

data/app/models/renalware/hd/sessions/save_session.rb

@@ -35,7 +35,11 @@ module Renalware
 
           if session.save
             # Might be cleaner if something listened for this event and created this job there?
-            UpdateRollingPatientStatisticsJob.perform_later(patient) unless session.open?
+            # UpdateRollingPatientStatisticsJob.perform_later(patient) unless session.open?
+            unless session.open?
+              Delayed::Job.enqueue UpdateRollingPatientStatisticsDjJob.new(patient.id)
+            end
+
             broadcast(:save_success, session)
           else
             session.type = session_type # See method comment

data/app/models/renalware/hd/update_rolling_patient_statistics.rb

@@ -30,7 +30,7 @@ module Renalware
       end
 
       def rolling_stats_for_this_patient
-        @patient_rolling_stats ||= begin
+        @rolling_stats_for_this_patient ||= begin
           PatientStatistics.where(patient: patient,
                                   rolling: true,
                                   year: nil,

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/letters"
+
+module Renalware
+  module Letters
+    class Batch < ApplicationRecord
+      include Accountable
+      attr_accessor(
+        :url,
+        :enclosures_present,
+        :state_eq,
+        :author_id_eq,
+        :created_by_id_eq,
+        :letterhead_id_eq,
+        :page_count_in_array,
+        :s
+      )
+
+      enum status: { queued: 0, processing: 10, awaiting_printing: 15, failure: 20, success: 30 }
+      has_many(
+        :items,
+        dependent: :restrict_with_exception,
+        class_name: "Renalware::Letters::BatchItem"
+      )
+      has_many(
+        :letters,
+        through: :items,
+        class_name: "Renalware::Letters::Letter"
+      )
+
+      def percent_complete
+        ((items.where(status: :compiled).count.to_f / batch_items_count) * 100).ceil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/letters"
+
+module Renalware
+  module Letters
+    class BatchItem < ApplicationRecord
+      belongs_to :letter
+      belongs_to :batch, counter_cache: true
+      enum status: { queued: 0, compiled: 10 }
+
+      def self.policy_class
+        BasePolicy
+      end
+    end
+  end
+end

data/app/models/renalware/letters/lists/form.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Renalware
+  module Letters
+    module Lists
+      # Form object to help us build and parse the appropriate filters for the
+      # letters_lists controller #show action, where we display all/batch_printable letters etc.
+      # For example, when displaying batchprintable letters we need to disable the enclosures
+      # filter (setting it to No), and restrict the optionsin the letter states dropdown so only
+      # Approved or Completed letters can be batch printed.
+      # We delegate logic to an instance of a private class which is (or is a subclass of)
+      # AllLetters.
+      # If we need to add another filter type, create another sub class of AllLetters.
+      class Form
+        delegate_missing_to :@handler
+
+        def initialize(named_filter:, params: {})
+          @handler = create_filter_specific_object_to_handle_all_requests(named_filter, params)
+        end
+
+        def create_filter_specific_object_to_handle_all_requests(named_filter, params)
+          handler_klass = "#{self.class.name}::#{named_filter.to_s.classify}Letters"
+          handler_klass.constantize.new(params)
+        end
+
+        class AllLetters
+          include ActiveModel::Model
+          include Virtus::Model
+
+          attribute :s, String # sort order, not really part of the form
+          attribute :enclosures_present, Boolean
+          attribute :state_eq, Integer
+          attribute :author_id_eq, Integer
+          attribute :created_by_id_eq, Integer
+          attribute :letterhead_id_eq, Integer
+          attribute :page_count_in_array, Integer
+
+          def letter_state_options(states = Letters::Letter.states)
+            states.map do |state|
+              label = I18n.t(state.to_sym, scope: "enums.letter.for_receptionists.state")
+              [label, state]
+            end
+          end
+
+          def author_options
+            @author_options ||= User.author.ordered
+          end
+
+          def typist_options
+            @typist_options ||= User.ordered
+          end
+
+          def letterhead_options
+            @letterhead_options ||= Letters::Letterhead.ordered
+          end
+
+          def page_count_options
+            [["1 or 2", "[1,2]"], ["3 or 4", "[3,4]"], ["5 or 6", "[5,6]"]]
+          end
+
+          def disabled_inputs
+            []
+          end
+
+          def allow_blank_inputs
+            [:state_eq, :page_count_in_array]
+          end
+        end
+
+        class BatchPrintableLetters < AllLetters
+          def initialize(params)
+            super
+            # These are the default values that must match the filters when the page is first
+            # loaded, so the right results are displayed
+            self.page_count_in_array ||= "[1,2]"
+          end
+
+          def letter_state_options
+            super([:approved])
+          end
+
+          def disabled_inputs
+            [:enclosures_present, :state_eq]
+          end
+
+          def allow_blank_inputs
+            []
+          end
+
+          def enclosures_present
+            false
+          end
+
+          def state_eq
+            @state_eq || :approved
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -44,7 +44,7 @@ module Renalware
         end
 
         # Note the letter must be a LetterPresenter which has a #to_html method
-        # The to_html method should (and does on the LetterPrsenter class) render the complete
+        # The to_html method should (and does on the LetterPresenter class) render the complete
         # html including surrounding layout with inline css and images. This way if the
         # layout changes or the image is changed for example, the cache for the pdf is no longer
         # valid and a new key and cache entry will be created.

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/letters"
+require "attr_extras"
+
+module Renalware
+  module Letters
+    module Printing
+      # - takes a batch of letters
+      # - compiles each letter along with its recipient cover sheets
+      # - adds blank pages to make sure the letter always starts on an odd page
+      # - appends all PDF letters
+      #   2-page documents (from the contents of the /2 folder)
+      # - moves these compiled PDFs to a network share.
+      # - removes the temp folder structure - auto
+      class BatchCompilePdfs
+        include PdfCombining
+        PAGE_COUNTS = %w(2 3 4 5 6 7 8 9 10).freeze
+
+        def self.call(batch, user)
+          new(batch, user).call
+        end
+
+        def initialize(batch, user)
+          @batch = batch
+          @user = user
+          @dir = Pathname(Dir.pwd)
+          Rails.logger.info "Compiling letter PDFs for batch #{batch.id} in folder #{dir}"
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def call
+          batch.status = :processing
+          batch.save_by!(user)
+          batch.items.each do |item|
+            validate_letter(item.letter)
+            assemble_letter_pdfs(item.letter, dir)
+            item.update(status: :compiled)
+          end
+          batch.filepath = append_files
+          batch.status = :awaiting_printing
+          batch.save_by!(user)
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        private
+
+        attr_reader :batch, :dir, :user
+
+        def append_files
+          folder = Rails.root.join("tmp", "batched_letters")
+          FileUtils.mkdir_p folder
+          pdf_file = folder.join("#{batch.id}.pdf")
+          glob = Dir.glob(dir.join("*.pdf"))
+          combine_multiple_pdfs_into_file(filepath: pdf_file, glob: glob) if glob.any?
+          Pathname(pdf_file).to_s
+        end
+
+        def page_count_allowing_for_cover_sheet(letter)
+          (letter.page_count + 1).to_s
+        end
+
+        def validate_letter(letter)
+          raise "Letter has no page_count" if letter.page_count.to_i.zero?
+          if letter.page_count.to_i > PAGE_COUNTS.last.to_i
+            raise "Letter page count (#{letter.page_count}) unexpected"
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        # TODO: refactor
+        def assemble_letter_pdfs(letter, dir)
+          Rails.logger.info "Interleaving address sheets and letters for letter #{letter.id}"
+          letter_has_an_odd_number_of_pages = letter.page_count.odd?
+          filenames = []
+          working_folder = dir.join("letter_#{letter.id}")
+          FileUtils.mkdir_p working_folder
+
+          output_filepath = dir.join("compiled_letter_#{letter.id}.pdf")
+
+          Dir.chdir(working_folder) do
+            letter_filename = write_letter_to_pdf_file(letter)
+            letter.recipients.each do |recipient|
+              Rails.logger.info " Recipient #{recipient.id}"
+              filenames << write_recipient_cover_sheet_pdf(letter, recipient)
+              filenames << letter_filename
+              filenames << blank_page_filename if letter_has_an_odd_number_of_pages
+            end
+            combine_multiple_pdfs_using_filenames(filenames, working_folder, output_filepath)
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+        # Remove letter and recipient working files
+        def remove_working_files
+          FileUtils.rm Dir.glob(dir.join("*.pdf"))
+        end
+
+        def write_letter_to_pdf_file(letter)
+          filename = "original_letter_#{letter.id}.pdf"
+          File.open(filename, "wb") do |file|
+            file.write(PdfRenderer.call(letter))
+          end
+          filename
+        end
+
+        def write_recipient_cover_sheet_pdf(letter, recipient)
+          filename = "letter_#{letter.id}_address_sheet_for_recipient_#{recipient.id}.pdf"
+          RecipientAddressPagePdf.new(recipient).render_file filename
+          filename
+        end
+
+        def blank_page_filename
+          @blank_page_filename ||= begin
+            Renalware::Engine.root.join("app", "assets", "pdf", "blank_page.pdf").to_s
+          end
+        end
+      end
+    end
+  end
+end