renalware-core 2.0.0.pre.rc3 → 2.0.0.pre.rc4

data/app/controllers/renalware/low_clearance/profiles_controller.rb

@@ -0,0 +1,45 @@
+require_dependency "renalware/low_clearance"
+
+module Renalware
+  module LowClearance
+    class ProfilesController < BaseController
+      def edit
+        render_edit(find_and_authorize_profile)
+      end
+
+      def update
+        profile = find_and_authorize_profile
+        if profile.update_by(current_user, profile_params)
+          redirect_to patient_low_clearance_dashboard_path,
+                      notice: t(".success", model_name: "profile")
+        else
+          flash.now[:error] = failed_msg_for("profile")
+          render_edit(profile)
+        end
+      end
+
+      private
+
+      def find_and_authorize_profile
+        (patient.profile || patient.build_profile).tap do |profile|
+          authorize profile
+        end
+      end
+
+      def render_edit(profile)
+        render :edit, locals: { patient: patient, profile: profile }
+      end
+
+      def profile_params
+        params
+          .require(:low_clearance_profile)
+          .permit(document: [])
+          .merge(document: document_attributes)
+      end
+
+      def document_attributes
+        params.require(:low_clearance_profile)[:document]&.permit!
+      end
+    end
+  end
+end

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

@@ -10,7 +10,8 @@ module Renalware
       before_action :find_primary_care_physician, only: [:edit, :update]
 
       def index
-        primary_care_physicians = PrimaryCarePhysician.order(:family_name)
+        primary_care_physicians = PrimaryCarePhysician.order(:name)
+                                                      .includes(:address)
                                                       .eager_load(practices: :address)
                                                       .page(page)
                                                       .per(per_page)
@@ -86,11 +87,11 @@ module Renalware
 
       def primary_care_physician_params
         params.require(:patients_primary_care_physician).permit(
-          :given_name, :family_name, :email, :practitioner_type, :code, :telephone,
+          :name, :practitioner_type, :code, :telephone,
           practice_ids: [],
           address_attributes: [
             :id, :name, :organisation_name, :street_1, :street_2, :street_3, :town, :county,
-            :postcode, :country_id, :telephone, :email
+            :postcode, :country_id, :telephone
           ]
         )
       end

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

@@ -94,7 +94,8 @@ module Renalware
       def exit_site_infection_params
         params
           .require(:pd_exit_site_infection)
-          .permit(:diagnosis_date, :treatment, :outcome, :notes)
+          .permit(:diagnosis_date, :treatment, :outcome, :notes, :recurrent, :cleared,
+                  :catheter_removed, clinical_presentation: [])
       end
 
       def load_exit_site_infection

data/app/controllers/renalware/transplants/donor_workups_controller.rb

@@ -7,8 +7,11 @@ module Renalware
 
       def show
         workup = DonorWorkup.for_patient(patient).first_or_initialize
-        redirect_to edit_patient_transplants_donor_workup_path(patient) if workup.new_record?
-        render locals: { patient: patient, workup: workup }
+        if workup.new_record?
+          redirect_to edit_patient_transplants_donor_workup_path(patient)
+        else
+          render locals: { patient: patient, workup: workup }
+        end
       end
 
       def edit

data/app/documents/renalware/low_clearance/profile_document.rb

@@ -0,0 +1,26 @@
+require "document/embedded"
+require "document/enum"
+
+module Renalware
+  module LowClearance
+    class ProfileDocument < Document::Embedded
+      attribute :first_seen_on, Date
+      attribute :dialysis_plan, Document::Enum
+      attribute :dialysis_planned_on, Date
+      attribute :predicted_esrf_date, Date
+      attribute :referral_creatinine, Integer
+      attribute :referred_by, String
+      attribute :education_status, Document::Enum
+      attribute :referral_egfr, Decimal
+      attribute :education_type, Document::Enum
+      attribute :attended_on, Date
+      attribute :dvd1_provided, Document::Enum, enums: %i(yes no)
+      attribute :dvd2_provided, Document::Enum, enums: %i(yes no)
+      attribute :transplant_referral, Document::Enum, enums: %i(yes no)
+      attribute :transplant_referred_on, Date
+      attribute :home_hd_possible, Document::Enum, enums: %i(yes no)
+      attribute :self_care_possible, Document::Enum, enums: %i(yes no)
+      attribute :access_notes, String
+    end
+  end
+end

data/app/documents/renalware/renal/profile_document.rb

@@ -23,27 +23,6 @@ module Renalware
         attribute :smoking, SmokingStatus
       end
       attribute :comorbidities, Comorbidities
-
-      class LowClearance < Document::Embedded
-        attribute :first_seen_on, Date
-        attribute :dialysis_plan, Document::Enum
-        attribute :dialysis_planned_on, Date
-        attribute :predicted_esrf_date, Date
-        attribute :referral_creatinine, Integer
-        attribute :referred_by, String
-        attribute :education_status, Document::Enum
-        attribute :referral_egfr, Decimal
-        attribute :education_type, Document::Enum
-        attribute :attended_on, Date
-        attribute :dvd1_provided, Document::Enum, enums: %i(yes no)
-        attribute :dvd2_provided, Document::Enum, enums: %i(yes no)
-        attribute :transplant_referral, Document::Enum, enums: %i(yes no)
-        attribute :transplant_referred_on, Date
-        attribute :home_hd_possible, Document::Enum, enums: %i(yes no)
-        attribute :self_care_possible, Document::Enum, enums: %i(yes no)
-        attribute :access_notes, String
-      end
-      attribute :low_clearance, LowClearance
     end
   end
 end

data/app/helpers/renalware/application_helper.rb

@@ -60,6 +60,11 @@ module Renalware
       bool ? "Yes" : "No"
     end
 
+    def yes_no_if_set(bool)
+      return if bool.nil?
+      yes_no(bool)
+    end
+
     def default_for_associated(assoc, method, msg)
       assoc.present? ? assoc.public_send(method) : msg
     end

data/app/helpers/renalware/attribute_name_helper.rb

@@ -6,28 +6,4 @@ module Renalware
       klass.human_attribute_name(attr) + String(suffix)
     end
   end
-
-  # A WIP experiment to create a better way of generating attribute names from I18n
-  # using the underlying human_attribute_name.
-  # Not convinced yet this is worth added complexity but the idea to access labels eg for
-  # table headers like so:
-  #   PatientLabels.name
-  #   PatientLabels.nhs_number
-  #
-  # class PatientLabels
-  #   class << self
-  #     # disables :reek:BooleanParameter
-  #     def method_missing(method, *_args, &block)
-  #       Renalware::Patient.human_attribute_name(method.to_sym) || super
-  #     end
-
-  #     def respond_to_missing?(_method_name, _include_private = false)
-  #       true
-  #     end
-
-  #     def name
-  #       method_missing(:name)
-  #     end
-  #   end
-  # end
 end

data/app/helpers/renalware/infection_organisms_helper.rb

@@ -7,25 +7,5 @@ module Renalware
     def new_pd_infection_organism_path(infectable)
       super(infectable_type: infectable.class.to_s, infectable_id: infectable.id)
     end
-
-    def organisms_and_sensitivities(infection_organisms)
-      if infection_organisms.blank?
-        "Unknown"
-      else
-        safe_join(
-          infection_organisms.map do |io|
-            "<li>#{io.organism_code.name} - #{io.sensitivity}</li>".html_safe
-          end
-        )
-      end
-    end
-
-    def organisms(infection_organisms)
-      if infection_organisms.blank?
-        "Unknown"
-      else
-        safe_join(infection_organisms.map { |io| "<li>#{io.organism_code.name}</li>".html_safe })
-      end
-    end
   end
 end

data/app/helpers/renalware/mdm_helper.rb

@@ -22,7 +22,7 @@ module Renalware
           when :pd then patient_pd_mdm_path(patient)
           when :hd then patient_hd_mdm_path(patient)
           when :transplant then patient_transplants_mdm_path(patient)
-          when :low_clearance then patient_renal_low_clearance_mdm_path(patient)
+          when :low_clearance then patient_low_clearance_mdm_path(patient)
           end
         end
       end

data/app/helpers/renalware/pd_regimes_helper.rb

@@ -15,11 +15,7 @@ module Renalware
     end
 
     def default_daily_glucose_average(glucose)
-      if glucose.blank?
-        0
-      else
-        glucose
-      end
+      glucose.presence || 0
     end
 
     # The list of treatment options, stored in I18n

data/app/mailers/renalware/admin/user_mailer.rb

@@ -1,7 +1,5 @@
 module Renalware
-  class Admin::UserMailer < ActionMailer::Base
-    default from: "renalware-admin@renalware.herokuapp.com"
-
+  class Admin::UserMailer < ApplicationMailer
     def approval(user)
       @user = user
       mail(to: @user.email, subject: "Renalware account approved")

data/app/mailers/renalware/letters/delivery/errors.rb

@@ -0,0 +1,9 @@
+require_dependency "renalware/letters"
+
+module Renalware
+  module Letters
+    module Delivery
+      class PatientHasNoPracticeError < StandardError; end
+    end
+  end
+end

data/app/mailers/renalware/letters/delivery/practice_mailer.rb

@@ -0,0 +1,55 @@
+require_dependency "renalware/letters"
+require "attr_extras"
+require_relative "./errors"
+
+module Renalware
+  module Letters
+    module Delivery
+      class PracticeMailer < ApplicationMailer
+        def patient_letter(letter:, to:)
+          validate_letter(letter)
+          letter_presenter = LetterPresenterFactory.new(letter)
+          attachments["letter.pdf"] = Letters::PdfRenderer.call(letter_presenter)
+
+          # Note here we render the content in a block so that we can use the locals: {..} syntax
+          # which is cleaner than using @vars.
+          mail(
+            to: to,
+            subject: build_subject_for(letter),
+            from: Renalware.config.default_from_email_address,
+            locals: locals_for(letter)
+          ) { |format| format.text { render(locals: locals_for(letter)) } }
+        end
+
+        private
+
+        # "$lettdescr from King's Renal Unit (KCH No $hospno1)";
+        def build_subject_for(letter)
+          renal_unit = Renalware.config.renal_unit_on_letters
+          "#{letter.description} from #{renal_unit} #{letter.patient.hospital_identifier}"
+        end
+
+        def locals_for(letter)
+          {
+            help_phone_number: Renalware.config.phone_number_on_letters,
+            help_email_address: Renalware.config.default_from_email_address,
+            ident_metadata: ident_meta_data_for_insertion_into_body(letter)
+          }
+        end
+
+        def ident_meta_data_for_insertion_into_body(letter)
+          patient = letter.patient
+          PracticeEmailMetaData.new(
+            letter: letter,
+            primary_care_physician: patient.primary_care_physician,
+            practice: patient.practice
+          )
+        end
+
+        def validate_letter(letter)
+          raise Delivery::PatientHasNoPracticeError if letter.patient&.practice.blank?
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/renalware/feeds/job.rb

@@ -0,0 +1,30 @@
+require_dependency "renalware/feeds"
+
+module Renalware
+  module Feeds
+    module Job
+      extend ActiveSupport::Concern
+
+      def formatted_exception(error)
+        [
+          "#{error.backtrace.first}: #{error.message} (#{error.class})",
+          error.backtrace.drop(1).map{ |s| "\t#{s}" }
+        ].join("\n")
+      end
+
+      def log(msg)
+        Rails.logger.info(msg)
+      end
+
+      def find_file_in(files, pattern)
+        file = files.select{ |f| f.basename.to_s.match(pattern) }.first
+        if file.nil?
+          msg = "Zip file does not contain a file with name matching #{pattern}!"
+          log(msg)
+          fail(msg)
+        end
+        file
+      end
+    end
+  end
+end

data/app/models/concerns/renalware/letters/letter_pathology.rb

@@ -5,15 +5,38 @@ module Renalware
     module LetterPathology
       extend ActiveSupport::Concern
 
-      # Update a letter's pathology snapshot to the current point in time
-      def build_pathology_snapshot(patient, letter)
-        return if patient.current_observation_set.nil?
-        possible_letter_codes = Renalware::Letters::RelevantObservationDescription.all.map(&:code)
-        letter.pathology_snapshot = begin
-          patient.current_observation_set.values.select do |code, _|
-            possible_letter_codes.include?(code.to_s)
-          end
+      # Filters a set of observations using a specific set of OBX codes
+      class FilteredObservationSet
+        EMPTY_SNAPSHOT = {}.freeze
+
+        def initialize(observation_set:, codes: nil)
+          @codes = codes || RelevantObservationDescription.all.map(&:code)
+          @observation_set = observation_set
         end
+
+        # Returns a hash of the filtered observations e.g.
+        # {
+        #   "NA"=>{"result"=>"139", "observed_at"=>"2016-03-15T03:28:00"},
+        #   "ALB"=>{"result"=>"49", "observed_at"=>"2016-03-15T03:28:00"},
+        #   ...
+        # }
+        def to_h
+          return if observation_set.blank?
+          hash = observation_set.values.select { |code, _| codes.include?(code.to_s) }
+          hash.empty? ? nil : hash
+        end
+
+        private
+
+        attr_reader :observation_set, :codes
+      end
+
+      # Update a letter's pathology snapshot to the current point in time
+      def build_pathology_snapshot(patient)
+        FilteredObservationSet.new(
+          observation_set: patient.current_observation_set,
+          codes: Renalware::Letters::RelevantObservationDescription.all.map(&:code)
+        ).to_h
       end
     end
   end

data/app/models/concerns/renalware/patients_ransack_helper.rb

@@ -52,16 +52,16 @@ module Renalware
 
       def identity_sql(query)
         sql = <<-SQL.squish
-          local_patient_id = :ucase_term OR
-          local_patient_id_2 = :ucase_term OR
-          local_patient_id_3 = :ucase_term OR
-          local_patient_id_4 = :ucase_term OR
-          local_patient_id_5 = :ucase_term OR
-          external_patient_id = :exact_term OR
-          nhs_number = :exact_term OR
-          family_name ILIKE :fuzzy_term
+          patients.local_patient_id = :ucase_term OR
+          patients.local_patient_id_2 = :ucase_term OR
+          patients.local_patient_id_3 = :ucase_term OR
+          patients.local_patient_id_4 = :ucase_term OR
+          patients.local_patient_id_5 = :ucase_term OR
+          patients.external_patient_id = :exact_term OR
+          patients.nhs_number = :exact_term OR
+          patients.family_name ILIKE :fuzzy_term
         SQL
-        sql += " OR ukrdc_external_id = :exact_term" if query_is_a_uuid?(query)
+        sql += " OR patients.ukrdc_external_id = :exact_term" if query_is_a_uuid?(query)
         sql
       end
       # rubocop:enable Metrics/MethodLength

data/app/models/concerns/renalware/personable.rb

@@ -4,18 +4,23 @@ module Renalware
 
     included do
       class_eval do
-        validates :given_name, presence: true
         validates :family_name, presence: true
+        validates :given_name,
+                  presence: {
+                    unless: -> {
+                      defined?(skip_given_name_validation?) && skip_given_name_validation?
+                    }
+                  }
       end
 
       def full_name
-        "#{given_name} #{family_name}"
+        [given_name, family_name].compact.join(" ")
       end
 
       def to_s(format = :default)
         case format
         when :default
-          "#{family_name}, #{given_name}"
+          [family_name, given_name].compact.join(", ")
         when :long
           "#{family_name}, #{given_name} (#{nhs_number})"
         end

data/app/models/concerns/renalware/string_logging.rb

@@ -0,0 +1,11 @@
+module Renalware
+  module StringLogging
+    extend ActiveSupport::Concern
+
+    def logging_to_stringio(string_io)
+      logger = ActiveSupport::Logger.new(string_io)
+      logger.formatter = Rails.configuration.log_formatter
+      Rails.logger = ActiveSupport::TaggedLogging.new(logger)
+    end
+  end
+end

data/app/models/renalware/admissions/admission.rb

@@ -0,0 +1,42 @@
+require_dependency "renalware/admissions"
+
+module Renalware
+  module Admissions
+    class Admission < ApplicationRecord
+      include Accountable
+      # PatientsRansackHelper adds the :identity_match scope for querying by patient name,
+      # local hospital id or NHS number. We use this scope from the filters on the admissions list
+      # to enable searching for a patient. *Note* you must join onto the patients table first
+      # if calling this scope or using it with ransack, e.g.
+      #   Admission.joins(:patient).identity_match("rab rog")
+
+      include PatientsRansackHelper
+      extend Enumerize
+
+      acts_as_paranoid
+
+      validates :patient_id, presence: true
+      validates :hospital_ward_id, presence: true
+      validates :admitted_on, presence: true
+      validates :reason_for_admission, presence: true
+      validates :admission_type, presence: true
+
+      belongs_to :patient
+      belongs_to :hospital_ward, class_name: "Hospitals::Ward"
+      belongs_to :summarised_by, class_name: "User"
+      belongs_to :modality_at_admission, class_name: "Modalities::Modality"
+
+      enumerize :admission_type, in: %i(unknown routine elective emergency consult transfer)
+      enumerize :discharge_destination, in: %i(home other_ward other_hosp itu death other)
+
+      scope :currently_admitted, lambda {
+        where(discharged_on: nil)
+      }
+
+      scope :discharged_but_missing_a_summary, lambda {
+        where("discharge_summary is null or discharge_summary = ?", "")
+          .where.not(discharged_on: nil)
+      }
+    end
+  end
+end

data/app/models/renalware/admissions/admission_query.rb

@@ -0,0 +1,38 @@
+require_dependency "renalware/admissions"
+require "attr_extras"
+
+module Renalware
+  module Admissions
+    class AdmissionQuery
+      pattr_initialize :query
+
+      def self.call(query)
+        new(query).call
+      end
+
+      def call
+        search.result
+      end
+
+      def search
+        @search ||= begin
+          Admission
+            .extending(Scopes)
+            .joins(:patient) # required for PatientsRansackHelper - see Admission
+            .includes(
+              hospital_ward: [:hospital_unit],
+              patient: { current_modality: [:description] }
+            )
+            .order(created_at: :desc)
+            .ransack(query)
+        end
+      end
+
+      module Scopes
+        def ransackable_scopes(_auth_object = nil)
+          %i(currently_admitted discharged_but_missing_a_summary identity_match)
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/admissions/admission_search_form.rb

@@ -0,0 +1,51 @@
+module Renalware
+  module Admissions
+    # Rather than using a Ransack Search object behind the form, as we do in many other places
+    # here we use a custom form object. This is mainly because we have a drop down of (virtual)
+    # statues, where each maps to a scope on Admission, where we want the selected 'status'
+    # to result in its associated scope being called. Ransack doesn't handle this, not
+    # surprisingly. So we have this thin form object around Ransack and do some pre-processing
+    # on the Status attribute (see #status_scope).
+    class AdmissionSearchForm
+      include ActiveModel::Model
+      include Virtus::Model
+
+      attribute :hospital_unit_id, Integer
+      attribute :hospital_ward_id, Integer
+      attribute :status, String
+      attribute :term, String
+
+      # Pass our simple form attributes to Ransack - we lean on Ransack to do querying
+      # so as to avoid unnecessary code here, though the magic obfuscates things a little...
+      def submit
+        @search ||= begin
+          options = {
+            hospital_ward_hospital_unit_id_eq: hospital_unit_id,
+            hospital_ward_id_eq: hospital_ward_id,
+            identity_match: term
+          }.merge!(status_scope)
+
+          AdmissionQuery.call(options)
+        end
+      end
+
+      def status_dropdown_options
+        [
+          ["Currently admitted", :currently_admitted],
+          ["Discharged but missing summary", :discharged_but_missing_a_summary]
+        ]
+      end
+
+      # If a status was selected in the drop down, map this to a ransack way of saying
+      # "call this scope on Admission", which is to pass the following (note the true
+      # which indicates the scope should be used):
+      #
+      #   { name_of_scope: true }
+      #
+      def status_scope
+        return {} if status.blank?
+        { status.to_sym => true }
+      end
+    end
+  end
+end

data/app/models/renalware/clinics/clinic_visit.rb

@@ -21,6 +21,7 @@ module Renalware
       validates :date, timeliness: { type: :date }
       validates :time, timeliness: { type: :time, allow_blank: true }
       validates :pulse, "renalware/patients/pulse" => true
+      validates :height, "renalware/patients/height" => true
       validates :temperature, "renalware/patients/temperature" => true
 
       enumerize :urine_blood, in: %i(neg trace very_low low medium high)

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

@@ -0,0 +1,31 @@
+require_dependency "renalware/feeds"
+
+module Renalware
+  module Feeds
+    class File < ApplicationRecord
+      include Accountable
+      extend Enumerize
+
+      validates :location, presence: true
+      validates :status, presence: true
+      validates :created_by, presence: true
+      validates :file_type, presence: true
+
+      belongs_to :file_type
+
+      enum status: { waiting: 0, processing: 1, success: 2, failure: 3 }
+
+      scope :ordered, ->{ order(created_at: :desc) }
+
+      def self.build(location:, file_type:, user: SystemUser.find)
+        new(
+          location: location,
+          file_type: file_type,
+          status: :waiting,
+          updated_by: user,
+          created_by: user
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require_dependency "renalware/feeds"
+
+module Renalware
+  module Feeds
+    class FileType < ApplicationRecord
+      validates :name, presence: true
+      validates :description, presence: true
+      validates :prompt, presence: true
+
+      has_many :files
+    end
+  end
+end