renalware-core 2.0.149 → 2.0.156

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

@@ -6,15 +6,14 @@ module Renalware
   module Pathology
     class ObservationDescription < ApplicationRecord
       belongs_to :measurement_unit
+      belongs_to :suggested_measurement_unit, class_name: "MeasurementUnit"
+
       has_many :observations,
                class_name: "Pathology::Observation",
                inverse_of: :description,
                dependent: :restrict_with_exception
-      has_many :code_group_memberships,
-               foreign_key: :observation_description_id,
-               dependent: :destroy
-      has_many :code_groups,
-               through: :code_group_memberships
+      has_many :code_group_memberships, dependent: :destroy
+      has_many :code_groups, through: :code_group_memberships
 
       scope :in_display_order, lambda {
         where("display_group is not null and display_order is not null")
@@ -24,6 +23,10 @@ module Renalware
       enum rr_type: { rr_type_simple: 0, rr_type_interpretation: 1 }
       enum rr_coding_standard: { ukrr: 0, pv: 1 }
 
+      validates :lower_threshold, numericality: { allow_nil: true }
+      validates :upper_threshold, numericality: { allow_nil: true }
+      validate :lower_threshold_lteq_upper_threshold
+
       def self.for(codes)
         ObservationDescriptionsByCodeQuery.new(codes: codes).call
       end
@@ -31,6 +34,21 @@ module Renalware
       def to_s
         code
       end
+
+      def self.policy_class
+        BasePolicy
+      end
+
+      private
+
+      def lower_threshold_lteq_upper_threshold
+        return if lower_threshold.blank?
+        return if upper_threshold.blank?
+
+        if lower_threshold.to_f >= upper_threshold.to_f
+          errors.add(:lower_threshold, "must be less than the upper threshold")
+        end
+      end
     end
   end
 end

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

@@ -6,7 +6,7 @@ require "sql/indexed_case_stmt"
 module Renalware
   module Pathology
     class ObservationDescriptionsByCodeQuery
-      def initialize(relation: ObservationDescription, codes:)
+      def initialize(codes:, relation: ObservationDescription)
         @relation = relation
         @codes = Array(codes)
       end

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

@@ -8,8 +8,15 @@ module Renalware
     # that can be persisted by ObservationRequest.
     # Note:
     # - A message can have multiple observation_requests, each with its own observations.
-    # - This class could be removed and a Builder class used to create the database models
-    #   directly - this would remove the extra level of indirection that this class introduces.
+    # - We create any missing *_description or measurement_unit rows - ie if a new OBR 'ABC' arrives
+    # - from the lab and we have not seen it before, we create a corresponding
+    # - observation_request_description first. Likewise for previously unseen OBX codes we will
+    # - create a new observation_description in realtime. If a OBC has a unit we have not seen
+    #   before eg MW (Megawatts!) we create that also. In this way the pathology 'metadata' is
+    #   keep up to date based on what the lab/send.
+    #
+    # Note this class could be removed and a Builder class used to create the database models
+    # directly - this would remove the extra level of indirection that this class introduces.
     class ObservationRequestsAttributesBuilder
       DEFAULT_REQUESTOR_NAME = "UNKNOWN"
       delegate :patient_identification, :observation_requests, to: :hl7_message
@@ -53,6 +60,10 @@ module Renalware
         @request_params ||= build_observation_request_params
       end
 
+      # Returns an array of hashes each containing an observation_request entry
+      # that wil be used to create associatwd database rows
+      # e.g. [ { observation_request: {..} }, {...} ]
+      #
       # rubocop:disable Metrics/MethodLength
       def build_observation_request_params
         requests.each_with_object([]) do |request, arr|
@@ -74,12 +85,19 @@ module Renalware
       end
       # rubocop:enable Metrics/MethodLength
 
+      # Returns an array of hashes where each has the attributes used to create a new
+      # pathology_observation in the datbase when passed inside the observation_request hash]
+      # built in build_observation_request_params { observations_attributes: [..] }
       # rubocop:disable Metrics/MethodLength
       def build_observations_params(request)
         request.observations.map do |observation|
+          unit = if observation.units.present?
+                   MeasurementUnit.find_or_create_by!(name: observation.units)
+                 end
           observation_description = find_observation_description(
             code: observation.identifier,
-            name: observation.name
+            name: observation.name,
+            measurement_unit: unit
           )
           next unless validate_observation(observation, observation_description)
 
@@ -103,8 +121,30 @@ module Renalware
         raise MissingRequestDescriptionError, code
       end
 
-      def find_observation_description(code:, name:)
-        ObservationDescription.find_or_create_by!(code: code) { |desc| desc.name = name || code }
+      # Finds an observation_description or creates one if not found.
+      # Makes sure the description.measurement_unit, if unset, is set to the HL7 unit (eg mg) if
+      # passed in. Also set the suggested_measurement_unit, which may be different to the
+      # observation_description if was set uncorrectly at some point.
+      # The idea of suggested_measurement_unit is that it always updated dynamically if missing,
+      # whereas measurement_unit is only updated if missing. This is to cope with the case where
+      # the units of an OBX changes (eg by a factor of 10 as HB was a while back at KCH); in this
+      # instance we only update the suggested_measurement_unit so its clear(ish) what the correct
+      # value should be.
+      def find_observation_description(code:, name:, measurement_unit:)
+        created_jit = false
+        desc = ObservationDescription.find_or_create_by!(code: code) do |desc|
+          desc.name = name || code
+          desc.measurement_unit = measurement_unit
+          desc.suggested_measurement_unit = measurement_unit
+          created_jit = true
+        end
+
+        if created_jit == false && measurement_unit.present?
+          desc.measurement_unit ||= measurement_unit
+          desc.suggested_measurement_unit = measurement_unit
+          desc.save! if desc.changed?
+        end
+        desc
       rescue ActiveRecord::RecordNotFound
         raise MissingObservationDescriptionError, code
       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/pathology/observations_within_date_range_query.rb

@@ -8,7 +8,7 @@ module Renalware
     # the specified date range.
     #
     class ObservationsWithinDateRangeQuery
-      def initialize(relation: Observation.all, date_range:)
+      def initialize(date_range:, relation: Observation.all)
         @relation = relation
         @date_range = date_range
       end

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
@@ -53,8 +54,8 @@ module Renalware
     has_many :alerts, class_name: "Patients::Alert"
     has_one :worry, class_name: "Patients::Worry"
 
-    belongs_to :first_cause, class_name: "Deaths::Cause", foreign_key: :first_cause_id
-    belongs_to :second_cause, class_name: "Deaths::Cause", foreign_key: :second_cause_id
+    belongs_to :first_cause, class_name: "Deaths::Cause"
+    belongs_to :second_cause, class_name: "Deaths::Cause"
 
     belongs_to :primary_care_physician, class_name: "Patients::PrimaryCarePhysician"
     belongs_to :practice, class_name: "Patients::Practice"
@@ -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/bookmark.rb

@@ -7,9 +7,9 @@ module Renalware
     class Bookmark < ApplicationRecord
       acts_as_paranoid
 
-      belongs_to :user, class_name: "Renalware::Patients::User", foreign_key: :user_id
+      belongs_to :user, class_name: "Renalware::Patients::User"
       # No touch required on patient
-      belongs_to :patient, class_name: "Renalware::Patient", foreign_key: :patient_id
+      belongs_to :patient, class_name: "Renalware::Patient"
 
       validates :patient, presence: true
       validates :user, 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/mdm_menu.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Renalware
+  module Patients
+    # Queries for and stores in a class variable the list of MDM 'scopes' to use when building
+    # the MDM menu. An example of a scope is "transplant" or "low_clearance".
+    # If you make changes to the system_view_metadata table to add/edit/remove a scope,
+    # you will need to restart the app for changes to to reflect in the menu. It is done this
+    # way as a changes are rare and we want to avoid running this query too many times.
+    # I think it will run once per procethread
+    class MDMMenu
+      thread_cattr_accessor :cached_items
+
+      def self.items
+        return cached_items if cached_items
+
+        self.cached_items = array_of_distinct_scopes_for_all_mdm_list_views
+        cached_items
+      end
+
+      def self.array_of_distinct_scopes_for_all_mdm_list_views
+        Rails.logger.info "#### Loading MDM scope names! ####"
+        scopes = Renalware::System::ViewMetadata
+          .distinct("scope")
+          .where(category: :mdm)
+          .pluck(:scope)
+
+        remove_invalid_scope_names_that_could_break_menu_rendering(scopes)
+      end
+
+      # Only accept MDM scopes names that are simple lower case underscored
+      # strings eg "my_view_name".
+      def self.remove_invalid_scope_names_that_could_break_menu_rendering(scopes)
+        scopes.select { |scope| scope.match?(/^[a-z0-9_]*$/) }
+      end
+
+      private_class_method :array_of_distinct_scopes_for_all_mdm_list_views
+      private_class_method :cached_items
+    end
+  end
+end

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

@@ -8,7 +8,7 @@ module Renalware
       attr_reader :modality_names, :q, :relation
 
       # modality_names: eg "HD" or "PD"
-      def initialize(relation: Patient.all, q:, modality_names:)
+      def initialize(q:, modality_names:, relation: Patient.all)
         @modality_names = modality_names
         @q = q
         @relation = relation

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/search_query.rb

@@ -18,7 +18,7 @@ module Renalware
       # FIELDS = %i(id family_name given_name nhs_number).freeze
       attr_reader :term, :scope
 
-      def initialize(scope: Patient.all, term:)
+      def initialize(term:, scope: Patient.all)
         @term = term
         @scope = scope
       end

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

@@ -14,7 +14,6 @@ module Renalware
 
       belongs_to :patient,
                  class_name: "Renalware::Patient",
-                 foreign_key: :patient_id,
                  touch: true
 
       validates :patient, presence: true, uniqueness: true

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