renalware-core 2.0.149 → 2.0.151

data/app/models/renalware/patient.rb

@@ -18,6 +18,7 @@ module Renalware
     # is a default new uuid value on the secure_id column
     before_create { self.secure_id ||= SecureRandom.uuid }
     before_save :upcase_local_patient_ids
+    # before_validation :strip_spaces_from_nhs_number
     friendly_id :secure_id, use: [:finders]
 
     # For compactness in urls, remove the dashes, so that
@@ -90,9 +91,10 @@ module Renalware
     accepts_nested_attributes_for :current_address
 
     validates :nhs_number,
-              length: { minimum: 10, maximum: 10 },
+              "renalware/patients/nhs_number" => true,
               uniqueness: { case_sensitive: false },
               allow_blank: true
+
     validates :local_patient_id, uniqueness: { case_sensitive: false }, allow_blank: true
     validates :local_patient_id_2, uniqueness: { case_sensitive: false }, allow_blank: true
     validates :local_patient_id_3, uniqueness: { case_sensitive: false }, allow_blank: true
@@ -107,6 +109,7 @@ module Renalware
     validates :email, email: true, allow_blank: true
 
     attr_accessor :skip_death_validations
+
     with_options if: :validate_death_attributes?, on: :update do
       validates :died_on, presence: true
       validates :died_on, timeliness: { type: :date }
@@ -125,6 +128,12 @@ module Renalware
       document&.diabetes&.diagnosis == true
     end
 
+    # Add spacing to an NHS number e.g. "7465613493" => "746 561 3493"
+    # Although this is arguably a view concern, formati
+    def nhs_number_formatted
+      nhs_number&.gsub(/(\d{3})(\d{3})(\d{4})/, '\1 \2 \3')
+    end
+
     # Overrides Personable mixin
     def to_s(format = :default)
       title_suffix = " (#{title})" if has_title?
@@ -165,6 +174,12 @@ module Renalware
 
     private
 
+    def strip_spaces_from_nhs_number
+      return if nhs_number.blank?
+
+      self.nhs_number = nhs_number.delete(" ")
+    end
+
     # Before saving, convert all the local patient ids to upper case
     # TODO: Use a constant for the max number of local patient ids
     def upcase_local_patient_ids

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/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/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