vonage 7.2.1 → 7.4.1

data/lib/vonage/voice/actions/connect.rb

@@ -0,0 +1,199 @@
+# typed: true
+# frozen_string_literal: true
+require 'phonelib'
+
+module Vonage  
+  class Voice::Actions::Connect
+    attr_accessor :endpoint, :from, :eventType, :timeout, :limit, :machineDetection, :eventUrl, :eventMethod, :ringbackTone
+
+    def initialize(attributes = {})
+      @endpoint = attributes.fetch(:endpoint)
+      @from = attributes.fetch(:from, nil)
+      @eventType = attributes.fetch(:eventType, nil)
+      @timeout = attributes.fetch(:timeout, nil)
+      @limit = attributes.fetch(:limit, nil)
+      @machineDetection = attributes.fetch(:machineDetection, nil)
+      @eventUrl = attributes.fetch(:eventUrl, nil)
+      @eventMethod = attributes.fetch(:eventMethod, nil)
+      @ringbackTone = attributes.fetch(:ringbackTone, nil)
+
+      after_initialize!
+    end
+
+    def after_initialize!
+      verify_endpoint
+
+      if self.from
+        verify_from
+      end
+
+      if self.eventType
+        verify_event_type
+      end
+
+      if self.limit
+        verify_limit
+      end
+
+      if self.machineDetection
+        verify_machine_detection
+      end
+
+      if self.eventUrl
+        verify_event_url
+      end
+
+      if self.eventMethod
+        verify_event_method
+      end
+
+      if self.ringbackTone
+        verify_ringback_tone
+      end
+    end
+
+    def verify_endpoint
+      case self.endpoint[:type]
+      when 'phone'
+        raise ClientError.new("Expected 'number' value to be in E.164 format") unless Phonelib.parse(endpoint[:number].to_i).valid?
+      when 'app'
+        raise ClientError.new("'user' must be defined") unless endpoint[:user]
+      when 'websocket'
+        raise ClientError.new("Expected 'uri' value to be a valid URI") unless URI.parse(endpoint[:uri]).kind_of?(URI::Generic)
+        raise ClientError.new("Expected 'content-type' parameter to be either 'audio/116;rate=16000' or 'audio/116;rate=8000") unless endpoint[:'content-type'] == 'audio/116;rate=16000' || endpoint[:'content-type'] == 'audio/116;rate=8000'
+      when 'sip'
+        raise ClientError.new("Expected 'uri' value to be a valid URI") unless URI.parse(endpoint[:uri]).kind_of?(URI::Generic)
+      end
+    end
+
+    def verify_from
+      raise ClientError.new("Invalid 'from' value, must be in E.164 format") unless Phonelib.parse(self.from.to_i).valid?
+    end
+
+    def verify_event_type
+      raise ClientError.new("Invalid 'eventType' value, must be 'synchronous' if defined") unless self.eventType == 'synchronous'
+    end
+
+    def verify_limit
+      raise ClientError.new("Invalid 'limit' value, must be between 0 and 7200 seconds") unless self.limit.to_i >= 0 && self.limit.to_i <= 7200
+    end
+
+    def verify_machine_detection
+      raise ClientError.new("Invalid 'machineDetection' value, must be either: 'continue' or 'hangup' if defined") unless self.machineDetection == 'continue' || self.machineDetection == 'hangup'
+    end
+
+    def verify_event_url
+      uri = URI.parse(self.eventUrl)
+
+      raise ClientError.new("Invalid 'eventUrl' value, must be a valid URL") unless uri.kind_of?(URI::HTTP) || uri.kind_of?(URI::HTTPS)
+
+      self.eventUrl
+    end
+
+    def verify_event_method
+      valid_methods = ['GET', 'POST']
+
+      raise ClientError.new("Invalid 'eventMethod' value. must be either: 'GET' or 'POST'") unless valid_methods.include?(self.eventMethod.upcase)
+    end
+
+    def verify_ringback_tone
+      uri = URI.parse(self.ringbackTone)
+
+      raise ClientError.new("Invalid 'ringbackTone' value, must be a valid URL") unless uri.kind_of?(URI::HTTP) || uri.kind_of?(URI::HTTPS)
+
+      self.ringbackTone
+    end
+
+    def action
+      create_connect!(self)
+    end
+
+    def create_connect!(builder)
+      ncco = [
+        {
+          action: 'connect',
+          endpoint: [
+            create_endpoint(builder)
+          ]
+        }
+      ]
+
+      ncco[0].merge!(from: builder.from) if builder.from
+      ncco[0].merge!(eventType: builder.eventType) if builder.eventType
+      ncco[0].merge!(timeout: builder.timeout) if builder.timeout
+      ncco[0].merge!(limit: builder.limit) if builder.limit
+      ncco[0].merge!(machineDetection: builder.machineDetection) if builder.machineDetection
+      ncco[0].merge!(eventUrl: builder.eventUrl) if builder.eventUrl
+      ncco[0].merge!(eventMethod: builder.eventMethod) if builder.eventMethod
+      ncco[0].merge!(ringbackTone: builder.ringbackTone) if builder.ringbackTone
+
+      ncco
+    end
+
+    def create_endpoint(builder)
+      case builder.endpoint[:type]
+      when 'phone'
+        phone_endpoint(builder.endpoint)
+      when 'app'
+        app_endpoint(builder.endpoint)
+      when 'websocket'
+        websocket_endpoint(builder.endpoint)
+      when 'sip'
+        sip_endpoint(builder.endpoint)
+      when 'vbc'
+        vbc_endpoint(builder.endpoint)
+      else
+        raise ClientError.new("Invalid value for 'endpoint', please refer to the Vonage API Developer Portal https://developer.nexmo.com/voice/voice-api/ncco-reference#endpoint-types-and-values for a list of possible values")
+      end
+    end
+
+    def phone_endpoint(endpoint_attrs)
+      hash = {
+        type: 'phone',
+        number: endpoint_attrs[:number]
+      }
+
+      hash.merge!(dtmfAnswer: endpoint_attrs[:dtmfAnswer]) if endpoint_attrs[:dtmfAnswer]
+      hash.merge!(onAnswer: endpoint_attrs[:onAnswer]) if endpoint_attrs[:onAnswer]
+
+      hash
+    end
+
+    def app_endpoint(endpoint_attrs)
+      {
+        type: 'app',
+        user: endpoint_attrs[:user]
+      }
+    end
+
+    def websocket_endpoint(endpoint_attrs)
+      hash = {
+        type: 'websocket',
+        uri: endpoint_attrs[:uri],
+        :'content-type' => endpoint_attrs[:'content-type']
+      }
+
+      hash.merge!(headers: endpoint_attrs[:headers]) if endpoint_attrs[:headers]
+
+      hash
+    end
+
+    def sip_endpoint(endpoint_attrs)
+      hash = {
+        type: 'sip',
+        uri: endpoint_attrs[:uri]
+      }
+
+      hash.merge!(headers: endpoint_attrs[:headers]) if endpoint_attrs[:headers]
+
+      hash
+    end
+
+    def vbc_endpoint(endpoint_attrs)
+      {
+        type: 'vbc',
+        extension: endpoint_attrs[:extension]
+      }
+    end
+  end
+end

data/lib/vonage/voice/actions/conversation.rb

@@ -0,0 +1,107 @@
+# typed: true
+# frozen_string_literal: true
+ 
+ module Vonage 
+  class Voice::Actions::Conversation
+    attr_accessor :name, :musicOnHoldUrl, :startOnEnter, :endOnExit, :record, :canSpeak, :canHear, :mute
+
+    def initialize(attributes = {})
+      @name = attributes.fetch(:name)
+      @musicOnHoldUrl = attributes.fetch(:musicOnHoldUrl, nil)
+      @startOnEnter = attributes.fetch(:startOnEnter, nil)
+      @endOnExit = attributes.fetch(:endOnExit, nil)
+      @record = attributes.fetch(:record, nil)
+      @canSpeak = attributes.fetch(:canSpeak, nil)
+      @canHear = attributes.fetch(:canHear, nil)
+      @mute = attributes.fetch(:mute, nil)
+
+      after_initialize!
+    end
+
+    def after_initialize!
+      if self.musicOnHoldUrl
+        verify_music_on_hold_url
+      end
+
+      if self.startOnEnter
+        verify_start_on_enter
+      end
+
+      if self.endOnExit
+        verify_end_on_exit
+      end
+
+      if self.record
+        verify_record
+      end
+
+      if self.canSpeak
+        verify_can_speak
+      end
+
+      if self.canHear
+        verify_can_hear
+      end
+
+      if self.mute
+        verify_mute
+      end
+    end
+
+    def verify_music_on_hold_url
+      uri = URI.parse(self.musicOnHoldUrl)
+
+      raise ClientError.new("Invalid 'musicOnHoldUrl' value, must be a valid URL") unless uri.kind_of?(URI::HTTP) || uri.kind_of?(URI::HTTPS)
+
+      self.musicOnHoldUrl
+    end
+
+    def verify_start_on_enter
+      raise ClientError.new("Expected 'startOnEnter' value to be a Boolean") unless self.startOnEnter == true || self.startOnEnter == false
+    end
+
+    def verify_end_on_exit
+      raise ClientError.new("Expected 'endOnExit' value to be a Boolean") unless self.endOnExit == true || self.endOnExit == false
+    end
+
+    def verify_record
+      raise ClientError.new("Expected 'record' value to be a Boolean") unless self.record == true || self.record == false
+    end
+
+    def verify_can_speak
+      raise ClientError.new("Expected 'canSpeak' value to be an Array of leg UUIDs") unless self.canSpeak.is_a?(Array)
+    end
+
+    def verify_can_hear
+      raise ClientError.new("Expected 'canHear' value to be an Array of leg UUIDs") unless self.canHear.is_a?(Array)
+    end
+
+    def verify_mute
+      raise ClientError.new("Expected 'mute' value to be a Boolean") unless self.mute == true || self.mute == false
+      raise ClientError.new("The 'mute' value is not supported if the 'canSpeak' option is defined") if self.canSpeak
+    end
+
+    def action
+      create_conversation!(self)
+    end
+
+    def create_conversation!(builder)
+      ncco = [
+        {
+          action: 'conversation',
+          name: builder.name
+        }
+      ]
+
+      ncco[0].merge!(musicOnHoldUrl: builder.musicOnHoldUrl) if (builder.musicOnHoldUrl || builder.musicOnHoldUrl == false)
+      ncco[0].merge!(startOnEnter: builder.startOnEnter) if (builder.startOnEnter || builder.startOnEnter == false)
+      ncco[0].merge!(endOnExit: builder.endOnExit) if (builder.endOnExit || builder.endOnExit == false)
+      ncco[0].merge!(record: builder.record) if builder.record
+      ncco[0].merge!(canSpeak: builder.canSpeak) if builder.canSpeak
+      ncco[0].merge!(canHear: builder.canHear) if builder.canHear
+      ncco[0].merge!(mute: builder.mute) if builder.mute
+
+      ncco
+    end
+  end
+end

data/lib/vonage/voice/actions/input.rb

@@ -0,0 +1,119 @@
+# typed: true
+# frozen_string_literal: true
+
+module Vonage
+  class Voice::Actions::Input
+    attr_accessor :type, :dtmf, :speech, :eventUrl, :eventMethod
+
+    def initialize(attributes = {})
+      @type = attributes.fetch(:type)
+      @dtmf = attributes.fetch(:dtmf, nil)
+      @speech = attributes.fetch(:speech, nil)
+      @eventUrl = attributes.fetch(:eventUrl, nil)
+      @eventMethod = attributes.fetch(:eventMethod, nil)
+
+      after_initialize!
+    end
+
+    def after_initialize!
+      validate_type
+
+      if self.dtmf
+        validate_dtmf
+      end
+
+      if self.speech
+        validate_speech
+      end
+
+      if self.eventUrl
+        validate_event_url
+      end
+
+      if self.eventMethod
+        validate_event_method
+      end
+    end
+
+    def validate_type
+      valid_types = ['dtmf', 'speech']
+
+      raise ClientError.new("Invalid 'type', must be an Array of at least one String") unless self.type.is_a?(Array)
+      raise ClientError.new("Invalid 'type' value, must be 'dtmf', 'speech' or both 'dtmf' and 'speech'") if (valid_types & self.type).empty?
+    end
+
+    def validate_dtmf
+      raise ClientError.new("Expected 'dtmf' to be included in 'type' parameter if 'dtmf' options specified") unless self.type.include?('dtmf')
+
+      if self.dtmf[:timeOut]
+        raise ClientError.new("Expected 'timeOut' to not be more than 10 seconds") if self.dtmf[:timeOut] > 10
+      end
+
+      if self.dtmf[:maxDigits]
+        raise ClientError.new("Expected 'maxDigits' to not be more than 22") if self.dtmf[:maxDigits] > 22
+      end
+
+      if self.dtmf[:submitOnHash]
+        raise ClientError.new("Invalid 'submitOnHash' value, must be a Boolean") unless self.dtmf[:submitOnHash] == true || self.dtmf[:submitOnHash] == false
+      end
+    end
+
+    def validate_speech
+      raise ClientError.new("Expected 'speech' to be included in 'type' parameter if 'speech' options specified") unless self.type.include?('speech')
+
+      if self.speech[:uuid]
+        raise ClientError.new("Invalid 'uuid' value, must be an Array containing a single call leg ID element") unless self.speech[:uuid].is_a?(Array)
+      end
+
+      if self.speech[:endOnSilence]
+        raise ClientError.new("Expected 'endOnSilence' to not be more than 10 seconds") unless self.speech[:endOnSilence] <= 10 && self.speech[:endOnSilence] >= 0
+      end
+
+      if self.speech[:context]
+        raise ClientError.new("Expected 'context' to be an Array of strings") unless self.speech[:context].is_a?(Array)
+      end
+
+      if self.speech[:startTimeout]
+        raise ClientError.new("Expected 'startTimeout' to not be more than 10 seconds") unless self.speech[:startTimeout] <= 10 && self.speech[:startTimeout] >= 0
+      end
+
+      if self.speech[:maxDuration]
+        raise ClientError.new("Expected 'maxDuration' to not be more than 60 seconds") unless self.speech[:maxDuration] <= 60 && self.speech[:maxDuration] >= 0
+      end
+    end
+
+    def validate_event_url
+      uri = URI.parse(self.eventUrl)
+
+      raise ClientError.new("Invalid 'eventUrl' value, must be a valid URL") unless uri.kind_of?(URI::HTTP) || uri.kind_of?(URI::HTTPS)
+
+      self.eventUrl
+    end
+
+    def validate_event_method
+      valid_methods = ['GET', 'POST']
+
+      raise ClientError.new("Invalid 'eventMethod' value. must be either: 'GET' or 'POST'") unless valid_methods.include?(self.eventMethod.upcase)
+    end
+
+    def action
+      create_input!(self)
+    end
+
+    def create_input!(builder)
+      ncco = [
+        {
+          action: 'input',
+          type: builder.type
+        }
+      ]
+
+      ncco[0].merge!(dtmf: builder.dtmf) if builder.dtmf
+      ncco[0].merge!(speech: builder.speech) if builder.speech
+      ncco[0].merge!(eventUrl: builder.eventUrl) if builder.eventUrl
+      ncco[0].merge!(eventMethod: builder.eventMethod) if builder.eventMethod
+
+      ncco
+    end
+  end
+end

data/lib/vonage/voice/actions/notify.rb

@@ -0,0 +1,57 @@
+# typed: true
+# frozen_string_literal: true
+
+module Vonage
+  class Voice::Actions::Notify
+    attr_accessor :payload, :eventUrl, :eventMethod
+
+    def initialize(attributes = {})
+      @payload = attributes.fetch(:payload)
+      @eventUrl = attributes.fetch(:eventUrl)
+      @eventMethod = attributes.fetch(:eventMethod, nil)
+
+      after_initialize!
+    end
+
+    def after_initialize!
+      validate_event_url
+
+      if self.eventMethod
+        validate_event_method
+      end
+    end
+
+    def validate_event_url
+      uri = URI.parse(self.eventUrl[0])
+
+      raise ClientError.new("Expected 'eventUrl' value to be an Array with a single string") unless self.eventUrl.is_a?(Array)
+      raise ClientError.new("Invalid 'eventUrl' value, must be a valid URL") unless uri.kind_of?(URI::HTTP) || uri.kind_of?(URI::HTTPS)
+
+      self.eventUrl
+    end
+
+    def validate_event_method
+      valid_methods = ['GET', 'POST']
+
+      raise ClientError.new("Invalid 'eventMethod' value. must be either: 'GET' or 'POST'") unless valid_methods.include?(self.eventMethod.upcase)
+    end
+
+    def action
+      create_notify!(self)
+    end
+
+    def create_notify!(builder)
+      ncco = [
+        {
+          action: 'notify',
+          payload: builder.payload,
+          eventUrl: builder.eventUrl
+        }
+      ]
+
+      ncco[0].merge!(eventMethod: builder.eventMethod) if builder.eventMethod
+
+      ncco
+    end
+  end
+end

data/lib/vonage/voice/actions/record.rb

@@ -0,0 +1,130 @@
+# typed: true
+# frozen_string_literal: true
+
+module Vonage
+  class Voice::Actions::Record
+    attr_accessor :format, :split, :channels, :endOnSilence, :endOnKey, :timeOut, :beepStart, :eventUrl, :eventMethod
+
+    def initialize(attributes = {})
+      @format = attributes.fetch(:format, nil)
+      @split = attributes.fetch(:split, nil)
+      @channels = attributes.fetch(:channels, nil)
+      @endOnSilence = attributes.fetch(:endOnSilence, nil)
+      @endOnKey = attributes.fetch(:endOnKey, nil)
+      @timeOut = attributes.fetch(:timeOut, nil)
+      @beepStart = attributes.fetch(:beepStart, nil)
+      @eventUrl = attributes.fetch(:eventUrl, nil)
+      @eventMethod = attributes.fetch(:eventMethod, nil)
+
+      after_initialize!
+    end
+
+    def after_initialize!
+      if self.format
+        validate_format
+      end
+
+      if self.split
+        validate_split
+      end
+
+      if self.channels
+        validate_channels
+      end
+
+      if self.endOnSilence
+        validate_end_on_silence
+      end
+
+      if self.endOnKey
+        validate_end_on_key
+      end
+
+      if self.timeOut
+        validate_time_out
+      end
+
+      if self.beepStart
+        validate_beep_start
+      end
+
+      if self.eventUrl
+        validate_event_url
+      end
+
+      if self.eventMethod
+        validate_event_method
+      end
+    end
+
+    def validate_format
+      valid_formats = ['mp3', 'wav', 'ogg']
+
+      raise ClientError.new("Invalid format, must be one of: 'mp3', 'wav', 'ogg'") unless valid_formats.include?(self.format)
+    end
+
+    def validate_split
+      raise ClientError.new("Expected 'split' value to be 'conversation' if defined") unless self.split == 'conversation'
+    end
+
+    def validate_channels
+      raise ClientError.new("The 'split' parameter must be defined to 'conversation' to also define 'channels'") unless self.split
+
+      raise ClientError.new("Expected 'split' parameter to be equal to or less than 32") unless self.channels <= 32
+    end
+
+    def validate_end_on_silence
+      raise ClientError.new("Expected 'endOnSilence' value to be between 3 and 10") unless self.endOnSilence <= 10 && self.endOnSilence >= 3
+    end
+
+    def validate_end_on_key
+      raise ClientError.new("Expected 'endOnKey' value to be a one of the following: a single digit between 1-9, '*' or '#'") unless self.endOnKey.match(/^(\*|[1-9]|\#)$/)
+    end
+
+    def validate_time_out
+      raise ClientError.new("Expected 'timeOut' value to be between 3 and 7200 seconds") unless self.timeOut <= 7200 && self.timeOut >= 3
+    end
+
+    def validate_beep_start
+      raise ClientError.new("Expected 'beepStart' value to be a Boolean") unless self.beepStart == true || self.beepStart == false
+    end
+
+    def validate_event_url
+      uri = URI.parse(self.eventUrl)
+
+      raise ClientError.new("Invalid 'eventUrl' value, must be a valid URL") unless uri.kind_of?(URI::HTTP) || uri.kind_of?(URI::HTTPS)
+
+      self.eventUrl
+    end
+
+    def validate_event_method
+      valid_methods = ['GET', 'POST']
+
+      raise ClientError.new("Invalid 'eventMethod' value. must be either: 'GET' or 'POST'") unless valid_methods.include?(self.eventMethod.upcase)
+    end
+
+    def action
+      create_record!(self)
+    end
+
+    def create_record!(builder)
+      ncco = [
+        {
+          action: 'record'
+        }
+      ]
+
+      ncco[0].merge!(format: builder.format) if builder.format
+      ncco[0].merge!(split: builder.split) if builder.split
+      ncco[0].merge!(channels: builder.channels) if builder.channels
+      ncco[0].merge!(endOnSilence: builder.endOnSilence) if builder.endOnSilence
+      ncco[0].merge!(endOnKey: builder.endOnKey) if builder.endOnKey
+      ncco[0].merge!(timeOut: builder.timeOut) if builder.timeOut
+      ncco[0].merge!(beepStart: builder.beepStart) if builder.beepStart
+      ncco[0].merge!(eventUrl: builder.eventUrl) if builder.eventUrl
+      ncco[0].merge!(eventMethod: builder.eventMethod) if builder.eventMethod
+
+      ncco
+    end
+  end
+end

data/lib/vonage/voice/actions/stream.rb

@@ -0,0 +1,72 @@
+# typed: true
+# frozen_string_literal: true
+
+module Vonage
+  class Voice::Actions::Stream
+    attr_accessor :streamUrl, :level, :bargeIn, :loop
+
+    def initialize(attributes = {})
+      @streamUrl = attributes.fetch(:streamUrl)
+      @level = attributes.fetch(:level, nil)
+      @bargeIn = attributes.fetch(:bargeIn, nil)
+      @loop = attributes.fetch(:loop, nil)
+
+      after_initialize!
+    end
+
+    def after_initialize!
+      verify_stream_url
+
+      if self.level
+        verify_level
+      end
+
+      if self.bargeIn
+        verify_barge_in
+      end
+
+      if self.loop
+        verify_loop
+      end
+    end
+
+    def verify_stream_url
+      raise ClientError.new("Expected 'streamUrl' parameter to be an Array containing a single string item") unless self.streamUrl.is_a?(Array)
+
+      uri = URI.parse(self.streamUrl[0])
+
+      raise ClientError.new("Invalid 'streamUrl' value, must be a valid URL") unless uri.kind_of?(URI::HTTP) || uri.kind_of?(URI::HTTPS)
+    end
+
+    def verify_level
+      raise ClientError.new("Expected 'level' value to be a number between -1 and 1") unless self.level.between?(-1, 1)
+    end
+
+    def verify_barge_in
+      raise ClientError.new("Expected 'bargeIn' value to be a Boolean") unless self.bargeIn == true || self.bargeIn == false
+    end
+
+    def verify_loop
+      raise ClientError.new("Expected 'loop' value to be either 1 or 0") unless self.loop == 1 || self.loop == 0
+    end
+
+    def action
+      create_stream!(self)
+    end
+
+    def create_stream!(builder)
+      ncco = [
+        {
+          action: 'stream',
+          streamUrl: builder.streamUrl
+        }
+      ]
+
+      ncco[0].merge!(level: builder.level) if builder.level
+      ncco[0].merge!(bargeIn: builder.bargeIn) if (builder.bargeIn || builder.bargeIn == false)
+      ncco[0].merge!(loop: builder.loop) if builder.loop
+
+      ncco
+    end
+  end
+end