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

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

@@ -1,73 +0,0 @@
-require_dependency "renalware/messaging"
-
-module Renalware
-  module Messaging
-    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, Messaging::InternalMessagePresenter) }
-      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?
-        InternalMessagePresenter.new(message.replying_to_message)
-      end
-
-      def render_new(form)
-        render :new,
-                locals: {
-                  form: form,
-                  recipient_options: RecipientOptions.new(patient, current_user).to_a,
-                  patient: patient
-                },
-                layout: false
-      end
-
-      def render_create(message)
-        render locals: {
-          message: InternalMessagePresenter.new(message),
-          original_message: message_we_are_replying_to(message)
-        }
-      end
-
-      def author
-        Messaging.cast_author(current_user)
-      end
-
-      def patient
-        Messaging.cast_patient(Patient.find(params[:patient_id]))
-      end
-
-      def message_params
-        params
-          .require(:messaging_message_form)
-          .permit(:subject, :body, :urgent, :replying_to_message_id, recipient_ids: [])
-      end
-    end
-  end
-end

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

@@ -1,55 +0,0 @@
-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
-    class ReceiptsController < BaseController
-      include Renalware::Concerns::Pageable
-      include PresenterHelper
-
-      # GET aka inbox
-      def unread
-        render_receipts(receipts.unread)
-      end
-
-      # GET
-      def read
-        render_receipts(receipts)
-      end
-
-      # PATCH
-      def mark_as_read
-        authorize receipt
-        receipt.update(read_at: Time.zone.now)
-        render locals: {
-          receipt: Messaging::ReceiptPresenter.new(receipt)
-        }
-      end
-
-      private
-
-      def render_receipts(receipts)
-        authorize receipts
-        render locals: {
-          receipts: present(receipts, Messaging::ReceiptPresenter)
-        }
-      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.cast_recipient(current_user)
-      end
-    end
-  end
-end

data/app/controllers/renalware/messaging/sent_messages_controller.rb

@@ -1,22 +0,0 @@
-require_dependency "renalware/messaging"
-require "collection_presenter"
-
-module Renalware
-  module Messaging
-    class SentMessagesController < BaseController
-      include Renalware::Concerns::Pageable
-
-      def index
-        messages = author.messages.page(page).per(per_page)
-        authorize messages
-        render locals: {
-          messages: CollectionPresenter.new(messages, Messaging::InternalMessagePresenter)
-        }
-      end
-
-      def author
-        Messaging.cast_author(current_user)
-      end
-    end
-  end
-end

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

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

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

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

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

@@ -1,50 +0,0 @@
-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/receipt.rb

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

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

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

@@ -1,22 +0,0 @@
-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/policies/renalware/messaging/receipt_policy.rb

@@ -1,19 +0,0 @@
-require_dependency "renalware/messaging"
-
-module Renalware
-  module Messaging
-    class ReceiptPolicy < BasePolicy
-      def mark_as_read?
-        update?
-      end
-
-      def unread?
-        index?
-      end
-
-      def read?
-        index?
-      end
-    end
-  end
-end

data/app/presenters/renalware/messaging/internal_message_presenter.rb

@@ -1,19 +0,0 @@
-require_dependency "renalware/messaging"
-
-module Renalware
-  module Messaging
-    class InternalMessagePresenter < SimpleDelegator
-      def age_in_days
-        (Time.zone.now.to_date - sent_at.to_date).to_i
-      end
-
-      def html_identifier
-        "message-#{id}"
-      end
-
-      def html_preview_identifier
-        "message-preview-#{id}"
-      end
-    end
-  end
-end