activemerchant 1.93.0 → 1.98.0

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

@@ -13,7 +13,7 @@ module ActiveMerchant #:nodoc:
       self.homepage_url = 'https://www.barclaycardsmartpay.com/'
       self.display_name = 'Barclaycard Smartpay'
 
-      API_VERSION = 'v30'
+      API_VERSION = 'v40'
 
       def initialize(options = {})
         requires!(options, :company, :merchant, :password)
@@ -37,7 +37,9 @@ module ActiveMerchant #:nodoc:
         post[:card] = credit_card_hash(creditcard)
         post[:billingAddress] = billing_address_hash(options) if options[:billing_address]
         post[:deliveryAddress] = shipping_address_hash(options) if options[:shipping_address]
-        add_3ds(post, options) if options[:execute_threed]
+        post[:shopperStatement] = options[:shopper_statement] if options[:shopper_statement]
+
+        add_3ds(post, options)
         commit('authorise', post)
       end
 
@@ -186,7 +188,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def parse_avs_code(response)
-        AVS_MAPPING[response['avsResult'][0..1].strip] if response['avsResult']
+        AVS_MAPPING[response['additionalData']['avsResult'][0..1].strip] if response.dig('additionalData', 'avsResult')
       end
 
       def flatten_hash(hash, prefix = nil)
@@ -210,12 +212,18 @@ module ActiveMerchant #:nodoc:
       end
 
       def parse(response)
-        Hash[
-          response.split('&').map do |x|
-            key, val = x.split('=', 2)
-            [key.split('.').last, CGI.unescape(val)]
+        parsed_response = {}
+        params = CGI.parse(response)
+        params.each do |key, value|
+          parsed_key = key.split('.', 2)
+          if parsed_key.size > 1
+            parsed_response[parsed_key[0]] ||= {}
+            parsed_response[parsed_key[0]][parsed_key[1]] = value[0]
+          else
+            parsed_response[parsed_key[0]] = value[0]
           end
-        ]
+        end
+        parsed_response
       end
 
       def post_data(data)
@@ -343,8 +351,33 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_3ds(post, options)
-        post[:additionalData] = { executeThreeD: 'true' }
-        post[:browserInfo] = { userAgent: options[:user_agent], acceptHeader: options[:accept_header] }
+        if three_ds_2_options = options[:three_ds_2]
+          device_channel = three_ds_2_options[:channel]
+          if device_channel == 'app'
+            post[:threeDS2RequestData] = { deviceChannel: device_channel }
+          else
+            add_browser_info(three_ds_2_options[:browser_info], post)
+            post[:threeDS2RequestData] = { deviceChannel: device_channel, notificationURL: three_ds_2_options[:notification_url] }
+          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 add_browser_info(browser_info, post)
+        return unless 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]
+        }
       end
     end
   end

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

@@ -153,6 +153,8 @@ module ActiveMerchant #:nodoc:
 
       # To match the other stored-value gateways, like TrustCommerce,
       # store and unstore need to be defined
+      #
+      # When passing a single-use token the :name option is required
       def store(payment_method, options = {})
         post = {}
         add_address(post, options)

data/lib/active_merchant/billing/gateways/beanstream/beanstream_core.rb

@@ -315,6 +315,9 @@ module ActiveMerchant #:nodoc:
         post[:operationType] = options[:operationType] || options[:operation] || secure_profile_action(:new)
         post[:customerCode] = options[:billing_id] || options[:vault_id] || false
         post[:status] = options[:status]
+
+        billing_address = options[:billing_address] || options[:address]
+        post[:trnCardOwner] = billing_address[:name]
       end
 
       def add_recurring_amount(post, money)

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

@@ -8,7 +8,7 @@ module ActiveMerchant
       self.supported_countries = %w(US CA GB AT BE BG HR CY CZ DK EE FI FR DE GR HU IE IT LV LT LU MT NL PL PT RO SK SI ES SE AR BO BR BZ CL CO CR DO EC GF GP GT HN HT MF MQ MX NI PA PE PR PY SV UY VE)
 
       self.default_currency = 'USD'
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners_club, :maestro]
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners_club, :maestro, :naranja, :cabal]
 
       self.homepage_url = 'https://home.bluesnap.com/'
       self.display_name = 'BlueSnap'
@@ -66,6 +66,8 @@ module ActiveMerchant
         'business_savings' => 'CORPORATE_SAVINGS'
       }
 
+      STATE_CODE_COUNTRIES = %w(US CA)
+
       def initialize(options={})
         requires!(options, :api_username, :api_password)
         super
@@ -93,6 +95,7 @@ module ActiveMerchant
         commit(:capture, :put) do |doc|
           add_authorization(doc, authorization)
           add_order(doc, options)
+          add_amount(doc, money, options) if options[:include_capture_amount] == true
         end
       end
 
@@ -220,6 +223,7 @@ module ActiveMerchant
         doc.send('merchant-transaction-id', truncate(options[:order_id], 50)) if options[:order_id]
         doc.send('soft-descriptor', options[:soft_descriptor]) if options[:soft_descriptor]
         add_description(doc, options[:description]) if options[:description]
+        add_3ds(doc, options[:three_d_secure]) if options[:three_d_secure]
         add_level_3_data(doc, options)
       end
 
@@ -228,12 +232,28 @@ module ActiveMerchant
         return unless address
 
         doc.country(address[:country]) if address[:country]
-        doc.state(address[:state]) if address[:state]
+        doc.state(address[:state]) if address[:state] && STATE_CODE_COUNTRIES.include?(address[:country])
         doc.address(address[:address]) if address[:address]
         doc.city(address[:city]) if address[:city]
         doc.zip(address[:zip]) if address[:zip]
       end
 
+      def add_3ds(doc, three_d_secure_options)
+        eci = three_d_secure_options[:eci]
+        cavv = three_d_secure_options[:cavv]
+        xid = three_d_secure_options[:xid]
+        ds_transaction_id = three_d_secure_options[:ds_transaction_id]
+        version = three_d_secure_options[:version]
+
+        doc.send('three-d-secure') do
+          doc.eci(eci) if eci
+          doc.cavv(cavv) if cavv
+          doc.xid(xid) if xid
+          doc.send('three-d-secure-version', version) if version
+          doc.send('ds-transaction-id', ds_transaction_id) if ds_transaction_id
+        end
+      end
+
       def add_level_3_data(doc, options)
         return unless options[:customer_reference_number]
         doc.send('level-3-data') do

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

@@ -163,10 +163,10 @@ module ActiveMerchant #:nodoc:
         xml.send('PaymentType', payment_type)
         xml.send('TxnType', 'WEB_SHOP')
         xml.send('BillerCode', options.fetch(:biller_code, ''))
-        xml.send('MerchantReference', '')
-        xml.send('CRN1', '')
-        xml.send('CRN2', '')
-        xml.send('CRN3', '')
+        xml.send('MerchantReference', options[:order_id]) if options[:order_id]
+        xml.send('CRN1', options[:crn1]) if options[:crn1]
+        xml.send('CRN2', options[:crn2]) if options[:crn2]
+        xml.send('CRN3', options[:crn3]) if options[:crn3]
         xml.send('Amount', amount)
       end
 

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

@@ -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))
@@ -565,6 +566,7 @@ module ActiveMerchant #:nodoc:
           '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
@@ -590,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]
@@ -604,6 +614,7 @@ module ActiveMerchant #:nodoc:
         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]
@@ -619,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]
@@ -640,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))

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,8 +168,8 @@ 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],
@@ -242,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