renalware-core 2.0.0.pre.beta4 → 2.0.0.pre.beta5

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

@@ -0,0 +1,19 @@
+require_dependency "renalware/messaging"
+
+module Renalware
+  module Messaging
+    class Message < ApplicationRecord
+      validates :body, presence: true
+      validates :subject, presence: true
+      validates :author, presence: true
+      validates :patient, presence: true
+      validates :sent_at, presence: true
+
+      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/messaging/message_factory.rb

@@ -0,0 +1,18 @@
+require_dependency "renalware/messaging"
+
+module Renalware
+  module Messaging
+    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

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

@@ -0,0 +1,34 @@
+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
+    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

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

@@ -0,0 +1,50 @@
+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
+    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

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

@@ -0,0 +1,13 @@
+require_dependency "renalware/messaging"
+
+module Renalware
+  module Messaging
+    class Patient < ActiveType::Record[Renalware::Patient]
+      has_many :messages
+
+      def to_s
+        super(:long)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require_dependency "renalware/messaging"
+
+module Renalware
+  module Messaging
+    class Receipt < ApplicationRecord
+      validates :recipient, presence: true
+      validates :message, presence: true
+
+      belongs_to :message
+      belongs_to :recipient
+
+      scope :unread, -> { where(read_at: nil) }
+
+      def read?
+        read_at.present?
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,85 @@
+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
+    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: "KCH",
+          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

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

@@ -0,0 +1,22 @@
+require_dependency "renalware/messaging"
+
+module Renalware
+  module Messaging
+    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

data/app/models/renalware/messaging.rb

@@ -0,0 +1,21 @@
+require_dependency "renalware"
+
+module Renalware
+  module Messaging
+    def self.table_name_prefix
+      "messaging_"
+    end
+
+    def self.cast_patient(patient)
+      ActiveType.cast(patient, ::Renalware::Messaging::Patient)
+    end
+
+    def self.cast_author(author)
+      ActiveType.cast(author, ::Renalware::Messaging::Author)
+    end
+
+    def self.cast_recipient(recipient)
+      ActiveType.cast(recipient, ::Renalware::Messaging::Recipient)
+    end
+  end
+end

data/app/models/renalware/modalities/change_patient_modality.rb

@@ -0,0 +1,112 @@
+require_dependency "renalware/modalities"
+
+module Renalware
+  module Modalities
+    class ChangePatientModality
+      include Broadcasting
+
+      attr_reader :patient, :user
+
+      def initialize(patient:, user:)
+        @patient = patient
+        @user = user
+      end
+
+      # Accepts an existing (unsaved) :modality, or builds a new one from the options hash.
+      # Terminates an existing current modality if once exists, and saves and make the new
+      # modality current.
+      # Example usage:
+      #
+      #   result = Modalities::ChangePatientModality
+      #    .new(patient: patient, user: curret_user)
+      #    .call(
+      #       description: HD::ModalityDescription.first!,
+      #       started_on: Time.zone.now
+      #    )
+      #
+      #  or
+      #
+      #  modality = patient.modalities.new(
+      #    description: HD::ModalityDescription.first!,
+      #    started_on: Time.zone.now
+      #  )
+      #  result = Modalities::ChangePatientModality
+      #    .new(patient: patient, user: curret_user)
+      #    .call(modality: modality)
+      #  )
+      #
+      # A Success or Failure result object is returned and the actual modality can be accessed on
+      # the result.object property.
+      #
+      # We can broadcast events to inform listeners the modality has changed.
+      # See #broadcast_modality_change_event_to_any_listeners for configuration.
+      #
+      def call(options)
+        new_modality = parse_options(options)
+        if new_modality.valid?
+          make_new_modality_the_current_one(new_modality)
+          broadcast_modality_change_event_to_any_listeners(new_modality)
+          Success.new(new_modality)
+        else
+          Failure.new(new_modality)
+        end
+      end
+
+      private
+
+      def make_new_modality_the_current_one(new_modality)
+        Modality.transaction do
+          current_modality.terminate_by(user, on: new_modality.started_on)
+          new_modality.save_by!(user)
+        end
+      end
+
+      # Broadcast (using Wisper) an event to indicate the patient's current modality has changed,
+      # This allows classes in other modules/parts of the application to take appropriate action.
+      # For example the Letters module may want to terminate all patient prescriptions if the
+      # modality changes to Death.
+      #
+      # The list of subscribers/listeners who will receive the message is set in the Broadcasting
+      # module which we mix in above _proveided_ the caller has chained the
+      # #broadcasting_to_configured_subscribers method like so
+      #
+      # result = Modalities::ChangePatientModality
+      #            .new(..)
+      #            .broadcasting_to_configured_subscribers
+      #            .call(..)
+      #
+      # If you wish to add more listeners and these are site/hospital-specific, this can be done
+      # by configuring Renalware.config.broadcast_subscription_map. Be careful to append to rather
+      # than replace the default entries in the hash map.
+      # For example in a your applications config/initalizers/renalware_core.rb, add:
+      #  Renalware.configure do |config|
+      #   map = config.broadcast_subscription_map
+      #   map["Renalware::Modalities::ChangePatientModality"] << "SomeNamespace::SomeListenerClass"
+      #  end
+      #
+      # When broadcasting events, if the event description has a #.to_sym e.g :hd or :death
+      # then we use that in the name of the event, e.g. `patient_modality_changed_to_death`.
+      # Otherwise, for more generic events we use `patient_modality_changed`.
+      # I'm not sure this is a very consistent approach so may need to revisit.
+      def broadcast_modality_change_event_to_any_listeners(new_modality)
+        type = new_modality.description.to_sym
+        method_name = type.nil? ? :patient_modality_changed : :"patient_modality_changed_to_#{type}"
+        broadcast(
+          method_name,
+          patient: patient,
+          modality: new_modality,
+          actor: user
+        )
+      end
+
+      def parse_options(options)
+        return options[:modality] if options.key?(:modality)
+        patient.modalities.new(options)
+      end
+
+      def current_modality
+        patient.current_modality || NullObject.instance
+      end
+    end
+  end
+end

data/app/models/renalware/modalities/description.rb

@@ -5,15 +5,19 @@ module Renalware
     class Description < ApplicationRecord
       acts_as_paranoid
 
-      validates :name, presence: true
-
-      def self.policy_class
-        BasePolicy
-      end
+      validates :name, presence: true, uniqueness: true
 
       def to_s
         name
       end
+
+      def to_sym
+        nil
+      end
+
+      def self.policy_class
+        Modalities::DescriptionPolicy
+      end
     end
   end
 end

data/app/models/renalware/modalities/modality.rb

@@ -11,25 +11,19 @@ module Renalware
       belongs_to :reason, class_name: "Reason"
 
       scope :ordered, -> { order(ended_on: :desc, updated_at: :desc) }
-
       scope :started_on_reversed, -> { order(started_on: :desc, updated_at: :desc) }
       scope :last_started_on, -> { started_on_reversed.where(ended_on: nil) }
 
       validates :patient, presence: true
       validates :started_on, presence: true
       validates :description, presence: true
-
       validates :started_on, timeliness: { type: :date }
-
       validate :validate_modality_starts_later_than_previous, on: :create, if: :patient
 
-      def transfer!(attrs)
-        transaction do
-          successor = patient.modalities.new(attrs)
-          successor.save!
-          terminate!(successor) if successor.valid?
-          successor
-        end
+      def terminate_by(user, on:)
+        self.ended_on = on
+        self.state = "terminated"
+        save_by!(user)
       end
 
       def to_s

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

@@ -0,0 +1,10 @@
+require_dependency "renalware/pathology"
+
+module Renalware
+  module Pathology
+    class MeasurementUnit < ApplicationRecord
+      validates :name, presence: true
+      has_many :observation_descriptions
+    end
+  end
+end

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

@@ -3,6 +3,8 @@ require_dependency "renalware/pathology"
 module Renalware
   module Pathology
     class ObservationDescription < ApplicationRecord
+      belongs_to :measurement_unit
+
       def self.for(codes)
         ObservationDescriptionsByCodeQuery.new(codes: codes).call
       end

data/app/models/renalware/pathology/requests/global_algorithm.rb

@@ -13,7 +13,7 @@ module Renalware
         def determine_required_request_descriptions
           rule_sets
             .select { |rule_set| rule_set.observation_required_for_patient?(@patient, @date) }
-            .map { |rule_set| rule_set.request_description }
+            .map(&:request_description)
             .uniq
         end
 

data/app/models/renalware/pathology/requests/high_risk_rule_set.rb

@@ -10,7 +10,7 @@ module Renalware
       class HighRiskRuleSet
 
         def self.rules
-          GlobalRule.where(rule_set_type: self.name)
+          GlobalRule.where(rule_set_type: name)
         end
 
         def self.primary_key

data/app/models/renalware/patient.rb

@@ -29,11 +29,12 @@ module Renalware
 
     has_one :current_key_observation_set, class_name: "Pathology::CurrentKeyObservationSet"
     has_one :current_address, as: :addressable, class_name: "Address"
-    has_one :summary, class_name: "PatientSummary"
+    has_one :summary, class_name: "Patients::Summary"
     belongs_to :ethnicity, class_name: "Patients::Ethnicity"
     belongs_to :religion, class_name: "Patients::Religion"
     belongs_to :language, class_name: "Patients::Language"
     has_many :bookmarks, class_name: "Patients::Bookmark"
+    has_many :alerts, class_name: "Patients::Alert"
     has_one :worry, class_name: "Patients::Worry"
 
     belongs_to :first_cause, class_name: "Deaths::Cause", foreign_key: :first_cause_id
@@ -123,13 +124,18 @@ module Renalware
 
     # @section services
 
-    def set_modality(attrs)
-      if current_modality.present?
-        current_modality.transfer!(attrs)
-      else
-        modalities.create(attrs)
-      end
-    end
+    # def set_modality(attrs, by: nil)
+    #   by ||= attrs[:by]
+    #   # if current_modality.present?
+    #   #   current_modality.transfer!(attrs)
+    #   # else
+    #   #   modalities.create(attrs)
+    #   # end
+    #   new_modality = modalities.new(attrs)
+    #   Modalities::ChangePatientModality
+    #     .new(patient: self, by: by)
+    #     .call(old_modality: current_modality, new_modality:new_modality)
+    # end
 
     def current_modality_death?
       return false if current_modality.blank?

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

@@ -0,0 +1,15 @@
+require_dependency "renalware/patients"
+
+module Renalware
+  module Patients
+    class Alert < ApplicationRecord
+      include Accountable
+      acts_as_paranoid
+
+      validates :patient, presence: true
+      validates :notes, presence: true
+
+      belongs_to :patient
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Renalware
+  module Patients
+    class PatientSearch
+      def self.call(params)
+        Renalware::Patient
+          .includes(current_modality: [:description])
+          .search(params[:q]).tap do |search|
+          search.sorts = %w(family_name given_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require_dependency "renalware"
+
+##
+# Backed by a SQL view, the patient summary is principally a set of counts fo various entities
+# which hang off a patient, for example prescriptions_count, problems_count etc.
+# These can be used for instance when building the patient navigation.
+#
+module Renalware
+  module Patients
+    class Summary < ApplicationRecord
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require_dependency "renalware/patients"
+
+module Renalware
+  module Patients
+    class WorryQuery
+      attr_reader :query_params
+
+      def initialize(query_params)
+        @query_params = query_params
+        @query_params[:s] = "date_time DESC" if @query_params[:s].blank?
+      end
+
+      def call
+        search
+          .result
+          .includes(:created_by, patient: { current_modality: [:description] })
+          .order(created_at: :asc)
+          .page(query_params[:page])
+          .per(query_params[:per_page])
+      end
+
+      def search
+        @search ||= Worry.ransack(query_params)
+      end
+    end
+  end
+end

data/app/models/renalware/pd/modality_description.rb

@@ -3,6 +3,9 @@ require_dependency "renalware/pd"
 module Renalware
   module PD
     class ModalityDescription < Modalities::Description
+      def to_sym
+        :pd
+      end
     end
   end
 end

data/app/models/renalware/pd.rb

@@ -25,7 +25,7 @@ module Renalware
 
       config_accessor(:delivery_intervals) { [1.week, 2.weeks, 3.weeks, 4.weeks] }
 
-      config_accessor(:training_durations) { (1..15).map{ |day| day.days } }
+      config_accessor(:training_durations) { (1..15).map(&:days) }
 
     end
 

data/app/models/renalware/transplants/mdm_patients_query.rb

@@ -23,6 +23,7 @@ module Renalware
       def search
         @search ||= begin
           relation
+            .includes(:current_key_observation_set)
             .extending(ModalityScopes)
             .extending(NamedFilterScopes)
             .with_current_modality_matching(MODALITY_NAMES)

data/app/policies/renalware/hd/station_policy.rb

@@ -0,0 +1,9 @@
+module Renalware
+  module HD
+    class StationPolicy < BasePolicy
+      def sort?
+        edit?
+      end
+    end
+  end
+end

data/app/policies/renalware/messaging/message_policy.rb

@@ -0,0 +1,11 @@
+require_dependency "renalware/messaging"
+
+module Renalware
+  module Messaging
+    class MessagePolicy < BasePolicy
+      def sent?
+        index?
+      end
+    end
+  end
+end