renalware-core 2.0.113 → 2.0.115

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

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/patients"
+
+module Renalware
+  module Patients
+    module Ingestion
+      # Responsible for making commands to process messages based on the
+      # message type.
+      #
+      class CommandFactory
+        def for(message)
+          case message.action
+          when :add_person_information then make_add_patient(message)
+          when :update_person_information then make_update_patient(message)
+          # when :admit_patient then make_admit_patient(message)
+          # when :merge_patient then make_merge_patient(message)
+          # when :update_admission then make_update_admission(message)
+          # when :cancel_admission then make_cancel_admission(message)
+          # when :transfer_patient then make_transfer_patient(message)
+          # when :discharge_patient then make_discharge_patient(message)
+          # when :cancel_discharge then make_cancel_discharge(message)
+          # when :add_consultant then make_add_consultant(message)
+          else :no_matching_command
+          end
+        end
+
+        private
+
+        # def make_add_patient_with_finder(message)
+        #   CommandWithFinder.new(
+        #     make_add_patient(message),
+        #     message, finder: Finder::Patient.new
+        #   )
+        # end
+
+        # def make_add_patient_with_finder(message)
+        #   CommandWithFinder.new(
+        #     make_add_patient(message),
+        #     message, finder: Finder::Patient.new
+        #   )
+        # end
+
+        def make_add_patient(message)
+          Commands::AddOrUpdatePatient.new(message)
+        end
+
+        def make_update_patient(message)
+          Commands::AddOrUpdatePatient.new(message)
+        end
+
+        # def make_merge_patient(message)
+        #   Commands::MergePatient.new(message,
+        #     major_patient_finder: make_patient_finder_with_add_if_missing,
+        #     minor_patient_finder: make_minor_patient_finder_with_add_if_missing)
+        # end
+
+        # def make_admit_patient(message)
+        #   Commands::AdmitPatient.new(message,
+        #     patient_finder: make_patient_finder_with_add_if_missing)
+        # end
+
+        # def make_update_admission(message)
+        #   Commands::UpdateAdmission.new(message,
+        #     admission_finder: make_admission_finder_with_logging_if_missing)
+        # end
+
+        # def make_cancel_admission(message)
+        #   Commands::CancelAdmission.new(message,
+        #     admission_finder: make_admission_finder_with_logging_if_missing)
+        # end
+
+        # def make_transfer_patient(message)
+        #   Commands::TransferPatient.new(message,
+        #     admission_finder: make_admission_finder_with_admit_if_missing)
+        # end
+
+        # def make_discharge_patient(message)
+        #   Commands::DischargePatient.new(message,
+        #     admission_finder: make_admission_finder_with_logging_if_missing)
+        # end
+
+        # def make_cancel_discharge(message)
+        #   Commands::CancelDischarge.new(message)
+        # end
+
+        # def make_add_consultant(message)
+        #   Commands::AddConsultant.new(message)
+        # end
+
+        # def make_admission_finder_with_logging_if_missing
+        #   MissingAdmissionLogger.new(make_admission_finder)
+        # end
+
+        # def make_admission_finder_with_admit_if_missing
+        #   MissingRecordHandler.new(make_admission_finder,
+        #     policy: make_missing_admission_handler)
+        # end
+
+        # def make_admission_finder
+        #   Finder::Admission.new
+        # end
+
+        # def make_patient_finder_with_add_if_missing
+        #   MissingRecordHandler.new(Finder::Patient.new,
+        #     policy: make_missing_patient_handler)
+        # end
+
+        # def make_minor_patient_finder_with_add_if_missing
+        #   missing_patient_handler = lambda { |message|
+        #     Commands::AddPatient.new(
+        #       message,
+        #       mapper_factory: MessageMappers::MinorPatient
+        #     ).call
+        #   }
+
+        #   MissingRecordHandler.new(Finder::MinorPatient.new,
+        #     policy: missing_patient_handler)
+        # end
+
+        # def make_missing_patient_handler
+        #   lambda { |message|
+        #     make_add_patient(message).call
+        #   }
+        # end
+
+        # def make_missing_admission_handler
+        #   lambda { |message|
+        #     make_admit_patient(message).call
+        #   }
+        # end
+      end
+    end
+  end
+end

data/app/models/renalware/patients/ingestion/commands/add_or_update_patient.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/patients/ingestion/command"
+
+module Renalware
+  module Patients
+    module Ingestion
+      module Commands
+        # We could be here as a results of 2 scenarios:
+        # - ADT28 add patient
+        # - ADT31 update patient
+        #
+        # In both circumstances our action is the same:
+        # 1. If the patient exists as a Renalware::Patient, update their details
+        # 2. Find or create a Patients::Abridgement for this patient
+        # 3. Update their abridgement info, including their Renalware::Patient id if one exists
+        #
+        # So basically we are maintaining patient data in 2 places:
+        # a) in Renalware::Patient and its associated address and demographics tables
+        # b) in Renalware::Patients::Abrigement, which is an abbreviated version of the patient's
+        #    details (name, numbers, DOB ect), enabling us to find and import a new patient by
+        #    taking the abridgement, finding all previously received ADT and ORU etc feed_messages
+        #    for the patient and replaying those messages to build the patient with their
+        #    and pathology. If a patient is already a Renalware::Patient then in theory we do
+        #    not need to maintain an abridgement for them, but for consistentency we do; it has
+        #    advantages when trying to add a new patient in the Renalware UI - e.g. it can show you
+        #    that that patient is already added because there is a patient_id on the abridgement.
+        class AddOrUpdatePatient < Command
+          def initialize(message, mapper_factory: MessageMappers::Patient)
+            @mapper_factory = mapper_factory
+
+            super(message)
+          end
+
+          attr_reader :mapper_factory
+
+          def call
+            # For now skip updating the patient, just update the index ie create/update a
+            # patient abridgement
+            # update_patient_if_exists
+            UpdateMasterPatientIndex.new(message).call
+          end
+
+          private
+
+          def update_patient_if_exists
+            patient = find_patient
+            return if patient.blank?
+
+            patient = mapper_factory.new(message, patient).fetch
+            patient.by = SystemUser.find
+            patient.save!
+            patient
+          end
+
+          def find_patient
+            Patient.find_by(
+              local_patient_id: message.patient_identification.internal_id
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/patients"
+
+#
+# When subscribed to HL7 `message_arrived` messages, gets notified of incoming HL7 messages
+#
+module Renalware
+  module Patients
+    module Ingestion
+      class MessageListener
+        def adt_message_arrived(hl7_message:, **)
+          return unless hl7_message.adt?
+
+          command = Command.for(hl7_message)
+          command.call
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Renalware
+  module Patients
+    module Ingestion
+      # Responsible for mapping attributes from a message to attributes
+      # to domain models.
+      #
+      class MessageMapper
+        def initialize(message)
+          @message = message
+        end
+
+        attr_reader :message
+
+        def fetch
+          raise NotImplementedError
+        end
+
+        # def source
+        #   Message.for(message)
+        # end
+      end
+    end
+  end
+end

data/app/models/renalware/patients/ingestion/message_mappers/patient.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/patients"
+
+module Renalware
+  module Patients
+    module Ingestion
+      module MessageMappers
+        # Given an HL7 message that instructs us to update a patient (eg ADT^A31) or add a new one
+        # (ADT^A28) we parse the patient level information from the HL7 message and update or create
+        # the patient.
+        class Patient < MessageMapper
+          delegate :patient_identification, to: :message
+          delegate :address, to: :patient_identification
+
+          def initialize(message, patient = nil)
+            @patient = patient || ::Renalware::Patient.new
+
+            super(message)
+          end
+
+          attr_reader :patient
+
+          def fetch
+            map_attributes
+            patient
+          end
+
+          private
+
+          # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          def map_attributes
+            patient.attributes = {
+              local_patient_id: patient_identification.internal_id,
+              nhs_number: patient_identification.external_id,
+              given_name: patient_identification.given_name,
+              family_name: patient_identification.family_name,
+              suffix: patient_identification.suffix,
+              title: patient_identification.title,
+              born_on: Time.zone.parse(patient_identification.dob)&.to_date,
+              died_on: Time.zone.parse(patient_identification.death_date)&.to_date,
+              sex: patient_identification.sex,
+              practice: find_practice(message.practice_code) || patient.practice,
+              primary_care_physician: find_primary_care_physician(message.gp_code)
+            }
+            patient.build_current_address if patient.current_address.blank?
+            patient.current_address.attributes = {
+              street_1: address[0],
+              street_2: address[1],
+              street_3: nil,
+              town: address[2],
+              county: address[3],
+              postcode: address.last
+            }
+          end
+          # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+          # If for some reason we cannot find the new practice (perhaps we have not imported it yet)
+          # then be sure to leave the patient's current practice unchanged.
+          def find_practice(code)
+            Patients::Practice.find_by(code: code) || patient.practice
+          end
+
+          # If for some reason we cannot find the new gp (perhaps we have not imported them yet)
+          # then be sure to leave the patient's current gp unchanged.
+          def find_primary_care_physician(code)
+            Patients::PrimaryCarePhysician.find_by(code: code) || patient.primary_care_physician
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "renalware/feeds"
+require "attr_extras"
+
+module Renalware
+  module Patients
+    module Ingestion
+      class UpdateMasterPatientIndex
+        pattr_initialize :hl7_message
+        attr_reader :rw_patient
+        delegate :patient_identification, to: :hl7_message
+
+        def self.call(hl7_message)
+          new(hl7_message).call
+        end
+
+        def call
+          return unless hl7_message.adt?
+
+          @rw_patient = find_patient_in_renalware
+          update_or_create_abridged_patient
+          # update_primary_care_physician
+          # update_practice
+        end
+
+        private
+
+        def find_patient_in_renalware
+          ::Renalware::Patient.find_by(
+            local_patient_id: patient_identification.internal_id
+          ) || NullObject.instance
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def update_or_create_abridged_patient
+          find_or_initialize_abridged_patient.update!(
+            given_name: patient_identification.given_name,
+            family_name: patient_identification.family_name,
+            sex: patient_identification.sex,
+            title: patient_identification.title,
+            suffix: patient_identification.suffix,
+            born_on: patient_identification.born_on,
+            died_at: patient_identification.died_at,
+            patient_id: rw_patient.id,
+            practice_code: hl7_message.practice_code,
+            gp_code: hl7_message.gp_code
+          )
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def find_or_initialize_abridged_patient
+          Patients::Abridgement.find_or_initialize_by(
+            hospital_number: patient_identification.internal_id
+          )
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/patients/ingestion/update_master_patient_index_job.rb.dead

@@ -0,0 +1,20 @@
+# # frozen_string_literal: true
+
+# require "renalware/feeds"
+# require "attr_extras"
+
+# module Renalware
+#   module Patients
+#     module Ingestion
+#       class UpdateMasterPatientIndex < ApplicationJob
+#         queue_as :master_patient_index
+#         queue_with_priority 10
+
+#         def perform(feed_message:)
+#           raise "todo"
+#           # UpdateMasterPatientIndex.call()
+#         end
+#       end
+#     end
+#   end
+# end

data/app/models/renalware/patients.rb

@@ -13,9 +13,10 @@ module Renalware
     end
 
     def configure
-      # Note that we no longer create all patients that coe in from the HL7 feed, so
-      # MessageListener has been removed from the registry.
-      # SubscriptionRegistry.instance.register(Feeds::MessageProcessor, MessageListener)
+      SubscriptionRegistry.instance.register(
+        Feeds::MessageProcessor,
+        Ingestion::MessageListener
+      )
     end
 
     def self.cast_user(user)

data/app/models/renalware/problems/problem.rb

@@ -12,11 +12,15 @@ module Renalware
       has_paper_trail class_name: "Renalware::Problems::Version", on: [:create, :update, :destroy]
 
       belongs_to :patient, touch: true
-      has_many :notes, dependent: :destroy
+      has_many :notes, -> { ordered }, dependent: :destroy
 
       scope :ordered, -> { order(position: :asc) }
-      scope :with_notes, -> { includes(:notes) }
+      scope :with_notes, -> { eager_load(:notes).merge(Renalware::Problems::Note.ordered) }
       scope :with_patient, -> { includes(:patient) }
+      scope :with_versions, -> { includes(versions: :item) }
+
+      # This scope is called by CoreExtensions::ActiveRecord::Sort
+      scope :position_sorting_scope, ->(problem) { where(patient_id: problem.patient.id) }
 
       validates :patient, presence: true
       validates :description, presence: true

data/app/models/renalware/ukrdc/incoming/paths.rb

@@ -6,17 +6,16 @@ module Renalware
   module UKRDC
     module Incoming
       class Paths
-        def initialize
-          FileUtils.mkdir_p incoming
-          FileUtils.mkdir_p archive
-        end
-
         def incoming
-          @incoming ||= working_path.join("incoming")
+          @incoming ||= begin
+            working_path.join("incoming").tap { |path| FileUtils.mkdir_p(path) }
+          end
         end
 
         def archive
-          @archive ||= working_path.join("archive", "incoming")
+          @archive ||= begin
+            working_path.join("archive", "incoming").tap { |path| FileUtils.mkdir_p(path) }
+          end
         end
 
         private

data/app/policies/renalware/admin/devops_policy.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/admin"
+
+module Renalware
+  module Admin
+    class DevopsPolicy < BasePolicy
+      def show?
+        user_is_devops?
+      end
+      alias index? show?
+      alias edit? show?
+      alias update? show?
+      alias destroy? show?
+      alias new? show?
+    end
+  end
+end

data/app/policies/renalware/hd/{diary_policy.rb → scheduling/diary_policy.rb}

@@ -2,7 +2,9 @@
 
 module Renalware
   module HD
-    class DiaryPolicy < BasePolicy
+    module Scheduling
+      class DiaryPolicy < BasePolicy
+      end
     end
   end
 end

data/app/presenters/renalware/clinical/profile_presenter.rb

@@ -39,7 +39,7 @@ module Renalware
       end
 
       def dry_weights
-        @dry_weights ||= DryWeight.for_patient(patient).ordered
+        @dry_weights ||= DryWeight.for_patient(patient).ordered.limit(5)
       end
 
       def body_compositions
@@ -48,6 +48,7 @@ module Renalware
             .for_patient(patient)
             .includes([:modality_description, :assessor])
             .ordered
+            .limit(5)
         end
       end
     end

data/app/presenters/renalware/directory/person_auto_complete_presenter.rb

@@ -10,7 +10,7 @@ module Renalware
       end
 
       def to_hash
-        { id: id, label: name_and_address }
+        { id: id, text: name_and_address }
       end
     end
   end

data/app/presenters/renalware/hd/scheduling/diary_presenter.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_dependency "collection_presenter"
+
+# TODO: mixing query and presenter here..
+module Renalware
+  module HD
+    module Scheduling
+      class DiaryPresenter
+        attr_reader :user, :weekly_diary, :master_diary, :null_diary
+        delegate :id, :hospital_unit_id, :to_s, :week, :created_at, to: :weekly_diary
+
+        # https://github.com/avdi/naught
+        NullDiary = Naught.build do |config|
+          config.black_hole
+          config.define_explicit_conversions
+          config.predicates_return false
+
+          def master?
+            false
+          end
+
+          def slot_for(diary_id, diurnal_period_code_id, station_id, day_of_week)
+            NullSlot.new(diary_id, diurnal_period_code_id, station_id, day_of_week)
+          end
+        end
+
+        def initialize(user, weekly_diary)
+          @user = user
+          @weekly_diary = weekly_diary
+          @master_diary = weekly_diary.master_diary
+          @null_diary = NullDiary.new
+        end
+
+        def each_diurnal_period
+          DiurnalPeriodCode.all.each do |diurnal_period_code|
+            yield(diurnal_period_code) if block_given?
+          end
+        end
+
+        def each_station
+          stations.each_with_index { |station, index| yield(station, index + 1) if block_given? }
+        end
+
+        # rubocop:disable Metrics/LineLength, Metrics/AbcSize
+        def each_day(diurnal_period, station)
+          (1..last_day_of_week).each do |day_of_week|
+            diurnal_period_id = diurnal_period.id
+            station_id = station.id
+            valid_from = weekly_diary.week.date_on_first_day_of_week
+            slot = weekly_diary.slot_for(diurnal_period_id, station_id, day_of_week) ||
+                   master_diary.slot_for(diurnal_period_id, station_id, day_of_week, valid_from: valid_from) ||
+                   null_diary.slot_for(weekly_diary.id, diurnal_period_id, station_id, day_of_week)
+            yield(slot) if block_given?
+          end
+        end
+        # rubocop:enable Metrics/LineLength, Metrics/AbcSize
+
+        def day_names
+          all_day_names = Time::DAYS_INTO_WEEK.keys
+          all_day_names.take(last_day_of_week)
+        end
+
+        def stations
+          @stations ||= begin
+            Station.includes(:location).for_unit(hospital_unit_id).ordered.map do |station|
+              StationPresenter.new(station)
+            end
+          end
+        end
+
+        def station_locations
+          StationLocation.all
+        end
+
+        private
+
+        def last_day_of_week
+          Renalware.config.include_sunday_on_hd_diaries ? 7 : 6
+        end
+      end
+    end
+  end
+end

data/app/presenters/renalware/hd/scheduling/diary_slot_presenter.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/hd"
+require_dependency "collection_presenter"
+
+# TODO: mixing query and presenter here..
+module Renalware
+  module HD
+    module Scheduling
+      class DiarySlotPresenter < SimpleDelegator
+        delegate :master?, to: :diary, allow_nil: true
+
+        # Patients who prefer to dialyse on this day e.g. Mon and in this period e.g. AM.
+        # Flag those already assigned so they cannot be chosen.
+        def patients_preferring_to_dialyse_today_in_this_period
+          patients = Renalware::HD::PatientsDialysingByDayAndPeriodQuery
+            .new(
+              diary.hospital_unit_id,
+              day_of_week,
+              diurnal_period_code.code
+            ).call.all
+          simplify(patients)
+        end
+
+        # Patients who prefer to dialyse on this day e.g. Mon
+        # Flag those already assigned so they cannot be chosen.
+        def patients_preferring_to_dialyse_today
+          patients = Renalware::HD::PatientsDialysingByDayQuery
+          .new(
+            diary.hospital_unit_id,
+            day_of_week
+          ).call.all
+          simplify(patients)
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def patient_search_options
+          hospital_unit = Renalware::Hospitals::Unit.find(diary.hospital_unit_id)
+          [
+            OpenStruct.new(
+              id: :dialysing_on_day_and_period,
+              name: "Dialysing #{day_of_week_name} #{diurnal_period_code.to_s.upcase}"
+            ),
+            OpenStruct.new(
+              id: :dialysing_on_day,
+              name: "Dialysing on #{day_of_week_name}"
+            ),
+            OpenStruct.new(
+              id: :dialysing_at_unit,
+              name: "All #{hospital_unit.unit_code} HD patients"
+            ),
+            OpenStruct.new(
+              id: :dialysing_at_hospital,
+              name: "All HD patients"
+            )
+          ]
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        private
+
+        def simplify(patients)
+          patients.map do |patient|
+            hd_profile = patient.hd_profile
+            text = "#{patient.to_s(:long)} - "\
+                  "#{hd_profile&.schedule_definition} "\
+                  "#{hd_profile&.hospital_unit&.unit_code}".strip.truncate(65)
+            OpenStruct.new(id: patient.id, text: text)
+          end
+        end
+      end
+    end
+  end
+end