activemerchant 1.133.0 → 1.138.0

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

@@ -0,0 +1,284 @@
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
+    class DatatransGateway < Gateway
+      version 'v1'
+
+      self.test_url = "https://api.sandbox.datatrans.com/#{fetch_version}/"
+      self.live_url = "https://api.datatrans.com/#{fetch_version}/"
+
+      self.supported_countries = %w(CH GR US) # to confirm the countries supported.
+      self.default_currency = 'CHF'
+      self.currencies_without_fractions = %w(CHF EUR USD)
+      self.currencies_with_three_decimal_places = %w()
+      self.supported_cardtypes = %i[master visa american_express unionpay diners_club discover jcb maestro dankort]
+
+      self.money_format = :cents
+
+      self.homepage_url = 'https://www.datatrans.ch/'
+      self.display_name = 'Datatrans'
+
+      CREDIT_CARD_SOURCE = {
+        visa: 'VISA',
+        master: 'MASTERCARD'
+      }.with_indifferent_access
+
+      DEVICE_SOURCE = {
+        apple_pay: 'APPLE_PAY',
+        google_pay: 'GOOGLE_PAY'
+      }.with_indifferent_access
+
+      def initialize(options = {})
+        requires!(options, :merchant_id, :password)
+        @merchant_id, @password = options.values_at(:merchant_id, :password)
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        authorize(money, payment, options.merge(auto_settle: true))
+      end
+
+      def verify(payment, options = {})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(100, payment, options) }
+          r.process(:ignore_result) { void(r.authorization, options) }
+        end
+      end
+
+      def authorize(money, payment, options = {})
+        post = { refno: options.fetch(:order_id, '') }
+        add_payment_method(post, payment)
+        add_3ds_data(post, payment, options)
+        add_currency_amount(post, money, options)
+        add_billing_address(post, options)
+        post[:autoSettle] = options[:auto_settle] if options[:auto_settle]
+        commit('authorize', post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = { refno: options.fetch(:order_id, '') }
+        transaction_id = authorization.split('|').first
+        add_currency_amount(post, money, options)
+        commit('settle', post, { transaction_id: })
+      end
+
+      def refund(money, authorization, options = {})
+        post = { refno: options.fetch(:order_id, '') }
+        transaction_id = authorization.split('|').first
+        add_currency_amount(post, money, options)
+        commit('credit', post, { transaction_id: })
+      end
+
+      def void(authorization, options = {})
+        post = {}
+        transaction_id = authorization.split('|').first
+        commit('cancel', post, { transaction_id: })
+      end
+
+      def store(payment_method, options = {})
+        exp_year = format(payment_method.year, :two_digits)
+        exp_month = format(payment_method.month, :two_digits)
+
+        post = {
+          requests: [
+            {
+              type: 'CARD',
+              pan: payment_method.number,
+              expiryMonth: exp_month,
+              expiryYear: exp_year
+            }
+          ]
+        }
+        commit('tokenize', post, { expiry_month: exp_month, expiry_year: exp_year })
+      end
+
+      def unstore(authorization, options = {})
+        data_alias = authorization.split('|')[2]
+        commit('delete_alias', {}, { alias_id: data_alias }, :delete)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )[\w =]+), '\1[FILTERED]').
+          gsub(%r((\"number\\":\\")\d+), '\1[FILTERED]\2').
+          gsub(%r((\"cvv\\":\\")\d+), '\1[FILTERED]\2').
+          gsub(%r((\"pan\\":\\")\d+), '\1[FILTERED]\2')
+      end
+
+      private
+
+      def add_payment_method(post, payment_method)
+        case payment_method
+        when String
+          token, exp_month, exp_year = payment_method.split('|')[2..4]
+          card = {
+            type: 'ALIAS',
+            alias: token,
+            expiryMonth: exp_month,
+            expiryYear: exp_year
+          }
+        when NetworkTokenizationCreditCard
+          card = {
+            type: DEVICE_SOURCE[payment_method.source] ? 'DEVICE_TOKEN' : 'NETWORK_TOKEN',
+            tokenType: DEVICE_SOURCE[payment_method.source] || CREDIT_CARD_SOURCE[card_brand(payment_method)],
+            token: payment_method.number,
+            cryptogram: payment_method.payment_cryptogram,
+            expiryMonth: format(payment_method.month, :two_digits),
+            expiryYear: format(payment_method.year, :two_digits)
+          }
+        when CreditCard
+          card = {
+            number: payment_method.number,
+            cvv: payment_method.verification_value.to_s,
+            expiryMonth: format(payment_method.month, :two_digits),
+            expiryYear: format(payment_method.year, :two_digits)
+          }
+        end
+        post[:card] = card
+      end
+
+      def add_3ds_data(post, payment_method, options)
+        return unless three_d_secure = options[:three_d_secure]
+
+        three_ds =
+          {
+            '3D':
+              {
+                eci: three_d_secure[:eci],
+                xid: three_d_secure[:ds_transaction_id],
+                threeDSTransactionId: three_d_secure[:three_ds_server_trans_id],
+                cavv: three_d_secure[:cavv],
+                threeDSVersion: three_d_secure[:version],
+                cavvAlgorithm: three_d_secure[:cavv_algorithm],
+                directoryResponse: three_d_secure[:directory_response_status],
+                authenticationResponse: three_d_secure[:authentication_response_status],
+                transStatusReason: three_d_secure[:trans_status_reason]
+              }.compact
+          }
+
+        post[:card].merge!(three_ds)
+      end
+
+      def country_code(country)
+        Country.find(country).code(:alpha3).value if country
+      rescue InvalidCountryCodeError
+        nil
+      end
+
+      def add_billing_address(post, options)
+        return unless billing_address = options[:billing_address]
+
+        post[:billing] = {
+          name: billing_address[:name],
+          street: billing_address[:address1],
+          street2: billing_address[:address2],
+          city: billing_address[:city],
+          country: country_code(billing_address[:country]),
+          phoneNumber: billing_address[:phone],
+          zipCode: billing_address[:zip],
+          email: options[:email]
+        }.compact
+      end
+
+      def add_currency_amount(post, money, options)
+        post[:currency] = (options[:currency] || currency(money))
+        post[:amount] = amount(money)
+      end
+
+      def commit(action, post, options = {}, method = :post)
+        response = parse(ssl_request(method, url(action, options), post.to_json, headers))
+        succeeded = success_from(action, response)
+
+        Response.new(
+          succeeded,
+          message_from(succeeded, response),
+          response,
+          authorization: authorization_from(response, action, options),
+          test: test?,
+          error_code: error_code_from(response)
+        )
+      rescue ResponseError => e
+        response = parse(e.response.body)
+        Response.new(false, message_from(false, response), response, test: test?, error_code: error_code_from(response))
+      end
+
+      def parse(response)
+        JSON.parse response
+      rescue JSON::ParserError
+        msg = 'Invalid JSON response received from Datatrans. Please contact them for support if you continue to receive this message.'
+        msg += "  (The raw response returned by the API was #{response.inspect})"
+        {
+          'successful' => false,
+          'response' => {},
+          'errors' => [msg]
+        }
+      end
+
+      def headers
+        {
+          'Content-Type' => 'application/json; charset=UTF-8',
+          'Authorization' => "Basic #{Base64.strict_encode64("#{@merchant_id}:#{@password}")}"
+        }
+      end
+
+      def url(endpoint, options = {})
+        case endpoint
+        when 'settle', 'credit', 'cancel'
+          "#{test? ? test_url : live_url}transactions/#{options[:transaction_id]}/#{endpoint}"
+        when 'tokenize'
+          "#{test? ? test_url : live_url}aliases/#{endpoint}"
+        when 'delete_alias'
+          "#{test? ? test_url : live_url}aliases/#{options[:alias_id]}"
+        else
+          "#{test? ? test_url : live_url}transactions/#{endpoint}"
+        end
+      end
+
+      def success_from(action, response)
+        case action
+        when 'authorize', 'credit'
+          response.include?('transactionId') && response.include?('acquirerAuthorizationCode')
+        when 'settle', 'cancel'
+          response.dig('response_code') == 204
+        when 'tokenize'
+          response.dig('responses', 0, 'alias') && response.dig('overview', 'failed') == 0
+        when 'delete_alias'
+          response.dig('response_code') == 204
+        else
+          false
+        end
+      end
+
+      def authorization_from(response, action, options)
+        token_array = [response.dig('responses', 0, 'alias'), options[:expiry_month], options[:expiry_year]].join('|') if action == 'tokenize'
+
+        auth = [response['transactionId'], response['acquirerAuthorizationCode'], token_array].join('|')
+        auth = options[:transaction_id] if action == 'settle'
+
+        return auth unless auth == '||'
+      end
+
+      def message_from(succeeded, response)
+        return if succeeded
+
+        response.dig('error', 'message')
+      end
+
+      def error_code_from(response)
+        response.dig('error', 'code')
+      end
+
+      def handle_response(response)
+        case response.code.to_i
+        when 200...300
+          response.body || { response_code: response.code.to_i }.to_json
+        else
+          raise ResponseError.new(response)
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,5 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class DecidirGateway < Gateway
       self.test_url = 'https://developers.decidir.com/api/v2'
       self.live_url = 'https://live.decidir.com/api/v2'
@@ -7,12 +7,13 @@ module ActiveMerchant #:nodoc:
       self.supported_countries = ['AR']
       self.money_format = :cents
       self.default_currency = 'ARS'
-      self.supported_cardtypes = %i[visa master american_express diners_club naranja cabal]
+      self.supported_cardtypes = %i[visa master american_express diners_club naranja cabal tuya patagonia_365 tarjeta_sol discover]
 
       self.homepage_url = 'http://www.decidir.com'
       self.display_name = 'Decidir'
 
       STANDARD_ERROR_CODE_MAPPING = {
+        -1 => STANDARD_ERROR_CODE[:processing_error],
         1 => STANDARD_ERROR_CODE[:call_issuer],
         2 => STANDARD_ERROR_CODE[:call_issuer],
         3 => STANDARD_ERROR_CODE[:config_error],
@@ -106,7 +107,9 @@ module ActiveMerchant #:nodoc:
           gsub(%r((apikey: )\w+)i, '\1[FILTERED]').
           gsub(%r((\"card_number\\\":\\\")\d+), '\1[FILTERED]').
           gsub(%r((\"security_code\\\":\\\")\d+), '\1[FILTERED]').
-          gsub(%r((\"emv_issuer_data\\\":\\\")\d+), '\1[FILTERED]')
+          gsub(%r((\"emv_issuer_data\\\":\\\")\d+), '\1[FILTERED]').
+          gsub(%r((\"cryptogram\\\":\\\"/)\w+), '\1[FILTERED]').
+          gsub(%r((\"token_card_data\\\":{.*\\\"token\\\":\\\")\d+), '\1[FILTERED]')
       end
 
       private
@@ -116,6 +119,7 @@ module ActiveMerchant #:nodoc:
         post[:site_transaction_id] = options[:order_id]
         post[:bin] = credit_card.number[0..5]
         post[:payment_type] = options[:payment_type] || 'single'
+        post[:wallet_id] = options[:wallet_id] if options[:wallet_id]
         post[:installments] = options[:installments] ? options[:installments].to_i : 1
         post[:description] = options[:description] if options[:description]
         post[:email] = options[:email] if options[:email]
@@ -127,34 +131,29 @@ module ActiveMerchant #:nodoc:
         add_payment(post, credit_card, options)
         add_aggregate_data(post, options) if options[:aggregate_data]
         add_sub_payments(post, options)
+        add_customer_data(post, options)
       end
 
       def add_payment_method_id(credit_card, options)
-        if options[:payment_method_id]
-          options[:payment_method_id].to_i
-        elsif options[:debit]
-          if CreditCard.brand?(credit_card.number) == 'visa'
-            31
-          elsif CreditCard.brand?(credit_card.number) == 'master'
-            105
-          elsif CreditCard.brand?(credit_card.number) == 'maestro'
-            106
-          elsif CreditCard.brand?(credit_card.number) == 'cabal'
-            108
-          end
-        elsif CreditCard.brand?(credit_card.number) == 'master'
-          104
-        elsif CreditCard.brand?(credit_card.number) == 'american_express'
-          65
-        elsif CreditCard.brand?(credit_card.number) == 'diners_club'
-          8
-        elsif CreditCard.brand?(credit_card.number) == 'cabal'
-          63
-        elsif CreditCard.brand?(credit_card.number) == 'naranja'
-          24
-        else
-          1
-        end
+        return options[:payment_method_id].to_i if options[:payment_method_id]
+
+        card_brand = CreditCard.brand?(credit_card.number)
+        debit = options[:debit]
+
+        payment_method_ids = {
+          'visa' => debit ? 31 : 1,
+          'master' => debit ? 105 : 104,
+          'maestro' => 106,
+          'cabal' => debit ? 108 : 63,
+          'american_express' => 65,
+          'diners_club' => 8,
+          'naranja' => 24,
+          'patagonia_365' => 55,
+          'tarjeta_sol' => 64,
+          'discover' => 139
+        }
+
+        payment_method_ids.fetch(card_brand, 1)
       end
 
       def add_invoice(post, money, options)
@@ -167,29 +166,58 @@ module ActiveMerchant #:nodoc:
         post[:amount] = localized_amount(money, currency).to_i
       end
 
-      def add_payment(post, credit_card, options)
-        card_data = {}
+      def add_payment(post, payment_method, options)
+        add_common_payment_data(post, payment_method, options)
+
+        case payment_method
+        when NetworkTokenizationCreditCard
+          add_network_token(post, payment_method, options)
+        else
+          add_credit_card(post, payment_method, options)
+        end
+      end
+
+      def add_common_payment_data(post, payment_method, options)
+        post[:card_data] = {}
+
+        data = post[:card_data]
+        data[:card_holder_identification] = {}
+        data[:card_holder_identification][:type] = options[:card_holder_identification_type] if options[:card_holder_identification_type]
+        data[:card_holder_identification][:number] = options[:card_holder_identification_number] if options[:card_holder_identification_number]
+        data[:card_holder_name] = payment_method.name if payment_method.name
+
+        # additional data used for Visa transactions
+        data[:card_holder_door_number] = options[:card_holder_door_number].to_i if options[:card_holder_door_number]
+        data[:card_holder_birthday] = options[:card_holder_birthday] if options[:card_holder_birthday]
+      end
+
+      def add_network_token(post, payment_method, options)
+        post[:is_tokenized_payment] = true
+        post[:fraud_detection] ||= {}
+        post[:fraud_detection][:sent_to_cs] = false
+        post[:card_data][:last_four_digits] = options[:last_4]
+        post[:card_data][:security_code] = payment_method.verification_value if payment_method.verification_value?
+
+        post[:token_card_data] = {
+          expiration_month: format(payment_method.month, :two_digits),
+          expiration_year: format(payment_method.year, :two_digits),
+          token: payment_method.number,
+          eci: payment_method.eci,
+          cryptogram: payment_method.payment_cryptogram
+        }
+      end
+
+      def add_credit_card(post, credit_card, options)
+        card_data = post[:card_data]
         card_data[:card_number] = credit_card.number
         card_data[:card_expiration_month] = format(credit_card.month, :two_digits)
         card_data[:card_expiration_year] = format(credit_card.year, :two_digits)
         card_data[:security_code] = credit_card.verification_value if credit_card.verification_value?
-        card_data[:card_holder_name] = credit_card.name if credit_card.name
 
         # the device_unique_id has to be sent in via the card data (as device_unique_identifier) no other fraud detection fields require this
-        if options[:fraud_detection].present?
-          card_data[:fraud_detection] = {} if (options[:fraud_detection][:device_unique_id]).present?
-          card_data[:fraud_detection][:device_unique_identifier] = (options[:fraud_detection][:device_unique_id]) if (options[:fraud_detection][:device_unique_id]).present?
+        if (device_id = options.dig(:fraud_detection, :device_unique_id))
+          card_data[:fraud_detection] = { device_unique_identifier: device_id }
         end
-
-        # additional data used for Visa transactions
-        card_data[:card_holder_door_number] = options[:card_holder_door_number].to_i if options[:card_holder_door_number]
-        card_data[:card_holder_birthday] = options[:card_holder_birthday] if options[:card_holder_birthday]
-
-        card_data[:card_holder_identification] = {}
-        card_data[:card_holder_identification][:type] = options[:card_holder_identification_type] if options[:card_holder_identification_type]
-        card_data[:card_holder_identification][:number] = options[:card_holder_identification_number] if options[:card_holder_identification_number]
-
-        post[:card_data] = card_data
       end
 
       def add_aggregate_data(post, options)
@@ -215,6 +243,14 @@ module ActiveMerchant #:nodoc:
         post[:aggregate_data] = aggregate_data
       end
 
+      def add_customer_data(post, options = {})
+        return unless options[:customer_email] || options[:customer_id]
+
+        post[:customer] = {}
+        post[:customer][:id] = options[:customer_id] if options[:customer_id]
+        post[:customer][:email] = options[:customer_email] if options[:customer_email]
+      end
+
       def add_sub_payments(post, options)
         # sub_payments field is required for purchase transactions, even if empty
         post[:sub_payments] = []
@@ -262,7 +298,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def commit(method, endpoint, parameters, options = {})
-        url = "#{(test? ? test_url : live_url)}/#{endpoint}"
+        url = "#{test? ? test_url : live_url}/#{endpoint}"
 
         begin
           raw_response = ssl_request(method, url, post_data(parameters), headers(options))

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

@@ -1,12 +1,12 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
+module ActiveMerchant # :nodoc:
+  module Billing # :nodoc:
     class DecidirPlusGateway < Gateway
       self.test_url = 'https://developers.decidir.com/api/v2'
       self.live_url = 'https://live.decidir.com/api/v2'
 
       self.supported_countries = ['AR']
       self.default_currency = 'ARS'
-      self.supported_cardtypes = %i[visa master american_express discover diners_club naranja cabal]
+      self.supported_cardtypes = %i[visa master american_express discover diners_club naranja cabal patagonia_365 tarjeta_sol discover]
 
       self.homepage_url = 'http://decidir.com.ar/home'
       self.display_name = 'Decidir Plus'
@@ -93,6 +93,12 @@ module ActiveMerchant #:nodoc:
         authorization.split('|')[0]
       end
 
+      def add_wallet_id(post, options)
+        return unless options[:wallet_id]
+
+        post[:wallet_id] = options[:wallet_id]
+      end
+
       def add_payment(post, payment, options = {})
         if payment.is_a?(String)
           token, bin = payment.split('|')
@@ -133,6 +139,7 @@ module ActiveMerchant #:nodoc:
 
         add_aggregate_data(post, options) if options[:aggregate_data]
         add_sub_payments(post, options)
+        add_wallet_id(post, options)
       end
 
       def add_aggregate_data(post, options)
@@ -177,37 +184,23 @@ module ActiveMerchant #:nodoc:
       def add_payment_method_id(options)
         return options[:payment_method_id].to_i if options[:payment_method_id]
 
-        if options[:debit]
-          case options[:card_brand]
-          when 'visa'
-            31
-          when 'master'
-            105
-          when 'maestro'
-            106
-          when 'cabal'
-            108
-          else
-            31
-          end
-        else
-          case options[:card_brand]
-          when 'visa'
-            1
-          when 'master'
-            104
-          when 'american_express'
-            65
-          when 'american_express_prisma'
-            111
-          when 'cabal'
-            63
-          when 'diners_club'
-            8
-          else
-            1
-          end
-        end
+        card_brand = options[:card_brand]
+        debit = options[:debit]
+
+        payment_method_ids = {
+          'visa' => debit ? 31 : 1,
+          'master' => debit ? 105 : 104,
+          'maestro' => 106,
+          'cabal' => debit ? 108 : 63,
+          'american_express' => 65,
+          'american_express_prisma' => 111,
+          'diners_club' => 8,
+          'patagonia_365' => 55,
+          'tarjeta_sol' => 64,
+          'discover' => 139
+        }
+
+        payment_method_ids.fetch(card_brand, debit ? 31 : 1)
       end
 
       def add_fraud_detection(post, options)
@@ -321,8 +314,11 @@ module ActiveMerchant #:nodoc:
         return error_code_from(response) unless validation_errors = response.dig('validation_errors')
 
         validation_errors = validation_errors[0]
+        message = "#{validation_errors&.dig('code')}: #{validation_errors&.dig('param')}"
+        return message unless message == ': '
 
-        "#{validation_errors.dig('code')}: #{validation_errors.dig('param')}"
+        errors = response['validation_errors'].map { |k, v| "#{k}: #{v}" }.join(', ')
+        "#{response['error_type']} - #{errors}"
       end
 
       def rejected?(response)