renalware-core 2.0.145 → 2.0.151

data/app/controllers/renalware/pathology/observation_requests_controller.rb

@@ -11,7 +11,7 @@ module Renalware
       def index
         observation_requests = find_observation_requests
         render locals: {
-          observation_requests: observation_requests.result .page(page).per(per_page),
+          observation_requests: observation_requests.result.page(page).per(per_page),
           search: observation_requests,
           obr_filter_options: obr_filter_options,
           patient: @patient

data/app/controllers/renalware/pathology/observations_controller.rb

@@ -8,12 +8,35 @@ module Renalware
       include Renalware::Concerns::Pageable
       before_action :load_patient
 
+      # Observation history for a particular OBX.
+      # - HTML version is rendered from patient pathology under Investigations when you
+      # select a Request and see its Observations and click on the Code.
+      # - JSON version used in graphs
+      # rubocop:disable Metrics/MethodLength
       def index
         description = find_description
         observations = find_observations_for_description(description)
 
-        render locals: { patient: @patient, observations: observations, description: description }
+        respond_to do |format|
+          format.html do
+            render locals: {
+              patient: @patient,
+              observations: observations,
+              description: description
+            }
+          end
+          format.json do
+            render json: {
+              code: description.code,
+              name: description.name,
+              results: observations.pluck(:observed_at, :result).map { |arr|
+                [arr.first.to_date, arr.last&.to_f]
+              }
+            }
+          end
+        end
       end
+      # rubocop:enable Metrics/MethodLength
 
       private
 
@@ -22,7 +45,8 @@ module Renalware
       end
 
       def find_observations_for_description(description)
-        @patient.observations
+        @patient
+          .observations
           .page(page)
           .includes(:request)
           .for_description(description)

data/app/controllers/renalware/pathology/requests/requests_controller.rb

@@ -24,7 +24,7 @@ module Renalware
             Request.find(params[:id])
           )
           authorize request
-          render(
+          render_with_wicked_pdf(
             pdf: "show",
             page_size: "A4",
             layout: "renalware/layouts/pdf",
@@ -52,7 +52,7 @@ module Renalware
         def create
           requests.each(&:print_form)
 
-          render(
+          render_with_wicked_pdf(
             pdf: "create",
             page_size: "A4",
             layout: "renalware/layouts/pdf",
@@ -81,9 +81,11 @@ module Renalware
         end
 
         def requests
-          RequestPresenter.present(
-            Requests::RequestsFactory.new(@patients, request_params).build
-          )
+          @requests ||= begin
+            RequestPresenter.present(
+              Requests::RequestsFactory.new(@patients, request_params).build
+            )
+          end
         end
 
         def request_params

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

@@ -26,6 +26,12 @@ module Renalware
         end
       end
 
+      def destroy
+        authorize patient
+        patient.update_by(current_user, primary_care_physician_id: nil, practice_id: nil)
+        render locals: { patient: patient }
+      end
+
       private
 
       # There maybe times (for instance after migration from a previous system) where the

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