plivo 0.3.19 → 4.20.0

data/lib/plivo/xml/multipartycall.rb

@@ -0,0 +1,188 @@
+module Plivo
+  module XML
+    class MultiPartyCall < Element
+      @nestables = []
+      @valid_attributes = %w[role maxDuration maxParticipants waitMusicUrl
+                             waitMusicMethod agentHoldMusicUrl agentHoldMusicMethod
+                             customerHoldMusicUrl customerHoldMusicMethod record
+                             recordFileFormat recordingCallbackUrl recordingCallbackMethod
+                             statusCallbackEvents statusCallbackUrl statusCallbackMethod
+                             stayAlone coachMode mute hold startMpcOnEnter endMpcOnExit
+                             enterSound enterSoundMethod exitSound exitSoundMethod
+                             onExitActionUrl onExitActionMethod relayDTMFInputs]
+
+      VALID_ROLE_VALUES = %w[agent supervisor customer]
+      VALID_METHOD_VALUES = %w[GET POST]
+      VALID_BOOL_VALUES = [true, false]
+      VALID_RECORD_FILE_FORMAT_VALUES = %w[mp3 wav]
+
+      def initialize(body, attributes = {})
+        if attributes[:role] && !VALID_ROLE_VALUES.include?(attributes[:role].downcase)
+          raise PlivoXMLError, "invalid attribute value #{attributes[:role]} for role"
+        elsif !attributes[:role]
+          raise PlivoXMLError, "role not mentioned : possible values - Agent / Supervisor / Customer"
+        end
+
+        if attributes[:maxDuration] && (attributes[:maxDuration]<300 || attributes[:maxDuration]>28800)
+          raise PlivoXMLError, "invalid attribute value #{attributes[:maxDuration]} for maxDuration"
+        elsif !attributes[:maxDuration]
+          attributes[:maxDuration] = 14400
+        end
+
+        if attributes[:maxParticipants] && (attributes[:maxParticipants]<2 || attributes[:maxParticipants]>10)
+          raise PlivoXMLError, "invalid attribute value #{attributes[:maxParticipants]} for maxParticipants"
+        elsif !attributes[:maxParticipants]
+          attributes[:maxParticipants] = 10
+        end
+
+        if attributes[:waitMusicMethod] && !VALID_METHOD_VALUES.include?(attributes[:waitMusicMethod].upcase)
+          raise PlivoXMLError, "invalid attribute value #{attributes[:waitMusicMethod]} for waitMusicMethod"
+        elsif !attributes[:waitMusicMethod]
+          attributes[:waitMusicMethod] = 'GET'
+        end
+
+        if attributes[:agentHoldMusicMethod] && !VALID_METHOD_VALUES.include?(attributes[:agentHoldMusicMethod].upcase)
+          raise PlivoXMLError, "invalid attribute value #{attributes[:agentHoldMusicMethod]} for agentHoldMusicMethod"
+        elsif !attributes[:agentHoldMusicMethod]
+          attributes[:agentHoldMusicMethod] = 'GET'
+        end
+
+        if attributes[:customerHoldMusicMethod] && !VALID_METHOD_VALUES.include?(attributes[:customerHoldMusicMethod].upcase)
+          raise PlivoXMLError, "invalid attribute value #{attributes[:customerHoldMusicMethod]} for customerHoldMusicMethod"
+        elsif !attributes[:customerHoldMusicMethod]
+          attributes[:customerHoldMusicMethod] = 'GET'
+        end
+
+        if attributes[:record] && !VALID_BOOL_VALUES.include?(attributes[:record])
+          raise PlivoXMLError, "invalid attribute value #{attributes[:record]} for record"
+        elsif !attributes[:record]
+          attributes[:record] = false
+        end
+
+        if attributes[:recordFileFormat] && !VALID_RECORD_FILE_FORMAT_VALUES.include?(attributes[:recordFileFormat])
+          raise PlivoXMLError, "invalid attribute value #{attributes[:recordFileFormat]} for recordFileFormat"
+        elsif !attributes[:recordFileFormat]
+          attributes[:recordFileFormat] = 'mp3'
+        end
+
+        if attributes[:recordingCallbackMethod] && !VALID_METHOD_VALUES.include?(attributes[:recordingCallbackMethod].upcase)
+          raise PlivoXMLError, "invalid attribute value #{attributes[:recordingCallbackMethod]} for recordingCallbackMethod"
+        elsif !attributes[:recordingCallbackMethod]
+          attributes[:recordingCallbackMethod] = 'GET'
+        end
+
+        if attributes[:statusCallbackEvents] && !multi_valid_param?(:statusCallbackEvents, attributes[:statusCallbackEvents], String, false, %w[mpc-state-changes participant-state-changes participant-speak-events participant-digit-input-events add-participant-api-events], true, ',') == true
+          raise PlivoXMLError, "invalid attribute value #{attributes[:statusCallbackEvents]} for statusCallbackEvents"
+        elsif !attributes[:statusCallbackEvents]
+          attributes[:statusCallbackEvents] = 'mpc-state-changes,participant-state-changes'
+        end
+
+        if attributes[:statusCallbackMethod] && !VALID_METHOD_VALUES.include?(attributes[:statusCallbackMethod].upcase)
+          raise PlivoXMLError, "invalid attribute value #{attributes[:statusCallbackMethod]} for statusCallbackMethod"
+        elsif !attributes[:statusCallbackMethod]
+          attributes[:statusCallbackMethod] = 'POST'
+        end
+
+        if attributes[:stayAlone] && !VALID_BOOL_VALUES.include?(attributes[:stayAlone])
+          raise PlivoXMLError, "invalid attribute value #{attributes[:stayAlone]} for stayAlone"
+        elsif !attributes[:stayAlone]
+          attributes[:stayAlone] = false
+        end
+
+        if attributes[:coachMode] && !VALID_BOOL_VALUES.include?(attributes[:coachMode])
+          raise PlivoXMLError, "invalid attribute value #{attributes[:coachMode]} for coachMode"
+        elsif !attributes[:coachMode]
+          attributes[:coachMode] = true
+        end
+
+        if attributes[:mute] && !VALID_BOOL_VALUES.include?(attributes[:mute])
+          raise PlivoXMLError, "invalid attribute value #{attributes[:mute]} for mute"
+        elsif !attributes[:mute]
+          attributes[:mute] = false
+        end
+
+        if attributes[:hold] && !VALID_BOOL_VALUES.include?(attributes[:hold])
+          raise PlivoXMLError, "invalid attribute value #{attributes[:hold]} for hold"
+        elsif !attributes[:hold]
+          attributes[:hold] = false
+        end
+
+        if attributes[:startMpcOnEnter] && !VALID_BOOL_VALUES.include?(attributes[:startMpcOnEnter])
+          raise PlivoXMLError, "invalid attribute value #{attributes[:startMpcOnEnter]} for startMpcOnEnter"
+        elsif !attributes[:startMpcOnEnter]
+          attributes[:startMpcOnEnter] = true
+        end
+
+        if attributes[:endMpcOnExit] && !VALID_BOOL_VALUES.include?(attributes[:endMpcOnExit])
+          raise PlivoXMLError, "invalid attribute value #{attributes[:endMpcOnExit]} for endMpcOnExit"
+        elsif !attributes[:endMpcOnExit]
+          attributes[:endMpcOnExit] = false
+        end
+
+        if attributes[:enterSound] && !is_one_among_string_url?(:enterSound, attributes[:enterSound], false, %w[beep:1 beep:2 none])
+          raise PlivoXMLError, "invalid attribute value #{attributes[:enterSound]} for enterSound"
+        elsif !attributes[:enterSound]
+          attributes[:enterSound] = 'beep:1'
+        end
+
+        if attributes[:enterSoundMethod] && !VALID_METHOD_VALUES.include?(attributes[:enterSoundMethod].upcase)
+          raise PlivoXMLError, "invalid attribute value #{attributes[:enterSoundMethod]} for enterSoundMethod"
+        elsif !attributes[:enterSoundMethod]
+          attributes[:enterSoundMethod] = 'GET'
+        end
+
+        if attributes[:exitSound] && !is_one_among_string_url?(:exitSound, attributes[:exitSound], false, %w[beep:1 beep:2 none])
+          raise PlivoXMLError, "invalid attribute value #{attributes[:exitSound]} for exitSound"
+        elsif !attributes[:exitSound]
+          attributes[:exitSound] = 'beep:2'
+        end
+
+        if attributes[:exitSoundMethod] && !VALID_METHOD_VALUES.include?(attributes[:exitSoundMethod].upcase)
+          raise PlivoXMLError, "invalid attribute value #{attributes[:exitSoundMethod]} for exitSoundMethod"
+        elsif !attributes[:exitSoundMethod]
+          attributes[:exitSoundMethod] = 'GET'
+        end
+
+        if attributes[:onExitActionMethod] && !VALID_METHOD_VALUES.include?(attributes[:onExitActionMethod].upcase)
+          raise PlivoXMLError, "invalid attribute value #{attributes[:onExitActionMethod]} for onExitActionMethod"
+        elsif !attributes[:onExitActionMethod]
+          attributes[:onExitActionMethod] = 'POST'
+        end
+
+        if attributes[:relayDTMFInputs] && !VALID_BOOL_VALUES.include?(attributes[:relayDTMFInputs])
+          raise PlivoXMLError, "invalid attribute value #{attributes[:relayDTMFInputs]} for relayDTMFInputs"
+        elsif !attributes[:relayDTMFInputs]
+          attributes[:relayDTMFInputs] = false
+        end
+
+        if attributes[:waitMusicUrl] && !valid_url?(:waitMusicUrl, attributes[:waitMusicUrl], false)
+          raise PlivoXMLError, "invalid attribute value #{attributes[:waitMusicUrl]} for waitMusicUrl"
+        end
+
+        if attributes[:agentHoldMusicUrl] && !valid_url?(:agentHoldMusicUrl, attributes[:agentHoldMusicUrl], false)
+          raise PlivoXMLError, "invalid attribute value #{attributes[:agentHoldMusicUrl]} for agentHoldMusicUrl"
+        end
+
+        if attributes[:customerHoldMusicUrl] && !valid_url?(:customerHoldMusicUrl, attributes[:customerHoldMusicUrl], false)
+          raise PlivoXMLError, "invalid attribute value #{attributes[:customerHoldMusicUrl]} for customerHoldMusicUrl"
+        end
+
+        if attributes[:recordingCallbackUrl] && !valid_url?(:recordingCallbackUrl, attributes[:recordingCallbackUrl], false)
+          raise PlivoXMLError, "invalid attribute value #{attributes[:recordingCallbackUrl]} for recordingCallbackUrl"
+        end
+
+        if attributes[:statusCallbackUrl] && !valid_url?(:statusCallbackUrl, attributes[:statusCallbackUrl], false)
+          raise PlivoXMLError, "invalid attribute value #{attributes[:statusCallbackUrl]} for statusCallbackUrl"
+        end
+
+        if attributes[:customerHoldMusicUrl] && !valid_url?(:customerHoldMusicUrl, attributes[:customerHoldMusicUrl], false)
+          raise PlivoXMLError, "invalid attribute value #{attributes[:customerHoldMusicUrl]} for customerHoldMusicUrl"
+        end
+
+        raise PlivoXMLError, 'No MPC name set for the MPC' unless body
+        super(body, attributes)
+      end
+
+    end
+  end
+end

data/lib/plivo/xml/number.rb

@@ -0,0 +1,13 @@
+module Plivo
+  module XML
+    class Number < Element
+      @nestables = []
+      @valid_attributes = %w[sendDigits sendOnPreanswer]
+
+      def initialize(body, attributes = {})
+        raise PlivoXMLError, 'No number set for Number' unless body
+        super(body, attributes)
+      end
+    end
+  end
+end

data/lib/plivo/xml/p.rb

@@ -0,0 +1,12 @@
+module Plivo
+  module XML
+    class P < Element
+      @nestables = %w(Break Cont Emphasis Lang Phoneme Prosody SayAs Sub S W)
+      @valid_attributes = []
+
+      def initialize(body)
+        super(body)
+      end
+    end
+  end
+end

data/lib/plivo/xml/phoneme.rb

@@ -0,0 +1,20 @@
+module Plivo
+  module XML
+    class Phoneme < Element
+      @nestables = []
+      @valid_attributes = %w(alphabet ph)
+
+      VALID_ALPHABET_ATTRIBUTE_VALUES=%w(ipa x-sampa x-amazon-pinyin)
+
+      def initialize(body, attributes = {})
+        unless attributes && attributes[:ph]
+          raise PlivoXMLError, 'ph attribute is required for Phoneme'
+        end
+        if attributes && attributes[:alphabet] && !VALID_ALPHABET_ATTRIBUTE_VALUES.include?(attributes[:alphabet])
+          raise PlivoXMLError, "invalid attribute value #{attributes[:alphabet]} for alphabet"
+        end
+        super(body, attributes)
+      end
+    end
+  end
+end

data/lib/plivo/xml/play.rb

@@ -0,0 +1,13 @@
+module Plivo
+  module XML
+    class Play < Element
+      @nestables = []
+      @valid_attributes = %w[loop]
+
+      def initialize(body, attributes = {})
+        raise PlivoXMLError 'No url set for Play' unless body
+        super(body, attributes)
+      end
+    end
+  end
+end

data/lib/plivo/xml/plivo_xml.rb

@@ -0,0 +1,19 @@
+module Plivo
+  module XML
+    class PlivoXML
+      attr_accessor :response
+
+      def initialize(response = nil)
+        response.nil? ? @response = Plivo::XML::Response.new : @response = response
+      end
+
+      def to_xml
+        '<?xml version="1.0" encoding="utf-8" ?>' + @response.to_xml
+      end
+
+      def to_s
+        '<?xml version="1.0" encoding="utf-8" ?>' + @response.to_s
+      end
+    end
+  end
+end

data/lib/plivo/xml/pre_answer.rb

@@ -0,0 +1,12 @@
+module Plivo
+  module XML
+    class PreAnswer < Element
+      @nestables = %w[Play Speak GetDigits Wait Redirect Message DTMF]
+      @valid_attributes = []
+
+      def initialize(attributes = {}, &block)
+        super(nil, attributes, &block)
+      end
+    end
+  end
+end

data/lib/plivo/xml/prosody.rb

@@ -0,0 +1,28 @@
+module Plivo
+  module XML
+    class Prosody < Element
+      @nestables = %w(Break Cont Emphasis Lang P Phoneme Prosody S SayAs Sub W)
+      @valid_attributes = %w(volume rate pitch)
+
+      VALID_VOLUME_ATTRIBUTE_VALUES=%w(default silent x-soft soft medium loud x-loud)
+      VALID_RATE_ATTRIBUTE_VALUES=%w(x-slow slow medium fast x-fast)
+      VALID_PITCH_ATTRIBUTE_VALUES=%w(default x-low low medium high x-high)
+
+      def initialize(body, attributes = {})
+        if attributes.nil? || attributes.length == 0
+          raise PlivoXMLError, 'Specify at least one attribute for Prosody tag'
+        end
+        if attributes[:volume] && !VALID_VOLUME_ATTRIBUTE_VALUES.include?(attributes[:volume]) && !attributes[:volume].include?('dB')
+          raise PlivoXMLError, "invalid attribute value #{attributes[:volume]} for volume"
+        end
+        if attributes[:rate] && !VALID_RATE_ATTRIBUTE_VALUES.include?(attributes[:rate]) && (!attributes[:rate].include?('%') || attributes[:rate].split('%')[0].to_i < 0)
+          raise PlivoXMLError, "invalid attribute value #{attributes[:rate]} for rate"
+        end
+        if attributes[:pitch] && !VALID_PITCH_ATTRIBUTE_VALUES.include?(attributes[:pitch]) && !attributes[:pitch].include?('%')
+          raise PlivoXMLError, "invalid attribute value #{attributes[:pitch]} for pitch"
+        end
+        super(body, attributes)
+      end
+    end
+  end
+end

data/lib/plivo/xml/record.rb

@@ -0,0 +1,17 @@
+module Plivo
+  module XML
+    class Record < Element
+      @nestables = []
+      @valid_attributes = %w[action method timeout finishOnKey
+                             maxLength playBeep recordSession
+                             startOnDialAnswer redirect fileFormat
+                             callbackUrl callbackMethod
+                             transcriptionType transcriptionUrl
+                             transcriptionMethod]
+
+      def initialize(attributes = {})
+        super(nil, attributes)
+      end
+    end
+  end
+end

data/lib/plivo/xml/redirect.rb

@@ -0,0 +1,13 @@
+module Plivo
+  module XML
+    class Redirect < Element
+      @nestables = []
+      @valid_attributes = ['method']
+
+      def initialize(body, attributes = {})
+        raise PlivoError 'No url set for Redirect' unless body
+        super(body, attributes)
+      end
+    end
+  end
+end

data/lib/plivo/xml/response.rb

@@ -0,0 +1,21 @@
+module Plivo
+  module XML
+    class Response < Element
+      @nestables = %w[Speak Play GetDigits GetInput Record Dial Message
+                      Redirect Wait Hangup PreAnswer Conference DTMF MultiPartyCall]
+      @valid_attributes = []
+
+      def initialize
+        super(nil, {})
+      end
+
+      def to_xml
+        super()
+      end
+
+      def to_s
+        super()
+      end
+    end
+  end
+end

data/lib/plivo/xml/s.rb

@@ -0,0 +1,12 @@
+module Plivo
+  module XML
+    class S < Element
+      @nestables = %w(Break Cont Emphasis Lang Phoneme Prosody SayAs Sub W)
+      @valid_attributes = []
+
+      def initialize(body)
+        super(body)
+      end
+    end
+  end
+end

data/lib/plivo/xml/say_as.rb

@@ -0,0 +1,24 @@
+module Plivo
+  module XML
+    class SayAs < Element
+      @nestables = []
+      @valid_attributes = %w(interpret-as format)
+
+      VALID_INTERPRET_AS_ATTRIBUTE_VALUES=%w(characters spell-out cardinal number ordinal digits fraction unit date time address expletive telephone)
+      VALID_FORMAT_ATTRIBUTE_VALUES=%w(mdy dmy ymd md dm ym my d m y yyyymmdd)
+
+      def initialize(body, attributes = {})
+        unless attributes && attributes["interpret-as"]
+          raise PlivoXMLError, 'interpret-as is a required attribute for say-as element'
+        end
+        if !VALID_INTERPRET_AS_ATTRIBUTE_VALUES.include?(attributes["interpret-as"])
+          raise PlivoXMLError, "invalid attribute value #{attributes["interpret-as"]} for interpret-as"
+        end
+        if attributes["interpret-as"]=='date' && attributes[:format] && !VALID_FORMAT_ATTRIBUTE_VALUES.include?(attributes[:format])
+          raise PlivoXMLError, "invalid attribute value #{attributes[:format]} for format"
+        end
+        super(body, attributes)
+      end
+    end
+  end
+end

data/lib/plivo/xml/speak.rb

@@ -0,0 +1,28 @@
+module Plivo
+  module XML
+    class Speak < Element
+      @valid_attributes = %w[voice language loop]
+
+      SUPPORTED_ENGINES=%w(Polly)
+      SUPPORTED_VOICES=%w(Nicole Russell Vitoria Ricardo Chantal Naja Mads Lotte Ruben Lea Celine Mathieu Vicki Marlene Hans Aditi Dora Karl Raveena Aditi Carla Giorgio Mizuki Takumi Seoyeon Zhiyu Liv Ewa Maja Jacek Jan Ines Cristiano Carmen Tatyana Maxim Conchita Enrique Astrid Filiz Amy Emma Brian Joanna Matthew Salli Justin Kendra Joey Kimberly Ivy Penelope Miguel Gwyneth Geraint Zeina Mia)
+
+      def initialize(body, attributes = {})
+        if attributes.nil? || attributes[:voice].nil? || ['MAN', 'WOMAN'].include?(attributes[:voice])
+          @nestables = []
+        else
+          engine = attributes[:voice].split('.')[0]
+          voice = attributes[:voice].split('.')[1]
+          if SUPPORTED_ENGINES.include?(engine) && SUPPORTED_VOICES.include?(voice)
+            @nestables = %w(Break Cont Emphasis Lang P Phoneme Prosody S SayAs Sub W)
+          else
+            raise PlivoXMLError, "<Speak> voice #{attributes[:voice]} is not valid."
+          end
+        end
+        if !body
+          raise PlivoXMLError, 'No text set for Speak'
+        end
+        super(body, attributes, @nestables)
+      end
+    end
+  end
+end

data/lib/plivo/xml/sub.rb

@@ -0,0 +1,16 @@
+module Plivo
+  module XML
+    class Sub < Element
+      @nestables = []
+      @valid_attributes = %w(alias)
+
+      def initialize(body, attributes = {})
+        raise PlivoXMLError, 'No text set for sub element' unless body
+        unless attributes && attributes[:alias]
+          raise PlivoXMLError, 'alias is a required attribute for sub element'
+        end
+        super(body, attributes)
+      end
+    end
+  end
+end

data/lib/plivo/xml/user.rb

@@ -0,0 +1,13 @@
+module Plivo
+  module XML
+    class User < Element
+      @nestables = []
+      @valid_attributes = %w[sendDigits sendOnPreanswer sipHeaders]
+
+      def initialize(body, attributes = {})
+        raise PlivoXMLError, 'No user set for User' unless body
+        super(body, attributes)
+      end
+    end
+  end
+end

data/lib/plivo/xml/w.rb

@@ -0,0 +1,17 @@
+module Plivo
+  module XML
+    class W < Element
+      @nestables = %w(Break Cont Emphasis Phoneme Prosody SayAs Sub)
+      @valid_attributes = %w(role)
+
+      VALID_ROLE_ATTRIBUTE_VALUES=%w(amazon:VB amazon:VBD amazon:SENSE_1)
+
+      def initialize(body, attributes = {})
+        if attributes && attributes[:role] && !VALID_ROLE_ATTRIBUTE_VALUES.include?(attributes[:role])
+          raise PlivoXMLError, "invalid attribute value #{attributes[:role]} for role"
+        end
+        super(body, attributes)
+      end
+    end
+  end
+end

data/lib/plivo/xml/wait.rb

@@ -0,0 +1,12 @@
+module Plivo
+  module XML
+    class Wait < Element
+      @nestables = []
+      @valid_attributes = %w[length silence minSilence beep]
+
+      def initialize(attributes = {})
+        super(nil, attributes)
+      end
+    end
+  end
+end

data/lib/plivo/xml.rb

@@ -0,0 +1,39 @@
+require 'rexml/document'
+require 'htmlentities'
+
+require_relative 'xml/element'
+require_relative 'xml/response'
+require_relative 'xml/conference'
+require_relative 'xml/dial'
+require_relative 'xml/dtmf'
+require_relative 'xml/get_digits'
+require_relative 'xml/get_input'
+require_relative 'xml/hangup'
+require_relative 'xml/message'
+require_relative 'xml/number'
+require_relative 'xml/play'
+require_relative 'xml/pre_answer'
+require_relative 'xml/record'
+require_relative 'xml/redirect'
+require_relative 'xml/speak'
+require_relative 'xml/user'
+require_relative 'xml/wait'
+require_relative 'xml/break'
+require_relative 'xml/emphasis'
+require_relative 'xml/lang'
+require_relative 'xml/p'
+require_relative 'xml/phoneme'
+require_relative 'xml/prosody'
+require_relative 'xml/s'
+require_relative 'xml/say_as'
+require_relative 'xml/sub'
+require_relative 'xml/w'
+require_relative 'xml/plivo_xml'
+require_relative 'xml/multipartycall'
+require_relative 'xml/cont'
+include Plivo::Exceptions
+
+module Plivo
+  module XML
+  end
+end