vonage 7.3.0 → 7.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71e2807806583d50e0ce062ffaaafbcb69f1629e3ba010a6cedbcc22cfcc0741
-  data.tar.gz: da726714cefba39cd4e78f7356dbc566e4c7a61718b968281e1625c4787f5d84
+  metadata.gz: a62ffd2c9e2a145badeb3e1e232b7959ca2b31c0d7355c1cf804db7e955cb96a
+  data.tar.gz: 6fa0cae4317a331b4218e3d479bff3b7031145c36386c7d19e94d59dfb9cc927
 SHA512:
-  metadata.gz: 13e4ce32d69d4bdc899e7143137e926891423e4d838d3ede9d606481e4da5840c47d6c4c4368ee428e1df6264ab36980cecfd485fbf4aa5b183cc340f4b05d72
-  data.tar.gz: 711085663db7d880b0b5fe7d1acee074c08052a13fef61982df704681c6b2482178126ff9b0d3d868514e5b18ef61a7a39259be7095db362699f0778aa0a9918
+  metadata.gz: fc3c593e76119e4c74094db945f74da19e0289766752c18f89f5de8491753b983f0d130e02af4be4c6bbb70c0ee0e73d0b626af96c676b86c15b0fdbd62803c2
+  data.tar.gz: 702152725c3a7a707965e971ba0b4599bac7e62dd842037ad9c4e784d68f0d645c90e203093fff806016cb6efc2f7e5269103f14ba2fe7a1fd255b265bd12ed9

data/README.md

@@ -1,6 +1,6 @@
 # Vonage Server SDK for Ruby
 
-[![Gem Version](https://badge.fury.io/rb/vonage.svg)](https://badge.fury.io/rb/vonage) ![Coverage Status](https://github.com/Vonage/vonage-ruby-sdk/workflows/CI/badge.svg) [![codecov](https://codecov.io/gh/Vonage/vonage-ruby-sdk/branch/master/graph/badge.svg)](https://codecov.io/gh/vonage/vonage-ruby-sdk)
+[![Gem Version](https://badge.fury.io/rb/vonage.svg)](https://badge.fury.io/rb/vonage) ![Coverage Status](https://github.com/Vonage/vonage-ruby-sdk/workflows/CI/badge.svg) [![codecov](https://codecov.io/gh/Vonage/vonage-ruby-sdk/branch/7.x/graph/badge.svg?token=FKW6KL532P)](https://codecov.io/gh/Vonage/vonage-ruby-sdk)
 
 
 <img src="https://developer.nexmo.com/assets/images/Vonage_Nexmo.svg" height="48px" alt="Nexmo is now known as Vonage" />
@@ -16,6 +16,7 @@ need a Vonage account. Sign up [for free at vonage.com][signup].
     * [JWT authentication](#jwt-authentication)
     * [Webhook signatures](#webhook-signatures)
     * [Pagination](#pagination)
+    * [NCCO Builder](#ncco-builder)
 * [Documentation](#documentation)
 * [Frequently Asked Questions](#frequently-asked-questions)
     * [Supported APIs](#supported-apis)
@@ -167,6 +168,32 @@ To modify the `auto_advance` behavior you can specify it in your method:
 client.applications.list(auto_advance: false)
 ```
 
+## NCCO Builder
+
+The Vonage Voice API accepts instructions via JSON objects called NCCOs. Each NCCO can be made up multiple actions that are executed in the order they are written. The Vonage API Developer Portal contains an [NCCO Reference](https://developer.vonage.com/voice/voice-api/ncco-reference) with instructions and information on all the parameters possible.
+
+The SDK includes an NCCO builder that you can use to build NCCOs for your Voice API methods.
+
+For example, to build `talk` and `input` NCCO actions and then combine them into a single NCCO you would do the following:
+
+```ruby
+talk = Vonage::Voice::Ncco.talk(text: 'Hello World!')
+input = Vonage::Voice::Ncco.input(type: ['dtmf'], dtmf: { bargeIn: true })
+ncco = Vonage::Voice::Ncco.build(talk, input)
+
+# => [{:action=>"talk", :text=>"Hello World!"}, {:action=>"input", :type=>["dtmf"], :dtmf=>{:bargeIn=>true}}]
+```
+
+Once you have the constructed NCCO you can then use it in a Voice API request:
+
+```ruby
+response = client.voice.create({
+  to: [{type: 'phone', number: '14843331234'}],
+  from: {type: 'phone', number: '14843335555'},
+  ncco: ncco
+})
+```
+
 ## Documentation
 
 Vonage Ruby documentation: https://www.rubydoc.info/github/Vonage/vonage-ruby-sdk

data/lib/vonage/version.rb

@@ -1,5 +1,5 @@
 # typed: strong
 
 module Vonage
-  VERSION = '7.3.0'
+  VERSION = '7.4.0'
 end

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

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

@@ -0,0 +1,73 @@
+# typed: true
+# frozen_string_literal: true
+module Vonage
+  class Voice::Actions::Talk
+    attr_accessor :text, :bargeIn, :loop, :level, :language, :style
+
+    def initialize(attributes= {})
+      @text = attributes.fetch(:text)
+      @bargeIn = attributes.fetch(:bargeIn, nil)
+      @loop = attributes.fetch(:loop, nil)
+      @level = attributes.fetch(:level, nil)
+      @language = attributes.fetch(:language, nil)
+      @style = attributes.fetch(:style, nil)
+
+      after_initialize!
+    end
+
+    def after_initialize!
+      if self.bargeIn
+        verify_barge_in
+      end
+
+      if self.loop
+        verify_loop
+      end
+
+      if self.level
+        verify_level
+      end
+
+      if self.style
+        verify_style
+      end
+    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 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_style
+      raise ClientError.new("Expected 'style' value to be an Integer") unless self.style.is_a?(Integer)
+    end
+
+    def action
+      create_talk!(self)
+    end
+
+    def create_talk!(builder)
+      ncco = [
+        {
+          action: 'talk',
+          text: builder.text
+        }
+      ]
+
+      ncco[0].merge!(bargeIn: builder.bargeIn) if (builder.bargeIn || builder.bargeIn == false)
+      ncco[0].merge!(loop: builder.loop) if builder.loop
+      ncco[0].merge!(level: builder.level) if builder.level
+      ncco[0].merge!(language: builder.language) if builder.language
+      ncco[0].merge!(style: builder.style) if builder.style
+
+      ncco
+    end
+  end
+end

data/lib/vonage/voice/ncco.rb

@@ -0,0 +1,42 @@
+# typed: true
+# frozen_string_literal: true
+
+module Vonage
+  class Voice::Ncco
+    ACTIONS = {
+      connect: Vonage::Voice::Actions::Connect,
+      conversation: Vonage::Voice::Actions::Conversation,
+      input: Vonage::Voice::Actions::Input,
+      notify: Vonage::Voice::Actions::Notify,
+      record: Vonage::Voice::Actions::Record,
+      stream: Vonage::Voice::Actions::Stream,
+      talk: Vonage::Voice::Actions::Talk
+    }
+
+    ACTIONS.keys.each do |method|      
+      self.class.send :define_method, method do |attributes|
+        ACTIONS[method].new(**attributes).action
+      end
+    end
+
+    def self.method_missing(method)
+      raise ClientError.new("NCCO action must be one of the valid options. Please refer to https://developer.nexmo.com/voice/voice-api/ncco-reference#ncco-actions for a complete list.")
+    end
+
+    # Create an NCCO
+    #
+    # @example
+    #   talk = Vonage::Voice::Ncco.talk(text: 'This is sample text')
+    #   input = Vonage::Voice::Ncco.input(type: ['dtmf'])
+    #   ncco = Vonage::Voice::Ncco.create(talk, input)
+    #
+    # @option actions [Vonage::Voice::Ncco]
+    #
+    # @return [Array]
+    #
+    # @see https://developer.nexmo.com/voice/voice-api/ncco-reference
+    def self.create(*actions)
+      actions.flatten!
+    end
+  end
+end

data/vonage.gemspec

@@ -16,6 +16,7 @@ Gem::Specification.new do |s|
   s.add_dependency('zeitwerk', '~> 2', '>= 2.2')
   s.add_dependency('sorbet-runtime', '~> 0.5')
   s.add_runtime_dependency('rexml')
+  s.add_runtime_dependency('phonelib')
   s.require_path = 'lib'
   s.metadata = {
     'homepage' => 'https://github.com/Vonage/vonage-ruby-sdk',

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: vonage
 version: !ruby/object:Gem::Version
-  version: 7.3.0
+  version: 7.4.0
 platform: ruby
 authors:
 - Vonage
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-16 00:00:00.000000000 Z
+date: 2021-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nexmo-jwt
@@ -72,6 +72,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: phonelib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Vonage Server SDK for Ruby
 email:
 - devrel@vonage.com
@@ -132,8 +146,16 @@ files:
 - lib/vonage/verify.rb
 - lib/vonage/version.rb
 - lib/vonage/voice.rb
+- lib/vonage/voice/actions/connect.rb
+- lib/vonage/voice/actions/conversation.rb
+- lib/vonage/voice/actions/input.rb
+- lib/vonage/voice/actions/notify.rb
+- lib/vonage/voice/actions/record.rb
+- lib/vonage/voice/actions/stream.rb
+- lib/vonage/voice/actions/talk.rb
 - lib/vonage/voice/dtmf.rb
 - lib/vonage/voice/list_response.rb
+- lib/vonage/voice/ncco.rb
 - lib/vonage/voice/stream.rb
 - lib/vonage/voice/talk.rb
 - vonage.gemspec