plivo 4.0.0 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 67ddbbf4767cb809f1a3de1c2a7a541b5f317771
-  data.tar.gz: 44f588880a060279674f01610df4844bf4162a4b
+  metadata.gz: f175349919f9673146aa1ff209cb04f858fb7b3d
+  data.tar.gz: 70f9007164e621fbd5a907a65fe9c9473982a8a8
 SHA512:
-  metadata.gz: 9607c564e67682986ac75cf192b30feb1c2d3d3d4c0206717f19b44515908c9a0e752ea0d9125ab4c0ddb5b8425ac72c63a1390806b3c12d0fcd62dbfa2b6d51
-  data.tar.gz: 17b9f7ea9874dcaeb535483246722128d3b4fadff0f6571fec1527695ce25e0b0bd88691cf9b5bcb2d9d467e07fd75c5aabf66586415e2232473d05d346711b9
+  metadata.gz: 7e62b19ef47a2a306e05a75a4acf531dacf7259dd1a92bebc2e4e97322fcf6892891490e860898a06e5163e8ee1748dd9fc9f575ba7fb5cb271867d5599ae66b
+  data.tar.gz: f56366f71dea549499326685b43aabeff5730db7a157b862b52c7cfa78ebc7d64c89422685e3541f57f66c971cb5524378981d6bc5d832b4c9d80c871b8f5cd8

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Change Log
 
+## [4.1.0](https://github.com/plivo/plivo-ruby/releases/tag/v4.1.0) (2018-02-26)
+- Add Address and Identity resources
+- Change a few functions in number-related methods to support the verification flows
+
 ## [4.0.0](https://github.com/plivo/plivo-ruby/releases/tag/v4.0.0) (2018-01-18)
 - Now supports timeout & proxy (in a non-deprecated way) settings
 - A bug fixed (#55)

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

data/lib/plivo/base/resource.rb

@@ -50,13 +50,13 @@ module Plivo
         @id = resource_json[@_identifier_string]
       end
 
-      def perform_update(params)
+      def perform_update(params, use_multipart_conn = false)
         unless @id
           raise_invalid_request("Cannot update a #{@_name} resource "\
           'without an identifier')
         end
 
-        response_json = @_client.send_request(@_resource_uri, 'POST', params)
+        response_json = @_client.send_request(@_resource_uri, 'POST', params, nil, use_multipart_conn)
 
         parse_and_set(params)
         parse_and_set(response_json)

data/lib/plivo/base/resource_interface.rb

@@ -51,9 +51,9 @@ module Plivo
         @_resource_type.new(@_client, resource_json: response_json)
       end
 
-      def perform_create(params)
+      def perform_create(params, use_multipart_conn=false)
         Response.new(
-          @_client.send_request(@_resource_uri, 'POST', params),
+          @_client.send_request(@_resource_uri, 'POST', params, nil, use_multipart_conn),
           @_identifier_string
         )
       end

data/lib/plivo/resources.rb

@@ -7,6 +7,8 @@ require_relative 'resources/numbers'
 require_relative 'resources/conferences'
 require_relative 'resources/calls'
 require_relative 'resources/endpoints'
+require_relative 'resources/addresses'
+require_relative 'resources/identities'
 
 module Plivo
   module Resources

data/lib/plivo/resources/addresses.rb

@@ -0,0 +1,302 @@
+module Plivo
+  module Resources
+    include Plivo::Utils
+    class Address < Base::Resource
+
+      def initialize(client, options = nil)
+        @_name = 'Verification/Address'
+        @_identifier_string = 'id'
+        super
+      end
+
+      def delete
+        perform_delete
+      end
+
+      ##
+      # Update an address
+      # @param [String] file_to_upload
+      # @param [Hash] options
+      # @option options [String] :salutation - One of Mr or Ms
+      # @option options [String] :first_name - First name of the user for whom the address is created
+      # @option options [String] :last_name - Last name of the user for whom the address is created
+      # @option options [String] :country_iso - Country ISO 2 code
+      # @option options [String] :address_line1 - Building name/number
+      # @option options [String] :address_line2 - The street name/number of the address
+      # @option options [String] :city - The city of the address for which the address proof is created
+      # @option options [String] :region - The region of the address for which the address proof is created
+      # @option options [String] :postal_code - The postal code of the address that is being created
+      # @option options [String] :alias - Alias name of the address
+      # @option options [String] :auto_correct_address - If set to true, the address will be auto-corrected by the system if necessary. The param needs to be set to false explicitly so that it is not auto-corrected.
+      # @option options [String] :callback_url - The callback URL that gets the result of address creation POSTed to.
+      # @return [Address] Address
+      def update(file_to_upload = nil, options = nil)
+        params = {}
+
+        unless options.nil?
+          %i[salutation first_name last_name country_iso address_line1 address_line2 city region postal_code alias callback_url]
+              .each do |param|
+            if options.key?(param) &&
+                valid_param?(param, options[param], [String, Symbol], true)
+              params[param] = options[param]
+            end
+          end
+
+          %i[auto_correct_address]
+              .each do |param|
+            if options.key?(param) &&
+                valid_param?(param, options[param], nil, true, [true, false])
+              params[param] = options[param]
+            end
+          end
+        end
+
+        unless file_to_upload.nil?
+          file_extension = file_to_upload.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 yet supported for upload")
+                         end
+
+          params[:file] = Faraday::UploadIO.new(file_to_upload, content_type)
+        end
+
+        return perform_update(params, true)
+      end
+
+      def to_s
+        {
+          account: @account,
+          address_line1: @address_line1,
+          address_line2: @address_line2,
+          alias: @alias,
+          api_id: @api_id,
+          city: @city,
+          country_iso: @country_iso,
+          document_details: @document_details,
+          first_name: @first_name,
+          id: @id,
+          last_name: @last_name,
+          postal_code: @postal_code,
+          region: @region,
+          salutation: @salutation,
+          subaccount: @subaccount,
+          url: @url,
+          validation_status: @validation_status,
+          verification_status: @verification_status
+        }.to_s
+      end
+    end
+
+    class AddressInterface < Base::ResourceInterface
+      def initialize(client, resource_list_json = nil)
+        @_name = 'Verification/Address'
+        @_resource_type = Address
+        @_identifier_string = 'id'
+        super
+      end
+
+      ##
+      # Get an address
+      # @param [String] address_id
+      # @return [Address] Address
+      def get(address_id)
+        valid_param?(:address_id, address_id, [String, Symbol], true)
+        perform_get(address_id)
+      end
+
+      ##
+      # List all addresses
+      # @param [Hash] options
+      # @option options [String] :country_iso - Country ISO 2 code
+      # @option options [String] :customer_name - Name of the customer or business that is mentioned in the address
+      # @option options [String] :alias - Friendly name of the id proof
+      # @option options [String] :verification_status - The status of the address: pending. accepted, rejected, null
+      # @option options [String] :validation_status - The status of the address: pending. accepted, rejected, null
+      # @option options [Int] :offset
+      # @option options [Int] :limit
+      # @return [Hash]
+      def list(options=nil)
+        return perform_list if options.nil?
+
+        params = {}
+
+        %i[country_iso customer_name alias].each do |param|
+          if options.key?(param) && valid_param?(param, options[param],
+                                                 [String, Symbol], true)
+            params[param] = options[param]
+          end
+        end
+
+        %i[verification_status validation_status].each do |param|
+          if options.key?(param) && valid_param?(param, options[param],
+                                                 [String, Symbol], true, ['pending', 'accepted', 'rejected',
+                                                                          :pending, :accepted, :rejected])
+            params[param] = options[param]
+          end
+        end
+
+        %i[offset limit].each do |param|
+          if options.key?(param) && valid_param?(param, options[param],
+                                                 [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
+
+        if options.key?(:offset) && options[:offset] < 0
+          raise_invalid_request("Offset can't be negative")
+        end
+
+        perform_list(params)
+      end
+
+      ##
+      # Create a new address
+      # @param [String] country_iso
+      # @param [String] salutation
+      # @param [String] first_name
+      # @param [String] last_name
+      # @param [String] address_line1
+      # @param [String] address_line2
+      # @param [String] city
+      # @param [String] region
+      # @param [String] postal_code
+      # @param [String] address_proof_type
+      # @param [String] file_to_upload
+      # @param [Hash] options
+      # @option options [String] :alias - Alias name of the address
+      # @option options [String] :auto_correct_address - If set to true, the address will be auto-corrected by the system if necessary. The param needs to be set to false explicitly so that it is not auto-corrected.
+      # @option options [String] :fiscal_identification_code - The code is valid for businesses alone
+      # @option options [String] :street_code - Street code of the address
+      # @option options [String] :municipal_code - Municipal code of the address
+      # @option options [String] :callback_url - The callback URL that gets the result of address creation POSTed to.
+      # @return [Address] Address
+      def create(country_iso, salutation, first_name, last_name, address_line1, address_line2, city, region,
+                 postal_code, address_proof_type, file_to_upload=nil, options=nil)
+        valid_param?(:country_iso, country_iso, [String, Symbol], true)
+        valid_param?(:salutation, salutation, [String, Symbol], true, ['Mr', 'Ms', :Ms, :Mr])
+        valid_param?(:first_name, first_name, [String, Symbol], true)
+        valid_param?(:last_name, last_name, [String, Symbol], true)
+        valid_param?(:address_line1, address_line1, [String, Symbol], true)
+        valid_param?(:address_line2, address_line2, [String, Symbol], true)
+        valid_param?(:city, city, [String, Symbol], true)
+        valid_param?(:region, region, [String, Symbol], true)
+        valid_param?(:postal_code, postal_code, [String, Symbol], true)
+        valid_param?(:address_proof_type,
+                     address_proof_type,
+                     [String, Symbol], true,
+                     ['national_id', 'passport', 'business_id', 'NIF', 'NIE', 'DNI', 'others',
+                      :national_id, :passport, :business_id, :NIF, :NIE, :DNI, :others])
+
+        params = {
+          country_iso: country_iso,
+          salutation: salutation,
+          first_name: first_name,
+          last_name: last_name,
+          address_line1: address_line1,
+          address_line2: address_line2,
+          city: city,
+          region: region,
+          postal_code: postal_code,
+          address_proof_type: address_proof_type
+        }
+
+        if country_iso == 'ES'
+          valid_param?(:fiscal_identification_code, options[:fiscal_identification_code], [String, Symbol], true)
+          params[:fiscal_identification_code] = options[:fiscal_identification_code]
+        end
+
+        if country_iso == 'DK'
+          valid_param?(:street_code, options[:street_code], [String, Symbol], true)
+          valid_param?(:municipal_code, options[:municipal_code], [String, Symbol], true)
+
+          params[:street_code] = options[:street_code]
+          params[:municipal_code] = options[:municipal_code]
+        end
+
+        unless file_to_upload.nil?
+          file_extension = file_to_upload.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 yet supported for upload")
+                         end
+
+          params[:file] = Faraday::UploadIO.new(file_to_upload, content_type)
+        end
+
+        %i[alias fiscal_identification_code street_code municipal_code callback_url]
+            .each do |param|
+          if options.key?(param) &&
+              valid_param?(param, options[param], [String, Symbol], true)
+            params[param] = options[param]
+          end
+        end
+
+        %i[auto_correct_address]
+            .each do |param|
+          if options.key?(param) &&
+              valid_param?(param, options[param], nil, true, [true, false])
+            params[param] = options[param]
+          end
+        end
+
+        perform_create(params, true)
+      end
+
+      ##
+      # Update an address
+      # @param [String] address_id
+      # @param [String] file_to_upload
+      # @param [Hash] options
+      # @option options [String] :salutation - One of Mr or Ms
+      # @option options [String] :first_name - First name of the user for whom the address is created
+      # @option options [String] :last_name - Last name of the user for whom the address is created
+      # @option options [String] :country_iso - Country ISO 2 code
+      # @option options [String] :address_line1 - Building name/number
+      # @option options [String] :address_line2 - The street name/number of the address
+      # @option options [String] :city - The city of the address for which the address proof is created
+      # @option options [String] :region - The region of the address for which the address proof is created
+      # @option options [String] :postal_code - The postal code of the address that is being created
+      # @option options [String] :alias - Alias name of the address
+      # @option options [String] :auto_correct_address - If set to true, the address will be auto-corrected by the system if necessary. The param needs to be set to false explicitly so that it is not auto-corrected.
+      # @option options [String] :callback_url - The callback URL that gets the result of address creation POSTed to.
+      # @return [Address] Address
+      def update(address_id, file_to_upload=nil, options=nil)
+        Address.new(@_client,
+                        resource_id: address_id).update(file_to_upload, options)
+      end
+
+      ##
+      # Delete an address
+      # @param [String] address_id
+      def delete(address_id)
+        valid_param?(:address_id, address_id, [String, Symbol], true)
+        Address.new(@_client,
+                     resource_id: address_id).delete
+      end
+
+      def each
+        offset = 0
+        loop do
+          address_list = list(offset: offset)
+          address_list[:objects].each { |address| yield address }
+          offset += 20
+          return unless address_list.length == 20
+        end
+      end
+    end
+  end
+end

data/lib/plivo/resources/calls.rb

@@ -210,6 +210,7 @@ module Plivo
           billed_duration: @billed_duration,
           call_direction: @call_direction,
           call_duration: @call_duration,
+          call_status: @call_status,
           call_uuid: @call_uuid,
           end_time: @end_time,
           from_number: @from_number,

data/lib/plivo/resources/identities.rb

@@ -0,0 +1,319 @@
+module Plivo
+  module Resources
+    include Plivo::Utils
+    class Identity < Base::Resource
+
+      def initialize(client, options = nil)
+        @_name = 'Verification/Identity'
+        @_identifier_string = 'id'
+        super
+      end
+
+      def delete
+        perform_delete
+      end
+
+      # Update an identity
+      # @param [String] identity_id
+      # @param [String] file_to_upload
+      # @param [Hash] options
+      # @option options [String] :salutation - One of Mr or Ms
+      # @option options [String] :first_name - First name of the user for whom the identity is created
+      # @option options [String] :last_name - Last name of the user for whom the identity is created
+      # @option options [String] :country_iso - Country ISO 2 code
+      # @option options [String] :birth_place - Birthplace of the user for whom the identity is created
+      # @option options [String] :birth_date - Birth date in yyyy-mm-dd format of the user for whom the identity is created
+      # @option options [String] :nationality - Nationality of the user for whom the identity is created
+      # @option options [String] :id_nationality - Nationality mentioned in the identity proof
+      # @option options [String] :id_issue_date - Issue date in yyyy-mm-dd mentioned in the identity proof
+      # @option options [String] :id_type -
+      # @option options [String] :id_number - The unique number on the identifier
+      # @option options [String] :address_line1 - Building name/number
+      # @option options [String] :address_line2 - The street name/number of the address
+      # @option options [String] :city - The city of the address for which the address proof is created
+      # @option options [String] :region - The region of the address for which the address proof is created
+      # @option options [String] :postal_code - The postal code of the address that is being created
+      # @option options [String] :alias - Alias name of the identity
+      # @option options [String] :business_name - Business name of the user for whom the identity is created.
+      # @option options [String] :auto_correct_address - If set to true, the address will be auto-corrected by the system if necessary. The param needs to be set to false explicitly so that it is not auto-corrected.
+      # @option options [String] :fiscal_identification_code - The code is valid for businesses alone
+      # @option options [String] :street_code - Street code of the address
+      # @option options [String] :municipal_code - Municipal code of the address
+      # @option options [String] :callback_url - The callback URL that gets the result of identity creation POSTed to.
+      # @option options [String] :subaccount - The link to the subaccount resource associated with the application. If the application belongs to the main account, this field will be null.
+      # @return [Identity] Identity
+      def update(file_to_upload = nil, options = nil)
+        params = {}
+
+        unless options.nil?
+          %i[salutation first_name last_name country_iso birth_place birth_date nationality id_nationality id_issue_date
+             id_type id_number address_line1 address_line2 city region postal_code alias business_name
+             fiscal_identification_code street_code municipal_code callback_url subaccount
+            ]
+              .each do |param|
+            if options.key?(param) &&
+                valid_param?(param, options[param], [String, Symbol], true)
+              params[param] = options[param]
+            end
+          end
+
+          %i[auto_correct_address]
+              .each do |param|
+            if options.key?(param) &&
+                valid_param?(param, options[param], nil, true, [true, false])
+              params[param] = options[param]
+            end
+          end
+        end
+
+        unless file_to_upload.nil?
+          file_extension = file_to_upload.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 yet supported for upload")
+                         end
+
+          params[:file] = Faraday::UploadIO.new(file_to_upload, content_type)
+        end
+
+        return perform_update(params, true)
+      end
+
+      def to_s
+        {
+          account: @account,
+          alias: @alias,
+          api_id: @api_id,
+          country_iso: @country_iso,
+          document_details: @document_details,
+          first_name: @first_name,
+          id: @id,
+          id_number: @id_number,
+          id_type: @id_type,
+          last_name: @last_name,
+          nationality: @nationality,
+          salutation: @salutation,
+          subaccount: @subaccount,
+          url: @url,
+          validation_status: @validation_status,
+          verification_status: @verification_status
+        }.to_s
+      end
+    end
+
+    class IdentityInterface < Base::ResourceInterface
+      def initialize(client, resource_list_json = nil)
+        @_name = 'Verification/Identity'
+        @_resource_type = Identity
+        @_identifier_string = 'id'
+        super
+      end
+
+      ##
+      # Get an identity
+      # @param [String] identity_id
+      # @return [Identity] Identity
+      def get(identity_id)
+        valid_param?(:identity_id, identity_id, [String, Symbol], true)
+        perform_get(identity_id)
+      end
+
+      ##
+      # List all identities
+      # @param [Hash] options
+      # @option options [String] :country_iso - Country ISO 2 code
+      # @option options [String] :customer_name - Name of the customer or business that is mentioned in the identity
+      # @option options [String] :alias - Friendly name of the id proof
+      # @option options [String] :verification_status - The status of the identity: pending. accepted, rejected, null
+      # @option options [Int] :offset
+      # @option options [Int] :limit
+      # @return [Hash]
+      def list(options=nil)
+        return perform_list if options.nil?
+
+        params = {}
+
+        %i[country_iso customer_name alias].each do |param|
+          if options.key?(param) && valid_param?(param, options[param],
+                                                 [String, Symbol], true)
+            params[param] = options[param]
+          end
+        end
+
+        %i[verification_status].each do |param|
+          if options.key?(param) && valid_param?(param, options[param],
+                                                 [String, Symbol], true, ['pending', 'accepted', 'rejected',
+                                                                          :pending, :accepted, :rejected])
+            params[param] = options[param]
+          end
+        end
+
+        %i[offset limit].each do |param|
+          if options.key?(param) && valid_param?(param, options[param],
+                                                 [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
+
+        if options.key?(:offset) && options[:offset] < 0
+          raise_invalid_request("Offset can't be negative")
+        end
+
+        perform_list(params)
+      end
+
+      ##
+      # Create a new identity
+      # @param [String] country_iso
+      # @param [String] salutation
+      # @param [String] first_name
+      # @param [String] last_name
+      # @param [String] birth_place
+      # @param [String] birth_date
+      # @param [String] nationality
+      # @param [String] id_nationality
+      # @param [String] id_issue_date
+      # @param [String] id_type
+      # @param [String] id_number
+      # @param [String] address_line1
+      # @param [String] address_line2
+      # @param [String] city
+      # @param [String] region
+      # @param [String] postal_code
+      # @param [String] file_to_upload
+      # @param [Hash] options
+      # @option options [String] :alias - Alias name of the identity
+      # @option options [String] :business_name - Business name of the user for whom the identity is created.
+      # @option options [String] :auto_correct_address - If set to true, the address will be auto-corrected by the system if necessary. The param needs to be set to false explicitly so that it is not auto-corrected.
+      # @option options [String] :fiscal_identification_code - The code is valid for businesses alone
+      # @option options [String] :street_code - Street code of the address
+      # @option options [String] :municipal_code - Municipal code of the address
+      # @option options [String] :callback_url - The callback URL that gets the result of identity creation POSTed to.
+      # @option options [String] :subaccount - The link to the subaccount resource associated with the application. If the application belongs to the main account, this field will be null.
+      # @return [Identity] Identity
+      def create(country_iso, salutation, first_name, last_name, birth_place, birth_date, nationality,
+                 id_nationality, id_issue_date, id_type, id_number, address_line1, address_line2,
+                 city, region, postal_code, file_to_upload=nil, options=nil)
+        valid_param?(:country_iso, country_iso, [String, Symbol], true)
+        valid_param?(:salutation, salutation, [String, Symbol], true, ['Mr', 'Ms', :Ms, :Mr])
+        valid_param?(:first_name, first_name, [String, Symbol], true)
+        valid_param?(:last_name, last_name, [String, Symbol], true)
+        valid_param?(:birth_place, birth_place, [String, Symbol], true)
+        valid_param?(:birth_date, birth_date, [String, Symbol], true)
+        valid_param?(:nationality, nationality, [String, Symbol], true)
+        valid_param?(:id_nationality, id_nationality, [String, Symbol], true)
+        valid_param?(:id_issue_date, id_issue_date, [String, Symbol], true)
+        valid_param?(:id_type, id_type, [String, Symbol], true)
+        valid_param?(:id_number, id_number, [String, Symbol], true)
+        valid_param?(:address_line1, address_line1, [String, Symbol], true)
+        valid_param?(:address_line2, address_line2, [String, Symbol], true)
+        valid_param?(:city, city, [String, Symbol], true)
+        valid_param?(:region, region, [String, Symbol], true)
+        valid_param?(:postal_code, postal_code, [String, Symbol], true)
+
+        params = {
+            country_iso: country_iso,
+            salutation: salutation,
+            first_name: first_name,
+            last_name: last_name,
+            birth_place: birth_place,
+            birth_date: birth_date,
+            nationality: nationality,
+            id_nationality: id_nationality,
+            id_issue_date: id_issue_date,
+            id_type: id_type,
+            id_number: id_number,
+            address_line1: address_line1,
+            address_line2: address_line2,
+            city: city,
+            region: region,
+            postal_code: postal_code
+        }
+
+        unless file_to_upload.nil?
+          file_extension = file_to_upload.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 yet supported for upload")
+                         end
+
+          params[:file] = Faraday::UploadIO.new(file_to_upload, content_type)
+        end
+
+        %i[alias business_name fiscal_identification_code street_code municipal_code callback_url subaccount]
+            .each do |param|
+          if options.key?(param) &&
+              valid_param?(param, options[param], [String, Symbol], true)
+            params[param] = options[param]
+          end
+        end
+
+        %i[auto_correct_address]
+            .each do |param|
+          if options.key?(param) &&
+              valid_param?(param, options[param], nil, true, [true, false])
+            params[param] = options[param]
+          end
+        end
+
+        perform_create(params, true)
+      end
+
+      # Update an identity
+      # @param [String] identity_id
+      # @param [String] file_to_upload
+      # @param [Hash] options
+      # @option options [String] :salutation - One of Mr or Ms
+      # @option options [String] :first_name - First name of the user for whom the identity is created
+      # @option options [String] :last_name - Last name of the user for whom the identity is created
+      # @option options [String] :country_iso - Country ISO 2 code
+      # @option options [String] :birth_place - Birthplace of the user for whom the identity is created
+      # @option options [String] :birth_date - Birth date in yyyy-mm-dd format of the user for whom the identity is created
+      # @option options [String] :nationality - Nationality of the user for whom the identity is created
+      # @option options [String] :id_nationality - Nationality mentioned in the identity proof
+      # @option options [String] :id_issue_date - Issue date in yyyy-mm-dd mentioned in the identity proof
+      # @option options [String] :id_type -
+      # @option options [String] :id_number - The unique number on the identifier
+      # @option options [String] :address_line1 - Building name/number
+      # @option options [String] :address_line2 - The street name/number of the address
+      # @option options [String] :city - The city of the address for which the address proof is created
+      # @option options [String] :region - The region of the address for which the address proof is created
+      # @option options [String] :postal_code - The postal code of the address that is being created
+      # @option options [String] :alias - Alias name of the identity
+      # @option options [String] :business_name - Business name of the user for whom the identity is created.
+      # @option options [String] :auto_correct_address - If set to true, the address will be auto-corrected by the system if necessary. The param needs to be set to false explicitly so that it is not auto-corrected.
+      # @option options [String] :fiscal_identification_code - The code is valid for businesses alone
+      # @option options [String] :street_code - Street code of the address
+      # @option options [String] :municipal_code - Municipal code of the address
+      # @option options [String] :callback_url - The callback URL that gets the result of identity creation POSTed to.
+      # @option options [String] :subaccount - The link to the subaccount resource associated with the application. If the application belongs to the main account, this field will be null.
+      # @return [Identity] Identity
+      def update(identity_id, file_to_upload=nil, options=nil)
+        Identity.new(@_client,
+                    resource_id: identity_id).update(file_to_upload, options)
+      end
+
+      ##
+      # Delete an identity
+      # @param [String] identity_id
+      def delete(identity_id)
+        valid_param?(:identity_id, identity_id, [String, Symbol], true)
+        Identity.new(@_client,
+                    resource_id: identity_id).delete
+      end
+    end
+  end
+end

data/lib/plivo/resources/numbers.rb

@@ -9,9 +9,10 @@ module Plivo
         super
       end
 
-      def buy(app_id = nil)
+      def buy(app_id = nil, verification_info = nil)
         params = {}
         params[:app_id] = app_id unless app_id.nil?
+        params[:verification_info] = verification_info unless verification_info.nil?
         perform_action(nil, 'POST', params, true)
       end
 
@@ -58,6 +59,7 @@ module Plivo
       #                                    - By default, numbers that have either voice or sms or both enabled are returned.
       # @option options [String] :lata Numbers can be searched using Local Access and Transport Area {http://en.wikipedia.org/wiki/Local_access_and_transport_area}. This filter is applicable only for country_iso US and CA.
       # @option options [String] :rate_center Numbers can be searched using Rate Center {http://en.wikipedia.org/wiki/Telephone_exchange}. This filter is application only for country_iso US and CA.
+      # @option options [Boolean] :eligible If set to true, lists only those numbers that you are eligible to buy at the moment. To list all numbers, ignore this option.
       # @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.
       def search(country_iso, options = nil)
@@ -83,6 +85,13 @@ module Plivo
           end
         end
 
+        %i[eligible].each do |param|
+          if options.key?(param) && valid_param?(param, options[param],
+                                                 nil, true, [true, false])
+            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")
@@ -105,10 +114,10 @@ module Plivo
         end
       end
 
-      def buy(number, app_id = nil)
+      def buy(number, app_id = nil, verification_info = nil)
         valid_param?(:number, number, [Integer, String, Symbol], true)
         PhoneNumber.new(@_client,
-                        resource_id: number).buy(app_id)
+                        resource_id: number).buy(app_id, verification_info)
       end
     end
 
@@ -136,6 +145,13 @@ module Plivo
           end
         end
 
+        %i[verification_info].each do |param|
+          if options.key?(param) &&
+              valid_param?(param, options[param], Hash, true)
+            params[param] = options[param]
+          end
+        end
+
         perform_update(params)
       end
 

data/lib/plivo/rest_client.rb

@@ -18,6 +18,7 @@ module Plivo
     attr_reader :messages, :account, :subaccounts, :recordings
     attr_reader :pricings, :numbers, :calls, :conferences
     attr_reader :phone_numbers, :applications, :endpoints
+    attr_reader :addresses, :identities
 
     def initialize(auth_id = nil, auth_token = nil, proxy_options = nil, timeout=5)
       configure_credentials(auth_id, auth_token)
@@ -46,12 +47,12 @@ module Plivo
       response[:body]
     end
 
-    def send_request(resource_path, method = 'GET', data = {}, timeout = nil)
+    def send_request(resource_path, method = 'GET', data = {}, timeout = nil, use_multipart_conn = false)
       timeout ||= @timeout
 
       response = case method
                  when 'GET' then send_get(resource_path, data, timeout)
-                 when 'POST' then send_post(resource_path, data, timeout)
+                 when 'POST' then send_post(resource_path, data, timeout, use_multipart_conn)
                  when 'DELETE' then send_delete(resource_path, timeout)
                  else raise_invalid_request("#{method} not supported by Plivo, yet")
                  end
@@ -121,6 +122,8 @@ module Plivo
       @calls = Resources::CallInterface.new(self)
       @endpoints = Resources::EndpointInterface.new(self)
       @applications = Resources::ApplicationInterface.new(self)
+      @addresses = Resources::AddressInterface.new(self)
+      @identities = Resources::IdentityInterface.new(self)
     end
 
     def configure_connection
@@ -146,11 +149,37 @@ module Plivo
       response
     end
 
-    def send_post(resource_path, data, timeout)
-      response = @conn.post do |req|
-        req.url resource_path
-        req.options.timeout = timeout if timeout
-        req.body = JSON.generate(data) if data
+    def send_post(resource_path, data, timeout, use_multipart_conn)
+      if use_multipart_conn
+        multipart_conn = Faraday.new(Base::PLIVO_API_URL) do |faraday|
+          faraday.headers = {
+            'User-Agent' => @headers['User-Agent'],
+            'Accept' => @headers['Accept']
+          }
+
+          # DANGER: Basic auth should always come after headers, else
+          # The headers will replace the basic_auth
+
+          faraday.request :multipart
+          faraday.request :url_encoded
+          faraday.basic_auth(auth_id, auth_token)
+
+          faraday.proxy=@proxy_hash if @proxy_hash
+          faraday.response :json, content_type: /\bjson$/
+          faraday.adapter Faraday.default_adapter
+        end
+
+        response = multipart_conn.post do |req|
+          req.url resource_path
+          req.options.timeout = timeout if timeout
+          req.body = data
+        end
+      else
+        response = @conn.post do |req|
+          req.url resource_path
+          req.options.timeout = timeout if timeout
+          req.body = JSON.generate(data) if data
+        end
       end
       response
     end

data/lib/plivo/version.rb

@@ -1,3 +1,3 @@
 module Plivo
-  VERSION = '4.0.0'.freeze
+  VERSION = '4.1.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plivo
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.1.0
 platform: ruby
 authors:
 - The Plivo SDKs Team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-18 00:00:00.000000000 Z
+date: 2018-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -149,10 +149,12 @@ files:
 - lib/plivo/exceptions.rb
 - lib/plivo/resources.rb
 - lib/plivo/resources/accounts.rb
+- lib/plivo/resources/addresses.rb
 - lib/plivo/resources/applications.rb
 - lib/plivo/resources/calls.rb
 - lib/plivo/resources/conferences.rb
 - lib/plivo/resources/endpoints.rb
+- lib/plivo/resources/identities.rb
 - lib/plivo/resources/messages.rb
 - lib/plivo/resources/numbers.rb
 - lib/plivo/resources/pricings.rb