denshobato 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1d59c4062e19fbdc958c66414757db47955fd6b0
+  data.tar.gz: 55d70a9a5e61cdb6dd0fc4dd382aa489eebe95e6
+SHA512:
+  metadata.gz: 62b1df33d46fd412176eeda92d5418dc4ceab95b21ff3cd721e4d894323646475bbbca46580eb57c22d887ba8e36edeea31be135500668de6098069ff444104c
+  data.tar.gz: eb62fe49f37f7884db56126c29db3ae00d81481a012f1504339e2156086a27820f041e6b6305384f4700811d938a6bfee6a7d6979978fd08a3397142828a11b5

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.2
+before_install: gem install bundler -v 1.11.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in denshobato.gemspec
+gemspec

data/README.md

@@ -0,0 +1,413 @@
+# Denshobato - Private messaging between models.
+
+![alt text](http://i.imgur.com/NuhMPrg.png "Denshobato")
+
+Denshobato is a Rails gem that helps models communicate with each other. It gives simple api for creating a complete conversation system. You can create conversation with any model. Denshobato provides api methods for making conversation, messages, blacklists and trash. It also provides Helper methods for controller and view.
+***
+
+##### [Install Gem](#install_gem)
+##### [Tutorial](#-tutorial)
+##### [Conversation API](#conversation)
+##### [Message API](#message)
+##### [Trash API](#trash)
+##### [BlackList API](#blacklist)
+##### [Controller Herper API](#controller)
+##### [View Herper API](#view)
+##### [Extensions](#extensions-1)
+
+### Requirements
+```
+Rails 4.
+
+Rails 3 isn't supported.
+Not ready for 5, while it is in Beta.
+```
+
+### <a name="install_gem"> </a>Install Gem
+
+```ruby
+gem 'denshobato'
+```
+or
+
+```gem install denshobato```
+
+Then run installation:
+
+```shell
+rails g denshobato:install
+```
+
+Run migrations
+
+```shell
+rake db:migrate
+```
+
+Add this line to your model. This will make it able to send messages.
+```ruby
+denshobato_for :your_class
+```
+
+### <a name="tutorial"> </a>Tutorial
+#### Create messaging system between reseller and customer.
+[Part 1](http://id25.github.io/2016/03/01/make-private-dialog-between-reseller-and-customer-part-1.html)
+
+[Part 2](http://id25.github.io/2016/03/02/make-private-dialog-between-reseller-and-customer-part-2.html)
+
+
+### Example:
+```ruby
+class User < ActiveRecord::Base
+  denshobato_for :user
+end
+
+class Customer < ActiveRecord::Base
+  denshobato_for :customer
+end
+```
+
+```ruby
+@user.make_conversation_with(@customer).save
+
+@user.send_message('Hello', @customer)
+```
+
+You're ready!
+
+### <a name="conversation"></a>Conversations API
+
+#####Create conversation with user
+
+```ruby
+current_user.make_conversation_with(customer)
+# => #<Denshobato::Conversation id: nil, sender_id: 1, sender_type: "User", recipient_id: 1,
+     #  recipient_type: "User", created_at: nil, updated_at: nil, trashed: false>
+
+# Example:
+# In your view:
+
+- @users.each do |user|
+  = link_to user.email, user if current_user != user
+  = button_to 'Start Conversation', start_conversation_path(id: user.id, class: user.class.name),
+    class: 'btn btn-success'
+
+# Create route
+# We need specify controller, because by default rails search for denshobato_conversations
+post 'start_conversation', to: 'conversations#start_conversation', as: :start_conversation
+
+# And action
+def start_conversation
+  recipient = params[:class].constantize.find(params[:id])
+  conversation = current_account.make_conversation_with(recipient)
+
+  if conversation.save
+    redirect_to :conversations
+  end
+end
+```
+
+Another way to create a conversation.
+```ruby
+
+# In your view
+# @conversation = current_user.hato_conversations.build
+
+= form_for @conversation, url: :conversations do |form|
+  = fill_conversation_form(form, user) # => denshobato view helper, for conversation creating
+  = f.submit 'Start Conversation', class: 'btn btn-primary'
+
+# Route, simple rest actions, i.e create for this.
+resources :denshobato_conversations, as: :conversations,
+  path: 'conversations', controller: 'conversations'
+
+def create
+  @conversation = current_account.hato_conversations.build(conversation_params)
+  if @conversation.save
+    redirect_to conversation_path(@conversation)
+  else
+    redirect_to :new, notice: 'Something went wrong'
+  end
+end
+```
+
+#####Fetch all conversations, where you're present.
+
+```ruby
+current_user.my_converstions
+# => #<ActiveRecord::Relation [#<Denshobato::Conversation id: 118, sender_id: 1, sender_type: "User",
+#      recipient_id: 2, recipient_type: "User", created_at: "2016-02-28 01:45:11",
+#      updated_at: "2016-02-28 01:45:11", trashed: false>,
+#    <Denshobato::Conversation id: 119, sender_id: 1, sender_type: "User", recipient_id: 1,
+#      recipient_type: "Customer", created_at: "2016-02-28 02:05:59",
+#      updated_at: "2016-02-28 02:05:59", trashed: false>]>
+```
+
+#####Find conversation with another user
+
+```ruby
+current_user.find_conversation_with(customer)
+# => #<Denshobato::Conversation id: 119, sender_id: 1, sender_type: "User",
+#      recipient_id: 1, recipient_type: "Customer",
+#      created_at: "2016-02-28 02:05:59", updated_at: "2016-02-28 02:05:59", trashed: false>
+```
+
+#####Return all your trashed conversation
+```ruby
+current_user.trashed_conversations
+# => #<ActiveRecord::Relation [#<Denshobato::Conversation id: 119, sender_id: 1, sender_type: "User",
+#      recipient_id: 1, recipient_type: "Customer", created_at: "2016-02-28 02:05:59",
+#      updated_at: "2016-02-28 02:21:48", trashed: true>]>
+```
+
+##### Return all messages from conversation
+```ruby
+@conversation.messages
+# => [#<Denshobato::Message id: 224, body: "Hi", author_id: 1, author_type: "User",
+#       created_at: "2016-02-28 00:51:00", updated_at: "2016-02-28 00:51:00">,
+#     #<Denshobato::Message id: 225, body: "Hello", author_id: 1,
+#       author_type: "Customer", created_at: "2016-02-28 00:53:11", updated_at: "2016-02-28 00:53:11">]
+```
+
+### <a name="message"></a>Messages API
+
+```ruby
+# This method sends message directly to the recipient
+# Takes responsibility to create conversation if it doesn`t exist yet or sends message to an existing conversation
+
+# Important!
+# After each created message, send notification
+if @message.save
+  @message.send_notification(@conversation.id)
+end
+# See example below
+
+msg = current_user.send_message(body: 'Hello', recipient)
+# => #<Denshobato::Message:0x000000054dc790 id: nil, body: "Hello", author_id: 1,
+#      author_type: "User", created_at: nil, updated_at: nil>
+msg.save
+```
+
+Another way - send message directly to a conversation
+```ruby
+current_user.send_message_to(conversation.id, body: 'Hello')
+
+# Example
+# @message_form = current_user.hato_messages.build
+
+= form_for @message_form, url: :messages do |form|
+  = form.text_field :body, class: 'form-control'
+  = fill_message_form(form, current_account, @conversation.id) # => denshobato helper, for message creating
+  = form.submit 'Send message', class: 'btn btn-primary'
+
+# Controller
+def create
+  conversation_id = params[:denshobato_message][:conversation_id]
+  @message = current_account.send_message_to(conversation_id, message_params)
+
+  if @message.save
+  # Important, send notifications after save message
+    @message.send_notification(conversation_id)
+    redirect_to conversation_path(conversation_id)
+  else
+    render :new, notice: 'Error'
+  end
+end
+```
+
+### <a name="trash"></a>Trash API
+
+##### Move conversation to trash and remove it out of there
+```ruby
+# @conversation.to_trash
+# @conversation.from_tash
+
+#Example
+# In your view
+- @conversations.each do |room|
+  = link_to "Conversation with #{room.recipient.email}", conversation_path(room)
+  = button_to 'Move to Trash', to_trash_path(id: room), class: 'btn btn-warning', method: :patch
+  = button_to 'Move from Trash', from_trash_path(id: room), class: 'btn btn-warning', method: :patch
+
+# Route
+patch :to_trash,   to: 'conversations#to_trash',   as: :to_trash
+patch :from_trash, to: 'conversations#from_trash', as: :from_trash
+
+# In your conversation controller
+%w(to_trash from_trash).each do |name|
+  define_method name do
+    room = Denshobato::Conversation.find(params[:id])
+    room.send(name)
+    redirect_to :conversations
+  end
+end
+```
+
+### <a name="blacklist"></a>BlackList API
+
+```ruby
+# current_user.add_to_blacklist(customer)
+# current_user.remove_from_blacklist(customer)
+
+- @users.each do |user|
+  = link_to user.email, user if current_account != user
+  - if user_in_black_list?(current_account, user)
+    p This user in your blacklist
+      = button_to 'Remove from black list', remove_from_blacklist_path(user: user,
+        klass: user.class.name), class: 'btn btn-info'
+  - else
+      = button_to 'Add to black list', black_list_path(user: user, klass: user.class.name),
+        class: 'btn btn-danger'
+
+# Routes
+post :black_list,            to: 'users#add_to_blacklist',      as: :black_list
+post :remove_from_blacklist, to: 'users#remove_from_blacklist', as: :remove_from_blacklist
+
+# Controller
+[%w(add_to_blacklist save), %w(remove_from_blacklist destroy)].each do |name, action|
+  define_method name do
+    user   = params[:klass].constantize.find(params[:user])
+    record = current_account.send(name, user)
+    record.send(action) ? (redirect_to :users) : (redirect_to :root)
+  end
+end
+```
+
+### <a name="controller"></a>Controller Helpers
+
+Check if user is already in conversation
+```ruby
+# user_in_conversation?(current_user, room)
+
+# Example
+@conversation = Denshobato::Conversation.find(params[:id])
+unless user_in_conversation?(current_user, @conversation)
+  redirect_to :conversations, notice: 'You can`t join this conversation'
+end
+```
+
+Check if sender and recipient already have conversation together.
+```ruby
+# conversation_exists?(sender, recipient)
+
+if conversation_exists?(current_user, @customer)
+  do_somthing
+end
+```
+
+Check if user can create conversation with other user
+```ruby
+# can_create_conversation?(sender, recipient)
+
+if can_create_conversation?(current_user, @customer)
+  @conversation_form = ...
+end
+```
+
+
+### <a name="view"></a>View Helpers
+
+Check if conversation exists, return `true` or `false`
+```ruby
+# @conversation = current_user.find_conversation(@user)
+
+- if conversation_exists?(current_user, @user)
+  = link_to 'Open chat', your_path(@conversation)
+```
+
+Check if user can create conversation with another user
+```ruby
+# can_create_conversation?(sender, recipient)
+
+- if can_create_conversation?(current_user, @customer)
+  = link_to 'Start Conversation', your_path...
+```
+
+Check if recipient is in blacklist
+```ruby
+# user_in_black_list?(sender, recipient)
+
+- if user_in_black_list?(current_user, @customer)
+  = button_to 'Remove from black list', remove_path...
+```
+
+Show name of recipient in conversation list
+```ruby
+- @conversations.includes(:sender).each do |room|
+  = link_to "Conversation with: #{interlocutor_name(current_user, room, :first_name, :last_name)}",
+    conversation_path(room)
+
+# => Conversation with: John Doe
+```
+
+Show avatar for recipient
+```ruby
+= interlocutor_avatar(current_user, :user_avatar, @conversation, 'img-responsive')
+
+# => <img src="..." class='img-responsive'/>
+```
+
+Show the last message, it's author and his avatar
+```ruby
+= "Last message: #{room.messages.last.try(:body)}"
+  = "#{interlocutor_image(room.messages.last.try(:author), :user_avatar, 'img-circle')}"
+  = "Last message from: #{message_from(room.messages.last, :first_name, :last_name)}"
+```
+
+Same inside of a conversation
+```ruby
+- @messages.includes(:author).each do |msg|
+  p = interlocutor_info(msg.author, :fist_name, :last_name)
+  = interlocutor_image(msg.author, :user_avatar, 'img-circle')
+  p = msg.body
+  hr
+```
+
+### Pagination
+If you use Kaminari, or Will Paginate, just follow their guide.
+
+Example:
+```ruby
+@messages = @conversation.messages.page(params[:page]).per(25)      # => Kaminari
+@messages = @conversation.messages.page(params[:page]).per_page(25) # => Will Paginate
+```
+
+And in your view
+```ruby
+= paginate @messages      # => Kaminari
+= will_paginate @messages # => Will Paginate
+```
+
+***
+
+### <a name="extensions"></a>Extensions
+![alt text](http://i.imgur.com/0sUUfDl.jpg "Screen")
+Denshobato has addon [denshobato_chat_panel](https://github.com/ID25/denshobato_chat_panel). This is simple chat panel for you. If you don't need any special customization for dialog panel, or if you want to try messaging quickly, you can use chat panel.
+
+That`s all for now.
+
+## Upcoming features
++ Conference
++ Read/Unread messages
+
+## Issues
+
+If you've found a bug, or have proposal/feature request, create an issue with your thoughts.
+[Denshobato Issues](https://github.com/ID25/denshobato/issues)
+
+## Contributing
+
++ Fork it
++ Create your feature branch (git checkout -b my-new-feature)
++ Write tests for new feature/bug fix
++ Make sure that tests pass and everything works like a charm
++ Commit your changes (git commit -am 'Added some feature')
++ Push to the branch (git push origin my-new-feature)
++ Create new Pull Request
+
+## The MIT License (MIT)
+
+#### Denshobato - Private messaging between models.
+![alt text](http://i.imgur.com/bo7kj7d.png "Denshobato")
+
+Copyright (c) 2016 Eugene Domosedov (ID25)

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'denshobato'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/denshobato.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'denshobato/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'denshobato'
+  spec.version       = Denshobato::VERSION
+  spec.authors       = ['ID25']
+  spec.email         = ['xid25x@gmail.com']
+
+  spec.summary       = 'Denshobato - private messaging between models'
+  spec.description   = 'Denshobato - private messaging between models'
+  spec.homepage      = 'https://github.com/ID25/denshobato'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'rails', '>= 3.2.0'
+  spec.add_runtime_dependency 'grape'
+
+  spec.add_development_dependency 'bundler', '~> 1.11'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'activerecord'
+  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'database_cleaner'
+  spec.add_development_dependency 'factory_girl', '~> 4.0'
+  spec.add_development_dependency 'shoulda-matchers', '~> 3.1'
+end

data/lib/denshobato/engine.rb

@@ -0,0 +1,5 @@
+module Denshobato
+  class Engine < Rails::Engine
+    config.autoload_paths += Dir["#{config.root}/lib/**/"]
+  end
+end

data/lib/denshobato/extenders/core.rb

@@ -0,0 +1,34 @@
+module Denshobato
+  module Extenders
+    module Core
+      def denshobato_for(_klass)
+        # Adds associations and methods to messagable model
+
+        adds_methods_to_model
+      end
+
+      private
+
+      def adds_methods_to_model
+        include Denshobato::CoreHelper # Adds helper methods for the core model
+
+        # Adds has_many association for a model, to allow it to create conversations
+        class_eval do
+          # Add conversations
+          has_many :denshobato_conversations, as: :sender, class_name: '::Denshobato::Conversation', dependent: :destroy
+
+          # Add messages
+          has_many :denshobato_messages, as: :author, class_name: '::Denshobato::Message', dependent: :destroy
+
+          # Add blacklists
+          has_many :denshobato_blacklists, as: :blocker, class_name: '::Denshobato::Blacklist', dependent: :destroy
+
+          # Added alias for the sake of brevity
+          alias_method :hato_conversations, :denshobato_conversations
+          alias_method :hato_messages,      :denshobato_messages
+          alias_method :blacklist,          :denshobato_blacklists
+        end
+      end
+    end
+  end
+end

data/lib/denshobato/helpers/controller_helper.rb

@@ -0,0 +1,23 @@
+module Denshobato
+  module ControllerHelper
+    include Denshobato::HelperUtils
+
+    def user_in_conversation?(user, room)
+      # redirect_to :root, notice: 'You can`t join this conversation unless user_in_conversation?(current_account, @conversation)'
+
+      hato_conversation.where(id: room.id, sender: user).present? || hato_conversation.where(id: room.id, recipient: user).present?
+    end
+
+    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
+  end
+end

data/lib/denshobato/helpers/core_helper.rb

@@ -0,0 +1,12 @@
+module Denshobato
+  module CoreHelper
+    include Denshobato::HelperUtils         # Useful helpers
+    include Denshobato::ConversationHelper  # Methods of Conversation model
+    include Denshobato::MessageHelper       # Methods of Message model
+    include Denshobato::BlacklistHelper     # Methods of BlackList model
+
+    # Methods for chat panel (json api)
+    # gem 'denshobato_chat_panel'
+    include Denshobato::ChatPanelHelper if defined?(DenshobatoChatPanel)
+  end
+end

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

@@ -0,0 +1,22 @@
+module Denshobato
+  module BlacklistHelper
+    def add_to_blacklist(user)
+      # Add user to blacklist
+      # User can`t create conversation or send message to a blocked model
+
+      blacklist.build(blocked: user)
+    end
+
+    def remove_from_blacklist(user)
+      # Remove user from blacklist
+
+      hato_blacklist.find_by(blocker: self, blocked: user)
+    end
+
+    def my_blacklist
+      # Show blocked users
+
+      blacklist.includes(:blocked)
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Denshobato
+  module ChatPanelHelper
+    # Default methods only for built-in Chat Panel
+    # Overwrite this methods when using Chat Panel
+
+    # class User < ActiveRecord::Base
+    #  def full_name
+    #    "#{first_name}", #{last_name}
+    #  end
+    #
+    #  def image
+    #    user_avatar.url
+    #  end
+    # end
+
+    DEFAULT_EMAIL = 'john.doe@gmail.com'.freeze
+
+    def full_name
+      # Set up default name for chat panel
+      # By default class name will be used, e.g => User
+
+      self.class.name.titleize
+    end
+
+    def image
+      # Show gravatar image
+
+      # Email field is expected by default for gravatar and for messagable model.
+      # If a model doesn`t have email field, send to method 'default' email, to show default gravatar
+      gravatar_image = Digest::MD5.hexdigest(email.downcase)
+      email == DEFAULT_EMAIL ? gravatar(gravatar_image, '?d=mm') : gravatar(gravatar_image)
+    end
+
+    def method_missing(method, *_args)
+      DEFAULT_EMAIL if method.to_s == 'email'
+    end
+
+    private
+
+    def gravatar(email, args = nil)
+      "https://secure.gravatar.com/avatar/#{email}/#{args}"
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Denshobato
+  module ConversationHelper
+    def my_conversations
+      # Return active user conversations (which is not in trash)
+
+      trashed = block_given? ? yield : false
+      hato_conversation.my_conversations(self, trashed)
+    end
+
+    def trashed_conversations
+      # Return trashed conversations
+
+      my_conversations { true } # => hato_conversation.where trashed: true
+    end
+
+    def make_conversation_with(recipient)
+      # Build conversation
+      # = form_for current_user.make_conversation_with(recipient) do |f|
+      # = f.submit 'Start Chat', class: 'btn btn-primary'
+
+      hato_conversations.build(recipient: recipient)
+    end
+
+    def find_conversation_with(user)
+      # Return an existing conversation between sender and recipient
+
+      hato_conversation.find_by(sender: self, recipient: user)
+    end
+  end
+end