telephony 1.0.3

data/app/controllers/telephony/signals/agents/presences_controller.rb

@@ -0,0 +1,64 @@
+module Telephony
+  module Signals
+    module Agents
+      class PresencesController < ApplicationController
+        protect_from_forgery :except => [:authenticate, :create]
+        before_filter :verify_pusher_request_signature, :except => :authenticate
+        after_filter :publish_events
+
+        def authenticate
+          @agent = Agent.find_by_csr_id params[:csr_id]
+
+          @agent.verify_status!
+
+          @agent.with_lock do
+            if @agent.offline?
+              if params[:csr_default_status] == 'not_available'
+                @agent.not_available
+              else
+                @agent.available
+              end
+            end
+          end
+
+          response = Pusher[params[:channel_name]]
+            .authenticate(params[:socket_id], user_id: @agent.id)
+          render json: response
+        end
+
+        def create
+          timestamp = params["presence"]["time_ms"].to_i
+          params[:presence][:events].each do |data|
+            @agent = Agent.where(id: data[:user_id]).first
+            if @agent
+              @agent.with_lock do
+                @agent.process_presence_event(data[:name], timestamp)
+              end
+            end
+          end
+          head :ok
+        end
+
+        private
+
+        def verify_pusher_request_signature
+          req = Pusher::WebHook.new request
+          unless req.valid?
+            render :text => "Bad Pusher signature", :status => :unauthorized and return
+          end
+        end
+
+        def publish_events
+          return if @agent.nil?
+
+          event = Events::Base.find_last_for_agent(@agent)
+          event.republish_only_for @agent
+
+          @agent.publish_status_change unless @agent.offline?
+
+          PusherEventPublisher.queue_change Conversation.queue_size, event.id, @agent
+        end
+      end
+    end
+  end
+end

data/app/controllers/telephony/transfers_controller.rb

@@ -0,0 +1,18 @@
+require_dependency 'telephony/application_controller'
+
+module Telephony
+  class TransfersController < ApplicationController
+    def create
+      Conversation.find_with_lock params[:conversation_id] do |conversation|
+        if conversation.transfer! params[:transfer_id], params[:transfer_type] == 'one_step'
+          render json: {}
+        else
+          errors = ['Transfer failed. Please try again in a few seconds.'] +
+            conversation.errors.full_messages
+
+          render json: { errors: errors }, status: :unprocessable_entity
+        end
+      end
+    end
+  end
+end

data/app/controllers/telephony/twilio_client_controller.rb

@@ -0,0 +1,37 @@
+require_dependency "telephony/application_controller"
+
+module Telephony
+  class TwilioClientController < ApplicationController
+    before_filter :validate_params, only: :token
+
+    def index
+      @token = generate_token_for("agent#{params['csr-id']}")
+      render layout: false
+    end
+
+    def token
+      token = generate_token_for("agent#{params['csr_id']}")
+      render json: { token: token }
+    end
+
+    private
+
+    def validate_params
+      if params['csr_id'].blank?
+        render json: { errors: ['Invalid csr id'] },
+          status: :bad_request
+      end
+    end
+
+    def generate_token_for client_name
+      account_sid = TWILIO_CONFIG[:account_sid]
+      auth_token = TWILIO_CONFIG[:auth_token]
+
+      capability = Twilio::Util::Capability.new account_sid, auth_token
+      # TODO: Get the correct value
+      capability.allow_client_outgoing "APabe7650f654fc34655fc81ae71caa3ff"
+      capability.allow_client_incoming client_name
+      capability.generate
+    end
+  end
+end

data/app/controllers/telephony/voicemails_controller.rb

@@ -0,0 +1,13 @@
+require_dependency 'telephony/application_controller'
+
+module Telephony
+  class VoicemailsController < ApplicationController
+    def index
+      @voicemails = Voicemail.most_recent.filter params.slice(:page, :csr_id)
+      render json: {
+        items: @voicemails,
+        total_count: @voicemails.total_count
+      }
+    end
+  end
+end

data/app/controllers/telephony/widget_controller.rb

@@ -0,0 +1,10 @@
+require_dependency "telephony/application_controller"
+
+module Telephony
+  class WidgetController < ApplicationController
+
+    def index
+      render layout: false, content_type: 'application/json'
+    end
+  end
+end

data/app/helpers/telephony/application_helper.rb

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

data/app/helpers/telephony/calls_helper.rb

@@ -0,0 +1,13 @@
+module Telephony
+  module CallsHelper
+    def twiml_word_for call
+      if call.agent && call.agent.uses_twilio_client?
+        :Client
+      elsif call.agent && call.agent.uses_sip?
+        :Sip
+      else
+        :Number
+      end
+    end
+  end
+end

data/app/models/telephony/agent.rb

@@ -0,0 +1,186 @@
+module Telephony
+  class Agent < Base
+    include AgentStateMachine
+
+    OFFLINE = "offline"
+    AVAILABLE = "available"
+    NOT_AVAILABLE = "not_available"
+    ON_A_CALL = "on_a_call"
+
+    STATUS_SORT_ORDER = {
+      AVAILABLE => 0,
+      ON_A_CALL => 1,
+      NOT_AVAILABLE => 2,
+      OFFLINE => 3
+    }
+
+    module PhoneType
+      PHONE         = "phone"
+      TWILIO_CLIENT = "twilio_client"
+      SIP           = "sip"
+
+      ALL = [PHONE, TWILIO_CLIENT, SIP]
+    end
+
+    PhoneType::ALL.each do |type|
+      define_method "uses_#{type}?".to_sym do
+        phone_type == type
+      end
+    end
+
+    has_many :calls
+
+    attr_accessible :csr_id,
+      :status,
+      :generate_caller_id,
+      :name,
+      :phone_ext,
+      :phone_number,
+      :phone_type,
+      :csr_type,
+      :sip_number,
+      :call_center_name,
+      :transferable_agents
+
+    serialize :transferable_agents, Array
+
+    validates :csr_id,       presence:  true
+    validates :phone_type,   inclusion: { :in => PhoneType::ALL }
+    validates :sip_number,   presence: true, :if => :uses_sip?
+    validates :phone_number, presence: true, :if => :uses_phone?
+
+    def self.sort_by_status agents
+      agents.sort_by { |agent| STATUS_SORT_ORDER[agent.status] }
+    end
+
+    def self.all_transferable_for_csr_id csr_id
+      agent = find_by_csr_id csr_id
+
+      transferables = select([:id, :csr_id, :csr_type, :status, :name, :phone_ext, :phone_number])
+
+      if agent && agent.transferable_agents.count > 0
+        transferables = transferables.where(csr_id: agent.transferable_agents)
+      end
+
+      sort_by_status(transferables)
+    end
+
+    def self.update_or_create_by_widget_data data
+      agent = find_or_create_by_csr_id data[:csr_id]
+      agent.update_attributes({
+        csr_type: data[:csr_type],
+        name: data[:csr_name],
+        generate_caller_id: data[:csr_generate_caller_id],
+        phone_number: data[:csr_phone_number],
+        phone_ext: data[:csr_phone_ext],
+        sip_number: data[:csr_sip_number],
+        call_center_name: data[:csr_call_center_name],
+        phone_type: data[:csr_phone_type].present? ? data[:csr_phone_type] : PhoneType::PHONE,
+        transferable_agents: data[:csr_transferable_agents].present? ? JSON.parse(data[:csr_transferable_agents]) : []
+      })
+      agent
+    end
+
+    def self.find_with_lock agent_id
+      transaction do
+        yield find agent_id, lock: true
+      end
+    end
+
+    def transferrable?
+      available?
+    end
+
+    def process_presence_event event, timestamp
+      if event == 'member_added'
+        update_status_by_event :came_online, timestamp
+      else
+        job = Telephony::Jobs::AgentOffline.new id, timestamp
+        if Telephony::DELAYED_JOB.respond_to?(:enqueue)
+          Telephony::DELAYED_JOB.enqueue job, run_at: 15.minutes.from_now
+        else
+          job.update_status
+        end
+      end
+    end
+
+    def update_status_by_event presence_event, timestamp
+      return if timestamp_of_last_presence_event > timestamp
+
+      self.send presence_event.to_sym
+      self.update_attribute :timestamp_of_last_presence_event, timestamp
+    end
+
+    def terminate_active_call
+      active_call.terminate! if active_call
+    end
+
+    def active_call
+      calls.where("state <> 'terminated'").last
+    end
+
+    def active_conversation_id
+      return nil unless on_a_call?
+      call = active_call
+      call.conversation_id if call
+    end
+
+    def verify_status!
+      return unless on_a_call?
+      call = active_call
+
+      if call.nil?
+        with_lock { call_ended! if (active_call.nil? and on_a_call?) }
+      elsif call.created_at < 5.minutes.ago && Telephony.provider.call_ended?(call.sid)
+        Conversation.find_with_lock(call.conversation_id) do
+          call.reload.terminate
+        end
+      end
+    end
+
+    def publish_status_change
+      PusherEventPublisher.publish channel: "csrs-#{csr_id}",
+        name: 'statusChange',
+        data: {
+          status: status,
+          timestamp: Integer(Time.now.to_f * 1000)
+        }
+    end
+
+    def number with_protocol = false
+      case phone_type
+      when PhoneType::SIP
+        sip_string with_protocol
+      when PhoneType::TWILIO_CLIENT
+        client_string with_protocol
+      else
+        phone_number
+      end
+    end
+
+    def encode_with coder
+      coder['attributes'] = {
+        'id'     => attributes['id'],
+        'csr_id' => attributes['csr_id']
+      }
+    end
+
+    private
+
+    def client_string with_protocol = false
+      "#{'client:' if with_protocol}agent#{csr_id}"
+    end
+
+    def sip_string with_protocol = false
+      "#{'sip:' if with_protocol}#{sip_address}"
+    end
+
+    def sip_address
+      "#{sip_number}@#{call_center.host}"
+    end
+
+    def call_center
+      CallCenter.find_by_name call_center_name
+    end
+  end
+end

data/app/models/telephony/agent_state_machine.rb

@@ -0,0 +1,54 @@
+require 'state_machine'
+
+module Telephony
+  module AgentStateMachine
+    extend ActiveSupport::Concern
+
+    included do
+      state_machine :status, :initial => :offline do
+        event :available do
+          transition any => :available
+        end
+
+        event :came_online do
+          transition :offline => :available
+        end
+
+        event :offline do
+          transition all - [:offline] => :offline
+        end
+
+        event :on_a_call do
+          transition :available => :on_a_call
+          transition :not_available => :on_a_call
+        end
+
+        event :not_available do
+          transition [:offline, :available] => :not_available
+        end
+
+        event :call_ended do
+          transition :on_a_call => :not_available
+        end
+
+        event :toggle_available do
+          transition :available => :not_available
+          transition :not_available => :available
+        end
+
+        after_transition do |agent, transition|
+          unless transition.loopback?
+            ActiveSupport::Notifications
+              .instrument("telephony.agent_status_change",
+              {
+                agent_id: agent.id,
+                csr_id: agent.csr_id,
+                status: transition.to,
+                timestamp: Time.now.to_i
+              })
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/telephony/base.rb

@@ -0,0 +1,7 @@
+module Telephony
+  class Base < ActiveRecord::Base
+    establish_connection "telephony_#{Rails.env}"
+
+    self.abstract_class = true
+  end
+end

data/app/models/telephony/blacklisted_number.rb

@@ -0,0 +1,5 @@
+module Telephony
+  class BlacklistedNumber < ActiveRecord::Base
+    attr_accessible :number
+  end
+end

data/app/models/telephony/call.rb

@@ -0,0 +1,94 @@
+module Telephony
+  class Call < Base
+    include NumberHelper
+    include CallStateMachine
+
+    belongs_to :conversation
+    has_many :recordings
+    has_one :voicemail
+    has_many :events, class_name: 'Events::Base'
+    belongs_to :agent
+
+    attr_accessible :sid,
+      :number,
+      :state,
+      :participant_id,
+      :participant_type,
+      :connected_at,
+      :terminated_at,
+      :agent
+
+    def number with_protocol = false
+      if agent
+        agent.number with_protocol
+      else
+        customer_number
+      end
+    end
+
+    def sanitized_number
+      normalize_number(number)
+    end
+
+    def make!
+      provider_call = Telephony.provider.call id, number(true), caller_id
+      update_attribute :sid, provider_call.sid
+    end
+
+    def dial_into_conference!
+      provider_call = Telephony.provider.dial_into_conference id, number(true), caller_id
+      update_attribute :sid, provider_call.sid
+    end
+
+    def caller_id
+      conversation.caller_id
+    end
+
+    def whitelisted_number?
+      agent || number != Telephony.provider.uncallable_number
+    end
+
+    def record!(options)
+      if options.include?(:RecordingUrl) && options.include?(:RecordingDuration)
+        recordings.create url: options[:RecordingUrl],
+                          duration: options[:RecordingDuration],
+                          start_time: options[:RecordingDuration].to_i.seconds.ago
+      end
+    end
+
+    def recorded?
+      agent.nil?
+    end
+
+    def redirect_to_dial
+      Telephony.provider.redirect_to_dial id, sid
+    end
+
+    def redirect_to_inbound_connect csr_id
+      Telephony.provider.redirect_to_inbound_connect csr_id, sid
+    end
+
+    def redirect_to_conference
+      Telephony.provider.redirect_to_conference id, sid
+    end
+
+    def redirect_to_hold
+      Telephony.provider.redirect_to_hold id, sid
+    end
+
+    def agent?
+      agent.present?
+    end
+
+    private
+
+    def number_without_whitelisting
+      self[:number]
+    end
+
+    def customer_number
+      number_without_whitelisting &&
+        Telephony.with_whitelisting(number_without_whitelisting)
+    end
+  end
+end