renalware-core 2.0.89 → 2.0.90

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/ukrdc"
+
+module Renalware
+  module UKRDC
+    module TreatmentTimeline
+      module HD
+        class ModalityCodeMap
+          def code_for_profile(profile)
+            hd_type = profile&.hd_type
+            return default_code if hd_type.blank?
+
+            ukrr_name = case hd_type.to_s.downcase
+                        when "hd" then "Haemodialysis"
+                        when "hdf_pre", "hdf_post" then "Haemodiafiltration"
+                        end
+
+            ModalityCode.find_by!(description: ukrr_name)
+          end
+
+          def default_code
+            ModalityCode.find_by!(description: "Haemodialysis")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/ukrdc"
+module Renalware
+  module UKRDC
+    module TreatmentTimeline
+      module HD
+        # Decorates an HD::Profile, adding methods that detect any changes significant enough
+        # to warrant generating a new UKRDC Treatment.
+        class ProfileDecorator < DumbDelegator
+          def initialize(profile, last_profile: nil)
+            @last_profile = last_profile
+            super(profile)
+          end
+
+          def hd_type
+            document.dialysis.hd_type
+          end
+
+          def changed?
+            return true if last_profile.blank?
+
+            hd_type_changed? || hospital_unit_changed?
+          end
+
+          def unchanged?
+            !changed?
+          end
+
+          def hd_type_changed?
+            last_profile.document.dialysis.hd_type != hd_type
+          end
+
+          def hospital_unit_changed?
+            last_profile.hospital_unit_id != hospital_unit_id
+          end
+
+          private
+
+          attr_reader :last_profile
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/ukrdc"
+require "attr_extras"
+
+module Renalware
+  module UKRDC
+    module TreatmentTimeline
+      module PD
+        # Generates a set of treatments based on a PD modality.
+        #
+        # There will be an initial treatment triggered by the modality itself, and then
+        # a treatment for each significant change in the pd regime during the period of the
+        # modality (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(
+              pd_regime_at_start_of_modality,
+              modality.started_on,
+              modality.ended_on
+            )
+          end
+
+          # 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.
+          def pd_regime_at_start_of_modality
+            @pd_regime_at_start_of_modality ||= begin
+              pd_regime_id = Renalware::PD::RegimeForModality.find_by!(
+                modality_id: modality.id
+              )&.pd_regime_id
+              return if pd_regime_id.blank?
+
+              Renalware::PD::Regime.find(pd_regime_id)
+            end
+          end
+
+          # Things that trigger a new Treatment for an PD patient
+          # - change of regime type eg from APD to CAPD
+          # - ?
+          # Loop through the patient's regimes and trigger a new treatment when these change
+          def create_treatments_within_modality
+            last_regime = pd_regime_at_start_of_modality
+
+            pd_regimes.each do |regime_|
+              regime = PD::RegimeDecorator.new(regime_, last_regime: last_regime)
+              create_treatment_from(regime) if last_regime.nil? || regime.changed?
+              last_regime = regime
+            end
+          end
+
+          # Note be sure not to include the regime at the start of the modality otherwise we could
+          # output this as a duplicate treatment
+          def pd_regimes
+            regimes = Renalware::PD::RegimesInDateRangeQuery.new(
+              patient: patient,
+              from: modality.started_on,
+              to: modality.ended_on
+            ).call
+            regimes - Array(pd_regime_at_start_of_modality)
+          end
+
+          def create_treatment_from(regime)
+            start_date = regime.present? ? regime.start_date : modality.started_on
+            end_date = regime.present? ? regime.end_date : modality.ended_on
+
+            create_treatment(regime, start_date, end_date)
+          end
+
+          # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          def create_treatment(regime, start_date, end_date)
+            treatments << Treatment.create!(
+              patient: patient,
+              clinician: modality.created_by,
+              started_on: start_date,
+              ended_on: end_date,
+              modality_id: modality.id,
+              modality_description_id: modality.description_id,
+              modality_code: treatment_for_pd_regime(regime),
+              pd_regime_id: regime&.id
+            )
+
+            # 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
+
+          def treatments
+            @treatments ||= []
+          end
+
+          def treatment_for_pd_regime(regime)
+            ModalityCodeMap.new.code_for_pd_regime(regime)
+          end
+
+          def pd_patient
+            Renalware::PD.cast_patient(patient)
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/ukrdc/treatment_timeline/pd/modality_code_map.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/ukrdc"
+
+module Renalware
+  module UKRDC
+    module TreatmentTimeline
+      module PD
+        class ModalityCodeMap
+          def code_for_pd_regime(regime)
+            return default_code if regime.blank?
+
+            ukrr_name = if regime.treatment =~ /assisted/i
+                          case regime.pd_type
+                          when :apd then "Assisted APD"
+                          when :capd then "Assisted CAPD"
+                          end
+                        else
+                          case regime.pd_type
+                          when :apd then "APD"
+                          when :capd then "CAPD"
+                          end
+                        end
+
+            ModalityCode.find_by!(description: ukrr_name)
+          end
+
+          def default_code
+            ModalityCode.find_by!(txt_code: 19)
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/ukrdc/treatment_timeline/pd/regime_decorator.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/ukrdc"
+require "attr_extras"
+
+module Renalware
+  module UKRDC
+    module TreatmentTimeline
+      module PD
+        class RegimeDecorator < DumbDelegator
+          def initialize(regime, last_regime:)
+            @last_regime = last_regime
+            super(regime)
+          end
+
+          def changed?
+            return true if last_regime.blank?
+
+            regime_type_changed?
+          end
+
+          def regime_type_changed?
+            last_regime&.type != type
+          end
+
+          def unchanged?
+            !changed?
+          end
+
+          private
+
+          attr_reader :last_regime
+        end
+      end
+    end
+  end
+end

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

@@ -13,6 +13,7 @@ module Renalware
       # If the site has not defined the ukrdc_prepare_tables SQL function then we exit gracefully.
       class PrepareTables
         def self.call
+          Treatment.delete_all
           connection = ActiveRecord::Base.connection
           result = connection.execute(<<-SQL)
             select 1 where exists(select 1 from pg_proc where proname = 'ukrdc_prepare_tables');

data/app/presenters/renalware/hd/session_presenter.rb

@@ -143,6 +143,12 @@ module Renalware
         access_type_abbreviation.split(" ").first
       end
 
+      def access_rr41_code
+        return if access_type_abbreviation.blank?
+
+        access_type_abbreviation.split(" ").last
+      end
+
       protected
 
       attr_reader :session, :view_context

data/app/presenters/renalware/ukrdc/patient_presenter.rb

@@ -38,12 +38,12 @@ module Renalware
         super
       end
 
-      def modalities
-        __getobj__
-          .modalities
-          .includes(:description)
-          .order(started_on: :asc, created_at: :asc)
-      end
+      # def modalities
+      #   __getobj__
+      #     .modalities
+      #     .includes(:description)
+      #     .order(started_on: :asc, created_at: :asc)
+      # end
 
       def dead?
         current_modality_death?
@@ -100,11 +100,22 @@ module Renalware
           .includes(:updated_by)
       end
 
+      def treatments
+        @treatments ||= begin
+          UKRDC::Treatment.where(patient_id: id).delete_all
+          UKRDC::TreatmentTimeline::GenerateTimeline.new(self).call
+          UKRDC::Treatment.where(patient_id: id).order(:patient_id, :started_on)
+        end
+      end
+
       # We always send the patients current prescriptions.
+      # Because the XSD rejects non-numeric dose amounts, only send prescriptions with a
+      # dose_amount of eg 10 or 10.23 or .23
       def prescriptions
         __getobj__
           .prescriptions
           .includes(:termination, :medication_route, :drug)
+          .where("dose_amount ~ '^[ ]*(\\d+|\\d+\.\\d+|\\.\\d+)[ ]*$'")
           .order(:prescribed_on)
       end
 

data/app/views/renalware/api/ukrdc/patients/_medications.xml.builder

@@ -26,14 +26,7 @@ xml.Medications do
       xml.Comments [prescription.dose_amount,
                     prescription.dose_unit&.text,
                     prescription.frequency].compact.join(" ")
-
-      # rubocop:disable Style/RescueModifier
-      # Only output DoseQuantity is it is an integer or decimal
-      dose_amount_is_a_number = Float(prescription.dose_amount) rescue nil
-      # rubocop:enable Style/RescueModifier
-      if dose_amount_is_a_number
-        xml.DoseQuantity prescription.dose_amount
-      end
+      xml.DoseQuantity prescription.dose_amount&.strip
 
       if prescription.dose_unit.present?
         xml.DoseUoM do

data/app/views/renalware/api/ukrdc/patients/_treatments.xml.builder

@@ -2,52 +2,91 @@
 
 xml = builder
 
+patient.treatments.each do |treatment|
+  namespace = treatment.modality_description.namespace&.downcase
+  partial = namespace&.to_sym || "generic"
+  locals = { treatment: treatment, builder: builder, patient: patient }
+
+  full_partial_path = "renalware/api/ukrdc/patients/treatments/#{partial}"
+  partial_exists = lookup_context.find_all(full_partial_path, [], true).any?
+
+  partial = partial_exists ? partial : "generic"
+  render "renalware/api/ukrdc/patients/treatments/#{partial}", **locals
+
+  # xml.Treatment do
+  #   xml.EncounterNumber "#{treatment.modality_id}-#{treatment.hd_profile_id}"
+  #   xml.EncounterType "N"
+  #   xml.FromTime treatment.started_on&.iso8601
+  #   xml.ToTime(treatment.ended_on&.iso8601) if treatment.ended_on.present?
+
+  #   if treatment.hospital_unit.present?
+  #     xml.HealthCareFacility do
+  #       xml.CodingStandard "ODS"
+  #       xml.Code treatment.hospital_unit.unit_code
+  #     end
+  #   end
+
+  #   xml.AdmitReason do
+  #     xml.CodingStandard "CF_RR7_TREATMENT"
+  #     xml.Code treatment.modality_code.txt_code
+  #   end
+
+  #   # HD
+  #   rr8 = treatment.hospital_unit&.unit_type_rr8
+  #   if rr8.present?
+  #     xml.Attributes do
+  #       xml.QBL05 rr8 # eg HOME
+  #     end
+  #   end
+  # end
+end
+
 # A temporary output of the treatment timeline using just modality descriptions with a
 # crude renal reg modality code assigned to them - HD, PD, Transplant, vCKD - all other modalities
 # fall through the gaps at this stage until we implement this properly. Also sub RR modal codes
 # like CAPD and HDF are not yet implemented, just the top level modality.
-patient.modalities.each do |modality|
-  ukrdc_modality_code_id = modality.description.ukrdc_modality_code_id
-
-  next if ukrdc_modality_code_id.blank?
-
-  ukrdc_modality_code = Renalware::UKRDC::ModalityCode.find(ukrdc_modality_code_id)
-
-  xml.Treatment do
-    xml.EncounterNumber modality.id
-    xml.EncounterType "N"
-    xml.FromTime modality.started_on&.iso8601
-    xml.ToTime(modality.ended_on&.iso8601) if modality.ended_on.present?
-
-    xml.HealthCareFacility do
-      xml.CodingStandard "ODS"
-      xml.Code Renalware.config.ukrdc_site_code
-    end
-
-    xml.AdmitReason do
-      xml.CodingStandard "CF_RR7_TREATMENT"
-      xml.Code ukrdc_modality_code.txt_code
-    end
-
-    # This is a bit of hack to get the HD Profile location for the current modality
-    if [1, 2, 3, 4, 5, 9].include?(ukrdc_modality_code.txt_code.to_i) # HD
-      profile = Renalware::HD::Profile
-        .where(patient_id: patient.id)
-        .where(<<-SQL).order(created_at: :desc).first
-        created_at::date <= '#{modality.started_on}'
-        and (
-          deactivated_at is NULL or
-          (
-            deactivated_at > '#{modality.started_on}'
-          )
-        )
-        SQL
-
-      if profile&.hospital_unit&.unit_type_rr8.present?
-        xml.Attributes do
-          xml.QBL05 profile.hospital_unit.unit_type_rr8 # eg HOME
-        end
-      end
-    end
-  end
-end
+# patient.modalities.each do |modality|
+#   ukrdc_modality_code_id = modality.description.ukrdc_modality_code_id
+
+#   next if ukrdc_modality_code_id.blank?
+
+#   ukrdc_modality_code = Renalware::UKRDC::ModalityCode.find(ukrdc_modality_code_id)
+
+#   xml.Treatment do
+#     xml.EncounterNumber modality.id
+#     xml.EncounterType "N"
+#     xml.FromTime modality.started_on&.iso8601
+#     xml.ToTime(modality.ended_on&.iso8601) if modality.ended_on.present?
+
+#     xml.HealthCareFacility do
+#       xml.CodingStandard "ODS"
+#       xml.Code Renalware.config.ukrdc_site_code
+#     end
+
+#     xml.AdmitReason do
+#       xml.CodingStandard "CF_RR7_TREATMENT"
+#       xml.Code ukrdc_modality_code.txt_code
+#     end
+
+#     # This is a bit of hack to get the HD Profile location for the current modality
+#     if [1, 2, 3, 4, 5, 9].include?(ukrdc_modality_code.txt_code.to_i) # HD
+#       profile = Renalware::HD::Profile
+#         .where(patient_id: patient.id)
+#         .where(<<-SQL).order(created_at: :desc).first
+#         created_at::date <= '#{modality.started_on}'
+#         and (
+#           deactivated_at is NULL or
+#           (
+#             deactivated_at > '#{modality.started_on}'
+#           )
+#         )
+#         SQL
+
+#       if profile&.hospital_unit&.unit_type_rr8.present?
+#         xml.Attributes do
+#           xml.QBL05 profile.hospital_unit.unit_type_rr8 # eg HOME
+#         end
+#       end
+#     end
+#   end
+# end