renalware-core 2.0.113 → 2.0.115

data/app/models/renalware/hd/scheduling/diary.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/hd"
+
+# A Diary is the schedule of HD Station/Patients assignments for one week for a particular unit.
+# A Diary is split into Periods (eg. am pm eve), and each Period has a matrix of slots
+# Imagine Days eg 1 to 6 on the X axis and Stations on the Y axis, and into each 'slot' we
+# put a patient.
+# A patient can only be in one slot in any period.
+#
+# Do not create instances of this class explicity, always use the STI sub classes eg MasterDiary.
+module Renalware
+  module HD
+    module Scheduling
+      class Diary < ApplicationRecord
+        include Accountable
+        self.table_name = :hd_diaries
+        has_many :slots, class_name: "DiarySlot", dependent: :restrict_with_exception
+        belongs_to :hospital_unit, class_name: "Hospitals::Unit"
+        has_many :patients,
+                 through: :slots, class_name: "Renalware::HD::Patient",
+                 dependent: :restrict_with_exception
+        validates :hospital_unit_id, presence: true
+        validates :master, inclusion: { in: [true, false], allow_nil: true }
+        composed_of :week,
+                    mapping: [%w(week_number week_number), %w(year year)],
+                    constructor: lambda { |week_number, year|
+                      WeekPeriod.new(week_number: week_number, year: year)
+                    }
+
+        def self.policy_class
+          DiaryPolicy
+        end
+
+        # Searchs the object graph rather than a SQL search
+        def slot_for(diurnal_period_code_id, station_id, day_of_week, valid_from: nil)
+          slots.find do |slot|
+            found = slot.diurnal_period_code_id == diurnal_period_code_id &&
+                    slot.station_id == station_id &&
+                    slot.day_of_week == day_of_week
+
+            # This applies to master diaries only really, where we only
+            # show recurring slots if they were created before the timeframe
+            # of the current week being viewed.
+            if found && valid_from
+              found = (slot.created_at <= valid_from.end_of_week)
+            end
+            found
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/hd/scheduling/diary_housekeeping_job.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "renalware/hd"
+
+# A cron job creates this delayed job, which does the following:
+# For all Weekly Diaries in the past, plus this week
+# for each day that is in the past
+# mark any slots in the weekly diary as archived
+# and where the weekly diary is inheriting slots from the master diary
+# create corresponding slots in the weekly diary (ie migrate those slots from master to weekly)
+# and archive them.
+# No slots before the current day should be touched
+module Renalware
+  module HD
+    module Scheduling
+      DiaryHousekeepingJob = Struct.new(:up_until) do
+        def max_attempts
+          1
+        end
+
+        def queue_name
+          "hd_diary_houskeeping"
+        end
+
+        def priority
+          5 # medium
+        end
+
+        def destroy_failed_jobs?
+          true
+        end
+
+        # :reek:UtilityFunction
+        def perform
+          up_until ||= Time.zone.today - 1.day
+          up_until = up_until.to_date
+          create_missing_weekly_diaries
+          move_elapsed_master_slots_into_weekly_slot_equivalent
+          archive_old_weekly_slots(up_until)
+        end
+
+        private
+
+        # Just inc case there are some missing weekly diaries
+        def create_missing_weekly_diaries
+          args = ArchiveArguments.new
+          Hospitals::Unit.hd_sites.each do |unit|
+            DiaryRange.new(
+              from_week_period: args.from_week_period,
+              to_week_period: args.to_week_period,
+              unit: unit
+            ).create_missing_weekly_diaries(by: User.first)
+          end
+        end
+
+        # Copy any master slots that are now in the past (as of midnight Sunday just gone) and
+        # which do not already have a weekly slot overriding the master, into weekly slots.
+        # This is to stop changes to the master diary affecting diary history.
+        # This executes a SQL view to do the dirty work. It references a SQL view called
+        # hd_diary_matrix to help it to decide which master slots to copy to the weekly diary.
+        # That view could be useful for other things. We could in fact build the diary UI from it.
+        def move_elapsed_master_slots_into_weekly_slot_equivalent
+          Rails.logger.debug("DEBUG: SELECT renalware.hd_diary_archive_elapsed_master_slots()")
+          conn = ActiveRecord::Base.connection
+          conn.execute("SELECT renalware.hd_diary_archive_elapsed_master_slots()")
+        end
+
+        # Flag elapsed slots as archived. Principally this will help us to stop them from being
+        # changed.
+        def archive_old_weekly_slots(up_until)
+          slots = DiarySlot
+            .unarchived
+            .joins(:diary)
+            .where(hd_diaries: { year: up_until.year, week_number: up_until.cweek })
+            .where(day_of_week: up_until.cwday)
+
+          ids = slots.pluck(:id)
+          Rails.logger.info("Archiving #{ids.length} slots up_until #{up_until} with ids #{ids}")
+          slots.update_all(archived: true, archived_at: Time.zone.now)
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/hd/scheduling/diary_range.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "renalware/hd"
+require "renalware/week_period"
+require "attr_extras"
+
+module Renalware
+  module HD
+    module Scheduling
+      # Represents a range of WeekPeriods and their diaries for a hospital unit
+      class DiaryRange
+        pattr_initialize [:from_week_period!, :to_week_period!, :unit!]
+
+        # If there are any missing weekly diaries in the date range, create them
+        def create_missing_weekly_diaries(by:)
+          week_periods_in_range.each do |period|
+            WeeklyDiary.find_or_create_by!(
+              hospital_unit_id: unit.id,
+              week_number: period.week_number,
+              year: period.year
+            ) do |diary|
+              log_weekly_diary_creation(period)
+              diary.master_diary = master_diary_for(unit, by)
+              diary.by = by
+            end
+          end
+        end
+
+        def log_weekly_diary_creation(period)
+          Rails.logger.debug(
+            "DEBUG: Creating weekly diary for unit #{unit.id} period "\
+            "#{period.week_number}/#{period.year}"
+          )
+        end
+
+        def from_date
+          from_week_period.date_on_first_day_of_week
+        end
+
+        def to_date
+          to_week_period.date_on_first_day_of_week
+        end
+
+        private
+
+        # Returns an array of WeekPeriods for each cwyear and cweek in the date range.
+        def week_periods_in_range
+          @week_periods_in_range ||= begin
+            # The array in the uniq block here serves to filter the date range. It filters out
+            # just the dates representing the first day of each unique week/year.
+            mondays_in_date_range = (from_date..to_date).uniq { |dt| [dt.cwyear, dt.cweek] }
+            # Now map the dates (one per week) into WeekPeriods
+            mondays_in_date_range.map do |date|
+              WeekPeriod.new(week_number: date.cweek, year: date.cwyear)
+            end
+          end
+        end
+
+        def master_diary_for(unit, by)
+          MasterDiary.find_or_create_by!(hospital_unit_id: unit.id) do |diary|
+            Rails.logger.debug "DEBUG: Creating master diary for unit #{unit.id}"
+            diary.master = true
+            diary.by = by
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/hd/scheduling/diary_slot.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/hd"
+
+module Renalware
+  module HD
+    module Scheduling
+      class DiarySlot < ApplicationRecord
+        self.table_name = :hd_diary_slots
+        # Changing to_ary from private to public here is a hack required to remove a SimpleDelgator
+        # warning in eg Renalware::HD::Scheduling::WeeklyDiary::WeeklySlotDecorator:
+        #
+        #   `respond_to?': delegator does not forward private method #to_ary
+        #
+        # Yielding a slot from DiaryPresenter to the view seems to want to call #to_ary on it, (have
+        # not looked into why) and as the slot is wrapped in a decorator using SimpleDelegator,
+        # SimpleDelegatr complains it can't delegate to a private method.
+        # An alternative is to define the following in each Slot decorator
+        #
+        #    def respond_to?(method, include_private = false)
+        #      return false if method == :to_ary
+        #      super
+        #    end
+        #
+        #  or to use method_missnig instead of SimpleDelegator in Slot Decorators.
+        #
+        public :to_ary
+
+        # Virtual attribute used on a form to determine what action as preformed on the slot
+        attr_accessor :change_type
+        # Virtual to help the prepopulation of select2 with the offending patient if an error
+        attr_accessor :patient_ids
+
+        include Accountable
+        belongs_to :diary, class_name: "Renalware::HD::Scheduling::Diary", touch: true
+        belongs_to :patient, touch: true
+        belongs_to :station, class_name: "Renalware::HD::Station"
+        belongs_to :diurnal_period_code
+
+        validates :diary, presence: true
+        validates :patient, presence: true
+        validates :station, presence: true
+        validates :diurnal_period_code, presence: true
+        validates :day_of_week, presence: true, inclusion: { in: 1..7 }
+
+        scope :weekly, -> { joins(:diary).where(hd_diaries: { master: false }) }
+        scope :archived, -> { weekly.where(archived: true) }
+        scope :unarchived, -> { weekly.where(archived: false) }
+
+        # A patient can only be assigned to one station in any period (e.g. am)/day combination
+        # for a diary. I.e. they can't be on two stations on Monday morning.
+        validates :patient_id,
+                  uniqueness: { scope: [:diary, :diurnal_period_code, :day_of_week] }
+
+        # Scoped to a diary, the combination of day + station + diurnal_period is unique
+        validates :diurnal_period_code_id,
+                  uniqueness: { scope: [:diary, :station_id, :day_of_week] }
+
+        delegate :id, to: :diary, prefix: true
+
+        def self.policy_class
+          DiaryPolicy
+        end
+
+        def on_master_diary?
+          diary&.master?
+        end
+
+        def description
+          period = diurnal_period_code.code.upcase # e.g. AM
+          if diary.master
+            "Recurring every #{day_of_week_name} #{period}"
+          else
+            "This week only on #{day_of_week_name} #{period}"
+          end
+        end
+
+        def day_of_week_name
+          Time::DAYS_INTO_WEEK.keys[day_of_week - 1].capitalize
+        end
+
+        def cell_id
+          "#{diurnal_period_code&.id}-#{station&.id}-#{day_of_week}"
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/hd/scheduling/find_or_create_diary_by_week_query.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/hd"
+require "renalware/week_period"
+##
+# Returns a hospital unit's diary for the requested week (passed to #new as a WeekPeriod
+# value object).
+#
+module Renalware
+  module HD
+    module Scheduling
+      class FindOrCreateDiaryByWeekQuery
+        attr_reader :unit_id, :period, :by, :relation
+
+        def initialize(unit_id:, week_period:, by:, relation: WeeklyDiary.all)
+          @relation = relation
+          @period = week_period
+          @unit_id = unit_id
+          @by = by
+        end
+
+        def call
+          find_or_create_diary
+        end
+
+        private
+
+        # Find the diary for the current unit/week/year, or, if for example if a user wants to fill
+        # next week's diary and it does not yet exist, create it
+        # NB we _always_ return a diary from this method - whether it is found or built just-in-time
+        def find_or_create_diary
+          attrs = {
+            hospital_unit_id: unit_id,
+            week_number: period.week_number,
+            year: period.year,
+            master: false
+          }
+          relation.find_by(**attrs) || build_diary(**attrs)
+        end
+
+        # Create a new Weekly diary for the current week/year/unit
+        # Add in DiaryPeriods for each currently defined diurnal period eg am pm eve
+        def build_diary(attrs)
+          master_diary = FindOrCreateMasterDiary.for_unit(unit_id, by)
+          diary = WeeklyDiary.create!(**attrs, by: by, master_diary: master_diary)
+          # Reload the diary using the supplied relation (might be egager_loads etc)
+          relation.find(diary.id)
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/hd/scheduling/find_or_create_master_diary.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Renalware
+  module HD
+    module Scheduling
+      class FindOrCreateMasterDiary
+        attr_reader :unit_id, :user
+
+        def self.for_unit(unit_id, user)
+          new(unit_id, user).call
+        end
+
+        def initialize(unit_id, user)
+          @unit_id = unit_id
+          @user = user
+        end
+
+        def call
+          MasterDiary.find_or_initialize_by(hospital_unit_id: unit_id).tap do |master|
+            master.by = user
+            master.save!
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/hd/scheduling/master_diary.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/hd"
+
+module Renalware
+  module HD
+    module Scheduling
+      class MasterDiary < Diary
+        # Overwrite the existing master attribute to ensure it defaults to true
+        attribute :master, :boolean, default: true
+        validates :hospital_unit_id, uniqueness: true
+        has_many :weekly_diaries, class_name: "WeeklyDiary"
+        # While our DB constraints could check for the string
+        # "Renalware::HD::Scheduling::MasterDiary" in the type column, this feels a bit fragile, so
+        # instead a MasterDiary must have a corresponding
+        # master = TRUE column
+        validates :master, inclusion: { in: [true], allow_nil: false }
+
+        class MasterSlotDecorator < SimpleDelegator
+          def master?
+            true
+          end
+        end
+
+        def decorate_slot(slot)
+          MasterSlotDecorator.new(slot)
+        end
+
+        def slot_for(*args)
+          (slot = super) && decorate_slot(slot)
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/hd/scheduling/weekly_diary.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/hd"
+
+module Renalware
+  module HD
+    module Scheduling
+      class WeeklyDiary < Diary
+        # Overwrite the existing master attribute to ensure it defaults to false
+        attribute :master, :boolean, default: false
+        belongs_to :master_diary, class_name: "Renalware::HD::Scheduling::MasterDiary"
+        validates :week_number,
+                  presence: true,
+                  uniqueness: { scope: [:year, :hospital_unit_id] },
+                  inclusion: { in: 1..53 }
+        validates :year, presence: true
+        validates :master, inclusion: { in: [false], allow_nil: false }
+        validates :master_diary, presence: true
+        delegate :to_s, to: :week
+        scope :ordered, -> { order(year: :desc, week_number: :desc) }
+
+        def applies_to_current_week?
+          today = Time.zone.today
+          [today.cweek, today.year] == [week.week_number, week.year]
+        end
+
+        def archived?
+          false
+        end
+
+        class WeeklySlotDecorator < SimpleDelegator
+          def master?
+            false
+          end
+        end
+
+        def decorate_slot(slot)
+          WeeklySlotDecorator.new(slot)
+        end
+
+        def slot_for(*args)
+          (slot = super) && decorate_slot(slot)
+        end
+      end
+    end
+  end
+end

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

@@ -3,14 +3,14 @@
 require_dependency "renalware/pathology"
 
 #
-# When subscribed to HL7 `message_arrived` messages, gets notified of incoming HL7 messages
+# When subscribed to HL7 `oru_message_arrived` messages, gets notified of incoming HL7 messages
 # and creates the observations contained therein provided the patient exists.
 #
 module Renalware
   module Pathology
     class MessageListener
       # Note: We are already inside a transaction here
-      def message_arrived(hl7_message:, **)
+      def oru_message_arrived(hl7_message:, **)
         pathology_params = parse_pathology_params(hl7_message)
         create_observation_requests_and_their_child_observations_from(pathology_params)
         #

data/app/models/renalware/pathology/requests/global_rule/latest_crf_older_than_weeks.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/pathology/requests"
+
+module Renalware
+  module Pathology
+    module Requests
+      class GlobalRule
+        class LatestCRFOlderThanWeeks < GlobalRule
+          validates :param_comparison_value, presence: true
+
+          # Returns true if the patient has a transplant registration with a latest CRF date
+          # older than <param_comparison_value> weeks ago.
+          def observation_required_for_patient?(patient, date)
+            registration = registration_for(patient)
+            return false unless registration
+
+            latest_crf_date = registration.document.crf.latest.recorded_on
+            return false if latest_crf_date.blank?
+
+            max_crf_date = date - param_comparison_value.to_i.weeks
+            latest_crf_date < max_crf_date
+          end
+
+          def to_s
+            "latest CRF older than #{param_comparison_value} weeks"
+          end
+
+          private
+
+          def registration_for(patient)
+            Transplants::Registration.for_patient(patient).first
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/pathology/requests/global_rule/patient_is_diabetic.rb

@@ -22,7 +22,7 @@ module Renalware
           end
 
           def param_comparison_boolean
-            param_comparison_value == "true"
+            param_comparison_value&.casecmp("true") == 0
           end
         end
       end

data/app/models/renalware/patient.rb

@@ -58,7 +58,7 @@ module Renalware
     has_many :exit_site_infections, class_name: "PD::ExitSiteInfection"
     has_many :peritonitis_episodes, class_name: "PD::PeritonitisEpisode"
     has_many :pd_regimes, class_name: "PD::Regime"
-    has_many :problems, class_name: "Problems::Problem"
+    has_many :problems, -> { ordered }, class_name: "Problems::Problem"
     has_many :prescriptions, class_name: "Medications::Prescription"
     has_many :drugs, through: :prescriptions
     has_many :medication_routes, through: :prescriptions, class_name: "Medications::MedicationRoute"

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/patients"
+
+module Renalware
+  module Patients
+    class Abridgement < ApplicationRecord
+      self.table_name = "patient_master_index"
+      validates :hospital_number, presence: true
+      validates :given_name, presence: true
+      validates :family_name, presence: true
+
+      def self.policy_class
+        ::Renalware::BasePolicy
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/patients"
+
+module Renalware
+  module Patients
+    class AbridgementSearchForm
+      include ActiveModel::Model
+      attr_accessor :criteria
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/patients"
+
+module Renalware
+  module Patients
+    module Ingestion
+      class Command
+        attr_reader :message
+
+        def initialize(message)
+          @message = message
+        end
+
+        def self.for(message)
+          CommandFactory.new.for(message)
+        end
+
+        def call
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end