renalware-core 2.0.0.pre.rc1 → 2.0.0.pre.rc3

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

@@ -3,7 +3,7 @@ require_dependency "renalware/pathology"
 module Renalware
   module Pathology
     class Observation < ApplicationRecord
-      belongs_to :request, class_name: "ObservationRequest", touch: true
+      belongs_to :request, class_name: "ObservationRequest", touch: true, inverse_of: :observations
       belongs_to :description, class_name: "ObservationDescription"
 
       validates :description, presence: true

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

@@ -3,7 +3,10 @@ require_dependency "renalware/pathology"
 module Renalware
   module Pathology
     class ObservationRequest < ApplicationRecord
-      has_many :observations, foreign_key: :request_id
+      has_many :observations,
+               foreign_key: :request_id,
+               inverse_of: :request,
+               dependent: :destroy
       belongs_to :description, class_name: "RequestDescription"
       belongs_to :patient, class_name: "Patient", touch: true
 

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

@@ -0,0 +1,73 @@
+require_dependency "renalware/pathology"
+
+module Renalware
+  module Pathology
+    # A singleton exposing all defined OBX codes as an array of symbols
+    class AllObservationCodes
+      include Singleton
+
+      # Example usage:
+      #   AllObservationCodes.include?(code)
+      def self.include?(code)
+        instance.all.include?(code)
+      end
+
+      def all
+        @all ||= ObservationDescription.order(:code).pluck(:code).map(&:upcase).map(&:to_sym)
+      end
+    end
+
+    # We mix this module into any database-returned jsonb hash of observations
+    # (e.g. CurrentObservationSet.values and Letter.pathology_snapshot)
+    module ObservationSetMethods
+      # Support these syntaxes
+      #   values.hgb # => { result: ... observed_at: ...}
+      #   values.HGB # => { result: ... observed_at: ...}
+      #   values.hgb_result # => 3.3
+      #   values.hgb_observed_at # => "2017-17-01"
+      # So the values has methods corresponding to the entire set of possible
+      # OBX codes, and also methods to reach in and get their result and observed_at date
+      # rubocop:disable Style/MethodMissing
+      def method_missing(method_name, *_args, &_block)
+        code, suffix = method_parts(method_name)
+        return super unless AllObservationCodes.include?(code)
+        observation_hash_or_hash_element_for(code, suffix)
+      end
+      # rubocop:enable Style/MethodMissing
+
+      # From eg hgb_result, returns
+      # [:HGB, "result"]
+      def method_parts(method_name)
+        matches = method_name.to_s.match(/([^_]*)(\w*)/)
+        [matches[1]&.upcase&.to_sym, matches[2]]
+      end
+
+      def observation_hash_or_hash_element_for(code, suffix)
+        obs_hash = self[code]
+        return nil if obs_hash.nil? # the patient may not have this observation in the set
+        return obs_hash[:result] if suffix == "_result"
+        return Date.parse(obs_hash[:observed_at]) if suffix == "_observed_at"
+        obs_hash
+      end
+    end
+
+    class ObservationsJsonbSerializer
+      def self.dump(hash)
+        JSON.parse hash.to_json
+      end
+
+      def self.load(hash)
+        type_check(hash)
+          .with_indifferent_access
+          .extend(ObservationSetMethods)
+      end
+
+      def self.type_check(hash)
+        if hash.nil? then {}
+        elsif hash.is_a?(Hash) then hash
+        else JSON.parse(hash)
+        end
+      end
+    end
+  end
+end

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

@@ -34,6 +34,10 @@ module Renalware
         Requests::HighRiskAlgorithm.new(self).patient_is_high_risk?
       end
 
+      def fetch_current_observation_set
+        current_observation_set || build_current_observation_set
+      end
+
       private
 
       def date_for_algorithms

data/app/models/renalware/pathology/update_current_observations.rb.dead

@@ -0,0 +1,25 @@
+require_dependency "renalware/pathology"
+
+module Renalware
+  module Pathology
+    class UpdateCurrentObservations
+      def call(params)
+        patient = find_patient(params[:patient_id])
+        set = patient.fetch_current_observation_set
+
+        params[:observation_request][:observations_attributes].each do |new_obs|
+          description = ObservationDescription.select(:code).find(new_obs[:description_id])
+          set.values[description.code] = new_obs.slice(:result, :observed_at)
+        end
+
+        set.save!
+      end
+
+      private
+
+      def find_patient(id)
+        Pathology::Patient.find_by(id: id)
+      end
+    end
+  end
+end

data/app/models/renalware/patient.rb

@@ -32,7 +32,7 @@ module Renalware
 
     serialize :sex, Gender
 
-    has_one :current_key_observation_set, class_name: "Pathology::CurrentKeyObservationSet"
+    has_one :current_observation_set, class_name: "Pathology::CurrentObservationSet"
     has_one :current_address, as: :addressable, class_name: "Address"
     has_one :summary, class_name: "Patients::Summary"
     belongs_to :ethnicity, class_name: "Patients::Ethnicity"

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

@@ -2,6 +2,7 @@ module Renalware
   module Patients
     class MDMPatientsQuery
       include ModalityScopes
+      include PatientPathologyScopes
       attr_reader :modality_names, :q, :relation
 
       # modality_names: eg "HD" or "PD"
@@ -19,19 +20,14 @@ module Renalware
         @search ||= begin
           relation
             .extending(ModalityScopes)
-            .extending(Scopes)
-            .with_current_key_pathology
+            .extending(PatientPathologyScopes)
+            .with_current_pathology
             .with_current_modality_matching(modality_names)
             .search(q)
-          # .order("pathology_current_key_observations.hgb_result asc")
         end
       end
 
-      module Scopes
-        def with_current_key_pathology
-          includes(:current_key_observation_set) # .joins(:current_key_observation)
-        end
-      end
+      # `
     end
   end
 end

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

@@ -2,6 +2,7 @@ module Renalware
   module PD
     class MDMPatientsQuery
       include ModalityScopes
+      include PatientPathologyScopes
       MODALITY_NAMES = "PD".freeze
       attr_reader :q, :relation
 
@@ -18,18 +19,13 @@ module Renalware
         @search ||= begin
           relation
             .extending(ModalityScopes)
-            .extending(Scopes)
+            .extending(PatientPathologyScopes)
             .with_current_modality_matching(MODALITY_NAMES)
-            .with_current_key_pathology
+            .with_current_pathology
+            .left_joins(:current_observation_set)
             .search(q)
         end
       end
-
-      module Scopes
-        def with_current_key_pathology
-          includes(:current_key_observation_set) # . joins(:current_key_observation)
-        end
-      end
     end
   end
 end

data/app/models/renalware/renal/low_clearance/mdm_patients_query.rb

@@ -25,7 +25,8 @@ module Renalware
               .extending(PatientPathologyScopes)
               .extending(ModalityScopes)
               .extending(NamedFilterScopes)
-              .with_current_key_pathology
+              .with_current_pathology
+              .left_joins(:current_observation_set)
               .with_current_modality_of_class(LowClearance::ModalityDescription)
               .public_send(named_filter.to_s)
               .search(query)
@@ -46,15 +47,15 @@ module Renalware
           end
 
           def urea
-            where("pathology_current_key_observation_sets.ure_result::float >= 30")
+            where("cast(values->'URE'->>'result' as float) >= 30.0")
           end
 
           def hgb_low
-            where("pathology_current_key_observation_sets.hgb_result::float < 100")
+            where("cast(values->'HGB'->>'result' as float) < 100.0")
           end
 
           def hgb_high
-            where("pathology_current_key_observation_sets.hgb_result::float > 130")
+            where("cast(values->'HGB'->>'result' as float) > 130.0")
           end
         end
       end

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

@@ -6,6 +6,7 @@ module Renalware
     #  different filter groups
     class MDMPatientsQuery
       include ModalityScopes
+      include PatientPathologyScopes
       MODALITY_NAMES = ["Transplant"].freeze
       attr_reader :q, :relation, :named_filter
 
@@ -23,10 +24,12 @@ module Renalware
       def search
         @search ||= begin
           relation
-            .includes(:current_key_observation_set)
             .extending(ModalityScopes)
+            .extending(PatientPathologyScopes)
             .extending(NamedFilterScopes)
             .with_current_modality_matching(MODALITY_NAMES)
+            .with_current_pathology
+            .left_joins(:current_observation_set)
             .public_send(named_filter.to_s)
             .search(q)
         end

data/app/presenters/renalware/admissions/consult_presenter.rb

@@ -16,8 +16,12 @@ module Renalware
         @patient ||= Renalware::PatientPresenter.new(__getobj__.patient)
       end
 
-      def unit_and_ward
-        [hospital_unit&.unit_code, hospital_ward&.name].compact.join("/")
+      def location
+        [
+          consult_site&.name,
+          hospital_ward&.name,
+          other_site_or_ward
+        ].compact.join(", ")
       end
 
       def patient_name

data/app/presenters/renalware/dashboard/dashboard_presenter.rb

@@ -10,10 +10,6 @@ module Renalware
 
       attr_reader :user
 
-      def title
-        I18n.t("renalware.dashboard.dashboards.title", name: @user.username&.capitalize)
-      end
-
       def bookmarks
         @bookmarks ||= begin
           Patients.cast_user(user)

data/app/presenters/renalware/hd/patient_presenter.rb

@@ -22,6 +22,12 @@ module Renalware
         hd_sessions.eager_load(:hospital_unit).where(type: "Renalware::HD::Session::Closed")
       end
 
+      def current_observation_set
+        @current_observation_set ||= begin
+          Renalware::Pathology::ObservationSetPresenter.new(__getobj__.current_observation_set)
+        end
+      end
+
       private
 
       def hd_profile

data/app/presenters/renalware/mdm_patient_presenter.rb

@@ -1,18 +1,14 @@
 module Renalware
   # Presenter formatting a single patient for use behind any MDM Patients listing.
   class MDMPatientPresenter < PatientPresenter
-    delegate :hgb_result,
-             :hgb_observed_at,
-             :ure_result,
-             :ure_observed_at,
-             :cre_result,
-             :cre_observed_at,
-             :mdrd_result,
-             :mdrd_observed_at,
-             to: :current_key_observation_set, allow_nil: true
-
     def esrf_date
       Renalware::Renal.cast_patient(__getobj__).profile&.esrf_on
     end
+
+    def current_observation_set
+      @current_observation_set ||= begin
+        Renalware::Pathology::ObservationSetPresenter.new(__getobj__.current_observation_set)
+      end
+    end
   end
 end

data/app/presenters/renalware/pathology/observation_set_presenter.rb

@@ -0,0 +1,57 @@
+require_dependency "renalware/pathology"
+require_dependency "attr_extras"
+
+module Renalware
+  module Pathology
+    class ObservationSetPresenter < DumbDelegator
+      class Observation
+        attr_reader_initialize [:code, :description, :result, :observed_at]
+      end
+
+      def method_missing(method_name, **args, &_block)
+        return if __getobj__.nil?
+        vals = __getobj__.values
+        vals.public_send(method_name)
+      end
+
+      def respond_to_missing?(method_name, _include_private = false)
+        (values.present? && values.respond_to?(method_name)) || super
+      end
+
+      def each_observation
+        return unless block_given?
+        __getobj__.values.sort.sort.each do |code, observation_hash|
+          observation = build_observation(
+            code: code,
+            observation_hash: observation_hash,
+            with_description: true
+          )
+          yield observation
+        end
+      end
+
+      private
+
+      def build_observation(code:, observation_hash:, with_description: false)
+        Observation.new(
+          code: code,
+          result: observation_hash["result"],
+          observed_at: ::Time.zone.parse(observation_hash["observed_at"]),
+          description: with_description ? description_for(code) : nil
+        )
+      end
+
+      def description_for(code)
+        observation_description_map.fetch(code, "#{code} (no description found!)")
+      end
+
+      def observation_description_map
+        @observation_description_map ||= begin
+          ::Renalware::Pathology::ObservationDescription
+            .pluck(:code, :name)
+            .each_with_object({}) { |desc, hash| hash[desc.first] = desc.last }
+        end
+      end
+    end
+  end
+end

data/app/presenters/renalware/pathology/observations_diff.rb

@@ -1,37 +1,123 @@
 require "attr_extras"
 require_dependency "renalware/pathology"
 
-# Uses Rails 5 `render anywhere` feature.
+# Compares two hashes of pathology observations (OBXs).
+# Used for example in a Letter, where a snapshot of pathology is stored on the letter,
+# but when the letter we compare the snapshot to the latest hash in the jsonb column
+# CurrentObserverationSet#values to see if there are newer results that the user might want
+# to bring into the letter.
+#
+# NB: uses Rails 5 `render anywhere` feature.
 module Renalware
   module Pathology
     class ObservationsDiff
-      def initialize(patient:, between_dates:, descriptions:)
-        @patient = patient
-        @descriptions = descriptions
-        @between_dates = Array(between_dates)
-        if between_dates.length != 2
-          raise ArgumentError, "between_dates argument must be an array of 2 dates"
-        end
+      pattr_initialize [:patient!, :observation_set_a!, :observation_set_b!, :descriptions!]
+
+      def changes?
+        @changes
       end
 
       def to_html
         render
       end
 
+      class Observation
+        delegate :any?, :to_h, to: :hash
+
+        def initialize(hash)
+          @hash = hash
+        end
+
+        def result
+          hash.fetch(:result, 0)
+        end
+
+        def observed_at
+          Time.zone.parse(hash.fetch(:observed_at, "1970-01-01"))
+        end
+
+        def supercedes?(other)
+          (observed_at > other.observed_at) ||
+            ((observed_at == other.observed_at) && result > other.result)
+        end
+
+        private
+
+        attr_reader :hash
+      end
+
+      # Given two hashes like this
+      # {
+      #   HGB: { result: 2.1, observed_at: "2017-12-12 00:01:01"},
+      #   CRE: { result: 9, observed_at: "2017-12-12 00:01:01"}
+      # }
+      # {
+      #   HGB: { result: 1.0, observed_at: "2018-12-12 00:01:01"}, # changed
+      #   CRE: { result: 1.1, observed_at: "2017-12-11 00:01:01"}, # no change!
+      #   PTH: { result: 1.1, observed_at: "2017-12-11 00:01:01"}  # new!
+      # }
+      # Return a hash that looks like this
+      # {
+      #   HGB: [
+      #     { result: 2.1, observed_at: "2017-12-12 00:01:01"}, # original
+      #     { result: 1.0, observed_at: "2018-12-12 00:01:01"}, # changed
+      #     -1.1 # digg
+      #   ],
+      #   CRE: [
+      #     { result: 9, observed_at: "2017-12-12 00:01:01"},
+      #     nil, # no new value
+      #     nil # no change
+      #   ],
+      #   PTH: [
+      #     nil, # no original
+      #     { result: 1.1, observed_at: "2017-12-11 00:01:01"}  # new!
+      #     1.1
+      #  ]
+      # }
+      # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
       def to_h
-        @to_h ||= build_diff_hash
+        return {} if observation_set_a.blank? && observation_set_a.blank?
+
+        filter_observations
+
+        description_codes.each_with_object({}) do |code, hash|
+          obs_a = Observation.new(observation_set_a.fetch(code, {}))
+          obs_b = Observation.new(observation_set_b.fetch(code, {}))
+
+          arr = Array.new(3)
+          arr[0] = obs_a if obs_a.any?
+
+          if obs_b.supercedes?(obs_a)
+            arr[1] = obs_b
+            arr[2] = obs_b.result.to_f - obs_a.result.to_f
+          end
+
+          hash[code] = arr
+        end
       end
+      # rubocop:enable Metrics/AbcSize,Metrics/MethodLength
 
       private
 
-      attr_reader :patient, :between_dates, :descriptions
+      def filter_observations
+        filter_observations_by_descriptions(observation_set_a)
+        filter_observations_by_descriptions(observation_set_b)
+      end
+
+      def filter_observations_by_descriptions(observations)
+        observations.select!{ |code, _obs| description_codes.include?(code.to_sym) }
+      end
+
+      def description_codes
+        @description_codes ||= descriptions.map(&:code).map(&:to_sym)
+      end
 
       def render
         renderer.render(
           partial: "renalware/pathology/observations/diff",
           locals: {
             patient: patient,
-            diffs: to_h
+            diff: self
           }
         )
       end
@@ -39,72 +125,6 @@ module Renalware
       def renderer
         ApplicationController.renderer
       end
-
-      def observations1
-        @observations1 ||= begin
-          observations_in_daterange(Time.zone.at(1)..between_dates.first)
-        end
-      end
-
-      def observations2
-        @observations2 ||= begin
-          obs1_ids = observations1.map(&:id)
-          observations_in_daterange(between_dates.first..between_dates.last)
-            .reject{ |obs| obs1_ids.include?(obs.id) }
-        end
-      end
-
-      def observations_in_daterange(range)
-        Pathology::CurrentObservationsForDescriptionsQuery.new(
-          patient: patient,
-          descriptions: descriptions
-        ).call.where(observed_at: range).reject{ |obs| obs.id.nil? }.to_a
-      end
-
-      class ObsWithDiff
-        include Virtus.model
-        attribute :observed_at
-        attribute :result, Float
-        attribute :result_diff
-
-        def result_diff(more_recent)
-          more_recent && result && (result.to_f - more_recent.result&.to_f)
-        end
-      end
-
-      # Build
-      # [
-      #   { "HGB" => [
-      #       { observed_at:, value: },
-      #       { observed_at:, value:, diff: }
-      #     ]
-      #   }
-      # ]
-      # Note this could be done with a SQL window function
-      # rubocop:disable Metrics/MethodLength
-      # rubocop:disable Metrics/AbcSize
-      def build_diff_hash
-        result = {}
-
-        observations1.each do |older_obs|
-          result[older_obs.description.code] = [
-            ObsWithDiff.new(older_obs.attributes.symbolize_keys),
-            nil
-          ]
-        end
-
-        observations2.each do |newer_obs|
-          arr = result[newer_obs.description.code] || Array(2)
-          older_obs = arr[0]
-          args = newer_obs.attributes.symbolize_keys
-                                     .merge(result_diff: older_obs&.result_diff(newer_obs))
-          arr[1] = ObsWithDiff.new(args)
-        end
-
-        result
-      end
-      # rubocop:enable Metrics/MethodLength Metrics/AbcSize
-      # rubocop:enable Metrics/AbcSize
     end
   end
 end