activemerchant 1.90.0 → 1.99.0

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

@@ -324,15 +324,15 @@ module ActiveMerchant #:nodoc:
           :region => address[:state],
           :postal_code => scrub_zip(address[:zip]),
         }
-        if address[:country] || address[:country_code_alpha2]
-          mapped[:country_code_alpha2] = (address[:country] || address[:country_code_alpha2])
-        elsif address[:country_name]
-          mapped[:country_name] = address[:country_name]
-        elsif address[:country_code_alpha3]
-          mapped[:country_code_alpha3] = address[:country_code_alpha3]
-        elsif address[:country_code_numeric]
-          mapped[:country_code_numeric] = address[:country_code_numeric]
+
+        mapped[:country_code_alpha2] = (address[:country] || address[:country_code_alpha2]) if address[:country] || address[:country_code_alpha2]
+        mapped[:country_name] = address[:country_name] if address[:country_name]
+        mapped[:country_code_alpha3] = address[:country_code_alpha3] if address[:country_code_alpha3]
+        unless address[:country].blank?
+          mapped[:country_code_alpha3] ||= Country.find(address[:country]).code(:alpha3).value
         end
+        mapped[:country_code_numeric] = address[:country_code_numeric] if address[:country_code_numeric]
+
         mapped
       end
 
@@ -419,7 +419,9 @@ module ActiveMerchant #:nodoc:
           'street: A, zip: N' => 'C',
           'street: A, zip: U' => 'I',
           'street: A, zip: I' => 'I',
-          'street: A, zip: A' => 'I'
+          'street: A, zip: A' => 'I',
+
+          'street: B, zip: B' => 'B'
         }
       end
 
@@ -445,7 +447,6 @@ module ActiveMerchant #:nodoc:
 
       def create_transaction(transaction_type, money, credit_card_or_vault_id, options)
         transaction_params = create_transaction_parameters(money, credit_card_or_vault_id, options)
-
         commit do
           result = @braintree_gateway.transaction.send(transaction_type, transaction_params)
           response = Response.new(result.success?, message_from_transaction_result(result), response_params(result), response_options(result))
@@ -543,6 +544,17 @@ module ActiveMerchant #:nodoc:
           'token'               => transaction.credit_card_details.token
         }
 
+        if transaction.risk_data
+          risk_data = {
+            'id'                      => transaction.risk_data.id,
+            'decision'                => transaction.risk_data.decision,
+            'device_data_captured'    => transaction.risk_data.device_data_captured,
+            'fraud_service_provider'  => transaction.risk_data.fraud_service_provider
+          }
+        else
+          risk_data = nil
+        end
+
         {
           'order_id'                => transaction.order_id,
           'amount'                  => transaction.amount.to_s,
@@ -553,6 +565,8 @@ module ActiveMerchant #:nodoc:
           'shipping_details'        => shipping_details,
           'vault_customer'          => vault_customer,
           'merchant_account_id'     => transaction.merchant_account_id,
+          'risk_data'               => risk_data,
+          'network_transaction_id'  => transaction.network_transaction_id || nil,
           'processor_response_code' => response_code_from_result(result)
         }
       end
@@ -578,6 +592,14 @@ module ActiveMerchant #:nodoc:
           parameters[:options][:skip_advanced_fraud_checking] = options[:skip_advanced_fraud_checking]
         end
 
+        if options[:skip_avs]
+          parameters[:options][:skip_avs] = options[:skip_avs]
+        end
+
+        if options[:skip_cvv]
+          parameters[:options][:skip_cvv] = options[:skip_cvv]
+        end
+
         parameters[:custom_fields] = options[:custom_fields]
         parameters[:device_data] = options[:device_data] if options[:device_data]
         parameters[:service_fee_amount] = options[:service_fee_amount] if options[:service_fee_amount]
@@ -585,11 +607,14 @@ module ActiveMerchant #:nodoc:
           parameters[:merchant_account_id] = merchant_account_id
         end
 
-        if options[:recurring]
+        if options[:transaction_source]
+          parameters[:transaction_source] = options[:transaction_source]
+        elsif options[:recurring]
           parameters[:recurring] = true
         end
 
         add_payment_method(parameters, credit_card_or_vault_id, options)
+        add_stored_credential_data(parameters, credit_card_or_vault_id, options)
 
         parameters[:billing] = map_address(options[:billing_address]) if options[:billing_address]
         parameters[:shipping] = map_address(options[:shipping_address]) if options[:shipping_address]
@@ -605,13 +630,7 @@ module ActiveMerchant #:nodoc:
           }
         end
 
-        if options[:three_d_secure]
-          parameters[:three_d_secure_pass_thru] = {
-            cavv: options[:three_d_secure][:cavv],
-            eci_flag: options[:three_d_secure][:eci],
-            xid: options[:three_d_secure][:xid],
-          }
-        end
+        add_3ds_info(parameters, options[:three_d_secure])
 
         parameters[:tax_amount] = options[:tax_amount] if options[:tax_amount]
         parameters[:tax_exempt] = options[:tax_exempt] if options[:tax_exempt]
@@ -626,6 +645,48 @@ module ActiveMerchant #:nodoc:
         parameters
       end
 
+      def add_3ds_info(parameters, three_d_secure_opts)
+        return if empty?(three_d_secure_opts)
+        pass_thru = {}
+
+        pass_thru[:three_d_secure_version] = three_d_secure_opts[:version] if three_d_secure_opts[:version]
+        pass_thru[:eci_flag] = three_d_secure_opts[:eci] if three_d_secure_opts[:eci]
+        pass_thru[:cavv_algorithm] = three_d_secure_opts[:cavv_algorithm] if three_d_secure_opts[:cavv_algorithm]
+        pass_thru[:cavv] = three_d_secure_opts[:cavv] if three_d_secure_opts[:cavv]
+        pass_thru[:directory_response] = three_d_secure_opts[:directory_response_status] if three_d_secure_opts[:directory_response_status]
+        pass_thru[:authentication_response] = three_d_secure_opts[:authentication_response_status] if three_d_secure_opts[:authentication_response_status]
+
+        parameters[:three_d_secure_pass_thru] = pass_thru.merge(xid_or_ds_trans_id(three_d_secure_opts))
+      end
+
+      def xid_or_ds_trans_id(three_d_secure_opts)
+        if three_d_secure_opts[:version].to_f >= 2
+          { ds_transaction_id: three_d_secure_opts[:ds_transaction_id] }
+        else
+          { xid: three_d_secure_opts[:xid] }
+        end
+      end
+
+      def add_stored_credential_data(parameters, credit_card_or_vault_id, options)
+        return unless (stored_credential = options[:stored_credential])
+        parameters[:external_vault] = {}
+        if stored_credential[:initial_transaction]
+          parameters[:external_vault][:status] = 'will_vault'
+        else
+          parameters[:external_vault][:status] = 'vaulted'
+          parameters[:external_vault][:previous_network_transaction_id] = stored_credential[:network_transaction_id]
+        end
+        if stored_credential[:initiator] == 'merchant'
+          if stored_credential[:reason_type] == 'installment'
+            parameters[:transaction_source] = 'recurring'
+          else
+            parameters[:transaction_source] = stored_credential[:reason_type]
+          end
+        else
+          parameters[:transaction_source] = ''
+        end
+      end
+
       def add_payment_method(parameters, credit_card_or_vault_id, options)
         if credit_card_or_vault_id.is_a?(String) || credit_card_or_vault_id.is_a?(Integer)
           if options[:payment_method_token]

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

@@ -68,7 +68,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def require_valid_domain!(options, param)
-        if options.key?(param)
+        if options[param]
           raise ArgumentError.new('not a valid cardconnect domain') unless /\Dcardconnect.com:\d{1,}\D/ =~ options[param]
         end
       end
@@ -233,6 +233,7 @@ module ActiveMerchant #:nodoc:
             item.each_pair do |k, v|
               updated.merge!(k.to_s.gsub(/_/, '') => v)
             end
+            updated
           end
         end
       end
@@ -267,6 +268,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))
@@ -281,6 +283,9 @@ module ActiveMerchant #:nodoc:
           test: test?,
           error_code: error_code_from(response)
         )
+      rescue ResponseError => e
+        return Response.new(false, 'Unable to authenticate.  Please check your credentials.', {}, :test => test?) if e.response.code == '401'
+        raise
       end
 
       def success_from(response)

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

@@ -1,7 +1,7 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class CecabankGateway < Gateway
-      self.test_url = 'http://tpv.ceca.es:8000'
+      self.test_url = 'https://tpv.ceca.es'
       self.live_url = 'https://pgw.ceca.es'
 
       self.supported_countries = ['ES']
@@ -13,14 +13,14 @@ module ActiveMerchant #:nodoc:
 
       #### CECA's MAGIC NUMBERS
       CECA_NOTIFICATIONS_URL = 'NONE'
-      CECA_ENCRIPTION = 'SHA1'
+      CECA_ENCRIPTION = 'SHA2'
       CECA_DECIMALS = '2'
       CECA_MODE = 'SSL'
       CECA_UI_LESS_LANGUAGE = 'XML'
       CECA_UI_LESS_LANGUAGE_REFUND = '1'
       CECA_UI_LESS_REFUND_PAGE = 'anulacion_xml'
-      CECA_ACTION_REFUND   = 'tpvanularparcialmente' # use partial refund's URL to avoid time frame limitations and decision logic on client side
-      CECA_ACTION_PURCHASE = 'tpv'
+      CECA_ACTION_REFUND   = 'anulaciones/anularParcial' # use partial refund's URL to avoid time frame limitations and decision logic on client side
+      CECA_ACTION_PURCHASE = 'tpv/compra'
       CECA_CURRENCIES_DICTIONARY = {'EUR' => 978, 'USD' => 840, 'GBP' => 826}
 
       # Creates a new CecabankGateway
@@ -168,18 +168,29 @@ module ActiveMerchant #:nodoc:
           'AcquirerBIN' => options[:acquirer_bin],
           'TerminalID' => options[:terminal_id]
         )
-        url = (test? ? self.test_url : self.live_url) + "/cgi-bin/#{action}"
-        xml = ssl_post(url, post_data(parameters))
+        url = (test? ? self.test_url : self.live_url) + "/tpvweb/#{action}.action"
+        xml = ssl_post("#{url}?", post_data(parameters))
         response = parse(xml)
         Response.new(
           response[:success],
-          response[:message],
+          message_from(response),
           response,
           :test => test?,
-          :authorization => build_authorization(response)
+          :authorization => build_authorization(response),
+          :error_code => response[:error_code]
         )
       end
 
+      def message_from(response)
+        if response[:message] == 'ERROR' && response[:error_message]
+          response[:error_message]
+        elsif response[:error_message]
+          "#{response[:message]} #{response[:error_message]}"
+        else
+          response[:message]
+        end
+      end
+
       def post_data(params)
         return nil unless params
 
@@ -231,7 +242,7 @@ module ActiveMerchant #:nodoc:
           CECA_NOTIFICATIONS_URL +
           CECA_NOTIFICATIONS_URL
         end
-        Digest::SHA1.hexdigest(signature_fields)
+        Digest::SHA2.hexdigest(signature_fields)
       end
     end
   end

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

@@ -1,22 +1,22 @@
 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={})
+      def initialize(options = {})
         requires!(options, :secret_key)
         super
       end
 
-      def purchase(amount, payment_method, options={})
+      def purchase(amount, payment_method, options = {})
         multi = MultiResponse.run do |r|
           r.process { authorize(amount, payment_method, options) }
           r.process { capture(amount, r.authorization, options) }
@@ -28,18 +28,19 @@ module ActiveMerchant #:nodoc:
         response(:purchase, succeeded, merged_params)
       end
 
-      def authorize(amount, payment_method, options={})
+      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_payment_method(post, payment_method, options)
         add_customer_data(post, options)
         add_transaction_data(post, options)
+        add_3ds(post, options)
 
         commit(:authorize, post)
       end
 
-      def capture(amount, authorization, options={})
+      def capture(amount, authorization, options = {})
         post = {}
         add_invoice(post, amount, options)
         add_customer_data(post, options)
@@ -47,12 +48,12 @@ module ActiveMerchant #:nodoc:
         commit(:capture, post, authorization)
       end
 
-      def void(authorization, options={})
+      def void(authorization, _options = {})
         post = {}
         commit(:void, post, authorization)
       end
 
-      def refund(amount, authorization, options={})
+      def refund(amount, authorization, options = {})
         post = {}
         add_invoice(post, amount, options)
         add_customer_data(post, options)
@@ -60,72 +61,102 @@ module ActiveMerchant #:nodoc:
         commit(:refund, post, authorization)
       end
 
-      def verify(credit_card, options={})
+      def verify(credit_card, options = {})
         MultiResponse.run(:use_first_response) do |r|
           r.process { authorize(100, credit_card, options) }
           r.process(:ignore_result) { void(r.authorization, options) }
         end
       end
 
+      def verify_payment(authorization, option={})
+        commit(:verify_payment, authorization)
+      end
+
       def supports_scrubbing?
         true
       end
 
       def scrub(transcript)
         transcript.
-          gsub(%r((Authorization: )[^\\]*)i, '\1[FILTERED]').
-          gsub(%r(("number\\":\\")\d+), '\1[FILTERED]').
-          gsub(%r(("cvv\\":\\")\d+), '\1[FILTERED]')
+          gsub(/(Authorization: )[^\\]*/i, '\1[FILTERED]').
+          gsub(/("number\\":\\")\d+/, '\1[FILTERED]').
+          gsub(/("cvv\\":\\")\d+/, '\1[FILTERED]')
       end
 
       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)
+      def add_payment_method(post, payment_method, options)
+        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)
+        post[:source][:stored] = 'true' if options[:card_on_file] == true
       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?
         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]
+      def add_transaction_data(post, options = {})
+        post[:payment_type] = 'Regular' if options[:transaction_indicator] == 1
+        post[:payment_type] = 'Recurring' if options[:transaction_indicator] == 2
+        post[:payment_type] = 'MOTO' if options[:transaction_indicator] == 3 || options.dig(:metadata, :manual_entry)
+        post[:previous_payment_id] = options[:previous_charge_id] if options[:previous_charge_id]
+      end
+
+      def add_3ds(post, options)
+        if options[:three_d_secure] || options[:execute_threed]
+          post[:'3ds'] = {}
+          post[:'3ds'][:enabled] = true
+          post[:success_url] = options[:callback_url] if options[:callback_url]
+          post[:failure_url] = options[:callback_url] if options[:callback_url]
+        end
+
+        if options[:three_d_secure]
+          post[:'3ds'][:eci] = options[:three_d_secure][:eci] if options[:three_d_secure][:eci]
+          post[:'3ds'][:cryptogram] = options[:three_d_secure][:cavv] if options[:three_d_secure][:cavv]
+          post[:'3ds'][:version] = options[:three_d_secure][:version] if options[:three_d_secure][:version]
+          post[:'3ds'][:xid] = options[:three_d_secure][:ds_transaction_id] || options[:three_d_secure][:xid]
+        end
       end
 
       def commit(action, post, authorization = nil)
         begin
-          raw_response = ssl_post(url(post, action, authorization), post.to_json, headers)
+          raw_response = (action == :verify_payment ? ssl_get("#{base_url}/payments/#{post}", headers) : 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/)
+          raise unless e.response.code.to_s =~ /4\d\d/
           response = parse(e.response.body)
         end
 
@@ -154,15 +185,21 @@ module ActiveMerchant #:nodoc:
       def headers
         {
           'Authorization' => @options[:secret_key],
-          'Content-Type'  => 'application/json;charset=UTF-8'
+          'Content-Type' => 'application/json;charset=UTF-8',
         }
       end
 
-      def url(post, action, authorization)
+      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 +208,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['approved'] == true || !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 +257,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