renalware-core 2.0.147 → 2.0.153

data/app/components/renalware/system/admin_menu_component.rb

@@ -35,11 +35,11 @@ module Renalware
       def menu_item(title, path, active_when_controller_matches, enabled = true)
         klasses = %w(link)
         klasses << "active" if current_controller_matches(active_when_controller_matches)
-        content_tag :li, class: klasses.join(" ") do
+        tag.li class: klasses.join(" ") do
           if enabled
             link_to(title, path)
           else
-            content_tag :span, title
+            tag.span title
           end
         end
       end

data/app/components/renalware/system/article_component.html.slim

@@ -0,0 +1,3 @@
+article
+  header
+    h1= title

data/app/components/renalware/system/article_component.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Renalware
+  module System
+    # Experimental ActionView component
+    class AdminMenuComponent < ApplicationComponent
+    end
+  end
+end

data/app/controllers/renalware/admissions/consults_controller.rb

@@ -25,7 +25,7 @@ module Renalware
                 query: query.search
               }
             )
-            render options
+            render_with_wicked_pdf options
           end
           format.html do
             consults = query.call.page(page).per(per_page)

data/app/controllers/renalware/base_controller.rb

@@ -11,13 +11,13 @@ module Renalware
     after_action :verify_authorized
 
     # A note on ahoy tracking:
-    # has_user_timed_out is defined on SessionTimeoutController
+    # check_session_expired is defined on SessionTimeoutController
     # using this in the that controller
-    #   skip_before_action :track_ahoy_visit, only: has_user_timed_out
+    #   skip_before_action :track_ahoy_visit, only: check_session_expired
     # does not seem to work hence this global blacklist
 
     # rubocop:disable Rails/LexicallyScopedActionFilter
-    after_action :track_action, except: [:has_user_timed_out, :status]
+    after_action :track_action, except: :status
     # rubocop:enable Rails/LexicallyScopedActionFilter
 
     rescue_from Pundit::NotAuthorizedError, with: :user_not_authorized

data/app/controllers/renalware/concerns/pdf_renderable.rb

@@ -36,7 +36,7 @@ module Renalware
           body = System::RenderLiquidTemplate.call(template_name: template_name,
                                                    variables: variables)
           options = default_pdf_options.merge!(pdf: filename, locals: { body: body })
-          render options
+          render_with_wicked_pdf options
         end
 
         private

data/app/controllers/renalware/hd/scheduling/diaries_controller.rb

@@ -36,7 +36,7 @@ module Renalware
                 pdf: pdf_filename,
                 locals: { unit: unit, diary: DiaryPresenter.new(current_user, diary) }
               )
-              render options
+              render_with_wicked_pdf options
             end
           end
         end

data/app/controllers/renalware/medications/prescriptions_controller.rb

@@ -76,7 +76,7 @@ module Renalware
 
       # rubocop:disable Layout/LineLength, Metrics/MethodLength
       def render_prescriptions_list_to_hand_to_patient
-        render(
+        render_with_wicked_pdf(
           pdf_options.merge(
             pdf: pdf_filename,
             disposition: "inline",

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/pathology"
+
+module Renalware
+  module Pathology
+    class ChartsController < Pathology::BaseController
+      # Returns HTML rendered by a view component for pulling into say a modal dialog
+      def show
+        authorize Patient, :show?
+        render(
+          locals: {
+            patient: patient,
+            observation_description: ObservationDescription.find(params[:id])
+          },
+          layout: false
+        )
+      end
+    end
+  end
+end

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

@@ -10,7 +10,7 @@ module Renalware
         observation_set = ObservationSetPresenter.new(
           patient.fetch_current_observation_set
         )
-        render :index, locals: { observation_set: observation_set }
+        render :index, locals: { observation_set: observation_set, patient: patient }
       end
     end
   end

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

@@ -15,7 +15,7 @@ module Renalware
           page: page || 1,
           per_page: 25
         ).call
-        render :index, locals: { table: observations_table }
+        render :index, locals: { table: observations_table, patient: patient }
       end
     end
   end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/pathology"
+
+module Renalware
+  module Pathology
+    class NearestObservationResultsController < Pathology::BaseController
+      def index
+        near_date
+        authorize Patient, :index?
+        render json: nearest_results
+      end
+
+      private
+
+      def code_group
+        @code_group ||= CodeGroup.find(params[:code_group_id])
+      end
+
+      def observation_description_ids
+        @observation_description_ids ||= code_group.memberships.pluck(:observation_description_id)
+      end
+
+      def near_date
+        Date.parse(params[:date])
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def nearest_results
+        Pathology
+          .cast_patient(Patient.find(params[:patient_id]))
+          .observations
+          .joins(:description)
+          .where(description_id: observation_description_ids)
+          .select(
+            :observed_at,
+            :result,
+            :description_id,
+            "pathology_observation_descriptions.code as code"
+          )
+          .map do |row|
+            {
+              code: row.code,
+              observed_on: row.observed_at.to_date,
+              result: row.result
+            }
+          end
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+  end
+end

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/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