renalware-core 2.0.145 → 2.0.151

data/app/models/renalware/patients/alert.rb

@@ -9,6 +9,7 @@ module Renalware
       acts_as_paranoid
 
       attr_accessor :urgency # for use in forms
+
       validates :patient, presence: true
       validates :notes, presence: true
 

data/app/models/renalware/patients/clear_patient_ukrdc_data.rb

@@ -12,12 +12,17 @@ module Renalware
         new(**args).call
       end
 
+      # Note that we want to avoid any patient validation errors (email is invalid etc)
+      # at this important stage, so we use validate: false. While we validate patient data
+      # entered thorugh the UI, its possible that some migrated data might be invalid
+      # and would cause an error to be raised during a callback in save!
       def call
         patient.send_to_rpv = false
         patient.rpv_decision_on = Time.zone.today
         patient.rpv_recorded_by = by.to_s
         patient.skip_death_validations = true
-        patient.save_by!(by)
+        patient.by = by
+        patient.save!(validate: false)
       end
     end
   end

data/app/models/renalware/patients/deceased_patients_query.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Renalware
+  module Patients
+    # Finds patients with a death modality or who have a died_on date
+    class DeceasedPatientsQuery
+      attr_reader :query_params
+
+      def initialize(query_params)
+        @query_params = query_params || {}
+        @query_params[:s] = "family_name ASC" if @query_params[:s].blank?
+      end
+
+      def call
+        search.result.where(id: ids_of_deceased_patients)
+      end
+
+      def search
+        Patient
+          .includes(:first_cause, current_modality: :description)
+          .ransack(query_params)
+      end
+
+      private
+
+      def ids_of_deceased_patients
+        (ids_of_patients_with_death_modality + ids_of_patients_with_died_on_date).uniq
+      end
+
+      def ids_of_patients_with_death_modality
+        Patient
+          .extending(ModalityScopes)
+          .with_current_modality_of_class(Renalware::Deaths::ModalityDescription)
+          .pluck(:id)
+      end
+
+      def ids_of_patients_with_died_on_date
+        Patient.where.not(died_on: nil).pluck(:id)
+      end
+    end
+  end
+end

data/app/models/renalware/patients/ingestion/update_master_patient_index.rb

@@ -9,6 +9,7 @@ module Renalware
       class UpdateMasterPatientIndex
         pattr_initialize :hl7_message
         attr_reader :rw_patient
+
         delegate :patient_identification, to: :hl7_message
 
         def self.call(hl7_message)

data/app/models/renalware/patients/patient_hospital_identifiers.rb

@@ -15,6 +15,7 @@ module Renalware
   module Patients
     class PatientHospitalIdentifiers
       attr_reader :patient, :name, :value, :first
+
       delegate :present?, to: :name
       delegate :name, :id, to: :first
       delegate :to_s, to: :first

data/app/models/renalware/patients/worry.rb

@@ -6,7 +6,11 @@ module Renalware
   module Patients
     class Worry < ApplicationRecord
       include Accountable
-      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]
+      )
 
       belongs_to :patient,
                  class_name: "Renalware::Patient",

data/app/models/renalware/pd.rb

@@ -9,6 +9,8 @@ module Renalware
     end
 
     def self.cast_patient(patient)
+      return patient if patient.is_a?(::Renalware::PD::Patient)
+
       ActiveType.cast(patient, ::Renalware::PD::Patient)
     end
 

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

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/ClassLength
+module Renalware
+  module PD
+    class AdequacyCalculatedAttributes
+      pattr_initialize [:adequacy!, :age!, :sex!]
+
+      delegate :urine_urea,
+               :height,
+               :weight,
+               :urine_creatinine,
+               :urine_24_vol,
+               :dialysate_urea,
+               :dialysate_creatinine,
+               :dial_24_vol_out,
+               :dial_24_missing,
+               :serum_urea,
+               :serum_creatinine,
+               :urine_24_missing,
+               to: :adequacy,
+               allow_nil: true
+
+      def to_h
+        return {} unless adequacy
+
+        {
+          total_creatinine_clearance: total_creatinine_clearance,
+          pertitoneal_creatinine_clearance: pertitoneal_creatinine_clearance,
+          renal_creatinine_clearance: renal_creatinine_clearance,
+          total_ktv: total_ktv,
+          pertitoneal_ktv: pertitoneal_ktv,
+          renal_ktv: renal_ktv,
+          dietry_protein_intake: dietry_protein_intake
+        }
+      end
+
+      def renal_urine_clearance
+        return if urine_24_missing
+        return if any_are_nil_or_zero?(urine_urea, serum_urea, urine_24_vol)
+
+        (urine_urea * urine_24_vol / 1000.0) / serum_urea * 7.0
+      end
+
+      def renal_creatinine_clearance
+        return if urine_24_missing
+        return if any_are_nil_or_zero?(urine_creatinine, serum_creatinine, urine_24_vol)
+
+        (
+          (urine_creatinine * urine_24_vol) / serum_creatinine * 7.0
+        ).round(2)
+      end
+
+      def residual_renal_function
+        return if any_are_nil_or_zero?(
+          body_surface_area,
+          renal_creatinine_clearance,
+          renal_urine_clearance
+        )
+
+        (
+          (renal_creatinine_clearance + renal_urine_clearance) / (2.0 * body_surface_area) * 1.72
+        ).to_i
+      end
+
+      def pertitoneal_creatinine_clearance
+        return if dial_24_missing
+        return if any_are_nil_or_zero?(
+          dial_24_vol_out,
+          serum_creatinine,
+          dialysate_creatinine,
+          body_surface_area
+        )
+
+        (
+          (dialysate_creatinine * dial_24_vol_out / 1000.0) /
+          serum_creatinine * 7.0 * 1.72 / body_surface_area
+        ).to_i
+      end
+
+      def total_creatinine_clearance
+        return if any_are_nil_or_zero?(residual_renal_function, pertitoneal_creatinine_clearance)
+
+        residual_renal_function + pertitoneal_creatinine_clearance
+      end
+
+      # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+      def dietry_protein_intake
+        return if urine_24_missing || dial_24_missing
+        return if any_are_nil_or_zero?(
+          dialysate_urea,
+          dial_24_vol_out,
+          urine_urea,
+          urine_24_vol,
+          weight
+        )
+
+        (
+          (
+            19.0 + 0.272 *
+            (
+              (dialysate_urea * dial_24_vol_out / 1000.0) + (urine_urea * urine_24_vol / 1000.0)
+            )
+          ) / weight
+        ).round(2)
+      end
+      # rubocop:enable Metrics/MethodLength,Metrics/AbcSize
+
+      def renal_ktv
+        return if urine_24_missing
+        return if any_are_nil_or_zero?(
+          urine_urea,
+          serum_urea,
+          urine_24_vol,
+          total_body_water
+        )
+
+        (
+          (urine_urea / serum_urea * urine_24_vol / 1000.0 * 7.0) / total_body_water.to_f
+        ).round(2)
+      end
+
+      def pertitoneal_ktv
+        return if dial_24_missing
+        return if any_are_nil_or_zero?(
+          serum_urea,
+          dialysate_urea,
+          dial_24_vol_out,
+          total_body_water
+        )
+
+        (
+          (dialysate_urea / serum_urea * dial_24_vol_out / 1000.0 * 7.0) / total_body_water.to_f
+        ).round(2)
+      end
+
+      def total_ktv
+        return if any_are_nil_or_zero?(renal_ktv, pertitoneal_ktv)
+
+        (renal_ktv + pertitoneal_ktv).round(2)
+      end
+
+      def body_surface_area
+        Clinics::BodySurfaceArea.calculate(weight: weight, height: height)
+      end
+
+      def total_body_water
+        Clinics::TotalBodyWater.calculate(height: height, weight: weight, age: age, sex: sex)
+      end
+
+      private
+
+      def any_are_nil_or_zero?(*attrs)
+        Array(attrs).map(&:to_f).any?(&:zero?)
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/ClassLength

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/pd"
+
+module Renalware
+  module PD
+    # Important to understand is that urine measurements related to renal calculations and
+    # dialysate measurements relate to peritoneal calculations
+    class AdequacyResult < ApplicationRecord
+      include PatientScope
+      include Accountable
+      include PatientsRansackHelper
+      acts_as_paranoid
+
+      belongs_to :patient, class_name: "Renalware::PD::Patient", touch: true
+      scope :ordered, -> { order(performed_on: :desc, created_at: :desc) }
+      validates :performed_on, presence: true
+      validates :dial_24_vol_in,
+                numericality: { greater_than_or_equal_to: 1005, less_than_or_equal_to: 35000 },
+                allow_nil: true
+      validates :dial_24_vol_out,
+                numericality: { greater_than_or_equal_to: 500, less_than_or_equal_to: 45000 },
+                allow_nil: true
+      validates :urine_24_vol,
+                numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 6000 },
+                allow_nil: true
+      validates :height, numericality: { allow_blank: true }
+      validates :weight, numericality: { allow_blank: true }
+
+      before_save :derive_calculated_attributes
+      before_save :update_completed
+
+      private
+
+      def derive_calculated_attributes
+        derived_attrs = AdequacyCalculatedAttributes.new(
+          adequacy: self,
+          age: patient.age,
+          sex: patient.sex
+        ).to_h
+        assign_attributes(derived_attrs)
+      end
+
+      # Derive the #complete attribute based on the presence of certain calculated fields.
+      # We may be complete even if some calculated fields are null, provided an appropriate
+      # urine-missing/dialysate-missing boolean is set. These indicate that the patient's urine
+      # or dialysate samples where missing so the renal calculations (relating to urine) or the
+      # peritioneal calculations (relating to dialysate) could not happen.
+      def update_completed
+        self.complete =
+          all_calculations_present? ||
+          urine_missing_but_peritoneal_calculation_present? ||
+          dialysate_missing_but_renal_calculation_present?
+      end
+
+      def all_calculations_present?
+        [
+          total_creatinine_clearance,
+          pertitoneal_creatinine_clearance,
+          renal_creatinine_clearance,
+          total_ktv,
+          pertitoneal_ktv,
+          renal_ktv
+        ].all?(&:present?)
+      end
+
+      def urine_missing_but_peritoneal_calculation_present?
+        urine_24_missing? && [pertitoneal_creatinine_clearance, pertitoneal_ktv].all?(&:present?)
+      end
+
+      def dialysate_missing_but_renal_calculation_present?
+        dial_24_missing? && [renal_creatinine_clearance, renal_ktv].all?(&:present?)
+      end
+    end
+  end
+end

data/app/models/renalware/pd/apd/glucose_calculator.rb

@@ -7,6 +7,7 @@ module Renalware
     module APD
       class GlucoseCalculator
         attr_reader :regime, :bags
+
         delegate :overnight_volume, to: :regime
 
         def initialize(regime:, strength:)

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

@@ -6,15 +6,19 @@ module Renalware
   module PD
     class Patient < ActiveType::Record[Renalware::Patient]
       has_many :pet_adequacy_results, dependent: :restrict_with_exception
+      has_many :pet_results, dependent: :restrict_with_exception
+      has_many :adequacy_results, dependent: :restrict_with_exception
 
       def treated?
         modality_descriptions.exists?(type: "Renalware::PD::ModalityDescription")
       end
 
+      # rubocop:disable Naming/PredicateName
       def has_ever_been_on_pd?
         @has_ever_been_on_pd ||=
           modality_descriptions.exists?(type: "Renalware::PD::ModalityDescription")
       end
+      # rubocop:enable Naming/PredicateName
     end
   end
 end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/pd"
+
+module Renalware
+  module PD
+    class PETDextroseConcentration < ApplicationRecord
+      validates :name, presence: true, uniqueness: true
+
+      scope :ordered, -> { order(position: :asc) }
+
+      def to_s
+        name
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/pd"
+#
+# Captures data used for PET (Peritoneal Equilibration Test) and Adequacy.
+#
+module Renalware
+  module PD
+    class PETResult < ApplicationRecord
+      include PatientScope
+      include Accountable
+      include PatientsRansackHelper
+      extend Enumerize
+      acts_as_paranoid
+
+      belongs_to :patient, class_name: "Renalware::PD::Patient", touch: true
+      scope :ordered, -> { order(performed_on: :desc, created_at: :desc) }
+      before_save :derive_calculated_attributes
+      belongs_to :dextrose_concentration, class_name: "PETDextroseConcentration"
+      belongs_to :overnight_dextrose_concentration, class_name: "PETDextroseConcentration"
+
+      def derive_calculated_attributes
+        self.d_pcr = calculated_d_pcr
+        self.net_uf = calculated_net_uf
+        self.complete = d_pcr.present? && net_uf.present?
+      end
+
+      def calculated_d_pcr
+        return if sample_4hr_creatinine.to_f == 0.0
+        return if serum_creatinine.to_f == 0.0
+
+        (sample_4hr_creatinine / serum_creatinine).round(2)
+      end
+
+      def calculated_net_uf
+        return if volume_in.to_i.zero?
+        return if volume_out.to_i.zero?
+
+        volume_out - volume_in
+      end
+
+      enumerize :test_type, in: %i(fast full), predicate: true
+
+      validates :performed_on, presence: true
+      validates :test_type, presence: true
+      validates :volume_in,
+                numericality: { greater_than_or_equal_to: 1000, less_than_or_equal_to: 3000 },
+                allow_nil: true
+      validates :volume_out,
+                numericality: { greater_than_or_equal_to: 500, less_than_or_equal_to: 4000 },
+                allow_nil: true
+      validates :infusion_time,
+                numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 30 },
+                allow_nil: true
+      validates :drain_time,
+                numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 45 },
+                allow_nil: true
+      validates :overnight_volume_in,
+                numericality: { greater_than_or_equal_to: 1000, less_than_or_equal_to: 3000 },
+                allow_nil: true
+      validates :overnight_volume_out,
+                numericality: { greater_than_or_equal_to: 500, less_than_or_equal_to: 4000 },
+                allow_nil: true
+      validates :overnight_dwell_time,
+                numericality: { greater_than_or_equal_to: 180, less_than_or_equal_to: 720 },
+                allow_nil: true
+
+      # This map is currently for documentation purposes but may be useful when exporting
+      # National Renal Database data
+      # NRD_MAP = {
+      #   pet_date: 163,
+      #   dialysate_creat_plasma_ratio: 164,
+      #   dialysate_glucose_start: 166,
+      #   dialysate_glucose_end: 167,
+      #   adequacy_date: [169,171,173],
+      #   ktv_total: 168,
+      #   ktv_dialysate: 170,
+      #   ktv_rrf: 19,
+      #   crcl_total: 172,
+      #   crcl_rrf: 174,
+      #   daily_urine: 21,
+      #   date_rff: [20,175,22,18,16],
+      #   creat_value: 176,
+      #   dialysate_effluent_volume: 165,
+      #   date_creat_clearance: 173,
+      #   date_creat_value: 177,
+      #   urine_urea_conc: 15,
+      #   urine_creat_conc: 17
+      # }.freeze
+    end
+  end
+end