activemerchant 1.130.0 → 1.133.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68d19e25c325eedb9f632b67713bd61ec67f09794560add0c22ba7b45c33cda6
-  data.tar.gz: 3c9405afcad2c9d066b76f1ad055d264e55569c14d9b9e322e2c6d3d83867b29
+  metadata.gz: 5d705df588bf311375b4dfc46da6912709e0aaecc7bd1800e69af7b61fcfa23b
+  data.tar.gz: 80ae4869bcbf875c2ef0bd7b5b257641c1810bc5110958a66d1cda956e6a994a
 SHA512:
-  metadata.gz: e5c803983440bd24cbadd24fc5c689061ece449436010f3ad2f328dd3bdbaf2cc3c68c43dae86482f4fee84de454d2e626b89bacf54ad67468285410d8860610
-  data.tar.gz: 77458ab3d685b3ea7b7f3f1a26617d201eb071ef540414e6934677a1541166bbd68b132bc5f980dbf60656058d97877e70c907ab950b2314a2cfcf205e9e2de3
+  metadata.gz: ba783e41a2872b825b73e5b20c6084e2d4b7200ab899a91ee6aa31977c6e4b3da651f96cd3c895417a8e3e70fdd84cd082a7450eb8a2d35c48b4fc2410ea2c02
+  data.tar.gz: b6c1718e9160fdf16745eff1758f5ffc25cbdd6a4bb219c4e13510e3a40b998f9f01b1426985fcb8b987cf73c1c5e8a760a4ffb8b506459ce4501ddb242bedb4

data/CHANGELOG

@@ -3,6 +3,34 @@
 
 == HEAD
 
+== Version 1.133.0 (July 20, 2023)
+* CyberSource: remove credentials from tests [bbraschi] #4836
+
+== Version 1.132.0 (July 20, 2023)
+* Stripe Payment Intents: Add support for new card on file field [aenand] #4807
+* Commerce Hub: Add `physicalGoodsIndicator` and `schemeReferenceTransactionId` GSFs [sinourain] #4786
+* Nuvei (formerly SafeCharge): Add customer details to credit action [yunnydang] #4820
+* IPG: Update live url to correct endpoint [curiousepic] #4121
+* VPos: Adding Panal Credit Card type [jherreraa] #4814
+* Stripe PI: Update parameters for creation of customer [almalee24] #4782
+* WorldPay: Update xml tag for Credit Cards [almalee24] #4797
+* PaywayDotCom: update `live_url` [jcreiff] #4824
+* Stripe & Stripe PI: Update login key validation [almalee24] #4816
+* CheckoutV2: Parse the AVS and CVV checks more often [aenand] #4822
+* NMI: Add shipping_firstname, shipping_lastname, shipping_email, and surcharge fields [jcreiff] #4825
+* Borgun: Update authorization_from & message_from [almalee24] #4826
+* Kushki: Add Brazil as supported country [almalee24] #4829
+* Adyen: Add additional data for airline and lodging [javierpedrozaing] #4815
+* MIT: Changed how the payload was sent to the gateway [alejandrofloresm] #4655
+* SafeCharge: Add unreferenced_refund field [yunnydang] #4831
+* CyberSource: include `paymentSolution` for ApplePay and GooglePay [bbraschi] #4835
+
+== Version 1.131.0 (June 21, 2023)
+* Redsys: Add supported countries [jcreiff] #4811
+* Authorize.net: Truncate nameOnAccount for bank refunds [jcreiff] #4808
+* CheckoutV2: Add support for several customer data fields [rachelkirk] #4800
+* Worldpay: check payment_method responds to payment_cryptogram and eci [bbraschi] #4812
+
 == Version 1.130.0 (June 13th, 2023)
 * Payu Latam - Update error code method to surface network code [yunnydang] #4773
 * CyberSource: Handling Canadian bank accounts [heavyblade] #4764

data/lib/active_merchant/billing/credit_card.rb

@@ -38,6 +38,7 @@ module ActiveMerchant #:nodoc:
     # * Edenred
     # * Anda
     # * Creditos directos (Tarjeta D)
+    # * Panal
     #
     # For testing purposes, use the 'bogus' credit card brand. This skips the vast majority of
     # validations, allowing you to focus on your core concerns until you're ready to be more concerned
@@ -130,6 +131,7 @@ module ActiveMerchant #:nodoc:
       # * +'edenred'+
       # * +'anda'+
       # * +'tarjeta-d'+
+      # * +'panal'+
       #
       # Or, if you wish to test your implementation, +'bogus'+.
       #

data/lib/active_merchant/billing/credit_card_methods.rb

@@ -46,7 +46,8 @@ module ActiveMerchant #:nodoc:
         'edenred' => ->(num) { num =~ /^637483\d{10}$/ },
         'anda' => ->(num) { num =~ /^603199\d{10}$/ },
         'tarjeta-d' => ->(num) { num =~ /^601828\d{10}$/ },
-        'hipercard' => ->(num) { num&.size == 16 && in_bin_range?(num.slice(0, 6), HIPERCARD_RANGES) }
+        'hipercard' => ->(num) { num&.size == 16 && in_bin_range?(num.slice(0, 6), HIPERCARD_RANGES) },
+        'panal' => ->(num) { num&.size == 16 && in_bin_range?(num.slice(0, 6), PANAL_RANGES) }
       }
 
       SODEXO_NO_LUHN = ->(num) { num =~ /^(505864|505865)\d{10}$/ }
@@ -182,7 +183,8 @@ module ActiveMerchant #:nodoc:
         (601256..601276),
         (601640..601652),
         (601689..601700),
-        (602011..602050),
+        (602011..602048),
+        [602050],
         (630400..630499),
         (639000..639099),
         (670000..679999),
@@ -247,6 +249,8 @@ module ActiveMerchant #:nodoc:
         637568..637568, 637599..637599, 637609..637609, 637612..637612
       ]
 
+      PANAL_RANGES = [[602049]]
+
       def self.included(base)
         base.extend(ClassMethods)
       end

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

@@ -68,6 +68,8 @@ module ActiveMerchant #:nodoc:
         add_application_info(post, options)
         add_level_2_data(post, options)
         add_level_3_data(post, options)
+        add_data_airline(post, options)
+        add_data_lodging(post, options)
         commit('authorise', post, options)
       end
 
@@ -291,6 +293,84 @@ module ActiveMerchant #:nodoc:
         post[:additionalData].compact!
       end
 
+      def add_data_airline(post, options)
+        return unless options[:additional_data_airline]
+
+        mapper = %w[
+          agency_invoice_number
+          agency_plan_name
+          airline_code
+          airline_designator_code
+          boarding_fee
+          computerized_reservation_system
+          customer_reference_number
+          document_type
+          flight_date
+          ticket_issue_address
+          ticket_number
+          travel_agency_code
+          travel_agency_name
+          passenger_name
+        ].each_with_object({}) { |value, hash| hash["airline.#{value}"] = value }
+
+        post[:additionalData].merge!(extract_and_transform(mapper, options[:additional_data_airline]))
+
+        if options[:additional_data_airline][:leg].present?
+          leg_data = %w[
+            carrier_code
+            class_of_travel
+            date_of_travel
+            depart_airport
+            depart_tax
+            destination_code
+            fare_base_code
+            flight_number
+            stop_over_code
+          ].each_with_object({}) { |value, hash| hash["airline.leg.#{value}"] = value }
+
+          post[:additionalData].merge!(extract_and_transform(leg_data, options[:additional_data_airline][:leg]))
+        end
+
+        if options[:additional_data_airline][:passenger].present?
+          passenger_data = %w[
+            date_of_birth
+            first_name
+            last_name
+            telephone_number
+            traveller_type
+          ].each_with_object({}) { |value, hash| hash["airline.passenger.#{value}"] = value }
+
+          post[:additionalData].merge!(extract_and_transform(passenger_data, options[:additional_data_airline][:passenger]))
+        end
+        post[:additionalData].compact!
+      end
+
+      def add_data_lodging(post, options)
+        return unless options[:additional_data_lodging]
+
+        mapper = {
+          'lodging.checkInDate': 'check_in_date',
+          'lodging.checkOutDate': 'check_out_date',
+          'lodging.customerServiceTollFreeNumber': 'customer_service_toll_free_number',
+          'lodging.fireSafetyActIndicator': 'fire_safety_act_indicator',
+          'lodging.folioCashAdvances': 'folio_cash_advances',
+          'lodging.folioNumber': 'folio_number',
+          'lodging.foodBeverageCharges': 'food_beverage_charges',
+          'lodging.noShowIndicator': 'no_show_indicator',
+          'lodging.prepaidExpenses': 'prepaid_expenses',
+          'lodging.propertyPhoneNumber': 'property_phone_number',
+          'lodging.room1.numberOfNights': 'number_of_nights',
+          'lodging.room1.rate': 'rate',
+          'lodging.totalRoomTax': 'total_room_tax',
+          'lodging.totalTax': 'totalTax',
+          'travelEntertainmentAuthData.duration': 'duration',
+          'travelEntertainmentAuthData.market': 'market'
+        }
+
+        post[:additionalData].merge!(extract_and_transform(mapper, options[:additional_data_lodging]))
+        post[:additionalData].compact!
+      end
+
       def add_shopper_data(post, options)
         post[:shopperEmail] = options[:email] if options[:email]
         post[:shopperEmail] = options[:shopper_email] if options[:shopper_email]

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

@@ -362,7 +362,7 @@ module ActiveMerchant
                   xml.accountType(options[:account_type])
                   xml.routingNumber(options[:routing_number])
                   xml.accountNumber(options[:account_number])
-                  xml.nameOnAccount("#{options[:first_name]} #{options[:last_name]}")
+                  xml.nameOnAccount(truncate("#{options[:first_name]} #{options[:last_name]}", 22))
                 end
               else
                 xml.creditCard do

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

@@ -172,7 +172,7 @@ module ActiveMerchant #:nodoc:
           success,
           message_from(success, pairs),
           pairs,
-          authorization: authorization_from(pairs),
+          authorization: authorization_from(pairs, options),
           test: test?
         )
       end
@@ -185,12 +185,12 @@ module ActiveMerchant #:nodoc:
         if succeeded
           'Succeeded'
         else
-          response[:message] || "Error with ActionCode=#{response[:actioncode]}"
+          response[:message] || response[:status_errormessage] || "Error with ActionCode=#{response[:actioncode]}"
         end
       end
 
-      def authorization_from(response)
-        [
+      def authorization_from(response, options)
+        authorization = [
           response[:dateandtime],
           response[:batch],
           response[:transaction],
@@ -200,6 +200,8 @@ module ActiveMerchant #:nodoc:
           response[:tramount],
           response[:trcurrency]
         ].join('|')
+
+        authorization == '|||||||' ? nil : authorization
       end
 
       def split_authorization(authorization)

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

@@ -139,6 +139,7 @@ module ActiveMerchant #:nodoc:
         add_authorization_type(post, options)
         add_payment_method(post, payment_method, options)
         add_customer_data(post, options)
+        add_extra_customer_data(post, payment_method, options)
         add_shipping_address(post, options)
         add_stored_credential_options(post, options)
         add_transaction_data(post, options)
@@ -239,6 +240,15 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      # created a separate method for these fields because they should not be included
+      # in all transaction types that include methods with source and customer fields
+      def add_extra_customer_data(post, payment_method, options)
+        post[:source][:phone] = {}
+        post[:source][:phone][:number] = options[:phone] || options.dig(:billing_address, :phone) || options.dig(:billing_address, :phone_number)
+        post[:source][:phone][:country_code] = options[:phone_country_code] if options[:phone_country_code]
+        post[:customer][:name] = payment_method.name if payment_method.respond_to?(:name)
+      end
+
       def add_shipping_address(post, options)
         if address = options[:shipping_address]
           post[:shipping] = {}
@@ -353,9 +363,6 @@ module ActiveMerchant #:nodoc:
       end
 
       def response(action, succeeded, response, source_id = nil)
-        successful_response = succeeded && action == :purchase || action == :authorize
-        avs_result = successful_response ? avs_result(response) : nil
-        cvv_result = successful_response ? cvv_result(response) : nil
         authorization = authorization_from(response) unless action == :unstore
         body = action == :unstore ? { response_code: response.to_s } : response
         Response.new(
@@ -365,8 +372,8 @@ module ActiveMerchant #:nodoc:
           authorization: authorization,
           error_code: error_code_from(succeeded, body),
           test: test?,
-          avs_result: avs_result,
-          cvv_result: cvv_result
+          avs_result: avs_result(response),
+          cvv_result: cvv_result(response)
         )
       end
 
@@ -417,11 +424,11 @@ module ActiveMerchant #:nodoc:
       end
 
       def avs_result(response)
-        response['source'] && response['source']['avs_check'] ? AVSResult.new(code: response['source']['avs_check']) : nil
+        response.respond_to?(:dig) && response.dig('source', 'avs_check') ? AVSResult.new(code: response['source']['avs_check']) : nil
       end
 
       def cvv_result(response)
-        response['source'] && response['source']['cvv_check'] ? CVVResult.new(response['source']['cvv_check']) : nil
+        response.respond_to?(:dig) && response.dig('source', 'cvv_check') ? CVVResult.new(response['source']['cvv_check']) : nil
       end
 
       def parse(body, error: nil)

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

@@ -120,7 +120,11 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_transaction_details(post, options, action = nil)
-        details = { captureFlag: options[:capture_flag], createToken: options[:create_token] }
+        details = {
+          captureFlag: options[:capture_flag],
+          createToken: options[:create_token],
+          physicalGoodsIndicator: [true, 'true'].include?(options[:physical_goods_indicator])
+        }
 
         if options[:order_id].present? && action == 'sale'
           details[:merchantOrderId] = options[:order_id]
@@ -214,7 +218,7 @@ module ActiveMerchant #:nodoc:
         post[:storedCredentials][:sequence] = stored_credential[:initial_transaction] ? 'FIRST' : 'SUBSEQUENT'
         post[:storedCredentials][:initiator] = stored_credential[:initiator] == 'merchant' ? 'MERCHANT' : 'CARD_HOLDER'
         post[:storedCredentials][:scheduled] = SCHEDULED_REASON_TYPES.include?(stored_credential[:reason_type])
-        post[:storedCredentials][:schemeReferenceTransactionId] = stored_credential[:network_transaction_id] if stored_credential[:network_transaction_id]
+        post[:storedCredentials][:schemeReferenceTransactionId] = options[:scheme_reference_transaction_id] || stored_credential[:network_transaction_id]
       end
 
       def add_credit_card(source, payment, options)

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

@@ -132,6 +132,11 @@ module ActiveMerchant #:nodoc:
         r703: 'Export hostname_country/ip_country match'
       }
 
+      @@payment_solution = {
+        apple_pay: '001',
+        google_pay: '012'
+      }
+
       # These are the options that can be used when creating a new CyberSource
       # Gateway object.
       #
@@ -322,6 +327,7 @@ module ActiveMerchant #:nodoc:
         add_airline_data(xml, options)
         add_sales_slip_number(xml, options)
         add_payment_network_token(xml) if network_tokenization?(creditcard_or_reference)
+        add_payment_solution(xml, creditcard_or_reference.source) if network_tokenization?(creditcard_or_reference)
         add_tax_management_indicator(xml, options)
         add_stored_credential_subsequent_auth(xml, options)
         add_issuer_additional_data(xml, options)
@@ -393,6 +399,7 @@ module ActiveMerchant #:nodoc:
           add_airline_data(xml, options)
           add_sales_slip_number(xml, options)
           add_payment_network_token(xml) if network_tokenization?(payment_method_or_reference)
+          add_payment_solution(xml, payment_method_or_reference.source) if network_tokenization?(payment_method_or_reference)
           add_tax_management_indicator(xml, options)
           add_stored_credential_subsequent_auth(xml, options)
           add_issuer_additional_data(xml, options)
@@ -670,6 +677,12 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_payment_solution(xml, source)
+        return unless (payment_solution = @@payment_solution[source])
+
+        xml.tag! 'paymentSolution', payment_solution
+      end
+
       def add_issuer_additional_data(xml, options)
         return unless options[:issuer_additional_data]
 

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

@@ -2,7 +2,7 @@ module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class IpgGateway < Gateway
       self.test_url = 'https://test.ipg-online.com/ipgapi/services'
-      self.live_url = 'https://www5.ipg-online.com'
+      self.live_url = 'https://www5.ipg-online.com/ipgapi/services'
 
       self.supported_countries = %w(AR)
       self.default_currency = 'ARS'

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

@@ -7,7 +7,7 @@ module ActiveMerchant #:nodoc:
       self.test_url = 'https://api-uat.kushkipagos.com/'
       self.live_url = 'https://api.kushkipagos.com/'
 
-      self.supported_countries = %w[CL CO EC MX PE]
+      self.supported_countries = %w[BR CL CO EC MX PE]
       self.default_currency = 'USD'
       self.money_format = :dollars
       self.supported_cardtypes = %i[visa master american_express discover diners_club alia]

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

@@ -93,8 +93,7 @@ module ActiveMerchant #:nodoc:
         post_to_json_encrypt = encrypt(post_to_json, @options[:key_session])
 
         final_post = '<authorization>' + post_to_json_encrypt + '</authorization><dataID>' + @options[:user] + '</dataID>'
-        json_post = {}
-        json_post[:payload] = final_post
+        json_post = final_post
         commit('sale', json_post)
       end
 
@@ -114,8 +113,7 @@ module ActiveMerchant #:nodoc:
         post_to_json_encrypt = encrypt(post_to_json, @options[:key_session])
 
         final_post = '<capture>' + post_to_json_encrypt + '</capture><dataID>' + @options[:user] + '</dataID>'
-        json_post = {}
-        json_post[:payload] = final_post
+        json_post = final_post
         commit('capture', json_post)
       end
 
@@ -136,8 +134,7 @@ module ActiveMerchant #:nodoc:
         post_to_json_encrypt = encrypt(post_to_json, @options[:key_session])
 
         final_post = '<refund>' + post_to_json_encrypt + '</refund><dataID>' + @options[:user] + '</dataID>'
-        json_post = {}
-        json_post[:payload] = final_post
+        json_post = final_post
         commit('refund', json_post)
       end
 
@@ -145,10 +142,18 @@ module ActiveMerchant #:nodoc:
         true
       end
 
+      def extract_mit_responses_from_transcript(transcript)
+        groups = transcript.scan(/reading \d+ bytes(.*?)read \d+ bytes/m)
+        groups.map do |group|
+          group.first.scan(/-> "(.*?)"/).flatten.map(&:strip).join('')
+        end
+      end
+
       def scrub(transcript)
         ret_transcript = transcript
         auth_origin = ret_transcript[/<authorization>(.*?)<\/authorization>/, 1]
         unless auth_origin.nil?
+          auth_origin = auth_origin.gsub('\n', '')
           auth_decrypted = decrypt(auth_origin, @options[:key_session])
           auth_json = JSON.parse(auth_decrypted)
           auth_json['card'] = '[FILTERED]'
@@ -162,6 +167,7 @@ module ActiveMerchant #:nodoc:
 
         cap_origin = ret_transcript[/<capture>(.*?)<\/capture>/, 1]
         unless cap_origin.nil?
+          cap_origin = cap_origin.gsub('\n', '')
           cap_decrypted = decrypt(cap_origin, @options[:key_session])
           cap_json = JSON.parse(cap_decrypted)
           cap_json['apikey'] = '[FILTERED]'
@@ -173,6 +179,7 @@ module ActiveMerchant #:nodoc:
 
         ref_origin = ret_transcript[/<refund>(.*?)<\/refund>/, 1]
         unless ref_origin.nil?
+          ref_origin = ref_origin.gsub('\n', '')
           ref_decrypted = decrypt(ref_origin, @options[:key_session])
           ref_json = JSON.parse(ref_decrypted)
           ref_json['apikey'] = '[FILTERED]'
@@ -182,15 +189,10 @@ module ActiveMerchant #:nodoc:
           ret_transcript = ret_transcript.gsub(/<refund>(.*?)<\/refund>/, ref_tagged)
         end
 
-        res_origin = ret_transcript[/#{Regexp.escape('reading ')}(.*?)#{Regexp.escape('read')}/m, 1]
-        loop do
-          break if res_origin.nil?
-
-          resp_origin = res_origin[/#{Regexp.escape('"')}(.*?)#{Regexp.escape('"')}/m, 1]
-          resp_decrypted = decrypt(resp_origin, @options[:key_session])
-          ret_transcript[/#{Regexp.escape('reading ')}(.*?)#{Regexp.escape('read')}/m, 1] = resp_decrypted
-          ret_transcript = ret_transcript.sub('reading ', 'response: ')
-          res_origin = ret_transcript[/#{Regexp.escape('reading ')}(.*?)#{Regexp.escape('read')}/m, 1]
+        groups = extract_mit_responses_from_transcript(transcript)
+        groups.each do |group|
+          group_decrypted = decrypt(group, @options[:key_session])
+          ret_transcript = ret_transcript.gsub('Conn close', "\n" + group_decrypted + "\nConn close")
         end
 
         ret_transcript
@@ -219,9 +221,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def commit(action, parameters)
-        json_str = JSON.generate(parameters)
-        cleaned_str = json_str.gsub('\n', '')
-        raw_response = ssl_post(live_url, cleaned_str, { 'Content-type' => 'application/json' })
+        raw_response = ssl_post(live_url, parameters, { 'Content-type' => 'text/plain' })
         response = JSON.parse(decrypt(raw_response, @options[:key_session]))
 
         Response.new(

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

@@ -149,6 +149,7 @@ module ActiveMerchant #:nodoc:
 
       def add_invoice(post, money, options)
         post[:amount] = amount(money)
+        post[:surcharge] = options[:surcharge] if options[:surcharge]
         post[:orderid] = options[:order_id]
         post[:orderdescription] = options[:description]
         post[:currency] = options[:currency] || currency(money)
@@ -232,6 +233,9 @@ module ActiveMerchant #:nodoc:
         end
 
         if (shipping_address = options[:shipping_address])
+          first_name, last_name = split_names(shipping_address[:name])
+          post[:shipping_firstname] = first_name if first_name
+          post[:shipping_lastname] = last_name if last_name
           post[:shipping_company] = shipping_address[:company]
           post[:shipping_address1] = shipping_address[:address1]
           post[:shipping_address2] = shipping_address[:address2]
@@ -240,6 +244,7 @@ module ActiveMerchant #:nodoc:
           post[:shipping_country] = shipping_address[:country]
           post[:shipping_zip] = shipping_address[:zip]
           post[:shipping_phone] = shipping_address[:phone]
+          post[:shipping_email] = options[:shipping_email] if options[:shipping_email]
         end
 
         if (descriptor = options[:descriptors])

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

@@ -2,7 +2,7 @@ module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class PaywayDotComGateway < Gateway
       self.test_url = 'https://paywaywsdev.com/PaywayWS/Payment/CreditCard'
-      self.live_url = 'https://paywayws.com/PaywayWS/Payment/CreditCard'
+      self.live_url = 'https://paywayws.net/PaywayWS/Payment/CreditCard'
 
       self.supported_countries = %w[US CA]
       self.default_currency = 'USD'

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

@@ -39,7 +39,7 @@ module ActiveMerchant #:nodoc:
       self.live_url = 'https://sis.redsys.es/sis/operaciones'
       self.test_url = 'https://sis-t.redsys.es:25443/sis/operaciones'
 
-      self.supported_countries = ['ES']
+      self.supported_countries = %w[ES FR GB IT PL PT]
       self.default_currency    = 'EUR'
       self.money_format        = :cents
 

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

@@ -73,10 +73,10 @@ module ActiveMerchant #:nodoc:
         add_transaction_data('Credit', post, money, options.merge!({ currency: original_currency }))
         post[:sg_CreditType] = 2
         post[:sg_AuthCode] = auth
-        post[:sg_TransactionID] = transaction_id
         post[:sg_CCToken] = token
         post[:sg_ExpMonth] = exp_month
         post[:sg_ExpYear] = exp_year
+        post[:sg_TransactionID] = transaction_id unless options[:unreferenced_refund]
 
         commit(post)
       end
@@ -86,6 +86,7 @@ module ActiveMerchant #:nodoc:
 
         add_payment(post, payment, options)
         add_transaction_data('Credit', post, money, options)
+        add_customer_details(post, payment, options)
 
         post[:sg_CreditType] = 1
 

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

@@ -696,7 +696,7 @@ module ActiveMerchant #:nodoc:
       def commit(method, url, parameters = nil, options = {})
         add_expand_parameters(parameters, options) if parameters
 
-        return Response.new(false, 'Invalid API Key provided') if test? && !key(options).start_with?('sk_test')
+        return Response.new(false, 'Invalid API Key provided') unless key_valid?(options)
 
         response = api_request(method, url, parameters, options)
         response['webhook_id'] = options[:webhook_id] if options[:webhook_id]
@@ -716,6 +716,18 @@ module ActiveMerchant #:nodoc:
           error_code: success ? nil : error_code_from(response))
       end
 
+      def key_valid?(options)
+        return true unless test?
+
+        %w(sk rk).each do |k|
+          if key(options).start_with?(k)
+            return false unless key(options).start_with?("#{k}_test")
+          end
+        end
+
+        true
+      end
+
       def authorization_from(success, url, method, response)
         return response.fetch('error', {})['charge'] unless success
 

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
@@ -997,12 +982,18 @@ module ActiveMerchant #:nodoc:
         when String
           token_type_and_details(payment_method)
         else
-          type = payment_method.respond_to?(:source) ? :network_token : :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
@@ -1028,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.130.0'
+  VERSION = '1.133.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activemerchant
 version: !ruby/object:Gem::Version
-  version: 1.130.0
+  version: 1.133.0
 platform: ruby
 authors:
 - Tobias Luetke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-06-13 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.13
+rubygems_version: 3.4.16
 signing_key: 
 specification_version: 4
 summary: Framework and tools for dealing with credit card transactions.