eric-adhearsion 0.7.999

data/lib/adhearsion/voip/asterisk/config_generators/voicemail.conf.rb

@@ -0,0 +1,240 @@
+require File.join(File.dirname(__FILE__), 'config_generator')
+
+module Adhearsion
+  module VoIP
+    module Asterisk
+      module ConfigFileGenerators
+        class Voicemail < AsteriskConfigGenerator
+          
+          DEFAULT_GENERAL_SECTION = {
+            :format => :wav
+          }
+          
+          # Don't worry. These will be overridable soon.
+          STATIC_ZONEMESSAGES_CONTEXT = %{
+            [zonemessages]
+            eastern=America/New_York|'vm-received' Q 'digits/at' IMp
+            central=America/Chicago|'vm-received' Q 'digits/at' IMp
+            central24=America/Chicago|'vm-received' q 'digits/at' H N 'hours'
+            military=Zulu|'vm-received' q 'digits/at' H N 'hours' 'phonetic/z_p'
+            european=Europe/Copenhagen|'vm-received' a d b 'digits/at' HM
+          }.unindent
+          
+          attr_reader :properties, :context_definitions
+          def initialize
+            @properties = DEFAULT_GENERAL_SECTION.clone
+            @mailboxes  = {}
+            @context_definitions = []
+            super
+          end
+          
+          def context(name)
+            raise ArgumentError, "Name cannot be 'general'!" if name.to_s.downcase == 'general'
+            raise ArgumentError, "A name can only be characters, numbers, and underscores!" if name.to_s !~ /^[\w_]+$/            
+            
+            returning ContextDefinition.new(name) do |context_definition|
+              yield context_definition
+              context_definitions << context_definition
+            end
+          end
+          
+          def greeting_maximum(seconds)
+            int "maxgreet" => seconds
+          end
+          
+          def execute_on_pin_change(command)
+            string "externpass" => command 
+          end
+          
+          def recordings
+            @recordings ||= RecordingDefinition.new
+            yield @recordings if block_given?
+            @recordings
+          end
+          
+          def emails
+            @emails ||= EmailDefinition.new
+            if block_given?
+              yield @emails
+            else
+              @emails
+            end
+          end
+          
+          def to_s
+            email_properties = @emails ? @emails.properties : {}
+            AsteriskConfigGenerator.warning_message +
+            "[general]\n" +
+            properties.merge(email_properties).map { |(key,value)| "#{key}=#{value}" }.sort.join("\n") + "\n\n" +
+            STATIC_ZONEMESSAGES_CONTEXT +
+            context_definitions.map(&:to_s).join("\n\n")
+          end
+          
+          private
+          
+          class ContextDefinition < AsteriskConfigGenerator
+            
+            attr_reader :mailboxes
+            def initialize(name)
+              @name      = name
+              @mailboxes = []
+              super()
+            end
+            
+            # TODO: This will hold a lot of the methods from the [general] section!
+            
+            def to_s
+              (%W[[#@name]] + mailboxes.map(&:to_s)).join "\n"
+            end
+            
+            def mailbox(mailbox_number)
+              box = MailboxDefinition.new(mailbox_number)
+              yield box
+              mailboxes << box
+            end
+            
+            private
+            
+            def mailbox_entry(options)
+              returning MailboxDefinition.new do |mailbox|
+                yield mailbox if block_given?
+                mailboxes << definition
+              end
+            end
+            
+            class MailboxDefinition
+
+              attr_reader :mailbox_number
+              def initialize(mailbox_number)
+                check_numeric mailbox_number
+                @mailbox_number = mailbox_number
+                @definition = {}
+                super()
+              end
+
+              def pin_number(number)
+                check_numeric number
+                @definition[:pin_number] = number
+              end
+
+              def name(str)
+                @definition[:name] = str
+              end
+
+              def email(str)
+                @definition[:email] = str
+              end
+
+              def to_hash
+                @definition
+              end
+              
+              def to_s
+                %(#{mailbox_number} => #{@definition[:pin_number]},#{@definition[:name]},#{@definition[:email]})[/^(.+?),*$/,1]
+              end
+
+              private
+              
+              def check_numeric(number)
+                raise ArgumentError, number.inspect + " is not numeric!" unless number.to_s =~ /^\d+$/
+              end
+
+            end
+          end
+          
+          class EmailDefinition < AsteriskConfigGenerator
+            EMAIL_VARIABLE_CONVENIENCES = {
+              :name             => '${VM_NAME}',
+              :duration         => '${VM_DUR}',
+              :message_number   => '${VM_MSGNUM}',
+              :mailbox          => '${VM_MAILBOX}',
+              :caller_id        => '${VM_CALLERID}',
+              :date             => '${VM_DATE}',
+              :caller_id_number => '${VM_CIDNUM}',
+              :caller_id_name   => '${VM_CIDNAME}'
+            }
+            
+            attr_reader :properties
+            def initialize
+              @properties = {}
+              super
+            end
+            
+            def [](email_variable)
+              if EMAIL_VARIABLE_CONVENIENCES.has_key? email_variable
+                EMAIL_VARIABLE_CONVENIENCES[email_variable]
+              else
+                raise ArgumentError, "Unrecognized variable #{email_variable.inspect}"
+              end
+            end
+            
+            def disable!
+              raise NotImpementedError
+            end
+            
+            def from(options)
+              name, email = options.values_at :name, :email
+              string :serveremail => email
+              string :fromstring  => name
+            end
+            
+            def attach_recordings(true_or_false)
+              boolean :attach => true_or_false
+            end
+            
+            def attach_recordings?
+              properties[:attach] == 'yes'
+            end
+            
+            def body(str)
+              str = str.gsub("\r", '').gsub("\n", '\n')
+              if str.length > 512
+                raise ArgumentError, "Asterisk has an email body limit of 512 characters! Your body is too long!\n" +
+                ("-" * 10) + "\n" + str
+              end
+              string :emailbody => str
+            end
+            
+            def subject(str)
+              string :emailsubject => str
+            end
+            
+            def command(cmd)
+              string :mailcmd => cmd
+            end
+            
+          end
+          
+          class RecordingDefinition < AsteriskConfigGenerator
+            
+            attr_reader :properties
+            def initialize
+              @properties = {}
+              super
+            end
+            
+            def format(symbol)
+              one_of [:gsm, :wav49, :wav], :format => symbol
+            end
+            
+            def allowed_length(seconds)
+              case seconds
+                when Fixnum
+                  int :maxmessage => "value"
+                when Range
+                  int :minmessage => seconds.first
+                  int :maxmessage => seconds.last
+                else
+                  raise ArgumentError, "Argument must be a Fixnum or Range!"
+              end
+            end
+            
+            def maximum_silence(seconds)
+              int :maxsilence => seconds
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/voip/asterisk/config_manager.rb

@@ -0,0 +1,71 @@
+require 'enumerator'
+module Adhearsion
+  module VoIP
+    module Asterisk
+      class ConfigurationManager
+        
+        class << self
+          def normalize_configuration(file_contents)
+            # cat sip.conf | sed -e 's/\s*;.*$//g' | sed -e '/^;.*$/d' | sed -e '/^\s*$/d'
+            file_contents.split(/\n+/).map do |line|
+              line.sub(/;.+$/, '').strip
+            end.join("\n").squeeze("\n")
+          end
+        end
+        
+        attr_reader :filename
+        
+        def initialize(filename)
+          @filename = filename
+        end
+        
+        def sections
+          @sections ||= read_configuration
+        end
+        
+        def [](section_name)
+          result = sections.find { |(name, *rest)| section_name == name }
+          result.last if result
+        end
+        
+        def delete_section(section_name)
+          sections.reject! { |(name, *rest)| section_name == name }
+        end
+        
+        def new_section(name, properties={})
+          sections << [name, properties]
+        end
+        
+        private
+        
+        def read_configuration
+          normalized_file = self.class.normalize_configuration execute(read_command)
+          normalized_file.split(/^\[([-_\w]+)\]$/)[1..-1].enum_slice(2).map do |(name,properties)|
+            [name, hash_from_properties(properties)]
+          end
+        end
+        
+        def hash_from_properties(properties)
+          properties.split(/\n+/).inject({}) do |property_hash,property|
+            all, name, value = *property.match(/^\s*([^=]+?)\s*=\s*(.+)\s*$/)
+            next property_hash unless name && value
+            property_hash[name] = value
+            property_hash
+          end
+        end
+        
+        def execute(command)
+          %x[command]
+        end
+        
+        def read_command
+          "cat #{filename}"
+        end
+        
+      end
+    end
+  end
+end
+
+# Read a file: cat a file
+# Parse a file: separate into a two dimensional hash

data/lib/adhearsion/voip/asterisk/special_dial_plan_managers.rb

@@ -0,0 +1,80 @@
+module Adhearsion
+  class DialPlan
+    class ConfirmationManager
+      
+      class << self
+          
+        def encode_hash_for_dial_macro_argument(options)
+          options    = options.clone
+          macro_name = options.delete :macro
+          options[:play] &&= options[:play].kind_of?(Array) ? options[:play].join('++') : options[:play]
+          encoded_options = URI.escape options.map { |key,value| "#{key}:#{value}" }.join('!')
+          returning "M(#{macro_name}^#{encoded_options})" do |str|
+            if str.rindex('^') != str.index('^')
+              raise ArgumentError, "You seem to have supplied a :confirm option with a caret (^) in it!" + 
+                                   " Please remove it. This will blow Asterisk up."
+            end
+          end
+        end
+        
+        def handle(call)
+          new(call).handle
+        end
+        
+        def confirmation_call?(call)
+          call.variables.has_key?(:network_script) && call.variables[:network_script].starts_with?('confirm!')
+        end
+                
+        def decode_hash(encoded_hash)
+          encoded_hash = encoded_hash =~ /^M\((.+)\)$/ ? $1 : encoded_hash
+          encoded_hash = encoded_hash =~ /^([^:]+\^)?(.+)$/ ? $2 : encoded_hash # Remove the macro name if it's there
+          unencoded = URI.unescape(encoded_hash).split('!')
+          unencoded.shift unless unencoded.first.include?(':')
+          unencoded = unencoded.map { |pair| key, value = pair.split(':'); [key.to_sym ,value] }.flatten
+          returning Hash[*unencoded] do |hash|
+            hash[:timeout]    &&= hash[:timeout].to_i
+            hash[:play]       &&= hash[:play].split('++')
+          end
+        end
+
+      end
+      
+      attr_reader :call
+      def initialize(call)
+        @call = call
+        extend Adhearsion::VoIP::Commands.for(call.originating_voip_platform)
+      end
+      
+      def handle
+        variables = self.class.decode_hash call.variables[:network_script]
+        
+        answer
+        loop do
+          response = interruptable_play(*variables[:play])
+          if response && response.to_s == variables[:key].to_s
+            # Don't set a variable to pass through to dial()
+            break
+          elsif response && response.to_s != variables[:key].to_s
+            next
+          else
+            response = wait_for_digit variables[:timeout]
+            if response 
+              if response.to_s == variables[:key].to_s
+                # Don't set a variable to pass through to dial()
+                break
+              else
+                next
+              end
+            else
+              # By setting MACRO_RESULT to CONTINUE, we cancel the dial.
+              variable 'MACRO_RESULT' => "CONTINUE"
+              break
+            end
+          end
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/adhearsion/voip/asterisk.rb

@@ -0,0 +1,4 @@
+require File.dirname(__FILE__) + "/dsl/numerical_string"
+require File.dirname(__FILE__) + "/asterisk/agi_server"
+require File.dirname(__FILE__) + "/asterisk/ami"
+require File.dirname(__FILE__) + "/asterisk/commands"