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

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

@@ -20,6 +20,10 @@ module Renalware
                dependent: :destroy,
                inverse_of: :letter
       has_many :recipients, dependent: :destroy
+      has_many :electronic_receipts, dependent: :destroy
+      has_many :electronic_cc_recipients,
+               through: :electronic_receipts,
+               source: :recipient
       has_one :signature, dependent: :destroy
       has_one :archive, foreign_key: "letter_id"
 

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

@@ -10,7 +10,9 @@ module Renalware
       end
 
       def build
+        @electronic_cc_recipient_ids = params.delete(:electronic_cc_recipient_ids)
         @letter = build_letter
+        build_electronic_ccs
         include_primary_care_physician_as_default_main_recipient
         assign_default_ccs
         build_salutation
@@ -25,7 +27,7 @@ module Renalware
 
       private
 
-      attr_reader :patient, :letter, :params
+      attr_reader :patient, :letter, :params, :electronic_cc_recipient_ids
 
       def build_letter
         # We should not have to set the STI type manually here but in some circumstances
@@ -48,6 +50,24 @@ module Renalware
         patient.contacts.default_ccs
       end
 
+      # Deal with wiring up new electronic CCs in the new, unsaved letter.
+      # NB: The way electronic CCs are handled on building a new Letter and on updating an existing
+      # one is different: when updating an existing letter (see code elsewhere) we lean on rails
+      # doing some magic for us; as long as we have an array of electronic_cc_recipients in the
+      # params, it will add/remove an associated electronic_receipt object for us (assigning the
+      # letter_id to them in the process), because we used
+      #   has_many :electronic_cc_recipients, through: :electronic_receipts
+      # However, here, as we have no letter.id (letter is unsaved), Rails cannot yet create the
+      # implied electronic_receipt object for each electronic_cc_recipient for us - we must do it
+      # ourselves using electronic_receipts.build so rails will update the letter id in each when
+      # the parent letter is saved.
+      def build_electronic_ccs
+        return if electronic_cc_recipient_ids.blank?
+        electronic_cc_recipient_ids.reject(&:blank?).map do |user_id|
+          letter.electronic_receipts.build(recipient_id: user_id)
+        end
+      end
+
       def build_salutation
         letter.salutation ||= begin
           main_recipient = letter.main_recipient

data/app/models/renalware/messaging.rb

@@ -2,20 +2,36 @@ require_dependency "renalware"
 
 module Renalware
   module Messaging
-    def self.table_name_prefix
+    module_function
+    def table_name_prefix
       "messaging_"
     end
 
-    def self.cast_patient(patient)
+    def cast_patient(patient)
       ActiveType.cast(patient, ::Renalware::Messaging::Patient)
     end
 
-    def self.cast_author(author)
+    def cast_author(author)
       ActiveType.cast(author, ::Renalware::Messaging::Author)
     end
 
-    def self.cast_recipient(recipient)
-      ActiveType.cast(recipient, ::Renalware::Messaging::Recipient)
+    # def cast_recipient(recipient)
+    #   ActiveType.cast(recipient, ::Renalware::Messaging::Recipient)
+    # end
+
+    module Internal
+      module_function
+      def cast_patient(patient)
+        ActiveType.cast(patient, ::Renalware::Messaging::Internal::Patient)
+      end
+
+      def cast_author(author)
+        ActiveType.cast(author, ::Renalware::Messaging::Internal::Author)
+      end
+
+      def cast_recipient(recipient)
+        ActiveType.cast(recipient, ::Renalware::Messaging::Internal::Recipient)
+      end
     end
   end
 end

data/app/models/renalware/messaging/internal/author.rb

@@ -0,0 +1,11 @@
+require_dependency "renalware/messaging"
+
+module Renalware
+  module Messaging
+    module Internal
+      class Author < ActiveType::Record[Renalware::User]
+        has_many :messages
+      end
+    end
+  end
+end

data/app/models/renalware/messaging/internal/message.rb

@@ -0,0 +1,15 @@
+require_dependency "renalware/messaging"
+
+module Renalware
+  module Messaging
+    module Internal
+      class Message < Renalware::Messaging::Message
+        belongs_to :author, class_name: "Internal::Author"
+        has_many :receipts
+        has_many :recipients, through: :receipts
+        belongs_to :replying_to_message, class_name: name
+        scope :ordered, ->{ order(sent_at: :desc) }
+      end
+    end
+  end
+end

data/app/models/renalware/messaging/internal/message_factory.rb

@@ -0,0 +1,20 @@
+require_dependency "renalware/messaging"
+
+module Renalware
+  module Messaging
+    module Internal
+      class MessageFactory
+        def self.build(**attributes)
+          attributes[:sent_at] ||= Time.zone.now
+          recipient_ids = attributes.delete(:recipient_ids) || []
+
+          Message.new(attributes).tap do |message|
+            recipient_ids.each do |recipient_id|
+              message.receipts.build(recipient_id: recipient_id)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/messaging/internal/message_form.rb

@@ -0,0 +1,36 @@
+require_dependency "renalware/messaging"
+
+# A form object used behind the html messages#new form, and serving to helps us capture
+# attributes for a Message and its Recipients. The MessageForm is passed to the SendMessage
+# object where it is persisted as a Message with many Recipients through Receipts.
+module Renalware
+  module Messaging
+    module Internal
+      class MessageForm
+        include ActiveModel::Model
+        include Virtus::Model
+
+        attribute :body, String
+        attribute :subject, String
+        attribute :urgent, Boolean, default: false
+        attribute :recipient_ids, Array, default: []
+        attribute :replying_to_message_id
+
+        validates :body, presence: true
+        validates :subject, presence: true
+        validates :recipient_ids, presence: true, length: { minimum: 1 }
+
+        def initialize(attributes = {})
+          remove_blank_recipient_ids_from(attributes)
+          super
+        end
+
+        private
+
+        def remove_blank_recipient_ids_from(params)
+          params[:recipient_ids].reject!(&:blank?) if params.key?(:recipient_ids)
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/messaging/internal/message_form_builder.rb

@@ -0,0 +1,52 @@
+require_dependency "renalware/messaging"
+
+# Builds a new MessageForm form object. MessageForm is used behind the html form when displaying a
+# `Send Message` Dialog the first time. Note that we don't use this builder again on e.g.
+# form submission - at that point all the required params are in the form payload - this is
+# only for the initial MesageForm creation.
+#
+module Renalware
+  module Messaging
+    module Internal
+      class MessageFormBuilder
+        attr_reader :patient, :params
+
+        def initialize(patient:, params:)
+          @patient = patient
+          @params = params
+        end
+
+        def call
+          MessageForm.new(
+            subject: build_subject,
+            recipient_ids: build_recipient_ids,
+            replying_to_message_id: replying_to_message_id
+          )
+        end
+
+        private
+
+        def build_subject
+          replying? ? "Re: #{replying_to_message.subject}" : patient.to_s
+        end
+
+        def build_recipient_ids
+          replying? ? Array(replying_to_message.author_id) : []
+        end
+
+        def replying_to_message
+          return NullObject.instance unless replying?
+          @replying_to_message ||= Message.find(replying_to_message_id)
+        end
+
+        def replying_to_message_id
+          params[:replying_to_message_id]
+        end
+
+        def replying?
+          replying_to_message_id.present?
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/messaging/internal/receipt.rb

@@ -0,0 +1,26 @@
+require_dependency "renalware/messaging"
+
+module Renalware
+  module Messaging
+    module Internal
+      class Receipt < ApplicationRecord
+        validates :recipient, presence: true
+        validates :message, presence: true
+
+        belongs_to :message
+        belongs_to :recipient
+
+        scope :unread, -> { where(read_at: nil) }
+        scope :read, -> { where.not(read_at: nil) }
+        scope :ordered, -> { joins(:message).merge(Message.ordered) }
+        scope :sent_by, lambda{ |user_id|
+          joins(:message).where(messaging_messages: { author_id: user_id })
+        }
+
+        def read?
+          read_at.present?
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/messaging/internal/recipient.rb

@@ -0,0 +1,12 @@
+require_dependency "renalware/messaging"
+
+module Renalware
+  module Messaging
+    module Internal
+      class Recipient < ActiveType::Record[Renalware::User]
+        has_many :receipts
+        has_many :messages, through: :receipts
+      end
+    end
+  end
+end

data/app/models/renalware/messaging/internal/recipient_options.rb

@@ -0,0 +1,87 @@
+require_dependency "renalware/messaging"
+
+# Builds grouped drop down options for potential private message recipients.
+# The groups are:
+# - users who have recently received a message about the current patient
+# - users who have recently received a message from the current author (excluding those already
+#   listed in the above group)
+# - all remaining users
+#
+# The author is excluded from all lists so they cannot send to themselves
+#
+module Renalware
+  module Messaging
+    module Internal
+      class RecipientOptions
+        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_a_message_about_patient,
+            users_having_recently_received_messages_from_author,
+            all_other_users
+          ]
+        end
+
+        private
+
+        def users_having_previously_received_a_message_about_patient
+          Group.new(
+            name: "Previous patient recipients",
+            users: Recipient.where(id: ids_of_users_having_received_a_message_about_patient)
+          )
+        end
+
+        def users_having_recently_received_messages_from_author
+          Group.new(
+            name: "Other recent recipients",
+            users: Recipient.where(id: ids_of_users_having_received_messages_from_author)
+          )
+        end
+
+        def all_other_users
+          ids_to_exclude = ids_of_users_having_received_a_message_about_patient +
+                           ids_of_users_having_received_messages_from_author
+          Group.new(
+            name: "All other users",
+            users: Recipient.where.not(id: ids_to_exclude)
+          )
+        end
+
+        def ids_of_users_having_received_a_message_about_patient
+          @ids_of_users_having_received_a_message_about_patient ||= begin
+            Message
+              .includes(:receipts)
+              .eager_load(:receipts)
+              .where(patient: patient)
+              .limit(20)
+              .pluck(:author_id, :recipient_id)
+              .flatten.uniq.compact
+          end
+        end
+
+        def ids_of_users_having_received_messages_from_author
+          @ids_of_users_having_received_messages_from_author ||= begin
+            ids = Message
+              .includes(:receipts).eager_load(:receipts)
+              .where(author: author)
+              .limit(20)
+              .pluck(:recipient_id).uniq.compact
+            ids - ids_of_users_having_received_a_message_about_patient
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/messaging/internal/send_message.rb

@@ -0,0 +1,24 @@
+require_dependency "renalware/messaging"
+
+module Renalware
+  module Messaging
+    module Internal
+      class SendMessage
+
+        def self.call(*args)
+          new.call(*args)
+        end
+
+        def call(author:, patient:, form:)
+          Message.transaction do
+            message = MessageFactory.build(patient: patient,
+                                           author: author,
+                                           **form.attributes)
+            message.save!
+            message
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/renalware/messaging/message.rb

@@ -1,5 +1,9 @@
 require_dependency "renalware/messaging"
 
+#
+# Abstract Message base class.
+# Use Internal::Message etc. subclasses (stored via STI).
+#
 module Renalware
   module Messaging
     class Message < ApplicationRecord
@@ -11,9 +15,6 @@ module Renalware
 
       belongs_to :patient
       belongs_to :author
-      belongs_to :replying_to_message, class_name: name
-      has_many :receipts
-      has_many :recipients, through: :receipts
     end
   end
 end

data/app/models/renalware/pathology.rb

@@ -10,7 +10,7 @@ module Renalware
       "pathology_"
     end
 
-    def self.cast_patient(patient)
+    def cast_patient(patient)
       ActiveType.cast(patient, ::Renalware::Pathology::Patient)
     end
 

data/app/models/renalware/pathology/message_param_parser.rb

@@ -6,6 +6,8 @@ module Renalware
     # that can be persisted by ObservationRequest.
     #
     class MessageParamParser
+
+      # message_payload is an HL7Message (a decorator around an ::HL7::Message)
       def parse(message_payload)
         request = message_payload.observation_request
 

data/app/models/renalware/patients/search_filter.rb

@@ -0,0 +1,32 @@
+# Works in concert with Patients::SearchQuery and Patients::SearchForm.
+# Example usage in a controller:
+#
+#   my_relation = Thing.all.joins(:patient)
+#   filter = Patients::SearchFilter.new(search_term, request)
+#   my_relation = patient_filter.call(my_relation)
+#   render locals: { search_form: filter.search_form }
+require_dependency "renalware/patients"
+
+module Renalware
+  module Patients
+    class SearchFilter
+      attr_reader :search_form
+
+      def initialize(search_term, request)
+        @search_form = build_search_form(search_term, request)
+      end
+
+      def call(relation)
+        matching_patients = Patients::SearchQuery.new(term: search_form.term).call
+        relation.merge(matching_patients)
+      end
+
+      def build_search_form(search_term, request)
+        Patients::SearchForm.new(
+          term: search_term,
+          url: request.path
+        )
+      end
+    end
+  end
+end