rene-adhearsion 0.8.6

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

@@ -0,0 +1,140 @@
+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

@@ -0,0 +1,101 @@
+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.
+                grep(/^\s*[^;\s]/).   # Grep lines that aren't commented out
+                join.                 # 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

@@ -0,0 +1,250 @@
+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