renalware-core 2.0.113 → 2.0.115

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

@@ -10,8 +10,12 @@ module Renalware
 
       def index
         observation_requests = find_observation_requests
-
-        render locals: { observation_requests: observation_requests, patient: @patient }
+        render locals: {
+          observation_requests: observation_requests.result .page(page).per(per_page),
+          search: observation_requests,
+          obr_filter_options: obr_filter_options,
+          patient: @patient
+        }
       end
 
       def show
@@ -22,16 +26,31 @@ module Renalware
 
       private
 
+      # Select just the OBR description ids and codes that have been associated with this patient.
+      # We'll uses them to build a filter dropdown list.
+      def obr_filter_options
+        @patient.observation_requests
+          .joins(:description)
+          .order("pathology_request_descriptions.code asc")
+          .pluck(
+            Arel.sql(
+              "distinct on(pathology_request_descriptions.code) pathology_request_descriptions.code"
+            ),
+            "pathology_request_descriptions.id",
+            "pathology_request_descriptions.name"
+          )
+      end
+
       def find_observation_requests
         @patient.observation_requests
-          .page(page)
           .includes(:description)
           .ordered
+          .ransack(params[:q])
       end
 
       def find_observation_request
         @patient.observation_requests
-          .includes(:description, observations: :description)
+          .includes(observations: :description)
           .find(params[:id])
       end
     end

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

@@ -104,10 +104,6 @@ module Renalware
             Pathology::OrderedPatientQuery
               .new(patient_ids)
               .call
-              .eager_load(:requests)
-              .eager_load(:rules)
-              .eager_load(:prescriptions)
-              .eager_load(:drugs)
           authorize Renalware::Patient
         end
 

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/patients"
+
+module Renalware
+  module Patients
+    class AbridgementsController < BaseController
+      def index
+        authorize Abridgement, :index?
+        render locals: {
+          form: AbridgementSearchForm.new,
+          results: abridgements_matching_search_criteria,
+          results_matching_dob: abridgements_matching_dobs
+        }
+      end
+
+      private
+
+      def abridgements_matching_search_criteria
+        return [] if search_params.blank?
+
+        Abridgement.where(hospital_number: search_params)
+      end
+
+      def abridgements_matching_dobs
+        return [] if abridgements_matching_search_criteria.empty?
+
+        dobs = abridgements_matching_search_criteria.map(&:born_on).uniq.compact
+        return [] if dobs.empty?
+
+        Abridgement.where(born_on: dobs) - abridgements_matching_search_criteria
+      end
+
+      def search_params
+        params.dig(:search, :criteria)
+      end
+    end
+  end
+end

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

@@ -5,8 +5,26 @@ require_dependency "renalware/hd/base_controller"
 module Renalware
   module PD
     class RegimesController < BaseController
+      include Renalware::Concerns::Pageable
       before_action :load_patient
 
+      def index
+        regimes = regime_type_class.for_patient(patient).with_bags.ordered.page(page).per(per_page)
+        render locals: {
+          patient: patient,
+          regimes: regimes,
+          pd_type_string: pd_type_string
+        }
+      end
+
+      def capd_regimes
+        @capd_regimes ||= CAPDRegime.for_patient(patient).with_bags.ordered.page(1).per(5)
+      end
+
+      def apd_regimes
+        @apd_regimes ||= APDRegime.for_patient(patient).with_bags.ordered.page(1).per(5)
+      end
+
       def new
         regime = cloned_last_known_regime_of_type || patient.pd_regimes.new(type: regime_type)
 
@@ -70,6 +88,14 @@ module Renalware
         params[:type] ? "Renalware::#{params[:type]}" : nil
       end
 
+      def regime_type_class
+        @regime_type_class ||= regime_type.constantize
+      end
+
+      def pd_type_string
+        regime_type_class.new.pd_type.upcase # CAPD or APD
+      end
+
       def cloned_last_known_regime_of_type
         regime = patient.pd_regimes
                         .order(start_date: :desc, created_at: :desc)

data/app/controllers/renalware/problems/problems_controller.rb

@@ -4,7 +4,7 @@ module Renalware
   module Problems
     class ProblemsController < BaseController
       def index
-        problems = patient.problems
+        problems = patient.problems.with_notes
         authorize problems
         render locals: {
           patient: patient,
@@ -14,7 +14,7 @@ module Renalware
       end
 
       def show
-        problem = patient.problems.with_archived.includes(versions: :item).find(params[:id])
+        problem = patient.problems.with_archived.with_versions.find(params[:id])
         notes = problem.notes.with_updated_by.ordered
         authorize problem
         render locals: {

data/app/helpers/renalware/application_helper.rb

@@ -3,10 +3,17 @@
 require "inline_image"
 require "git_commit_sha"
 require "breadcrumb"
+require "webpacker/helper"
 
 module Renalware
   module ApplicationHelper
     include Renalware::Engine.routes.url_helpers
+    include ::Webpacker::Helper
+
+    # See https://github.com/rails/webpacker/blob/master/docs/engines.md
+    def current_webpacker_instance
+      Renalware.webpacker
+    end
 
     def default_patient_link(patient)
       link_to(patient.to_s(:default), patient_clinical_summary_path(patient))
@@ -37,9 +44,11 @@ module Renalware
     end
 
     # For use in pages
+    # rubocop:disable Rails/OutputSafety
     def page_heading(title)
       content_for(:page_title) { title.html_safe }
     end
+    # rubocop:enable Rails/OutputSafety
 
     def t?(key)
       t(key, cascade: false, raise: false, default: "").present?

data/app/helpers/renalware/article_helper.rb

@@ -21,5 +21,23 @@ module Renalware
       output.concat(capture(&block)) if block_given?
       output.safe_concat("</article>")
     end
+
+    # Renders
+    # <span>5 of 16<div>
+    # if the collection has been paginated, otherwise
+    # <span>5<div>
+    def collection_count(collection)
+      return unless collection&.respond_to?(:length)
+
+      parts = ["("]
+      parts.append(collection.length)
+      if collection.respond_to?(:total_count)
+        if collection.total_count > collection.length
+          parts.append(" of #{collection.total_count}")
+        end
+      end
+      parts.append(")")
+      content_tag("span", parts.join(""))
+    end
   end
 end

data/app/helpers/renalware/form_helper.rb

@@ -6,13 +6,14 @@ module Renalware
       " field_with_errors" if model.errors.key?(attr)
     end
 
-    def render_input(builder, attribute)
+    def render_input(builder, attribute, html_options: {})
       renderable = builder.object.public_send(attribute)
       return unless renderable
 
       render input_partial_path_for(renderable),
              attribute: attribute,
-             f: builder
+             f: builder,
+             html_options: html_options
     end
 
     def input_partial_path_for(renderable)

data/app/helpers/renalware/users_helper.rb

@@ -2,8 +2,12 @@
 
 module Renalware
   module UsersHelper
+    def current_user_is_developer?
+      current_user.has_role?(:devops)
+    end
+
     def current_user_is_super_admin?
-      current_user.has_role?(:super_admin) || current_user.has_role?(:devops)
+      current_user.has_role?(:super_admin) || current_user_is_developer?
     end
 
     def current_user_is_admin?

data/app/javascript/controllers/clipboard_controller.js

@@ -0,0 +1,16 @@
+import { Controller } from "stimulus"
+
+// Experimental Stimulus clipboard controller. No IE11 support.
+// Can be enhanced but initially this exists just so we can test stimulus/webpack integration
+// when the engine is pulled into a host app
+export default class extends Controller {
+  static targets = ["source", "result"]
+
+  copy(event) {
+    event.preventDefault()
+    this.sourceTarget.select()
+    document.execCommand("copy")
+    console.log("Copied")
+    this.resultTarget.innerHTML = "Copied"
+  }
+}

data/app/javascript/packs/renalware_core.js

@@ -0,0 +1,20 @@
+// This file is automatically compiled by Webpack, along with any other files
+// present in this directory. You're encouraged to place your actual application logic in
+// a relevant structure within app/javascript and only use these pack files to reference
+// that code so it'll be compiled.
+// Uncomment to copy all static images under ../images to the output folder and reference
+// them with the image_pack_tag helper in views (e.g <%= image_pack_tag 'rails.png' %>)
+// or the `imagePath` JavaScript helper below.
+//
+// const images = require.context('../images', true)
+// const imagePath = (name) => images(name, true)
+
+// require("@rails/ujs").start()
+// require("@rails/activestorage").start()
+
+import { Application } from "stimulus"
+import { definitionsFromContext } from "stimulus/webpack-helpers"
+
+const application = Application.start()
+const context = require.context("../controllers", true, /\.js$/)
+application.load(definitionsFromContext(context))

data/app/jobs/feed_job.rb

@@ -13,9 +13,7 @@
 #
 FeedJob = Struct.new(:raw_message) do
   def perform
-    Renalware::Feeds
-      .message_processor
-      .call(raw_message)
+    Renalware::Feeds.message_processor.call(raw_message)
   end
 
   def max_attempts

data/app/jobs/hl7_message_example.yml

@@ -1,10 +1,10 @@
 --- !ruby/struct:FeedJob
 raw_message: |
   MSH|^~\&|HM|LBE|SCM||20091112164645||ORU^R01|1258271|P|2.3.1|||AL||||
-  PID|||Z999990^^^PAS Number||RABBIT^JESSICA^^^MS||19880924|F|||18 RABBITHOLE ROAD^LONDON^^^SE8 8JR|||||||||||||||||||
+  PID|||Z100002^^^PAS Number||RABBIT^JESSICA^^^MS||19880924|F|||18 RABBITHOLE ROAD^LONDON^^^SE8 8JR|||||||||||||||||||
   PV1||Inpatient|NIBC^^^^^^^^|||||MID^KINGS MIDWIVES||||||||||NHS|HXF888888^^^Visit Number|||||||||
   ORC|RE|^PCS|09B0099478^LA||CM||||200911111841|||MID^KINGS MIDWIVES|||||||
-  OBR|1|^PCS|09B0099478^LA|FBC^FULL BLOOD COUNT^MB||200911111841|200911111841|||||||200911111841|B^Blood|MID^KINGS MIDWIVES||09B0099478||||200911121646||HM|F||||||||||||||||||
+  OBR|1|PlacerOrderNumber1^PCS|09B0099478^LA|FBC^FULL BLOOD COUNT^MB||200911111841|200911111841|||||||200911111841|B^Blood|MID^KINGS MIDWIVES||09B0099478||||200911121646||HM|F||||||||||||||||||
   OBX|1|TX|WBC^WBC^MB||6.09||||||F|||200911112026||BBKA^Donald DUCK|
   OBX|2|TX|RBC^RBC^MB||4.00||||||F|||200911112026||BBKA^Donald DUCK|
   OBX|3|TX|HGB^Hb^MB||11.8||||||F|||200911112026||BBKA^Donald DUCK|

data/app/models/renalware/feeds/files/practice_memberships/import_job.rb

@@ -11,6 +11,8 @@ module Renalware
           include Feeds::Job
           FILE_TO_EXTRACT_FROM_ARCHIVE = /epracmem.csv/.freeze
 
+          # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          # TODO: refactor
           def perform(file)
             logging_to_stringio(strio = StringIO.new)
             log "Before upload there are #{practice_membership_count} practice memberships"
@@ -25,6 +27,7 @@ module Renalware
           ensure
             file.update!(status: status, result: strio.string, time_taken: elapsed_ms)
           end
+          # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
           private
 

data/app/models/renalware/feeds/files/primary_care_physicians/import_job.rb

@@ -12,6 +12,7 @@ module Renalware
 
           FILE_TO_EXTRACT_FROM_ARCHIVE = /^egpcur.csv$/.freeze
 
+          # rubocop:disable Metrics/AbcSize
           def perform(file)
             logging_to_stringio(strio = StringIO.new)
             log "PrimaryCarePhysician count before update: #{primary_care_physician_count}"
@@ -26,6 +27,7 @@ module Renalware
           ensure
             file.update!(status: status, result: strio.string, time_taken: elapsed_ms)
           end
+          # rubocop:enable Metrics/AbcSize
 
           private
 

data/app/models/renalware/feeds/hl7_message.rb

@@ -11,10 +11,19 @@ module Renalware
     #   HL7Message.new(raw_message).patient_identification.internal_id
     #
     class HL7Message < SimpleDelegator
-      def initialize(message_string)
-        @message_string = message_string
-        super(::HL7::Message.new(message_string.lines))
-      end
+      ACTIONS = {
+        "ADT^A28" => :add_person_information,
+        "ADT^A31" => :update_person_information,
+        "ADT^A08" => :update_admission,
+        "ADT^A01" => :admit_patient,
+        "ADT^A02" => :transfer_patient,
+        "ADT^A03" => :discharge_patient,
+        "ADT^A11" => :cancel_admission,
+        "MFN^M02" => :add_consultant,
+        "ADT^A34" => :merge_patient,
+        "ADT^A13" => :cancel_discharge,
+        "ORU^R01" => :add_pathology_observations
+      }.freeze
 
       class ObservationRequest < SimpleDelegator
         alias_attribute :date_time, :observation_date
@@ -117,6 +126,8 @@ module Renalware
         alias_attribute :external_id, :patient_id
         alias_attribute :sex, :admin_sex
         alias_attribute :dob, :patient_dob
+        alias_attribute :born_on, :patient_dob
+        alias_attribute :died_at, :death_date
 
         def internal_id
           patient_id_list.split("^").first
@@ -134,6 +145,18 @@ module Renalware
           patient_name[1]
         end
 
+        def suffix
+          patient_name[3]
+        end
+
+        def title
+          patient_name[4]
+        end
+
+        def address
+          super.split("^")
+        end
+
         private
 
         def patient_name
@@ -153,8 +176,36 @@ module Renalware
         self[:MSH].message_control_id
       end
 
-      def to_s
-        @message_string.tr("\r", "\n")
+      # Adding this so it is part of the interface and we can mock an HL7Message in tests
+      def to_hl7
+        super
+      end
+
+      def message_type
+        type.split("^").first
+      end
+
+      def event_type
+        parts = type.split("^")
+        parts.length == 2 && parts.last
+      end
+
+      %i(ORU ADT).each do |msg_type|
+        define_method(:"#{msg_type.to_s.downcase}?") do
+          msg_type.to_s == message_type
+        end
+      end
+
+      def action
+        ACTIONS.fetch(type)
+      end
+
+      def practice_code
+        self[:PD1].e3.split("^")[2] if self[:PD1]
+      end
+
+      def gp_code
+        self[:PD1].e4.split("^")[0] if self[:PD1]
       end
     end
   end

data/app/models/renalware/feeds/hl7_test_form.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Renalware
+  module Feeds
+    class HL7TestForm
+      include ActiveModel::Model
+      attr_accessor :body
+    end
+  end
+end

data/app/models/renalware/feeds/hl7_test_message.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_dependency "renalware/feeds"
+
+module Renalware
+  module Feeds
+    # Test messages stored in the databse that we can run to check they work
+    class HL7TestMessage < ApplicationRecord
+    end
+  end
+end

data/app/models/renalware/feeds/message_parser.rb

@@ -8,9 +8,13 @@ module Renalware
     # message object.
     #
     class MessageParser
+      def self.parse(*args)
+        new.parse(*args)
+      end
+
       def parse(message_string)
-        lines = message_string.split("\n").join("\r")
-        HL7Message.new(lines)
+        lines = message_string.split("\n").join("\r").lines
+        HL7Message.new(::HL7::Message.new(lines))
       end
     end
   end

data/app/models/renalware/feeds/message_processor.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_dependency "renalware/feeds"
+require "attr_extras"
 
 module Renalware
   module Feeds
@@ -9,32 +10,48 @@ module Renalware
     #
     class MessageProcessor
       include Broadcasting
+      attr_reader :raw_message, :hl7_message, :feed_message
 
-      # For SubscriptionRegistry only, may not be needed as also inc in Broadcasting module
-      include Wisper::Publisher
-
+      # We want to wrap message processing in a transaction because if message processing
+      # fails we don't want to leave an unprocessed message in the feed_messages table.
+      # If we did, and the same FeedJob retires a few minutes later, if will try to save to
+      # feed_messages with the same MD5 body_hash (the message is identical to one already saved)
+      # resulting in unique key violation.
+      # Using a transaction here prevents any orphaned records if there is an error.
+      # However we should be aware that any listeners raising an error will prevent successful
+      # in all other listeners. So a listener should be careful to catch errors and not re-raise
+      # them, or use the :message_processed message (lower down) which is safer.
       def call(raw_message)
-        feed_message = nil
+        @raw_message = raw_message
 
-        # We want to wrap message processing in a transaction because if message processing
-        # fails we don't want to leave an unprocessed message in the feed_messages table.
-        # If we did, and the same FeedJob retires a few minutes later, if will try to save to
-        # feed_messages with the same MD5 body_hash (the message is identical to one already saved)
-        # resulting in unique key violation.
-        # Using a transaction here prevents any orphaned records if there is an error.
-        # However we should be aware that any listeners raising an error will prevent successful
-        # in all other listeners. So a listener should be careful to catch errors and not re-raise
-        # them, or use the :message_processed message (lower down) which is safer.
+        parse_raw_message_into_hl7_object
         ActiveRecord::Base.transaction do
-          hl7_message = build_hl7_object_from(raw_message)
-          feed_message = persist_message(hl7_message)
-          broadcast(
-            :message_arrived,
-            hl7_message: hl7_message,
-            feed_message: feed_message
-          )
+          create_feed_message_using_raw_message_and_basic_extracted_patient_data
+          allow_listeners_to_process_the_message
         end
 
+        allow_listeners_to_post_process_the_message
+      rescue StandardError => exception
+        notify_exception(exception)
+        raise exception
+      end
+
+      private
+
+      def notify_exception(exception)
+        Engine.exception_notifier.notify(exception)
+      end
+
+      def allow_listeners_to_process_the_message
+        message_to_broadcast = "#{hl7_message.message_type.downcase}_message_arrived"
+        broadcast(
+          message_to_broadcast.to_sym,
+          hl7_message: hl7_message,
+          feed_message: feed_message
+        )
+      end
+
+      def allow_listeners_to_post_process_the_message
         # Another event, this one letting anyone interested know that a message been successfully
         # processed. They might want to forward the message on somewhere else for instance.
         # Think Diaverum.
@@ -44,8 +61,9 @@ module Renalware
         # e.g. forwarding, logging etc.
         # Its is recommended here to use an async listener - see example in renalware-diaverum
         # - so that any error in the listener has its own try mechansim and does not cause the
-        # current job to retry,
-        broadcast(:message_processed, feed_message: feed_message)
+        # current job to retry.
+        message_to_broadcast = "#{hl7_message.message_type.downcase}_message_processed"
+        broadcast(message_to_broadcast.to_sym, feed_message: feed_message)
       rescue Feeds::DuplicateMessageReceivedError => e
         Rails.logger.warn("Rejected duplicate HL7 message: #{e.message}")
       rescue StandardError => e
@@ -53,10 +71,8 @@ module Renalware
         raise e
       end
 
-      private
-
-      def build_hl7_object_from(raw_message)
-        MessageParser.new.parse(raw_message)
+      def parse_raw_message_into_hl7_object
+        @hl7_message = MessageParser.parse(raw_message)
       end
 
       # If the incoming message has already been processed we should not be processing it again.
@@ -64,12 +80,8 @@ module Renalware
       # same message payload is saved twice - in this case we exit #call early, the broadcast
       # is not issued and therefore the message is not processed. The message will go back into
       # the delayed_job queue and retry, failing until it finally gives up!
-      def persist_message(hl7_message)
-        PersistMessage.new.call(hl7_message)
-      end
-
-      def notify_exception(exception)
-        Engine.exception_notifier.notify(exception)
+      def create_feed_message_using_raw_message_and_basic_extracted_patient_data
+        @feed_message = PersistMessage.new.call(hl7_message)
       end
     end
   end

data/app/models/renalware/feeds/persist_message.rb

@@ -8,21 +8,27 @@ module Renalware
       # hl7_message is an HL7Message (a decorator around ::HL7::Message)
       # If the same message is persisted twice we'll get an ActiveRecord::RecordNotUnique error
       # but that's fine as we don't want to process the same HL7 message twice.
+      # rubocop:disable Metrics/MethodLength
       def call(hl7_message)
+        body_hash = Digest::MD5.hexdigest(hl7_message.to_hl7)
         Message.create!(
           event_code: hl7_message.type,
           header_id: hl7_message.header_id,
           body: hl7_message.to_s,
-          body_hash: Digest::MD5.hexdigest(hl7_message.to_s),
+          body_hash: body_hash,
           patient_identifier: hl7_message.patient_identification&.internal_id
         )
-      rescue ActiveRecord::RecordNotUnique => e
+      rescue ActiveRecord::RecordNotUnique
         # If a duplicate messages comes in (we have calculated the body_hash for the message and it
         # turns out that body_hash is not unique in the database, meaning the message is already
         # stored) then raise a custom error so it can be handled upstream - ie we can choose to
         # ignore it.
-        raise Feeds::DuplicateMessageReceivedError, e.message
+        raise(
+          DuplicateMessageError,
+          "header_id=#{hl7_message.header_id}, body_hash=#{body_hash}"
+        )
       end
+      # rubocop:enable Metrics/MethodLength
     end
   end
 end

data/app/models/renalware/feeds.rb

@@ -13,6 +13,8 @@ module Renalware
       "feed_"
     end
 
+    class DuplicateMessageError < StandardError; end
+
     def message_processor
       @message_processor ||= build_message_processor
     end

data/app/models/renalware/hd/scheduling/archive_arguments.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "renalware/hd"
+
+module Renalware
+  module HD
+    module Scheduling
+      class ArchiveArguments
+        attr_reader :from_week_period, :to_week_period, :up_until_date
+
+        def initialize(from: nil, to: nil)
+          @from_week_period = WeekPeriod.from_date(from || 1.year.ago)
+          @up_until_date = (to || Time.zone.now - 1.day).to_date
+          @to_week_period = WeekPeriod.from_date(@up_until_date)
+        end
+      end
+    end
+  end
+end