activemerchant 1.133.0 → 1.137.0

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

@@ -0,0 +1,279 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class DatatransGateway < Gateway
+      self.test_url = 'https://api.sandbox.datatrans.com/v1/'
+      self.live_url = 'https://api.datatrans.com/v1/'
+
+      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: 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: transaction_id })
+      end
+
+      def void(authorization, options = {})
+        post = {}
+        transaction_id = authorization.split('|').first
+        commit('cancel', post, { transaction_id: 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')
+      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[:xid],
+                threeDSTransactionId: three_d_secure[:ds_transaction_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('|')
+        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

@@ -7,7 +7,7 @@ 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]
 
       self.homepage_url = 'http://www.decidir.com'
       self.display_name = 'Decidir'
@@ -127,6 +127,7 @@ 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)
@@ -167,29 +168,55 @@ 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[:token_card_data] = {
+          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 +242,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 +297,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

@@ -321,8 +321,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)