renalware-core 2.0.111 → 2.0.112

data/app/controllers/renalware/hd/session_forms/batches_controller.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/hd/base_controller"
+
+module Renalware
+  module HD
+    module SessionForms
+      class BatchesController < BaseController
+        def create
+          batch = create_unprocessed_batch_and_batch_items
+          authorize batch
+          Delayed::Job.enqueue BatchPrintJob.new(batch.id, current_user.id)
+
+          respond_to do |format|
+            format.js {
+              render locals: { batch: batch }
+            }
+          end
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def status
+          batch = find_and_authorize_batch(params[:batch_id])
+          respond_to do |format|
+            format.json {
+              render(
+                status: :ok,
+                json: {
+                  id: batch.id,
+                  status: batch.status,
+                  percent_complete: batch.percent_complete
+                }
+              )
+            }
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+        #
+
+        # rubocop:disable Metrics/MethodLength
+        def show
+          batch = find_and_authorize_batch
+          respond_to do |format|
+            format.pdf do
+              # Returns the PDF itself using path saved in the Batch - provided status is correct
+              send_file(
+                batch.filepath,
+                type: "application/pdf",
+                disposition: "inline",
+                filename: "session_forms_batch_#{batch.id}.pdf"
+              )
+            end
+            format.html do
+              # Returns a partial with a link to the compiled batch pdf
+              render layout: false, locals: { batch: find_and_authorize_batch }
+            end
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        private
+
+        def create_unprocessed_batch_and_batch_items
+          batch = Batch.new
+          Batch.transaction do
+            patient_ids.each { |patient_id| batch.items.build(printable_id: patient_id) }
+            batch.save_by!(current_user)
+          end
+          batch
+        end
+
+        def patient_ids
+          params.require(:batch).require(:patient_ids).split(",")
+        end
+
+        def find_and_authorize_batch(id = nil)
+          Batch.find(id || params[:id]).tap { |batch| authorize batch }
+        end
+      end
+    end
+  end
+end

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

@@ -18,6 +18,7 @@ module Renalware
           render :index, locals: { requests: requests, query: requests_query.search }
         end
 
+        # Displays an historical PDF
         def show
           request = RequestPresenter.new(
             Request.find(params[:id])
@@ -25,17 +26,19 @@ module Renalware
           authorize request
           render(
             pdf: "show",
-            layout: false,
+            page_size: "A4",
+            layout: "renalware/layouts/pdf",
             locals: { request: request },
+            show_as_html: params.key?(:debug),
             extra: "--no-print-media-type" # NOTE: Foundation CSS does not work well in print mode
           )
         end
 
+        # HTML POST
         # NOTE: This needs to be POST since params[:patient_ids] may exceed url char limit in GET
         def new
           render(
             :new,
-            layout: false,
             locals: local_vars.merge(
               all_clinics: Renalware::Pathology::Clinic.for_algorithm,
               all_consultants: Renalware::Renal::Consultant.ordered,
@@ -44,12 +47,15 @@ module Renalware
           )
         end
 
+        # PDF POST
+        # Displays multiple PDFs
         def create
           requests.each(&:print_form)
 
           render(
             pdf: "create",
-            layout: false,
+            page_size: "A4",
+            layout: "renalware/layouts/pdf",
             locals: local_vars,
             extra: "--no-print-media-type" # NOTE: Foundation CSS does not work well in print mode
           )
@@ -67,8 +73,8 @@ module Renalware
         def request_html_form_params
           OpenStruct.new(
             patient_ids: raw_request_params[:patient_ids],
-            clinic_id: request_params[:clinic].id,
-            consultant_id: request_params[:consultant].id,
+            clinic_id: request_params[:clinic]&.id,
+            consultant_id: request_params[:consultant]&.id,
             telephone: request_params[:telephone],
             template: request_params[:template]
           )
@@ -93,7 +99,15 @@ module Renalware
 
         def load_patients
           patient_ids = raw_request_params[:patient_ids]
-          @patients = Pathology::OrderedPatientQuery.new(patient_ids).call
+
+          @patients =
+            Pathology::OrderedPatientQuery
+              .new(patient_ids)
+              .call
+              .eager_load(:requests)
+              .eager_load(:rules)
+              .eager_load(:prescriptions)
+              .eager_load(:drugs)
           authorize Renalware::Patient
         end
 

data/app/controllers/renalware/surveys/dashboards_controller.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/patients"
+
+module Renalware
+  module Surveys
+    class DashboardsController < BaseController
+      def show
+        authorize Survey, :index?
+        render locals: {
+          patient: patient,
+          eq5d_responses: EQ5DPivotedResponse.where(patient: patient).ordered,
+          pos_s_responses: POSSPivotedResponse.where(patient: patient).ordered
+        }
+      end
+
+      private
+
+      def query_params
+        params.fetch(:q, {})
+      end
+    end
+  end
+end

data/app/jobs/renalware/hd/session_forms/batch_print_job.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/letters"
+
+module Renalware
+  module HD
+    module SessionForms
+      BatchPrintJob = Struct.new(:batch_id, :user_id) do
+        include UsingTempFolder
+
+        # Returns the name of a temp file containing the pdf data
+        def perform
+          in_a_temporary_folder do |dir|
+            Dir.chdir(dir) do
+              batch = Batch.find(batch_id)
+              user = User.find(user_id)
+              BatchCompilePdfs.call(batch, user)
+            end
+          end
+        end
+
+        def max_attempts
+          1
+        end
+
+        def queue_name
+          "hd_session_forms"
+        end
+
+        def priority
+          0 # high
+        end
+
+        def destroy_failed_jobs?
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Renalware
+  module PdfCompilation
+    extend ActiveSupport::Concern
+
+    def combine_multiple_pdfs_into_file(filepath:, glob:)
+      filepath = Pathname(filepath)
+      Rails.logger.info " Compiling PDFs #{glob.join(',')} into #{filepath}"
+      shell_to_ghostscript_to_combine_files(glob, dir, filepath)
+      filepath
+    end
+
+    def combine_multiple_pdfs_using_filenames(filenames, dir, output_filepath)
+      filenames = Array(filenames)
+      Rails.logger.info " Compiling PDFs #{filenames.join(',')} into #{output_filepath}"
+      using_a_temporary_output_file do |tmp_outfile|
+        shell_to_ghostscript_to_combine_files(filenames, dir, tmp_outfile)
+        move_tempfile_to_output_file(tmp_outfile, output_filepath)
+      end
+    end
+
+    # rubocop:disable Metrics/LineLength
+    def shell_to_ghostscript_to_combine_files(filenames, dir, outputfile)
+      outputfile = Pathname(outputfile)
+      cmd = "gs -dNOPAUSE -sDEVICE=pdfwrite -sOUTPUTFILE=#{outputfile} -dBATCH #{filenames.join(' ')}"
+      err = msg = nil
+      Open3.popen3(cmd, chdir: dir.to_s) do |_stdin, stdout, stderr|
+        err = stderr.read
+        msg = stdout.read
+      end
+      if err.present?
+        raise "Error combining PDFs: #{[err, msg].join(' ')} command: #{cmd}"
+      end
+    end
+    # rubocop:enable Metrics/LineLength
+
+    def move_tempfile_to_output_file(tmp_outfile, output_file)
+      FileUtils.mv tmp_outfile.path, output_file
+      output_file
+    end
+
+    def rails_tmp_folder
+      Rails.root.join("tmp").to_s
+    end
+
+    # Create a tempfile outside the temp dir as dir will be destroyed when outside block closes.
+    def using_a_temporary_output_file
+      file = Tempfile.new("pdf_combined", rails_tmp_folder)
+      begin
+        yield file
+      ensure
+        file.close
+        file.unlink # deletes the temp file
+      end
+    end
+  end
+end

data/app/models/renalware/clinical/allergy_status_form.rb

@@ -9,7 +9,7 @@ module Renalware
       attribute :no_known_allergies, Integer
 
       def save(patient, user)
-        return unless patient.allergies.count == 0
+        return unless patient.allergies.count.zero?
 
         patient.allergy_status = no_known_allergies? ? :no_known_allergies : :unrecorded
         patient.by = user

data/app/models/renalware/clinical/delete_allergy.rb

@@ -12,7 +12,7 @@ module Renalware
         Allergy.transaction do
           patient = allergy.patient
           allergy.destroy
-          if patient.allergies.count == 0
+          if patient.allergies.count.zero?
             patient.update(allergy_status: :unrecorded, by: user)
           end
         end

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

@@ -25,13 +25,9 @@ module Renalware
       end
 
       class QueryableAppointment < ActiveType::Record[Appointment]
-        ransacker :starts_at, type: :date do
+        ransacker :starts_on, type: :date do
           Arel.sql("DATE(starts_at)")
         end
-
-        ransacker :start_time, type: :datetime do
-          Arel.sql("starts_at")
-        end
       end
     end
   end

data/app/models/renalware/hd.rb

@@ -9,5 +9,11 @@ module Renalware
     def self.cast_patient(patient)
       ActiveType.cast(patient, ::Renalware::HD::Patient)
     end
+
+    module SessionForms
+      def self.table_name_prefix
+        "hd_session_form_"
+      end
+    end
   end
 end

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

@@ -3,7 +3,7 @@
 module Renalware
   module HD
     class PatientListener
-      def patient_modality_changed_to_death(patient:, modality:, actor:)
+      def patient_modality_changed_to_death(patient:, actor:, **)
         nullify_significant_hd_profile_attributes(patient, by: actor)
       end
 

data/app/models/renalware/hd/session_forms/batch.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "attr_extras"
+require_dependency "renalware/hd"
+
+module Renalware
+  module HD
+    module SessionForms
+      class Batch < ApplicationRecord
+        include Accountable
+
+        enum status: { queued: 0, processing: 10, awaiting_printing: 15, failure: 20, success: 30 }
+
+        has_many(
+          :items,
+          dependent: :restrict_with_exception,
+          class_name: "BatchItem"
+        )
+
+        def percent_complete
+          ((items.where(status: :compiled).count.to_f / batch_items_count) * 100).ceil
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/hd/session_forms/batch_compile_pdfs.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/letters"
+require "attr_extras"
+
+module Renalware
+  module HD
+    module SessionForms
+      # Given a Batch object representing a request to 'print' (ie compile) a PDF of multiple
+      # HD Session Forms (aka protocols), where each batch.item points to the patient we want to
+      # print, we render each PDF in the current folder (we assume the caller has chdir'ed
+      # us into a tmp location), and then append them all together as <batchid>.pdf in a known
+      # location. The filepath is assigned to the batch and saved, so it can be served to
+      # a user via the user later.
+      class BatchCompilePdfs
+        include PdfCompilation
+
+        def self.call(batch, user)
+          new(batch, user).call
+        end
+
+        def initialize(batch, user)
+          @batch = batch
+          @user = user
+          @dir = Pathname(Dir.pwd)
+        end
+
+        def call
+          batch.update_by(user, status: :processing)
+          process_batch_items
+          batch.filepath = append_files
+          batch.status = :awaiting_printing
+          batch.save_by!(user)
+        rescue StandardError => e
+          batch.update(last_error: e.message, status: :failure)
+          raise e
+        end
+
+        private
+
+        attr_reader :batch, :dir, :user
+
+        def process_batch_items
+          filename = "batch_#{batch.id}.pdf"
+          File.open(filename, "wb") do |file|
+            file.write(PdfRenderer.new(patients: patients).call)
+          end
+          batch.items.each { |item| item.update(status: :compiled) }
+        end
+
+        def patients
+          @patients ||= HD::Patient.where(id: batch.items.pluck(:printable_id))
+        end
+
+        def render_session_form_pdf_to_file_for(patient)
+          filename = "session_form_#{patient.id}.pdf"
+          File.open(filename, "wb") do |file|
+            file.write(PdfRenderer.new(patient: patient).call)
+          end
+          filename
+        end
+
+        def append_files
+          glob = Dir.glob(dir.join("*.pdf"))
+          if glob.any?
+            combine_multiple_pdfs_into_file(
+              filepath: compiled_output_pdf_filename,
+              glob: glob
+            )
+          end
+          Pathname(compiled_output_pdf_filename).to_s # TODO: what happens if no content?
+        end
+
+        def working_folder
+          Rails.root.join("tmp", "batched_hd_session_forms").tap do |folder|
+            FileUtils.mkdir_p folder
+          end
+        end
+
+        def compiled_output_pdf_filename
+          working_folder.join("#{batch.id}.pdf")
+        end
+      end
+    end
+  end
+end