plivo 4.15.2 → 4.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9623fb2c4baf69935048acfa538cb061326de346
-  data.tar.gz: 30629da34bc63fed7092e9c264c34cd41a496870
+  metadata.gz: 432a8633325d5e44eee995dc40993c24b25251ae
+  data.tar.gz: f1c57049cd472b7f27912e15c34949e560994132
 SHA512:
-  metadata.gz: 69b585a499ec727dbc3f615d654b429f39a3f699028994de89cb79298b333e0a2d54501697644f579f4266fadc7bc0bb4fd4a43d50f021722e2defda30d8f979
-  data.tar.gz: 843e1f620186e4c8e6153f8a2cac6793c666e49479382622e9d24fa2452801fe99c7240480b2b04495e45d939d4731f11910607617e0b1eee815f73ebf5fd43f
+  metadata.gz: eef8a0013b8f4eb0356c98bf70c6390b0be26b23bfc6236b78751df0d8c3496a29d0f556361a5068225beda650b6d8385cd95927c05bac3cc37fb761e635ed11
+  data.tar.gz: f2a93d08156446bfe73769f162c8bd8ade2d20314cadf636b8831ea91b02de673965638b3e0aea385d2c9a7dd5527b91432295c379ad88bfc16365a2d49a029a

data/CHANGELOG.md

@@ -1,5 +1,8 @@
 # Change Log
 
+## [4.16.0](https://github.com/plivo/plivo-ruby/releases/tag/v4.16.0) (2021-02-08)
+- Add support for Regulatory Compliance APIs.
+
 ## [4.15.2](https://github.com/plivo/plivo-ruby/releases/tag/v4.15.2) (2021-01-27)
 - Fix Call API resource - Set answer_method as Optional param.
 

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.15.2'
+gem 'plivo', '>= 4.16.0'
 ```
 
 And then execute:

data/examples/regulatory_compliance.rb

@@ -0,0 +1,167 @@
+require "rubygems"
+require "plivo"
+
+include Plivo
+include Plivo::Exceptions
+
+AUTH_ID = ""
+AUTH_TOKEN = ""
+
+client = RestClient.new(AUTH_ID, AUTH_TOKEN)
+
+# if credentials are stored in the PLIVO_AUTH_ID and the PLIVO_AUTH_TOKEN environment variables
+# then initialize client as:
+# client = RestClient.new
+
+# 1. EndUSers
+begin
+  resp = client.end_users.create('Sample First Name',
+   'Sample last name',
+   'individual')
+  puts resp
+rescue PlivoRESTError => e
+  puts "Exception: " + e.message
+end
+
+
+# Response:
+# {
+#   "api_id": "36989807-a76f-4555-84d1-9dfdccca7a80",
+#   "end_user_id": "36989807-a76f-4555-84d1-9dfdccca7a80",
+#   "name": "Sample First Name",
+#   "last_name": 'Sample last name',
+#   "end_user_type": 'individual',
+#   "created_on": '2021-02-08T05:28:49.238152984Z',
+#   "message": "created"
+# }
+
+# 2. Compliance Document Type
+begin
+    resp = client.compliance_document_types.get('6264e9ee-5826-4f9a-80ce-00b00f7a6c0c')
+    puts resp
+  rescue PlivoRESTError => e
+    puts "Exception: " + e.message
+  end
+
+# Response:
+# {
+#   "api_id": "36989807-a76f-4555-84d1-9dfdccca7a80",
+#   "document_type_id": "36989807-a76f-4555-84d1-9dfdccca7a80",
+#   "document_name": "Address Information",
+#   "description": 'End User Residential Address information',
+#   "information": [
+#      {
+#         "enums": [
+#             "Water",
+#             "Electricity",
+#             "Gas",
+#             "Property Rental",
+#             "Others"
+#         ],
+#         "field_name": "type_of_utility",
+#         "field_type": "enum",
+#         "friendly_name": "Type of Utility"
+#      }
+#   ],
+#   "proof_required": "Scanned copy of the Bill",
+#   "created_at": '2018-11-03 19:32:33.240504+00:00'
+# }
+
+# 3. Compliance Documents
+begin
+    resp = client.compliance_documents.list(
+        limit: 5,
+        offset: 0,
+        document_type_id: '15d48097-6fd6-4bbc-97ee-0c3dd0a8fe1a',
+        end_user_id: '4493840308')
+    puts resp
+  rescue PlivoRESTError => e
+    puts "Exception: " + e.message
+  end
+
+# Response
+#  {
+#    "alias": "test alias",
+#    "api_id": "3cfabf1a-6579-11eb-b408-0242ac110005",
+#    "created_at": "2021-02-02 08:08:10.312992 +0000 UTC",
+#    "document_id": "4a9599cc-c58c-4804-8c04-1d4918cb6df7",
+#    "document_type_id": "be903190-cc96-4fd8-b3cd-97832fe7c086",
+#    "end_user_id": "652e1445-1657-4a80-972f-6dbd467b00b5",
+#    "meta_information": {
+#        "use_case_description": "test"
+#    }
+#}
+
+# 4. Compliance Requirements
+begin
+    resp = client.compliance_requirements.list(
+        country_iso2: 'ES',
+        end_user_type: 'business',
+        number_type: 'local')
+    puts resp
+  rescue PlivoRESTError => e
+    puts "Exception: " + e.message
+  end
+
+# Response:
+#{
+#   "acceptable_document_types": [
+#      {
+#         "acceptable_documents": [
+#            {
+#               "document_type_id": "e68cf5fe-cea0-4b6c-a2b1-bef1d9add467",
+#               "document_type_name": "Address Information"
+#            }
+#          ],
+#          "name": "End User Address Details",
+#          "scope": "local"
+#      },
+#      {
+#         "acceptable_documents": [
+#            {
+#               "document_type_id": "e9b0b6fb-fd2f-44c1-9428-ee69afbd808b",
+#               "document_type_name": "Utility Bill"
+#            }
+#          ],
+#          "name": "Proof of Address ",
+#          "scope": "local"
+#        }
+#    ],
+#    "api_id": "75ea8886-6499-11eb-ad59-0242ac110005",
+#    "compliance_requirement_id": "4ae473b0-f154-41a4-aba8-ab76be12f27f",
+#    "country_iso2": "ES",
+#    "end_user_type": "individual",
+#    "number_type": "local"
+#}
+
+# 5. Compliance Applications
+begin
+    resp = client.compliance_applications.create(
+        alias_: 'test',
+        compliance_requirement_id: '4ae473b0-f154-41a4-aba8-ab76be12f27f',
+        end_user_type: 'individual'
+        end_user_id: 'f7ba78e0-1d31-4f75-842c-cd2f91334d9f',
+        document_ids: ["a663bc92-5c8e-4e95-80d5-ba75d3569a98","4a9599cc-c58c-4804-8c04-1d4918cb6df7"],
+        country_iso2: 'FR',
+        number_type: 'mobile'
+    )
+    puts resp
+  rescue PlivoRESTError => e
+    puts "Exception: " + e.message
+  end
+
+# Response:
+# {
+#   "api_id": "36989807-a76f-4555-84d1-9dfdccca7a80",
+#   "alias": "test",
+#   "compliance_application_id": "7c83fd87-fb5d-4a88-bde0-7c96da35f1e6",
+#   "compliance_requirement_id": "4ae473b0-f154-41a4-aba8-ab76be12f27f",
+#   "country_iso2": "FR",
+#   "documents": [],
+#   "end_user_id": "f7ba78e0-1d31-4f75-842c-cd2f91334d9f",
+#   "end_user_type": "individual",
+#   "message": "created",
+#   "number_type": "local",
+#   "status": "draft",
+#   "created_at": '2021-02-08T19:32:33.240504+00:00'
+# }

data/lib/plivo/base/resource_interface.rb

@@ -59,6 +59,12 @@ module Plivo
         )
       end
 
+      def perform_submit(identifier, params = nil)
+        valid_param?(:identifier, identifier, [String, Symbol], true)
+        response_json = @_client.send_request(@_resource_uri + identifier.to_s + '/Submit/', 'POST', params, nil, false, is_voice_request: @_is_voice_request)
+        @_resource_type.new(@_client, resource_json: response_json)
+      end
+
       def perform_post(params)
         response_json = @_client.send_request(@_resource_uri, 'POST', params, nil, false, is_voice_request: @_is_voice_request)
 

data/lib/plivo/resources.rb

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

data/lib/plivo/resources/regulatory_compliance.rb

@@ -0,0 +1,610 @@
+module Plivo
+  module Resources
+    include Plivo::Utils
+
+    class EndUser < Base::Resource
+      def initialize(client, options = nil)
+        @_name = 'EndUser'
+        @_identifier_string = 'end_user'
+        super
+      end
+
+      def update(options = nil)
+        return perform_update({}) if options.nil?
+
+        valid_param?(:options, options, Hash, true)
+
+        params = {}
+        params_expected = %i[ name last_name ]
+        params_expected.each do |param|
+          if options.key?(param) &&
+             valid_param?(param, options[param], [String, Symbol], false)
+            params[param] = options[param]
+          end
+        end
+
+        if options.key?(:end_user_type) &&
+          valid_param?(:end_user_type, options[:end_user_type].capitalize,[String, Symbol], false,  %w[Business Individual])
+          params[:end_user_type] = options[:end_user_type].capitalize
+        end
+
+        perform_update(params)
+      end
+
+      def delete
+        perform_delete
+      end
+
+      def to_s
+        {
+          api_id: @api_id,
+          end_user_id: @end_user_id,
+          end_user_type: @end_user_type,
+          name: @name,
+          last_name: @last_name,
+          created_at: @created_at
+        }.delete_if { |key, value| value.nil? }.to_s
+      end
+    end
+
+    class EndUsersInterface < Base::ResourceInterface
+      def initialize(client, resource_list_json = nil)
+        @_name = 'EndUser'
+        @_resource_type = EndUser
+        @_identifier_string = 'end_user'
+        super
+      end
+
+      ##
+      # Get an EndUser
+      # @param [String] end_user_id
+      # return [EndUser]
+      def get(end_user_id)
+        valid_param?(:end_user_id, end_user_id, [String, Symbol], true)
+        perform_get(end_user_id)
+      end
+
+      ##
+      # List all EndUser
+      # @param [Hash] options
+      # @option options [Int] :offset
+      # @option options [Int] :limit
+      # @return [Hash]
+      def list(options = nil)
+        return perform_list if options.nil?
+        valid_param?(:options, options, Hash, true)
+
+        params = {}
+        params_expected = %i[ name last_name ]
+        params_expected.each do |param|
+          if options.key?(param) &&
+             valid_param?(param, options[param], [String, Symbol], false)
+            params[param] = options[param]
+          end
+        end
+
+        if options.key?(:end_user_type) &&
+          valid_param?(:end_user_type, options[:end_user_type].capitalize,[String, Symbol], false,  %w[Business Individual])
+          params[:end_user_type] = options[:end_user_type].capitalize
+        end
+
+        %i[offset limit].each do |param|
+          if options.key?(param) && valid_param?(param, options[param],
+                                                 [Integer], true)
+            params[param] = options[param]
+          end
+        end
+
+        raise_invalid_request("Offset can't be negative") if options.key?(:offset) && options[:offset] < 0
+
+        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
+
+        perform_list(params)
+      end
+
+      ##
+      # Create an EndUser
+      # @param [String] name
+      # @param [String] last_name
+      # @param [String] end_user_type
+      # return [EndUser] EndUser
+      def create(name, last_name = nil , end_user_type)
+        valid_param?(:name, name, [String, Symbol], true)
+        valid_param?(:last_name, last_name, [String, Symbol], false)
+        valid_param?(:end_user_type, end_user_type.capitalize, [String, Symbol], true, %w[Business Individual])
+
+        params = {
+          name: name,
+          last_name: last_name,
+          end_user_type: end_user_type.capitalize
+        }
+
+        return perform_create(params)
+      end
+
+      ##
+      # Update an EndUser
+      # @param [String] end_user_id
+      # @param [Hash] options
+      # return [EndUser]
+      def update(end_user_id, options = nil)
+        valid_param?(:end_user_id, end_user_id, [String, Symbol], true)
+        EndUser.new(@_client,
+                        resource_id: end_user_id).update(options)
+      end
+
+      ##
+      # Delete an EndUser.
+      # @param [String] end_user_id
+      def delete(end_user_id)
+        valid_param?(:end_user_id, end_user_id, [String, Symbol], true)
+        EndUser.new(@_client,
+                        resource_id: end_user_id).delete
+      end
+    end
+
+    class ComplianceDocumentType < Base::Resource
+      def initialize(client, options = nil)
+        @_name = 'ComplianceDocumentType'
+        @_identifier_string = 'compliance_document_type'
+        super
+      end
+
+      def to_s
+        {
+          api_id: @api_id,
+          document_type_id: @document_type_id,
+          document_name: @document_name,
+          description: @description,
+          information: @information,
+          proof_required: @proof_required,
+          created_at: @created_at
+        }.delete_if { |key, value| key==:api_id && value.nil? }.to_s
+      end
+    end
+
+    class ComplianceDocumentTypesInterface < Base::ResourceInterface
+      def initialize(client, resource_list_json = nil)
+        @_name = 'ComplianceDocumentType'
+        @_resource_type = ComplianceDocumentType
+        @_identifier_string = 'compliance_document_type'
+        super
+      end
+
+      # Get a ComplianceDocumentType
+      # @param [String] document_type_id
+      # @return [ComplianceDocumentType] ComplianceDocumentType
+      def get(document_type_id)
+        valid_param?(:document_type_id, document_type_id, [String, Symbol], true)
+        perform_get(document_type_id)
+      end
+
+      ##
+      # List all ComplianceDocumentTypes
+      # @option options [Int] :offset
+      # @option options [Int] :limit
+      # @return [Hash]
+      def list(options = nil)
+        return perform_list if options.nil?
+        valid_param?(:options, options, Hash, false)
+
+        params = {}
+        %i[offset limit].each do |param|
+          if options.key?(param) && valid_param?(param, options[param],
+                                                 [Integer], false)
+            params[param] = options[param]
+          end
+        end
+
+        raise_invalid_request("Offset can't be negative") if options.key?(:offset) && options[:offset] < 0
+
+        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
+
+        perform_list(params)
+      end
+    end
+
+    class ComplianceDocument < Base::Resource
+      def initialize(client, options = nil)
+        @_name = 'ComplianceDocument'
+        @_identifier_string = 'compliance_document'
+        super
+      end
+
+      def delete
+        perform_delete
+      end
+
+      def update(params)
+        perform_update(params, use_multipart_conn: true)
+      end
+
+      def to_s
+        {
+          api_id: @api_id,
+          end_user_id: @end_user_id,
+          document_type_id: @document_type_id,
+          compliance_document_id: @compliance_document_id,
+          document_id: @document_id,
+          alias: @alias,
+          meta_information: @meta_information,
+          file: @file,
+          file_name: @file_name,
+          created_at: @created_at
+        }.delete_if { |key, value| value.nil? }.to_s
+      end
+    end
+  
+    class ComplianceDocumentsInterface < Base::ResourceInterface 
+      def initialize(client, resource_list_json = nil)
+        @_name = 'ComplianceDocument'
+        @_resource_type = ComplianceDocument
+        @_identifier_string = 'compliance_document'
+        super
+      end
+
+      # Get a ComplianceDocument
+      # @param [String] compliance_document_id
+      # @return [ComplianceDocument] ComplianceDocument
+      def get(compliance_document_id)
+        valid_param?(:compliance_document_id, compliance_document_id, [String, Symbol], true)
+        perform_get(compliance_document_id)
+      end
+
+      # List all ComplianceDocuments
+      # @option options [Hash] :options
+      # @option options [Int] :offset
+      # @option options [Int] :limit
+      # @return [Hash]
+      def list(options = nil)
+        return perform_list if options.nil?
+        valid_param?(:options, options, Hash, false)
+
+        params = {}
+
+        params_expected = %i[ end_user_id document_type_id ]
+        params_expected.each do |param|
+          if options.key?(param) &&
+             valid_param?(param, options[param], [String, Symbol], false)
+            params[param] = options[param]
+          end
+        end
+
+        if options.key?(:alias) && valid_param?(:alias, options[:alias],[String, Symbol], false)
+          params[:alias] = options[:alias]
+        end
+
+        %i[offset limit].each do |param|
+          if options.key?(param) && valid_param?(param, options[param],
+                                                 [Integer], true)
+            params[param] = options[param]
+          end
+        end
+
+        raise_invalid_request("Offset can't be negative") if options.key?(:offset) && options[:offset] < 0
+
+        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
+
+        perform_list(params)
+      end
+
+      # Create a ComplianceDocument
+      # @param [String] end_user_id
+      # @param [String] document_type_id
+      # @param [String] alias_
+      # @param [String] file
+      # @param [Hash] options
+      # @return [ComplianceDocument] ComplianceDocument
+      def create(end_user_id: nil , document_type_id: nil, alias_: nil, file: nil, **options)
+        valid_param?(:end_user_id, end_user_id, [String, Symbol], true)
+        valid_param?(:document_type_id, document_type_id, [String, Symbol], true)
+        valid_param?(:alias, :alias_, [String, Symbol], true)
+
+        params = {
+          end_user_id: end_user_id,
+          document_type_id: document_type_id,
+          alias: alias_
+        }
+
+        if !options.nil?
+          valid_param?(:options, options, Hash, false) 
+          options.each do |key, value|
+            if valid_param?(key, value, [String, Symbol], false)
+              params[key] = value
+            end
+          end
+        end
+
+        upload(file, params) if !file.nil?
+
+        perform_create(params, use_multipart_conn: true)
+      end
+
+      # Update a ComplianceDocument
+      # @param [String] compliance_document_id
+      # @param [Hash] options
+      # return [ComplianceDocument] ComplianceDocument
+      def update(compliance_document_id, options = nil)
+        valid_param?(:compliance_document_id, compliance_document_id, [String, Symbol], true)
+        valid_param?(:options, options, Hash, true) if !options.nil?
+        params = {}
+
+        options.each do |key, value|
+          params[key] = value
+        end
+
+        upload(params[:file], params) if params.key?(:file)
+
+        ComplianceDocument.new(@_client, resource_id: compliance_document_id).update(params)
+      end
+
+      # Delete a ComplianceDocument
+      # @param [String] compliance_document_id
+      def delete(compliance_document_id)
+        valid_param?(:compliance_document_id, compliance_document_id, [String, Symbol], true)
+        ComplianceDocument.new(@_client, resource_id: compliance_document_id).delete
+      end
+
+      private
+
+      def upload(filepath, params)
+        file_extension = filepath.split('.')[-1]
+  
+        content_type = case file_extension
+                          when 'jpeg' then 'image/jpeg'
+                          when 'jpg' then 'image/jpeg'
+                          when 'png' then 'image/png'
+                          when 'pdf' then 'application/pdf'
+                          else raise_invalid_request("#{file_extension} is not supported for upload")
+                        end
+  
+        params[:file] = Faraday::UploadIO.new(filepath, content_type)
+      end
+    end
+
+    class ComplianceRequirement < Base::Resource
+      def initialize(client, options = nil)
+        @_name = 'ComplianceRequirement'
+        @_identifier_string = 'compliance_requirement'
+        super
+      end
+
+      def to_s
+        {
+          api_id: @api_id,
+          compliance_requirement_id: @compliance_requirement_id,
+          country_iso2: @country_iso2,
+          number_type: @number_type,
+          end_user_type: @end_user_type,
+          acceptable_document_types: @acceptable_document_types
+        }.delete_if { |key, value| value.nil? }.to_s
+      end
+    end
+  
+    class ComplianceRequirementsInterface < Base::ResourceInterface 
+      def initialize(client, resource_list_json = nil)
+        @_name = 'ComplianceRequirement'
+        @_resource_type = ComplianceRequirement
+        @_identifier_string = 'compliance_requirement'
+        super
+      end
+
+      # Get a ComplianceRequirement
+      # @param [String] compliance_requirement_id
+      # @return [ComplianceRequirement] ComplianceRequirement
+      def get(compliance_requirement_id)
+        valid_param?(:compliance_requirement_id, compliance_requirement_id, [String, Symbol], true)
+        perform_get(compliance_requirement_id)
+      end
+
+      # List all ComplianceRequirements
+      # @option options [String] :country_iso2
+      # @option options [String] :number_type
+      # @option options [String] :phone_number
+      # @option options [String] :end_user_type
+      # A combination of country_iso2, number_type, end_user_type OR
+      # phone_number, end_user_type can be used to fetch compliance requirements.
+      def list(options = nil)
+        valid_param?(:options, options, Hash, true)
+
+        params = {}
+        params_expected = %i[ country_iso2 number_type phone_number ]
+        params_expected.each do |param|
+          if options.key?(param) &&
+             valid_param?(param, options[param], [String, Symbol], false)
+            params[param] = options[param]
+          end
+        end
+
+        if options.key?(:end_user_type) &&
+          valid_param?(:end_user_type, options[:end_user_type].capitalize, [String, Symbol], false, %w[Business Individual])
+          params[:end_user_type] = options[:end_user_type].capitalize
+        end
+
+        perform_get_without_identifier(params)
+      end
+    end
+
+    class ComplianceApplication < Base::Resource
+      def initialize(client, options = nil)
+        @_name = 'ComplianceApplication'
+        @_identifier_string = 'compliance_application'
+        super
+      end
+
+      def to_s
+        {
+          api_id: @api_id,
+          created_at: @created_at,
+          compliance_application_id: @compliance_application_id,
+          alias: @alias,
+          status: @status,
+          end_user_id: @end_user_id,
+          end_user_type: @end_user_type,
+          country_iso2: @country_iso2,
+          number_type: @number_type,
+          compliance_requirement_id: @compliance_requirement_id,
+          documents: @documents,
+        }.delete_if { |key, value| value.nil? }.to_s
+      end
+
+      def update(params)
+        perform_update(params)
+      end
+
+      def delete
+        perform_delete
+      end
+    end
+  
+    class ComplianceApplicationsInterface < Base::ResourceInterface 
+      def initialize(client, resource_list_json = nil)
+        @_name = 'ComplianceApplication'
+        @_resource_type = ComplianceApplication
+        @_identifier_string = 'compliance_application'
+        super
+      end
+
+      # Get a ComplianceApplication
+      # @param [String] compliance_application_id
+      # @return [ComplianceApplication] ComplianceApplication
+      def get(compliance_application_id)
+        valid_param?(:compliance_application_id, compliance_application_id, [String, Symbol], true)
+        perform_get(compliance_application_id)
+      end
+
+      # List all ComplianceApplications
+      # @option options [Hash] :options
+      # @option options [Int] :offset
+      # @option options [Int] :limit
+      # @return [Hash]
+      def list(options = nil)
+        return perform_list if options.nil?
+        valid_param?(:options, options, Hash, true)
+
+        params = {}
+        params_expected = %i[  end_user_id country_iso2 number_type status ]
+        params_expected.each do |param|
+          if options.key?(param) &&
+             valid_param?(param, options[param], [String, Symbol], false)
+            params[param] = options[param]
+          end
+        end
+
+        if options.key?(:end_user_type) &&
+          valid_param?(:end_user_type, options[:end_user_type].capitalize, [String, Symbol], false, %w[Business Individual])
+          params[:end_user_type] = options[:end_user_type].capitalize
+        end
+
+        if options.key?(:alias) && valid_param?(:alias, options[:alias],[String, Symbol], false)
+          params[:alias] = options[:alias]
+        end
+
+        %i[offset limit].each do |param|
+          if options.key?(param) && valid_param?(param, options[param],
+                                                 [Integer], true)
+            params[param] = options[param]
+          end
+        end
+
+        raise_invalid_request("Offset can't be negative") if options.key?(:offset) && options[:offset] < 0
+
+        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
+
+        perform_list(params)
+      end
+
+      # Create a ComplianceApplication
+      # @param [String] compliance_requirement_id
+      # @param [String] end_user_id
+      # @param [String] alias_
+      # @param [Array] document_ids
+      # @param [String] end_user_type
+      # @param [String] country_iso2
+      # @param [String] number_type
+      # @return [ComplianceApplication] ComplianceApplication
+      def create(compliance_requirement_id: nil, end_user_id: nil, alias_: nil,
+        document_ids: nil,
+        end_user_type: nil,
+        country_iso2: nil,
+        number_type: nil
+        )
+        valid_param?(:compliance_requirement_id, compliance_requirement_id, [String, Symbol], false)
+        valid_param?(:end_user_id, end_user_id, [String, Symbol], false)
+        valid_param?(:alias_, alias_, [String, Symbol], false)
+        valid_param?(:country_iso2, country_iso2, [String, Symbol], false)
+        valid_param?(:number_type, number_type, [String, Symbol], false)
+        valid_param?(:document_ids, document_ids, [Array], false)
+        if !document_ids.nil?
+          document_ids.each do |document_id|
+            valid_param?(:document_id, document_id, [String, Symbol], true)
+          end
+        end
+
+        if !end_user_type.nil?
+          end_user_type = end_user_type.downcase
+          valid_param?(:end_user_type, end_user_type, [String, Symbol], false, %w[business individual])
+        end
+
+        params = {
+          compliance_requirement_id: compliance_requirement_id,
+          end_user_id: end_user_id,
+          end_user_type: end_user_type,
+          country_iso2: country_iso2,
+          number_type: number_type,
+          document_ids: document_ids,
+          alias: alias_
+        }.delete_if { |key, value| value.nil? }
+
+        perform_create(params, false)
+      end
+
+      # Update a ComplianceApplication
+      # @param [String] compliance_application_id
+      # @param [Array] document_ids
+      # @return [ComplianceApplication] ComplianceApplication
+      def update(compliance_application_id, document_ids)
+        valid_param?(:compliance_application_id, compliance_application_id, [String, Symbol], true)
+        valid_param?(:document_ids, document_ids, [Array], true)
+        document_ids.each do |document_id|
+          valid_param?(:document_id, document_id, [String, Symbol], true)
+        end
+
+        params = {
+          compliance_application_id: compliance_application_id,
+          document_ids: document_ids
+        }
+
+        ComplianceApplication.new(@_client,
+                        resource_id: compliance_application_id).update(params)
+      end
+
+      # Delete a ComplianceApplication
+      # @param [String] compliance_application_id
+      def delete(compliance_application_id)
+        valid_param?(:compliance_application_id, compliance_application_id, [String, Symbol], true)
+        ComplianceApplication.new(@_client,
+                        resource_id: compliance_application_id).delete
+      end
+
+      # Submit a ComplianceApplication
+      # @param [String] compliance_application_id
+      def submit(compliance_application_id)
+        valid_param?(:compliance_application_id, compliance_application_id, [String, Symbol], true)
+        perform_submit(compliance_application_id)
+      end
+    end
+  end
+end

data/lib/plivo/rest_client.rb

@@ -14,6 +14,8 @@ module Plivo
     attr_reader :powerpacks
     attr_reader :powerpacks, :media
     attr_reader :lookup
+    attr_reader :end_users
+    attr_reader :compliance_document_types, :compliance_documents, :compliance_requirements, :compliance_applications
 
     def initialize(auth_id = nil, auth_token = nil, proxy_options = nil, timeout = 5)
       configure_base_uri
@@ -50,6 +52,11 @@ module Plivo
       @identities = Resources::IdentityInterface.new(self)
       @call_feedback = Resources::CallFeedbackInterface.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)
     end
   end
 end

data/lib/plivo/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plivo
 version: !ruby/object:Gem::Version
-  version: 4.15.2
+  version: 4.16.0
 platform: ruby
 authors:
 - The Plivo SDKs Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-27 00:00:00.000000000 Z
+date: 2021-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -168,6 +168,7 @@ files:
 - examples/lookup.rb
 - examples/multi_party_call.rb
 - examples/phlos.rb
+- examples/regulatory_compliance.rb
 - lib/plivo.rb
 - lib/plivo/base.rb
 - lib/plivo/base/resource.rb
@@ -196,6 +197,7 @@ files:
 - lib/plivo/resources/powerpacks.rb
 - lib/plivo/resources/pricings.rb
 - lib/plivo/resources/recordings.rb
+- lib/plivo/resources/regulatory_compliance.rb
 - lib/plivo/rest_client.rb
 - lib/plivo/utils.rb
 - lib/plivo/version.rb