activemerchant 1.126.0 → 1.129.0

data/lib/active_merchant/billing/gateways/plexo.rb

@@ -0,0 +1,308 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class PlexoGateway < Gateway
+      self.test_url = 'https://api.testing.plexo.com.uy/v1/payments'
+      self.live_url = 'https://api.plexo.com.uy/v1/payments'
+
+      self.supported_countries = ['UY']
+      self.default_currency = 'UYU'
+      self.supported_cardtypes = %i[visa master american_express discover passcard edenred anda tarjeta-d]
+
+      self.homepage_url = 'https://www.plexo.com.uy'
+      self.display_name = 'Plexo'
+
+      APPENDED_URLS = %w(captures refunds cancellations verify)
+      AMOUNT_IN_RESPONSE = %w(authonly purchase /verify)
+      APPROVED_STATUS = %w(approved authorized)
+
+      def initialize(options = {})
+        requires!(options, :client_id, :api_key)
+        @credentials = options
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        post = {}
+        build_auth_purchase_request(money, post, payment, options)
+
+        commit('purchase', post, options)
+      end
+
+      def authorize(money, payment, options = {})
+        post = {}
+        build_auth_purchase_request(money, post, payment, options)
+        add_capture_type(post, options)
+
+        commit('authonly', post, options)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        post[:ReferenceId] = options[:reference_id] || generate_unique_id
+        post[:Amount] = amount(money)
+
+        commit("/#{authorization}/captures", post, options)
+      end
+
+      def refund(money, authorization, options = {})
+        post = {}
+        post[:ReferenceId] = options[:reference_id] || generate_unique_id
+        post[:Type] = options[:refund_type] || 'refund'
+        post[:Description] = options[:description]
+        post[:Reason] = options[:reason]
+        post[:Amount] = amount(money)
+
+        commit("/#{authorization}/refunds", post, options)
+      end
+
+      def void(authorization, options = {})
+        post = {}
+        post[:ReferenceId] = options[:reference_id] || generate_unique_id
+        post[:Description] = options[:description]
+        post[:Reason] = options[:reason]
+
+        commit("/#{authorization}/cancellations", post, options)
+      end
+
+      def verify(credit_card, options = {})
+        post = {}
+        post[:ReferenceId] = options[:reference_id] || generate_unique_id
+        post[:MerchantId] = options[:merchant_id] || @credentials[:merchant_id]
+        post[:StatementDescriptor] = options[:statement_descriptor] if options[:statement_descriptor]
+        post[:CustomerId] = options[:customer_id] if options[:customer_id]
+        money = options[:verify_amount].to_i || 100
+
+        add_payment_method(post, credit_card, options)
+        add_metadata(post, options[:metadata])
+        add_amount(money, post, options)
+        add_browser_details(post, options)
+
+        commit('/verify', post, options)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r(("Number\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("Cvc\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("InvoiceNumber\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]').
+          gsub(%r(("MerchantId\\?"\s*:\s*\\?")[^"]*)i, '\1[FILTERED]')
+      end
+
+      private
+
+      def encoded_credentials
+        Base64.encode64("#{@credentials[:client_id]}:#{@credentials[:api_key]}").delete("\n")
+      end
+
+      def build_auth_purchase_request(money, post, payment, options)
+        post[:ReferenceId] = options[:reference_id] || generate_unique_id
+        post[:MerchantId] = options[:merchant_id] || @credentials[:merchant_id]
+        post[:Installments] = options[:installments] if options[:installments]
+        post[:StatementDescriptor] = options[:statement_descriptor] if options[:statement_descriptor]
+        post[:CustomerId] = options[:customer_id] if options[:customer_id]
+
+        add_payment_method(post, payment, options)
+        add_items(post, options[:items])
+        add_metadata(post, options[:metadata])
+        add_amount(money, post, options)
+        add_browser_details(post, options)
+      end
+
+      def header(parameters = {})
+        {
+          'Content-Type' => 'application/json',
+          'Authorization' => "Basic #{encoded_credentials}"
+        }
+      end
+
+      def add_capture_type(post, options)
+        post[:Capture] = {}
+        post[:Capture][:Method] = options.dig(:capture_type, :method) || 'manual'
+      end
+
+      def add_items(post, items)
+        return unless items&.kind_of?(Array)
+
+        post[:Items] = []
+
+        items.each do |option_item|
+          item = {}
+          item[:ReferenceId] = option_item[:reference_id] || generate_unique_id
+          item[:Name] = option_item[:name] if option_item[:name]
+          item[:Description] = option_item[:description] if option_item[:description]
+          item[:Quantity] = option_item[:quantity] if option_item[:quantity]
+          item[:Price] = option_item[:price] if option_item[:price]
+          item[:Discount] = option_item[:discount] if option_item[:discount]
+
+          post[:Items].append(item)
+        end
+      end
+
+      def add_metadata(post, metadata)
+        return unless metadata&.kind_of?(Hash)
+
+        metadata.transform_keys! { |key| key.to_s.camelize.to_sym }
+        post[:Metadata] = metadata
+      end
+
+      def add_amount(money, post, amount_options)
+        post[:Amount] = {}
+
+        post[:Amount][:Currency] = amount_options[:currency] || self.default_currency
+        post[:Amount][:Total] = amount(money)
+        post[:Amount][:Details] = {}
+        add_amount_details(post[:Amount][:Details], amount_options[:amount_details]) if amount_options[:amount_details]
+      end
+
+      def add_amount_details(amount_details, options)
+        return unless options
+
+        amount_details[:TaxedAmount] = options[:taxed_amount] if options[:taxed_amount]
+        amount_details[:TipAmount] = options[:tip_amount] if options[:tip_amount]
+        amount_details[:DiscountAmount] = options[:discount_amount] if options[:discount_amount]
+        amount_details[:TaxableAmount] = options[:taxable_amount] if options[:taxable_amount]
+        add_tax(amount_details, options[:tax])
+      end
+
+      def add_tax(post, tax)
+        return unless tax
+
+        post[:Tax] = {}
+        post[:Tax][:Type] = tax[:type] if tax[:type]
+        post[:Tax][:Amount] = tax[:amount] if tax[:amount]
+        post[:Tax][:Rate] = tax[:rate] if tax[:rate]
+      end
+
+      def add_browser_details(post, browser_details)
+        return unless browser_details
+
+        post[:BrowserDetails] = {}
+        post[:BrowserDetails][:DeviceFingerprint] = browser_details[:finger_print] if browser_details[:finger_print]
+        post[:BrowserDetails][:IpAddress] = browser_details[:ip] if browser_details[:ip]
+      end
+
+      def add_payment_method(post, payment, options)
+        post[:paymentMethod] = {}
+
+        if payment&.is_a?(CreditCard)
+          post[:paymentMethod][:type] = 'card'
+          post[:paymentMethod][:Card] = {}
+          post[:paymentMethod][:Card][:Number] = payment.number
+          post[:paymentMethod][:Card][:ExpMonth] = format(payment.month, :two_digits) if payment.month
+          post[:paymentMethod][:Card][:ExpYear] = format(payment.year, :two_digits) if payment.year
+          post[:paymentMethod][:Card][:Cvc] = payment.verification_value if payment.verification_value
+
+          add_card_holder(post[:paymentMethod][:Card], payment, options)
+        end
+      end
+
+      def add_card_holder(card, payment, options)
+        requires!(options, :email)
+
+        cardholder = {}
+        cardholder[:FirstName] = payment.first_name if payment.first_name
+        cardholder[:LastName] = payment.last_name if payment.last_name
+        cardholder[:Email] = options[:email]
+        cardholder[:Birthdate] = options[:cardholder_birthdate] if options[:cardholder_birthdate]
+        cardholder[:Identification] = {}
+        cardholder[:Identification][:Type] = options[:identification_type] if options[:identification_type]
+        cardholder[:Identification][:Value] = options[:identification_value] if options[:identification_value]
+        add_billing_address(cardholder, options)
+
+        card[:Cardholder] = cardholder
+      end
+
+      def add_billing_address(cardholder, options)
+        return unless address = options[:billing_address]
+
+        cardholder[:BillingAddress] = {}
+        cardholder[:BillingAddress][:City] = address[:city]
+        cardholder[:BillingAddress][:Country] = address[:country]
+        cardholder[:BillingAddress][:Line1] = address[:address1]
+        cardholder[:BillingAddress][:Line2] = address[:address2]
+        cardholder[:BillingAddress][:PostalCode] = address[:zip]
+        cardholder[:BillingAddress][:State] = address[:state]
+      end
+
+      def parse(body)
+        return {} if body == ''
+
+        JSON.parse(body)
+      end
+
+      def build_url(action, base)
+        url = base
+        url += action if APPENDED_URLS.any? { |key| action.include?(key) }
+        url
+      end
+
+      def get_authorization_from_url(url)
+        url.split('/')[1]
+      end
+
+      def reorder_amount_fields(response)
+        return response unless response['amount']
+
+        amount_obj = response['amount']
+        response['amount'] = amount_obj['total'].to_i if amount_obj['total']
+        response['currency'] = amount_obj['currency'] if amount_obj['currency']
+        response['amount_details'] = amount_obj['details'] if amount_obj['details']
+        response
+      end
+
+      def commit(action, parameters, options = {})
+        base_url = (test? ? test_url : live_url)
+        url = build_url(action, base_url)
+        response = parse(ssl_post(url, parameters.to_json, header(options)))
+        response = reorder_amount_fields(response) if AMOUNT_IN_RESPONSE.include?(action)
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response, action),
+          test: test?,
+          error_code: error_code_from(response)
+        )
+      end
+
+      def handle_response(response)
+        case response.code.to_i
+        when 200...300, 400, 401
+          response.body
+        else
+          raise ResponseError.new(response)
+        end
+      end
+
+      def success_from(response)
+        APPROVED_STATUS.include?(response['status'])
+      end
+
+      def message_from(response)
+        response = response['transactions']&.first if response['transactions']&.is_a?(Array)
+        response['resultMessage'] || response['message']
+      end
+
+      def authorization_from(response, action = nil)
+        if action.include?('captures')
+          get_authorization_from_url(action)
+        else
+          response['id']
+        end
+      end
+
+      def error_code_from(response)
+        return if success_from(response)
+
+        response = response['transactions']&.first if response['transactions']&.is_a?(Array)
+        response['resultCode'] || response['status']
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/gateways/priority.rb

@@ -27,12 +27,12 @@ module ActiveMerchant #:nodoc:
       self.display_name = 'Priority'
 
       def initialize(options = {})
-        requires!(options, :merchant_id, :key, :secret)
+        requires!(options, :merchant_id, :api_key, :secret)
         super
       end
 
       def basic_auth
-        Base64.strict_encode64("#{@options[:key]}:#{@options[:secret]}")
+        Base64.strict_encode64("#{@options[:api_key]}:#{@options[:secret]}")
       end
 
       def request_headers
@@ -72,6 +72,18 @@ module ActiveMerchant #:nodoc:
         commit('purchase', params: params)
       end
 
+      def credit(amount, credit_card, options = {})
+        params = {}
+        params['authOnly'] = false
+        params['isSettleFunds'] = true
+        amount = -amount
+
+        add_merchant_id(params)
+        add_amount(params, amount, options)
+        add_credit_params(params, credit_card, options)
+        commit('credit', params: params)
+      end
+
       def refund(amount, authorization, options = {})
         params = {}
         add_merchant_id(params)
@@ -147,6 +159,12 @@ module ActiveMerchant #:nodoc:
         add_additional_data(params, options)
       end
 
+      def add_credit_params(params, credit_card, options)
+        add_replay_id(params, options)
+        add_credit_card(params, credit_card, 'purchase', options)
+        add_additional_data(params, options)
+      end
+
       def add_replay_id(params, options)
         params['replayId'] = options[:replay_id] if options[:replay_id]
       end
@@ -157,13 +175,12 @@ module ActiveMerchant #:nodoc:
         card_details = {}
         card_details['expiryMonth'] = format(credit_card.month, :two_digits).to_s
         card_details['expiryYear'] = format(credit_card.year, :two_digits).to_s
-        card_details['expiryDate'] = exp_date(credit_card)
         card_details['cardType'] = credit_card.brand
         card_details['last4'] = credit_card.last_digits
-        card_details['cvv'] = credit_card.verification_value
+        card_details['cvv'] = credit_card.verification_value unless credit_card.verification_value.nil?
         card_details['number'] = credit_card.number
         card_details['avsStreet'] = options[:billing_address][:address1] if options[:billing_address]
-        card_details['avsZip'] =  options[:billing_address][:zip] if options[:billing_address]
+        card_details['avsZip'] =  options[:billing_address][:zip] if !options[:billing_address].nil? && !options[:billing_address][:zip].nil?
 
         params['cardAccount'] = card_details
       end
@@ -181,11 +198,17 @@ module ActiveMerchant #:nodoc:
         params['shouldGetCreditCardLevel'] = options[:should_get_credit_card_level] if options[:should_get_credit_card_level]
         params['source'] = options[:source] if options[:source]
         params['invoice'] = options[:invoice] if options[:invoice]
+        params['isTicket'] = options[:is_ticket] if options[:is_ticket]
+        params['shouldVaultCard'] = options[:should_vault_card] if options[:should_vault_card]
+        params['sourceZip'] = options[:source_zip] if options[:source_zip]
+        params['authCode'] = options[:auth_code] if options[:auth_code]
+        params['achIndicator'] = options[:ach_indicator] if options[:ach_indicator]
+        params['bankAccount'] = options[:bank_account] if options[:bank_account]
+        params['meta'] = options[:meta] if options[:meta]
       end
 
       def add_pos_data(params, options)
         pos_data = {}
-
         pos_data['cardholderPresence'] = options.dig(:pos_data, :cardholder_presence) || 'Ecom'
         pos_data['deviceAttendance'] = options.dig(:pos_data, :device_attendance) || 'HomePc'
         pos_data['deviceInputCapability'] = options.dig(:pos_data, :device_input_capability) || 'Unknown'

data/lib/active_merchant/billing/gateways/rapyd.rb

@@ -4,13 +4,15 @@ module ActiveMerchant #:nodoc:
       self.test_url = 'https://sandboxapi.rapyd.net/v1/'
       self.live_url = 'https://api.rapyd.net/v1/'
 
-      self.supported_countries = %w(US BR CA CL CO DO SV MX PE PT VI AU HK IN ID JP MY NZ PH SG KR TW TH VN AD AT BE BA BG HR CY CZ DK EE FI FR GE DE GI GR GL HU IS IE IL IT LV LI LT LU MK MT MD MC ME NL GB NO PL RO RU SM SK SI ZA ES SE CH TR VA)
+      self.supported_countries = %w(CA CL CO DO SV PE PT VI AU HK IN ID JP MY NZ PH SG KR TW TH VN AD AT BE BA BG HR CY CZ DK EE FI FR GE DE GI GR GL HU IS IE IL IT LV LI LT LU MK MT MD MC ME NL GB NO PL RO RU SM SK SI ZA ES SE CH TR VA)
       self.default_currency = 'USD'
       self.supported_cardtypes = %i[visa master american_express discover]
 
       self.homepage_url = 'https://www.rapyd.net/'
       self.display_name = 'Rapyd Gateway'
 
+      USA_PAYMENT_METHODS = %w[us_debit_discover_card us_debit_mastercard_card us_debit_visa_card us_ach_bank]
+
       STANDARD_ERROR_CODE_MAPPING = {}
 
       def initialize(options = {})
@@ -20,63 +22,58 @@ module ActiveMerchant #:nodoc:
 
       def purchase(money, payment, options = {})
         post = {}
-        add_invoice(post, money, options)
-        add_payment(post, payment, options)
-        add_address(post, payment, options)
-        add_metadata(post, options)
-        add_ewallet(post, options)
-        post[:capture] = true if payment_is_card?(options)
-
-        if payment_is_ach?(options)
-          MultiResponse.run do |r|
-            r.process { commit(:post, 'payments', post) }
-            post = {}
-            post[:token] = r.authorization
-            post[:param2] = r.params.dig('data', 'original_amount').to_s
-            r.process { commit(:post, 'payments/completePayment', post) }
-          end
-        else
-          commit(:post, 'payments', post)
-        end
+        add_auth_purchase(post, money, payment, options)
+        post[:capture] = true unless payment.is_a?(Check)
+
+        commit(:post, 'payments', post)
       end
 
       def authorize(money, payment, options = {})
         post = {}
-        add_invoice(post, money, options)
-        add_payment(post, payment, options)
-        add_address(post, payment, options)
-        add_metadata(post, options)
-        add_ewallet(post, options)
-        post[:capture] = false
+        add_auth_purchase(post, money, payment, options)
+        post[:capture] = false unless payment.is_a?(Check)
+
         commit(:post, 'payments', post)
       end
 
       def capture(money, authorization, options = {})
         post = {}
-        commit(:post, "payments/#{authorization}/capture", post)
+        commit(:post, "payments/#{add_reference(authorization)}/capture", post)
       end
 
       def refund(money, authorization, options = {})
         post = {}
-        post[:payment] = authorization
+        post[:payment] = add_reference(authorization)
         add_invoice(post, money, options)
         add_metadata(post, options)
+        add_ewallet(post, options)
+
         commit(:post, 'refunds', post)
       end
 
       def void(authorization, options = {})
         post = {}
-        commit(:delete, "payments/#{authorization}", post)
+        commit(:delete, "payments/#{add_reference(authorization)}", post)
       end
 
-      # Gateway returns an error if trying to run a $0 auth as invalid payment amount
-      # Gateway does not support void on a card transaction and refunds can only be done on completed transactions
-      # (such as a purchase). Authorize transactions are considered 'active' and not 'complete' until they are captured.
       def verify(credit_card, options = {})
-        MultiResponse.run do |r|
-          r.process { purchase(100, credit_card, options) }
-          r.process { refund(100, r.authorization, options) }
-        end
+        authorize(0, credit_card, options)
+      end
+
+      def store(payment, options = {})
+        post = {}
+        add_payment(post, payment, options)
+        add_customer_object(post, payment, options)
+        add_metadata(post, options)
+        add_ewallet(post, options)
+        add_payment_fields(post, options)
+        add_payment_urls(post, options)
+        add_address(post, payment, options)
+        commit(:post, 'customers', post)
+      end
+
+      def unstore(customer)
+        commit(:delete, "customers/#{add_reference(customer)}", {})
       end
 
       def supports_scrubbing?
@@ -87,25 +84,34 @@ module ActiveMerchant #:nodoc:
         transcript.
           gsub(%r((Access_key: )\w+), '\1[FILTERED]').
           gsub(%r(("number\\?":\\?")\d+), '\1[FILTERED]').
+          gsub(%r(("account_number\\?":\\?")\d+), '\1[FILTERED]').
+          gsub(%r(("routing_number\\?":\\?")\d+), '\1[FILTERED]').
           gsub(%r(("cvv\\?":\\?")\d+), '\1[FILTERED]')
       end
 
       private
 
-      def payment_is_ach?(options)
-        return unless options[:pm_type]
+      def add_reference(authorization)
+        return unless authorization
 
-        return true if options[:pm_type].include?('_bank')
+        authorization.split('|')[0]
       end
 
-      def payment_is_card?(options)
-        return unless options[:pm_type]
-
-        return true if options[:pm_type].include?('_card')
+      def add_auth_purchase(post, money, payment, options)
+        add_invoice(post, money, options)
+        add_payment(post, payment, options)
+        add_customer_object(post, payment, options)
+        add_3ds(post, payment, options)
+        add_address(post, payment, options)
+        add_metadata(post, options)
+        add_ewallet(post, options)
+        add_payment_fields(post, options)
+        add_payment_urls(post, options)
+        add_customer_id(post, options)
       end
 
       def add_address(post, creditcard, options)
-        return unless address = options[:address]
+        return unless address = options[:billing_address]
 
         post[:address] = {}
         # name and line_1 are required at the gateway
@@ -116,22 +122,31 @@ module ActiveMerchant #:nodoc:
         post[:address][:state] = address[:state] if address[:state]
         post[:address][:country] = address[:country] if address[:country]
         post[:address][:zip] = address[:zip] if address[:zip]
-        post[:address][:phone_number] = address[:phone] if address[:phone]
+        post[:address][:phone_number] = address[:phone].gsub(/\D/, '') if address[:phone]
       end
 
       def add_invoice(post, money, options)
-        post[:amount] = amount(money).to_f.to_s
+        post[:amount] = money.zero? ? 0 : amount(money).to_f.to_s
         post[:currency] = (options[:currency] || currency(money))
       end
 
       def add_payment(post, payment, options)
-        if payment_is_card?(options)
+        if payment.is_a?(CreditCard)
           add_creditcard(post, payment, options)
-        elsif payment_is_ach?(options)
+        elsif payment.is_a?(Check)
           add_ach(post, payment, options)
+        else
+          add_token(post, payment, options)
         end
       end
 
+      def add_stored_credential(post, options)
+        return unless stored_credential = options[:stored_credential]
+
+        post[:payment_method][:fields][:network_reference_id] = stored_credential[:network_transaction_id] if stored_credential[:network_transaction_id]
+        post[:initiation_type] = stored_credential[:reason_type] if stored_credential[:reason_type]
+      end
+
       def add_creditcard(post, payment, options)
         post[:payment_method] = {}
         post[:payment_method][:fields] = {}
@@ -141,8 +156,10 @@ module ActiveMerchant #:nodoc:
         pm_fields[:number] = payment.number
         pm_fields[:expiration_month] = payment.month.to_s
         pm_fields[:expiration_year] = payment.year.to_s
-        pm_fields[:cvv] = payment.verification_value.to_s
         pm_fields[:name] = "#{payment.first_name} #{payment.last_name}"
+        pm_fields[:cvv] = payment.verification_value.to_s
+
+        add_stored_credential(post, options)
       end
 
       def add_ach(post, payment, options)
@@ -158,6 +175,24 @@ module ActiveMerchant #:nodoc:
         post[:payment_method][:fields][:payment_purpose] = options[:payment_purpose] if options[:payment_purpose]
       end
 
+      def add_token(post, payment, options)
+        return unless token = payment.split('|')[1]
+
+        post[:payment_method] = token
+      end
+
+      def add_3ds(post, payment, options)
+        return unless three_d_secure = options[:three_d_secure]
+
+        post[:payment_method_options] = {}
+        post[:payment_method_options]['3d_required'] = three_d_secure[:required]
+        post[:payment_method_options]['3d_version'] = three_d_secure[:version]
+        post[:payment_method_options][:cavv] = three_d_secure[:cavv]
+        post[:payment_method_options][:eci] = three_d_secure[:eci]
+        post[:payment_method_options][:xid] = three_d_secure[:xid]
+        post[:payment_method_options][:ds_trans_id] = three_d_secure[:ds_transaction_id]
+      end
+
       def add_metadata(post, options)
         post[:metadata] = options[:metadata] if options[:metadata]
       end
@@ -166,6 +201,30 @@ module ActiveMerchant #:nodoc:
         post[:ewallet_id] = options[:ewallet_id] if options[:ewallet_id]
       end
 
+      def add_payment_fields(post, options)
+        post[:payment] = {}
+
+        post[:payment][:description] = options[:description] if options[:description]
+        post[:payment][:statement_descriptor] = options[:statement_descriptor] if options[:statement_descriptor]
+      end
+
+      def add_payment_urls(post, options)
+        post[:complete_payment_url] = options[:complete_payment_url] if options[:complete_payment_url]
+        post[:error_payment_url] = options[:error_payment_url] if options[:error_payment_url]
+      end
+
+      def add_customer_object(post, payment, options)
+        post[:name] = "#{payment.first_name} #{payment.last_name}" unless payment.is_a?(String)
+        phone = options.dig(:billing_address, :phone) .gsub(/\D/, '') unless options[:billing_address].nil?
+        post[:phone_number] = phone || options.dig(:customer, :phone_number)
+        post[:email] = options[:email] || options.dig(:customer, :email)
+        post[:addresses] = options.dig(:customer, :addresses) if USA_PAYMENT_METHODS.include?(options[:pm_type])
+      end
+
+      def add_customer_id(post, options)
+        post[:customer] = options[:customer_id] if options[:customer_id]
+      end
+
       def parse(body)
         return {} if body.empty? || body.nil?
 
@@ -238,7 +297,9 @@ module ActiveMerchant #:nodoc:
       end
 
       def authorization_from(response)
-        response.dig('data') ? response.dig('data', 'id') : response.dig('status', 'operation_id')
+        id = response.dig('data') ? response.dig('data', 'id') : response.dig('status', 'operation_id')
+
+        "#{id}|#{response.dig('data', 'default_payment_method')}"
       end
 
       def error_code_from(response)