activemerchant 1.92.0 → 1.94.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7269c204ea4aba074e22b8d23828116e472e5537bee163e0e60159192609cc27
-  data.tar.gz: 4b42091ca8a875d56f2bd1cc53d8440e63733930143ee662d9ca5ef87ff3cd00
+  metadata.gz: 5a2728fa6c7116ab636feb7ba715c2e4d5305fb54898d1687d633cbfb2a4795f
+  data.tar.gz: d63425c0a65919bc4a2a007d41b145a355a341667be616ae8fc0337ce2d8d145
 SHA512:
-  metadata.gz: 8a4cf32bc3055e7f8f6663a024f26424a498ec66f746a703f504723275f969f67fbfbd1cb4b7824245deef9dc7769dd94451a0d7a182491a19439a9df258f624
-  data.tar.gz: 847b1508be32ccd72185dc2e6d58075e4e6fecf693e069a068ab34dee1c8fd848e6dc760bf44708a9e4d97ca00fbcec9955b6612311555194d3bb5ee9e6351a2
+  metadata.gz: f577b5623169e0e7a1a12f4f2fa212517fba33a5ec40fb61a8e14c9df629939a4e31ed6a24ed9fabe783404553ff98ff8bdb5f0fabdc3c9da8fe8bc31c8ad97f
+  data.tar.gz: 2d37c0742319a5533236acaeb9e885692b8610208d540adda49dc21147584a3dbc50ba28632d014fb7d280d4ff9202032e5fe05dde1b1741eabf4889e9a08a42

data/CHANGELOG

@@ -1,8 +1,29 @@
 = ActiveMerchant CHANGELOG
 
 == HEAD
-
-== Version 1.91.0 (April 8, 2019)
+== Version 1.94.0 (May 21, 2019)
+* Mundipagg: Fix number lengths for both VR and Sodexo [dtykocki] #3195
+* Stripe: Support show and list webhook endpoints [jknipp] #3196
+* CardConnect: Add frontendid parameter to requests [gcatlin] #3198
+* Adyen: Correct formatting of Billing Address [nfarve] #3200
+* Stripe: Stripe: Show payment source [jknipp] #3202
+* Checkout V2: Checkout V2: Correct success criteria [curiousepic] #3205
+* Adyen: Add normalized hash of 3DS 2.0 data fields from web browsers [davidsantoso] #3207
+* Stripe: Do not attempt application fee refund if refund was not successful [jasonwebster] #3206
+* Elavon: Send transaction_currency if currency is provided [gcatlin] #3201
+* Elavon: Multi-currency support [jknipp] #3210
+* Adyen: Support preAuths and Synchronous Adjusts [curiousepic] #3212
+* WorldPay: Support Unknown Card Type [tanyajajodia] #3213
+* Mundipagg: Make gateway_affiliation_id an option [curiousepic] #3219
+* CyberSource: Adds Elo Card Type [tanyajajodia] #3220
+* CyberSource: Support standalone credit for cards [curiousepic] 3225
+
+== Version 1.93.0 (April 18, 2019)
+* Stripe: Do not consider a refund unsuccessful if only refunding the fee failed [jasonwebster] #3188
+* Stripe: Fix webhook creation for connected account [jknipp] #3193
+* Adyen: Upgrade to v40 API version [davidsantoso] #3192
+
+== Version 1.92.0 (April 8, 2019)
 * BluePay: Send customer IP address when provided [jknipp] #3149
 * PaymentExpress: Use ip field for client_info field [jknipp] #3150
 * Bambora Asia-Pacific: Adds Store [molbrown] #3147

data/lib/active_merchant/billing/credit_card_methods.rb

@@ -13,8 +13,8 @@ module ActiveMerchant #:nodoc:
         'dankort'            => ->(num) { num =~ /^5019\d{12}$/ },
         'maestro'            => ->(num) { (12..19).cover?(num&.size) && in_bin_range?(num.slice(0, 6), MAESTRO_RANGES) },
         'forbrugsforeningen' => ->(num) { num =~ /^600722\d{10}$/ },
-        'sodexo'             => ->(num) { num =~ /^(606071|603389|606070|606069|606068|600818)\d{8}$/ },
-        'vr'                 => ->(num) { num =~ /^(627416|637036)\d{8}$/ },
+        'sodexo'             => ->(num) { num =~ /^(606071|603389|606070|606069|606068|600818)\d{10}$/ },
+        'vr'                 => ->(num) { num =~ /^(627416|637036)\d{10}$/ },
         'carnet'             => lambda { |num|
           num&.size == 16 && (
             in_bin_range?(num.slice(0, 6), CARNET_RANGES) ||

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

@@ -4,8 +4,8 @@ module ActiveMerchant #:nodoc:
 
       # we recommend setting up merchant-specific endpoints.
       # https://docs.adyen.com/developers/api-manual#apiendpoints
-      self.test_url = 'https://pal-test.adyen.com/pal/servlet/Payment/v18'
-      self.live_url = 'https://pal-live.adyen.com/pal/servlet/Payment/v18'
+      self.test_url = 'https://pal-test.adyen.com/pal/servlet/Payment/v40'
+      self.live_url = 'https://pal-live.adyen.com/pal/servlet/Payment/v40'
 
       self.supported_countries = ['AT', 'AU', 'BE', 'BG', 'BR', 'CH', 'CY', 'CZ', 'DE', 'DK', 'EE', 'ES', 'FI', 'FR', 'GB', 'GI', 'GR', 'HK', 'HU', 'IE', 'IS', 'IT', 'LI', 'LT', 'LU', 'LV', 'MC', 'MT', 'MX', 'NL', 'NO', 'PL', 'PT', 'RO', 'SE', 'SG', 'SK', 'SI', 'US']
       self.default_currency = 'USD'
@@ -80,6 +80,7 @@ module ActiveMerchant #:nodoc:
         post = init_post(options)
         add_invoice_for_modification(post, money, options)
         add_reference(post, authorization, options)
+        add_extra_data(post, nil, options)
         commit('adjustAuthorisation', post, options)
       end
 
@@ -174,6 +175,9 @@ module ActiveMerchant #:nodoc:
         post[:additionalData][:overwriteBrand] = normalize(options[:overwrite_brand]) if options[:overwrite_brand]
         post[:additionalData][:customRoutingFlag] = options[:custom_routing_flag] if options[:custom_routing_flag]
         post[:additionalData]['paymentdatasource.type'] = NETWORK_TOKENIZATION_CARD_SOURCE[payment.source.to_s] if payment.is_a?(NetworkTokenizationCreditCard)
+        post[:additionalData][:authorisationType] = options[:authorisation_type] if options[:authorisation_type]
+        post[:additionalData][:adjustAuthorisationData] = options[:adjust_authorisation_data] if options[:adjust_authorisation_data]
+        post[:additionalData][:RequestedTestAcquirerResponseCode] = options[:requested_test_acquirer_response_code] if options[:requested_test_acquirer_response_code] && test?
         post[:deviceFingerprint] = options[:device_fingerprint] if options[:device_fingerprint]
         add_risk_data(post, options)
       end
@@ -214,13 +218,13 @@ module ActiveMerchant #:nodoc:
       def add_address(post, options)
         return unless post[:card]&.kind_of?(Hash)
         if (address = options[:billing_address] || options[:address]) && address[:country]
-          post[:card][:billingAddress] = {}
-          post[:card][:billingAddress][:street] = address[:address1] || 'N/A'
-          post[:card][:billingAddress][:houseNumberOrName] = address[:address2] || 'N/A'
-          post[:card][:billingAddress][:postalCode] = address[:zip] if address[:zip]
-          post[:card][:billingAddress][:city] = address[:city] || 'N/A'
-          post[:card][:billingAddress][:stateOrProvince] = address[:state] || 'N/A'
-          post[:card][:billingAddress][:country] = address[:country] if address[:country]
+          post[:billingAddress] = {}
+          post[:billingAddress][:street] = address[:address1] || 'N/A'
+          post[:billingAddress][:houseNumberOrName] = address[:address2] || 'N/A'
+          post[:billingAddress][:postalCode] = address[:zip] if address[:zip]
+          post[:billingAddress][:city] = address[:city] || 'N/A'
+          post[:billingAddress][:stateOrProvince] = address[:state] || 'N/A'
+          post[:billingAddress][:country] = address[:country] if address[:country]
         end
       end
 
@@ -308,9 +312,31 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_3ds(post, options)
-        return unless options[:execute_threed] || options[:threed_dynamic]
-        post[:browserInfo] = { userAgent: options[:user_agent], acceptHeader: options[:accept_header] }
-        post[:additionalData] = { executeThreeD: 'true' } if options[:execute_threed]
+        if three_ds_2_options = options[:three_ds_2]
+          if browser_info = three_ds_2_options[:browser_info]
+            post[:browserInfo] = {
+              acceptHeader: browser_info[:accept_header],
+              colorDepth: browser_info[:depth],
+              javaEnabled: browser_info[:java],
+              language: browser_info[:language],
+              screenHeight: browser_info[:height],
+              screenWidth: browser_info[:width],
+              timeZoneOffset: browser_info[:timezone],
+              userAgent: browser_info[:user_agent]
+            }
+
+            if device_channel = three_ds_2_options[:channel]
+              post[:threeDS2RequestData] = {
+                deviceChannel: device_channel,
+                notificationURL: three_ds_2_options[:notification_url] || 'https://example.com/notification'
+              }
+            end
+          end
+        else
+          return unless options[:execute_threed] || options[:threed_dynamic]
+          post[:browserInfo] = { userAgent: options[:user_agent], acceptHeader: options[:accept_header] }
+          post[:additionalData] = { executeThreeD: 'true' } if options[:execute_threed]
+        end
       end
 
       def parse(body)
@@ -374,8 +400,10 @@ module ActiveMerchant #:nodoc:
         case action.to_s
         when 'authorise', 'authorise3d'
           ['Authorised', 'Received', 'RedirectShopper'].include?(response['resultCode'])
-        when 'capture', 'refund', 'cancel', 'adjustAuthorisation'
+        when 'capture', 'refund', 'cancel'
           response['response'] == "[#{action}-received]"
+        when 'adjustAuthorisation'
+          response['response'] == 'Authorised' || response['response'] == '[adjustAuthorisation-received]'
         else
           false
         end

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

@@ -267,6 +267,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def commit(action, parameters, verb: :put, path: '')
+        parameters[:frontendid] = application_id
         parameters[:merchid] = @options[:merchant_id]
         url = url(action, path)
         response = parse(ssl_request(verb, url, post_data(parameters), headers))

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

@@ -1,15 +1,15 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class CheckoutV2Gateway < Gateway
-      self.display_name = 'Checkout.com V2 Gateway'
+      self.display_name = 'Checkout.com Unified Payments'
       self.homepage_url = 'https://www.checkout.com/'
-      self.live_url = 'https://api2.checkout.com/v2'
-      self.test_url = 'https://sandbox.checkout.com/api2/v2'
+      self.live_url = 'https://api.checkout.com'
+      self.test_url = 'https://api.sandbox.checkout.com'
 
       self.supported_countries = ['AD', 'AE', 'AT', 'BE', 'BG', 'CH', 'CY', 'CZ', 'DE', 'DK', 'EE', 'ES', 'FO', 'FI', 'FR', 'GB', 'GI', 'GL', 'GR', 'HR', 'HU', 'IE', 'IS', 'IL', 'IT', 'LI', 'LT', 'LU', 'LV', 'MC', 'MT', 'NL', 'NO', 'PL', 'PT', 'RO', 'SE', 'SI', 'SM', 'SK', 'SJ', 'TR', 'VA']
       self.default_currency = 'USD'
       self.money_format = :cents
-      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club]
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :maestro,  :discover]
 
       def initialize(options={})
         requires!(options, :secret_key)
@@ -30,11 +30,12 @@ module ActiveMerchant #:nodoc:
 
       def authorize(amount, payment_method, options={})
         post = {}
-        post[:autoCapture] = 'n'
+        post[:capture] = false
         add_invoice(post, amount, options)
         add_payment_method(post, payment_method)
         add_customer_data(post, options)
         add_transaction_data(post, options)
+        add_3ds(post, options)
 
         commit(:authorize, post)
       end
@@ -81,49 +82,69 @@ module ActiveMerchant #:nodoc:
       private
 
       def add_invoice(post, money, options)
-        post[:value] = localized_amount(money, options[:currency])
-        post[:trackId] = options[:order_id]
+        post[:amount] = localized_amount(money, options[:currency])
+        post[:reference] = options[:order_id]
         post[:currency] = options[:currency] || currency(money)
-        post[:descriptor] = {}
-        post[:descriptor][:name] = options[:descriptor_name] if options[:descriptor_name]
-        post[:descriptor][:city] = options[:descriptor_city] if options[:descriptor_city]
+        if options[:descriptor_name] || options[:descriptor_city]
+          post[:billing_descriptor] = {}
+          post[:billing_descriptor][:name] = options[:descriptor_name] if options[:descriptor_name]
+          post[:billing_descriptor][:city] = options[:descriptor_city] if options[:descriptor_city]
+        end
+        post[:metadata] = {}
+        post[:metadata][:udf5] = application_id || 'ActiveMerchant'
       end
 
       def add_payment_method(post, payment_method)
-        post[:card] = {}
-        post[:card][:name] = payment_method.name
-        post[:card][:number] = payment_method.number
-        post[:card][:cvv] = payment_method.verification_value
-        post[:card][:expiryYear] = format(payment_method.year, :four_digits)
-        post[:card][:expiryMonth] = format(payment_method.month, :two_digits)
+        post[:source] = {}
+        post[:source][:type] = 'card'
+        post[:source][:name] = payment_method.name
+        post[:source][:number] = payment_method.number
+        post[:source][:cvv] = payment_method.verification_value
+        post[:source][:expiry_year] = format(payment_method.year, :four_digits)
+        post[:source][:expiry_month] = format(payment_method.month, :two_digits)
       end
 
       def add_customer_data(post, options)
-        post[:email] = options[:email] || 'unspecified@example.com'
-        post[:customerIp] = options[:ip] if options[:ip]
+        post[:customer] = {}
+        post[:customer][:email] = options[:email] || nil
+        post[:payment_ip] = options[:ip] if options[:ip]
         address = options[:billing_address]
-        if(address && post[:card])
-          post[:card][:billingDetails] = {}
-          post[:card][:billingDetails][:addressLine1] = address[:address1]
-          post[:card][:billingDetails][:addressLine2] = address[:address2]
-          post[:card][:billingDetails][:city] = address[:city]
-          post[:card][:billingDetails][:state] = address[:state]
-          post[:card][:billingDetails][:country] = address[:country]
-          post[:card][:billingDetails][:postcode] = address[:zip]
-          post[:card][:billingDetails][:phone] = { number: address[:phone] } unless address[:phone].blank?
+        if(address && post[:source])
+          post[:source][:billing_address] = {}
+          post[:source][:billing_address][:address_line1] = address[:address1] unless address[:address1].blank?
+          post[:source][:billing_address][:address_line2] = address[:address2] unless address[:address2].blank?
+          post[:source][:billing_address][:city] = address[:city] unless address[:city].blank?
+          post[:source][:billing_address][:state] = address[:state] unless address[:state].blank?
+          post[:source][:billing_address][:country] = address[:country] unless address[:country].blank?
+          post[:source][:billing_address][:zip] = address[:zip] unless address[:zip].blank?
+          post[:source][:phone] = { number: address[:phone] } unless address[:phone].blank?
         end
       end
 
       def add_transaction_data(post, options={})
-        post[:cardOnFile] = true if options[:card_on_file] == true
-        post[:transactionIndicator] = options[:transaction_indicator] || 1
-        post[:previousChargeId] = options[:previous_charge_id] if options[:previous_charge_id]
+        post[:card_on_file] = true if options[:card_on_file] == true
+        post[:payment_type] = 'Regular' if options[:transaction_indicator] == 1
+        post[:payment_type] = 'Recurring' if options[:transaction_indicator] == 2
+        post[:previous_payment_id] = options[:previous_charge_id] if options[:previous_charge_id]
+      end
+
+      def add_3ds(post, options)
+        if options[:three_d_secure]
+          post[:'3ds'] = {}
+          post[:'3ds'][:enabled] = true
+          post[:'3ds'][:eci] =  options[:eci] if options[:eci]
+          post[:'3ds'][:cryptogram] =  options[:cavv] if options[:cavv]
+          post[:'3ds'][:xid] =  options[:xid] if options[:xid]
+        end
       end
 
       def commit(action, post, authorization = nil)
         begin
           raw_response = ssl_post(url(post, action, authorization), post.to_json, headers)
           response = parse(raw_response)
+          if action == :capture && response.key?('_links')
+            response['id'] = response['_links']['payment']['href'].split('/')[-1]
+          end
         rescue ResponseError => e
           raise unless(e.response.code.to_s =~ /4\d\d/)
           response = parse(e.response.body)
@@ -160,9 +181,15 @@ module ActiveMerchant #:nodoc:
 
       def url(post, action, authorization)
         if action == :authorize
-          "#{base_url}/charges/card"
+          "#{base_url}/payments"
+        elsif action == :capture
+          "#{base_url}/payments/#{authorization}/captures"
+        elsif action == :refund
+          "#{base_url}/payments/#{authorization}/refunds"
+        elsif action == :void
+          "#{base_url}/payments/#{authorization}/voids"
         else
-          "#{base_url}/charges/#{authorization}/#{action}"
+          "#{base_url}/payments/#{authorization}/#{action}"
         end
       end
 
@@ -171,33 +198,33 @@ module ActiveMerchant #:nodoc:
       end
 
       def avs_result(response)
-        response['card'] && response['card']['avsCheck'] ? AVSResult.new(code: response['card']['avsCheck']) : nil
+        response['source'] && response['source']['avs_check'] ? AVSResult.new(code: response['source']['avs_check']) : nil
       end
 
       def cvv_result(response)
-        response['card'] && response['card']['cvvCheck'] ? CVVResult.new(response['card']['cvvCheck']) : nil
+        response['source'] && response['source']['cvv_check'] ? CVVResult.new(response['source']['cvv_check']) : nil
       end
 
       def parse(body)
         JSON.parse(body)
       rescue JSON::ParserError
         {
-          'message' => 'Invalid JSON response received from CheckoutV2Gateway. Please contact CheckoutV2Gateway if you continue to receive this message.',
+          'message' => 'Invalid JSON response received from Checkout.com Unified Payments Gateway. Please contact Checkout.com if you continue to receive this message.',
           'raw_response' => scrub(body)
         }
       end
 
       def success_from(response)
-        (response['responseCode'] == '10000' && !response['responseMessage'].start_with?('40')) || response['responseCode'] == '10100'
+        response['response_summary'] == 'Approved' || !response.key?('response_summary') && response.key?('action_id')
       end
 
       def message_from(succeeded, response)
         if succeeded
           'Succeeded'
-        elsif response['errors']
-          response['message'] + ': ' + response['errors'].first
+        elsif response['error_type']
+          response['error_type'] + ': ' + response['error_codes'].first
         else
-          response['responseMessage'] || response['message'] || 'Unable to read error message'
+          response['response_summary'] || response['response_code'] || 'Unable to read error message'
         end
       end
 
@@ -220,12 +247,12 @@ module ActiveMerchant #:nodoc:
 
       def error_code_from(succeeded, response)
         return if succeeded
-        if response['errorCode'] && response['errorMessageCodes']
-          "#{response["errorCode"]}: #{response["errorMessageCodes"].join(", ")}"
-        elsif response['errorCode']
-          response['errorCode']
+        if response['error_type'] && response['error_codes']
+          "#{response["error_type"]}: #{response["error_codes"].join(", ")}"
+        elsif response['error_type']
+          response['error_type']
         else
-          STANDARD_ERROR_CODE_MAPPING[response['responseCode']]
+          STANDARD_ERROR_CODE_MAPPING[response['response_code']]
         end
       end
     end

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

@@ -26,7 +26,7 @@ module ActiveMerchant #:nodoc:
 
       XSD_VERSION = '1.153'
 
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb, :dankort, :maestro]
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb, :dankort, :maestro, :elo]
       self.supported_countries = %w(US BR CA CN DK FI FR DE IN JP MX NO SE GB SG LB)
 
       self.default_currency = 'USD'
@@ -43,7 +43,8 @@ module ActiveMerchant #:nodoc:
         :diners_club => '005',
         :jcb => '007',
         :dankort => '034',
-        :maestro => '042'
+        :maestro => '042',
+        :elo => '054'
       }
 
       @@response_codes = {
@@ -142,9 +143,10 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      # Adds credit to a subscription (stand alone credit).
-      def credit(money, reference, options = {})
-        commit(build_credit_request(money, reference, options), :credit, money, options)
+      # Adds credit to a card or subscription (stand alone credit).
+      def credit(money, creditcard_or_reference, options = {})
+        setup_address_hash(options)
+        commit(build_credit_request(money, creditcard_or_reference, options), :credit, money, options)
       end
 
       # Stores a customer subscription/profile with type "on-demand".
@@ -327,11 +329,10 @@ module ActiveMerchant #:nodoc:
         xml.target!
       end
 
-      def build_credit_request(money, reference, options)
+      def build_credit_request(money, creditcard_or_reference, options)
         xml = Builder::XmlMarkup.new :indent => 2
 
-        add_purchase_data(xml, money, true, options)
-        add_subscription(xml, options, reference)
+        add_payment_method_or_subscription(xml, money, creditcard_or_reference, options)
         add_credit_service(xml)
 
         xml.target!

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

@@ -42,6 +42,7 @@ module ActiveMerchant #:nodoc:
         else
           add_creditcard(form, payment_method)
         end
+        add_currency(form, money, options)
         add_address(form, options)
         add_customer_data(form, options)
         add_test_mode(form, options)
@@ -54,6 +55,7 @@ module ActiveMerchant #:nodoc:
         add_salestax(form, options)
         add_invoice(form, options)
         add_creditcard(form, creditcard)
+        add_currency(form, money, options)
         add_address(form, options)
         add_customer_data(form, options)
         add_test_mode(form, options)
@@ -69,6 +71,7 @@ module ActiveMerchant #:nodoc:
           add_approval_code(form, authorization)
           add_invoice(form, options)
           add_creditcard(form, options[:credit_card])
+          add_currency(form, money, options)
           add_customer_data(form, options)
           add_test_mode(form, options)
         else
@@ -102,6 +105,7 @@ module ActiveMerchant #:nodoc:
         form = {}
         add_invoice(form, options)
         add_creditcard(form, creditcard)
+        add_currency(form, money, options)
         add_address(form, options)
         add_customer_data(form, options)
         add_test_mode(form, options)
@@ -178,6 +182,11 @@ module ActiveMerchant #:nodoc:
         form[:last_name] = truncate(creditcard.last_name, 30)
       end
 
+      def add_currency(form, money, options)
+        currency = options[:currency] || currency(money)
+        form[:transaction_currency] = currency if currency && (@options[:multi_currency] || options[:multi_currency])
+      end
+
       def add_token(form, token)
         form[:token] = token
       end

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

@@ -155,7 +155,8 @@ module ActiveMerchant #:nodoc:
         post[:customer][:name] = payment.name if post[:customer]
         post[:customer_id] = parse_auth(payment)[0] if payment.is_a?(String)
         post[:payment] = {}
-        post[:payment][:gateway_affiliation_id] = @options[:gateway_id] if @options[:gateway_id]
+        affiliation = options[:gateway_affiliation_id] || @options[:gateway_id]
+        post[:payment][:gateway_affiliation_id] = affiliation if affiliation
         post[:payment][:metadata] = { mundipagg_payment_method_code: '1' } if test?
         if voucher?(payment)
           add_voucher(post, payment, options)

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

@@ -150,14 +150,21 @@ module ActiveMerchant #:nodoc:
         post[:reason] = options[:reason] if options[:reason]
         post[:expand] = [:charge]
 
-        MultiResponse.run(:first) do |r|
-          r.process { commit(:post, "charges/#{CGI.escape(identification)}/refunds", post, options) }
+        response = commit(:post, "charges/#{CGI.escape(identification)}/refunds", post, options)
 
-          if options[:refund_fee_amount] && options[:refund_fee_amount].to_s != '0'
-            r.process { fetch_application_fee(identification, options) }
-            r.process { refund_application_fee(options[:refund_fee_amount].to_i, application_fee_from_response(r.responses.last), options) }
+        if response.success? && options[:refund_fee_amount] && options[:refund_fee_amount].to_s != '0'
+          charge = api_request(:get, "charges/#{CGI.escape(identification)}", nil, options)
+
+          if application_fee = charge['application_fee']
+            fee_refund_options = {
+              currency: options[:currency], # currency isn't used by Stripe here, but we need it for #add_amount
+              key: @fee_refund_api_key
+            }
+            refund_application_fee(options[:refund_fee_amount].to_i, application_fee, fee_refund_options)
           end
         end
+
+        response
       end
 
       def verify(payment, options = {})
@@ -168,21 +175,10 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def application_fee_from_response(response)
-        return unless response.success?
-        response.params['application_fee'] unless response.params['application_fee'].empty?
-      end
-
       def refund_application_fee(money, identification, options = {})
-        return Response.new(false, 'Application fee id could not be found') unless identification
-
         post = {}
         add_amount(post, money, options)
-        options[:key] = @fee_refund_api_key if @fee_refund_api_key
-        options.delete(:stripe_account)
-
-        refund_fee = commit(:post, "application_fees/#{CGI.escape(identification)}/refunds", post, options)
-        application_fee_response!(refund_fee, "Application fee could not be refunded: #{refund_fee.message}")
+        commit(:post, "application_fees/#{CGI.escape(identification)}/refunds", post, options)
       end
 
       # Note: creating a new credit card will not change the customer's existing default credit card (use :set_default => true)
@@ -313,10 +309,16 @@ module ActiveMerchant #:nodoc:
         commit(:post, 'sources', post, options)
       end
 
+      def show_source(source_id, options)
+        commit(:get, "sources/#{source_id}", nil, options)
+      end
+
       def create_webhook_endpoint(options, events)
         post = {}
         post[:url] = options[:callback_url]
         post[:enabled_events] = events
+        post[:connect] = true if options[:stripe_account]
+        options.delete(:stripe_account)
         commit(:post, 'webhook_endpoints', post, options)
       end
 
@@ -324,6 +326,18 @@ module ActiveMerchant #:nodoc:
         commit(:delete, "webhook_endpoints/#{options[:webhook_id]}", {}, options)
       end
 
+      def show_webhook_endpoint(options)
+        options.delete(:stripe_account)
+        commit(:get, "webhook_endpoints/#{options[:webhook_id]}", nil, options)
+      end
+
+      def list_webhook_endpoints(options)
+        params = {}
+        params[:limit] = options[:limit] if options[:limit]
+        options.delete(:stripe_account)
+        commit(:get, "webhook_endpoints?#{post_data(params)}", nil, options)
+      end
+
       def create_post_for_auth_or_purchase(money, payment, options)
         post = {}
 
@@ -516,17 +530,6 @@ module ActiveMerchant #:nodoc:
         post[:metadata][:card_read_method] = creditcard.read_method if creditcard.respond_to?(:read_method)
       end
 
-      def fetch_application_fee(identification, options = {})
-        options[:key] = @fee_refund_api_key
-
-        fetch_charge = commit(:get, "charges/#{CGI.escape(identification)}", nil, options)
-        application_fee_response!(fetch_charge, "Application fee id could not be retrieved: #{fetch_charge.message}")
-      end
-
-      def application_fee_response!(response, message)
-        response.success? ? response : Response.new(false, message)
-      end
-
       def parse(body)
         JSON.parse(body)
       end

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

@@ -21,7 +21,8 @@ module ActiveMerchant #:nodoc:
         'jcb'              => 'JCB-SSL',
         'maestro'          => 'MAESTRO-SSL',
         'diners_club'      => 'DINERS-SSL',
-        'elo'              => 'ELO-SSL'
+        'elo'              => 'ELO-SSL',
+        'unknown'          => 'CARD-SSL'
       }
 
       AVS_CODE_MAP = {
@@ -252,7 +253,7 @@ module ActiveMerchant #:nodoc:
           end
         else
           xml.tag! 'paymentDetails', credit_fund_transfer_attribute(options) do
-            xml.tag! CARD_CODES[card_brand(payment_method)] do
+            xml.tag! card_code_for(payment_method) do
               xml.tag! 'cardNumber', payment_method.number
               xml.tag! 'expiryDate' do
                 xml.tag! 'date', 'month' => format(payment_method.month, :two_digits), 'year' => format(payment_method.year, :four_digits)
@@ -502,6 +503,10 @@ module ActiveMerchant #:nodoc:
         return 3 if three_decimal_currency?(currency)
         return 2
       end
+
+      def card_code_for(payment_method)
+        CARD_CODES[card_brand(payment_method)] || CARD_CODES['unknown']
+      end
     end
   end
 end

data/lib/active_merchant/version.rb

@@ -1,3 +1,3 @@
 module ActiveMerchant
-  VERSION = '1.92.0'
+  VERSION = '1.94.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activemerchant
 version: !ruby/object:Gem::Version
-  version: 1.92.0
+  version: 1.94.0
 platform: ruby
 authors:
 - Tobias Luetke
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-08 00:00:00.000000000 Z
+date: 2019-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport