plivo 4.16.0 → 4.58.0

data/lib/plivo/resources/verify_session.rb

@@ -0,0 +1,106 @@
+module Plivo
+    module Resources
+        include Plivo::Utils
+        class Session < Base::Resource
+            def initialize(client, options = nil)
+                @_name = 'Session'
+                @_identifier_string = 'session_uuid'
+                super
+            end
+            def to_s
+                {
+                  api_id: @api_id,
+                  session_uuid: @session_uuid,
+                  app_uuid: @app_uuid,
+                  alias: @alias,
+                  recipient: @recipient,
+                  channel: @channel,
+                  status: @status,
+                  count: @count,
+                  requestor_ip: @requestor_ip,
+                  destination_country_iso2: @destination_country_iso2,
+                  destination_network: @destination_network,
+                  attempt_details: @attempt_details,
+                  charges: @charges,
+                  created_at: @created_at,
+                  updated_at: @updated_at
+                }.to_s
+            end
+        end    
+
+        class SessionInterface < Base::ResourceInterface
+            def initialize(client, resource_list_json = nil)
+                @_name = 'Verify/Session'
+                @_resource_type = Session
+                @_identifier_string = 'session_uuid'
+                super
+            end
+
+            # @param [String] session_uuid
+            def get(session_uuid)
+                perform_get(session_uuid)
+            end
+
+            def create(app_uuid = nil, recipient = nil,channel = nil,url = nil, method = nil)
+                valid_param?(:app_uuid, app_uuid, [String, Symbol], false)
+                valid_param?(:recipient, recipient, [Integer, String, Symbol], true)
+                valid_param?(:channel, channel, [String, Symbol], false)
+                valid_param?(:url, url, [String], false)
+                valid_param?(:method, method, String, false, %w[POST GET])
+
+                params = {
+                    app_uuid: app_uuid,
+                    recipient: recipient,
+                    channel: channel,
+                    url: url,
+                    method: method
+                }
+                perform_create(params)
+            end   
+            
+            def list(options = nil)
+                return perform_list if options.nil?
+                valid_param?(:options, options, Hash, true)
+                params = {}
+                params_expected = %i[
+                subaccount status session_time__gt session_time__gte
+                session_time__lt session_time__lte session_time country alias app_uuid recipient
+                ]
+
+                params_expected.each do |param|
+                    if options.key?(param) &&
+                       valid_param?(param, options[param], [String, Symbol], true)
+                      params[param] = options[param]
+                    end
+                end
+          
+                %i[offset limit].each do |param|
+                    if options.key?(param) &&
+                        valid_param?(param, options[param], [Integer, Integer], true)
+                        params[param] = options[param]
+                    end
+                end
+                
+                if options.key?(:limit) &&
+                    (options[:limit] > 20 || options[:limit] <= 0)
+                   raise_invalid_request('The maximum number of results that can be '\
+                   "fetched is 20. limit can't be more than 20 or less than 1")
+                end
+
+                raise_invalid_request("Offset can't be negative") if options.key?(:offset) && options[:offset] < 0
+
+                perform_list_without_object(params)
+            end
+            
+            def validate(session_uuid = nil, otp = nil)
+                valid_param?(:session_uuid, session_uuid, [String, Symbol], true)
+                valid_param?(:otp, otp, [String], true)
+                id = session_uuid
+                params = {
+                    otp: otp
+                }
+                perform_action_with_identifier(id, 'POST', params)
+            end    
+        end    
+    end    
+end    

data/lib/plivo/resources.rb

@@ -7,6 +7,7 @@ require_relative 'resources/pricings'
 require_relative 'resources/numbers'
 require_relative 'resources/conferences'
 require_relative 'resources/calls'
+require_relative 'resources/token'
 require_relative 'resources/endpoints'
 require_relative 'resources/addresses'
 require_relative 'resources/identities'
@@ -15,8 +16,15 @@ require_relative 'resources/nodes'
 require_relative 'resources/phlo_member'
 require_relative 'resources/call_feedback'
 require_relative 'resources/media'
+require_relative 'resources/brand'
+require_relative 'resources/campaign'
+require_relative 'resources/profile'
 require_relative 'resources/lookup'
 require_relative 'resources/regulatory_compliance'
+require_relative 'resources/multipartycalls'
+require_relative 'resources/verify_session'
+require_relative 'resources/tollfree_verification'
+require_relative 'resources/verify_caller_id'
 
 module Plivo
   module Resources

data/lib/plivo/rest_client.rb

@@ -8,14 +8,19 @@ module Plivo
     # Resources
     attr_reader :messages, :account, :subaccounts, :recordings
     attr_reader :pricings, :numbers, :calls, :conferences
-    attr_reader :phone_numbers, :applications, :endpoints
+    attr_reader :token
+    attr_reader :phone_numbers, :applications, :endpoints, :multipartycalls
     attr_reader :addresses, :identities
     attr_reader :call_feedback
     attr_reader :powerpacks
     attr_reader :powerpacks, :media
     attr_reader :lookup
+    attr_reader :brand, :campaign, :profile
     attr_reader :end_users
     attr_reader :compliance_document_types, :compliance_documents, :compliance_requirements, :compliance_applications
+    attr_reader :verify_session
+    attr_reader :tollfree_verifications
+    attr_reader :verify_caller_id
 
     def initialize(auth_id = nil, auth_token = nil, proxy_options = nil, timeout = 5)
       configure_base_uri
@@ -39,6 +44,9 @@ module Plivo
       @messages = Resources::MessagesInterface.new(self)
       @powerpacks = Resources::PowerpackInterface.new(self)
       @media = Resources::MediaInterface.new(self)
+      @brand = Resources::BrandInterface.new(self)
+      @campaign = Resources::CampaignInterface.new(self)
+      @profile = Resources::ProfileInterface.new(self)
       @subaccounts = Resources::SubaccountInterface.new(self)
       @recordings = Resources::RecordingInterface.new(self)
       @pricings = Resources::PricingInterface.new(self)
@@ -46,17 +54,22 @@ module Plivo
       @phone_numbers = Resources::PhoneNumberInterface.new(self)
       @conferences = Resources::ConferenceInterface.new(self)
       @calls = Resources::CallInterface.new(self)
+      @token = Resources::TokenInterface.new(self)
       @endpoints = Resources::EndpointInterface.new(self)
       @applications = Resources::ApplicationInterface.new(self)
       @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)
       @compliance_documents = Resources::ComplianceDocumentsInterface.new(self)
       @compliance_requirements = Resources::ComplianceRequirementsInterface.new(self)
       @compliance_applications = Resources::ComplianceApplicationsInterface.new(self)
+      @verify_session = Resources::SessionInterface.new(self)
+      @tollfree_verifications = Resources::TollfreeVerificationsInterface.new(self)
+      @verify_caller_id = Resources::VerifyCallerIdInterface.new(self)
     end
   end
 end

data/lib/plivo/template.rb

@@ -0,0 +1,102 @@
+require_relative "resources"
+require_relative "base_client"
+require_relative "base"
+require_relative "location"
+module Plivo
+    class Template
+      attr_accessor :name, :language, :components
+  
+      def initialize(name: nil, language: nil, components: nil)
+        @name = name
+        @language = language
+        @components = components
+      end
+  
+      def to_hash
+        {
+          name: @name,
+          language: @language,
+          components: @components&.map(&:to_hash)&.reject { |h| h.values.all?(&:nil?) }
+        }.reject { |_, v| v.nil? }
+      end
+    end
+  
+    class Component
+      attr_accessor :type, :sub_type, :index, :parameters
+  
+      def initialize(type: nil, sub_type: nil, index: nil, parameters: nil)
+        @type = type
+        @sub_type = sub_type
+        @index = index
+        @parameters = parameters
+      end
+  
+      def to_hash
+        {
+          type: @type,
+          sub_type: @sub_type,
+          index: @index,
+          parameters: @parameters&.map(&:to_hash)&.reject { |h| h.values.all?(&:nil?) }
+        }.reject { |_, v| v.nil? }
+      end
+    end
+  
+    class Parameter
+      attr_accessor :type, :text, :media, :payload, :currency, :date_time, :location
+  
+      def initialize(type: nil, text: nil, media: nil, payload: nil, currency: nil, date_time: nil, location: nil)
+        @type = type
+        @text = text
+        @media = media
+        @payload = payload
+        @currency = currency
+        @date_time = date_time
+        @location = location
+      end
+  
+      def to_hash
+        {
+          type: @type,
+          text: @text,
+          media: @media,
+          payload: @payload,
+          currency: @currency&.to_hash,
+          date_time: @date_time&.to_hash,
+          location: @location&.to_hash
+        }.reject { |_, v| v.nil? }
+      end
+    end
+  
+    class Currency
+      attr_accessor :fallback_value, :currency_code, :amount_1000
+  
+      def initialize(fallback_value: nil, currency_code: nil, amount_1000: nil)
+        @fallback_value = fallback_value
+        @currency_code = currency_code
+        @amount_1000 = amount_1000
+      end
+  
+      def to_hash
+        {
+          fallback_value: @fallback_value,
+          currency_code: @currency_code,
+          amount_1000: @amount_1000
+        }.reject { |_, v| v.nil? }
+      end
+    end
+  
+    class DateTime
+      attr_accessor :fallback_value
+  
+      def initialize(fallback_value: nil)
+        @fallback_value = fallback_value
+      end
+  
+      def to_hash
+        {
+          fallback_value: @fallback_value
+        }.reject { |_, v| v.nil? }
+      end
+    end
+  end
+  

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
@@ -116,7 +227,7 @@ module Plivo
         uri += "?"
       end
       if parsed_uri.query.to_s.length > 0
-        parsed_uri_query = URI.decode(parsed_uri.query)
+        parsed_uri_query = URI.decode_www_form_component(parsed_uri.query)
         if method == "GET"
           queryParamMap = getMapFromQueryString?(parsed_uri_query)
           params.keys.sort.each { |key|

data/lib/plivo/version.rb

@@ -1,3 +1,3 @@
 module Plivo
-  VERSION = "4.16.0".freeze
+  VERSION = "4.58.0".freeze
 end

data/lib/plivo/xml/cont.rb

@@ -0,0 +1,13 @@
+module Plivo
+    module XML
+      class Cont < Element
+        @nestables = []
+        @valid_attributes = []
+  
+        def initialize(body)
+          super(body)
+        end
+      end
+    end
+  end
+  

data/lib/plivo/xml/dial.rb

@@ -3,7 +3,7 @@ module Plivo
     class Dial < Element
       @nestables = %w[Number User]
       @valid_attributes = %w[action method timeout hangupOnStar
-                             timeLimit callerId callerName confirmSound
+                             timeLimit callerId callerName confirmSound confirmTimeout
                              dialMusic confirmKey redirect
                              callbackUrl callbackMethod digitsMatch digitsMatchBLeg
                              sipHeaders]

data/lib/plivo/xml/element.rb

@@ -80,8 +80,15 @@ module Plivo
       def add(element)
         raise PlivoXMLError, 'invalid element' unless element
         if @nestables.include?(element.name)
-          @node.elements << element.node
-          element
+          if element.name == "Cont"
+            @node.elements << element.node 
+            element
+            temp = REXML::Text.new element.node.text
+            @node.elements['Cont'] = temp
+          else
+            @node.elements << element.node 
+            element
+          end
         else
           raise PlivoXMLError, "#{element.name} not nestable in #{@name}"
         end

data/lib/plivo/xml/emphasis.rb

@@ -1,7 +1,7 @@
 module Plivo
   module XML
     class Emphasis < Element
-      @nestables = %w(Break Emphasis Lang Phoneme Prosody SayAs Sub W)
+      @nestables = %w(Break Cont Emphasis Lang Phoneme Prosody SayAs Sub W)
       @valid_attributes = %w(level)
 
       VALID_LEVEL_ATTRIBUTE_VALUE=%w(strong moderate reduced)

data/lib/plivo/xml/lang.rb

@@ -1,7 +1,7 @@
 module Plivo
   module XML
     class Lang < Element
-      @nestables = %w(Break Emphasis Lang P Phoneme Prosody S SayAs Sub W)
+      @nestables = %w(Break Cont Emphasis Lang P Phoneme Prosody S SayAs Sub W)
       @valid_attributes = %w(xmllang)
 
        VALID_LANG_ATTRIBUTE_VALUES = [