activemerchant 1.125.0 → 1.126.0

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

@@ -0,0 +1,362 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class SimetrikGateway < Gateway
+      self.test_url = 'https://payments.sta.simetrik.com/v1'
+      self.live_url = 'https://payments.simetrik.com/v1'
+
+      class_attribute :test_auth_url, :live_auth_url
+      self.test_auth_url = 'https://tenant-payments-dev.us.auth0.com/oauth/token'
+      self.live_auth_url = 'https://tenant-payments-prod.us.auth0.com/oauth/token'
+
+      self.supported_countries = %w(PE AR)
+      self.default_currency = 'USD'
+      self.supported_cardtypes = %i[visa master american_express discover]
+
+      self.homepage_url = 'https://www.simetrik.com'
+      self.display_name = 'Simetrik'
+
+      STANDARD_ERROR_CODE_MAPPING = {
+        'R101' => STANDARD_ERROR_CODE[:incorrect_number],
+        'R102' => STANDARD_ERROR_CODE[:invalid_number],
+        'R103' => STANDARD_ERROR_CODE[:invalid_expiry_date],
+        'R104' => STANDARD_ERROR_CODE[:invalid_cvc],
+        'R105' => STANDARD_ERROR_CODE[:expired_card],
+        'R106' => STANDARD_ERROR_CODE[:incorrect_cvc],
+        'R107' => STANDARD_ERROR_CODE[:incorrect_pin],
+        'R201' => STANDARD_ERROR_CODE[:incorrect_zip],
+        'R202' => STANDARD_ERROR_CODE[:incorrect_address],
+        'R301' => STANDARD_ERROR_CODE[:card_declined],
+        'R302' => STANDARD_ERROR_CODE[:processing_error],
+        'R303' => STANDARD_ERROR_CODE[:call_issuer],
+        'R304' => STANDARD_ERROR_CODE[:pick_up_card],
+        'R305' => STANDARD_ERROR_CODE[:processing_error],
+        'R306' => STANDARD_ERROR_CODE[:processing_error],
+        'R307' => STANDARD_ERROR_CODE[:processing_error],
+        'R401' => STANDARD_ERROR_CODE[:config_error],
+        'R402' => STANDARD_ERROR_CODE[:test_mode_live_card],
+        'R403' => STANDARD_ERROR_CODE[:unsupported_feature]
+
+      }
+
+      def initialize(options = {})
+        requires!(options, :client_id, :client_secret, :audience)
+        super
+        @access_token = {}
+        sign_access_token()
+      end
+
+      def authorize(money, payment, options = {})
+        requires!(options, :token_acquirer)
+
+        post = {}
+        add_forward_route(post, options)
+        add_forward_payload(post, money, payment, options)
+        add_stored_credential(post, options)
+
+        commit('authorize', post, { token_acquirer: options[:token_acquirer] })
+      end
+
+      def capture(money, authorization, options = {})
+        requires!(options, :token_acquirer)
+        post = {
+          forward_payload: {
+            amount: {
+              total_amount: amount(money).to_f,
+              currency: (options[:currency] || currency(money))
+            },
+            transaction: {
+              id: authorization
+            },
+            acquire_extra_options: options[:acquire_extra_options] || {}
+          }
+        }
+        post[:forward_payload][:amount][:vat] = options[:vat] if options[:vat]
+
+        add_forward_route(post, options)
+        commit('capture', post, { token_acquirer: options[:token_acquirer] })
+      end
+
+      def refund(money, authorization, options = {})
+        requires!(options, :token_acquirer)
+        post = {
+          forward_payload: {
+            amount: {
+              total_amount: amount(money).to_f,
+              currency: (options[:currency] || currency(money))
+            },
+            transaction: {
+              id: authorization
+            },
+            acquire_extra_options: options[:acquire_extra_options] || {}
+          }
+        }
+        post[:forward_payload][:transaction][:comment] = options[:comment] if options[:comment]
+
+        add_forward_route(post, options)
+        commit('refund', post, { token_acquirer: options[:token_acquirer] })
+      end
+
+      def void(authorization, options = {})
+        requires!(options, :token_acquirer)
+        post = {
+          forward_payload: {
+            transaction: {
+              id: authorization
+            },
+            acquire_extra_options: options[:acquire_extra_options] || {}
+          }
+        }
+        add_forward_route(post, options)
+        commit('void', post, { token_acquirer: options[:token_acquirer] })
+      end
+
+      def purchase(money, payment, options = {})
+        requires!(options, :token_acquirer)
+
+        post = {}
+        add_forward_route(post, options)
+        add_forward_payload(post, money, payment, options)
+
+        add_stored_credential(post, options)
+        commit('charge', post, { token_acquirer: options[:token_acquirer] })
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((\"number\\\":\\\")\d+), '\1[FILTERED]').
+          gsub(%r((\"security_code\\\":\\\")\d+), '\1[FILTERED]').
+          gsub(%r((\"exp_month\\\":\\\")\d+), '\1[FILTERED]').
+          gsub(%r((\"exp_year\\\":\\\")\d+), '\1[FILTERED]').
+          gsub(%r((\"holder_first_name\\\":\\\")"\w+"), '\1[FILTERED]').
+          gsub(%r((\"holder_last_name\\\":\\\")"\w+"), '\1[FILTERED]')
+      end
+
+      private
+
+      def add_forward_route(post, options)
+        forward_route = {}
+        forward_route[:trace_id] = options[:trace_id] if options[:trace_id]
+
+        forward_route[:psp_extra_fields] = options[:psp_extra_fields] || {}
+        post[:forward_route] = forward_route
+      end
+
+      def add_forward_payload(post, money, payment, options)
+        forward_payload = {}
+        add_user(forward_payload, options[:user]) if options[:user]
+        add_order(forward_payload, money, options[:order]) if options[:order] || money
+        add_payment_method(forward_payload, payment, options[:payment_method]) if options[:payment_method] || payment
+
+        forward_payload[:payment_method] = {} unless forward_payload[:payment_method]
+        forward_payload[:payment_method][:card] = {} unless forward_payload[:payment_method][:card]
+        add_address('billing_address', forward_payload[:payment_method][:card], options[:billing_address]) if options[:billing_address]
+
+        add_three_ds_fields(forward_payload[:authentication] = {}, options[:three_ds_fields]) if options[:three_ds_fields]
+        add_sub_merchant(forward_payload, options[:sub_merchant]) if options[:sub_merchant]
+        forward_payload[:acquire_extra_options] = options[:acquire_extra_options] || {}
+        post[:forward_payload] = forward_payload
+      end
+
+      def add_sub_merchant(post, sub_merchant_options)
+        sub_merchant = {}
+        sub_merchant[:merchant_id] = sub_merchant_options[:merchant_id] if sub_merchant_options[:merchant_id]
+        sub_merchant[:extra_params] = sub_merchant_options[:extra_params] if sub_merchant_options[:extra_params]
+        sub_merchant[:mcc] =  sub_merchant_options[:mcc] if sub_merchant_options[:mcc]
+        sub_merchant[:name] = sub_merchant_options[:name] if sub_merchant_options[:name]
+        sub_merchant[:address] = sub_merchant_options[:address] if sub_merchant_options[:address]
+        sub_merchant[:postal_code] = sub_merchant_options[:postal_code] if sub_merchant_options[:postal_code]
+        sub_merchant[:url] = sub_merchant_options[:url] if sub_merchant_options[:url]
+        sub_merchant[:phone_number] = sub_merchant_options[:phone_number] if sub_merchant_options[:phone_number]
+
+        post[:sub_merchant] = sub_merchant
+      end
+
+      def add_payment_method(post, payment, payment_method_options)
+        payment_method = {}
+        opts = nil
+        opts = payment_method_options[:card] if payment_method_options
+        add_card(payment_method, payment, opts) if opts || payment
+
+        post[:payment_method] = payment_method
+      end
+
+      def add_three_ds_fields(post, three_ds_options)
+        three_ds = {}
+        three_ds[:version] = three_ds_options[:version] if three_ds_options[:version]
+        three_ds[:eci] = three_ds_options[:eci] if three_ds_options[:eci]
+        three_ds[:cavv] = three_ds_options[:cavv] if three_ds_options[:cavv]
+        three_ds[:ds_transaction_id] = three_ds_options[:ds_transaction_id] if three_ds_options[:ds_transaction_id]
+        three_ds[:acs_transaction_id] = three_ds_options[:acs_transaction_id] if three_ds_options[:acs_transaction_id]
+        three_ds[:xid] = three_ds_options[:xid] if three_ds_options[:xid]
+        three_ds[:enrolled] = three_ds_options[:enrolled] if three_ds_options[:enrolled]
+        three_ds[:cavv_algorithm] = three_ds_options[:cavv_algorithm] if three_ds_options[:cavv_algorithm]
+        three_ds[:directory_response_status] = three_ds_options[:directory_response_status] if three_ds_options[:directory_response_status]
+        three_ds[:authentication_response_status] = three_ds_options[:authentication_response_status] if three_ds_options[:authentication_response_status]
+        three_ds[:three_ds_server_trans_id] = three_ds_options[:three_ds_server_trans_id] if three_ds_options[:three_ds_server_trans_id]
+
+        post[:three_ds_fields] = three_ds
+      end
+
+      def add_card(post, card, card_options = {})
+        card_hash = {}
+        card_hash[:number] = card.number
+        card_hash[:exp_month] = card.month
+        card_hash[:exp_year] = card.year
+        card_hash[:security_code] = card.verification_value
+        card_hash[:type] = card.brand
+        card_hash[:holder_first_name] = card.first_name
+        card_hash[:holder_last_name] = card.last_name
+        post[:card] = card_hash
+      end
+
+      def add_user(post, user_options)
+        user = {}
+        user[:id] = user_options[:id] if user_options[:id]
+        user[:email] = user_options[:email] if user_options[:email]
+
+        post[:user] = user
+      end
+
+      def add_stored_credential(post, options)
+        return unless options[:stored_credential]
+
+        check_initiator = %w[merchant cardholder].any? { |item| item == options[:stored_credential][:initiator] }
+        check_reason_type = %w[recurring installment unscheduled].any? { |item| item == options[:stored_credential][:reason_type] }
+        post[:forward_payload][:authentication] = {} unless post[:forward_payload].key?(:authentication)
+        post[:forward_payload][:authentication][:stored_credential] = options[:stored_credential] if check_initiator && check_reason_type
+      end
+
+      def add_order(post, money, order_options)
+        order = {}
+        order[:id] = order_options[:id] if order_options[:id]
+        order[:description] = order_options[:description] if order_options[:description]
+        order[:installments] = order_options[:installments] if order_options[:installments]
+        order[:datetime_local_transaction] = order_options[:datetime_local_transaction] if order_options[:datetime_local_transaction]
+
+        add_amount(order, money, order_options[:amount]) if order_options[:amount]
+        add_address('shipping_address', order, order_options[:shipping_address]) if order_options[:shipping_address]
+
+        post[:order] = order
+      end
+
+      def add_amount(post, money, amount_options)
+        amount_obj = {}
+        amount_obj[:total_amount] = amount(money).to_f
+        amount_obj[:currency] = (amount_options[:currency] || currency(money))
+        amount_obj[:vat] = amount_options[:vat] if amount_options[:vat]
+
+        post[:amount] = amount_obj
+      end
+
+      def add_address(tag, post, address_options)
+        address = {}
+        address[:name] = address_options[:name] if address_options[:name]
+        address[:address1] = address_options[:address1] if address_options[:address1]
+        address[:address2] = address_options[:address2] if address_options[:address2]
+        address[:company] = address_options[:company] if address_options[:company]
+        address[:city] = address_options[:city] if address_options[:city]
+        address[:state] = address_options[:state] if address_options[:state]
+        address[:zip] = address_options[:zip] if address_options[:zip]
+        address[:country] = address_options[:country] if address_options[:country]
+        address[:phone] = address_options[:phone] if address_options[:phone]
+        address[:fax] = address_options[:fax] if address_options[:fax]
+
+        post[tag] = address
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def commit(action, parameters, url_params = {})
+        begin
+          response = JSON.parse ssl_post(url(action, url_params), post_data(parameters), authorized_headers())
+        rescue ResponseError => exception
+          case exception.response.code.to_i
+          when 400...499
+            response = JSON.parse exception.response.body
+          else
+            raise exception
+          end
+        end
+
+        Response.new(
+          success_from(response['code']),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          avs_result: AVSResult.new(code: avs_code_from(response)),
+          cvv_result: CVVResult.new(cvv_code_from(response)),
+          test: test?,
+          error_code: error_code_from(response)
+        )
+      end
+
+      def avs_code_from(response)
+        response['avs_result']
+      end
+
+      def cvv_code_from(response)
+        response['cvv_result']
+      end
+
+      def success_from(code)
+        code == 'S001'
+      end
+
+      def message_from(response)
+        response['message']
+      end
+
+      def url(action, url_params)
+        "#{(test? ? test_url : live_url)}/#{url_params[:token_acquirer]}/#{action}"
+      end
+
+      def post_data(data = {})
+        data.to_json
+      end
+
+      def authorization_from(response)
+        response['simetrik_authorization_id']
+      end
+
+      def error_code_from(response)
+        STANDARD_ERROR_CODE_MAPPING[response['code']] unless success_from(response['code'])
+      end
+
+      def authorized_headers
+        {
+          'content-Type' => 'application/json',
+          'Authorization' => "Bearer #{sign_access_token()}"
+        }
+      end
+
+      def sign_access_token
+        fetch_access_token() if Time.new.to_i > (@access_token[:expires_at] || 0) + 10
+        @access_token[:access_token]
+      end
+
+      def auth_url
+        (test? ? test_auth_url : live_auth_url)
+      end
+
+      def fetch_access_token
+        login_info = {}
+        login_info[:client_id] = @options[:client_id]
+        login_info[:client_secret] = @options[:client_secret]
+        login_info[:audience] = @options[:audience]
+        login_info[:grant_type] = 'client_credentials'
+        response = parse(ssl_post(auth_url(), login_info.to_json, {
+          'content-Type' => 'application/json'
+        }))
+
+        @access_token[:access_token] = response['access_token']
+        @access_token[:expires_at] = Time.new.to_i + response['expires_in']
+      end
+    end
+  end
+end

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

@@ -48,7 +48,8 @@ module ActiveMerchant #:nodoc:
         'processing_error' => STANDARD_ERROR_CODE[:processing_error],
         'incorrect_pin' => STANDARD_ERROR_CODE[:incorrect_pin],
         'test_mode_live_card' => STANDARD_ERROR_CODE[:test_mode_live_card],
-        'pickup_card' => STANDARD_ERROR_CODE[:pickup_card]
+        'pickup_card' => STANDARD_ERROR_CODE[:pickup_card],
+        'amount_too_small' => STANDARD_ERROR_CODE[:invalid_amount]
       }
 
       BANK_ACCOUNT_HOLDER_TYPE_MAPPING = {
@@ -288,7 +289,8 @@ module ActiveMerchant #:nodoc:
           gsub(%r(((\[card\]|card)\[encrypted_pin_key_id\]=)[\w=]+(&?)), '\1[FILTERED]\3').
           gsub(%r(((\[card\]|card)\[number\]=)\d+), '\1[FILTERED]').
           gsub(%r(((\[card\]|card)\[swipe_data\]=)[^&]+(&?)), '\1[FILTERED]\3').
-          gsub(%r(((\[bank_account\]|bank_account)\[account_number\]=)\d+), '\1[FILTERED]')
+          gsub(%r(((\[bank_account\]|bank_account)\[account_number\]=)\d+), '\1[FILTERED]').
+          gsub(%r(((\[payment_method_data\]|payment_method_data)\[card\]\[token\]=)[^&]+(&?)), '\1[FILTERED]\3')
       end
 
       def supports_network_tokenization?

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

@@ -11,43 +11,44 @@ module ActiveMerchant #:nodoc:
       CONFIRM_INTENT_ATTRIBUTES = %i[receipt_email return_url save_payment_method setup_future_usage off_session]
       UPDATE_INTENT_ATTRIBUTES = %i[description statement_descriptor_suffix statement_descriptor receipt_email setup_future_usage]
       DEFAULT_API_VERSION = '2020-08-27'
-      NO_WALLET_SUPPORT = %w(apple_pay google_pay android_pay)
 
       def create_intent(money, payment_method, options = {})
-        card_source_pay = payment_method.source.to_s if defined?(payment_method.source)
-        card_brand_pay = card_brand(payment_method) unless payment_method.is_a?(String) || payment_method.nil?
-        if NO_WALLET_SUPPORT.include?(card_source_pay) || NO_WALLET_SUPPORT.include?(card_brand_pay)
-          store_apple_or_google_pay_token = 'Direct Apple Pay and Google Pay transactions are not supported. Those payment methods must be stored before use.'
-          return Response.new(false, store_apple_or_google_pay_token)
-        end
-        post = {}
-        add_amount(post, money, options, true)
-        add_capture_method(post, options)
-        add_confirmation_method(post, options)
-        add_customer(post, options)
-        result = add_payment_method_token(post, payment_method, options)
-        return result if result.is_a?(ActiveMerchant::Billing::Response)
-
-        add_external_three_d_secure_auth_data(post, options)
-        add_metadata(post, options)
-        add_return_url(post, options)
-        add_connected_account(post, options)
-        add_radar_data(post, options)
-        add_shipping_address(post, options)
-        setup_future_usage(post, options)
-        add_exemption(post, options)
-        add_stored_credentials(post, options)
-        add_ntid(post, options)
-        add_claim_without_transaction_id(post, options)
-        add_error_on_requires_action(post, options)
-        add_fulfillment_date(post, options)
-        request_three_d_secure(post, options)
-
-        CREATE_INTENT_ATTRIBUTES.each do |attribute|
-          add_whitelisted_attribute(post, options, attribute)
+        MultiResponse.run do |r|
+          if payment_method.is_a?(NetworkTokenizationCreditCard)
+            r.process { tokenize_apple_google(payment_method, options) }
+            payment_method = (r.params['token']['id']) if r.success?
+          end
+          r.process do
+            post = {}
+            add_amount(post, money, options, true)
+            add_capture_method(post, options)
+            add_confirmation_method(post, options)
+            add_customer(post, options)
+
+            result = add_payment_method_token(post, payment_method, options)
+            return result if result.is_a?(ActiveMerchant::Billing::Response)
+
+            add_external_three_d_secure_auth_data(post, options)
+            add_metadata(post, options)
+            add_return_url(post, options)
+            add_connected_account(post, options)
+            add_radar_data(post, options)
+            add_shipping_address(post, options)
+            setup_future_usage(post, options)
+            add_exemption(post, options)
+            add_stored_credentials(post, options)
+            add_ntid(post, options)
+            add_claim_without_transaction_id(post, options)
+            add_error_on_requires_action(post, options)
+            add_fulfillment_date(post, options)
+            request_three_d_secure(post, options)
+
+            CREATE_INTENT_ATTRIBUTES.each do |attribute|
+              add_whitelisted_attribute(post, options, attribute)
+            end
+            commit(:post, 'payment_intents', post, options)
+          end
         end
-
-        commit(:post, 'payment_intents', post, options)
       end
 
       def show_intent(intent_id, options)
@@ -59,6 +60,7 @@ module ActiveMerchant #:nodoc:
         result = add_payment_method_token(post, payment_method, options)
         return result if result.is_a?(ActiveMerchant::Billing::Response)
 
+        add_payment_method_types(post, options)
         CONFIRM_INTENT_ATTRIBUTES.each do |attribute|
           add_whitelisted_attribute(post, options, attribute)
         end
@@ -86,6 +88,13 @@ module ActiveMerchant #:nodoc:
         post_data
       end
 
+      def add_payment_method_card_data_token(post_data, payment_method)
+        post_data.merge!({
+          payment_method_types: ['card'],
+          payment_method_data: { type: 'card', card: { token: payment_method } }
+        })
+      end
+
       def update_intent(money, intent_id, payment_method, options = {})
         post = {}
         add_amount(post, money, options)
@@ -115,6 +124,7 @@ module ActiveMerchant #:nodoc:
         add_metadata(post, options)
         add_return_url(post, options)
         add_fulfillment_date(post, options)
+        request_three_d_secure(post, options)
         post[:on_behalf_of] = options[:on_behalf_of] if options[:on_behalf_of]
         post[:usage] = options[:usage] if %w(on_session off_session).include?(options[:usage])
         post[:description] = options[:description] if options[:description]
@@ -186,7 +196,6 @@ module ActiveMerchant #:nodoc:
       def store(payment_method, options = {})
         params = {}
         post = {}
-
         # If customer option is provided, create a payment method and attach to customer id
         # Otherwise, create a customer, then attach
         if payment_method.is_a?(StripePaymentToken) || payment_method.is_a?(ActiveMerchant::Billing::CreditCard)
@@ -285,7 +294,13 @@ module ActiveMerchant #:nodoc:
       def add_payment_method_token(post, payment_method, options)
         case payment_method
         when StripePaymentToken
-          post[:payment_method] = payment_method.payment_data['id']
+          post[:payment_method_data] = {
+            type: 'card',
+            card: {
+              token: payment_method.payment_data['id'] || payment_method.payment_data
+            }
+          }
+          post[:payment_method] = payment_method.payment_data['id'] || payment_method.payment_data
         when String
           extract_token_from_string_and_maybe_add_customer_id(post, payment_method)
         when ActiveMerchant::Billing::CreditCard
@@ -299,7 +314,34 @@ module ActiveMerchant #:nodoc:
           post[:customer] = customer_id
         end
 
-        post[:payment_method] = payment_method
+        if payment_method.include?('tok_')
+          add_payment_method_card_data_token(post, payment_method)
+        else
+          post[:payment_method] = payment_method
+        end
+      end
+
+      def tokenize_apple_google(payment, options = {})
+        tokenization_method = payment.source == :google_pay ? :android_pay : payment.source
+        post = {
+          card: {
+            number: payment.number,
+            exp_month: payment.month,
+            exp_year: payment.year,
+            tokenization_method: tokenization_method,
+            eci: payment.eci,
+            cryptogram: payment.payment_cryptogram
+          }
+        }
+        token_response = api_request(:post, 'tokens', post, options)
+        success = token_response['error'].nil?
+        if success && token_response['id']
+          Response.new(success, nil, token: token_response)
+        elsif token_response['error']['message']
+          Response.new(false, "The tokenization process fails. #{token_response['error']['message']}")
+        else
+          Response.new(false, "The tokenization process fails. #{token_response}")
+        end
       end
 
       def get_payment_method_data_from_card(post, payment_method, options)
@@ -430,21 +472,24 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_shipping_address(post, options = {})
-        return unless shipping = options[:shipping]
+        return unless shipping = options[:shipping_address]
 
         post[:shipping] = {}
-        post[:shipping][:address] = {}
-        post[:shipping][:address][:line1] = shipping[:address][:line1]
-        post[:shipping][:address][:city] = shipping[:address][:city] if shipping[:address][:city]
-        post[:shipping][:address][:country] = shipping[:address][:country] if shipping[:address][:country]
-        post[:shipping][:address][:line2] = shipping[:address][:line2] if shipping[:address][:line2]
-        post[:shipping][:address][:postal_code] = shipping[:address][:postal_code] if shipping[:address][:postal_code]
-        post[:shipping][:address][:state] = shipping[:address][:state] if shipping[:address][:state]
 
+        # fields required by Stripe PI
+        post[:shipping][:address] = {}
+        post[:shipping][:address][:line1] = shipping[:address1]
         post[:shipping][:name] = shipping[:name]
-        post[:shipping][:carrier] = shipping[:carrier] if shipping[:carrier]
-        post[:shipping][:phone] = shipping[:phone] if shipping[:phone]
-        post[:shipping][:tracking_number] = shipping[:tracking_number] if shipping[:tracking_number]
+
+        # fields considered optional by Stripe PI
+        post[:shipping][:address][:city] = shipping[:city] if shipping[:city]
+        post[:shipping][:address][:country] = shipping[:country] if shipping[:country]
+        post[:shipping][:address][:line2] = shipping[:address2] if shipping[:address2]
+        post[:shipping][:address][:postal_code] = shipping[:zip] if shipping[:zip]
+        post[:shipping][:address][:state] = shipping[:state] if shipping[:state]
+        post[:shipping][:phone] = shipping[:phone_number] if shipping[:phone_number]
+        post[:shipping][:carrier] = (shipping[:carrier] || options[:shipping_carrier]) if shipping[:carrier] || options[:shipping_carrier]
+        post[:shipping][:tracking_number] = (shipping[:tracking_number] || options[:shipping_tracking_number]) if shipping[:tracking_number] || options[:shipping_tracking_number]
       end
 
       def format_idempotency_key(options, suffix)

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

@@ -90,8 +90,8 @@ module ActiveMerchant #:nodoc:
       CURRENCY_CODES['PEN'] = 604
 
       def add_invoice(params, money, options)
-        # Visanet Peru expects a 9-digit numeric purchaseNumber
-        params[:purchaseNumber] = (SecureRandom.random_number(900_000_000) + 100_000_000).to_s
+        # Visanet Peru expects a 12-digit alphanumeric purchaseNumber
+        params[:purchaseNumber] = generate_purchase_number_stamp
         params[:externalTransactionId] = options[:order_id]
         params[:amount] = amount(money)
         params[:currencyId] = CURRENCY_CODES[options[:currency] || currency(money)]
@@ -142,6 +142,10 @@ module ActiveMerchant #:nodoc:
         authorization.split('|')
       end
 
+      def generate_purchase_number_stamp
+        (Time.now.to_f.round(2) * 100).to_i.to_s
+      end
+
       def commit(action, params, options = {})
         raw_response = ssl_request(method(action), url(action, params, options), params.to_json, headers)
         response = parse(raw_response)

data/lib/active_merchant/version.rb

@@ -1,3 +1,3 @@
 module ActiveMerchant
-  VERSION = '1.125.0'
+  VERSION = '1.126.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activemerchant
 version: !ruby/object:Gem::Version
-  version: 1.125.0
+  version: 1.126.0
 platform: ruby
 authors:
 - Tobias Luetke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-01-20 00:00:00.000000000 Z
+date: 2022-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -184,6 +184,7 @@ files:
 - lib/active_merchant/billing/gateway.rb
 - lib/active_merchant/billing/gateways.rb
 - lib/active_merchant/billing/gateways/adyen.rb
+- lib/active_merchant/billing/gateways/airwallex.rb
 - lib/active_merchant/billing/gateways/allied_wallet.rb
 - lib/active_merchant/billing/gateways/authorize_net.rb
 - lib/active_merchant/billing/gateways/authorize_net_arb.rb
@@ -206,6 +207,7 @@ files:
 - lib/active_merchant/billing/gateways/bpoint.rb
 - lib/active_merchant/billing/gateways/braintree.rb
 - lib/active_merchant/billing/gateways/braintree/braintree_common.rb
+- lib/active_merchant/billing/gateways/braintree/token_nonce.rb
 - lib/active_merchant/billing/gateways/braintree_blue.rb
 - lib/active_merchant/billing/gateways/braintree_orange.rb
 - lib/active_merchant/billing/gateways/bridge_pay.rb
@@ -370,6 +372,7 @@ files:
 - lib/active_merchant/billing/gateways/quickpay/quickpay_v10.rb
 - lib/active_merchant/billing/gateways/quickpay/quickpay_v4to7.rb
 - lib/active_merchant/billing/gateways/qvalent.rb
+- lib/active_merchant/billing/gateways/rapyd.rb
 - lib/active_merchant/billing/gateways/realex.rb
 - lib/active_merchant/billing/gateways/redsys.rb
 - lib/active_merchant/billing/gateways/s5.rb
@@ -382,6 +385,7 @@ files:
 - lib/active_merchant/billing/gateways/secure_pay_au.rb
 - lib/active_merchant/billing/gateways/secure_pay_tech.rb
 - lib/active_merchant/billing/gateways/securion_pay.rb
+- lib/active_merchant/billing/gateways/simetrik.rb
 - lib/active_merchant/billing/gateways/skip_jack.rb
 - lib/active_merchant/billing/gateways/smart_ps.rb
 - lib/active_merchant/billing/gateways/so_easy_pay.rb