activemerchant 1.129.0 → 1.133.0

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

@@ -34,9 +34,9 @@ module ActiveMerchant #:nodoc:
             add_connected_account(post, options)
             add_radar_data(post, options)
             add_shipping_address(post, options)
+            add_stored_credentials(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)
@@ -76,22 +76,27 @@ module ActiveMerchant #:nodoc:
 
       def create_payment_method(payment_method, options = {})
         post_data = add_payment_method_data(payment_method, options)
-
         options = format_idempotency_key(options, 'pm')
         commit(:post, 'payment_methods', post_data, options)
       end
 
       def add_payment_method_data(payment_method, options = {})
-        post_data = {}
-        post_data[:type] = 'card'
-        post_data[:card] = {}
-        post_data[:card][:number] = payment_method.number
-        post_data[:card][:exp_month] = payment_method.month
-        post_data[:card][:exp_year] = payment_method.year
-        post_data[:card][:cvc] = payment_method.verification_value if payment_method.verification_value
-        add_billing_address(post_data, options)
-        add_name_only(post_data, payment_method) if post_data[:billing_details].nil?
-        post_data
+        post = {
+          type: 'card',
+          card: {
+            number: payment_method.number,
+            exp_month: payment_method.month,
+            exp_year: payment_method.year
+          }
+        }
+
+        post[:card][:cvc] = payment_method.verification_value if payment_method.verification_value
+        if billing = options[:billing_address] || options[:address]
+          post[:billing_details] = add_address(billing, options)
+        end
+
+        add_name_only(post, payment_method) if post[:billing_details].nil?
+        post
       end
 
       def add_payment_method_card_data_token(post_data, payment_method)
@@ -212,16 +217,7 @@ module ActiveMerchant #:nodoc:
           result = add_payment_method_token(params, payment_method, options)
           return result if result.is_a?(ActiveMerchant::Billing::Response)
 
-          if options[:customer]
-            customer_id = options[:customer]
-          else
-            post[:description] = options[:description] if options[:description]
-            post[:email] = options[:email] if options[:email]
-            options = format_idempotency_key(options, 'customer')
-            post[:expand] = [:sources]
-            customer = commit(:post, 'customers', post, options)
-            customer_id = customer.params['id']
-          end
+          customer_id = options[:customer] || customer(post, payment_method, options).params['id']
           options = format_idempotency_key(options, 'attach')
           attach_parameters = { customer: customer_id }
           attach_parameters[:validate] = options[:validate] unless options[:validate].nil?
@@ -231,6 +227,23 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def customer(post, payment, options)
+        post[:description] = options[:description] if options[:description]
+        post[:expand] = [:sources]
+        post[:email] = options[:email]
+
+        if billing = options[:billing_address] || options[:address]
+          post.merge!(add_address(billing, options))
+        end
+
+        if shipping = options[:shipping_address]
+          post[:shipping] = add_address(shipping, options).except(:email)
+        end
+
+        options = format_idempotency_key(options, 'customer')
+        commit(:post, 'customers', post, options)
+      end
+
       def unstore(identification, options = {}, deprecated_options = {})
         if identification.include?('pm_')
           _, payment_method = identification.split('|')
@@ -399,17 +412,19 @@ module ActiveMerchant #:nodoc:
         post[:payment_method_options][:card][:moto] = true if options[:moto]
       end
 
-      # Stripe Payment Intents does not pass any parameters for cardholder/merchant initiated
-      # it also does not support installments for any country other than Mexico (reason for this is unknown)
-      # The only thing that Stripe PI requires for stored credentials to work currently is the network_transaction_id
-      # network_transaction_id is created when the card is authenticated using the field `setup_for_future_usage` with the value `off_session` see def setup_future_usage below
+      # Stripe Payment Intents now supports specifying on a transaction level basis stored credential information.
+      # The feature is currently gated but is listed as `stored_credential_transaction_type` inside the
+      # `post[:payment_method_options][:card]` hash. Since this is a beta field adding an extra check to use
+      # the existing logic by default. To be able to utilize this field, you must reach out to Stripe.
 
       def add_stored_credentials(post, options = {})
         return unless options[:stored_credential] && !options[:stored_credential].values.all?(&:nil?)
 
-        stored_credential = options[:stored_credential]
         post[:payment_method_options] ||= {}
         post[:payment_method_options][:card] ||= {}
+        add_stored_credential_transaction_type(post, options) if options[:stored_credential_transaction_type]
+
+        stored_credential = options[:stored_credential]
         post[:payment_method_options][:card][:mit_exemption] = {}
 
         # Stripe PI accepts network_transaction_id and ds_transaction_id via mit field under card.
@@ -419,6 +434,50 @@ module ActiveMerchant #:nodoc:
         post[:payment_method_options][:card][:mit_exemption][:network_transaction_id] = stored_credential[:network_transaction_id] if stored_credential[:network_transaction_id]
       end
 
+      def add_stored_credential_transaction_type(post, options = {})
+        stored_credential = options[:stored_credential]
+        # Do not add anything unless these are present.
+        return unless stored_credential[:reason_type] && stored_credential[:initiator]
+
+        # Not compatible with off_session parameter.
+        options.delete(:off_session)
+        if stored_credential[:initial_transaction]
+          # Initial transactions must by CIT
+          return unless stored_credential[:initiator] == 'cardholder'
+
+          initial_transaction_stored_credential(post, stored_credential[:reason_type])
+        else
+          # Subsequent transaction
+          subsequent_transaction_stored_credential(post, stored_credential[:initiator], stored_credential[:reason_type])
+        end
+      end
+
+      def initial_transaction_stored_credential(post, reason_type)
+        if reason_type == 'unscheduled'
+          # Charge on-session and store card for future one-off payment use
+          post[:payment_method_options][:card][:stored_credential_transaction_type] = 'setup_off_session_unscheduled'
+        elsif reason_type == 'recurring'
+          # Charge on-session and store card for future recurring payment use
+          post[:payment_method_options][:card][:stored_credential_transaction_type] = 'setup_off_session_recurring'
+        else
+          # Charge on-session and store card for future on-session payment use.
+          post[:payment_method_options][:card][:stored_credential_transaction_type] = 'setup_on_session'
+        end
+      end
+
+      def subsequent_transaction_stored_credential(post, initiator, reason_type)
+        if initiator == 'cardholder'
+          # Charge on-session customer using previously stored card.
+          post[:payment_method_options][:card][:stored_credential_transaction_type] = 'stored_on_session'
+        elsif reason_type == 'recurring'
+          # Charge off-session customer using previously stored card for recurring transaction
+          post[:payment_method_options][:card][:stored_credential_transaction_type] = 'stored_off_session_recurring'
+        else
+          # Charge off-session customer using previously stored card for one-off transaction
+          post[:payment_method_options][:card][:stored_credential_transaction_type] = 'stored_off_session_unscheduled'
+        end
+      end
+
       def add_ntid(post, options = {})
         return unless options[:network_transaction_id]
 
@@ -478,30 +537,35 @@ module ActiveMerchant #:nodoc:
       def add_billing_address_for_card_tokenization(post, options = {})
         return unless (billing = options[:billing_address] || options[:address])
 
-        post[:card][:address_city] = billing[:city] if billing[:city]
-        post[:card][:address_country] = billing[:country] if billing[:country]
-        post[:card][:address_line1] = billing[:address1] if billing[:address1]
-        post[:card][:address_line2] = billing[:address2] if billing[:address2]
-        post[:card][:address_zip] = billing[:zip] if billing[:zip]
-        post[:card][:address_state] = billing[:state] if billing[:state]
+        billing = add_address(billing, options)
+        billing[:address].transform_keys! { |k| k == :postal_code ? :address_zip : k.to_s.prepend('address_').to_sym }
+
+        post[:card][:name] = billing[:name]
+        post[:card].merge!(billing[:address])
       end
 
-      def add_billing_address(post, options = {})
-        return unless billing = options[:billing_address] || options[:address]
+      def add_shipping_address(post, options = {})
+        return unless shipping = options[:shipping_address]
 
-        email = billing[:email] || options[:email]
+        post[:shipping] = add_address(shipping, options).except(:email)
+        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
 
-        post[:billing_details] = {}
-        post[:billing_details][:address] = {}
-        post[:billing_details][:address][:city] = billing[:city] if billing[:city]
-        post[:billing_details][:address][:country] = billing[:country] if billing[:country]
-        post[:billing_details][:address][:line1] = billing[:address1] if billing[:address1]
-        post[:billing_details][:address][:line2] = billing[:address2] if billing[:address2]
-        post[:billing_details][:address][:postal_code] = billing[:zip] if billing[:zip]
-        post[:billing_details][:address][:state] = billing[:state] if billing[:state]
-        post[:billing_details][:email] = email if email
-        post[:billing_details][:name] = billing[:name] if billing[:name]
-        post[:billing_details][:phone] = billing[:phone] if billing[:phone]
+      def add_address(address, options)
+        {
+          address: {
+            city: address[:city],
+            country: address[:country],
+            line1: address[:address1],
+            line2: address[:address2],
+            postal_code: address[:zip],
+            state: address[:state]
+          }.compact,
+          email: address[:email] || options[:email],
+          phone: address[:phone] || address[:phone_number],
+          name: address[:name]
+        }.compact
       end
 
       def add_name_only(post, payment_method)
@@ -511,27 +575,6 @@ module ActiveMerchant #:nodoc:
         post[:billing_details][:name] = name
       end
 
-      def add_shipping_address(post, options = {})
-        return unless shipping = options[:shipping_address]
-
-        post[:shipping] = {}
-
-        # fields required by Stripe PI
-        post[:shipping][:address] = {}
-        post[:shipping][:address][:line1] = shipping[:address1]
-        post[:shipping][:name] = shipping[:name]
-
-        # 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)
         return options unless options[:idempotency_key]
 

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

@@ -9,7 +9,7 @@ module ActiveMerchant #:nodoc:
 
       self.supported_countries = ['PY']
       self.default_currency = 'PYG'
-      self.supported_cardtypes = %i[visa master]
+      self.supported_cardtypes = %i[visa master panal]
 
       self.homepage_url = 'https://comercios.bancard.com.py'
       self.display_name = 'vPOS'

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

@@ -28,21 +28,6 @@ module ActiveMerchant #:nodoc:
         network_token: 'NETWORKTOKEN'
       }
 
-      CARD_CODES = {
-        'visa'             => 'VISA-SSL',
-        'master'           => 'ECMC-SSL',
-        'discover'         => 'DISCOVER-SSL',
-        'american_express' => 'AMEX-SSL',
-        'jcb'              => 'JCB-SSL',
-        'maestro'          => 'MAESTRO-SSL',
-        'diners_club'      => 'DINERS-SSL',
-        'elo'              => 'ELO-SSL',
-        'naranja'          => 'NARANJA-SSL',
-        'cabal'            => 'CABAL-SSL',
-        'unionpay'         => 'CHINAUNIONPAY-SSL',
-        'unknown'          => 'CARD-SSL'
-      }
-
       AVS_CODE_MAP = {
         'A' => 'M', # Match
         'B' => 'P', # Postcode matches, address not verified
@@ -646,7 +631,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_card_details(xml, payment_method, options)
-        xml.tag! card_code_for(payment_method) do
+        xml.tag! 'CARD-SSL' do
           add_card(xml, payment_method, options)
         end
       end
@@ -683,7 +668,8 @@ module ActiveMerchant #:nodoc:
             'year' => format(payment_method.year, :four_digits_year)
           )
         end
-        xml.cardHolderName card_holder_name(payment_method, options)
+        name = card_holder_name(payment_method, options)
+        xml.cardHolderName name if name.present?
         xml.cvc payment_method.verification_value
 
         add_address(xml, (options[:billing_address] || options[:address]), options)
@@ -995,13 +981,19 @@ module ActiveMerchant #:nodoc:
         case payment_method
         when String
           token_type_and_details(payment_method)
-        when NetworkTokenizationCreditCard
-          { payment_type: :network_token }
         else
-          { payment_type: :credit }
+          type = network_token?(payment_method) ? :network_token : :credit
+
+          { payment_type: type }
         end
       end
 
+      def network_token?(payment_method)
+        payment_method.respond_to?(:source) &&
+          payment_method.respond_to?(:payment_cryptogram) &&
+          payment_method.respond_to?(:eci)
+      end
+
       def token_type_and_details(token)
         token_details = token_details_from_authorization(token)
         token_details[:payment_type] = token_details.has_key?(:token_id) ? :token : :pay_as_order
@@ -1027,10 +1019,6 @@ module ActiveMerchant #:nodoc:
         return 2
       end
 
-      def card_code_for(payment_method)
-        CARD_CODES[card_brand(payment_method)] || CARD_CODES['unknown']
-      end
-
       def eligible_for_0_auth?(payment_method, options = {})
         payment_method.is_a?(CreditCard) && %w(visa master).include?(payment_method.brand) && options[:zero_dollar_auth]
       end

data/lib/active_merchant/version.rb

@@ -1,3 +1,3 @@
 module ActiveMerchant
-  VERSION = '1.129.0'
+  VERSION = '1.133.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activemerchant
 version: !ruby/object:Gem::Version
-  version: 1.129.0
+  version: 1.133.0
 platform: ruby
 authors:
 - Tobias Luetke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-05-03 00:00:00.000000000 Z
+date: 2023-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -480,7 +480,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.12
+rubygems_version: 3.4.16
 signing_key: 
 specification_version: 4
 summary: Framework and tools for dealing with credit card transactions.