renalware-core 2.0.147 → 2.0.153

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

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

data/app/models/renalware/medications/prescription.rb

@@ -10,8 +10,10 @@ module Renalware
 
       attr_accessor :drug_select
 
-      has_paper_trail class_name: "Renalware::Medications::PrescriptionVersion",
-                      on: [:create, :update]
+      has_paper_trail(
+        versions: { class_name: "Renalware::Medications::PrescriptionVersion" },
+        on: [:create, :update]
+      )
 
       belongs_to :patient, touch: true
 

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

@@ -30,10 +30,12 @@ module Renalware
     #         M.position_within_subgroup;
     class CodeGroup < ApplicationRecord
       include Accountable
+
       has_paper_trail(
-        class_name: "Renalware::Pathology::Version",
+        versions: { class_name: "Renalware::Pathology::Version" },
         on: [:create, :update, :destroy]
       )
+
       validates :name, presence: true, uniqueness: true
       validates :description, presence: true
       has_many(

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

@@ -11,7 +11,10 @@ module Renalware
     # determines its order in the subgroup.
     class CodeGroupMembership < ApplicationRecord
       include Accountable
-      has_paper_trail class_name: "Renalware::Pathology::Version", on: [:create, :update, :destroy]
+      has_paper_trail(
+        versions: { class_name: "Renalware::Pathology::Version" },
+        on: [:create, :update, :destroy]
+      )
       validates :position_within_subgroup, presence: true
       validates :subgroup, presence: true
       belongs_to :code_group

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/pathology"
+
+module Renalware
+  module Pathology
+    class NearestObservationsQuery
+      pattr_initialize [:patient!, :date!, :code_group!, look_behind_days!: 2]
+
+      # rubocop:disable Metrics/MethodLength
+      def call
+        pathology_patient
+          .observations
+          .joins(:description)
+          .where(description_id: observation_description_ids)
+          .where("observed_at >= ?", (date - look_behind_days.days).beginning_of_day)
+          .select(
+            :observed_at,
+            :result,
+            :description_id,
+            "pathology_observation_descriptions.code as code"
+          )
+          .map do |row|
+            {
+              code: row.code,
+              observed_on: row.observed_at.to_date,
+              result: row.result
+            }
+          end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      private
+
+      def pathology_patient
+        Pathology.cast_patient(patient)
+      end
+
+      def observation_description_ids
+        @observation_description_ids ||= code_group.memberships.pluck(:observation_description_id)
+      end
+    end
+  end
+end

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

@@ -34,7 +34,7 @@ module Renalware
 
       def observation_hash_or_hash_element_for(code, suffix)
         obs_hash = self[code]
-        return nil if obs_hash.blank? # the patient may not have this code in the set, or it might be {}
+        return nil if obs_hash.blank? # patient may not have this code in the set, or it might be {}
         return obs_hash[:result] if suffix == "_result"
         return Date.parse(obs_hash[:observed_at]) if suffix == "_observed_at"
 

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
@@ -34,7 +35,10 @@ module Renalware
 
     enumerize :marital_status, in: %i(married single divorced widowed)
 
-    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]
+    )
 
     serialize :sex, Gender
 
@@ -87,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
@@ -104,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 }
@@ -122,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?
@@ -162,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/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/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