renalware-core 2.0.109 → 2.0.110

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/letters"
+require "attr_extras"
+
+module Renalware
+  module Letters
+    module Printing
+      # Marks as completed a Batch and all Letters within it.
+      class CompleteBatch
+        pattr_initialize [:batch!, :user!]
+
+        # TOD: Avoid loading all letters into memory
+        def call
+          Batch.transaction do
+            batch.letters.each { |letter| CompleteLetter.build(letter).call(by: user) }
+            batch.update_by(user, status: :success)
+            batch.reload
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/letters/printing/create_pdf_by_interleaving_address_sheet_and_letter_for_each_recipient.rb.dead

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/letters"
+require "attr_extras"
+
+module Renalware
+  module Letters
+    module Printing
+      # Build PDF for printing. We are targetting an envelope stuffer so there will be an address
+      # cover sheet in front of each letter.
+      # So for a letter where the patient is the main recipient, and we CC to the GP (no practice
+      # email address so snail mailing) and 1 extra CC (a contact) the output will look like
+      # this:
+      #
+      # 1. Patient address cover sheet
+      # 2. Letter
+      # 3. GP address cover sheet
+      # 2. Letter
+      # 5. Contact address cover sheet
+      # 2. Letter
+      #
+      # Note however the we always pad each item (address sheet, letter) with blank pages to make
+      # sure duplex printing does not cause the next page recipient's content to be rendered on the
+      # back of the ast page of the previous letter for example/
+      #
+      # Compiles print content for all input letters and outputs the merged PDF to output_file.
+      # Allows batch printing if you want to print say all 2 page letters together.
+      # The caller may choose for example to send the output_file could be sent back to the browser
+      # for manual printing using (eg using send_file) or copy the merged PDF to a folder for
+      # automated printing.
+      # class CreatePdfByInterleavingAddressSheetAndLetterForEachRecipient
+        # pattr_initialize [:letters!, :output_file!]
+
+        # def call
+        #   # There is a choice of two methods of building the merged PDF. See pros and cons.
+        #   # The other is UsingSeparatePdfForEachLetterSection.
+        #   UsingOnePdfForAllLetterSections.new(
+        #     letters: letters,
+        #     output_file: output_file
+        #   ).call
+        # end
+
+        # # For each letter, uses whkhtmltopdf to build the entire print content, ie all address
+        # # sheets and required instance of the letter are created as one fresh pdf (no cache will be
+        # # used).
+        # #
+        # # Pros:
+        # # - Quicker: For each letter only one PDF is generated, and although the generation is slow
+        # #   as it does not use the previously cached letter PDF, and it has to render all the letter
+        # #   sections, including the letter itself, for every recipient, its stil faster then
+        # #   rendering separate PDFs for each section.
+        # # Cons:
+        # #  - wastes some resources because it does not use the cache and renders same letter
+        # #    multiple times in the views
+        # #  - cannot be 100% sure the number of pages in the final PDF will be extactly what we
+        # #    predict, so requires a check to load the pdf into a reader and validate the page_count
+        # class UsingOnePdfForAllLetterSections
+        #   include PdfCombining
+        #   pattr_initialize [:letters!, :output_file!]
+
+        #   def call
+        #     in_a_temporary_folder do |dir|
+        #       Array(letters).each do |letter|
+        #         if letter.page_count.to_i < 1
+        #           raise(ArgumentError, "letter.page_count not set on letter.id=#{letter.id}")
+        #         end
+
+        #         letter_filename = create_letter_pdf_in(dir, letter)
+        #         files << letter_filename
+        #       end
+        #       combine_multiple_pdfs_into_one(dir, output_file)
+        #       # For debuging:
+        #       # FileUtils.cp output_file, "/Users/tim/Desktop/x.pdf"
+        #       # `open /Users/tim/Desktop/x.pdf`
+        #     end
+        #   end
+
+        #   private
+
+        #   def create_letter_pdf_in(dir, letter)
+        #     filename = "letter_#{letter.id}.pdf"
+        #     path = dir.join(filename)
+        #     File.open(path, "wb") { |file| file.write(DuplexInterleavedPdfRenderer.call(letter)) }
+        #     filename
+        #   end
+        end
+      end
+    end
+  end
+end

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

@@ -21,7 +21,7 @@ module Renalware
           end
           # NB not caching the pdf for now until we can find a more standard way of using the
           # letter cache across adhoc and env stuffer renderers. Here for example we should be
-          # using a hex digest of the interleaved letter but currentlt would not be.
+          # 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(

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

@@ -11,43 +11,46 @@ module Renalware
       module PdfCombining
         extend ActiveSupport::Concern
 
-        def combine_multiple_pdfs_into_one(dir, output_filepath)
+        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_into(tmp_outfile, dir)
-            copy_tempfile_to_output_file(tmp_outfile, output_filepath)
+            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_into(outfile, dir)
-          cmd = "gs -dNOPAUSE -sDEVICE=pdfwrite -sOUTPUTFILE=#{outfile.path} -dBATCH #{files.join(' ')}"
-          err = Open3.popen3(cmd, chdir: dir.to_s) do |_stdin, _stdout, stderr|
-            stderr.read
+        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
-          raise "Error combining PDFs: #{err}" unless err.empty?
         end
         # rubocop:enable Metrics/LineLength
 
-        def copy_tempfile_to_output_file(tmp_outfile, output_file)
-          FileUtils.cp tmp_outfile.path, output_file
+        def move_tempfile_to_output_file(tmp_outfile, output_file)
+          FileUtils.mv tmp_outfile.path, output_file
           output_file
         end
 
-        def files
-          @files ||= []
-        end
-
         def rails_tmp_folder
           Rails.root.join("tmp").to_s
         end
 
-        def in_a_temporary_folder
-          Dir.mktmpdir(nil, rails_tmp_folder) do |dir|
-            yield Pathname(dir)
-            # temp dir removed here!
-          end
-        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)

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

@@ -26,7 +26,7 @@ module Renalware
     #   patient_id  observation_date  observations
     #   ------------------------------------------
     #   1           2018-02-02        {"CYA": "14"}
-    #   1           2016-06-15        {"CMVDNA": "0.10"}
+    #   1           2016-06-15        {"CMVD": "0.10"}
     #   1           2016-03-15        {"NA": "137", "TP": "74", "ALB": "48", "ALP": "71", ...
     #   1           2016-02-29        {"NA": "136", "TP": "78", "ALB": "47", "ALP": "71", ...
     #

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

@@ -25,7 +25,7 @@ module Renalware
           CRP FER FOL B12 URE CRE EGFR NA POT BIC
           CCA PHOS PTHI TP GLO ALB URAT BIL ALT AST
           ALP GGT BGLU HBA HBAI CHOL HDL LDL TRIG TSH
-          CK URR CRCL UREP AL
+          CK URR CRCL UREP AL CICLOMS TACROMS SIROMS CMVD TROP
         )
       end
     end

data/app/models/renalware/pathology/requests/global_rule/transplant_date_within_weeks.rb

@@ -20,7 +20,7 @@ module Renalware
           end
 
           def to_s
-            "transplant date within #{@param_comparison_value} weeks ago"
+            "transplant date within #{param_comparison_value} weeks ago"
           end
         end
       end

data/app/models/renalware/pathology/requests/global_rule/transplant_registration_status.rb

@@ -14,11 +14,13 @@ module Renalware
             return false if registration.blank?
 
             registration_status = registration.current_status
+            return false if registration_status.blank?
+
             registration_status.description.code == param_comparison_value
           end
 
           def to_s
-            "transplant registration status is #{@param_comparison_value}"
+            "transplant registration status is #{param_comparison_value}"
           end
         end
       end

data/app/models/renalware/pathology/requests/request.rb

@@ -12,7 +12,7 @@ module Renalware
 
         belongs_to :patient, class_name: "::Renalware::Pathology::Patient", touch: true
         belongs_to :clinic, class_name: "::Renalware::Clinics::Clinic"
-        belongs_to :consultant, class_name: "::Renalware::Pathology::Consultant"
+        belongs_to :consultant, class_name: "::Renalware::Renal::Consultant"
         has_and_belongs_to_many :request_descriptions,
                                 class_name: "::Renalware::Pathology::RequestDescription"
         has_and_belongs_to_many :patient_rules,

data/app/models/renalware/pathology/requests/request_params_factory.rb

@@ -1,14 +1,13 @@
 # frozen_string_literal: true
 
 require_dependency "renalware/pathology"
+require "attr_extras"
 
 module Renalware
   module Pathology
     module Requests
       class RequestParamsFactory
-        def initialize(params)
-          @params = params
-        end
+        pattr_initialize :params
 
         def build
           {
@@ -16,7 +15,7 @@ module Renalware
             consultant: consultant,
             telephone: telephone,
             template: template,
-            by: @params[:by]
+            by: params[:by]
           }
         end
 
@@ -39,9 +38,9 @@ module Renalware
         end
 
         def requested_clinic
-          return if @params[:clinic_id].blank?
+          return if params[:clinic_id].blank?
 
-          Renalware::Clinics::Clinic.find(@params[:clinic_id])
+          Renalware::Clinics::Clinic.find(params[:clinic_id])
         end
 
         def default_clinic
@@ -49,25 +48,25 @@ module Renalware
         end
 
         def requested_consultant
-          return if @params[:consultant_id].blank?
+          return if params[:consultant_id].blank?
 
-          Renalware::Pathology::Consultant.find(@params[:consultant_id])
+          Renalware::Renal::Consultant.find(params[:consultant_id])
         end
 
         def default_consultant
-          Renalware::Pathology::Consultant.ordered.first
+          Renalware::Renal::Consultant.ordered.first
         end
 
         def requested_telephone
-          @params[:telephone]
+          params[:telephone]
         end
 
         def default_telephone
-          consultant.telephone
+          consultant&.telephone
         end
 
         def requested_template
-          @params[:template]
+          params[:template]
         end
 
         def default_template

data/app/models/renalware/patient.rb

@@ -180,11 +180,12 @@ module Renalware
     end
 
     def must_have_at_least_one_identifier
-      if hospital_identifiers.all.empty?
+      if hospital_identifiers.all.empty? && external_patient_id.blank?
         errors.add(
           :base,
           "The patient must have at least one of these numbers: "\
-          "#{Renalware.config.patient_hospital_identifiers.keys.join(', ')}"
+          "#{Renalware.config.patient_hospital_identifiers.keys.join(', ')}, "\
+          "Other Hospital Number"
         )
       end
     end

data/app/models/renalware/pd/apd_regime.rb

@@ -78,16 +78,16 @@ module Renalware
       validates :no_cycles_per_apd, presence: true
       validates :fill_volume, presence: true
 
-      with_options if: :has_additional_manual_exchange_bag?, on: [:create, :update] do |regime|
-        regime.validates :additional_manual_exchange_volume, presence: true
+      with_options if: :has_additional_manual_exchange_bag?, on: [:create, :update] do
+        validates :additional_manual_exchange_volume, presence: true
       end
 
-      with_options if: :has_last_fill_bag?, on: [:create, :update] do |regime|
-        regime.validates :last_fill_volume, presence: true
+      with_options if: :has_last_fill_bag?, on: [:create, :update] do
+        validates :last_fill_volume, presence: true
       end
 
-      with_options if: :tidal?, on: [:create, :update] do |regime|
-        regime.validates :tidal_percentage, presence: true
+      with_options if: :tidal?, on: [:create, :update] do
+        validates :tidal_percentage, presence: true
       end
 
       def pd_type

data/app/models/renalware/renal/consultant.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/renal"
+
+module Renalware
+  module Renal
+    class Consultant < ApplicationRecord
+      validates :name, presence: true
+      scope :ordered, -> { order(name: :asc) }
+
+      def to_s
+        name
+      end
+    end
+  end
+end

data/app/models/renalware/transplants/registrations/wait_list_query.rb

@@ -46,24 +46,18 @@ module Renalware
               .where(
                 <<-SQL.squish
                 (
-                  transplant_registration_status_descriptions.code in ('active','suspended')
+                  transplant_registration_status_descriptions.code in ('active')
                   and
                   (
-                    transplant_registrations.document -> 'uk_transplant_centre' ->> 'status' not ilike '%' || transplant_registration_status_descriptions.code || '%'
-                    or
-                    transplant_registrations.document -> 'uk_transplant_centre' ->> 'status' = ''
-                    or
-                    transplant_registrations.document -> 'uk_transplant_centre' ->> 'status' IS NULL
+                    transplant_registrations.document -> 'uk_transplant_centre' ->> 'status' not ilike 'A'
                   )
                 )
                 or
                 (
-                  transplant_registration_status_descriptions.code not in ('active','suspended')
+                  transplant_registration_status_descriptions.code not in ('active')
                   and
                   (
-                    transplant_registrations.document -> 'uk_transplant_centre' ->> 'status' ilike '%active%'
-                    or
-                    transplant_registrations.document -> 'uk_transplant_centre' ->> 'status' ilike '%suspended%'
+                    transplant_registrations.document -> 'uk_transplant_centre' ->> 'status' ilike 'A'
                   )
                 )
                 SQL

data/app/models/renalware/ukrdc/treatment_timeline/generator_factory.rb

@@ -14,7 +14,7 @@ module Renalware
         def self.call(modality)
           type = modality.description.code&.to_s&.camelize
           klass = (klass_for(type) || klass_for(DEFAULT_TYPE)).new(modality)
-          Rails.logger.info "GeneratorFactory type = #{type} class = #{klass}"
+          Rails.logger.debug "GeneratorFactory type = #{type} class = #{klass}"
           klass
         end
 

data/app/pdfs/renalware/letters/printing/recipient_address_page_pdf.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/letters"
+
+module Renalware
+  module Letters
+    module Printing
+      # Creates a letter addressee/recipient cover sheet PDF that will be inserted in front
+      # of each copy of the letter. Page 2 is always blank because we as are duplex printing.
+      class RecipientAddressPagePdf
+        include Prawn::View
+        attr_reader :recipient
+
+        def initialize(recipient)
+          @recipient = recipient
+          build
+        end
+
+        def document
+          @document ||= Prawn::Document.new(
+            page_size: "A4",
+            page_layout: :portrait,
+            left_margin: 65,
+            top_margin: 109
+          )
+        end
+
+        private
+
+        def build
+          render_recipient_address
+          render_blank_second_page
+          self
+        end
+
+        def render_recipient_address
+          presenter = RecipientPresenter.new(recipient)
+          font_size 9
+          text "PRIVATE AND CONFIDENTIAL"
+          text " "
+          presenter.address.to_a.each { |line| text line }
+        end
+
+        def render_blank_second_page
+          start_new_page
+        end
+      end
+    end
+  end
+end