denshobato 0.0.1

data/lib/denshobato/helpers/core_modules/message_helper.rb

@@ -0,0 +1,60 @@
+module Denshobato
+  module MessageHelper
+    def send_message(text, recipient)
+      # This method sends message directly to the recipient
+      # Takes responsibility to create conversation if it doesn`t exist yet
+      # sends message to an existing conversation
+
+      # Find conversation.
+      room = hato_conversation.find_by(sender: self, recipient: recipient)
+
+      # If conversation doesn`t exist, create one.
+      conversation = room.nil? ? create_conversation(self, recipient) : room
+
+      # Return validation error, if conversation is a String (see create_conversation method)
+      return errors.add(:blacklist, conversation) if conversation.is_a?(String)
+
+      # Create message for this conversation.
+      send_message_to(conversation.id, body: text)
+    end
+
+    def send_message_to(id, params)
+      # This method sends message directly to conversation
+
+      return errors.add(:message, 'Conversation not present') unless id
+
+      # Expect record id
+      # If id == active record object, get it`s id
+      id = id.id if id.is_a?(ActiveRecord::Base)
+
+      room = hato_conversation.find(id)
+
+      # Show validation error if the author of a message is not in conversation
+      return message_error(id, self) unless user_in_conversation(room, self)
+
+      # If everything is ok, build message
+      hato_messages.build(params)
+    end
+
+    private
+
+    def create_conversation(sender, recipient)
+      room = sender.make_conversation_with(recipient)
+
+      # Get validation error
+      room.valid? ? room.save && room : room.errors[:blacklist].join('')
+    end
+
+    def message_error(id, author)
+      # TODO: Return validation error in the most efficient way
+
+      author.hato_messages.build(conversation_id: id)
+    end
+
+    def user_in_conversation(room, author)
+      # Check if user is in conversation as sender or recipient
+
+      hato_conversation.where(id: room.id, sender: author).present? || hato_conversation.where(id: room.id, recipient: author).present?
+    end
+  end
+end

data/lib/denshobato/helpers/helper_utils.rb

@@ -0,0 +1,21 @@
+module Denshobato
+  module HelperUtils
+    private
+
+    def class_name(klass)
+      klass.class.name
+    end
+
+    def hato_conversation
+      Denshobato::Conversation
+    end
+
+    def hato_message
+      Denshobato::Message
+    end
+
+    def hato_blacklist
+      Denshobato::Blacklist
+    end
+  end
+end

data/lib/denshobato/helpers/view_helper.rb

@@ -0,0 +1,61 @@
+module Denshobato
+  module ViewHelper
+    include Denshobato::HelperUtils
+    include Denshobato::ViewMessagingHelper
+
+    def conversation_exists?(sender, recipient)
+      # Check if sender and recipient already have conversation together.
+
+      hato_conversation.find_by(sender: sender, recipient: recipient)
+    end
+
+    def can_create_conversation?(sender, recipient)
+      # If current sender is current recipient, return false
+
+      sender == recipient ? false : true
+    end
+
+    def user_in_black_list?(blocker, blocked)
+      hato_blacklist.where(blocker: blocker, blocked: blocked).present?
+    end
+
+    def devise_url_helper(action, user, controller)
+      # Polymorphic devise urls
+      # E.g, you have two models, seller and customer
+      # You can create helper (like current_account)
+      # Use this method for url's
+
+      # devise_url_helper(:edit, current_account, :registration)
+      # => :edit_seller_registration, or :edit_customer_registration
+
+      "#{action}_#{user.class.name.downcase}_#{controller}".to_sym
+    end
+
+    def fill_conversation_form(form, recipient)
+      # = form_for @conversation do |form|
+      ### = fill_conversation_form(form, @conversation)
+      ### = f.submit 'Start Chating', class: 'btn btn-primary'
+
+      recipient_id   = form.hidden_field :recipient_id,   value: recipient.id
+      recipient_type = form.hidden_field :recipient_type, value: recipient.class.name
+
+      recipient_id + recipient_type
+    end
+
+    def fill_message_form(form, user, room_id)
+      # @message = current_user.build_conversation_message(@conversation)
+      # = form_for [@conversation, @message] do |form|
+      ### = form.text_field :body
+      ### = fill_message_form(form, @message)
+      ### = form.submit
+
+      room_id = room_id.id if room_id.is_a?(ActiveRecord::Base)
+
+      sender_id       = form.hidden_field :sender_id,       value: user.id
+      sender_class    = form.hidden_field :sender_type,     value: user.class.name
+      conversation_id = form.hidden_field :conversation_id, value: room_id
+
+      sender_id + sender_class + conversation_id
+    end
+  end
+end

data/lib/denshobato/helpers/view_messaging_helper.rb

@@ -0,0 +1,52 @@
+module Denshobato
+  module ViewMessagingHelper
+    # OPTIMIZE: Metaprogram interlocutors methods.
+
+    def interlocutor_avatar(user, image_column, conversation, css_class)
+      sender    = conversation.sender
+      recipient = conversation.recipient
+
+      return show_image(sender,    image_column, css_class)  if user == sender
+      return show_image(recipient, image_column, css_class)  if user == recipient
+    end
+
+    def interlocutor_name(user, conversation, *fields)
+      sender    = conversation.sender
+      recipient = conversation.recipient
+
+      return show_filter(sender, fields)    if fields.any? && user == sender
+      return show_filter(recipient, fields) if fields.any? && user == recipient
+    end
+
+    def message_from(message, *fields)
+      # Show information about message creator
+
+      return unless message
+      show_filter(message.author, fields)
+    end
+
+    def interlocutor_info(klass, *fields)
+      show_filter(klass, fields)
+    end
+
+    def interlocutor_image(user, column, css_class)
+      show_image(user, column, css_class)
+    end
+
+    private
+
+    def show_image(user, image, css_class)
+      # Show image_tag with user avatar and css class
+
+      image_tag(user.try(image) || '', class: css_class)
+    end
+
+    def show_filter(klass, fields)
+      # Adds fields to View
+      # h3 = "Conversation with: #{interlocutor_name(user, conversation, :first_name, :last_name)}"
+      # => Conversation with John Doe
+
+      fields.each_with_object([]) { |field, array| array << klass.send(:try, field) }.join(' ').strip
+    end
+  end
+end

data/lib/denshobato/models/blacklist.rb

@@ -0,0 +1,13 @@
+module Denshobato
+  class Blacklist < ::ActiveRecord::Base
+    self.table_name = 'denshobato_blacklists'
+
+    # Set up polymorphic association
+    belongs_to :blocker, polymorphic: true
+    belongs_to :blocked, polymorphic: true
+
+    # Validation
+    validates :blocker_id, :blocker_type, uniqueness: { scope: [:blocked_id, :blocked_type], message: 'User already in your blacklist' }
+    validates :blocked_id, :blocked_type, :blocker_id, :blocker_type, presence: true
+  end
+end

data/lib/denshobato/models/conversation.rb

@@ -0,0 +1,103 @@
+module Denshobato
+  class Conversation < ::ActiveRecord::Base
+    include Denshobato::HelperUtils
+
+    self.table_name = 'denshobato_conversations'
+
+    # Set-up Polymorphic association
+    belongs_to :sender,    polymorphic: true
+    belongs_to :recipient, polymorphic: true
+
+    # Has Many association
+    has_many :denshobato_notifications, class_name: '::Denshobato::Notification', dependent: :destroy
+
+    # Validate fields
+    validates         :sender_id, :sender_type, :recipient_id, :recipient_type, presence: true
+    validate          :conversation_uniqueness, on: :create
+    before_validation :check_sender # Sender can't create conversation with himself
+    before_validation :blocked_user # Check if blocked user tries to start conversation
+
+    # Callbacks
+    after_create      :recipient_conversation # Create conversation for recipient, where he is sender.
+    after_destroy     :remove_messages, if: :both_conversation_removed? # Remove messages and notifications
+
+    # Scopes
+    scope :my_conversations, lambda { |user, bool|
+      bool ? where(trashed: bool, sender: user).order(updated_at: :desc) : includes(:recipient).where(trashed: bool, sender: user).order(updated_at: :desc)
+    }
+
+    # Methods
+    def messages
+      # Return all messages of conversation
+
+      ids = notifications.pluck(:message_id)
+      hato_message.where(id: ids)
+    end
+
+    def to_trash
+      # Move conversation to trash
+
+      bool = block_given? ? yield : true
+      update(trashed: bool)
+    end
+
+    def from_trash
+      # Move conversation from trash
+
+      to_trash { false }
+    end
+
+    # Alias
+    alias notifications denshobato_notifications
+
+    private
+
+    def recipient_conversation
+      if hato_conversation.where(recipient: sender, sender: recipient).present?
+        errors.add(:conversation, 'You already have conversation with this user')
+      else
+        recipient.make_conversation_with(sender).save
+      end
+    end
+
+    def check_sender
+      errors.add(:conversation, 'You can`t create conversation with yourself') if sender == recipient
+    end
+
+    def conversation_uniqueness
+      # Check conversation for uniqueness, when recipient is sender, and vice versa.
+
+      hash = Hash[*columns.flatten] # => { sender_id: 1, sender_type: 'User' ... }
+
+      errors.add(:conversation, 'You already have conversation with this user.') if hato_conversation.where(hash).present?
+    end
+
+    def remove_messages
+      # When sender and recipient remove their conversation together
+      # remove all messages and notifications belonging to this conversation
+
+      hato_message.where(id: messages.map(&:id)).destroy_all
+      notifications.destroy_all
+    end
+
+    def both_conversation_removed?
+      # Check when both conversations are removed
+
+      hato_conversation.where(sender: recipient, recipient: sender).empty?
+    end
+
+    def blocked_user
+      if hato_blacklist.where(blocker: recipient, blocked: sender).present?
+        errors.add(:blacklist, 'You`re in blacklist')
+      end
+
+      if hato_blacklist.where(blocker: sender, blocked: recipient).present?
+        errors.add(:blacklist, 'Remove user from blacklist, to start conversation')
+      end
+    end
+
+    def columns
+      [['sender_id', sender_id], ['sender_type', sender_type], ['recipient_id', recipient_id], ['recipient_type', recipient_type]]
+    end
+  end
+end

data/lib/denshobato/models/message.rb

@@ -0,0 +1,96 @@
+module Denshobato
+  class Message < ::ActiveRecord::Base
+    attr_accessor :conversation_id
+
+    self.table_name = 'denshobato_messages'
+
+    # Associations
+    belongs_to :author, polymorphic: true
+    has_many   :denshobato_notifications, class_name: '::Denshobato::Notification'
+
+    # Validations
+    before_validation :access_to_posting_message
+    validates         :body, :author_id, :author_type, presence: true
+
+    # Callbacks
+    before_destroy :skip_deleting_messages, if: :message_belongs_to_conversation?
+
+    # Alias
+    alias notifications denshobato_notifications
+
+    # Methods
+    def send_notification(id)
+      # Find current conversation
+      conversation = hato_conversation.find(id)
+
+      # Create Notifications
+      create_notifications_for(conversation)
+    end
+
+    def message_time
+      # Formatted time for chat panel
+
+      created_at.strftime('%a %b %d | %I:%M %p')
+    end
+
+    private
+
+    def skip_deleting_messages
+      errors.add(:base, 'Can`t delete message, as long as it belongs to the conversation')
+
+      # The before_destroy callback needs a true/false value to determine whether or not to proceeed
+      false
+    end
+
+    def access_to_posting_message
+      return unless conversation_id
+
+      room = hato_conversation.find(conversation_id)
+
+      # If author of message is not present in conversation, show error
+
+      errors.add(:message, 'You can`t post to this conversation') unless user_in_conversation(room, author)
+    end
+
+    def create_notifications_for(conversation)
+      # Take sender and recipient
+      sender         = conversation.sender
+      recipient      = conversation.recipient
+
+      # Find conversation where sender it's recipient
+      conversation_2 = recipient.find_conversation_with(sender)
+
+      # If recipient deletes conversation, create it for him
+      conversation_2 = create_conversation_for_recipient(sender, recipient) if conversation_2.nil?
+
+      # Send notifications for new messages to sender and recipient
+      [conversation.id, conversation_2.id].each { |id| notifications.create(conversation_id: id) }
+    end
+
+    def user_in_conversation(room, author)
+      # Check if user is already in conversation
+
+      hato_conversation.where(id: room.id, sender: author).present? || hato_conversation.where(id: room.id, recipient: author).present?
+    end
+
+    def create_conversation_for_recipient(sender, recipient)
+      # Create Conversation for recipient
+      # Skip callbacks, because conversation for sender exists already
+
+      conv = hato_conversation.new(sender: recipient, recipient: sender)
+      hato_conversation.skip_callback(:create, :after, :recipient_conversation)
+      conv.save
+      conv
+    end
+
+    def message_belongs_to_conversation?
+      # Check if message has live notifications for any conversation
+
+      hato_conversation.where(id: notifications.pluck(:conversation_id)).present?
+    end
+
+    def hato_conversation
+      Denshobato::Conversation
+    end
+  end
+end

data/lib/denshobato/models/notification.rb

@@ -0,0 +1,17 @@
+module Denshobato
+  class Notification < ::ActiveRecord::Base
+    self.table_name = 'denshobato_notifications'
+
+    # Associations
+    belongs_to :denshobato_message,      class_name: 'Denshobato::Message', foreign_key: 'message_id', dependent: :destroy
+    belongs_to :denshobato_conversation, class_name: 'Denshobato::Conversation', foreign_key: 'conversation_id', touch: true
+
+    # Validations
+    validates :message_id, :conversation_id, presence: true
+    validates :message_id, uniqueness: { scope: :conversation_id }
+
+    # Aliases
+    alias message denshobato_message
+    alias conversation denshobato_conversation
+  end
+end

data/lib/denshobato/version.rb

@@ -0,0 +1,3 @@
+module Denshobato
+  VERSION = '0.0.1'.freeze
+end

data/lib/denshobato.rb

@@ -0,0 +1,35 @@
+require 'denshobato/version'
+require 'denshobato/engine' if defined?(Rails)
+
+# Helpers
+Denshobato.autoload :HelperUtils,      'denshobato/helpers/helper_utils'
+Denshobato.autoload :ViewHelper,       'denshobato/helpers/view_helper'
+Denshobato.autoload :ControllerHelper, 'denshobato/helpers/controller_helper'
+
+# View Helpers for messaging
+Denshobato.autoload :ViewMessagingHelper, 'denshobato/helpers/view_messaging_helper'
+
+module Denshobato
+  if defined?(ActiveRecord::Base)
+    require 'denshobato/extenders/core' # denshobato_for method
+
+    # Active Record Models
+    Denshobato.autoload :Conversation, 'denshobato/models/conversation'
+    Denshobato.autoload :Message,      'denshobato/models/message'
+    Denshobato.autoload :Notification, 'denshobato/models/notification'
+    Denshobato.autoload :Blacklist,    'denshobato/models/blacklist'
+
+    # Add helper methods to core model
+    Denshobato.autoload :ConversationHelper, 'denshobato/helpers/core_modules/conversation_helper'
+    Denshobato.autoload :MessageHelper, 'denshobato/helpers/core_modules/message_helper'
+    Denshobato.autoload :BlacklistHelper, 'denshobato/helpers/core_modules/blacklist_helper'
+    Denshobato.autoload :ChatPanelHelper, 'denshobato/helpers/core_modules/chat_panel_helper' if defined?(DenshobatoChatPanel)
+    Denshobato.autoload :CoreHelper, 'denshobato/helpers/core_helper'
+
+    ActiveRecord::Base.extend Denshobato::Extenders::Core
+  end
+
+  # Include Helpers
+  ActionView::Base.include       Denshobato::ViewHelper       if defined?(ActionView::Base)
+  ActionController::Base.include Denshobato::ControllerHelper if defined?(ActionController::Base)
+end

data/lib/generators/denshobato/install_generator.rb

@@ -0,0 +1,40 @@
+module Denshobato
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.dirname(__FILE__)
+      desc 'Add the migrations'
+
+      def copy_conversations
+        p 'Copying migrations'
+
+        copy_file './migrations/create_conversations.rb', "db/migrate/#{time}_create_denshobato_conversations.rb"
+      end
+
+      def copy_messages
+        sleep 1
+        copy_file './migrations/create_messages.rb', "db/migrate/#{time}_create_denshobato_messages.rb"
+      end
+
+      def copy_notifications
+        sleep 1
+        copy_file './migrations/create_notifications.rb', "db/migrate/#{time}_create_denshobato_notifications.rb"
+      end
+
+      def copy_blacklists
+        sleep 1
+        copy_file './migrations/create_blacklists.rb', "db/migrate/#{time}_create_denshobato_blacklists.rb"
+      end
+
+      def done
+        puts 'Denshobato Installed'
+        puts 'Run rake db:migrate'
+      end
+
+      private
+
+      def time
+        DateTime.now.to_s(:number)
+      end
+    end
+  end
+end

data/lib/generators/denshobato/migrations/create_blacklists.rb

@@ -0,0 +1,8 @@
+class CreateDenshobatoBlacklists < ActiveRecord::Migration
+  def change
+    create_table :denshobato_blacklists do |t|
+      t.references :blocker, polymorphic: true, index: { name: 'blocker_user' }
+      t.references :blocked, polymorphic: true, index: { name: 'blocked_user' }
+    end
+  end
+end

data/lib/generators/denshobato/migrations/create_conversations.rb

@@ -0,0 +1,11 @@
+class CreateDenshobatoConversations < ActiveRecord::Migration
+  def change
+    create_table :denshobato_conversations do |t|
+      t.boolean    :trashed,   default: false
+      t.references :sender,    polymorphic: true, index: { name: 'conversation_polymorphic_sender' }
+      t.references :recipient, polymorphic: true, index: { name: 'conversation_polymorphic_recipient' }
+
+      t.timestamps null: false
+    end
+  end
+end

data/lib/generators/denshobato/migrations/create_messages.rb

@@ -0,0 +1,10 @@
+class CreateDenshobatoMessages < ActiveRecord::Migration
+  def change
+    create_table :denshobato_messages do |t|
+      t.text :body, default: ''
+      t.references :author, polymorphic: true, index: { name: 'message_polymorphic_author' }
+
+      t.timestamps null: false
+    end
+  end
+end

data/lib/generators/denshobato/migrations/create_notifications.rb

@@ -0,0 +1,10 @@
+class CreateDenshobatoNotifications < ActiveRecord::Migration
+  def change
+    create_table :denshobato_notifications do |t|
+      t.integer :message_id,      index: { name: 'notification_for_message' }
+      t.integer :conversation_id, index: { name: 'notification_for_conversation' }
+    end
+
+    add_index :denshobato_notifications, [:message_id, :conversation_id], name: 'unique_messages_for_conversations', unique: true
+  end
+end