freeswitcher 0.4.10 → 0.5.0

data/README

@@ -56,27 +56,83 @@ An Inbound Event Socket Listener example using FreeSWITCHeR's hook system:
 --------------------------------------------------------------------------
 
   #!/usr/bin/ruby
-  require 'pp'
   require 'fsr'
   require "fsr/listener/inbound"
 
-  # EXAMPLE 1 
-  # This adds a hook on CHANNEL_CREATE events. You can also create a method to handle the event you're after. See the next example
-  FSL::Inbound.add_event_hook(:CHANNEL_CREATE) { FSR::Log.info "*** [#{event.content[:unique_id]}] Channel created - greetings from the hook!" }
+  class MyEventListener < FSR::Listener::Inbound
+    def before_session
+      # This adds a hook on CHANNEL_CREATE events. You can also create a method to handle the event you're after. See the next example
+      add_event(:CHANNEL_CREATE) { |e| p e }
 
-  # EXAMPLE 2
-  # Define a method to handle CHANNEL_HANGUP events.
-  def custom_channel_hangup_handler(event)
-    FSR::Log.info "*** [#{event.content[:unique_id]}] Channel hangup. The event:"
-    pp event
-  end
+      # This adds a hook on CHANNEL_HANGUP events with a callback method.
+      add_event(:CHANNEL_HANGUP) { |e| channel_hangup(e) }
+    end
 
-  # This adds a hook for EXAMPLE 2
-  FSL::Inbound.add_event_hook(:CHANNEL_HANGUP) { custom_channel_hangup_handler(event) }
+    def channel_hangup(event)
+      p event
+    end
+
+    def on_event(event)
+      # This gets called for _every_ event that's subscribed (through add_event)
+      p event
+    end
+  end
 
 
   # Start FSR Inbound Listener
-  FSR.start_ies!(FSL::Inbound, :host => "localhost", :port => 8021)
+  FSR.start_ies!(MyEventListener, :host => "localhost", :port => 8021)
+
+A More Advanced Example, Publishing Events To A Web Socket:
+-----------------------------------------------------------
+
+  class MyWebSocketClient < Struct.new(:reporter, :socket, :channel_id)
+    Channel = EM::Channel.new
+
+    def initialize(reporter, socket)
+      self.reporter, self.socket = reporter, socket
+      socket.onopen(&method(:on_open))
+      socket.onmessage(&method(:on_message))
+      socket.onclose(&method(:on_close))
+    end
+
+    def on_message(json)
+      msg = JSON.parse(json)
+      FSR::Log.info "Websocket got #{msg}"
+    end
+
+    def send(msg)
+      socket.send(msg.to_json)
+    end
+
+    def on_open
+      FSR::Log.info("Subscribed listener")
+      self.channel_id = Channel.subscribe { |message| send(message) }
+    end
+
+    def on_close
+      Channel.unsubscribe(channel_id)
+      FSR::Log.info("Unsubscribed listener")
+    end
+  end
+
+  # Add the Channel to your event listener
+  class MyEventListener
+    def on_event(event)
+      MyWebSocketClient::Channel << event.content
+    end
+  end
+
+  # Start Listener within and EM.run
+  EM.epoll
+  EM.run do
+    server, port = '127.0.0.1', 8021
+    EventMachine.connect(server, port, MyEventListener, auth: 'MyPassword') do |listener|
+      FSR::Log.info "MyEventListener connected to #{server} on #{port}"
+      EventMachine.start_server('0.0.0.0'), 8080, EventSocket::WebSocket::Connection, {}) do |websocket|
+        MyWebSocketClient.new(reporter, websocket)
+      end
+    end
+  end
 
 
 An Inbound Event Socket Listener example using the on_event callback method instead of hooks:

data/Rakefile

@@ -15,7 +15,7 @@ GEM_FILES << "spec/fsr_listener_helper.rb" if Pathname("spec/helper.rb").file?
 
 GEMSPEC = Gem::Specification.new do |spec|
   spec.name = "freeswitcher"
-  spec.version = ENV["FSR_VERSION"] || FSR::VERSION
+  spec.version = (ENV["FSR_VERSION"] || FSR::VERSION).dup
   spec.summary = 'A library for interacting with the "FreeSWITCH":http://freeswitch.org telephony platform'
   spec.authors = ["Jayson Vaughn", "Michael Fellinger", "Kevin Berry", "TJ Vanderpoel"]
   spec.email = "FreeSWITCHeR@rubyists.com"

data/examples/play_and_get_digits.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), "..", 'lib', 'fsr')
+require "fsr/listener/outbound"
+$stdout.flush
+
+class PlayAndGetDigitsDemo < FSR::Listener::Outbound
+
+  def session_initiated
+    exten = @session.headers[:caller_caller_id_number]
+    FSR::Log.info "*** Answering incoming call from #{exten}"
+
+    answer do
+      FSR::Log.info "***Reading DTMF from #{exten}"
+      #######################################################
+      ## NOTE YOU MUST MAKE SURE YOU PASS A VALID WAV FILE ##
+      #######################################################
+      play_and_get_digits("/usr/local/freeswitch/sounds/music/8000/sweet.wav","/usr/local/freeswitch/sounds/music/8000/not.wav", :chan_var => rand(10000).to_s) do |read_var|
+          FSR::Log.info "***Success, grabbed #{read_var.to_s.strip} from #{exten}"
+          # Tell the caller what they entered
+          # If you have mod_flite installed you should hear speech
+          speak("Got the DTMF of: #{read_var.to_s.strip}") { hangup }
+      end
+    end
+
+    def receive_reply(reply)
+      FSR::Log.info "Received #{reply.inspect}"
+    end
+
+  end
+
+end
+
+FSR.start_oes! PlayAndGetDigitsDemo, :port => 8084, :host => "0.0.0.0"

data/lib/fsr.rb

@@ -34,7 +34,10 @@ module FSR
   end
 
   ROOT = Pathname(__FILE__).dirname.expand_path.freeze
-  $LOAD_PATH.unshift(FSR::ROOT)
+  $LOAD_PATH.unshift(FSR::ROOT.to_s)
+
+  FSR_ROOT = Pathname(__FILE__).join("..").dirname.expand_path.freeze
+  $LOAD_PATH.unshift(FSR::FSR_ROOT.to_s)
 
   # Load all FSR::Cmd classes
   def self.load_all_commands(retrying = false)

data/lib/fsr/app/play_and_get_digits.rb

@@ -1,8 +1,13 @@
 require "fsr/app"
+require 'fsr/file_methods'
+
 module FSR
   #http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_play_and_get_digits
   module App
     class PlayAndGetDigits < Application
+
+      include ::FSR::App::FileMethods
+
       attr_reader :chan_var
       DEFAULT_ARGS = {:min => 0, :max => 10, :tries => 3, :timeout => 7000, :terminators => ["#"], :chan_var => "fsr_read_dtmf", :regexp => '\d'}
 
@@ -30,6 +35,9 @@ module FSR
         @chan_var = arg_hash[:chan_var]
         @terminators = arg_hash[:terminators]
         @regexp = arg_hash[:regexp]
+
+        raise unless test_files(@sound_file, @invalid_file)
+
       end
 
       def arguments

data/lib/fsr/app/playback.rb

@@ -1,19 +1,25 @@
 require "fsr/app"
+require 'fsr/file_methods'
 module FSR
   module App
     class Playback < Application
+
+      include ::FSR::App::FileMethods
+
       attr_reader :wavfile
 
       def initialize(wavfile)
-        # wav file you wish to play, full path 
+        # wav file you wish to play, full path
+        test_files wavfile
         @wavfile = wavfile
       end
+
       def arguments
         @wavfile
       end
 
       def sendmsg
-        "call-command: execute\nexecute-app-name: %s\nexecute-app-arg: %s\nevent-lock:true\n\n" % [app_name, arguments] 
+        "call-command: execute\nexecute-app-name: %s\nexecute-app-arg: %s\nevent-lock:true\n\n" % [app_name, arguments]
       end
     end
 

data/lib/fsr/cmd/call_center.rb

@@ -0,0 +1,156 @@
+require "fsr/app"
+module FSR
+  module Cmd
+    class CallCenter < Command
+      attr_accessor :cmd
+      def initialize(fs_socket = nil, config_type = :agent)
+        @fs_socket = fs_socket # FSR::CommandSocket obj
+        @config_type = config_type
+        @last_repsonse = nil
+        @cmd = []
+      end
+
+      def list_agent
+        ["list"]
+      end
+
+      def last_response
+        responses.last
+      end
+
+      def responses
+        @responses ||= []
+      end
+
+      def list_tier(queue)
+        ["list", queue]
+      end
+
+      def list_queue(queue=nil)
+        ["list", queue].compact
+      end
+
+      def list(*args)
+        @listing = true
+        @cmd = case @config_type
+        when :agent
+          list_agent(*args)
+        when :tier
+          list_tier(*args)
+        when :queue
+          list_queue(*args)
+        else
+          raise "no such config_type #{@config_type}"
+        end
+        self
+      end
+
+
+      def set_agent(agent, field, value)
+        value = value.respond_to?(:each_char) ? "'#{value}'" : value
+        ["set", field.to_s, "'#{agent}'", value].compact
+      end
+
+      def set_tier(agent, queue, field, value)
+        ["set", field.to_s, queue, agent, "'#{value}'"].compact
+      end
+
+      def set(agent, *args)
+        @listing = false
+        @cmd = case @config_type
+        when :agent
+          set_agent(agent, *args)
+        when :tier
+          set_tier(agent, *args)
+        else
+          raise "Cannot run set on #{@config_type}"
+        end
+        self
+      end
+
+      def add_tier(agent, queue, level = 1, position = nil)
+        ["add", queue, agent, level, position].compact
+      end
+
+      def add_agent(agent, callback = nil)
+        callback ||= 'callback'
+        ["add", "'#{agent}'", callback].compact
+      end
+
+      def add(agent, *args)
+        @listing = false
+        @cmd = case @config_type
+        when :agent
+          add_agent(agent, *args)
+        when :tier
+          add_tier(agent, *args)
+        else
+          raise "Cannot add to #{@config_type}"
+        end
+        self
+      end
+
+      protected :list_agent, :list_tier, :list_queue, :set_agent, :set_tier, :add_tier, :add_agent
+      def del(agent, queue = nil)
+        @listing = false
+        @cmd = ["del", queue, agent].compact        
+        self
+      end
+
+      def run(api_method = :api)
+        orig_command = "%s %s" % [api_method, raw]
+        resp = @fs_socket.say(orig_command)
+        responses << resp
+        if @listing
+          if resp["body"].match(/^([^|]*\|[^|]*)+/)
+            require "csv"
+            csv = CSV.parse(resp["body"], :col_sep => '|', :headers => true)
+            case @config_type
+            when :tier
+              require "fsr/model/tier"
+              csv.to_a[1 .. -2].map { |c| FSR::Model::Tier.new(csv.headers, *c) }
+            when :queue
+              require "fsr/model/queue"
+              csv.to_a[1 .. -2].map { |c| FSR::Model::Queue.new(csv.headers, *c) }
+            when :agent
+              require "fsr/model/agent"
+              csv.to_a[1 .. -2].map { |c| FSR::Model::Agent.new(csv.headers, *c) }
+            end
+          else
+            []
+          end
+        else
+          resp["body"].to_s =~ /\+OK$/
+        end
+      end
+=begin
+      # Send the command to the event socket, using bgapi by default.
+      def run(api_method = :api)
+        orig_command = "%s %s" % [api_method, raw]
+        Log.debug "saying #{orig_command}"
+        resp = @fs_socket.say(orig_command)
+        unless resp["body"] == "0 total."
+          call_info, count = resp["body"].split("\n\n")
+          require "fsr/model/call"
+          begin
+            require "fastercsv"
+            @calls = FCSV.parse(call_info)
+          rescue LoadError
+            require "csv"
+            @calls = CSV.parse(call_info)
+          end
+          return @calls[1 .. -1].map { |c| FSR::Model::Call.new(@calls[0],*c) }
+        end
+        []
+      end
+=end
+
+      # This method builds the API command to send to the freeswitch event socket
+      def raw
+        ["callcenter_config", @config_type, *@cmd].join(" ")
+      end
+    end
+
+    register(:call_center, CallCenter)
+  end
+end

data/lib/fsr/cmd/calls.rb

@@ -25,14 +25,14 @@ module FSR
           require "fsr/model/call"
           begin
             require "fastercsv"
-            calls = FCSV.parse(call_info)
+            @calls = FCSV.parse(call_info)
           rescue LoadError
             require "csv"
-            calls = CSV.parse(call_info)
+            @calls = CSV.parse(call_info)
           end
-          return calls[1 .. -1].map { |c| FSR::Model::Call.new(*c) }
+          return @calls[1 .. -1].map { |c| FSR::Model::Call.new(@calls[0],*c) }
         end
-        nil
+        []
       end
 
       # This method builds the API command to send to the freeswitch event socket

data/lib/fsr/cmd/channels.rb

@@ -0,0 +1,47 @@
+require "fsr/app"
+module FSR
+  module Cmd
+    class Channels < Command
+
+      include Enumerable
+      def each(&block)
+        @channels ||= run
+        if @channels
+          @channels.each { |call| yield call }
+        end
+      end
+
+      def initialize(fs_socket = nil, distinct = true)
+        @distinct = distinct
+        @fs_socket = fs_socket # FSR::CommandSocket obj
+      end
+
+      # Send the command to the event socket, using bgapi by default.
+      def run(api_method = :api)
+        orig_command = "%s %s" % [api_method, raw]
+        Log.debug "saying #{orig_command}"
+        resp = @fs_socket.say(orig_command)
+        unless resp["body"] == "0 total."
+          call_info, count = resp["body"].split("\n\n")
+          require "fsr/model/channel"
+          begin
+            require "fastercsv"
+            @channels = FCSV.parse(call_info)
+          rescue LoadError
+            require "csv"
+            @channels = CSV.parse(call_info)
+          end
+          return @channels[1 .. -1].map { |c| FSR::Model::Channel.new(@channels[0],*c) }
+        end
+        []
+      end
+
+      # This method builds the API command to send to the freeswitch event socket
+      def raw
+        orig_command = @distinct ? "show distinct_channels" : "show channels"
+      end
+    end
+
+    register(:channels, Channels)
+  end
+end

data/lib/fsr/cmd/enum.rb

@@ -0,0 +1,40 @@
+require "fsr/app"
+module FSR
+  module Cmd
+    class Enum < Command
+      attr_reader :ph_nbr
+
+      def initialize(fs_socket = nil, phone_number = nil)
+        @fs_socket = fs_socket # FSR::CommandSocket obj
+        @ph_nbr = phone_number # phone number to look up, up to 15 digits
+      end
+
+      # Send the command to the event socket, using api by default.
+      def run(api_method = :api)
+        orig_command = "%s %s" % [api_method, raw]
+        Log.debug "saying #{orig_command}"
+        resp = @fs_socket.say(orig_command)
+        parse(resp)
+      end
+
+      # This method builds the API command to send to the freeswitch event socket
+      def raw
+        orig_command = "enum #{ph_nbr}"
+      end
+
+      def parse(response)
+        body = response["body"]
+        offered_routes,supported_routes = body.match(/Offered\ Routes:(.*?)Supported\ Routes:(.*?)/mx)[1 .. 2]
+        order, pref, service, route = offered_routes.match(/==+\n(.*)/m)[1].split
+        unless body == "No Match!"
+          require "fsr/model/enum"
+          return FSR::Model::Enum.new(offered_routes, supported_routes, order, pref, service, route)
+        end
+        nil
+      end
+
+    end
+
+    register(:enum, Enum)
+  end
+end