plivo 4.18.0 → 4.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e6a3db3d74dfd421dc5abd1ff8d789461c2af629
-  data.tar.gz: ceb2c8debfa9704d378f59a920f9edbe4f1809e1
+  metadata.gz: d0e41ca933ee8b7b7e1d43b5f894acd712e0f4db
+  data.tar.gz: 87f28295afadfa54936053e9972fe25781bd89ae
 SHA512:
-  metadata.gz: 7c579fb2504706df20e2d56dfa5856fffb69f6a024f005eeeb44f2c54b700c4f52f1749675c7fc4554fa4a61dcc9d905114f8e0648ddb5e51a2567d35be820c6
-  data.tar.gz: f567d3806d6ba132efed4dcdab2fed7b16290f9bcc2c8b73322bf67908aabbf7658ab424b30ec473720d0f99989f997713631d3489695377fd1ea92f44243615
+  metadata.gz: '08ea6b08cadfa871edcb5ccdeaa41eda8af3cb8e74c4e1afc8a0031c9d10a79aff48591d3aaac59651d3874bb8d0226f2c47227277847fabf2dcc9ccf2c4496f'
+  data.tar.gz: 731d629d2fe5b97d5b7b513f0a2dd8aade4a648d7fd403799bff496883a8850208db06c2f49ec321551ccd43c59d9dec17d1b42d363d9e0a1593792cdc228e6c

data/CHANGELOG.md

@@ -1,5 +1,8 @@
 # Change Log
 
+## [4.19.0](https://github.com/plivo/plivo-ruby/releases/tag/v4.19.0) (2021-07-19)
+- Add support for Voice MultiPartyCall APIs (includes retry) and XML, validate voice UTs
+
 ## [4.18.0](https://github.com/plivo/plivo-ruby/releases/tag/v4.18.0) (2021-07-13)
 - Power pack ID has been included to the response for the [list all messages API](https://www.plivo.com/docs/sms/api/message/list-all-messages/) and the [get message details API](https://www.plivo.com/docs/sms/api/message#retrieve-a-message).
 - Support for filtering messages by Power pack ID has been added to the [list all messages API](https://www.plivo.com/docs/sms/api/message#list-all-messages).

data/README.md

@@ -8,9 +8,7 @@ The Plivo Ruby SDK makes it simpler to integrate communications into your Ruby a
 Add this line to your application's Gemfile:
 
 ```ruby
-
-gem 'plivo', '>= 4.18.0'
-
+gem 'plivo', '>= 4.19.0'
 ```
 
 And then execute:

data/lib/plivo/base/resource.rb

@@ -114,5 +114,35 @@ module Plivo
         Response.new(response_json, @_identifier_string)
       end
     end
+
+    class SecondaryResource < Resource
+      attr_reader :secondary_id
+      def initialize(client, options = nil)
+        super
+        configure_secondary_options(options) if options
+        configure_secondary_resource_uri
+      end
+
+      def configure_secondary_options(options)
+        valid_param?(:options, options, Hash, false)
+        @secondary_id = options[:member_id] if options.key?(:member_id)
+        secondary_parse_and_set(options[:resource_json]) if options.key?(:resource_json)
+      end
+
+      def secondary_parse_and_set(resource_json)
+        return unless resource_json
+
+        valid_param?(:resource_json, resource_json, Hash, true)
+        return unless @_secondary_identifier_string && (resource_json.key? @_secondary_identifier_string)
+        @secondary_id = resource_json[@_secondary_identifier_string]
+      end
+
+      def configure_secondary_resource_uri
+        to_join = @secondary_id ? [@_client.auth_id, @_name, @id, @_secondary_name, @secondary_id] : [@_client.auth_id, @_name, @id]
+        to_join = ['', 'v1', 'Account'] << to_join
+        to_join << ''
+        @_resource_uri = to_join.join('/')
+      end
+    end
   end
 end

data/lib/plivo/base_client.rb

@@ -33,7 +33,7 @@ module Plivo
           raise Exceptions::PlivoRESTError, "Resource at #{response[:url]} "\
           'couldn\'t be deleted'
         end
-      elsif !([200, 201, 202, 207].include? response[:status])
+      elsif !([200, 201, 202, 204, 207].include? response[:status])
         raise Exceptions::PlivoRESTError, "Received #{response[:status]} for #{method}"
       end
       @@voice_retry_count = 0
@@ -266,6 +266,7 @@ module Plivo
           req.url resource_path
           req.options.timeout = timeout if timeout
           req.body = data
+          puts req
         end
       else
         if !data.nil? && (data.has_key? 'is_callinsights_request')

data/lib/plivo/resources.rb

@@ -17,6 +17,7 @@ require_relative 'resources/call_feedback'
 require_relative 'resources/media'
 require_relative 'resources/lookup'
 require_relative 'resources/regulatory_compliance'
+require_relative 'resources/multipartycalls'
 
 module Plivo
   module Resources

data/lib/plivo/resources/multipartycalls.rb

@@ -0,0 +1,554 @@
+module Plivo
+  module Resources
+    include Plivo::Utils
+    class MultiPartyCall < Base::Resource
+      def initialize(client, options = nil)
+        @_name = 'MultiPartyCall'
+        @_identifier_string = 'mpc_uuid'
+        super
+        @_is_voice_request = true
+        if options.key? :multi_party_prefix
+          @id = options[:multi_party_prefix] + '_' + @id
+        else
+          @id = 'uuid_' + @id
+        end
+        configure_resource_uri
+      end
+
+      def get
+        perform_action(nil,'GET',nil,true)
+      end
+
+      def add_participant(role,
+                          from=nil,
+                          to=nil,
+                          call_uuid=nil,
+                          caller_name=nil,
+                          call_status_callback_url=nil,
+                          call_status_callback_method='POST',
+                          sip_headers=nil,
+                          confirm_key=nil,
+                          confirm_key_sound_url=nil,
+                          confirm_key_sound_method='GET',
+                          dial_music='Real',
+                          ring_timeout=45,
+                          delay_dial=0,
+                          max_duration=14400,
+                          max_participants=10,
+                          wait_music_url=nil,
+                          wait_music_method='GET',
+                          agent_hold_music_url=nil,
+                          agent_hold_music_method='GET',
+                          customer_hold_music_url=nil,
+                          customer_hold_music_method='GET',
+                          recording_callback_url=nil,
+                          recording_callback_method='GET',
+                          status_callback_url=nil,
+                          status_callback_method='GET',
+                          on_exit_action_url=nil,
+                          on_exit_action_method='POST',
+                          record=false,
+                          record_file_format='mp3',
+                          status_callback_events='mpc-state-changes,participant-state-changes',
+                          stay_alone=false,
+                          coach_mode=true,
+                          mute=false,
+                          hold=false,
+                          start_mpc_on_enter=false,
+                          end_mpc_on_exit=false,
+                          relay_dtmf_inputs=false,
+                          enter_sound='beep:1',
+                          enter_sound_method='GET',
+                          exit_sound='beep:2',
+                          exit_sound_method='GET')
+        if (from and to) and call_uuid
+          raise_invalid_request('cannot specify call_uuid when (from, to) is provided')
+        end
+        if not from and not to and not call_uuid
+          raise_invalid_request('specify either call_uuid or (from, to)')
+        end
+        if call_uuid.nil? and (not from or not to)
+          raise_invalid_request('specify (from, to) when not adding an existing call_uuid to multi party participant')
+        end
+
+        valid_param?(:role, role.downcase, String, true, %w[agent supervisor customer])
+        valid_param?(:from, from, String, false ) unless from.nil?
+        valid_param?(:to, to, String, false ) unless to.nil?
+        valid_multiple_destination_nos?(:to, to, role: role, delimiter: '<', agent_limit: 20) unless to.nil?
+        valid_param?(:call_uuid, call_uuid, String, false ) unless call_uuid.nil?
+        valid_param?(:caller_name, caller_name, String, false) unless caller_name.nil?
+        valid_range?(:caller_name, caller_name.length, false, 0, 50) unless caller_name.nil?
+        valid_url?(:call_status_callback_url, call_status_callback_url, false) unless call_status_callback_url.nil?
+        valid_param?(:call_status_callback_method, call_status_callback_method.upcase, String, false, %w[GET POST])
+        valid_param?(:sip_headers, sip_headers, String, false) unless sip_headers.nil?
+        valid_param?(:confirm_key, confirm_key, String, false , %w[0 1 2 3 4 5 6 7 8 9 # *]) unless confirm_key.nil?
+        valid_url?(:confirm_key_sound_url, confirm_key_sound_url, false) unless confirm_key_sound_url.nil?
+        valid_param?(:confirm_key_sound_method, confirm_key_sound_method.upcase, String, false, %w[GET POST])
+        is_one_among_string_url?(:dial_music, dial_music, false, %w[real none])
+        valid_param?(:ring_timeout, ring_timeout, [String,Integer], false)
+        valid_multiple_destination_integers?(:ring_timeout, ring_timeout)
+        valid_param?(:delay_dial, delay_dial, [String,Integer], false)
+        valid_multiple_destination_integers?(:delay_dial, delay_dial)
+        valid_range?(:max_duration, max_duration, false, 300, 28800)
+        valid_range?(:max_participants, max_participants, false, 2, 10)
+        valid_url?(:wait_music_url, wait_music_url, false ) unless wait_music_url.nil?
+        valid_param?(:wait_music_method, wait_music_method.upcase, String, false , %w[GET POST])
+        valid_url?(:agent_hold_music_url, agent_hold_music_url, false) unless agent_hold_music_url.nil?
+        valid_param?(:agent_hold_music_method, agent_hold_music_method.upcase, String, false , %w[GET POST])
+        valid_url?(:customer_hold_music_url, customer_hold_music_url, false) unless customer_hold_music_url.nil?
+        valid_param?(:customer_hold_music_method, customer_hold_music_method.upcase, String, false, %w[GET POST])
+        valid_url?(:recording_callback_url, recording_callback_url, false) unless recording_callback_url.nil?
+        valid_param?(:recording_callback_method, recording_callback_method.upcase, String, false, %w[GET POST])
+        valid_url?(:status_callback_url, status_callback_url, false) unless status_callback_url.nil?
+        valid_param?(:status_callback_method, status_callback_method.upcase, String, false, %w[GET POST])
+        valid_url?(:on_exit_action_url, on_exit_action_url, false ) unless on_exit_action_url.nil?
+        valid_param?(:on_exit_action_method, on_exit_action_method.upcase, String, false, %w[GET POST])
+        valid_param?(:record, record, [TrueClass, FalseClass], false )
+        valid_param?(:record_file_format, record_file_format.downcase, String, false, %w[mp3 wav])
+        multi_valid_param?(:status_callback_events, status_callback_events.downcase, String, false, %w[mpc-state-changes participant-state-changes participant-speak-events participant-digit-input-events add-participant-api-events], true, ',')
+        valid_param?(:stay_alone, stay_alone, [TrueClass, FalseClass], false)
+        valid_param?(:coach_mode, coach_mode, [TrueClass, FalseClass], false)
+        valid_param?(:mute, mute, [TrueClass, FalseClass],false)
+        valid_param?(:hold, hold, [TrueClass, FalseClass], false)
+        valid_param?(:start_mpc_on_enter, start_mpc_on_enter, [TrueClass, FalseClass], false)
+        valid_param?(:end_mpc_on_exit, end_mpc_on_exit, [TrueClass, FalseClass], false)
+        valid_param?(:relay_dtmf_inputs, relay_dtmf_inputs, [TrueClass, FalseClass], false)
+        is_one_among_string_url?(:enter_sound, enter_sound, false, %w[beep:1 beep:2 none])
+        valid_param?(:enter_sound_method, enter_sound_method.upcase, String, false, %w[GET POST])
+        is_one_among_string_url?(:exit_sound, exit_sound, false , %w[beep:1 beep:2 none])
+        valid_param?(:exit_sound_method, exit_sound_method.upcase, String, false, %w[GET POST])
+        if (to!=nil) && (ring_timeout.is_a?(String)) && (to.split('<').size < ring_timeout.split('<').size)
+          raise_invalid_request("RingTimeout:number of ring_timout(s) should be same as number of destination(s)")
+        end
+          
+        if (to!=nil) && (delay_dial.is_a?(String)) && (to.split('<').size < delay_dial.split('<').size)
+          raise_invalid_request("Delaydial : number of delay_dial(s) should be same as number of destination(s)")
+        end
+
+        params = {}
+        params[:role] = role unless role.nil?
+        params[:from] = from unless from.nil?
+        params[:to] = to unless to.nil?
+        params[:call_uuid] = call_uuid unless call_uuid.nil?
+        params[:caller_name] = caller_name || from
+        params[:call_status_callback_url] = call_status_callback_url unless call_status_callback_url.nil?
+        params[:call_status_callback_method] = call_status_callback_method.upcase unless call_status_callback_method.nil?
+        params[:sip_headers] = sip_headers unless sip_headers.nil?
+        params[:confirm_key] = confirm_key unless confirm_key.nil?
+        params[:confirm_key_sound_url] = confirm_key_sound_url unless confirm_key_sound_url.nil?
+        params[:confirm_key_sound_method] = confirm_key_sound_method.upcase unless confirm_key_sound_method.nil?
+        params[:dial_music] = dial_music unless dial_music.nil?
+        params[:ring_timeout] = ring_timeout unless ring_timeout.nil?
+        params[:delay_dial] = delay_dial unless delay_dial.nil?
+        params[:max_duration] = max_duration unless max_duration.nil?
+        params[:max_participants] = max_participants unless max_participants.nil?
+        params[:wait_music_url] = wait_music_url unless wait_music_url.nil?
+        params[:wait_music_method] = wait_music_method.upcase unless wait_music_method.nil?
+        params[:agent_hold_music_url] = agent_hold_music_url unless agent_hold_music_url.nil?
+        params[:agent_hold_music_method] = agent_hold_music_method.upcase unless agent_hold_music_method.nil?
+        params[:customer_hold_music_url] = customer_hold_music_url unless customer_hold_music_url.nil?
+        params[:customer_hold_music_method] = customer_hold_music_method.upcase unless customer_hold_music_method.nil?
+        params[:recording_callback_url] = recording_callback_url unless recording_callback_url.nil?
+        params[:recording_callback_method] = recording_callback_method.upcase unless recording_callback_method.nil?
+        params[:status_callback_url] = status_callback_url unless status_callback_url.nil?
+        params[:status_callback_method] = status_callback_method.upcase unless status_callback_method.nil?
+        params[:on_exit_action_url] = on_exit_action_url unless on_exit_action_url.nil?
+        params[:on_exit_action_method] = on_exit_action_method.upcase unless on_exit_action_method.nil?
+        params[:record] = record unless record.nil?
+        params[:record_file_format] = record_file_format.downcase unless record_file_format.nil?
+        params[:status_callback_events] = status_callback_events.downcase unless status_callback_events.nil?
+        params[:stay_alone] = stay_alone unless stay_alone.nil?
+        params[:coach_mode] = coach_mode unless coach_mode.nil?
+        params[:mute] = mute unless mute.nil?
+        params[:hold] = hold unless hold.nil?
+        params[:start_mpc_on_enter] = start_mpc_on_enter unless start_mpc_on_enter.nil?
+        params[:end_mpc_on_exit] = end_mpc_on_exit unless end_mpc_on_exit.nil?
+        params[:relay_dtmf_inputs] = relay_dtmf_inputs unless relay_dtmf_inputs.nil?
+        params[:enter_sound] = enter_sound unless enter_sound.nil?
+        params[:enter_sound_method] = enter_sound_method.upcase unless exit_sound_method.nil?
+        params[:exit_sound] = exit_sound unless exit_sound.nil?
+        params[:exit_sound_method] = exit_sound_method.upcase unless exit_sound_method.nil?
+        perform_action_apiresponse('Participant', 'POST', params, true )
+      end
+
+      def start
+        perform_action_apiresponse(nil, 'POST', Hash['status' => 'active'], true)
+      end
+
+      def stop
+        perform_action_apiresponse(nil, 'DELETE', nil, true)
+      end
+
+      def start_recording(file_format = 'mp3', status_callback_url = nil, status_callback_method='POST')
+        valid_param?(:file_format, file_format, String, false , %w[mp3 wav])
+        valid_url?(:status_callback_url, status_callback_url, false) unless status_callback_url.nil?
+        valid_param?(:status_callback_method, status_callback_method.upcase,String, false, %w[GET POST])
+
+        params = {}
+        params[:file_format] = file_format.downcase unless file_format.nil?
+        params[:status_callback_url] = status_callback_url unless status_callback_url.nil?
+        params[:status_callback_method] = status_callback_method.upcase unless status_callback_method.nil?
+
+        perform_action_apiresponse('Record', 'POST', params, true)
+      end
+
+      def stop_recording
+        perform_action_apiresponse('Record', 'DELETE')
+      end
+
+      def pause_recording
+        perform_action_apiresponse('Record/Pause', 'POST')
+      end
+
+      def resume_recording
+        perform_action_apiresponse('Record/Resume', 'POST')
+      end
+
+
+      def start_participant_recording(member_id, file_format='mp3', status_callback_url=nil, status_callback_method='POST')
+        valid_param?(:member_id, member_id, [String, Integer], true)
+        MultiPartyCallParticipant.new(@_client, resource_id: mpc_id[1], member_id: member_id).start_participant_recording(file_format, status_callback_url, status_callback_method)
+      end
+
+      def stop_participant_recording(member_id)
+        valid_param?(:member_id, member_id, [String, Integer], true)
+        MultiPartyCallParticipant.new(@_client, resource_id: mpc_id[1], member_id: member_id).stop_participant_recording
+      end
+
+      def pause_participant_recording(member_id)
+        valid_param?(:member_id, member_id, [String, Integer], true)
+        MultiPartyCallParticipant.new(@_client, resource_id: mpc_id[1], member_id: member_id).pause_participant_recording
+      end
+
+      def resume_participant_recording(member_id)
+        valid_param?(:member_id, member_id, [String, Integer], true)
+        MultiPartyCallParticipant.new(@_client, resource_id: mpc_id[1], member_id: member_id).resume_participant_recording
+      end
+      
+      def list_participants(call_uuid = nil )
+        valid_param?(:call_uuid, call_uuid, String, false) unless call_uuid.nil?
+        params = {}
+        params[:call_uuid] = call_uuid unless call_uuid.nil?
+        perform_action('Participant', 'GET', params, true)
+      end
+
+      def update_participant(member_id, coach_mode = nil, mute = nil , hold = nil)
+        valid_param?(:member_id, member_id, [String, Integer], true)
+        MultiPartyCallParticipant.new(@_client, resource_id: @id, member_id: member_id).update_participant(coach_mode, mute, hold)
+      end
+
+      def kick_participant(member_id)
+        valid_param?(:member_id, member_id, [String, Integer], true)
+        MultiPartyCallParticipant.new(@_client, resource_id: @id, member_id: member_id).kick_participant
+      end
+
+      def get_participant(member_id)
+        valid_param?(:member_id, member_id, [String, Integer], true)
+        MultiPartyCallParticipant.new(@_client,resource_id: @id, member_id: member_id).get_participant
+      end
+    end
+
+    class MultiPartyCallParticipant < Base::SecondaryResource
+      def initialize(client, options = nil)
+        @_name = 'MultiPartyCall'
+        @_identifier_string = 'mpc_uuid'
+        @_secondary_name = 'Participant'
+        @_secondary_identifier_string = 'member_id'
+        super
+        @_is_voice_request = true
+        if options.key? :multi_party_prefix
+          @id = options[:multi_party_prefix] + '_' + @id
+        elsif @id.split('_').size > 1
+          nil
+        else
+          @id = 'uuid_' + @id
+        end
+        configure_secondary_resource_uri
+      end
+
+      def start_participant_recording(file_format = 'mp3', status_callback_url = nil, status_callback_method='POST')
+        valid_param?(:file_format, file_format, String, false , %w[mp3 wav])
+        valid_url?(:status_callback_url, status_callback_url, false) unless status_callback_url.nil?
+        valid_param?(:status_callback_method, status_callback_method.upcase,String, false, %w[GET POST])
+
+        params = {}
+        params[:file_format] = file_format.downcase unless file_format.nil?
+        params[:status_callback_url] = status_callback_url unless status_callback_url.nil?
+        params[:status_callback_method] = status_callback_method.upcase unless status_callback_method.nil?
+
+        perform_action_apiresponse('Record', 'POST', params, true)
+      end
+
+      def stop_participant_recording
+        perform_action_apiresponse('Record', 'DELETE')
+      end
+
+      def pause_participant_recording
+        perform_action_apiresponse('Record/Pause', 'POST')
+      end
+
+      def resume_participant_recording
+        perform_action_apiresponse('Record/Resume', 'POST')
+      end
+
+      def update_participant(coach_mode = nil, mute= nil, hold = nil)
+        valid_param?(:coach_mode, coach_mode, [TrueClass, FalseClass], false) unless coach_mode.nil?
+        valid_param?(:mute, mute, [TrueClass, FalseClass], false) unless mute.nil?
+        valid_param?(:hold, hold, [TrueClass, FalseClass], false) unless hold.nil?
+        params = {}
+        params[:coach_mode] = coach_mode unless coach_mode.nil?
+        params[:mute] = mute unless mute.nil?
+        params[:hold] = hold unless hold.nil?
+        perform_action_apiresponse(nil, 'POST', params, true )
+      end
+
+      def kick_participant
+        perform_action_apiresponse(nil, 'DELETE', nil, true)
+      end
+
+      def get_participant
+        perform_action_apiresponse(nil,'GET',nil,false)
+      end
+    end
+
+    class MultiPartyCallInterface < Base::ResourceInterface
+      def initialize(client, resource_list_json = nil)
+        @_name = 'MultiPartyCall'
+        @_resource_type = MultiPartyCall
+        @_identifier_string = 'mpc_uuid'
+        super
+        @_is_voice_request = true
+      end
+
+      def make_mpc_id(uuid=nil, friendly_name=nil)
+        if not uuid and not friendly_name
+          raise_invalid_request('specify either multi party call friendly name or uuid')
+        end
+        if uuid and friendly_name
+          raise_invalid_request('cannot specify both multi party call friendly name or uuid')
+        end
+        if uuid
+          identifier =  ['uuid', uuid]
+        else
+          identifier = ['name', friendly_name]
+        end
+        return identifier
+      end
+
+      def list(options={})
+        valid_param?(:options, options, Hash, false)
+        valid_subaccount?(options[:sub_account], true) unless options[:sub_account].nil?
+        valid_param?(:friendly_name, options[:friendly_name], String, false) unless options[:friendly_name].nil?
+        valid_param?(:status, options[:status].downcase, String, false, %w[initialized active ended]) unless options[:status].nil?
+        valid_param?(:termination_cause_code, options[:termination_cause_code], Integer, false) unless options[:termination_cause_code].nil?
+        valid_date_format?(:end_time__gt, options[:end_time__gt], false ) unless options[:end_time__gt].nil?
+        valid_date_format?(:end_time__gte, options[:end_time__gte], false ) unless options[:end_time__gte].nil?
+        valid_date_format?(:end_time__lt, options[:end_time__lt], String) unless options[:end_time__lt].nil?
+        valid_date_format?(:end_time__lte, options[:end_time__lte], false) unless options[:end_time__lte].nil?
+        valid_date_format?(:creation_time__gt, options[:creation_time__gt], false) unless options[:creation_time__gt].nil?
+        valid_date_format?(:creation_time__gte, options[:creation_time__gte], false) unless options[:creation_time__gte].nil?
+        valid_date_format?(:creation_time__lt, options[:creation_time__lt], false) unless options[:creation_time__lt].nil?
+        valid_date_format?(:creation_time__lte, options[:creation_time__lte], false) unless options[:creation_time__lte].nil?
+        valid_range?(:limit, options[:limit], false, 1, 20)
+        valid_range?(:offset, options[:offset], false, 0)
+        perform_action(nil ,'GET', options ,true )
+      end
+      
+      def get(options = {})
+        valid_param?(:options, options, Hash, false)
+        valid_param?(:uuid, options[:uuid], String, false) unless options[:uuid].nil?
+        valid_param?(:friendly_name, options[:friendly_name], String, false) unless options[:friendly_name].nil?
+        mpc_id = make_mpc_id(options[:uuid], options[:friendly_name])
+        MultiPartyCall.new(@_client, resource_id: mpc_id[1], multi_party_prefix: mpc_id[0]).get
+      end
+
+      def add_participant(options = {})
+        valid_param?(:options, options, Hash, false)
+        if not options[:role ]
+          raise_invalid_request("Role is mandatory")
+        end
+        options[:call_status_callback_method] = 'POST' unless options.key?(:call_status_callback_method)
+        options[:confirm_key_sound_method] = 'GET' unless options.key?(:confirm_key_sound_method)
+        options[:dial_music] = 'Real' unless options.key?(:dial_music)
+        options[:ring_timeout] = 45 unless options.key?(:ring_timeout) 
+        options[:delay_dial] = 0 unless options.key?(:delay_dial)
+        options[:max_duration] = 14400 unless options.key?(:max_duration)
+        options[:max_participants] = 10 unless options.key?(:max_participants)
+        options[:wait_music_method] = 'GET' unless options.key?(:wait_music_method)
+        options[:agent_hold_music_method] = 'GET' unless options.key?(:agent_hold_music_method)
+        options[:customer_hold_music_method] = 'GET' unless options.key?(:customer_hold_music_method)
+        options[:recording_callback_method] ='GET' unless options.key?(:recording_callback_method)
+        options[:status_callback_method] = 'GET' unless options.key?(:status_callback_method)
+        options[:on_exit_action_method] = 'POST' unless options.key?(:on_exit_action_method)
+        options[:record] = false  unless options.key?(:record)
+        options[:record_file_format] = 'mp3' unless options.key?(:record_file_format)
+        options[:status_callback_events] = 'mpc-state-changes,participant-state-changes' unless options.key?(:status_callback_events)
+        options[:stay_alone] = false unless options.key?(:stay_alone)
+        options[:coach_mode] = true unless options.key?(:coach_mode)
+        options[:mute] = false unless options.key?(:mute)
+        options[:hold] = false unless options.key?(:hold)
+        options[:start_mpc_on_enter] = true unless options.key?(:start_mpc_on_enter)
+        options[:end_mpc_on_exit] = false unless options.key?(:end_mpc_on_exit)
+        options[:relay_dtmf_inputs] = false unless options.key?(:relay_dtmf_inputs)
+        options[:enter_sound] = 'beep:1' unless options.key?(:enter_sound)
+        options[:enter_sound_method] = 'GET' unless options.key?(:enter_sound_method)
+        options[:exit_sound] = 'beep:2' unless options.key?(:exit_sound)
+        options[:exit_sound_method] = 'GET' unless options.key?(:exit_sound_method)
+        valid_param?(:friendly_name, options[:friendly_name], String, false) unless options[:friendly_name].nil?
+        valid_param?(:uuid, options[:uuid], String, false) unless options[:uuid].nil?
+        mpc_id = make_mpc_id(options[:uuid], options[:friendly_name])
+
+        MultiPartyCall.new(@_client, resource_id: mpc_id[1], multi_party_prefix: mpc_id[0]).add_participant(options[:role],options[:from],options[:to],options[:call_uuid],options[:caller_name],options[:call_status_callback_url],options[:call_status_callback_method],options[:sip_headers],options[:confirm_key],
+                                                                          options[:confirm_key_sound_url],options[:confirm_key_sound_method],options[:dial_music],options[:ring_timeout],options[:delay_dial],options[:max_duration], options[:max_participants],options[:wait_music_url],
+                                                                          options[:wait_music_method],options[:agent_hold_music_url],options[:agent_hold_music_method],options[:customer_hold_music_url],options[:customer_hold_music_method],
+                                                                          options[:recording_callback_url],options[:recording_callback_method],options[:status_callback_url],options[:status_callback_method],options[:on_exit_action_url], options[:on_exit_action_method],
+                                                                          options[:record],options[:record_file_format],options[:status_callback_events],options[:stay_alone], options[:coach_mode],options[:mute],options[:hold],options[:start_mpc_on_enter],options[:end_mpc_on_exit],
+                                                                          options[:relay_dtmf_inputs],options[:enter_sound],options[:enter_sound_method],options[:exit_sound],options[:exit_sound_method])
+      end
+
+      def start(options = {})
+        valid_param?(:options, options, Hash, false)
+        valid_param?(:uuid, options[:uuid], String, false)
+        valid_param?(:friendly_name, options[:friendly_name], String, false)
+        mpc_id = make_mpc_id(options[:uuid], options[:friendly_name])
+        MultiPartyCall.new(@_client,resource_id: mpc_id[1], multi_party_prefix: mpc_id[0]).start
+      end
+
+      def stop(options = {})
+        valid_param?(:options, options, Hash, false)
+        valid_param?(:uuid, options[:uuid], String, false) unless options[:uuid].nil?
+        valid_param?(:friendly_name, options[:friendly_name], String, false) unless options[:friendly_name].nil?
+        mpc_id = make_mpc_id(options[:uuid], options[:friendly_name])
+        MultiPartyCall.new(@_client, resource_id: mpc_id[1], multi_party_prefix: mpc_id[0]).stop
+      end
+
+      def start_recording(options = {})
+        valid_param?(:options, options, Hash, false)
+        options[:file_format] = 'mp3' unless options.key?(:file_format)
+        options[:status_callback_method] = 'POST' unless options.key?(:status_callback_method)
+        valid_param?(:uuid, options[:uuid], String, false) unless options[:uuid].nil?
+        valid_param?(:friendly_name, options[:friendly_name], String, false) unless options[:friendly_name].nil?
+        mpc_id = make_mpc_id(options[:uuid], options[:friendly_name])
+        MultiPartyCall.new(@_client, resource_id: mpc_id[1], multi_party_prefix: mpc_id[0]).start_recording(options[:file_format], options[:status_callback_url], options[:status_callback_method])
+      end
+
+      def stop_recording(options = {})
+        valid_param?(:options, options, Hash, false)
+        valid_param?(:uuid, options[:uuid], String, false) unless options[:uuid].nil?
+        valid_param?(:friendly_name, options[:friendly_name], String, false) unless options[:friendly_name].nil?
+        mpc_id = make_mpc_id(options[:uuid], options[:friendly_name])
+        MultiPartyCall.new(@_client, resource_id: mpc_id[1], multi_party_prefix: mpc_id[0]).stop_recording
+      end
+
+      def pause_recording(options = {})
+        valid_param?(:options, options, Hash, false)
+        valid_param?(:uuid, options[:uuid], String, false) unless options[:uuid].nil?
+        valid_param?(:friendly_name, options[:friendly_name], String, false) unless options[:friendly_name].nil?
+        mpc_id = make_mpc_id(options[:uuid], options[:friendly_name])
+        MultiPartyCall.new(@_client, resource_id: mpc_id[1], multi_party_prefix: mpc_id[0]).pause_recording
+      end
+
+      def resume_recording(options = {})
+        valid_param?(:options, options, Hash, false)
+        valid_param?(:uuid, options[:uuid], String, false) unless options[:uuid].nil?
+        valid_param?(:friendly_name, options[:friendly_name], String, false) unless options[:friendly_name].nil?
+        mpc_id = make_mpc_id(options[:uuid], options[:friendly_name])
+        MultiPartyCall.new(@_client, resource_id: mpc_id[1], multi_party_prefix: mpc_id[0]).resume_recording
+      end
+
+      def start_participant_recording(options = {})
+        valid_param?(:options, options, Hash, false)
+        if not options[:member_id]
+          raise_invalid_request("Member Id is mandatory")
+        end
+        options[:file_format] = 'mp3' unless options.key?(:file_format)
+        options[:status_callback_method] = 'POST' unless options.key?(:status_callback_method)
+        valid_param?(:member_id, options[:member_id], [String, Integer], true)
+        valid_param?(:uuid, options[:uuid], String, false) unless options[:uuid].nil?
+        valid_param?(:friendly_name, options[:friendly_name], String, false) unless options[:friendly_name].nil?
+        mpc_id = make_mpc_id(options[:uuid], options[:friendly_name])
+        MultiPartyCallParticipant.new(@_client, resource_id: mpc_id[1], multi_party_prefix: mpc_id[0], member_id: options[:member_id]).start_participant_recording(options[:file_format], options[:status_callback_url], options[:status_callback_method])
+      end
+
+      def stop_participant_recording(options = {})
+        valid_param?(:options, options, Hash, false)
+        if not options[:member_id]
+          raise_invalid_request("Member Id is mandatory")
+        end
+        valid_param?(:member_id, options[:member_id], [String, Integer], true)
+        valid_param?(:uuid, options[:uuid], String, false) unless options[:uuid].nil?
+        valid_param?(:friendly_name, options[:friendly_name], String, false) unless options[:friendly_name].nil?
+        mpc_id = make_mpc_id(options[:uuid], options[:friendly_name])
+        MultiPartyCallParticipant.new(@_client, resource_id: mpc_id[1], multi_party_prefix: mpc_id[0], member_id: options[:member_id]).stop_participant_recording
+      end
+
+      def pause_participant_recording(options = {})
+        valid_param?(:options, options, Hash, false)
+        if not options[:member_id]
+          raise_invalid_request("Member Id is mandatory")
+        end
+        valid_param?(:member_id, options[:member_id], [String, Integer], true)
+        valid_param?(:uuid, options[:uuid], String, false) unless options[:uuid].nil?
+        valid_param?(:friendly_name, options[:friendly_name], String, false) unless options[:friendly_name].nil?
+        mpc_id = make_mpc_id(options[:uuid], options[:friendly_name])
+        MultiPartyCallParticipant.new(@_client, resource_id: mpc_id[1], multi_party_prefix: mpc_id[0], member_id: options[:member_id]).pause_participant_recording
+      end
+
+      def resume_participant_recording(options = {})
+        valid_param?(:options, options, Hash, false)
+        if not options[:member_id]
+          raise_invalid_request("Member Id is mandatory")
+        end
+        valid_param?(:member_id, options[:member_id], [String, Integer], true)
+        valid_param?(:uuid, options[:uuid], String, false) unless options[:uuid].nil?
+        valid_param?(:friendly_name, options[:friendly_name], String, false) unless options[:friendly_name].nil?
+        mpc_id = make_mpc_id(options[:uuid], options[:friendly_name])
+        MultiPartyCallParticipant.new(@_client, resource_id: mpc_id[1], multi_party_prefix: mpc_id[0], member_id: options[:member_id]).resume_participant_recording
+      end
+      
+      def list_participants(options = {})
+        valid_param?(:options, options, Hash, false)
+        valid_param?(:uuid, options[:uuid], String, false) unless options[:uuid].nil?
+        valid_param?(:friendly_name, options[:friendly_name], String, false) unless options[:friendly_name].nil?
+        mpc_id = make_mpc_id(options[:uuid], options[:friendly_name])
+        MultiPartyCall.new(@_client, resource_id: mpc_id[1], multi_party_prefix: mpc_id[0]).list_participants(options[:call_uuid])
+      end
+
+      def update_participant(options =  {})
+        valid_param?(:options, options, Hash, false)
+        if not options[:member_id]
+          raise_invalid_request("Member Id is mandatory")
+        end
+        valid_param?(:member_id, options[:member_id], [String, Integer], true)
+        valid_param?(:uuid, options[:uuid], String, false) unless options[:uuid].nil?
+        valid_param?(:friendly_name, options[:friendly_name], String, false) unless options[:friendly_name].nil?
+        mpc_id = self.make_mpc_id(options[:uuid], options[:friendly_name])
+        MultiPartyCallParticipant.new(@_client, resource_id: mpc_id[1], multi_party_prefix: mpc_id[0], member_id: options[:member_id]).update_participant(options[:coach_mode], options[:mute], options[:hold])
+      end
+
+      def kick_participant(options = {})
+        valid_param?(:options, options, Hash, false)
+        if not options[:member_id]
+          raise_invalid_request("Member Id is mandatory")
+        end
+        valid_param?(:member_id, options[:member_id], [String, Integer], true)
+        valid_param?(:uuid, options[:uuid], String, false) unless options[:uuid].nil?
+        valid_param?(:friendly_name, options[:friendly_name], String, false) unless options[:friendly_name].nil?
+        mpc_id = make_mpc_id(options[:uuid], options[:friendly_name])
+        MultiPartyCallParticipant.new(@_client, resource_id: mpc_id[1], multi_party_prefix: mpc_id[0], member_id: options[:member_id]).kick_participant
+      end
+
+      def get_participant(options = {})
+        valid_param?(:options, options, Hash, false)
+        if not options[:member_id]
+          raise_invalid_request("Member Id is mandatory")
+        end
+        valid_param?(:member_id, options[:member_id], [String, Integer], true)
+        valid_param?(:uuid, options[:uuid], String, false) unless options[:uuid].nil?
+        valid_param?(:friendly_name, options[:friendly_name], String, false) unless options[:friendly_name].nil?
+        mpc_id = make_mpc_id(options[:uuid], options[:friendly_name])
+        MultiPartyCallParticipant.new(@_client, resource_id: mpc_id[1], multi_party_prefix: mpc_id[0], member_id: options[:member_id]).get_participant
+      end
+    end
+  end
+end

data/lib/plivo/rest_client.rb

@@ -8,7 +8,7 @@ module Plivo
     # Resources
     attr_reader :messages, :account, :subaccounts, :recordings
     attr_reader :pricings, :numbers, :calls, :conferences
-    attr_reader :phone_numbers, :applications, :endpoints
+    attr_reader :phone_numbers, :applications, :endpoints, :multipartycalls
     attr_reader :addresses, :identities
     attr_reader :call_feedback
     attr_reader :powerpacks
@@ -51,6 +51,7 @@ module Plivo
       @addresses = Resources::AddressInterface.new(self)
       @identities = Resources::IdentityInterface.new(self)
       @call_feedback = Resources::CallFeedbackInterface.new(self)
+      @multipartycalls = Resources::MultiPartyCallInterface.new( self)
       @lookup = Resources::LookupInterface.new(self)
       @end_users = Resources::EndUsersInterface.new(self)
       @compliance_document_types = Resources::ComplianceDocumentTypesInterface.new(self)

data/lib/plivo/utils.rb

@@ -67,6 +67,117 @@ module Plivo
       expected_value?(param_name, expected_values, param_value)
     end
 
+    def valid_multiple_destination_nos?(param_name, param_value, options = nil)
+      if param_value.split(options[:delimiter]).size > 1 && options[:role].downcase != 'agent'
+        raise_invalid_request("Multiple #{param_name} values given for role #{options[:role]}")
+      elsif param_value.split(options[:delimiter]).size >= options[:agent_limit]
+        raise_invalid_request("No of #{param_name} values provided should be lesser than #{options[:agent_limit]}")
+      else
+        return true
+      end
+    end
+
+    def valid_multiple_destination_integers?(param_name, param_value)
+      if (param_value.is_a? String)
+        values = param_value.split("<")
+        for i in values
+          unless (Integer(i) rescue false)
+            raise_invalid_request("#{param_name} Destination Value must be integer")
+          end
+        end
+      end
+    end
+    
+    def valid_url?(param_name, param_value, mandatory = false)
+      if mandatory && param_value.nil?
+        raise_invalid_request("#{param_name} is a required parameter")
+      end
+
+      return true if param_value.nil?
+      return raise_invalid_request("#{param_name}: Expected a String but received #{param_value.class} instead") unless expected_type?(param_name, String, param_value)
+
+      if param_value =~ /^(http[s]?:\/\/([a-zA-Z]|[0-9]|[\$\-\_\@\.\&\+\/\#]|[\!\*\(\)\,]|(%[0-9a-fA-F][0-9a-fA-F]))+|nil)$/ix
+        return true
+      else
+        return raise_invalid_request("Invalid URL : Doesn't satisfy the URL format")
+      end
+    end
+
+    def valid_range?(param_name, param_value, mandatory = false, lower_bound = nil, upper_bound = nil)
+      if mandatory && param_value.nil?
+        raise_invalid_request("#{param_name} is a required parameter")
+      end
+
+      return true if param_value.nil?
+
+      return raise_invalid_request("#{param_name}: Expected an Integer but received #{param_value.class} instead") unless expected_type?(param_name, Integer, param_value)
+      if lower_bound && upper_bound
+        return raise_invalid_request("#{param_name} ranges between #{lower_bound} and #{upper_bound}") if param_value < lower_bound or param_value > upper_bound
+
+        return true if param_value >= lower_bound and param_value <= upper_bound
+      elsif lower_bound
+        return raise_invalid_request("#{param_name} should be greater than #{lower_bound}") if param_value < lower_bound
+
+        return true if param_value >= lower_bound
+      elsif upper_bound
+        return raise_invalid_request("#{param_name} should be lesser than #{upper_bound}") if param_value > upper_bound
+
+        return true if param_value <= upper_bound
+      else
+        return raise_invalid_request("Any one or both of lower and upper bound should be provided")
+      end
+    end
+
+    def multi_valid_param?(param_name, param_value, expected_types = nil, mandatory = false, expected_values = nil, make_down_case = false, seperator = ',')
+      if mandatory && param_value.nil?
+        raise_invalid_request("#{param_name} is a required parameter")
+      end
+
+      return true if param_value.nil?
+
+      if make_down_case
+        param_value = param_value.downcase
+      else
+        param_value = param_value.uppercase
+      end
+
+      for val in param_value.split(seperator)
+        return expected_type?(param_name, expected_types, val.strip) unless expected_values
+        expected_value?(param_name, expected_values, val.strip)
+      end
+    end
+
+    def valid_date_format?(param_name, param_value, mandatory = false)
+      if mandatory && param_value.nil?
+        raise_invalid_request("#{param_name} is a required parameter")
+      end
+
+      return true if param_value.nil?
+
+      if param_value =~ /^(\d{4}\-\d{2}\-\d{2}\ \d{2}\:\d{2}(\:\d{2}(\.\d{1,6})?)?)$/ix
+        return true
+      else
+        return raise_invalid_request("Invalid Date Format")
+      end
+    end
+
+    def is_one_among_string_url?(param_name, param_value, mandatory = false, expected_values= nil)
+      if mandatory && param_value.nil?
+        raise_invalid_request("#{param_name} is a required parameter")
+      end
+
+      return true if param_value.nil?
+      return raise_invalid_request("#{param_name}: Expected a String but received #{param_value.class} instead") unless expected_type?(param_name, String, param_value)
+
+      if expected_values.include? param_value.downcase or expected_values.include? param_value.upcase
+        return true
+      elsif valid_url?(param_name, param_value)
+        return true
+      else
+        raise_invalid_request("#{param_name} neither a valid URL nor in the expected values")
+      end
+    end
+
     def expected_type?(param_name, expected_types, param_value)
       return true if expected_types.nil?
       param_value_class = param_value.class

data/lib/plivo/version.rb

@@ -1,3 +1,3 @@
 module Plivo
-  VERSION = "4.18.0".freeze
+  VERSION = "4.19.0".freeze
 end

data/lib/plivo/xml.rb

@@ -29,7 +29,7 @@ require_relative 'xml/say_as'
 require_relative 'xml/sub'
 require_relative 'xml/w'
 require_relative 'xml/plivo_xml'
-
+require_relative 'xml/multipartycall'
 include Plivo::Exceptions
 
 module Plivo

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/response.rb

@@ -2,7 +2,7 @@ module Plivo
   module XML
     class Response < Element
       @nestables = %w[Speak Play GetDigits GetInput Record Dial Message
-                      Redirect Wait Hangup PreAnswer Conference DTMF]
+                      Redirect Wait Hangup PreAnswer Conference DTMF MultiPartyCall]
       @valid_attributes = []
 
       def initialize

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plivo
 version: !ruby/object:Gem::Version
-  version: 4.18.0
+  version: 4.19.0
 platform: ruby
 authors:
 - The Plivo SDKs Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-07-13 00:00:00.000000000 Z
+date: 2021-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -190,6 +190,7 @@ files:
 - lib/plivo/resources/lookup.rb
 - lib/plivo/resources/media.rb
 - lib/plivo/resources/messages.rb
+- lib/plivo/resources/multipartycalls.rb
 - lib/plivo/resources/nodes.rb
 - lib/plivo/resources/numbers.rb
 - lib/plivo/resources/phlo_member.rb
@@ -213,6 +214,7 @@ files:
 - lib/plivo/xml/hangup.rb
 - lib/plivo/xml/lang.rb
 - lib/plivo/xml/message.rb
+- lib/plivo/xml/multipartycall.rb
 - lib/plivo/xml/number.rb
 - lib/plivo/xml/p.rb
 - lib/plivo/xml/phoneme.rb