renalware-core 2.0.149 → 2.0.156

data/app/controllers/renalware/patients/mdms_controller.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/patients"
+
+module Renalware
+  module Patients
+    class MDMsController < BaseController
+      include Renalware::Concerns::Pageable
+      include Pagy::Backend
+
+      class MDMListOptions
+        attr_reader_initialize [
+          :search!,
+          :patients!,
+          :current_view!,
+          :view_proc!,
+          :pagination!
+        ]
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def show
+        authorize Patient, :index?
+        sql_view_klass = SqlView.new(view_name).klass
+        sql_view_klass.reset_column_information
+        search = sql_view_klass.ransack(params[:q])
+        view_proc = ->(patient) { patient_transplants_mdm_path(patient_id: patient.secure_id) }
+        pagy, patients = pagy(search.result)
+        options = MDMListOptions.new(
+          search: search,
+          patients: patients.load, # search.result.page(page).per(5).load,
+          current_view: current_view,
+          view_proc: view_proc,
+          pagination: pagy
+        )
+        render locals: { options: options }
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      private
+
+      def view_name
+        "#{current_view.schema_name}.#{current_view.view_name}"
+      end
+
+      def current_view
+        @current_view ||=
+          views.detect { |vw| vw.slug == params.fetch(:filter, "all") } || views.first
+      end
+
+      def views
+        @views ||= begin
+          scope = params[:scope]
+          System::ViewMetadata.where(
+            category: "mdm",
+            scope: scope
+          ).tap do |relation|
+            if relation.empty?
+              raise "No SQL views for found for category 'mdm' scope: '#{scope}'"
+            end
+          end
+        end
+      end
+
+      class SqlView
+        pattr_initialize :view_name
+
+        # Create a class under Renalware:: for this SQL name
+        # Note that Ransack search_form_for requires our otherwise anonymous class to have a name.
+        def klass
+          return Renalware.const_get(class_name) if class_exists?
+
+          underlying_view_name = view_name
+          Class.new(ApplicationRecord) do
+            self.table_name = underlying_view_name
+            define_method(:to_s, ->(_x) { patient_name })
+            define_method(:to_param, -> { secure_id })
+          end.tap do |klass|
+            Renalware.const_set(class_name, klass)
+            # klass.connection # not sure this is required.
+          end
+        end
+
+        private
+
+        def class_name
+          @class_name ||= begin
+            unless view_name.match?(/^[.a-z_0-9]*$/)
+              raise ArgumentError, "Invalid view name '#{view_name}'"
+            end
+
+            "AnonymousView#{view_name.split('.').last.camelcase}"
+          end
+        end
+
+        def class_exists?
+          Renalware.const_get(class_name)
+        rescue NameError
+          false
+        end
+      end
+    end
+  end
+end

data/app/controllers/renalware/pd/adequacy_completions_controller.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/pd"
+
+module Renalware
+  module PD
+    class AdequacyCompletionsController < BaseController
+      include Pagy::Backend
+
+      def index
+        query = AdequacyResult.joins(:patient).order(performed_on: :desc).ransack(params[:q])
+        pagy, results = pagy(query.result)
+        authorize results
+        render locals: { pagination: pagy, results: results, query: query }
+      end
+    end
+  end
+end

data/app/controllers/renalware/pd/adequacy_results_controller.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/pd"
+
+module Renalware
+  module PD
+    class AdequacyResultsController < PD::BaseController
+      def new
+        adequacy = AdequacyResult.new(patient: patient, performed_on: Date.current)
+        authorize adequacy
+        render locals: { adequacy: adequacy }
+      end
+
+      def create
+        adequacy = AdequacyResult.new(result_params)
+        authorize adequacy
+
+        if adequacy.save_by(current_user)
+          redirect_to patient_pd_dashboard_path(patient), notice: success_msg_for("Adequacy result")
+        else
+          render :new, locals: { adequacy: adequacy }
+        end
+      end
+
+      def edit
+        adequacy = find_and_authorize_result
+        # adequacy.derive_calculated_attributes
+        render locals: { adequacy: adequacy }
+      end
+
+      def update
+        result = find_and_authorize_result
+        if result.update_by(current_user, result_params)
+          redirect_to patient_pd_dashboard_path(patient), notice: success_msg_for("Result")
+        else
+          render_edit(result)
+        end
+      end
+
+      def destroy
+        result = find_and_authorize_result
+        result.destroy!
+        redirect_to patient_pd_dashboard_path(patient), notice: success_msg_for("Result")
+      end
+
+      def index
+        respond_to do |format|
+          format.js do
+            results = patient.adequacy_results.ordered
+            authorize results
+            render locals: { results: results }
+          end
+        end
+      end
+
+      private
+
+      def find_and_authorize_result
+        PD::AdequacyResult.for_patient(patient).find(params[:id]).tap do |adequacy|
+          authorize adequacy
+        end
+      end
+
+      def render_edit(adequacy)
+        render :edit, locals: { adequacy: adequacy }
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def result_params
+        params
+          .require(:pd_adequacy_result)
+          .permit(
+            :patient_id,
+            :performed_on,
+            :height,
+            :weight,
+            :dial_24_vol_in,
+            :dial_24_vol_out,
+            :dial_24_missing,
+            :urine_24_vol,
+            :urine_24_missing,
+            :dialysate_urea,
+            :dialysate_creatinine,
+            :dialysate_glu,
+            :dialysate_na,
+            :dialysate_protein,
+            :urine_urea,
+            :urine_creatinine,
+            :urine_na,
+            :urine_k,
+            :serum_urea,
+            :serum_creatinine
+          )
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+  end
+end

data/app/controllers/renalware/pd/pet_completions_controller.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/pd"
+
+module Renalware
+  module PD
+    class PETCompletionsController < BaseController
+      include Pagy::Backend
+
+      def index
+        query = PETResult.joins(:patient).order(performed_on: :desc).ransack(params[:q])
+        pagy, results = pagy(query.result)
+        authorize results
+        render locals: { pagination: pagy, results: results, query: query }
+      end
+    end
+  end
+end

data/app/controllers/renalware/pd/pet_results_controller.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/pd"
+
+module Renalware
+  module PD
+    class PETResultsController < BaseController
+      def new
+        pet = PETResult.new(
+          patient: patient,
+          performed_on: Date.current
+        )
+        authorize pet
+        render_new(pet)
+      end
+
+      def create
+        pet = PETResult.new(pet_result_params)
+        authorize pet
+
+        if pet.save_by(current_user)
+          redirect_to patient_pd_dashboard_path(patient), notice: success_msg_for("PET result")
+        else
+          render_new(pet)
+        end
+      end
+
+      def index
+        respond_to do |format|
+          format.json do # Graphing data
+            authorize PETResult, :index?
+            render json: pet_graph_data
+          end
+          format.js do
+            results = patient.pet_results.ordered
+            authorize results
+            render locals: { results: results }
+          end
+        end
+      end
+
+      def edit
+        render locals: { pet: find_authorize_pet_result }
+      end
+
+      def update
+        pet = find_authorize_pet_result
+        if pet.update_by(current_user, pet_result_params)
+          redirect_to patient_pd_dashboard_path(patient), notice: success_msg_for("PET result")
+        else
+          render_edit(pet)
+        end
+      end
+
+      def destroy
+        find_authorize_pet_result.destroy!
+        redirect_to patient_pd_dashboard_path(patient), notice: success_msg_for("Result")
+      end
+
+      private
+
+      def pet_graph_data
+        patient
+          .pet_results
+          .where("d_pcr is not null and net_uf is not null")
+          .order(performed_on: :asc)
+          .pluck(:d_pcr, :net_uf)
+      end
+
+      def find_authorize_pet_result
+        PD::PETResult.for_patient(patient).find(params[:id]).tap do |pet|
+          authorize pet
+        end
+      end
+
+      def render_edit(pet)
+        render :edit, locals: { pet: pet }
+      end
+
+      def render_new(pet)
+        render :new, locals: { pet: pet }
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def pet_result_params
+        dialysate_sample_params = [0, 2, 4, 6].each_with_object([]) do |hr, arr|
+          arr << :"sample_#{hr}hr_time"
+          arr << :"sample_#{hr}hr_urea"
+          arr << :"sample_#{hr}hr_creatinine"
+          arr << :"sample_#{hr}hr_glc"
+          arr << :"sample_#{hr}hr_sodium"
+          arr << :"sample_#{hr}hr_protein"
+        end
+
+        params
+          .require(:pd_pet_result)
+          .permit(
+            :patient_id,
+            :performed_on,
+            :test_type,
+            :volume_in,
+            :volume_out,
+            :dextrose_concentration_id,
+            :infusion_time,
+            :drain_time,
+            :overnight_volume_in,
+            :overnight_volume_out,
+            :overnight_dextrose_concentration_id,
+            :overnight_dwell_time,
+            :serum_time,
+            :serum_urea,
+            :serum_creatinine,
+            :plasma_glc,
+            :serum_ab,
+            :serum_na,
+            *dialysate_sample_params
+          )
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+  end
+end

data/app/controllers/renalware/pd/unified_pet_adequacies_controller.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/pd/base_controller"
+
+module Renalware
+  module PD
+    # PET and Adequacy are two distinct, descrete PD tests.
+    # The function of this unified PET + Adequacy controller is to provide the functionality for
+    # a user to add the data for both at the same time.
+    # This is because
+    # a) users tend to regard the tests as 'lumped-together' (even though they aren't), and
+    # b) both tests are often done at the same time, so a unified form saves some time and effort.
+    #
+    # Note that we never edit a unified PET + Adequacy; as they create separate rows in the db
+    # and are separate models, once created they are treated distinctly. This is mainly because
+    # the processing of the tests is quicte different.
+    # See pet.rb and adequacy.rb for more detail.
+    class UnifiedPETAdequaciesController < BaseController
+      include PresenterHelper
+
+      # We use an activbe model form to present a unified model api for the view
+      # to display and submit in the #new template.
+      def new
+        form = UnifiedPETAdequacyForm.new(
+          patient: patient,
+          pet: PETResult.new(patient: patient, performed_on: Date.current),
+          adequacy: AdequacyResult.new(patient: patient, performed_on: Date.current)
+        )
+        authorize Patient, :index?
+        render locals: { form: form }
+      end
+
+      def create
+        authorize Patient, :new?
+        pet = PETResult.new(pet_params)
+        adequacy = AdequacyResult.new(adequacy_params)
+        form = build_form_object(pet, adequacy)
+
+        if form.valid?
+          form.save_by!(current_user)
+          redirect_to patient_pd_dashboard_path(patient)
+        else
+          render :new, locals: { form: form }
+        end
+      end
+
+      def build_form_object(pet, adequacy)
+        UnifiedPETAdequacyForm.new(
+          patient: patient,
+          pet: pet,
+          adequacy: adequacy,
+          **unified_params.to_h.symbolize_keys
+        )
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def pet_params
+        params
+          .require(:patient_pd_unified_pet_adequacy)
+          .require(:pet)
+          .permit(
+            :patient_id,
+            :performed_on,
+            :test_type,
+            :volume_in,
+            :volume_out,
+            :dextrose_concentration_id,
+            :infusion_time,
+            :drain_time,
+            :overnight_volume_in,
+            :overnight_volume_out,
+            :overnight_dextrose_concentration_id,
+            :overnight_dwell_time
+          )
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def adequacy_params
+        params
+          .require(:patient_pd_unified_pet_adequacy)
+          .require(:adequacy)
+          .permit(
+            :patient_id,
+            :performed_on,
+            :height,
+            :weight,
+            :dial_24_vol_in,
+            :dial_24_vol_out,
+            :dial_24_missing,
+            :urine_24_vol,
+            :urine_24_missing
+          )
+      end
+
+      def unified_params
+        params
+          .require(:patient_pd_unified_pet_adequacy)
+          .permit(:adequacy_missing, :pet_missing)
+      end
+    end
+  end
+end