renalware-core 2.0.152 → 2.0.158

data/app/components/renalware/patients/messages_component.html.slim

@@ -0,0 +1,45 @@
+.summary-part--messages
+  article.messages
+    header
+      h2
+        = link_to title, renalware.patient_messaging_internal_messages_path(patient)
+      ul
+        li= link_to "View All", renalware.patient_messaging_internal_messages_path(patient), class: "button"
+
+    - if messages.any?
+      table.toggleable.easy-read data-controller="toggle"
+        thead
+          tr
+            th.togglers.noprint= rows_toggler
+            th.col-width-tiny
+            th.col-width-date-time Date
+            th.col-width-medium Author
+            th.col-width-medium Subject
+            th
+              ' Body
+              i(style="font-weight: normal") - toggle to see complete message
+        - messages.each do |message|
+          tbody
+            tr
+              td= row_toggler
+              - if message.urgent?
+                td
+                  span.rounded.bg-orange-300.px-2 urgent
+              - else
+                td
+              td= l(message.created_at)
+              td= message.author
+              td.with-ellipsis= message.subject
+              td.with-ellipsis= message.body
+            tr
+              td
+              td
+              td(colspan=4)
+                p
+                  b
+                    ' Sent to:
+                  span= message.recipients.map(&:to_s).join(" & ")
+                p= message.body
+
+    - else
+      p.empty-section No messages

data/app/components/renalware/patients/messages_component.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Renalware
+  module Patients
+    class MessagesComponent < ApplicationComponent
+      include ToggleHelper
+      include Pagy::Backend
+      include Pagy::Frontend
+      TITLE = "Messages"
+
+      attr_reader :patient, :current_user
+
+      def initialize(patient:, current_user:)
+        @patient = patient
+        @current_user = current_user
+        super
+      end
+
+      def pagination
+        load_messages unless @pagination
+        @pagination
+      end
+
+      def messages
+        load_messages unless @messages
+        @messages
+      end
+
+      def title
+        if pagination.items < pagination.count
+          "#{TITLE} (#{pagination.items} of #{pagination.count})"
+        else
+          "#{TITLE} (#{pagination.count})"
+        end
+      end
+
+      private
+
+      def load_messages
+        @pagination, @messages = pagy(scope, items: 5, link_extra: "data-remote='true'")
+      end
+
+      def messaging_patient
+        @messaging_patient ||= Messaging.cast_patient(patient)
+      end
+
+      def scope
+        messaging_patient.messages.where(public: true).order(created_at: :desc)
+      end
+    end
+  end
+end

data/app/components/renalware/pd/adequacy_results_component.html.slim

@@ -1,9 +1,7 @@
 - if results.any?
-
-  article
-    header
-      h2= title
+  = render(Renalware::ArticleComponent.new(title: title)) do |article|
+    - article.with(:actions) do
       = link_to "Add", renalware.new_patient_pd_adequacy_result_path(patient), class: :button
-      = link_to "Show all", renalware.patient_pd_adequacy_results_path(patient), remote: true, class: "float-none button flex-initial secondary"
+      = link_to "Show all", renalware.patient_pd_adequacy_results_path(patient), remote: true, class: "button secondary"
     #adequacy-results-table
       = render "renalware/pd/adequacy_results/table", results: results, current_user: current_user

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

@@ -22,6 +22,8 @@ ul.side-nav.side-nav--admin
   = super_admin_menu_item "HD Dialysers", renalware.hd_dialysers_path, %r{hd/dialysers}
   = super_admin_menu_item "HD Cannulation Types", renalware.hd_cannulation_types_path, %r{hd/cannulation_types}
   = super_admin_menu_item "Print batches", renalware.letters_batches_path, %r{letters/batches}
+  = super_admin_menu_item "OBX", renalware.pathology_observation_descriptions_path, %r{admin/pathology_observation_descriptions}
+  = super_admin_menu_item "Pathology Code Groups", renalware.pathology_code_groups_path, %r{pathology/code_groups}
   = admin_menu_item "Mailshots", renalware.letters_mailshots_path, %r{letters/mailshots}
   = super_admin_menu_item "Playground", renalware.admin_playground_path, %r{admin/playground}
-  = developer_menu_item "HL7 Test", renalware.new_feeds_hl7_test_message_path
+  = developer_menu_item "HL7 Test", renalware.new_feeds_hl7_test_message_path, %r{admin/123}

data/app/components/renalware/users/last_signin_component.html.slim

@@ -0,0 +1,3 @@
+- if effective_last_sign_in_at.present?
+  p.last-login(style="position: absolute;top: -36px; right: 2px;")
+    = "You last signed in at #{effective_last_sign_in_at.strftime("%H:%M")} on #{effective_last_sign_in_at.strftime("%d-%b-%Y")}"

data/app/components/renalware/users/last_signin_component.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Renalware
+  module Users
+    # Renders a section on the dashboard that displays the last date and time the
+    # user signed in. This is a National Cyber Security Centre recommendation.
+    class LastSigninComponent < ApplicationComponent
+      include Renalware::UsersHelper
+      pattr_initialize [:current_user!]
+      delegate :last_sign_in_at, :current_sign_in_at, to: :current_user
+
+      def effective_last_sign_in_at
+        return if last_sign_in_at.blank? || last_sign_in_at == current_sign_in_at
+
+        last_sign_in_at
+      end
+
+      def render?
+        effective_last_sign_in_at.present?
+      end
+    end
+  end
+end

data/app/controllers/renalware/admin/playgrounds_controller.rb

@@ -50,7 +50,7 @@ module Renalware
         return {} if form.patient_id.blank?
 
         ActiveRecord::Base.connection.execute(
-          Arel.sql(<<-SQL)
+          Arel.sql(<<-SQL.squish)
             select
               observed_on as x,
               result as y

data/app/controllers/renalware/admin/users_controller.rb

@@ -51,6 +51,7 @@ module Renalware
           :telephone,
           :consultant,
           :hidden,
+          :prescriber,
           role_ids: []
         )
     end

data/app/controllers/renalware/drugs/drugs_controller.rb

@@ -8,7 +8,11 @@ module Renalware
       include Renalware::Concerns::Pageable
 
       before_action :prepare_drugs_search, only: :index
+      after_action :track_action, except: :selected_drugs
 
+      # Return a list of drugs as JSON for specific drug type (medication_switch)
+      # TODO: Make a separate resource eg drug_/esa/drugs.json. E.g.
+      # drug_type.drugs.ordered.pluck(:id, :name)
       def selected_drugs
         selected_drugs = Drug.for(params[:medication_switch])
                              .ordered

data/app/controllers/renalware/hd/historical_profiles_controller.rb

@@ -9,7 +9,7 @@ module Renalware
       include PresenterHelper
 
       def show
-        profile = Profile.deleted.for_patient(patient).find_by!(id: params[:id])
+        profile = Profile.deleted.for_patient(patient).find(params[:id])
         authorize profile
         render locals: {
           patient: patient,

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

@@ -9,9 +9,8 @@ module Renalware
       include PrescriptionsHelper
       include PresenterHelper
 
-      before_action :load_patient
-
       def index
+        authorize Prescription, :index?
         @treatable = treatable_class.find(treatable_id)
         respond_to do |format|
           format.html { render_index }
@@ -23,6 +22,7 @@ module Renalware
       def new
         @treatable = treatable_class.find(treatable_id)
         prescription = build_new_prescription_for(@treatable)
+        authorize prescription
         render_form(prescription, url: patient_prescriptions_path(patient, @treatable))
       end
 
@@ -32,6 +32,7 @@ module Renalware
         prescription = patient.prescriptions.new(
           prescription_params.merge(treatable: @treatable)
         )
+        authorize prescription
 
         if prescription.save
           render_index
@@ -42,6 +43,7 @@ module Renalware
 
       def edit
         prescription = patient.prescriptions.find(params[:id])
+        authorize prescription
         @treatable = prescription.treatable
 
         render_form(prescription, url: patient_prescription_path(patient, prescription))
@@ -49,6 +51,7 @@ module Renalware
 
       def update
         prescription = patient.prescriptions.find(params[:id])
+        authorize prescription
         @treatable = prescription.treatable
 
         updated = RevisePrescription.new(prescription).call(prescription_params)

data/app/controllers/renalware/messaging/internal/messages_controller.rb

@@ -8,6 +8,7 @@ module Renalware
       class MessagesController < BaseController
         include Renalware::Concerns::Pageable
         include PresenterHelper
+        include Pagy::Backend
 
         def new
           authorize Message, :new?
@@ -28,8 +29,20 @@ module Renalware
           end
         end
 
+        # Display all public message for a patient
+        def index
+          authorize Message, :index?
+          scope = patient.messages.where(public: true).order(created_at: :desc)
+          pagination, messages = pagy(scope, items: 20)
+          render locals: { patient: patient, messages: messages, pagination: pagination }
+        end
+
         private
 
+        def patient
+          Messaging.cast_patient(Patient.find(params[:patient_id]))
+        end
+
         def message_we_are_replying_to(message)
           return if message.replying_to_message_id.blank?
 
@@ -57,14 +70,10 @@ module Renalware
           Messaging::Internal.cast_author(current_user)
         end
 
-        def patient
-          Messaging.cast_patient(Patient.find(params[:patient_id]))
-        end
-
         def message_params
           params
             .require(:internal_message)
-            .permit(:subject, :body, :urgent, :replying_to_message_id, recipient_ids: [])
+            .permit(:subject, :body, :urgent, :replying_to_message_id, :public, recipient_ids: [])
         end
       end
     end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/pathology"
+
+module Renalware
+  module Pathology
+    class ObservationDescriptionsController < BaseController
+      include Pagy::Backend
+
+      def index
+        query = ObservationDescription
+          .includes(:measurement_unit)
+          .order(:code)
+          .ransack(params[:q] || {})
+        pagy, descriptions = pagy(query.result)
+        authorize descriptions
+        render locals: { descriptions: descriptions, pagy: pagy, query: query }
+      end
+
+      def edit
+        render_edit find_authorise_description
+      end
+
+      def update
+        description = find_authorise_description
+        if description.update(description_params)
+          redirect_to(
+            pathology_observation_descriptions_path,
+            notice: t(".success", model_name: "observation descrition")
+          )
+        else
+          render_edit(description)
+        end
+      end
+
+      private
+
+      def render_edit(description)
+        render :edit, locals: { description: description }
+      end
+
+      def find_authorise_description
+        ObservationDescription.find(params[:id]).tap { |desc| authorize desc }
+      end
+
+      def description_params
+        params
+          .require(:pathology_observation_description)
+          .permit(
+            :name,
+            :measurement_unit_id,
+            :lower_threshold,
+            :upper_threshold
+          )
+      end
+    end
+  end
+end

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/system/view_metadata_controller.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Renalware
+  module System
+    class ViewMetadataController < BaseController
+      def edit
+        klass = klass_for_view(view_name)
+        render locals: { view: view, klass: klass }, layout: false
+      end
+
+      def update
+        view = find_and_authorize_view
+        authorize view
+        if view.update(view_metadata_params)
+          redirect_back fallback_location: dashboard_path
+        end
+      end
+
+      # Restore the view to previous version at a specific datetime
+      def restore
+        view = find_and_authorize_view
+        datetime_version_to_restore = params[:version_at]
+        view.paper_trail.version_at(datetime_version_to_restore).save!
+        redirect_back(fallback_location: root_url)
+      end
+
+      private
+
+      def view
+        @view ||= find_and_authorize_view
+      end
+
+      def view_name
+        "#{view.schema_name}.#{view.view_name}"
+      end
+
+      # Dynamically create an anonymous AR class to wrap the view so we can get
+      # pagination etc without having to work with PG::Result.
+      def klass_for_view(view_name)
+        Class.new(ApplicationRecord) do
+          self.table_name = view_name
+          define_method(:to_s, ->(_x) { patient_name })
+          define_method(:to_param, -> { secure_id })
+        end.tap do |klass|
+          Object.const_set("AnonymousView", klass) # required for ransack search_form_for
+          klass.connection
+        end
+      end
+
+      def find_and_authorize_view
+        ViewMetadata.find(params[:id]).tap { |view| authorize view }
+      end
+
+      def view_metadata_params
+        params
+          .require(:view_metadata)
+          .permit(filters: {}, columns: [[:code, :name, :width, :truncate, :hidden]])
+      end
+    end
+  end
+end