renalware-core 2.0.0.pre.beta7 → 2.0.0.pre.beta8

data/app/controllers/renalware/letters/letters_controller.rb

@@ -131,8 +131,12 @@ module Renalware
         contacts = find_contacts
         contact = build_contact
         render action, locals: {
-          patient: @patient, letter: letter, contact: contact,
-            contacts: contacts, contact_descriptions: find_contact_descriptions
+          patient: @patient,
+          letter: letter,
+          contact: contact,
+          contacts: contacts,
+          contact_descriptions: find_contact_descriptions,
+          electronic_recipient_options: electronic_recipient_options
         }
       end
 
@@ -153,6 +157,10 @@ module Renalware
         Contact.new.tap(&:build_person)
       end
 
+      def electronic_recipient_options
+        ElectronicRecipientOptions.new(patient, current_user)
+      end
+
       def event_class
         @event_class ||= event_type.singularize.classify.constantize
       end
@@ -178,7 +186,8 @@ module Renalware
           :letterhead_id, :author_id, :description, :issued_on, :enclosures,
           :salutation, :body, :notes,
           main_recipient_attributes: main_recipient_attributes,
-          cc_recipients_attributes: cc_recipients_attributes
+          cc_recipients_attributes: cc_recipients_attributes,
+          electronic_cc_recipient_ids: []
         ]
       end
 
@@ -194,6 +203,12 @@ module Renalware
         ]
       end
 
+      # def electronic_receipts_attributes
+      #   [
+      #     :recipient_id
+      #   ]
+      # end
+
       def address_attributes
         [
           :id, :name, :organisation_name, :street_1, :street_2, :street_3, :town, :county,

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

@@ -0,0 +1,75 @@
+require_dependency "renalware/messaging"
+
+module Renalware
+  module Messaging
+    module Internal
+      class MessagesController < BaseController
+        include Renalware::Concerns::Pageable
+        include PresenterHelper
+
+        def sent
+          messages = author.messages.page(page).per(per_page)
+          authorize messages
+          render locals: { messages: present(messages, MessagePresenter) }
+        end
+
+        def new
+          authorize Message, :new?
+          form = MessageFormBuilder.new(patient: patient, params: params).call
+          render_new(form)
+        end
+
+        def create
+          authorize Message, :create?
+          form = MessageForm.new(message_params)
+
+          if form.valid?
+            message = SendMessage.call(author: author, patient: patient, form: form)
+            flash.now[:notice] = "Message was successfully sent"
+            render_create(message)
+          else
+            render_new(form)
+          end
+        end
+
+        private
+
+        def message_we_are_replying_to(message)
+          return if message.replying_to_message_id.blank?
+          MessagePresenter.new(message.replying_to_message)
+        end
+
+        def render_new(form)
+          render :new,
+                  locals: {
+                    form: form,
+                    recipient_options: RecipientOptions.new(patient, author).to_a,
+                    patient: patient
+                  },
+                  layout: false
+        end
+
+        def render_create(message)
+          render locals: {
+            message: MessagePresenter.new(message),
+            original_message: message_we_are_replying_to(message)
+          }
+        end
+
+        def author
+          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: [])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+require_dependency "renalware/messaging"
+
+# A Receipt is cross reference between Message and Recipient.
+# We can for instance mark on a receipt if/when it was read or viewed.
+module Renalware
+  module Messaging
+    module Internal
+      class ReceiptsController < BaseController
+        include Renalware::Concerns::Pageable
+        include PresenterHelper
+
+        # GET aka inbox
+        def unread
+          render_receipts(receipts.unread)
+        end
+
+        # GET all read messages
+        def read
+          render_receipts(receipts.read)
+        end
+
+        def sent
+          render_receipts(sent_receipts)
+        end
+
+        # PATCH
+        def mark_as_read
+          authorize receipt
+          receipt.update(read_at: Time.zone.now)
+          render locals: {
+            receipt: ReceiptPresenter.new(receipt)
+          }
+        end
+
+        private
+
+        def render_receipts(receipts)
+          patient_filter = Patients::SearchFilter.new(search_term, request)
+          receipts = receipts.joins(message: [:patient])
+          receipts = patient_filter.call(receipts).ordered.page(page).per(per_page)
+          authorize receipts
+
+          render locals: {
+            receipts: present(receipts, ReceiptPresenter),
+            search_form: patient_filter.search_form
+          }
+        end
+
+        def receipts
+          @receipts ||= recipient.receipts.page(page).per(per_page)
+        end
+
+        def receipt
+          @receipt ||= recipient.receipts.find_by!(
+            message_id: params[:message_id],
+            id: params[:id]
+          )
+        end
+
+        def recipient
+          Messaging::Internal.cast_recipient(current_user)
+        end
+
+        def search_term
+          params.fetch(:patient_search, {}).fetch(:term, nil)
+        end
+
+        def sent_receipts
+          Receipt.sent_by(current_user.id)
+        end
+      end
+    end
+  end
+end

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

@@ -17,7 +17,8 @@ module Renalware
       def search
         skip_authorization
         query = Patients::SearchQuery.new(term: params[:term])
-        render json: query.call.to_json
+        patients = query.call.page(page).per(per_page)
+        render json: simplify(patients).to_json
       end
 
       def new
@@ -65,6 +66,15 @@ module Renalware
 
       private
 
+      def simplify(patients)
+        patients.map do |patient|
+          {
+            id: patient.id,
+            text: patient.to_s(:long)
+          }
+        end
+      end
+
       def patient_params
         params
           .require(:patient)

data/app/controllers/renalware/session_timeout_controller.rb

@@ -52,7 +52,7 @@ module Renalware
     def referrer_is_a_devise_url?
       referrer = request.referer
       return if request.blank?
-      regex_defining_devise_paths = /#{new_user_session_path}/
+      regex_defining_devise_paths = %r{(#{new_user_session_path}|users\/password|users\/sign_up)}
       URI.parse(referrer).path =~ regex_defining_devise_paths
     end
   end

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

@@ -1,4 +1,4 @@
-# rubocop:disable Style/EmptyLineBetweenDefs, Style/SingleLineMethods
+# rubocop:disable Layout/EmptyLineBetweenDefs, Style/SingleLineMethods
 require "document/embedded"
 require "document/enum"
 

data/app/helpers/renalware/application_helper.rb

@@ -4,6 +4,11 @@ require "breadcrumb"
 
 module Renalware
   module ApplicationHelper
+    include Renalware::Engine.routes.url_helpers
+
+    def default_patient_link(patient)
+      link_to(patient, patient_clinical_summary_path(patient))
+    end
 
     def patient_search
       ::Renalware::Patients::PatientSearch.call(params)

data/app/helpers/renalware/xhr_helper.rb

@@ -7,5 +7,12 @@ module Renalware
         $("#{el}").html("#{escape_javascript(render(partial, locals))}");
       EOS
     end
+
+    def replace(el, partial:, locals:)
+      <<-EOS.squish.html_safe
+        $("#{el}").replaceWith("#{escape_javascript(render(partial, locals))}");
+        $("#{el}").addClass("post-action-highlight");
+      EOS
+    end
   end
 end

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

@@ -10,7 +10,7 @@ module Renalware
     included do
       class_eval do
         devise(:expirable, :database_authenticatable, :registerable,
-               :rememberable, :trackable, :validatable, :timeoutable)
+               :rememberable, :trackable, :validatable, :timeoutable, :recoverable)
       end
 
       # Makes the User 'approvable'

data/app/models/renalware/admissions.rb

@@ -0,0 +1,7 @@
+module Renalware
+  module Admissions
+    def self.table_name_prefix
+      "admission_"
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require_dependency "renalware/admissions"
+
+module Renalware
+  module Admissions
+    class Request < ApplicationRecord
+      include Accountable
+      extend Enumerize
+
+      acts_as_paranoid
+
+      belongs_to :patient
+      belongs_to :reason, class_name: "RequestReason"
+
+      validates :patient_id, presence: true, uniqueness: true
+      validates :reason_id, presence: true
+      validates :priority, presence: true
+
+      enumerize :priority, in: %i(low medium high urgent)
+
+      scope :ordered, ->{ order(position: :asc) }
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require_dependency "renalware/admissions"
+
+module Renalware
+  module Admissions
+    class RequestReason < ApplicationRecord
+      acts_as_paranoid
+      validates :description, presence: true
+      scope :ordered, ->{ order(description: :asc) }
+    end
+  end
+end

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

@@ -2,8 +2,8 @@ require_dependency "renalware/feeds"
 
 module Renalware
   module Feeds
-    # Responsible for co-ordinating the processing sequences of a raw
-    # HL7 message.
+    #
+    # Responsible for coordinating the processing sequences of a raw HL7 message.
     #
     class MessageProcessor
       include Wisper::Publisher

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

@@ -3,6 +3,8 @@ require_dependency "renalware/feeds"
 module Renalware
   module Feeds
     class PersistMessage
+
+      # message_payload is an HL7Message (a decorator around ::HL7::Message)
       def call(message_payload)
         Message.create!(
           event_code: message_payload.type,

data/app/models/renalware/hd/sessions/auditable_session.rb

@@ -44,6 +44,10 @@ module Renalware
           (dialysis_minutes_shortfall.to_f / prescribed_time.to_f) * 100.0
         end
 
+        def dialysis_minutes_shortfall_gt_5_pct?
+          dialysis_minutes_shortfall_percentage > 5.0
+        end
+
         def weight_loss
           document.observations_before.weight.to_f - document.observations_after.weight.to_f
         end

data/app/models/renalware/hd/sessions/auditable_session_collection.rb

@@ -33,6 +33,7 @@ module Renalware
           mean_blood_flow
           mean_litres_processed
           mean_ufr
+          number_of_sessions_with_dialysis_minutes_shortfall_gt_5_pct
         ).freeze
 
         def to_h
@@ -86,6 +87,10 @@ module Renalware
           MeanValueStrategy.new(sessions: closed_sessions, selector: selector).call.round(2)
         end
 
+        def number_of_sessions_with_dialysis_minutes_shortfall_gt_5_pct
+          sessions.count(&:dialysis_minutes_shortfall_gt_5_pct?)
+        end
+
         def mean_ufr
           selector = ->(session) { session.ufr }
           MeanValueStrategy.new(sessions: closed_sessions, selector: selector).call

data/app/models/renalware/hd/update_rolling_patient_statistics.rb

@@ -1,6 +1,6 @@
 module Renalware
   module HD
-    class UpdateRollingPatientStatistics < ActiveJob::Base
+    class UpdateRollingPatientStatistics < ApplicationJob
 
       def initialize(patient:)
         @patient = patient
@@ -24,7 +24,7 @@ module Renalware
       end
 
       def auditable_sessions
-        @auditable_sessions ||= Sessions:: AuditableSessionCollection.new(recent_sessions)
+        @auditable_sessions ||= Sessions::AuditableSessionCollection.new(recent_sessions)
       end
 
       def rolling_stats_for_this_patient

data/app/models/renalware/letters/electronic_receipt.rb

@@ -0,0 +1,35 @@
+require_dependency "renalware/letters"
+
+# Represents an Electronic CC - a reference to a letter sent to a recipient (another user on the
+# system) as a 'CC'. We use the concept of a 'receipt' which, while mainly being a cross table
+# between letter and recipient user, is also a well-named place to store related information
+# for example whether the message has been read (e.g. the letter viewed).
+module Renalware
+  module Letters
+    class ElectronicReceipt < ApplicationRecord
+      belongs_to :letter
+      belongs_to :recipient, class_name: "Renalware::User"
+      validates :letter, presence: true
+      validates :recipient_id, presence: true
+
+      # Merge scope here to make sure we only get approved letters
+      scope :sent_by, lambda{ |user_id|
+        joins(:letter)
+          .merge(Letter::Approved.all)
+          .where(letter_letters: { author_id: user_id })
+      }
+      scope :unread, -> { where(read_at: nil).joins(:letter).merge(Letter::Approved.all) }
+      scope :read, -> { where.not(read_at: nil).joins(:letter).merge(Letter::Approved.all) }
+      scope :for_recipient, ->(user_id) { where(recipient_id: user_id) }
+      scope :ordered, -> { order(created_at: :desc) }
+
+      def read?
+        read_at.present?
+      end
+
+      def unread?
+        !read?
+      end
+    end
+  end
+end

data/app/models/renalware/letters/electronic_recipient_options.rb

@@ -0,0 +1,78 @@
+require_dependency "renalware/letters"
+
+module Renalware
+  module Letters
+    class ElectronicRecipientOptions
+      attr_reader :patient, :author
+
+      class Group
+        include Virtus.model
+        attribute :name, String
+        attribute :users, Array, default: []
+      end
+
+      def initialize(patient, author)
+        @patient = patient
+        @author = author
+      end
+
+      def to_a
+        [
+          users_having_previously_received_been_cced_about_this_patient,
+          users_having_recently_been_cced_by_author,
+          all_other_users
+        ]
+      end
+
+      private
+
+      def users_having_previously_received_been_cced_about_this_patient
+        Group.new(
+          name: "Previous CC recipients",
+          users: User.where(
+            id: ids_of_users_having_previously_received_been_cced_about_this_patient
+          )
+        )
+      end
+
+      def users_having_recently_been_cced_by_author
+        Group.new(
+          name: "Other recent recipients",
+          users: User.where(id: ids_of_users_having_recently_been_cced_by_author)
+        )
+      end
+
+      def all_other_users
+        ids_to_exclude = ids_of_users_having_previously_received_been_cced_about_this_patient +
+                         ids_of_users_having_recently_been_cced_by_author
+        Group.new(
+          name: "All other user",
+          users: User.where.not(id: ids_to_exclude)
+        )
+      end
+
+      def ids_of_users_having_previously_received_been_cced_about_this_patient
+        @ids_of_users_having_previously_received_been_cced_about_this_patient ||= begin
+          Letter
+            .includes(:electronic_receipts)
+            .eager_load(:electronic_receipts)
+            .where(patient: patient)
+            .limit(20)
+            .pluck(:recipient_id)
+            .flatten.uniq.compact
+        end
+      end
+
+      def ids_of_users_having_recently_been_cced_by_author
+        @ids_of_users_having_recently_been_cced_by_author ||= begin
+          ids = Letter
+            .includes(:electronic_receipts).eager_load(:electronic_receipts)
+            .where(author: author)
+            .limit(20)
+            .pluck(:recipient_id).uniq.compact
+          ids - ids_of_users_having_previously_received_been_cced_about_this_patient
+        end
+      end
+    end
+  end
+end