adhearsion 1.2.6 → 2.0.0.alpha1

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

@@ -1,140 +0,0 @@
-require File.join(File.dirname(__FILE__), 'config_generator')
-
-module Adhearsion
-  module VoIP
-    module Asterisk
-      module ConfigFileGenerators
-        class Agents < AsteriskConfigGenerator
-
-          attr_accessor :general_section, :agent_section, :agent_definitions, :agent_section_special
-          def initialize
-            @general_section       = {}
-            @agent_section         = {}
-            @agent_section_special = {} # Uses => separator
-            @agent_definitions     = []
-
-            super
-          end
-
-          def to_s
-            AsteriskConfigGenerator.warning_message +
-            general_section.inject("[general]") { |section,(key,value)| section + "\n#{key}=#{value}" } +
-            agent_section.inject("\n[agents]")  { |section,(key,value)| section + "\n#{key}=#{value}" } +
-            agent_section_special.inject("")    { |section,(key,value)| section + "\n#{key} => #{value}" } +
-            agent_definitions.inject("\n") do |section,properties|
-              section + "\nagent => #{properties[:id]},#{properties[:password]},#{properties[:name]}"
-            end
-          end
-          alias conf to_s # Allows "agents.conf" if agents.kind_of?(Agents)
-
-          def agent(id, properties)
-            agent_definitions << {:id => id}.merge(properties)
-          end
-
-          # Group memberships for agents (may change in mid-file)
-          # WHAT DOES GROUPING ACCOMPLISH?
-          def groups(*args)
-            agent_section[:group] = args.join(",")
-          end
-
-          # Define whether callbacklogins should be stored in astdb for
-          # persistence. Persistent logins will be reloaded after
-          # Asterisk restarts.
-          def persistent_agents(yes_or_no)
-            general_section[:persistentagents] = boolean_to_yes_no yes_or_no
-          end
-
-          # enable or disable a single extension from longing in as multiple
-          # agents, defaults to enabled
-          def allow_multiple_logins_per_extension(yes_or_no)
-            general_section[:multiplelogin] = boolean_to_yes_no yes_or_no
-          end
-
-          # Define maxlogintries to allow agent to try max logins before
-          # failed. Default to 3
-          def max_login_tries(number_of_tries)
-            agent_section[:maxlogintries] = number_of_tries
-          end
-
-          # Define autologoff times if appropriate.  This is how long
-          # the phone has to ring with no answer before the agent is
-          # automatically logged off (in seconds)
-          def log_off_after_duration(time_in_seconds)
-            agent_section[:autologoff] = time_in_seconds
-          end
-
-          # Define autologoffunavail to have agents automatically logged
-          # out when the extension that they are at returns a CHANUNAVAIL
-          # status when a call is attempted to be sent there.
-          # Default is "no".
-          def log_off_if_unavailable(yes_or_no)
-            agent_section[:autologoffunavail] = boolean_to_yes_no yes_or_no
-          end
-
-          # Define ackcall to require an acknowledgement by '#' when
-          # an agent logs in using agentcallbacklogin.  Default is "no".
-          def require_hash_to_acknowledge(yes_or_no)
-            agent_section[:ackcall] = boolean_to_yes_no yes_or_no
-          end
-
-          # Define endcall to allow an agent to hangup a call by '*'.
-          # Default is "yes". Set this to "no" to ignore '*'.
-          def allow_star_to_hangup(yes_or_no)
-            agent_section[:endcall] = boolean_to_yes_no yes_or_no
-          end
-
-          # Define wrapuptime.  This is the minimum amount of time when
-          # after disconnecting before the caller can receive a new call
-          # note this is in milliseconds.
-          def time_between_calls(time_in_seconds)
-            agent_section[:wrapuptime] = (time_in_seconds * 1000).to_i
-          end
-
-          # Define the default musiconhold for agents
-          # musiconhold => music_class
-          def hold_music_class(music_class)
-            agent_section_special[:musiconhold] = music_class.to_s
-          end
-
-          # TODO: I'm not exactly sure what this even does....
-
-          # Define the default good bye sound file for agents
-          # default to vm-goodbye
-          def play_on_agent_goodbye(sound_file_name)
-            agent_section_special[:agentgoodbye] = sound_file_name
-          end
-
-          # Define updatecdr. This is whether or not to change the source
-          # channel in the CDR record for this call to agent/agent_id so
-          # that we know which agent generates the call
-          def change_cdr_source(yes_or_no)
-            agent_section[:updatecdr] =  boolean_to_yes_no yes_or_no
-          end
-
-          # An optional custom beep sound file to play to always-connected agents.
-          def play_for_waiting_keep_alive(sound_file)
-            agent_section[:custom_beep] = sound_file
-          end
-
-          def record_agent_calls(yes_or_no)
-            agent_section[:recordagentcalls] = boolean_to_yes_no yes_or_no
-          end
-
-          def recording_format(symbol)
-            raise ArgumentError, "Unrecognized format #{symbol}" unless [:wav, :wav49, :gsm].include? symbol
-            agent_section[:recordformat] = symbol
-          end
-
-          def recording_prefix(string)
-            agent_section[:urlprefix] = string
-          end
-
-          def save_recordings_in(path_to_directory)
-            agent_section[:savecallsin] = path_to_directory
-          end
-
-        end
-      end
-    end
-  end
-end

data/lib/adhearsion/voip/asterisk/config_generators/config_generator.rb

@@ -1,102 +0,0 @@
-module Adhearsion
-  module VoIP
-    module Asterisk
-      module ConfigFileGenerators
-        class AsteriskConfigGenerator
-
-          SECTION_TITLE = /(\[[\w_-]+\])/
-
-          class << self
-
-            # Converts a config file into a Hash of contexts mapping to two dimensional array of pairs
-            def create_sanitary_hash_from(config_file_content)
-              almost_sanitized = Hash[*config_file_content.
-                split("\n").          # Split the lines into an Array
-                grep(/^\s*[^;\s]/).   # Grep lines that aren't commented out
-                join("\n").           # Convert them into one String again
-                split(SECTION_TITLE). # Separate them into sections
-                map(&:strip).         # Remove all whitespace
-                reject(&:empty?).     # Get rid of indices that were only whitespace
-                                      # Lastly, separate the keys/value pairs for the Hash
-                map { |token| token =~ /^#{SECTION_TITLE}$/ ? token : token.split(/\n+/).sort }
-              ]
-            end
-
-            def warning_message
-              %{;; THIS FILE WAS GENERATED BY ADHEARSION ON #{Time.now.ctime}!\n} +
-              %{;; ANY CHANGES MADE BELOW WILL BE BLOWN AWAY WHEN THE FILE IS REGENERATED!\n\n}
-            end
-
-          end
-
-          def initialize
-            yield self if block_given?
-          end
-
-          def to_sanitary_hash
-            self.class.create_sanitary_hash_from to_s
-          end
-
-          protected
-
-          def boolean(options)
-            cache = options.delete(:with) || properties
-            options.each_pair do |key, value|
-              cache[key] = boolean_to_yes_no value
-            end
-          end
-
-          def string(options)
-            cache = options.delete(:with) || properties
-            options.each_pair do |key, value|
-              cache[key] = value
-            end
-          end
-
-          def int(options)
-            cache = options.delete(:with) || properties
-            options.each_pair do |property,number|
-              number = number.to_i if (number.kind_of?(String) && number =~ /^\d+$/) || number.kind_of?(Numeric)
-              raise ArgumentError, "#{number.inspect} must be an integer" unless number.kind_of?(Fixnum)
-              cache[property] = number.to_i
-            end
-          end
-
-          def one_of(criteria, options)
-            cache = options.delete(:with) || properties
-            options.each_pair do |key, value|
-              search = !criteria.find { |criterion| criterion === value }.nil?
-              unless search
-                msg = "Didn't recognize #{value.inspect}! Must be one of " + criteria.map(&:inspect).to_sentence
-                raise ArgumentError, msg
-              end
-              cache[key] = [true, false].include?(value) ? boolean_to_yes_no(value) : value
-            end
-          end
-
-          def one_of_and_translate(criteria, options)
-            cache = options.delete(:with) || properties
-            options.each_pair do |key, value|
-              search = criteria.keys.find { |criterion| criterion === value }
-              unless search
-                msg = "Didn't recognize #{value.inspect}! Must be one of " + criteria.keys.map(&:inspect).to_sentence
-                raise ArgumentError, msg
-              end
-              cache[key] = criteria[value]
-            end
-          end
-
-          private
-
-          def boolean_to_yes_no(boolean)
-            unless boolean.equal?(boolean) || boolean.equal?(boolean)
-              raise "#{boolean.inspect} is not true/false!"
-            end
-            boolean ? 'yes' : 'no'
-          end
-
-        end
-      end
-    end
-  end
-end

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

@@ -1,250 +0,0 @@
-require File.join(File.dirname(__FILE__), 'config_generator')
-
-module Adhearsion
-  module VoIP
-    module Asterisk
-      module ConfigFileGenerators
-
-        # This will generate a queues.conf file. If there is no documentation on what a method
-        # actually does, take a look at the documentation for its original key/value pair in
-        # an unedited queues.conf file. WARNING! Don't get too embedded with these method names.
-        # I'm still not satisfied. These settings will be greatly abstracted eventually.
-        class Queues < AsteriskConfigGenerator
-
-          DEFAULT_GENERAL_SECTION = {
-            :autofill => "yes"
-          }
-
-          attr_reader :general_section, :queue_definitions, :properties
-          def initialize
-            @general_section   = DEFAULT_GENERAL_SECTION.clone
-            @properties        = {}
-            @queue_definitions = []
-            super
-          end
-
-          def queue(name)
-            new_queue = QueueDefinition.new name
-            yield new_queue if block_given?
-            queue_definitions << new_queue
-            new_queue
-          end
-
-          def to_s
-            AsteriskConfigGenerator.warning_message +
-            general_section.inject("[general]") { |section,(key,value)| section + "\n#{key}=#{value}" } + "\n\n" +
-            queue_definitions.map(&:to_s).join("\n\n")
-          end
-          alias conf to_s
-
-          def persistent_members(yes_no)
-            boolean :persistentmembers => yes_no, :with => general_section
-          end
-
-          def monitor_type(symbol)
-            criteria = {:monitor => "Monitor", :mix_monitor => "MixMonitor"}
-            one_of_and_translate criteria, 'monitor-type' => symbol, :with => general_section
-          end
-
-
-          class QueueDefinition < AsteriskConfigGenerator
-
-            DEFAULT_QUEUE_PROPERTIES = {
-              :autofill          => 'yes',
-              :eventwhencalled   => 'vars',
-              :eventmemberstatus => 'yes',
-              :setinterfacevar   => 'yes'
-            }
-
-            SUPPORTED_RING_STRATEGIES = [:ringall, :roundrobin, :leastrecent, :fewestcalls, :random, :rrmemory]
-
-            DEFAULT_SOUND_FILES = {
-              'queue-youarenext'   => 'queue-youarenext',
-              'queue-thereare'     => 'queue-thereare',
-              'queue-callswaiting' => 'queue-callswaiting',
-              'queue-holdtime'     => 'queue-holdtime',
-              'queue-minutes'      => 'queue-minutes',
-              'queue-seconds'      => 'queue-seconds',
-              'queue-thankyou'     => 'queue-thankyou',
-              'queue-lessthan'     => 'queue-less-than',
-              'queue-reporthold'   => 'queue-reporthold',
-              'periodic-announce'  => 'queue-periodic-announce'
-            }
-
-            SOUND_FILE_SYMBOL_INTERPRETATIONS = {
-              :you_are_next           => 'queue-youarenext',
-              :there_are              => 'queue-thereare',
-              :calls_waiting          => 'queue-callswaiting',
-              :hold_time              => 'queue-holdtime',
-              :minutes                => 'queue-minutes',
-              :seconds                => 'queue-seconds',
-              :thank_you              => 'queue-thankyou',
-              :less_than              => 'queue-lessthan',
-              :report_hold            => 'queue-reporthold',
-              :periodic_announcement  => 'periodic-announce'
-            }
-
-            attr_reader :members, :name, :properties
-            def initialize(name)
-              @name        = name
-              @members     = []
-              @properties  = DEFAULT_QUEUE_PROPERTIES.clone
-              @sound_files = DEFAULT_SOUND_FILES.clone
-            end
-
-            def to_s
-              "[#{name}]\n" +
-              properties.merge(@sound_files).map { |key, value| "#{key}=#{value}" }.sort.join("\n") + "\n\n" +
-              members.map { |member| "member => #{member}" }.join("\n")
-            end
-
-            def music_class(moh_identifier)
-              string :musicclass => moh_identifier
-            end
-
-            def play_on_connect(sound_file)
-              string :announce => sound_file
-            end
-
-            def strategy(symbol)
-              one_of SUPPORTED_RING_STRATEGIES, :strategy => symbol
-            end
-
-            def service_level(seconds)
-              int :servicelevel => seconds
-            end
-
-            # A context may be specified, in which if the user types a SINGLE
-            # digit extension while they are in the queue, they will be taken out
-            # of the queue and sent to that extension in this context. This context
-            # should obviously be a different context other than the one that
-            # normally forwards to Adhearsion (though the context that handles
-            # these digits should probably go out to Adhearsion too).
-            def exit_to_context_on_digit_press(context_name)
-              string :context => context_name
-            end
-
-            # Ex: ring_timeout 15.seconds
-            def ring_timeout(seconds)
-              int :timeout => seconds
-            end
-
-            # Ex: retry_after_waiting 5.seconds
-            def retry_after_waiting(seconds)
-              int :retry => seconds
-            end
-
-            # THIS IS UNSUPPORTED
-            def weight(number)
-              int :weight => number
-            end
-
-            # Ex: wrapup_time 1.minute
-            def wrapup_time(seconds)
-              int :wrapuptime => seconds
-            end
-
-
-            def autopause(yes_no)
-              boolean :autopause => yes_no
-            end
-
-            def maximum_length(number)
-              int :maxlen => number
-            end
-
-            def queue_status_announce_frequency(seconds)
-              int "announce-frequency" => seconds
-            end
-
-            def periodically_announce(sound_file, options={})
-              frequency = options.delete(:every) || 1.minute
-
-              string 'periodic-announce' => sound_file
-              int 'periodic-announce-frequency' => frequency
-            end
-
-            def announce_hold_time(seconds)
-              one_of [true, false, :once], "announce-holdtime" => seconds
-            end
-
-            def announce_round_seconds(yes_no_or_once)
-              int "announce-round-seconds" => yes_no_or_once
-            end
-
-            def monitor_format(symbol)
-              one_of [:wav, :gsm, :wav49], 'monitor-format' => symbol
-            end
-
-            def monitor_type(symbol)
-              criteria = {:monitor => "Monitor", :mix_monitor => "MixMonitor"}
-              one_of_and_translate criteria, 'monitor-type' => symbol
-            end
-
-            # Ex: join_empty true
-            # Ex: join_empty :strict
-            def join_empty(yes_no_or_strict)
-              one_of [true, false, :strict], :joinempty => yes_no_or_strict
-            end
-
-            def leave_when_empty(yes_no)
-              boolean :leavewhenempty => yes_no
-            end
-
-            def report_hold_time(yes_no)
-              boolean :reportholdtime => yes_no
-            end
-
-            def ring_in_use(yes_no)
-              boolean :ringinuse => yes_no
-            end
-
-            # Number of seconds to wait when an agent is to be bridged with
-            # a caller. Normally you'd want this to be zero.
-            def delay_connection_by(seconds)
-              int :memberdelay => seconds
-            end
-
-            def timeout_restart(yes_no)
-              boolean :timeoutrestart => yes_no
-            end
-
-            # Give a Hash argument here to override the default sound files for this queue.
-            #
-            # Usage:
-            #
-            #   queue.sound_files :you_are_next          => 'queue-youarenext',
-            #                     :there_are             => 'queue-thereare',
-            #                     :calls_waiting         => 'queue-callswaiting',
-            #                     :hold_time             => 'queue-holdtime',
-            #                     :minutes               => 'queue-minutes',
-            #                     :seconds               => 'queue-seconds',
-            #                     :thank_you             => 'queue-thankyou',
-            #                     :less_than             => 'queue-less-than',
-            #                     :report_hold           => 'queue-reporthold',
-            #                     :periodic_announcement => 'queue-periodic-announce'
-            #
-            # Note: the Hash values are the defaults. You only need to specify the ones you
-            # wish to override.
-            def sound_files(hash_of_files)
-              hash_of_files.each_pair do |key, value|
-                unless SOUND_FILE_SYMBOL_INTERPRETATIONS.has_key? key
-                  message = "Unrecogized sound file identifier #{key.inspect}. " +
-                        "Supported: " + SOUND_FILE_SYMBOL_INTERPRETATIONS.keys.map(&:inspect).to_sentence
-                  raise ArgumentError, message
-                end
-                @sound_files[SOUND_FILE_SYMBOL_INTERPRETATIONS[key]] = value
-              end
-            end
-
-            def member(driver)
-              members << (driver.kind_of?(String) && driver =~ %r'/' ? driver : "Agent/#{driver}")
-            end
-
-          end
-
-        end
-      end
-    end
-  end
-end