doodle_rails 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: af2ea8a12cd16908d7f2afecc8f5bbdcb2f72d11
+  data.tar.gz: 81ee8369d7a1c904a43b8c18a724b9d82fe5003f
+SHA512:
+  metadata.gz: 198575898ddef68256d9b11dbae7231d95f1cbe8bb4286f74eb18c6d61e92e91a858ac26fb0e93a445255c0edef2a94665c5c79421d9642d30747e1b18935d9f
+  data.tar.gz: e91b49295a269c5be4901299463f02226411ab4bea4d6674ef593b167f5e72810ef59db429542847db591fdf6d424d18578fe6df39b4f436d3b85691689f9d35

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Gabriel Malaquias
+
+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.rdoc

@@ -0,0 +1,3 @@
+= Doodle
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,37 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Doodle'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+load 'rails/tasks/statistics.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/assets/javascripts/doodle/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/app/assets/javascripts/doodle/auth.js

@@ -0,0 +1,2 @@
+// Place all the behaviors and hooks related to the matching controller here.
+// All this logic will automatically be available in application.js.

data/app/assets/javascripts/doodle/keywords.js

@@ -0,0 +1,2 @@
+// Place all the behaviors and hooks related to the matching controller here.
+// All this logic will automatically be available in application.js.

data/app/assets/javascripts/doodle/users.js

@@ -0,0 +1,2 @@
+// Place all the behaviors and hooks related to the matching controller here.
+// All this logic will automatically be available in application.js.

data/app/assets/stylesheets/doodle/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any styles
+ * defined in the other CSS/SCSS files in this directory. It is generally better to create a new
+ * file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/assets/stylesheets/doodle/auth.css

@@ -0,0 +1,4 @@
+/*
+  Place all the styles related to the matching controller here.
+  They will automatically be included in application.css.
+*/

data/app/assets/stylesheets/doodle/keywords.css

@@ -0,0 +1,4 @@
+/*
+  Place all the styles related to the matching controller here.
+  They will automatically be included in application.css.
+*/

data/app/assets/stylesheets/doodle/users.css

@@ -0,0 +1,4 @@
+/*
+  Place all the styles related to the matching controller here.
+  They will automatically be included in application.css.
+*/

data/app/controllers/doodle/application_controller.rb

@@ -0,0 +1,15 @@
+module Doodle
+  class ApplicationController < ActionController::Base
+    def authenticate
+      render json: { session_token: create_and_authenticate }
+    end
+
+    def authenticate_user
+
+    end
+
+    def auth_params
+      params.require(:auth).permit(:login, :pass)
+    end
+  end
+end

data/app/controllers/doodle/auth_controller.rb

@@ -0,0 +1,23 @@
+require_dependency "doodle/application_controller"
+
+module Doodle
+  class AuthController < ApplicationController
+    def authenticate
+      @user = User.where(pass: auth_params[:pass], login: auth_params[:login], type: auth_params[:type]).first
+
+      if @user.present?
+        render json: { login: @user.login, session_token: token_creator_service.token }
+      else
+        render json: { error: "When authenticate user" }
+      end
+    end
+
+    def auth_params
+      @params ||= params.require(:auth).permit(:login, :pass, :type)
+    end
+
+    def token_creator_service
+      @creator_service ||= Layer::TokenCreatorService.new(@user.login)
+    end
+  end
+end

data/app/controllers/doodle/chat_controller.rb

@@ -0,0 +1,50 @@
+require_dependency "doodle/application_controller"
+
+module Doodle
+  class ChatController < ApplicationController
+
+    def has_protocols?
+      protocols = Protocol.waiting_in_channel(params.require(:channel))
+      render json: { has_protocols: protocols.size }, status: 200
+    end
+
+    def next
+      protocol = protocol_finder_service.next
+      join_service = chat_join_service(protocol)
+      if join_service.break_limit? && protocol.blank?
+        render json: { error: 'Analyst already have limit of protocols in progress' }, status: 422
+      else
+        join_service.join(params.require(:channel))
+        render json: { conversation: protocol.conversation_id }, status: 200
+      end
+    end
+
+    def finalize
+      user = User::Analyst.find_by_login(params.require(:login))
+      protocol = protocol_finder_service.find_by_conversation(params.require(:id))
+
+      if user.blank? || protocol.blank?
+        render json: { text: "Protocol or user dont found"}, status: 422
+      else
+
+        protocol_finalizer_service(protocol).call
+        chat_join_service(protocol, user).out(protocol.channel.name)
+
+        render json: { id: protocol.id, text: "Protocol finalized with success" }
+      end
+    end
+
+    def protocol_finalizer_service(protocol)
+      @protcol_finalizer_service ||= Protocol::FinalizerService.new(protocol)
+    end
+
+    def chat_join_service(protocol, user)
+      @chat_join_service ||= Chat::JoinService.new(user, protocol)
+    end
+
+    def protocol_finder_service
+      @finder_service ||= Protocol::FinderService.new
+    end
+  end
+end
+

data/app/controllers/doodle/conversations_controller.rb

@@ -0,0 +1,30 @@
+require_dependency "doodle/application_controller"
+
+module Doodle
+  class ConversationsController < ApplicationController
+    def create
+      channel  = channel_finder_service.call.first
+
+      if channel.present?
+        conversation = conversation_creator_service([params.require(:login)]).call
+        protocol = protocol_creator_service(channel, conversation).call
+        render json: { protocol_id: protocol.id, prococol_status: protocol.status, channel: channel.name, conversation_id: conversation.id }, status: 201
+      else
+        render json: { error: 'Channel dont found, Please create channel with this name first' }
+      end
+    end
+
+    def channel_finder_service
+      @channel_finder_service ||= Channel::FinderService.new({name: params.require(:channel)})
+    end
+
+    def protocol_creator_service(channel, conversation)
+      @protocol_creator_service ||= Protocol::CreatorService.new(params.require(:login), channel, conversation)
+    end
+
+    def conversation_creator_service(participants)
+      @conversation_creator_service ||= ::Layer::Conversation::CreatorService.new(participants)
+    end
+  end
+end
+

data/app/controllers/doodle/keywords_controller.rb

@@ -0,0 +1,32 @@
+require_dependency "doodle/application_controller"
+require 'pry'
+
+module Doodle
+  class KeywordsController < ApplicationController
+
+    def create
+      keyword = Keyword.new(keyword_params)
+      if keyword.save
+        render json: keyword.reload.to_json
+      else
+        render json: {error: 'When save keyword'}.to_json
+      end
+    end
+
+    def index
+      if params[:keyword].present?
+        render json: finder_service.to_json
+      else
+        render json: Keyword.all.to_json
+      end
+    end
+
+    def keyword_params
+      params.require(:keyword).permit(:name, :value, :type)
+    end
+
+    def finder_service
+      @finder_service || Doodle::Keyword::FinderService.new(keyword_params)
+    end
+  end
+end

data/app/controllers/doodle/users_controller.rb

@@ -0,0 +1,35 @@
+require_dependency "doodle/application_controller"
+
+module Doodle
+  class UsersController < ApplicationController
+
+    def join
+      user = User::Analyst.find_by_params(users_params[:login])
+      channel = params.require(:channel)
+
+      if user
+        if user.has_channels?
+          user.enter_in_channel(channel)
+        end
+        render json: { channel: channel }, status: 200
+      end
+
+      render json: { error: 'User not found' }, status: 404
+
+    end
+
+
+    def create
+      user = User.new(users_params)
+      if user.save
+        render json: user.reload.to_json
+      else
+        render json: {error: 'When save keyword'}.to_json
+      end
+    end
+
+    def users_params
+      params.require(:user).permit(:login, :pass, :type)
+    end
+  end
+end

data/app/helpers/doodle/application_helper.rb

@@ -0,0 +1,4 @@
+module Doodle
+  module ApplicationHelper
+  end
+end

data/app/helpers/doodle/auth_helper.rb

@@ -0,0 +1,4 @@
+module Doodle
+  module AuthHelper
+  end
+end

data/app/helpers/doodle/keywords_helper.rb

@@ -0,0 +1,4 @@
+module Doodle
+  module KeywordsHelper
+  end
+end

data/app/helpers/doodle/users_helper.rb

@@ -0,0 +1,4 @@
+module Doodle
+  module UsersHelper
+  end
+end

data/app/models/doodle/channel.rb

@@ -0,0 +1,12 @@
+module Doodle
+  class Channel < ActiveRecord::Base
+    has_many :user_channels
+    has_many :users, through: :user_channels
+
+    has_many :protocols
+
+    def self.find_protocols_by_channel(name)
+      Channel.find_by_name(name).protocols
+    end
+  end
+end

data/app/models/doodle/keyword/action.rb

@@ -0,0 +1,4 @@
+module Doodle
+  class Keyword::Action < Keyword
+  end
+end

data/app/models/doodle/keyword/text.rb

@@ -0,0 +1,4 @@
+module Doodle
+  class Keyword::Text < Keyword
+  end
+end

data/app/models/doodle/keyword.rb

@@ -0,0 +1,4 @@
+module Doodle
+  class Keyword < ActiveRecord::Base
+  end
+end

data/app/models/doodle/protocol.rb

@@ -0,0 +1,65 @@
+module Doodle
+  class Protocol < ActiveRecord::Base
+    include AASM
+    belongs_to :channel
+    belongs_to :user
+
+    aasm column: :status do
+      state :waiting, initial: true
+      state :in_progress
+      state :finalized
+
+      after_all_transitions :log_status_change
+
+      event :progress do
+        before do
+          self.update(in_progress_at: Time.now)
+        end
+
+        transitions from: :waiting, to: :in_progress
+      end
+
+      event :finalize do
+        before do
+          self.update(finalized_at: Time.now)
+        end
+
+        transitions from: :in_progress, to: :finalized
+      end
+    end
+
+    scope :waiting_in_channel, -> (channel){ joins(:channel).where(status: :waiting, 'doodle_channels.name' => channel) }
+
+    def duration
+      (self.finalized_at - self.created_at).round
+    end
+
+    def log_status_change
+      Rails.logger.info "[DOODLE] [PROTOCOL] - Protocol #{self.id} of customer #{self.customer_login} changed from #{aasm.from_state} to #{aasm.to_state}"
+    end
+
+    def add_analyst_into(user)
+      self.user = user
+      self.save
+    end
+
+    def add_participant_into_conversation(login)
+      conversation = Layer::Conversation.find(self.conversation_id)
+      conversation.participants << login
+      conversation.save
+    end
+
+    def remove_participant_from_conversation(login)
+      conversation = Layer::Conversation.find(self.conversation_id)
+      conversation.participants = conversation.participants - [login]
+      conversation.save
+    end
+
+    def self.next(channel = 'corporativo')
+      protocol = self.waiting_in_channel(channel).first
+      protocol.progress!
+      protocol
+    end
+
+  end
+end

data/app/models/doodle/user/analyst.rb

@@ -0,0 +1,18 @@
+module Doodle
+  class User::Analyst < User
+
+    def enter_in_channel(name)
+      user_channel = user_channel_by_name(name)
+      user_channel.turn_online! if user_channel.may_turn_online?
+    end
+
+    def out_of_channel(name)
+      user_channel = user_channel_by_name(name)
+      user_channel.turn_offline! if user_channel.may_turn_offline?
+    end
+
+    def user_channel_by_name(name)
+      self.user_channels.joins(:channel).where('doodle_channels.name' => name).first
+    end
+  end
+end

data/app/models/doodle/user/customer.rb

@@ -0,0 +1,4 @@
+module Doodle
+  class User::Customer < User
+  end
+end

data/app/models/doodle/user.rb

@@ -0,0 +1,9 @@
+module Doodle
+  class User < ActiveRecord::Base
+    has_many :user_channels
+    has_many :channels, through: :user_channels
+
+
+
+  end
+end

data/app/models/doodle/user_channel.rb

@@ -0,0 +1,27 @@
+module Doodle
+  class UserChannel < ActiveRecord::Base
+    include AASM
+
+    belongs_to :user
+    belongs_to :channel
+
+    aasm column: :status do
+      state :offline, initial: true
+      state :online
+
+      after_all_transitions :log_status_change
+
+      event :turn_online do
+        transitions from: :offline, to: :online
+      end
+
+      event :turn_offline do
+        transitions from: :online, to: :offline
+      end
+    end
+
+    def log_status_change
+      Rails.logger.info "[POC] [CHANNEL] - Analyst #{self.user.login} change your status from #{aasm.from_state} to #{aasm.to_state}"
+    end
+  end
+end

data/app/services/doodle/channel/finder_service.rb

@@ -0,0 +1,15 @@
+module Doodle
+  class Channel::FinderService
+    def initialize(params)
+      @params = params
+    end
+
+    def call
+      scope = nil
+      @params.each do |k, v|
+        scope = Doodle::Channel.where({k => v})
+      end
+      scope.all
+    end
+  end
+end

data/app/services/doodle/chat/join_service.rb

@@ -0,0 +1,23 @@
+module Doodle
+  class Chat::JoinService
+    def initialize(user, protocol)
+      @protocol = protocol
+      @user = user
+    end
+
+    def join(channel)
+      @protocol.add_analyst_into(@user)
+      @protocol.add_participant_into_conversation(@user.login)
+      @user.enter_in_channel(channel)
+    end
+
+    def break_limit?
+      @user.break_limit_concurrent_protocols?
+    end
+
+    def out(channel)
+      @protocol.remove_participant_from_conversation(@user.login)
+      @user.out_of_channel(channel)
+    end
+  end
+end

data/app/services/doodle/keyword/finder_service.rb

@@ -0,0 +1,15 @@
+module Doodle
+  class Keyword::FinderService
+    def initialize(params)
+      @params = params
+    end
+
+    def call
+      scope = nil
+      @params.each do |k, v|
+        scope = Doodle::Keyword.where(k, v)
+      end
+      scope.all
+    end
+  end
+end

data/app/services/doodle/protocol/creator_service.rb

@@ -0,0 +1,16 @@
+module Doodle
+  class Protocol::CreatorService
+    def initialize(customer_login, channel, conversation)
+      @customer_login = customer_login
+      @channel = channel
+      @conversation = conversation
+    end
+
+    def call
+      Protocol.create(customer_login: @customer_login,
+                      channel: @channel,
+                      conversation_id: @conversation.id,
+                      phone: '(XX) XXXX-XXXX')
+    end
+  end
+end

data/app/services/doodle/protocol/finalizer_service.rb

@@ -0,0 +1,11 @@
+module Doodle
+  class Protocol::FinalizerService
+    def initialize(protocol)
+      @protocol = protocol
+    end
+
+    def call
+      @protocol.finalize!
+    end
+  end
+end

data/app/services/doodle/protocol/finder_service.rb

@@ -0,0 +1,13 @@
+module Doodle
+  class Protocol::FinderService
+    def next
+      Protocol.next
+    end
+
+    def find_by_conversation(id)
+      Protocol.find_by_conversation_id(id)
+    end
+  end
+end
+
+

data/app/services/layer/conversation/creator_service.rb

@@ -0,0 +1,11 @@
+module Layer
+  class Conversation::CreatorService
+    def initialize(participants)
+      @participants = participants
+    end
+
+    def call
+      Layer::Conversation.create(participants: @participants)
+    end
+  end
+end

data/app/services/layer/token_creator_service.rb

@@ -0,0 +1,13 @@
+class Layer::TokenCreatorService
+  def initialize(login)
+    @login = login
+  end
+
+  def token
+    client = Layer::Client.authenticate do |nonce|
+      Layer::IdentityToken.new(@login, nonce)
+    end
+    client.token
+  end
+
+end

data/app/views/layouts/doodle/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Doodle</title>
+  <%= stylesheet_link_tag    "doodle/application", media: "all" %>
+  <%= javascript_include_tag "doodle/application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/initializers/layer.rb

@@ -0,0 +1,12 @@
+Layer::Client.configure do |config|
+  config.app_id = "layer:///apps/staging/151aa76a-ce72-11e5-ac55-80e4720f6b18"
+  config.token = "H6EvCKXyPpXuQtBDU07TdgLguNMatEQcOKBmQqpJTVsg5Gdj"
+end
+
+Layer::IdentityToken.layer_provider_id = "layer:///providers/1519612a-ce72-11e5-ac55-80e4720f6b18"
+Layer::IdentityToken.layer_key_id = "layer:///keys/0ff36abc-d0d2-11e5-b2af-61c9960f423b"
+
+key = File.readlines("#{Rails.root}/config/private_key.pem").join('')
+Layer::IdentityToken.layer_private_key = OpenSSL::PKey::RSA.new(key)
+
+