adhearsion-asterisk 0.1.0

data/lib/adhearsion/asterisk/config_generator/queues.rb

@@ -0,0 +1,247 @@
+require File.join(File.dirname(__FILE__), '../config_generator')
+
+module Adhearsion
+  module Asterisk
+    class ConfigGenerator
+      # 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 < ConfigGenerator
+
+        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
+          ConfigGenerator.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 < ConfigGenerator
+
+          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

data/lib/adhearsion/asterisk/config_generator/voicemail.rb

@@ -0,0 +1,238 @@
+require File.join(File.dirname(__FILE__), '../config_generator')
+
+module Adhearsion
+  module Asterisk
+    class ConfigGenerator
+      class Voicemail < ConfigGenerator
+
+        DEFAULT_GENERAL_SECTION = {
+          :format => :wav
+        }
+
+        # Don't worry. These will be overridable soon.
+        STATIC_ZONEMESSAGES_CONTEXT = <<-ZONEMESSAGES.strip_heredoc
+          [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
+        ZONEMESSAGES
+
+        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_]+$/
+
+          ContextDefinition.new(name).tap 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 : {}
+          ConfigGenerator.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 < ConfigGenerator
+
+          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)
+            MailboxDefinition.new.tap 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 < ConfigGenerator
+          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 < ConfigGenerator
+
+          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