adhearsion 2.6.4 → 3.0.0.beta1

data/lib/adhearsion/rayo/component/prompt.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module Adhearsion
+  module Rayo
+    module Component
+      class Prompt < ComponentNode
+        register :prompt, :prompt
+
+        attribute :barge_in, Boolean
+        attribute :output, Output
+        attribute :input, Input
+
+        ##
+        # Create a prompt command
+        #
+        # @param [Output] output
+        # @param [Input] input
+        # @param [Hash] options
+        # @option options [true, false, optional] :barge_in Indicates wether or not the input should interrupt then output
+        #
+        # @return [Component::Prompt] a formatted Rayo prompt command
+        #
+        def initialize(output = nil, input = nil, options = {})
+          super options
+          self.output = output
+          self.input  = input
+        end
+
+        def inherit(xml_node)
+          input_node = xml_node.at_xpath('ns:input', ns: Input.registered_ns)
+          self.input = Input.from_xml input_node if input_node
+
+          output_node = xml_node.at_xpath('ns:output', ns: Output.registered_ns)
+          self.output = Output.from_xml output_node if output_node
+
+          super
+        end
+
+        def rayo_attributes
+          {
+            'barge-in' => barge_in
+          }
+        end
+
+        def rayo_children(root)
+          input.to_rayo(root) if input
+          output.to_rayo(root) if output
+          super
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/rayo/component/receive_fax.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Adhearsion
+  module Rayo
+    module Component
+      class ReceiveFax < ComponentNode
+        register :receivefax, :fax
+
+        class Fax < RayoNode
+          register :fax, :fax_complete
+
+          attribute :url, String
+          attribute :resolution, String
+          attribute :pages, Integer
+          attribute :size, Integer
+        end
+
+        class Complete
+          class Finish < Event::Complete::Reason
+            register :finish, :fax_complete
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/rayo/component/record.rb

@@ -0,0 +1,165 @@
+# encoding: utf-8
+
+module Adhearsion
+  module Rayo
+    module Component
+      class Record < ComponentNode
+        register :record, :record
+
+        VALID_DIRECTIONS = [:duplex, :send, :recv].freeze
+
+        # @return [String] the codec to use for recording
+        attribute :format
+
+        # @return [Integer] Controls how long the recognizer should wait after the end of the prompt for the caller to speak before sending a Recorder event.
+        attribute :initial_timeout, Integer
+
+        # @return [Integer] Controls the length of a period of silence after callers have spoken to conclude they finished.
+        attribute :final_timeout, Integer
+
+        # @return [Integer] Indicates the maximum duration for the recording.
+        attribute :max_duration, Integer
+
+        # @return [true, false] Indicates whether record will be preceded with a beep.
+        attribute :start_beep, Boolean
+
+        # @return [true, false] Indicates whether record will be followed by a beep.
+        attribute :stop_beep, Boolean
+
+        # @return [true, false] Whether subsequent record will start in PAUSE mode.
+        attribute :start_paused, Boolean
+
+        # @return [Symbol] the direction of media to be recorded.
+        attribute :direction, Symbol
+        def direction=(direction)
+          if direction && !VALID_DIRECTIONS.include?(direction.to_sym)
+            raise ArgumentError, "Invalid Direction (#{direction}), use: #{VALID_DIRECTIONS*' '}"
+          end
+          super
+        end
+
+        # @return [true, false] wether to mix audio down or not
+        attribute :mix, Boolean
+
+        def rayo_attributes
+          {
+            'format' => format,
+            'initial-timeout' => initial_timeout,
+            'final-timeout' => final_timeout,
+            'max-duration' => max_duration,
+            'start-beep' => start_beep,
+            'stop-beep' => stop_beep,
+            'start-paused' => start_paused,
+            'direction' => direction,
+            'mix' => mix
+          }
+        end
+
+        state_machine :state do
+          event :paused do
+            transition :executing => :paused
+          end
+
+          event :resumed do
+            transition :paused => :executing
+          end
+        end
+
+        # Pauses a running Record
+        #
+        # @return [Command::Record::Pause] an Rayo pause message for the current Record
+        #
+        # @example
+        #    record_obj.pause_action.to_xml
+        #
+        #    returns:
+        #      <pause xmlns="urn:xmpp:rayo:record:1"/>
+        def pause_action
+          Pause.new :component_id => component_id, :target_call_id => target_call_id
+        end
+
+        ##
+        # Sends an Rayo pause message for the current Record
+        #
+        def pause!
+          raise InvalidActionError, "Cannot pause a Record that is not executing" unless executing?
+          pause_action.tap do |action|
+            result = write_action action
+            paused! if result
+          end
+        end
+
+        ##
+        # Create an Rayo resume message for the current Record
+        #
+        # @return [Command::Record::Resume] an Rayo resume message
+        #
+        # @example
+        #    record_obj.resume_action.to_xml
+        #
+        #    returns:
+        #      <resume xmlns="urn:xmpp:rayo:record:1"/>
+        def resume_action
+          Resume.new :component_id => component_id, :target_call_id => target_call_id
+        end
+
+        ##
+        # Sends an Rayo resume message for the current Record
+        #
+        def resume!
+          raise InvalidActionError, "Cannot resume a Record that is not paused." unless paused?
+          resume_action.tap do |action|
+            result = write_action action
+            resumed! if result
+          end
+        end
+
+        ##
+        # Directly returns the recording for the component
+        # @return [Adhearsion::Rayo::Component::Record::Recording] The recording object
+        #
+        def recording
+          complete_event.recording
+        end
+
+        ##
+        # Directly returns the recording URI for the component
+        # @return [String] The recording URI
+        #
+        def recording_uri
+          recording.uri
+        end
+
+        class Pause < CommandNode # :nodoc:
+          register :pause, :record
+        end
+
+        class Resume < CommandNode # :nodoc:
+          register :resume, :record
+        end
+
+        class Recording < Event
+          register :recording, :record_complete
+
+          attribute :uri
+          attribute :duration, Integer
+          attribute :size, Integer
+        end
+
+        class Complete
+          class MaxDuration < Event::Complete::Reason
+            register :'max-duration', :record_complete
+          end
+
+          class InitialTimeout < Event::Complete::Reason
+            register :'initial-timeout', :record_complete
+          end
+
+          class FinalTimeout < Event::Complete::Reason
+            register :'final-timeout', :record_complete
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/rayo/component/send_fax.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+module Adhearsion
+  module Rayo
+    module Component
+      class SendFax < ComponentNode
+        register :sendfax, :fax
+
+        class FaxDocument < RayoNode
+          register :document, :fax
+
+          attribute :url, String
+          attribute :identity, String
+          attribute :header, String
+          attribute :pages, String
+
+          def inherit(xml_node)
+            super
+            if pages = xml_node[:pages]
+              self.pages = pages.split(',').map { |p| p.include?('-') ? Range.new(*p.split('-').map(&:to_i)) : p.to_i }
+            end
+            self
+          end
+
+          def rayo_attributes
+            {
+              'url'      => url,
+              'identity' => identity,
+              'header'   => header,
+              'pages'    => rayo_pages
+            }
+          end
+
+        private
+
+          def rayo_pages
+            pages ? pages.map { |p| p.is_a?(Range) ? "#{p.min}-#{p.max}" : p }.join(',') : nil
+          end
+        end
+
+        def inherit(xml_node)
+          document_nodes = xml_node.xpath 'ns:document', ns: self.class.registered_ns
+          self.render_documents = document_nodes.to_a.map { |node| FaxDocument.from_xml node }
+
+          super
+       end
+
+        def rayo_children(root)
+          render_documents.each do |render_document|
+            render_document.to_rayo root.parent
+          end
+          super
+        end
+
+        # @return [Document] the document to render
+        attribute :render_documents, Array[FaxDocument], default: []
+
+        def render_document=(other)
+          self.render_documents = [other].compact
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/rayo/component/stop.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+module Adhearsion
+  module Rayo
+    module Component
+      class Stop < CommandNode # :nodoc:
+        register :stop, :ext
+      end
+    end
+  end
+end

data/lib/adhearsion/rayo/connection.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+module Adhearsion
+  module Rayo
+    module Connection
+    end
+  end
+end
+
+require 'adhearsion/rayo/connection/asterisk'
+require 'adhearsion/rayo/connection/connected'
+require 'adhearsion/rayo/connection/xmpp'

data/lib/adhearsion/rayo/connection/asterisk.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+
+require 'ruby_ami'
+require 'adhearsion/rayo/connection/generic_connection'
+require 'adhearsion/translator'
+
+module Adhearsion
+  module Rayo
+    module Connection
+      class Asterisk < GenericConnection
+        attr_reader :ami_client, :translator
+        attr_accessor :event_handler
+
+        def initialize(options = {})
+          @stream_options = options.values_at(:host, :port, :username, :password)
+          @ami_client = new_ami_stream
+          @translator = Translator::Asterisk.new @ami_client, self
+          super()
+        end
+
+        def run
+          start_ami_client
+          raise DisconnectedError
+        end
+
+        def stop
+          translator.terminate
+          ami_client.terminate
+        end
+
+        def write(command, options)
+          translator.async.execute_command command, options
+        end
+
+        def send_message(*args)
+          translator.send_message *args
+        end
+
+        def handle_event(event)
+          event_handler.call event
+        end
+
+        def new_ami_stream
+          stream = RubyAMI::Stream.new(*@stream_options, ->(event) { translator.async.handle_ami_event event }, logger)
+          client = (ami_client || RubyAMIStreamProxy.new(stream))
+          client.stream = stream
+          client
+        end
+
+        def start_ami_client
+          @ami_client = new_ami_stream unless ami_client.alive?
+          ami_client.async.run
+          Celluloid::Actor.join(ami_client)
+        end
+
+        def new_call_uri
+          Adhearsion.new_uuid
+        end
+
+        class RubyAMIStreamProxy
+          attr_accessor :stream
+
+          def initialize(ami)
+            @stream = ami
+          end
+
+          def method_missing(method, *args, &block)
+            stream.__send__(method, *args, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/rayo/connection/connected.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Adhearsion
+  module Rayo
+    module Connection
+      Connected = Class.new do
+        def source
+          nil
+        end
+
+        def client=(other)
+          nil
+        end
+
+        def eql?(other)
+          other.is_a? self.class
+        end
+        alias :== :eql?
+      end
+    end
+  end
+end

data/lib/adhearsion/rayo/connection/generic_connection.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+module Adhearsion
+  module Rayo
+    module Connection
+      class GenericConnection
+        def initialize
+          @event_handler = lambda { |event| raise 'No event handler set' }
+        end
+
+        def ready!
+        end
+
+        def not_ready!
+        end
+
+        def connected?
+        end
+      end
+    end
+  end
+end