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

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

@@ -0,0 +1,26 @@
+require_dependency "renalware/hd"
+
+module Renalware
+  module HD
+    class PatientsDialysingByScheduleQuery
+      attr_reader :hospital_unit_id, :schedule_definition_ids
+
+      def initialize(hospital_unit_id, schedule_definition_ids)
+        @hospital_unit_id = hospital_unit_id
+        @schedule_definition_ids = Array(schedule_definition_ids)
+      end
+
+      def call
+        return [] if schedule_definition_ids.empty?
+        Patient
+          .eager_load(hd_profile: [:hospital_unit, { schedule_definition: [:diurnal_period] }])
+          .where(
+            hd_profiles: {
+              schedule_definition_id: schedule_definition_ids,
+              hospital_unit_id: hospital_unit_id
+            })
+          .order(:family_name, :given_name)
+      end
+    end
+  end
+end

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

@@ -33,8 +33,8 @@ module Renalware
           sql = <<-SQL.squish
             (hd_preference_sets.hospital_unit_id > 0 AND
               hd_profiles.hospital_unit_id != hd_preference_sets.hospital_unit_id) OR
-            (coalesce(hd_preference_sets.schedule, '') != '' AND
-              hd_profiles.schedule != hd_preference_sets.schedule) OR
+            (coalesce(hd_preference_sets.schedule_definition_id, 0) != 0 AND
+              hd_profiles.schedule_definition_id != hd_preference_sets.schedule_definition_id) OR
             (coalesce(hd_preference_sets.other_schedule, '') != '' AND
               hd_profiles.other_schedule != hd_preference_sets.other_schedule)
           SQL

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

@@ -5,10 +5,10 @@ module Renalware
     class PreferenceSet < ApplicationRecord
       include PatientScope
       include Accountable
-      include HasSchedule
 
       belongs_to :patient, touch: true
       belongs_to :hospital_unit, class_name: "Hospitals::Unit"
+      belongs_to :schedule_definition, foreign_key: "schedule_definition_id"
 
       has_paper_trail class_name: "Renalware::HD::Version"
 
@@ -18,7 +18,7 @@ module Renalware
       delegate :hospital_centre, to: :hospital_unit, allow_nil: true
 
       def preferred_schedule
-        other_schedule_required? ? other_schedule : schedule.try(:text)
+        other_schedule || schedule_definition&.to_s
       end
 
       def self.policy_class

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

@@ -6,15 +6,16 @@ module Renalware
     class Profile < ApplicationRecord
       include Document::Base
       include PatientScope
-      include HasSchedule
       include Accountable
       include Supersedeable
 
       belongs_to :patient, touch: true
       belongs_to :hospital_unit, class_name: "Hospitals::Unit"
+      belongs_to :dialysate
       belongs_to :prescriber, class_name: "User", foreign_key: "prescriber_id"
       belongs_to :named_nurse, class_name: "User", foreign_key: "named_nurse_id"
       belongs_to :transport_decider, class_name: "User", foreign_key: "transport_decider_id"
+      belongs_to :schedule_definition, foreign_key: "schedule_definition_id"
 
       has_document class_name: "Renalware::HD::ProfileDocument"
       has_paper_trail class_name: "Renalware::HD::Version"
@@ -25,6 +26,7 @@ module Renalware
       delegate :hospital_centre, to: :hospital_unit, allow_nil: true
 
       scope :ordered, -> { order(deactivated_at: :desc) }
+      scope :dialysing_at_unit, ->(unit_id) { where(hospital_unit_id: unit_id) }
 
       def self.policy_class
         BasePolicy

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

@@ -0,0 +1,44 @@
+require_dependency "renalware/hd"
+
+# A ScheduleDefinition is a database-normalized way of expressing e.g. "Mon Wed Fri AM"
+# A ScheduleDefinition has a days array e.g. [1,3,5] in the above example, where Monday = 1 etc,
+# and a reference to a DiurnalPeriodCode e.g. "am".
+# Defining schedules this way lets a hospital have a bit more control of the possible HD Schedules
+# that a patient can have - for example it can be defined that on Mon Tu Wed once can dialyse
+# in am, pm, or eve - and also allows us to define SQL that will find patients that dialyse on a
+# particular day at a particular time (diurnal period).
+# For example to find patients who, according to their HD Profile, dialyse on Wednesday (day=3)
+# evening:
+#   select p.id from patients p
+#   inner join hd_profiles hdp on hdp.patient_id = p.id
+#   inner join hd_schedule_definitions hds on hds.id = hdp.schedule_definition_id
+#   inner join hd_diurnal_period_codes hdc on hdc.id = hds.diurnal_period_id
+#   where hdc.code = 'am' and hds.days @> ARRAY[3]::integer[]
+#
+module Renalware
+  module HD
+    class ScheduleDefinition < ApplicationRecord
+      ABBREV_DAY_NAMES = %w(Mon Tue Wed Thu Fri Sat Sun).freeze
+      validates :days, presence: true
+      validates :diurnal_period_id, presence: true
+      belongs_to :diurnal_period, class_name: "DiurnalPeriodCode", foreign_key: :diurnal_period_id
+      scope :ordered, -> { order(days: :asc) }
+
+      # Render the schedule definition to a human friendly format e.g. "Mon, Wed, Fri AM"
+      # to display for example in dropdown lists when choosing a patient's preferred or actual
+      # schedule.
+      # Note that we store days of the week as integers starting at 1 (Monday).
+      # ABBREV_DAY_NAMES is a 0-based array, so we have to subtract 1 from our days of the week
+      # when mapping to a day name string.
+      def to_s
+        day_names = days.map{ |day_number| ABBREV_DAY_NAMES[day_number - 1] }.join(" ")
+        "#{day_names} #{diurnal_period.code.upcase}".strip
+      end
+
+      # Find all schedules that have a day falling on the required day.
+      # For example if day_of_week is 1 (Monday) find any schedules where the Postgres days[] array
+      # contains a 1 - e.g. a Mon Wed Fri AM schedule (where days = [1,3,5])
+      scope :for_day_of_week, ->(day_of_week) { where("days @> ?", "{#{day_of_week}}") }
+    end
+  end
+end

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

@@ -17,6 +17,7 @@ module Renalware
       belongs_to :dry_weight, class_name: "Renalware::Clinical::DryWeight"
       belongs_to :modality_description, class_name: "Modalities::Description"
       belongs_to :hospital_unit, class_name: "Hospitals::Unit"
+      belongs_to :dialysate
       belongs_to :signed_on_by, class_name: "User", foreign_key: "signed_on_by_id"
       belongs_to :signed_off_by, class_name: "User", foreign_key: "signed_off_by_id"
       has_many :prescription_administrations,

data/app/models/renalware/hd/session/closed.rb

@@ -2,8 +2,8 @@ require_dependency "renalware/hd"
 require_dependency "renalware/patients/hdf_presence_validator"
 require "document/base"
 
-# This Closed (state) Session adds validation standard HD::Session to enforce the presence of
-# most fields.
+# This Closed (state) Session adds validation to the standard HD::Session in order
+# to enforce the presence of most fields.
 module Renalware
   module HD
     class Session::Closed < Session
@@ -13,6 +13,7 @@ module Renalware
       validates :signed_off_by, presence: true
       validates :end_time, presence: true
       validates :signed_off_at, presence: true
+      validates :dialysate, presence: true
 
       def self.policy_class
         ClosedSessionPolicy

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

@@ -45,12 +45,12 @@ module Renalware
           session.hospital_unit = profile.hospital_unit
           unless dna_session?
             session.document.info.hd_type = profile.document.dialysis.hd_type
-            session.document.info.dialysis_fluid_used = profile.document.dialysis.dialysate
+            session.dialysate_id = profile.dialysate_id
           end
         end
       end
 
-      def set_default_access(session) # rubocop:disable Style/AccessorMethodName
+      def set_default_access(session) # rubocop:disable Naming/AccessorMethodName
         return if dna_session?
         accesses_patient = Renalware::Accesses.cast_patient(patient)
         if (profile = accesses_patient.current_profile)

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

@@ -1,22 +1,13 @@
-# To override the values in the location enum use something like this:
-# module CustomizeHDStationLocationEnum
-#   extend Enumerize
-#   enumerize :location, in: %i(side_room ante_room cubicle)
-# end
-# Renalware::HD::Station.singleton_class.send(:prepend, CustomizeHDStationLocationEnum)
-#
 require_dependency "renalware/hd"
 
 module Renalware
   module HD
     class Station < ApplicationRecord
-      extend Enumerize
       include Accountable
+      belongs_to :location, class_name: "HD::StationLocation", foreign_key: :location_id
       validates :hospital_unit_id, presence: true
       validates :name, uniqueness: { scope: :hospital_unit_id }
 
-      enumerize :location, in: %i(side_room)
-
       scope :for_unit, ->(id){ where(hospital_unit_id: id) }
       scope :ordered, ->{ order(position: :asc) }
     end

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

@@ -0,0 +1,10 @@
+require_dependency "renalware/hd"
+
+module Renalware
+  module HD
+    class StationLocation < ApplicationRecord
+      validates :name, presence: true, uniqueness: true
+      validates :colour, presence: true
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require_dependency "renalware/hd"
+
+module Renalware
+  module HD
+    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::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

data/app/models/renalware/hospitals/unit.rb

@@ -16,7 +16,6 @@ module Renalware
       validates :name, presence: true
       validates :renal_registry_code, presence: true
       validates :unit_type, presence: true
-      validates :number_of_hd_stations, numericality: { allow_blank: true, only_integer: true }
 
       enumerize :unit_type, in: %i(hospital satellite home)
 

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

@@ -17,6 +17,7 @@ module Renalware
         @search ||= begin
           Prescription
             .current
+            .ordered
             .includes(:medication_route, :drug)
             .includes(patient: { current_modality: :description })
             .eager_load(drug: [:drug_types])

data/app/models/renalware/messaging.rb

@@ -3,6 +3,7 @@ require_dependency "renalware"
 module Renalware
   module Messaging
     module_function
+
     def table_name_prefix
       "messaging_"
     end
@@ -21,6 +22,7 @@ module Renalware
 
     module Internal
       module_function
+
       def cast_patient(patient)
         ActiveType.cast(patient, ::Renalware::Messaging::Internal::Patient)
       end

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

@@ -5,8 +5,8 @@ module Renalware
     class Patient < ActiveType::Record[Renalware::Patient]
       has_many :messages
 
-      def to_s
-        super(:long)
+      def to_s(format = :long)
+        super(format)
       end
     end
   end

data/app/models/renalware/patient.rb

@@ -11,16 +11,21 @@ module Renalware
     extend Enumerize
     extend FriendlyId
 
-    # Out use of has_secure_token here ensures patient.secure_id is populated with a 24 char
-    # base58 token which is used in urls anywhere a patient is referenced, in order to obfuscate
-    # their database id. Note however that we also lean on a PG function
-    # (generate_patient_secure_id()) which will generate a new base58 patient secure_id if a
-    # patient record is created _outside_ of rails (for example during data migration).
-    # The PG function is only invoked at the SQL level to provide a default if none exists when a
-    #  patient created.
-    has_secure_token :secure_id
+    # Before creation generate a UUID to use in urls with friendly_id (i.e. in #to_param)
+    # Note if inserting directly into the database (bypassing Rails) this will still work as there
+    # is a default new uuid value on the secure_id column
+    before_create { self.secure_id ||= SecureRandom.uuid }
+    before_save :upcase_local_patient_ids
     friendly_id :secure_id, use: [:finders]
 
+    # For compactness in urls, remove the dashes, so that
+    #  a12d9a8e-9cc9-4fbe-88dd-2d1c983ea04f
+    # becomes
+    #  a12d9a8e9cc94fbe88dd2d1c983ea04f
+    def secure_id
+      @secure_id_without_dashes ||= super&.gsub("-", "")
+    end
+
     enumerize :marital_status, in: %i(married single divorced widowed)
 
     has_paper_trail class_name: "Renalware::Patients::Version"
@@ -123,21 +128,6 @@ module Renalware
       self.primary_care_physician == primary_care_physician
     end
 
-    # @section services
-
-    # def set_modality(attrs, by: nil)
-    #   by ||= attrs[:by]
-    #   # if current_modality.present?
-    #   #   current_modality.transfer!(attrs)
-    #   # else
-    #   #   modalities.create(attrs)
-    #   # end
-    #   new_modality = modalities.new(attrs)
-    #   Modalities::ChangePatientModality
-    #     .new(patient: self, by: by)
-    #     .call(old_modality: current_modality, new_modality:new_modality)
-    # end
-
     def current_modality_death?
       return false if current_modality.blank?
 
@@ -154,6 +144,18 @@ module Renalware
 
     private
 
+    # TODO: Use a constant for the max number of local patient ids
+    def upcase_local_patient_ids
+      self.local_patient_id = local_patient_id.upcase if local_patient_id.present?
+      (2..5).each{ |index| upcase_local_patient_id(index) }
+    end
+
+    def upcase_local_patient_id(index)
+      attr_name = :"local_patient_id_#{index}"
+      id_value = send(attr_name)
+      send("#{attr_name}=", id_value.upcase) if id_value.present?
+    end
+
     def has_title?
       respond_to?(:title) && title.present?
     end

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

@@ -13,19 +13,23 @@
 module Renalware
   module Patients
     class SearchQuery
-      attr_reader :term
 
-      def initialize(term:)
+      # FIELDS = %i(id family_name given_name nhs_number).freeze
+      attr_reader :term, :scope
+
+      def initialize(scope: Patient.all, term:)
         @term = term
+        @scope = scope
       end
 
       def call
         search.result
       end
 
+      # .select(FIELDS)
       def search
         @search ||= begin
-          Patient
+          scope
             .search(identity_match: term).tap do |search|
               search.sorts = %w(family_name given_name)
             end

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

@@ -8,6 +8,7 @@ require_dependency "renalware"
 module Renalware
   module Patients
     class Summary < ApplicationRecord
+      self.primary_key = :id
     end
   end
 end

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

@@ -14,7 +14,9 @@ module Renalware
         Regime.transaction do
           regime.assign_attributes(params)
           return ::Renalware::Success.new(regime) unless regime.anything_changed?
-          return ::Renalware::Failure.new(regime.with_bag_destruction_marks_removed) unless regime.valid?
+          unless regime.valid?
+            return ::Renalware::Failure.new(regime.with_bag_destruction_marks_removed)
+          end
 
           new_regime = revise_regime(by: by)
           ::Renalware::Success.new(new_regime)

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

@@ -4,6 +4,9 @@ module Renalware
   module Renal
     class Patient < ActiveType::Record[Renalware::Patient]
       has_one :profile
+      scope :having_no_primary_renal_diagnosis, lambda {
+        where(renal_profile: nil)
+      }
     end
   end
 end

data/app/models/renalware/renal/registry/preflight_checks/deaths_query.rb

@@ -0,0 +1,41 @@
+require_dependency "renalware/renal"
+
+module Renalware
+  module Renal
+    module Registry
+      module PreflightChecks
+        class DeathsQuery
+          include ModalityScopes
+          MODALITY_NAMES = %w(Death).freeze
+
+          attr_reader :relation
+
+          def initialize(relation = default_relation)
+            @relation = relation
+          end
+
+          def default_relation
+            Renalware::Patient
+              .preload(current_modality: [:description])
+              .all
+              .order(family_name: :asc)
+          end
+
+          def call
+            relation
+              .extending(ModalityScopes)
+              .with_current_modality_matching(MODALITY_NAMES)
+              .joins("LEFT OUTER JOIN renal_profiles ON renal_profiles.patient_id = patients.id")
+              .where("patients.first_cause_id is NULL AND renal_profiles.esrf_on IS NOT NULL")
+          end
+
+          def self.missing_data_for(patient)
+            [
+              :cause_of_death
+            ]
+          end
+        end
+      end
+    end
+  end
+end