renalware-core 2.0.145 → 2.0.151

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/pd"
+
+# Captures data used for PET (Peritoneal Equilibration Test) and Adequacy.
+module Renalware
+  module PD
+    class UnifiedPETAdequacyForm
+      include ActiveModel::Model
+      include Virtus::Model
+
+      attribute :pet, PETResult
+      attribute :adequacy, AdequacyResult
+      attribute :patient, Patient
+
+      attribute :pet_missing, Boolean
+      attribute :adequacy_missing, Boolean
+
+      def valid?
+        objects_to_save.each(&:validate).all?(&:valid?)
+      end
+
+      def save_by!(user)
+        PETResult.transaction do
+          objects_to_save.each { |obj| obj.save_by!(user) }
+        end
+      end
+
+      def objects_to_save
+        @objects_to_save ||= begin
+          [].tap do |arr|
+            arr << pet unless pet_missing
+            arr << adequacy unless adequacy_missing
+          end
+        end
+      end
+
+      # This method lets us just use eg simple_form_for in the view without
+      # having to specify the url option i.e. PatientPDUnifiedPetAdequacy here will
+      # resolve to 'patient_pd_pet_adequacy_results_path'
+      def self.model_name
+        ActiveModel::Name.new(self, nil, "PatientPDUnifiedPetAdequacy")
+      end
+    end
+  end
+end

data/app/models/renalware/problems/problem.rb

@@ -9,7 +9,11 @@ module Renalware
       include Accountable
 
       acts_as_paranoid
-      has_paper_trail class_name: "Renalware::Problems::Version", on: [:create, :update, :destroy]
+
+      has_paper_trail(
+        versions: { class_name: "Renalware::Problems::Version" },
+        on: [:create, :update, :destroy]
+      )
 
       belongs_to :patient, touch: true
       has_many :notes, -> { ordered }, dependent: :destroy

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

@@ -18,7 +18,10 @@ module Renalware
       scope :today, -> { where(created_at: Time.zone.today.all_day) }
       scope :hotlist, -> { where(hotlist: true) }
 
-      has_paper_trail class_name: "Renalware::Renal::Version", on: [:create, :update, :destroy]
+      has_paper_trail(
+        versions: { class_name: "Renalware::Renal::Version" },
+        on: [:create, :update, :destroy]
+      )
 
       ransacker :created_at_casted do |_parent|
         Arel.sql("date(renal_aki_alerts.created_at)")

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

@@ -9,7 +9,10 @@ module Renalware
       include Document::Base
       extend Enumerize
 
-      has_paper_trail class_name: "Renalware::Renal::Version", on: [:create, :update, :destroy]
+      has_paper_trail(
+        versions: { class_name: "Renalware::Renal::Version" },
+        on: [:create, :update, :destroy]
+      )
 
       belongs_to :patient, touch: true
       belongs_to :prd_description

data/app/models/renalware/renal/registry/preflight_checks/missing_esrf_query.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/renal"
+
+module Renalware
+  module Renal
+    module Registry
+      module PreflightChecks
+        # Finds patients with a current modality of HD, PD or Transplant, who have no ESRF date
+        class MissingESRFQuery
+          include ModalityScopes
+          MODALITY_NAMES = %w(HD PD Transplant).freeze
+
+          attr_reader :relation, :query_params
+
+          def initialize(relation: nil, query_params: {})
+            @relation = relation || default_relation
+            @query_params = query_params
+            @query_params[:s] = "modality_descriptions_name ASC" if @query_params[:s].blank?
+          end
+
+          def default_relation
+            Renalware::Renal::Patient.left_outer_joins(:profile)
+          end
+
+          def call
+            search
+              .result
+              .extending(ModalityScopes)
+              .preload(current_modality: [:description])
+              .merge(HD::Patient.with_profile)
+              .eager_load(:profile)
+              .with_current_modality_matching(MODALITY_NAMES)
+              .where("renal_profiles.esrf_on IS NULL")
+          end
+
+          def search
+            @search ||= relation.ransack(query_params)
+          end
+
+          def self.missing_data_for(_patient)
+            [
+              :esrf
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/snippets/duplicate_snippet_title_generator.rb

@@ -8,6 +8,7 @@ module Renalware
       MAX_ATTEMPTS = 100
 
       attr_reader :snippet, :title_suffix
+
       delegate :valid?, to: :snippet
 
       def initialize(snippet, title_suffix: "[CLONED]")

data/app/models/renalware/surveys/question.rb

@@ -17,6 +17,10 @@ module Renalware
       validates :code, presence: true, uniqueness: { scope: :survey_id }
       validates :label, presence: true
       validates :position, presence: true
+
+      def admin_label
+        label_abbrv.presence || label
+      end
     end
   end
 end

data/app/models/renalware/transplants/donation.rb

@@ -12,8 +12,10 @@ module Renalware
       belongs_to :patient, touch: true
       belongs_to :recipient, class_name: "Patient", foreign_key: "recipient_id", touch: true
 
-      has_paper_trail class_name: "Renalware::Transplants::Version",
-                      on: [:create, :update, :destroy]
+      has_paper_trail(
+        versions: { class_name: "Renalware::Transplants::Version" },
+        on: [:create, :update, :destroy]
+      )
 
       scope :ordered, -> { order(created_at: :asc) }
       scope :reversed, -> { order(created_at: :desc) }

data/app/models/renalware/transplants/donor_followup.rb

@@ -11,8 +11,10 @@ module Renalware
                  foreign_key: "operation_id",
                  touch: true
 
-      has_paper_trail class_name: "Renalware::Transplants::Version",
-                      on: [:create, :update, :destroy]
+      has_paper_trail(
+        versions: { class_name: "Renalware::Transplants::Version" },
+        on: [:create, :update, :destroy]
+      )
 
       validates :last_seen_on, timeliness: { type: :date, allow_blank: true }
       validates :dead_on, timeliness: { type: :date, allow_blank: true }

data/app/models/renalware/transplants/donor_operation.rb

@@ -19,8 +19,10 @@ module Renalware
       scope :ordered, -> { order(performed_on: :asc) }
       scope :reversed, -> { order(performed_on: :desc) }
 
-      has_paper_trail class_name: "Renalware::Transplants::Version",
-                      on: [:create, :update, :destroy]
+      has_paper_trail(
+        versions: { class_name: "Renalware::Transplants::Version" },
+        on: [:create, :update, :destroy]
+      )
       has_document class_name: "Renalware::Transplants::DonorOperationDocument"
 
       enumerize :kidney_side, in: %i(left right both)

data/app/models/renalware/transplants/donor_workup.rb

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

data/app/models/renalware/transplants/recipient_followup.rb

@@ -28,8 +28,11 @@ module Renalware
                                     reject_if: :all_blank,
                                     allow_destroy: true
 
-      has_paper_trail class_name: "Renalware::Transplants::Version",
-                      on: [:create, :update, :destroy]
+      has_paper_trail(
+        versions: { class_name: "Renalware::Transplants::Version" },
+        on: [:create, :update, :destroy]
+      )
+
       has_document class_name: "Renalware::Transplants::RecipientFollowupDocument"
 
       validates :stent_removed_on, timeliness: { type: :date, allow_blank: true }

data/app/models/renalware/transplants/recipient_operation.rb

@@ -19,8 +19,11 @@ module Renalware
       scope :reversed, -> { order(performed_on: :desc) }
       scope :most_recent, -> { order(performed_on: :desc).first }
 
-      has_paper_trail class_name: "Renalware::Transplants::Version",
-                      on: [:create, :update, :destroy]
+      has_paper_trail(
+        versions: { class_name: "Renalware::Transplants::Version" },
+        on: [:create, :update, :destroy]
+      )
+
       has_document class_name: "Renalware::Transplants::RecipientOperationDocument"
 
       validates :performed_on, presence: true

data/app/models/renalware/transplants/recipient_workup.rb

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

data/app/models/renalware/transplants/recipient_workup_builder.rb

@@ -20,6 +20,7 @@ module Renalware
       private
 
       attr_reader :workup, :default_consenter_name
+
       delegate :document, to: :workup
 
       def assign_default_consenter

data/app/models/renalware/transplants/registration.rb

@@ -18,8 +18,11 @@ module Renalware
               class_name: "RegistrationStatus",
               foreign_key: "registration_id"
 
-      has_paper_trail class_name: "Renalware::Transplants::Version",
-                      on: [:create, :update, :destroy]
+      has_paper_trail(
+        versions: { class_name: "Renalware::Transplants::Version" },
+        on: [:create, :update, :destroy]
+      )
+
       has_document class_name: "Renalware::Transplants::RegistrationDocument"
 
       accepts_nested_attributes_for :statuses

data/app/models/renalware/transplants/registration_status.rb

@@ -14,7 +14,7 @@ module Renalware
       scope :reversed, -> { order(started_on: :desc, created_at: :desc) }
 
       validates :description_id, presence: true
-      validates :started_on, timeliness: { type: :date, allow_blank: false }
+      validates :started_on, presence: true, timeliness: { type: :date, allow_blank: false }
       validates :terminated_on, timeliness: { type: :date, allow_blank: true }
 
       validate :constraint_started_on_today_or_before, if: :started_on

data/app/models/renalware/transplants/rejection_episode.rb

@@ -7,7 +7,7 @@ module Renalware
     class RejectionEpisode < ApplicationRecord
       include Accountable
       has_paper_trail(
-        class_name: "Renalware::Transplants::Version",
+        versions: { class_name: "Renalware::Transplants::Version" },
         on: [:create, :update, :destroy]
       )
       belongs_to :followup, class_name: "RecipientFollowup", touch: true

data/app/models/renalware/ukrdc/{batch_number.rb → batch.rb}

@@ -4,7 +4,7 @@ require_dependency "renalware/ukrdc"
 
 module Renalware
   module UKRDC
-    class BatchNumber < ApplicationRecord
+    class Batch < ApplicationRecord
       def self.next
         create!
       end

data/app/models/renalware/ukrdc/create_encrypted_patient_xml_files.rb

@@ -16,9 +16,8 @@ module Renalware
         :patient_ids,
         :changed_since,
         :logger,
-        :request_uuid,
         :timestamp,
-        :batch_number,
+        :batch,
         :summary,
         :force_send
       )
@@ -27,16 +26,15 @@ module Renalware
         @changed_since = Time.zone.parse(changed_since) if changed_since.present?
         @patient_ids = Array(patient_ids)
         @logger = logger || Rails.logger
-        @request_uuid = SecureRandom.uuid # helps group logs together
         @timestamp = Time.zone.now.strftime("%Y%m%d%H%M%S%L")
-        @batch_number ||= BatchNumber.next.number
+        @batch ||= Batch.next
         @summary = ExportSummary.new
         @force_send = force_send
       end
 
       # rubocop:disable Metrics/MethodLength
       def call
-        logger.tagged(request_uuid) do
+        logger.tagged(batch.number) do
           summary.milliseconds_taken = Benchmark.ms do
             create_patient_xml_files
             encrypt_patient_xml_files
@@ -48,7 +46,7 @@ module Renalware
           email_summary
         end
       rescue StandardError => e
-        # TODO: if fails before copying to outgoing then we should roll back BatchNumber
+        # TODO: if fails before copying to outgoing then we should roll back Batch
         Engine.exception_notifier.notify(e)
         raise e
       end
@@ -60,37 +58,64 @@ module Renalware
         @paths ||= begin
           Paths.new(
             timestamp: timestamp,
-            batch_number: batch_number,
+            batch_number: batch.number,
             working_path: config.ukrdc_working_path
           )
         end
       end
 
-      # rubocop:disable Metrics/MethodLength
+      # If UKRDC_THREADS is set to a nonzero value (eg 4 but depending on CPUs/cores),
+      # a threadpool containing that number of threads is created and XML creation
+      # (including PDF letter rendering) for that patient happens in a separate thread.
+      # The performance increase in doing it this way is marginal unless there are
+      # PDFs to be rendered, which can introduce significant IO wait. As PDFs are cached
+      # by the PDFLetterCache, using threads may have limited benefit but
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       def create_patient_xml_files
         count = 0
         patients = ukrdc_patients_who_have_changed_since_last_send
         summary.num_changed_patients = patients.count
         schema = UKRDC::XsdSchema.new
-        patients.find_each do |patient|
+        thread_count = ENV["UKRDC_THREADS"].to_i
+        use_threads = thread_count.nonzero?
+
+        if use_threads
+          thread_pool = Concurrent::ThreadPoolExecutor.new(max_threads: thread_count)
+        end
+
+        patients.map do |patient|
           count += 1
           Rails.logger.info count
-          CreatePatientXMLFile.new(
-            patient: patient,
-            dir: paths.timestamped_xml_folder,
-            changes_since: changed_since,
-            request_uuid: request_uuid,
-            batch_number: batch_number,
-            logger: logger,
-            force_send: force_send,
-            schema: schema
-          ).call
-
-          # Every n patients, force the garbage collector to kick in
-          # GC.start if (count % 10).zero?
+          if use_threads
+            thread_pool.post do
+              Rails.logger.info "Thread #{Thread.current.object_id}"
+              ActiveRecord::Base.connection_pool.with_connection do
+                create_xml_file(patient: patient, schema: schema)
+              end
+            end
+          else
+            create_xml_file(patient: patient, schema: schema)
+          end
+        end
+      ensure
+        if use_threads
+          thread_pool.shutdown
+          thread_pool.wait_for_termination
         end
       end
-      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+      def create_xml_file(patient:, schema:)
+        CreatePatientXMLFile.new(
+          patient: patient,
+          dir: paths.timestamped_xml_folder,
+          changes_since: changed_since,
+          batch: batch,
+          logger: logger,
+          force_send: force_send,
+          schema: schema
+        ).call
+      end
 
       def build_summary
         summary.count_of_files_in_outgoing_folder = count_of_files_in_outgoing_folder
@@ -141,7 +166,7 @@ module Renalware
       end
 
       def export_results
-        TransmissionLog.where(request_uuid: request_uuid).group(:status).count(:status).to_h
+        TransmissionLog.where(batch_id: batch.id).group(:status).count(:status).to_h
       end
 
       def encrypt_patient_xml_files

data/app/models/renalware/ukrdc/create_patient_xml_file.rb

@@ -9,11 +9,10 @@ module Renalware
       pattr_initialize [
         :patient!,
         :dir!,
-        :request_uuid!,
         :schema!,
         :changes_since,
         :logger,
-        :batch_number,
+        :batch,
         :renderer, # so we can pass a test renderer to bypass real rendering
         :log,
         :force_send
@@ -24,7 +23,7 @@ module Renalware
       # send. This is primarily for debugging and testing phases with UKRDC
       def call
         update_patient_to_indicated_we_checked_them_for_any_relevant_changes
-        UKRDC::TransmissionLog.with_logging(patient, request_uuid) do |log|
+        UKRDC::TransmissionLog.with_logging(patient: patient, batch: batch) do |log|
           @log = log
           logger.info "  Patient #{patient.ukrdc_external_id}"
           xml_payload = build_payload(log)
@@ -86,7 +85,7 @@ module Renalware
           nil
         else
           Payload.new(result.xml).tap do |payload|
-            log.payload = payload.to_s
+            # log.payload = payload.to_s
             log.payload_hash = payload.to_md5_hash
           end
         end
@@ -117,7 +116,7 @@ module Renalware
       end
 
       def xml_filepath
-        xml_filename = Filename.new(patient: patient, batch_number: batch_number).to_s
+        xml_filename = Filename.new(patient: patient, batch_number: batch.number).to_s
         File.join(dir, xml_filename)
       end