renalware-core 2.0.89 → 2.0.90

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dea8d3ef3c91160dead8c1db92b9a131b218f2ab1001c2acd0ad6698f6b83e33
-  data.tar.gz: 4a19dba06dfd48d8973e103dd3cb950162bf3fe038af55acbd5cee991e240b17
+  metadata.gz: 1a92055c00589d505aae488859a5a4e9071a8d49d658c1bd1dcb1d205ad10da1
+  data.tar.gz: 56b74f8c39ed127a5d958d6f08fc65941a11ea37c4cd62efce78714a9350230f
 SHA512:
-  metadata.gz: de2b1c0d56675e5e23607cca2729c9864516ff919e838a278dcc84a15598b72ed2ab26b0be8894894a8cb10d5c1229213af78a6001bbfcc723ec881e5f43e52b
-  data.tar.gz: a8c732dfd1caba2154487c21c8f557ba52e09f161b71886262516938b2331399c33806d9fe292b961ad08d60d373baf55e632c1754d7cddfdcebe76922d5259f
+  metadata.gz: 7b8ddfbdb456d9a15e402755da4de84caf59c0f8fb1c00e71f55d784251d955ddb712e7d3c5af3c9d4e643fd49767c2a9511a6acccd21db77f83d2dd8c28c259
+  data.tar.gz: 57fbed3713860f482a2c18bcfebbba90d33a8cabad1595b754cf0445cd257755e3b369baba7a0f4c38dc4e3ecdafde9220719eb9ddf88a2639402788616812a2

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/hd"
+
+module Renalware
+  module HD
+    # Backed by a (scenic) view this model is used to resolve the HD Profile in use or created
+    # just after a patient was assigned an HD modality,
+    # Note that this view could have been written as a SQL function or a ruby query object.
+    # I implemented it as a view because I would like semi technical people to be able to inspect
+    # the view to ascertain which HD modalities have no profile etc. Its just easier to review the
+    # data if it is a view.
+    #
+    # Example usage
+    #  modality_profile = HD::ProfileForModality.where(modality_id: 1)
+    #  modality_profile.hd_profile_id # => 123
+    class ProfileForModality < ApplicationRecord
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "attr_extras"
+
+module Renalware
+  module HD
+    class ProfilesInDateRangeQuery
+      pattr_initialize [:patient!, :from!, :to!]
+
+      def call
+        scope = Renalware::HD::Profile
+          .with_deactivated
+          .order(created_at: :asc, deactivated_at: :desc)
+
+        scope
+          .where(conditions.merge(deactivated_at: from..to))
+          .or(
+            scope.where(conditions.merge(deactivated_at: nil))
+          )
+      end
+
+      private
+
+      def conditions
+        {
+          patient_id: patient.id,
+          created_at: from..DateTime::Infinity.new
+        }
+      end
+    end
+  end
+end

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

@@ -3,6 +3,8 @@
 module Renalware
   module HD
     class ReviseHDProfile
+      attr_reader :profile, :new_profile
+
       def initialize(profile)
         raise(ArgumentError, "Cannot revise a new Profile") unless profile.persisted?
 
@@ -15,12 +17,8 @@ module Renalware
         return false unless profile.valid?
 
         profile.restore_attributes
-        profile.supersede!(params)
+        @new_profile = profile.supersede!(params)
       end
-
-      private
-
-      attr_reader :profile
     end
   end
 end

data/app/models/renalware/modalities/description.rb

@@ -26,6 +26,14 @@ module Renalware
       def augmented_name_for(_patient)
         name
       end
+
+      # For a ModalityDescription with type Renalware::HD::ModalityDescription
+      # this will return "HD"
+      def namespace
+        return if type.blank?
+
+        type.gsub("::", "").gsub(/^Renalware/, "").gsub(/ModalityDescription$/, "").underscore
+      end
     end
   end
 end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/pd"
+
+module Renalware
+  module PD
+    # Backed by a (scenic) view this model is used to resolve the PD Regime in use or created
+    # just after a patient was assigned an PD modality,
+    # Note that this view could have been written as a SQL function or a ruby query object.
+    # I implemented it as a view because I would like semi-technical people to be able to inspect
+    # the view to ascertain which PD modalities have no regime. Its just easier to review the
+    # data if it is a view.
+    #
+    # Example usage
+    #  modality_regime = PD::RegimeForModality.where(modality_id: 1)
+    #  modality_regime.pd_regime_id # => 123
+    #
+    class RegimeForModality < ApplicationRecord
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "attr_extras"
+
+module Renalware
+  module PD
+    class RegimesInDateRangeQuery
+      pattr_initialize [:patient!, :from!, :to!]
+
+      def call
+        scope = Renalware::PD::Regime.order(start_date: :asc, end_date: :desc)
+
+        scope
+          .where(conditions.merge(end_date: from..to))
+          .or(
+            scope.where(conditions.merge(end_date: nil))
+          )
+      end
+
+      private
+
+      def conditions
+        {
+          patient_id: patient.id,
+          start_date: from..DateTime::Infinity.new
+        }
+      end
+    end
+  end
+end

data/app/models/renalware/ukrdc/create_encrypted_patient_xml_files.rb

@@ -67,9 +67,11 @@ module Renalware
       end
 
       def create_patient_xml_files
+        count = 0
         patients = ukrdc_patients_who_have_changed_since_last_send
         summary.num_changed_patients = patients.count
         patients.find_each do |patient|
+          count += 1
           CreatePatientXMLFile.new(
             patient: patient,
             dir: paths.timestamped_xml_folder,
@@ -79,6 +81,9 @@ module Renalware
             logger: logger,
             force_send: force_send
           ).call
+
+          # Every n patients, force the garbage collector to kick in
+          GC.start if (count % 10).zero?
         end
       end
 
@@ -129,7 +134,7 @@ module Renalware
       end
 
       def email_recipients
-        Array(ENV.fetch("DAILY_REPORT_EMAIL_RECIPIENTS", "dev@airslie.com").split(","))
+        Array(ENV.fetch("DAILY_REPORT_EMAIL_RECIPIENTS", "tim@airslie.com").split(","))
       end
 
       def export_results

data/app/models/renalware/ukrdc/treatment.rb

@@ -8,6 +8,11 @@ module Renalware
       belongs_to :patient
       belongs_to :clinician, class_name: "Renalware::User"
       belongs_to :modality_code
+      belongs_to :modality, class_name: "Modalities::Modality"
+      belongs_to :modality_description, class_name: "Modalities::Description"
+      belongs_to :hospital_unit, class_name: "Hospitals::Unit"
+      belongs_to :hd_profile, class_name: "HD::Profile"
+      belongs_to :pd_regime, class_name: "PD::Regime"
       validates :patient, presence: true
       validates :modality_code, presence: true
 

data/app/models/renalware/ukrdc/treatment_timeline/generate_timeline.rb

@@ -14,19 +14,25 @@ module Renalware
         pattr_initialize :patient
 
         def call
-          PrepareTables.call
-          RemapModelTableNamesToTheirPreparedEquivalents.new.call do
-            modalities.each do |modality|
-              print "#{modality.description.name} "
-              GeneratorFactory.call(modality).call
-            end
+         # RemapModelTableNamesToTheirPreparedEquivalents.new.call do
+          Rails.logger.info "    Generating Treatment rows for modalities #{modality_names}"
+          modalities.each do |modality|
+            generator = GeneratorFactory.call(modality)
+            generator.call
           end
+          # end
         end
 
         private
 
         def modalities
-          patient.modalities.order(started_on: :asc, updated_at: :asc)
+          @modalities ||= begin
+            patient.modalities.includes(:description).order(started_on: :asc, updated_at: :asc)
+          end
+        end
+
+        def modality_names
+          modalities.map { |mod| mod.description.name }.join("->")
         end
       end
     end

data/app/models/renalware/ukrdc/treatment_timeline/generate_treatments.rb

@@ -23,18 +23,23 @@ module Renalware
         private
 
         def patient_scope
-          Renalware::Patient.select(:id)
+          Renalware::Patient
+            .select(:id)
+            .where("send_to_renalreg = true or send_to_rpv = true")
         end
 
-        # rubocop:disable Rails/Output
+        # rubocop:disable Rails/Output, Metrics/AbcSize
         def generate_treatments
+          PrepareTables.call
           Rails.logger.info "#{patient_scope.count} patients"
-          patient_scope.find_each do |patient|
+          patient_scope.find_each.with_index do |patient, index|
             print "\n#{patient.id}: "
             GenerateTimeline.new(patient).call
+            # Start gargbage collection periodically to prevent server ram issues.
+            GC.start if (index % 50).zero?
           end
         end
-        # rubocop:enable Rails/Output
+        # rubocop:enable Rails/Output, Metrics/AbcSize
 
         def log(msg)
           Rails.logger.info(msg)

data/app/models/renalware/ukrdc/treatment_timeline/generator_factory.rb

@@ -25,7 +25,7 @@ module Renalware
         end
 
         def self.klass_for(type)
-          "Renalware::UKRDC::TreatmentTimeline::Generators::#{type}Timeline".safe_constantize
+          "Renalware::UKRDC::TreatmentTimeline::#{type}::Generator".safe_constantize
         end
       end
     end

data/app/models/renalware/ukrdc/treatment_timeline/generic/generator.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/ukrdc"
+
+module Renalware
+  module UKRDC
+    module TreatmentTimeline
+      module Generic
+        # Handles creating a treatment record for any modality that has not been handled in a more
+        # specific way. Note that we only create a Treatment if we find a ukrdc_modality_code_id
+        # in the modality's description row in the database. Some modalities will not have that
+        # id so we just ignore them.
+        class Generator
+          pattr_initialize :modality
+
+          def call
+            create_treatment if ukrdc_modality_code.present?
+          end
+
+          private
+
+          def ukrdc_modality_code
+            @ukrdc_modality_code ||= begin
+              UKRDC::ModalityCode.find_by(
+                id: modality.description.ukrdc_modality_code_id
+              )
+            end
+          end
+
+          def create_treatment
+            Treatment.create!(
+              patient: modality.patient,
+              clinician: modality.created_by,
+              started_on: modality.started_on,
+              modality_id: modality.id,
+              modality_description_id: modality.description_id,
+              ended_on: modality.ended_on,
+              modality_code: ukrdc_modality_code
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/ukrdc/treatment_timeline/hd/generator.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/ukrdc"
+require "attr_extras"
+
+module Renalware
+  module UKRDC
+    module TreatmentTimeline
+      module HD
+        # Generates a set of treatments based on an HD modality and any HD::Profiles
+        # during the span of that modality.
+        #
+        # There will be an initial treatment triggered by the modality itself, and then
+        # a treatment for each significant change in the HD::Profile during the period of the
+        # modality (ie until it ends).
+        #
+        class Generator
+          pattr_initialize :modality
+          delegate :patient, to: :modality
+
+          def call
+            create_treatment_from_modality
+            create_treatments_within_modality
+          end
+
+          private
+
+          def create_treatment_from_modality
+            create_treatment(
+              hd_profile_at_start_of_modality,
+              modality.started_on,
+              modality.ended_on
+            )
+          end
+
+          # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          def create_treatment(profile, start_date, end_date)
+            treatments << Treatment.create!(
+              patient: patient,
+              clinician: modality.created_by,
+              started_on: start_date,
+              modality_id: modality.id,
+              modality_description_id: modality.description_id,
+              hospital_unit: profile&.hospital_unit,
+              ended_on: end_date,
+              modality_code: ukrdc_modality_code_from_profile(profile),
+              hd_profile: profile
+            )
+
+            # Update the end date on the previous treatment - ie the one we just added is
+            # taking over as the currently active treatment
+            unless treatments.length <= 1
+              previous_treatment = treatments[treatments.length - 2]
+              previous_treatment.update!(ended_on: start_date)
+            end
+          end
+          # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+          # Find the modality that was active on the day of the modality change
+          # The profile might have been added up to say 14 days later however so if there is none
+          # active on the day the modality was created, search up to 14 days ahead until we find
+          # one. Return nil if none found.
+          # Its complicated a bit by the fact that although there is a prescribed_on in the
+          # hd_profile, it is sometimes missing so we need to default to created_at in that
+          # instance.
+          def hd_profile_at_start_of_modality
+            @hd_profile_at_start_of_modality ||= begin
+              hd_profile_id = Renalware::HD::ProfileForModality.find_by!(
+                modality_id: modality.id
+              ).hd_profile_id
+              return if hd_profile_id.blank?
+
+              HD::ProfileDecorator.new(
+                Renalware::HD::Profile.with_deactivated.find(hd_profile_id)
+              )
+            end
+          end
+
+          # 3 things trigger a new Treatment for an HD patient
+          # - change of site
+          # - change of hd_type to from hd and (hdf_pre || hdf_post)
+          # - change of hd prescription
+          # Loop through the hd_profiles and trigger an new treatment when these change
+          # There is a problem here as we are creating duplicate treatments
+          # I think we need to first find the hd profile that is associated with the hd modality
+          # and that becomes the 'last_profile' here
+          def create_treatments_within_modality
+            last_profile = hd_profile_at_start_of_modality
+
+            hd_profiles.each do |profile_|
+              profile = HD::ProfileDecorator.new(profile_, last_profile: last_profile)
+              create_treatment_from(profile) if last_profile.nil? || profile.changed?
+              last_profile = profile
+            end
+          end
+
+          def hd_profiles
+            profiles = Renalware::HD::ProfilesInDateRangeQuery.new(
+              patient: patient,
+              from: modality.started_on,
+              to: modality.ended_on
+            ).call
+            profiles - Array(hd_profile_at_start_of_modality)
+          end
+
+          def create_treatment_from(profile)
+            start_date = profile.present? ? profile.created_at : modality.started_on
+            end_date = profile.present? ? profile.deactivated_at : modality.ended_on
+
+            create_treatment(profile, start_date, end_date)
+          end
+
+          def treatments
+            @treatments ||= []
+          end
+
+          def hd_patient
+            Renalware::HD.cast_patient(patient)
+          end
+
+          def ukrdc_modality_code_from_profile(profile)
+            ModalityCodeMap.new.code_for_profile(profile)
+          end
+        end
+      end
+    end
+  end
+end