effective_messaging 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6193093b822303bfc098d13ddaa7fe17787571ba0f65a5531ac0978272381320
+  data.tar.gz: b305d1836ab2a6f37b1236a986f36753d9194b969cc1105431733720a4d68535
+SHA512:
+  metadata.gz: b9b841f95b963670a6471bc6f28ae379ca99e43c7ee686f6d368c9853e4db1aaa2cd50dd7c1fdf15f20fefdb5f43a2d062e103074fbe01a9a9335b88bb465b20
+  data.tar.gz: e9e6c2cd7a336d3bf1fb547bceca70c49a2089728e4927b806ae77d78c9ec04836b8217b6a854be56f8e8af3cc96a01d2ee44a1973c104bef5642a8e5a2030cd

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2023 Code and Effect Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,131 @@
+# Effective Messaging
+
+Centralize all communications between one or more users.
+
+## Getting Started
+
+This requires Rails 6+ and Twitter Bootstrap 4 and just works with Devise.
+
+Please first install the [effective_datatables](https://github.com/code-and-effect/effective_datatables) gem.
+
+Please download and install the [Twitter Bootstrap4](http://getbootstrap.com)
+
+Add to your Gemfile:
+
+```ruby
+gem 'effective_messaging'
+```
+
+Run the bundle command to install it:
+
+```console
+bundle install
+```
+
+Then run the generator:
+
+```ruby
+rails generate effective_messaging:install
+```
+
+The generator will install an initializer which describes all configuration options and creates a database migration.
+
+If you want to tweak the table names, manually adjust both the configuration file and the migration now.
+
+Then migrate the database:
+
+```ruby
+rake db:migrate
+```
+
+Please add the following to your User model:
+
+```ruby
+effective_messaging_user                 # effective_messaging_user
+
+# Effective messaging
+def effective_messaging_display_name
+  to_s
+end
+
+# An anonymous token for your users
+def effective_messaging_anonymous_name
+  'Anonymous' + Base64::encode64("#{id}-#{created_at.strftime('%F')}").chomp.first(8)
+end
+```
+
+Add dashboard:
+
+```haml
+.card.card-dashboard.mb-4
+  .card-body= render 'effective/messaging/dashboard'
+```
+
+Add a link to the admin menu:
+
+```haml
+- if can?(:admin, :effective_messaging) && can?(:index, Effective::Chat)
+  = nav_link_to 'Chats', effective_messaging.admin_chats_path
+
+- if can?(:admin, :effective_messaging) && can?(:index, Effective::ChatMessage)
+  = nav_link_to 'Chat Messages', effective_messaging.admin_chat_messages_path
+```
+
+## Authorization
+
+All authorization checks are handled via the effective_resources gem found in the `config/initializers/effective_resources.rb` file.
+
+## Permissions
+
+The permissions you actually want to define are as follows (using CanCan):
+
+```ruby
+can(:index, Effective::Chat)
+can([:show, :update], Effective::Chat) { |chat| user.chat_user(chat: chat).present? }
+
+if user.admin?
+  can :admin, :effective_messaging
+
+  can(crud, Effective::Chat)
+  can(crud, Effective::ChatUser)
+  can(crud - [:new, :create], Effective::ChatMessage)
+end
+```
+
+## Creating a chat
+
+```ruby
+users = User.where(id: [1,2,3])
+
+chat = Effective::Chat.new(title: 'A cool chat', anonymous: true, users: users)
+chat.save!
+```
+
+and you can just render it *outside of a form*:
+
+```haml
+- chat = Effective::Chat.first
+= render(chat)
+= render('effective/chats/chat', chat: chat)
+```
+
+## License
+
+MIT License.  Copyright [Code and Effect Inc.](http://www.codeandeffect.com/)
+
+## Testing
+
+Run tests by:
+
+```ruby
+rails test
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Bonus points for test coverage
+6. Create new Pull Request

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/app/assets/config/effective_messaging_manifest.js

@@ -0,0 +1,3 @@
+//= link_directory ../javascripts .js
+//= link_directory ../stylesheets .css
+//= link_tree ../images

data/app/assets/javascripts/effective_messaging.js

@@ -0,0 +1 @@
+//= require_tree ./effective_messaging

data/app/assets/stylesheets/effective_messaging.scss

@@ -0,0 +1 @@
+@import 'effective_messaging/base';

data/app/controllers/admin/chat_messages_controller.rb

@@ -0,0 +1,13 @@
+module Admin
+  class ChatMessagesController < ApplicationController
+    before_action(:authenticate_user!) if defined?(Devise)
+    before_action { EffectiveResources.authorize!(self, :admin, :effective_messaging) }
+
+    include Effective::CrudController
+
+    def permitted_params
+      params.require(:effective_chat_message).permit!
+    end
+
+  end
+end

data/app/controllers/admin/chats_controller.rb

@@ -0,0 +1,13 @@
+module Admin
+  class ChatsController < ApplicationController
+    before_action(:authenticate_user!) if defined?(Devise)
+    before_action { EffectiveResources.authorize!(self, :admin, :effective_messaging) }
+
+    include Effective::CrudController
+
+    def permitted_params
+      params.require(:effective_chat).permit!
+    end
+
+  end
+end

data/app/controllers/effective/chats_controller.rb

@@ -0,0 +1,16 @@
+module Effective
+  class ChatsController < ApplicationController
+    before_action(:authenticate_user!) if defined?(Devise)
+
+    include Effective::CrudController
+
+    resource_scope -> { Effective::Chat.all.deep }
+
+    private
+
+    def permitted_params
+      params.require(:effective_chat).except(:user_type).permit(chat_messages_attributes: [:body])
+    end
+
+  end
+end

data/app/datatables/admin/effective_chat_messages_datatable.rb

@@ -0,0 +1,30 @@
+module Admin
+  class EffectiveChatMessagesDatatable < Effective::Datatable
+
+    datatable do
+      col :id, visible: false
+      col :token, visible: false
+
+      col :created_at, label: 'Date'
+      col :chat, search: :string
+
+      col :name
+      col :body, label: 'Message'
+
+      actions_col
+    end
+
+    collection do
+      scope = Effective::ChatMessage.deep.all
+
+      if attributes[:user_id].present? && attributes[:user_type].present?
+        user = attributes[:user_type].constantize.find(attributes[:user_id])
+        scope = Effective::ChatMessage.where(user: user)
+      end
+
+      scope
+
+    end
+
+  end
+end

data/app/datatables/admin/effective_chats_datatable.rb

@@ -0,0 +1,51 @@
+module Admin
+  class EffectiveChatsDatatable < Effective::Datatable
+
+    datatable do
+      col :id, visible: false
+      col :token, visible: false
+
+      col :created_at, visible: false
+      col :updated_at
+
+      col :parent, visible: false
+      col :title
+      col :anonymous
+
+      col :chat_users
+
+      col(:chat_users, search: :string) do |chat|
+        if chat.anonymous?
+          chat.chat_users.map do |chat_user|
+            content_tag(:div, chat_user.name, class_name: 'col-resource_item')
+          end
+        else
+          chat.chat_users.map do |chat_user|
+            link = link_to(chat_user.name, "/admin/users/#{chat_user.user_id}/edit")
+            content_tag(:div, link, class_name: 'col-resource_item')
+          end
+        end.join
+      end.search do |collection, term|
+        Effective::Chat.search_by_chat_user_name(term)
+      end
+
+      col :chat_messages_count, label: 'Num Messages'
+
+      col :last_notified_at, visible: false
+
+      actions_col(new: false)
+    end
+
+    collection do
+      scope = Effective::Chat.deep.all
+
+      if attributes[:user_id].present? && attributes[:user_type].present?
+        user = attributes[:user_type].constantize.find(attributes[:user_id])
+        scope = Effective::Chat.for_user(user)
+      end
+
+      scope
+    end
+
+  end
+end

data/app/datatables/effective_chats_datatable.rb

@@ -0,0 +1,21 @@
+# Dashboard Chats
+class EffectiveChatsDatatable < Effective::Datatable
+  datatable do
+    order :updated_at
+
+    col :token, visible: false
+    col :created_at, visible: false
+    col :updated_at, label: 'Last message'
+
+    col :title
+    col :chat_users, label: 'Participants'
+    col :chat_messages_count, label: 'Messages'
+
+    actions_col
+  end
+
+  collection do
+    Effective::Chat.deep.where(id: current_user.chats)
+  end
+
+end

data/app/helpers/effective_messaging_helper.rb

@@ -0,0 +1,3 @@
+module EffectiveMessagingHelper
+
+end

data/app/mailers/effective/messaging_mailer.rb

@@ -0,0 +1,59 @@
+module Effective
+  class MessagingMailer < EffectiveMessaging.parent_mailer_class
+
+    include EffectiveMailer
+    include EffectiveEmailTemplatesMailer if EffectiveMessaging.use_effective_email_templates
+
+    def chat_new_message(chat, chat_user, opts = {})
+      raise('expected a chat') unless chat.kind_of?(Chat)
+      raise('expected a chat user') unless chat_user.kind_of?(ChatUser)
+
+      user = chat_user.user
+      raise('expected user to have an email') unless user.try(:email).present?
+
+      @assigns = assigns_for(chat).merge(assigns_for(chat_user))
+
+      subject = subject_for(__method__, "New Message - #{chat}", chat, opts)
+      headers = headers_for(chat, opts)
+
+      mail(to: user.email, subject: subject, **headers)
+    end
+
+    protected
+
+    def assigns_for(resource)
+      if resource.kind_of?(Effective::Chat)
+        return chat_assigns(resource)
+      end
+
+      if resource.kind_of?(Effective::ChatUser)
+        return chat_user_assigns(resource)
+      end
+
+      raise('unexpected resource')
+    end
+
+    def chat_assigns(chat)
+      raise('expected a chat') unless chat.kind_of?(Chat)
+
+      values = {
+        date: chat.created_at.strftime('%F'),
+        title: chat.title,
+        url: effective_messaging.chat_url(chat)
+      }.compact
+
+      { chat: values }
+    end
+
+    def chat_user_assigns(chat_user)
+      raise('expected a chat_user') unless chat_user.kind_of?(ChatUser)
+
+      values = {
+        name: chat_user.name
+      }.compact
+
+      { user: values }
+    end
+
+  end
+end

data/app/models/concerns/effective_messaging_user.rb

@@ -0,0 +1,47 @@
+# EffectiveMessagingUser
+#
+# Mark your user model with effective_messaging_user to get all the includes
+
+module EffectiveMessagingUser
+  extend ActiveSupport::Concern
+
+  module Base
+    def effective_messaging_user
+      include ::EffectiveMessagingUser
+    end
+  end
+
+  module ClassMethods
+    def effective_messaging_user?; true; end
+  end
+
+  included do
+    has_many :chat_users, -> { Effective::ChatUser.sorted },
+      class_name: 'Effective::ChatUser', inverse_of: :user, dependent: :nullify
+
+    accepts_nested_attributes_for :chat_users, allow_destroy: true
+
+    has_many :chats, -> { Effective::Chat.sorted }, through: :chat_users, class_name: 'Effective::Chat'
+    accepts_nested_attributes_for :chats, allow_destroy: true
+  end
+
+  # Instance Methods
+  def chat_user(chat:)
+    chat_users.find { |cu| cu.chat_id == chat.id }
+  end
+
+  def effective_messaging_display_name
+    to_s
+  end
+
+  def effective_messaging_anonymous_name
+    raise('to be implemented by the app')
+    # Base64::encode64("#{id}-#{created_at.strftime('%F')}").chomp.first(8)
+  end
+
+  # Find or build
+  # def build_chat_user(chat:)
+  #   chat_user(chat: chat) || chat_users.build(chat: chat)
+  # end
+
+end

data/app/models/effective/chat.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Effective
+  class Chat < ActiveRecord::Base
+    self.table_name = EffectiveMessaging.chats_table_name.to_s
+
+    NOTIFY_AFTER = 2.minutes
+
+    attr_accessor :current_user
+    attr_accessor :user_type # Must be set when creating a chat by admin/new form, and passing user_ids
+
+    acts_as_tokened
+    log_changes if respond_to?(:log_changes)
+
+    # If we want to use chats in a has_many way
+    belongs_to :parent, polymorphic: true, optional: true
+
+    has_many :chat_users, -> { ChatUser.sorted }, inverse_of: :chat, dependent: :destroy
+    accepts_nested_attributes_for :chat_users, allow_destroy: true
+
+    has_many :chat_messages, -> { ChatMessage.sorted }, inverse_of: :chat, dependent: :destroy
+    accepts_nested_attributes_for :chat_messages, allow_destroy: true
+
+    effective_resource do
+      title                  :string
+      anonymous              :boolean
+
+      chat_messages_count    :integer
+      token                  :string
+
+      timestamps
+    end
+
+    scope :sorted, -> { order(id: :desc) }
+    scope :deep, -> { includes(:chat_users, :chat_messages) }
+
+    scope :for_user, -> (user) { where(id: ChatUser.where(user: user).select(:chat_id)) }
+    scope :search_by_chat_user_name, -> (name) { where(id: ChatUser.with_name(name).select(:chat_id)) }
+
+    validates :title, presence: true, length: { maximum: 255 }
+
+    def to_s
+      title.presence || 'New Chat'
+    end
+
+    # This is an API for sending a message.
+    def send_message!(user:, body:)
+      raise('expected an effective_messaging_user') unless user.class.respond_to?(:effective_messaging_user?)
+
+      chat_user = chat_user(user: user)
+      raise('expected user to be a chat_user in this chat') unless chat_user.present?
+
+      # Build and send message
+      chat_message = chat_messages.build(body: body, user: user, chat_user: chat_user, name: chat_user.name)
+
+      # Creates message, which also calls notify! below
+      save!
+
+      chat_message
+    end
+
+    # Called by an after_commit on chat message
+    def notify!(except: nil, force: false)
+      raise('expected a ChatUser') if except.present? && !except.kind_of?(ChatUser)
+
+      # Notify everyone in the chat except the user that created this message
+      notified = (chat_users - [except]).map do |chat_user|
+
+        # Only notify once every 5 minutes unless force
+        if chat_user.last_notified_at.present? && !force
+          next if (Time.zone.now - chat_user.last_notified_at) < NOTIFY_AFTER
+        end
+
+        EffectiveMessaging.send_email(:chat_new_message, self, chat_user)
+        chat_user
+      end
+
+      ChatUser.where(id: notified).update_all(last_notified_at: Time.zone.now) if notified.present?
+
+      # updated_at is when last message was sent
+      touch
+    end
+
+    def chat_user(user:)
+      raise('expected an effective_messaging_user') unless user.class.respond_to?(:effective_messaging_user?)
+      chat_users.find { |cu| cu.user_id == user.id && cu.user_type == user.class.name }
+    end
+
+    def build_chat_user(user:)
+      chat_user(user: user) || chat_users.build(user: user)
+    end
+
+    # Always build
+    def build_chat_message(user:, body: nil)
+      raise('expected an effective_messaging_user') unless user.class.respond_to?(:effective_messaging_user?)
+      chat_messages.build(user: user, body: body)
+    end
+
+    # Builders for polymorphic users form
+    def users
+      chat_users.map(&:user)
+    end
+
+    def user_ids
+      chat_users.map(&:user_id)
+    end
+
+    def user_ids=(user_ids)
+      raise('expected a user_type') unless user_type.present?
+
+      # The users in this chat
+      self.users = user_type.constantize.where(id: user_ids)
+
+      # Return user_ids
+      user_ids
+    end
+
+    def users=(users)
+      users = Array(users)
+      raise('expected a effective_messaging_user') unless users.all? { |user| user.class.respond_to?(:effective_messaging_user?) }
+
+      # Mark for destruction
+      chat_users.each { |cu| cu.mark_for_destruction unless users.include?(cu.user) }
+
+      # Find or build chat_users
+      users.each { |user| build_chat_user(user: user) }
+
+      # Return users
+      users
+    end
+
+  end
+end

data/app/models/effective/chat_message.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Effective
+  class ChatMessage < ActiveRecord::Base
+    self.table_name = EffectiveMessaging.chat_messages_table_name.to_s
+
+    log_changes(to: :chat) if respond_to?(:log_changes)
+
+    belongs_to :chat, counter_cache: true
+
+    # Who sent this message
+    belongs_to :chat_user
+    belongs_to :user, polymorphic: true
+
+    effective_resource do
+      name          :string       # The name, anonymous or display, when sent
+      body          :text
+
+      timestamps
+    end
+
+    scope :sorted, -> { order(:id) }
+    scope :deep, -> { includes(:chat) }
+
+    # Use the controller's current_user to initialize the chat_user, user and name
+    before_validation(if: -> { new_record? && chat.present? }) do
+      self.user ||= chat.current_user
+      self.chat_user ||= chat.chat_user(user: self.user)
+      self.name ||= self.chat_user&.name
+    end
+
+    after_commit(on: :create) { chat.notify!(except: chat_user) }
+
+    validates :name, presence: true
+    validates :body, presence: true
+
+    def to_s
+      body.presence || 'New Chat Message'
+    end
+
+  end
+end

data/app/models/effective/chat_user.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Effective
+  class ChatUser < ActiveRecord::Base
+    self.table_name = EffectiveMessaging.chat_users_table_name.to_s
+
+    log_changes(to: :chat) if respond_to?(:log_changes)
+
+    belongs_to :chat
+    belongs_to :user, polymorphic: true
+
+    scope :with_name, -> (name) {
+      anonymous = where(chat_id: Chat.where(anonymous: true)).where('anonymous_name ILIKE ?', "%#{name}%")
+      displayed = where(chat_id: Chat.where(anonymous: false)).where('display_name ILIKE ?', "%#{name}%")
+
+      anonymous.or(displayed)
+    }
+
+    effective_resource do
+      display_name      :string
+      anonymous_name    :string
+
+      last_notified_at  :datetime
+
+      timestamps
+    end
+
+    scope :sorted, -> { order(:id) }
+    scope :deep, -> { includes(:chat) }
+
+    before_validation do
+      self.display_name ||= user.effective_messaging_display_name
+      self.anonymous_name ||= user.effective_messaging_anonymous_name
+    end
+
+    validates :display_name, presence: true, length: { maximum: 255 }
+    validates :anonymous_name, presence: true, length: { maximum: 255 }
+
+    def to_s
+      name.presence || 'New Chat User'
+    end
+
+    def name
+      chat&.anonymous? ? anonymous_name : display_name
+    end
+
+  end
+end

data/app/views/admin/chat_messages/_chat_message.html.haml

@@ -0,0 +1 @@
+= render 'effective/chats/chat_message', chat_message: :chat_message

data/app/views/admin/chats/_chat.html.haml

@@ -0,0 +1 @@
+= render 'effective/chats/chat', chat: chat, admin: true

data/app/views/admin/chats/_form.html.haml

@@ -0,0 +1,8 @@
+= tabs do
+  = tab "Chat" do
+    = render 'admin/chats/form_chat', chat: chat
+
+  - if chat.persisted?
+    - if chat.respond_to?(:log_changes_datatable)
+      = tab "Logs" do
+        = render_inline_datatable(chat.log_changes_datatable)

data/app/views/admin/chats/_form_chat.html.haml

@@ -0,0 +1,17 @@
+= effective_form_with(model: [:admin, chat], engine: true) do |f|
+  = f.text_field :title, label: "Title"
+
+  - if f.object.anonymous?
+    = f.static_field :anonymous do
+      %p Yes, this is an anonymous chat. User names and emails will not be displayed
+  - else
+    = f.check_box :anonymous, label: 'Yes, this is an anonymous chat', hint: 'user names and emails will not be displayed'
+
+  = f.hidden_field :user_type, value: current_user.class.name
+
+  - ajax_url = (@select2_ajax_path || effective_resources.users_admin_select2_ajax_index_path) unless Rails.env.test?
+
+  = f.select :user_ids, current_user.class.all, required: true,
+    ajax_url: ajax_url, hint: 'The users that can participate in this chat'
+
+  = effective_submit(f)

data/app/views/admin/chats/_layout.html.haml

@@ -0,0 +1,2 @@
+.effective-chat
+  = yield

data/app/views/effective/chats/_chat.html.haml

@@ -0,0 +1,10 @@
+= render 'layout' do
+  - chat_user = chat.chat_user(user: current_user)
+
+  - # New message form
+  - if chat_user.present? && EffectiveResources.authorized?(self, :update, chat)
+    = render('effective/chats/form', chat: chat)
+
+  - elsif EffectiveResources.authorized?(self, :show, chat)
+    = render('effective/chats/summary', chat: chat)
+    = render(partial: 'effective/chats/chat_message', collection: chat.chat_messages, chat: chat)

data/app/views/effective/chats/_chat_message.html.haml

@@ -0,0 +1,10 @@
+= render 'layout' do
+
+  - label = content_tag(:strong, chat_message.name) + ' commented ' + time_ago_in_words(chat_message.created_at) + ' ago'
+
+  .card
+    .card-header
+      = label
+      Yea
+    .card-body
+      = simple_format chat_message.body

data/app/views/effective/chats/_form.html.haml

@@ -0,0 +1,27 @@
+= effective_form_with(model: chat, engine: true, remote: true) do |f|
+  -# Doesn't do anything, we just need something to submit thats not the ID
+  = f.hidden_field :user_type
+
+  - # This is a remote form so we refresh all the chat messages each time we submit
+  = render('effective/chats/summary', chat: chat)
+  = render(partial: 'effective/chats/chat_message', collection: chat.chat_messages, chat: chat)
+
+  - if chat.chat_messages.blank?
+    %p There are no messages so far. Please send one!
+
+  %hr
+
+  - chat_message = chat.build_chat_message(user: current_user)
+  - chat_user = chat.chat_user(user: current_user)
+
+  .card
+    .card-header.bg-secondary
+      Send message
+    .card-body
+      %p Your name is displayed as <strong>#{chat_user.name}</strong>.
+
+      = f.fields_for :chat_messages, chat_message do |fcm|
+        - # The user and name are set by controller's current_user
+        = fcm.text_area :body, required: true, label: 'Send message...'
+
+      = f.submit 'Send Message'

data/app/views/effective/chats/_layout.html.haml

@@ -0,0 +1,2 @@
+.effective-chat
+  = yield

data/app/views/effective/chats/_summary.html.haml

@@ -0,0 +1,13 @@
+%p
+  - if chat.anonymous?
+    = badges('anonymous')
+
+  = succeed('.') do
+    A chat with
+    = pluralize(chat.chat_users.count, 'participants')
+    opened
+    = time_ago_in_words(chat.created_at)
+    ago
+
+  = succeed('.') do
+    = pluralize(chat.chat_messages_count, 'message')

data/app/views/effective/messaging/_dashboard.html.haml

@@ -0,0 +1,10 @@
+%h2 Messages and Chat
+
+- if current_user.chats.present?
+  %p You are a member of #{pluralize(current_user.chats.length, 'chat')}.
+
+  - datatable = EffectiveResources.best('EffectiveChatsDatatable').new(self, namespace: :effective)
+  = render_datatable(datatable, simple: true)
+
+- else
+  %p You haven't received any messages. When you do, we'll show it here.

data/app/views/effective/messaging_mailer/chat_new_message.liquid

@@ -0,0 +1,11 @@
+---
+subject: 'New message {{ chat.title }}'
+from: 'admin@example.com'
+---
+Hello {{ user.name }},
+
+You have received a new message. Please visit:
+
+{{ chat.url }}
+
+Thank you

data/config/effective_messaging.rb

@@ -0,0 +1,27 @@
+EffectiveMessaging.setup do |config|
+  config.chats_table_name = :chats
+  config.chat_users_table_name = :chat_users
+  config.chat_messages_table_name = :chat_messages
+
+  # Layout Settings
+  # Configure the Layout per controller, or all at once
+  # config.layout = { application: 'application', admin: 'admin' }
+
+  # Mailer Settings
+  # Please see config/initializers/effective_messaging.rb for default effective_* gem mailer settings
+  #
+  # Configure the class responsible to send e-mails.
+  # config.mailer = 'Effective::MessagingMailer'
+  #
+  # Override effective_resource mailer defaults
+  #
+  # config.parent_mailer = nil      # The parent class responsible for sending emails
+  # config.deliver_method = nil     # The deliver method, deliver_later or deliver_now
+  # config.mailer_layout = nil      # Default mailer layout
+  # config.mailer_sender = nil      # Default From value
+  # config.mailer_admin = nil       # Default To value for Admin correspondence
+  # config.mailer_subject = nil     # Proc.new method used to customize Subject
+
+  # Will work with effective_email_templates gem
+  config.use_effective_email_templates = true
+end

data/config/routes.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+Rails.application.routes.draw do
+  mount EffectiveMessaging::Engine => '/', as: 'effective_messaging'
+end
+
+EffectiveMessaging::Engine.routes.draw do
+  # Public routes
+  scope module: 'effective' do
+    resources :chats, only: [:show, :update]
+  end
+
+  namespace :admin do
+    resources :chats
+    resources :chat_messages, only: [:index, :show, :destroy]
+  end
+
+end

data/db/migrate/01_create_effective_messaging.rb.erb

@@ -0,0 +1,44 @@
+class CreateEffectiveMessaging < ActiveRecord::Migration[6.0]
+  def change
+    create_table <%= @chats_table_name %> do |t|
+      t.integer :parent_id
+      t.string :parent_type
+
+      t.string :title
+      t.boolean :anonymous, default: false
+
+      t.integer :chat_messages_count, default: 0
+      t.string :token
+
+      t.timestamps
+    end
+
+    create_table <%= @chat_users_table_name %> do |t|
+      t.integer :chat_id
+
+      t.integer :user_id
+      t.string :user_type
+
+      t.string :display_name
+      t.string :anonymous_name
+
+      t.datetime :last_notified_at
+
+      t.timestamps
+    end
+
+    create_table <%= @chat_messages_table_name %> do |t|
+      t.integer :chat_id
+      t.integer :chat_user_id
+
+      t.integer :user_id
+      t.string :user_type
+
+      t.string :name
+      t.text :body
+
+      t.timestamps
+    end
+
+  end
+end

data/db/seeds.rb

@@ -0,0 +1 @@
+puts "Running effective_messaging seeds"

data/lib/effective_messaging/engine.rb

@@ -0,0 +1,18 @@
+module EffectiveMessaging
+  class Engine < ::Rails::Engine
+    engine_name 'effective_messaging'
+
+    # Set up our default configuration options.
+    initializer 'effective_messaging.defaults', before: :load_config_initializers do |app|
+      eval File.read("#{config.root}/config/effective_messaging.rb")
+    end
+
+    # Include acts_as_messaging concern and allow any ActiveRecord object to call it
+    initializer 'effective_messaging.active_record' do |app|
+      app.config.to_prepare do
+        ActiveRecord::Base.extend(EffectiveMessagingUser::Base)
+      end
+    end
+
+  end
+end

data/lib/effective_messaging/version.rb

@@ -0,0 +1,3 @@
+module EffectiveMessaging
+  VERSION = '0.1.0'.freeze
+end

data/lib/effective_messaging.rb

@@ -0,0 +1,22 @@
+require 'effective_resources'
+require 'effective_datatables'
+require 'effective_messaging/engine'
+require 'effective_messaging/version'
+
+module EffectiveMessaging
+
+  def self.config_keys
+    [
+      :chats_table_name, :chat_users_table_name, :chat_messages_table_name,
+      :layout,
+      :mailer, :parent_mailer, :deliver_method, :mailer_layout, :mailer_sender, :mailer_admin, :mailer_subject, :use_effective_email_templates
+    ]
+  end
+
+  include EffectiveGem
+
+  def self.mailer_class
+    mailer&.constantize || Effective::MessagingMailer
+  end
+
+end

data/lib/generators/effective_messaging/install_generator.rb

@@ -0,0 +1,32 @@
+module EffectiveMessaging
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      desc 'Creates an EffectiveMessaging initializer in your application.'
+
+      source_root File.expand_path('../../templates', __FILE__)
+
+      def self.next_migration_number(dirname)
+        if not ActiveRecord::Base.timestamped_migrations
+          Time.new.utc.strftime("%Y%m%d%H%M%S")
+        else
+          '%.3d' % (current_migration_number(dirname) + 1)
+        end
+      end
+
+      def copy_initializer
+        template ('../' * 3) + 'config/effective_messaging.rb', 'config/initializers/effective_messaging.rb'
+      end
+
+      def create_migration_file
+        @chats_table_name  = ':' + EffectiveMessaging.chats_table_name.to_s
+        @chat_users_table_name  = ':' + EffectiveMessaging.chat_users_table_name.to_s
+        @chat_messages_table_name  = ':' + EffectiveMessaging.chat_messages_table_name.to_s
+
+        migration_template ('../' * 3) + 'db/migrate/01_create_effective_messaging.rb.erb', 'db/migrate/create_effective_messaging.rb'
+      end
+
+    end
+  end
+end

data/lib/generators/templates/effective_messaging_mailer_preview.rb

@@ -0,0 +1,4 @@
+# Visit http://localhost:3000/rails/mailers
+
+class EffectiveMessagingMailerPreview < ActionMailer::Preview
+end

data/lib/tasks/effective_messaging_tasks.rake

@@ -0,0 +1,8 @@
+namespace :effective_messaging do
+
+  # bundle exec rake effective_messaging:seed
+  task seed: :environment do
+    load "#{__dir__}/../../db/seeds.rb"
+  end
+
+end

metadata

@@ -0,0 +1,281 @@
+--- !ruby/object:Gem::Specification
+name: effective_messaging
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Code and Effect
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-01-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+- !ruby/object:Gem::Dependency
+  name: effective_bootstrap
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: effective_datatables
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: effective_orders
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: effective_resources
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: effective_roles
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: wicked
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: devise
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: haml-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: effective_test_bot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: effective_developer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: effective_email_templates
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Centralize the communication between one or more users.
+email:
+- info@codeandeffect.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/config/effective_messaging_manifest.js
+- app/assets/javascripts/effective_messaging.js
+- app/assets/javascripts/effective_messaging/base.js
+- app/assets/stylesheets/effective_messaging.scss
+- app/assets/stylesheets/effective_messaging/base.scss
+- app/controllers/admin/chat_messages_controller.rb
+- app/controllers/admin/chats_controller.rb
+- app/controllers/effective/chats_controller.rb
+- app/datatables/admin/effective_chat_messages_datatable.rb
+- app/datatables/admin/effective_chats_datatable.rb
+- app/datatables/effective_chats_datatable.rb
+- app/helpers/effective_messaging_helper.rb
+- app/mailers/effective/messaging_mailer.rb
+- app/models/concerns/effective_messaging_user.rb
+- app/models/effective/chat.rb
+- app/models/effective/chat_message.rb
+- app/models/effective/chat_user.rb
+- app/views/admin/chat_messages/_chat_message.html.haml
+- app/views/admin/chats/_chat.html.haml
+- app/views/admin/chats/_form.html.haml
+- app/views/admin/chats/_form_chat.html.haml
+- app/views/admin/chats/_layout.html.haml
+- app/views/effective/chats/_chat.html.haml
+- app/views/effective/chats/_chat_message.html.haml
+- app/views/effective/chats/_form.html.haml
+- app/views/effective/chats/_layout.html.haml
+- app/views/effective/chats/_summary.html.haml
+- app/views/effective/messaging/_dashboard.html.haml
+- app/views/effective/messaging_mailer/chat_new_message.liquid
+- config/effective_messaging.rb
+- config/routes.rb
+- db/migrate/01_create_effective_messaging.rb.erb
+- db/seeds.rb
+- lib/effective_messaging.rb
+- lib/effective_messaging/engine.rb
+- lib/effective_messaging/version.rb
+- lib/generators/effective_messaging/install_generator.rb
+- lib/generators/templates/effective_messaging_mailer_preview.rb
+- lib/tasks/effective_messaging_tasks.rake
+homepage: https://github.com/code-and-effect/effective_messaging
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: Centralize the communication between one or more users.
+test_files: []