renalware-core 2.0.0.pre.beta9 → 2.0.0.pre.beta10

data/app/models/renalware/admissions/consult.rb

@@ -0,0 +1,25 @@
+require_dependency "renalware/admissions"
+
+module Renalware
+  module Admissions
+    class Consult < ApplicationRecord
+      include Accountable
+      extend Enumerize
+      acts_as_paranoid
+      validates :patient_id, presence: true
+      validates :hospital_unit_id, presence: true
+      validates :hospital_ward_id, presence: true
+      validates :started_on, presence: true
+      validates :description, presence: true
+      validates :consult_type, presence: true
+
+      belongs_to :patient
+      belongs_to :hospital_unit, class_name: "Hospitals::Unit"
+      belongs_to :hospital_ward, class_name: "Hospitals::Ward"
+      belongs_to :seen_by, class_name: "User"
+
+      enumerize :transfer_priority, in: %i(unknown necessary desirable potential unnecessary)
+      enumerize :aki_risk, in: %i(yes no unknown)
+    end
+  end
+end

data/app/models/renalware/admissions/consult_query.rb

@@ -0,0 +1,21 @@
+require_dependency "renalware/admissions"
+
+module Renalware
+  module Admissions
+    class ConsultQuery
+      attr_reader :query
+
+      def initialize(query = {})
+        @query = query
+      end
+
+      def call
+        search.result
+      end
+
+      def search
+        @search ||= Consult.order(created_at: :desc).ransack(query)
+      end
+    end
+  end
+end

data/app/models/renalware/clinical/modality_description.rb

@@ -3,6 +3,7 @@ require_dependency "renalware/clinical"
 module Renalware
   module Clinical
     class ModalityDescription < Modalities::Description
+
       def to_sym
         :clinical
       end

data/app/models/renalware/hd/archive_yesterdays_slots_job.rb

@@ -0,0 +1,68 @@
+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 thos slots from master to weekly)
+# and archive them.
+# Not slots before the current day (or the up_until: arg) should be touched
+#
+#
+# OK we have a problem,
+# If last week there was no weekly diary created... then there is nothing to archive if eg today is
+# Monday.
+# So really whats the query for finding slots to archive?
+# We need to really always inner join onto weekly diaryies, and within tose for their slots
+# select unarchved onces in the past.
+# So we MUST always have weekly diaries for every possible week and not rely om a user working te UI
+# to create these JIT - because if they don't, unless we have a fn to creatae missing diaries,
+# (from which date?) then we can't query
+# So either
+# - seed next 10 years (520 per unit)
+# - have a fn to generate missing diaries - might be better and safer in the long run?
+# - Otherwise after 5 or 10 years or whatever its bound to have cased a problem.
+
+module Renalware
+  module HD
+    class ArchiveYesterdaysSlotsJob < ApplicationJob
+      attr_reader :up_until
+
+      # :reek:UtilityFunction
+      def perform(up_until: nil)
+        @up_until = up_until&.to_date
+        @up_until ||= (Time.zone.today - 1.day)
+
+        diary = Diary.find_by(year: @up_until.year, week_number: @up_until.cweek)
+        return unless diary
+
+        diary
+          .slots
+          .unarchived
+          .where(day_of_week: @up_until.cwday)
+          .update_all(archived: true, archived_at: Time.zone.now)
+        # DiarySlot
+        #   .unarchived
+        #   .joins(:diary)
+        #   .where(hd_diaries: { year: up_until.year, week_number: up_until.cweek)
+
+        #   .update_all(archived: true, archived_at: Time.zone.now)
+      end
+
+      private
+
+      def create_missing_weekly_diaries
+        # intering query
+        # basic implemenraiton
+        # select all weeklydiaries pluch year week from installation start date??? to now
+        # loop through
+        #  diary year 2017 week 1
+        #  MISSING diary year 2017 week 1 - so create
+        #  diary year 2017 week 3
+        #  select
+      end
+
+    end
+  end
+end

data/app/models/renalware/hd/dialysate.rb

@@ -0,0 +1,16 @@
+require_dependency "renalware/hd"
+
+module Renalware
+  module HD
+    class Dialysate < ApplicationRecord
+      acts_as_paranoid
+      validates :name, presence: true, uniqueness: true
+      validates :sodium_content, presence: true
+      validates :sodium_content_uom, presence: true
+
+      def to_s
+        name
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+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
+    class Diary < ApplicationRecord
+      include Accountable
+
+      has_many :slots, class_name: "Renalware::HD::DiarySlot"
+      has_many :patients, through: :slots, class_name: "Renalware::HD::Patient"
+      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)
+        slots.find do |slot|
+          slot.diurnal_period_code_id == diurnal_period_code_id &&
+            slot.station_id == station_id &&
+            slot.day_of_week == day_of_week
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+require_dependency "renalware/hd"
+
+module Renalware
+  module HD
+    class DiarySlot < ApplicationRecord
+      # Changing to_ary from private to public here is a hack required to remove a SimpleDelgator
+      # warning in eg Renalware::HD::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
+
+      include Accountable
+      belongs_to :diary, class_name: "Renalware::HD::Diary"
+      belongs_to :patient
+      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

data/app/models/renalware/hd/diurnal_period_code.rb

@@ -4,6 +4,11 @@ module Renalware
   module HD
     class DiurnalPeriodCode < ApplicationRecord
       validates :code, presence: true, uniqueness: true
+      scope :for, ->(code) { where(code: code) }
+
+      def to_s
+        code
+      end
     end
   end
 end

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

@@ -0,0 +1,48 @@
+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
+    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

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

@@ -0,0 +1,24 @@
+module Renalware
+  module HD
+    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
+
+      # TODO: !alwasy suing first :0)
+      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

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

@@ -0,0 +1,31 @@
+require_dependency "renalware/hd"
+
+module Renalware
+  module HD
+    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: "Renalware::HD::WeeklyDiary"
+      # While out DB constraints could check for the string "Renalware::HD::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

data/app/models/renalware/hd/patient_listener.rb

@@ -12,7 +12,7 @@ module Renalware
         hd_profile = HD.cast_patient(patient).hd_profile
         return if hd_profile.nil?
         hd_profile.hospital_unit = nil
-        hd_profile.schedule = nil
+        hd_profile.schedule_definition = nil
         hd_profile.save_by!(by)
       end
     end

data/app/models/renalware/hd/patients_dialysing_by_day_and_period_query.rb

@@ -0,0 +1,39 @@
+require_dependency "renalware/hd"
+
+# Find for example HD Patients who according to their HD Profile dialyse on Monday PM
+# Example usage in that instance:
+#   PatientsDialysingByDayAndPeriodQuery.new(1, "am").call
+module Renalware
+  module HD
+    class PatientsDialysingByDayAndPeriodQuery
+      attr_reader :hospital_unit_id, :day_of_week, :period_code
+
+      def initialize(hospital_unit_id, day_of_week, period_code)
+        @hospital_unit_id = hospital_unit_id
+        @day_of_week = day_of_week
+        @period_code = period_code
+      end
+
+      def call
+        PatientsDialysingByScheduleQuery.new(
+          hospital_unit_id,
+          schedule_definition_ids
+        ).call
+      end
+
+      private
+
+      # Find the first schedule having day_of_week in the pg days[] array (e.g. [2,4,6] if
+      # day_of_week is 2 (Tuesday) AND matching the period_code ie having the correct diurnal
+      # period code e.g. AM.
+      # Note
+      def schedule_definition_ids
+        HD::ScheduleDefinition
+          .eager_load(:diurnal_period)
+          .merge(Renalware::HD::DiurnalPeriodCode.for(period_code))
+          .merge(Renalware::HD::ScheduleDefinition.for_day_of_week(day_of_week))
+          .pluck(:id)
+      end
+    end
+  end
+end

data/app/models/renalware/hd/patients_dialysing_by_day_query.rb

@@ -0,0 +1,32 @@
+require_dependency "renalware/hd"
+
+# Find for example HD Patients who according to their HD Profile dialyse on Monday
+# at a particular unit
+# Example usage in that instance (1 == Monday):
+#   PatientsDialysingByDayQuery.new(unit_id, 1).call
+#
+module Renalware
+  module HD
+    class PatientsDialysingByDayQuery
+      attr_reader :hospital_unit_id, :day_of_week
+
+      def initialize(hospital_unit_id, day_of_week)
+        @hospital_unit_id = hospital_unit_id
+        @day_of_week = day_of_week
+      end
+
+      def call
+        PatientsDialysingByScheduleQuery.new(
+          hospital_unit_id,
+          schedule_definition_ids
+        ).call
+      end
+
+      private
+
+      def schedule_definition_ids
+        Renalware::HD::ScheduleDefinition.for_day_of_week(day_of_week).pluck(:id)
+      end
+    end
+  end
+end