activemerchant 1.126.0 → 1.129.0

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

@@ -0,0 +1,277 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class ReachGateway < Gateway
+      self.test_url = 'https://checkout.rch.how/'
+      self.live_url = 'https://checkout.rch.io/'
+
+      self.supported_countries = ['US']
+      self.default_currency = 'USD'
+      self.supported_cardtypes = %i[visa diners_club american_express jcb master discover maestro]
+
+      self.homepage_url = 'https://www.withreach.com/'
+      self.display_name = 'Reach'
+      self.currencies_without_fractions = %w(BIF BYR CLF CLP CVE DJF GNF ISK JPY KMF KRW PYG RWF UGX UYI VND VUV XAF XOF XPF IDR MGA MRO)
+
+      API_VERSION = 'v2.22'.freeze
+      STANDARD_ERROR_CODE_MAPPING = {}
+      PAYMENT_METHOD_MAP = {
+        american_express: 'AMEX',
+        cabal: 'CABAL',
+        check: 'ACH',
+        dankort: 'DANKORT',
+        diners_club: 'DINERS',
+        discover: 'DISC',
+        elo: 'ELO',
+        jcb: 'JCB',
+        maestro: 'MAESTRO',
+        master: 'MC',
+        naranja: 'NARANJA',
+        union_pay: 'UNIONPAY',
+        visa: 'VISA'
+      }
+
+      def initialize(options = {})
+        requires!(options, :merchant_id, :secret)
+        super
+      end
+
+      def authorize(money, payment, options = {})
+        request = build_checkout_request(money, payment, options)
+        add_custom_fields_data(request, options)
+        add_customer_data(request, options, payment)
+        add_stored_credentials(request, options)
+        post = { request: request, card: add_payment(payment, options) }
+        if options[:stored_credential]
+          MultiResponse.run(:use_first_response) do |r|
+            r.process { commit('checkout', post) }
+            r.process do
+              r2 = get_network_payment_reference(r.responses[0])
+              r.params[:network_transaction_id] = r2.message
+              r2
+            end
+          end
+        else
+          commit('checkout', post)
+        end
+      end
+
+      def purchase(money, payment, options = {})
+        options[:capture] = true
+        authorize(money, payment, options)
+      end
+
+      def capture(money, authorization, options = {})
+        post = { request: { MerchantId: @options[:merchant_id], OrderId: authorization } }
+        commit('capture', post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r(((MerchantId)[% \w]+[%]\d{2})[\w -]+), '\1[FILTERED]').
+          gsub(%r((signature=)[\w%]+), '\1[FILTERED]\2').
+          gsub(%r((Number%22%3A%22)[\d]+), '\1[FILTERED]\2').
+          gsub(%r((VerificationCode%22%3A)[\d]+), '\1[FILTERED]\2')
+      end
+
+      def refund(amount, authorization, options = {})
+        currency = options[:currency] || currency(options[:amount])
+        post = {
+          request: {
+            MerchantId: @options[:merchant_id],
+            OrderId: authorization,
+            ReferenceId: options[:order_id] || options[:reference_id],
+            Amount: localized_amount(amount, currency)
+          }
+        }
+        commit('refund', post)
+      end
+
+      def void(authorization, options = {})
+        post = {
+          request: {
+            MerchantId: @options[:merchant_id],
+            OrderId: authorization
+          }
+        }
+
+        commit('cancel', post)
+      end
+
+      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
+
+      private
+
+      def build_checkout_request(amount, payment, options)
+        currency = options[:currency] || currency(options[:amount])
+        {
+          MerchantId: @options[:merchant_id],
+          ReferenceId: options[:order_id],
+          ConsumerCurrency: currency,
+          Capture: options[:capture] || false,
+          PaymentMethod: PAYMENT_METHOD_MAP.fetch(payment.brand.to_sym, 'unsupported'),
+          Items: [
+            Sku: options[:item_sku] || SecureRandom.alphanumeric,
+            ConsumerPrice: localized_amount(amount, currency),
+            Quantity: (options[:item_quantity] || 1)
+          ]
+        }
+      end
+
+      def add_payment(payment, options)
+        ntid = options.dig(:stored_credential, :network_transaction_id)
+        cvv_or_previos_reference = (ntid ? { PreviousNetworkPaymentReference: ntid } : { VerificationCode: payment.verification_value })
+        {
+          Name: payment.name,
+          Number: payment.number,
+          Expiry: { Month: payment.month, Year: payment.year }
+        }.merge!(cvv_or_previos_reference)
+      end
+
+      def add_customer_data(request, options, payment)
+        address = options[:billing_address] || options[:address]
+
+        return if address.blank?
+
+        request[:Consumer] = {
+          Name: payment.respond_to?(:name) ? payment.name : address[:name],
+          Email: options[:email],
+          Address: address[:address1],
+          City: address[:city],
+          Country: address[:country]
+        }.compact
+      end
+
+      def add_stored_credentials(request, options)
+        request[:PaymentModel] = payment_model(options) || ''
+        request[:DeviceFingerprint] = options[:device_fingerprint] if options[:device_fingerprint]
+      end
+
+      def payment_model(options)
+        stored_credential = options[:stored_credential]
+        return options[:payment_model] if options[:payment_model]
+        return 'CIT-One-Time' unless stored_credential
+
+        payment_model_options = {
+          initial_transaction: {
+            'cardholder' => {
+              'installment' => 'CIT-Setup-Scheduled',
+              'unscheduled' => 'CIT-Setup-Unscheduled-MIT',
+              'recurring' => 'CIT-Setup-Unscheduled'
+            }
+          },
+          no_initial_transaction: {
+            'cardholder' => {
+              'unscheduled' => 'CIT-Subsequent-Unscheduled'
+            },
+            'merchant' => {
+              'recurring' => 'MIT-Subsequent-Scheduled',
+              'unscheduled' => 'MIT-Subsequent-Unscheduled'
+            }
+          }
+        }
+        initial = stored_credential[:initial_transaction] ? :initial_transaction : :no_initial_transaction
+        payment_model_options[initial].dig(stored_credential[:initiator], stored_credential[:reason_type])
+      end
+
+      def add_custom_fields_data(request, options)
+        add_shipping_data(request, options) if options[:taxes].present?
+        request[:RateOfferId] = options[:rate_offer_id] if options[:rate_offer_id].present?
+        request[:Items] = options[:items] if options[:items].present?
+      end
+
+      def add_shipping_data(request, options)
+        request[:Shipping] = {
+          ConsumerPrice: options[:price],
+          ConsumerTaxes: options[:taxes],
+          ConsumerDuty: options[:duty]
+        }
+        request[:Consignee] = {
+          Name: options[:consignee_name],
+          Address: options[:consignee_address],
+          City: options[:consignee_city],
+          Country: options[:consignee_country]
+        }
+      end
+
+      def sign_body(body)
+        Base64.strict_encode64(OpenSSL::HMAC.digest('sha256', @options[:secret].encode('utf-8'), body.encode('utf-8')))
+      end
+
+      def parse(body)
+        hash_response = URI.decode_www_form(body).to_h
+        hash_response['response'] = JSON.parse(hash_response['response'])
+
+        hash_response
+      end
+
+      def format_and_sign(post)
+        post[:request] = post[:request].to_json
+        post[:card] = post[:card].to_json if post[:card].present?
+        post[:signature] = sign_body(post[:request])
+        post
+      end
+
+      def get_network_payment_reference(response)
+        parameters = { request: { MerchantId: @options[:merchant_id], OrderId: response.params['response']['OrderId'] } }
+        body = post_data format_and_sign(parameters)
+
+        raw_response = ssl_request :post, url('query'), body, {}
+        response = parse(raw_response)
+        message = response.dig('response', 'Payment', 'NetworkPaymentReference')
+        Response.new(true, message, {})
+      end
+
+      def commit(action, parameters)
+        body = post_data format_and_sign(parameters)
+        raw_response = ssl_post url(action), body
+        response = parse(raw_response)
+
+        Response.new(
+          success_from(response),
+          message_from(response) || '',
+          response,
+          authorization: authorization_from(response['response']),
+          # avs_result: AVSResult.new(code: response['some_avs_response_key']),
+          # cvv_result: CVVResult.new(response['some_cvv_response_key']),
+          test: test?,
+          error_code: error_code_from(response)
+        )
+      rescue ActiveMerchant::ResponseError => e
+        Response.new(false, (e.response.body.present? ? e.response.body : e.response.msg), {}, test: test?)
+      end
+
+      def success_from(response)
+        response.dig('response', 'Error').blank?
+      end
+
+      def message_from(response)
+        success_from(response) ? '' : response.dig('response', 'Error', 'ReasonCode')
+      end
+
+      def authorization_from(response)
+        response['OrderId']
+      end
+
+      def post_data(params)
+        params.map { |k, v| "#{k}=#{CGI.escape(v.to_s)}" }.join('&')
+      end
+
+      def error_code_from(response)
+        response['response']['Error']['Code'] unless success_from(response)
+      end
+
+      def url(action)
+        "#{test? ? test_url : live_url}#{API_VERSION}/#{action}"
+      end
+    end
+  end
+end

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

@@ -91,7 +91,7 @@ module ActiveMerchant #:nodoc:
       # More operations are supported by the gateway itself, but
       # are not supported in this library.
       SUPPORTED_TRANSACTIONS = {
-        purchase:   'A',
+        purchase:   '0',
         authorize:  '1',
         capture:    '2',
         refund:     '3',
@@ -266,9 +266,13 @@ module ActiveMerchant #:nodoc:
       end
 
       def verify(creditcard, options = {})
-        MultiResponse.run(:use_first_response) do |r|
-          r.process { authorize(100, creditcard, options) }
-          r.process(:ignore_result) { void(r.authorization, options) }
+        if options[:sca_exemption_behavior_override] == 'endpoint_and_ntid'
+          purchase(0, creditcard, options)
+        else
+          MultiResponse.run(:use_first_response) do |r|
+            r.process { authorize(100, creditcard, options) }
+            r.process(:ignore_result) { void(r.authorization, options) }
+          end
         end
       end
 
@@ -685,7 +689,7 @@ module ActiveMerchant #:nodoc:
         cipher = OpenSSL::Cipher.new('DES3')
         cipher.encrypt
 
-        cipher.key = Base64.strict_decode64(key)
+        cipher.key = Base64.urlsafe_decode64(key)
         # The OpenSSL default of an all-zeroes ("\\0") IV is used.
         cipher.padding = 0
 

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

@@ -427,7 +427,7 @@ module ActiveMerchant #:nodoc:
       def past_purchase_reference?(payment_method)
         return false unless payment_method.is_a?(String)
 
-        payment_method.split(';').last == 'purchase'
+        %w(purchase repeat).include?(payment_method.split(';').last)
       end
     end
   end

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

@@ -133,6 +133,7 @@ module ActiveMerchant #:nodoc:
         add_creditcard(post, payment, options)
         add_customer(post, payment, options)
         add_customer_data(post, options)
+        add_external_three_ds(post, options)
         if options[:email]
           post[:metadata] = {}
           post[:metadata][:email] = options[:email]
@@ -140,6 +141,40 @@ module ActiveMerchant #:nodoc:
         post
       end
 
+      def add_external_three_ds(post, options)
+        return if options[:three_d_secure].blank?
+
+        post[:threeDSecure] = {
+          external: {
+            version: options[:three_d_secure][:version],
+            authenticationValue: options[:three_d_secure][:cavv],
+            acsTransactionId: options[:three_d_secure][:acs_transaction_id],
+            status: options[:three_d_secure][:authentication_response_status],
+            eci: options[:three_d_secure][:eci]
+          }.merge(xid_or_ds_trans_id(options[:three_d_secure]))
+        }
+      end
+
+      def xid_or_ds_trans_id(three_ds)
+        if three_ds[:version].to_f >= 2.0
+          { dsTransactionId: three_ds[:ds_transaction_id] }
+        else
+          { xid: three_ds[:xid] }
+        end
+      end
+
+      def validate_three_ds_params(three_ds)
+        errors = {}
+        supported_version = %w{1.0.2 2.1.0 2.2.0}.include?(three_ds[:version])
+        supported_auth_response = ['Y', 'N', 'U', 'R', 'E', 'A', nil].include?(three_ds[:status])
+
+        errors[:three_ds_version] = 'ThreeDs version not supported' unless supported_version
+        errors[:auth_response] = 'Authentication response value not supported' unless supported_auth_response
+        errors.compact!
+
+        errors.present? ? Response.new(false, 'ThreeDs data is invalid', errors) : nil
+      end
+
       def add_amount(post, money, options, include_currency = false)
         currency = (options[:currency] || default_currency)
         post[:amount] = localized_amount(money, currency)
@@ -182,6 +217,11 @@ module ActiveMerchant #:nodoc:
       end
 
       def commit(url, parameters = nil, options = {}, method = nil)
+        if parameters.present? && parameters[:threeDSecure].present?
+          three_ds_errors = validate_three_ds_params(parameters[:threeDSecure][:external])
+          return three_ds_errors if three_ds_errors
+        end
+
         response = api_request(url, parameters, options, method)
         success = !response.key?('error')