plivo 4.16.0 → 4.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 432a8633325d5e44eee995dc40993c24b25251ae
-  data.tar.gz: f1c57049cd472b7f27912e15c34949e560994132
+  metadata.gz: d0e41ca933ee8b7b7e1d43b5f894acd712e0f4db
+  data.tar.gz: 87f28295afadfa54936053e9972fe25781bd89ae
 SHA512:
-  metadata.gz: eef8a0013b8f4eb0356c98bf70c6390b0be26b23bfc6236b78751df0d8c3496a29d0f556361a5068225beda650b6d8385cd95927c05bac3cc37fb761e635ed11
-  data.tar.gz: f2a93d08156446bfe73769f162c8bd8ade2d20314cadf636b8831ea91b02de673965638b3e0aea385d2c9a7dd5527b91432295c379ad88bfc16365a2d49a029a
+  metadata.gz: '08ea6b08cadfa871edcb5ccdeaa41eda8af3cb8e74c4e1afc8a0031c9d10a79aff48591d3aaac59651d3874bb8d0226f2c47227277847fabf2dcc9ccf2c4496f'
+  data.tar.gz: 731d629d2fe5b97d5b7b513f0a2dd8aade4a648d7fd403799bff496883a8850208db06c2f49ec321551ccd43c59d9dec17d1b42d363d9e0a1593792cdc228e6c

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # 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).
+
+## [4.17.1](https://github.com/plivo/plivo-ruby/releases/tag/v4.17.1) (2021-06-18)
+- **WARNING**: Remove total_count field from meta data for list MDR response
+
+## [4.17.0](https://github.com/plivo/plivo-ruby/releases/tag/v4.17.0) (2021-06-15)
+- Added stir verification param as part of Get CDR and live call APIs response.
+
 ## [4.16.0](https://github.com/plivo/plivo-ruby/releases/tag/v4.16.0) (2021-02-08)
 - Add support for Regulatory Compliance APIs.
 

data/README.md

@@ -8,7 +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.16.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/calls.rb

@@ -230,7 +230,8 @@ module Plivo
           from: @from,
           request_uuid: @request_uuid,
           direction: @direction,
-          caller_name: @caller_name
+          caller_name: @caller_name,
+          stir_verification: @stir_verification
         }
         call_details = call_details.select {|k, v| !v.nil? }
         call_details.to_s

data/lib/plivo/resources/messages.rb

@@ -29,6 +29,7 @@ module Plivo
           to_number: @to_number,
           total_amount: @total_amount,
           total_rate: @total_rate,
+          powerpack_id: @powerpack_id,
           units: @units
         }.to_s
       end
@@ -152,8 +153,7 @@ module Plivo
       # @option options [Int] :limit Used to display the number of results per page. The maximum number of results that can be fetched is 20.
       # @option options [Int] :offset Denotes the number of value items by which the results should be offset. Eg:- If the result contains a 1000 values and limit is set to 10 and offset is set to 705, then values 706 through 715 are displayed in the results. This parameter is also used for pagination of the results.
       # @option options [String] :error_code Delivery Response code returned by the carrier attempting the delivery. See Supported error codes {https://www.plivo.com/docs/api/message/#standard-plivo-error-codes}.
-      #@option options[List]: media_urls Minimum one media url should be present in Media urls list to send mms. Maximum allowd 10 media urls inside the list (e.g, media_urls : ['https//example.com/test.jpg', 'https://example.com/abcd.gif'])
-      #@option options[List]: media_ids Minimum one media ids should be present in Media ids list to send mms. Maximum allowd 10 media ids inside the list (e.g, media_ids : ['1fs211ba-355b-11ea-bbc9-02121c1190q7'])
+      # @option options [String] :powerpack_id Filter the results by powerpack id.
       def list(options = nil)
         return perform_list if options.nil?
         valid_param?(:options, options, Hash, true)
@@ -161,7 +161,7 @@ module Plivo
         params = {}
         params_expected = %i[
           subaccount message_time message_time__gt message_time__gte
-          message_time__lt message_time__lte error_code
+          message_time__lt message_time__lte error_code powerpack_id
         ]
         params_expected.each do |param|
           if options.key?(param) &&

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.16.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.16.0
+  version: 4.19.0
 platform: ruby
 authors:
 - The Plivo SDKs Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-08 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