activemerchant 1.94.0 → 1.99.0

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

@@ -6,6 +6,10 @@ module ActiveMerchant #:nodoc:
       self.display_name = 'Credorax Gateway'
       self.homepage_url = 'https://www.credorax.com/'
 
+      # NOTE: the IP address you run the remote tests from will need to be
+      # whitelisted by Credorax; contact support@credorax.com as necessary to
+      # request your IP address be added to the whitelist for your test
+      # account.
       self.test_url = 'https://intconsole.credorax.com/intenv/service/gateway'
 
       # The live URL is assigned on a per merchant basis once certification has passed
@@ -15,7 +19,7 @@ module ActiveMerchant #:nodoc:
       # ActiveMerchant::Billing::CredoraxGateway.live_url = "https://assigned-subdomain.credorax.net/crax_gate/service/gateway"
       self.live_url = 'https://assigned-subdomain.credorax.net/crax_gate/service/gateway'
 
-      self.supported_countries = %w(DE GB FR IT ES PL NL BE GR CZ PT SE HU RS AT CH BG DK FI SK NO IE HR BA AL LT MK SI LV EE ME LU MT IS AD MC LI SM)
+      self.supported_countries = %w(AD AT BE BG HR CY CZ DK EE FR DE GI GR GG HU IS IE IM IT JE LV LI LT LU MT MC NO PL PT RO SM SK ES SE CH GB)
       self.default_currency = 'EUR'
       self.currencies_without_fractions = %w(CLP JPY KRW PYG VND)
       self.currencies_with_three_decimal_places = %w(BHD JOD KWD OMR RSD TND)
@@ -131,6 +135,7 @@ module ActiveMerchant #:nodoc:
         add_echo(post, options)
         add_submerchant_id(post, options)
         add_transaction_type(post, options)
+        add_processor(post, options)
 
         commit(:purchase, post)
       end
@@ -145,6 +150,7 @@ module ActiveMerchant #:nodoc:
         add_echo(post, options)
         add_submerchant_id(post, options)
         add_transaction_type(post, options)
+        add_processor(post, options)
 
         commit(:authorize, post)
       end
@@ -156,6 +162,7 @@ module ActiveMerchant #:nodoc:
         add_customer_data(post, options)
         add_echo(post, options)
         add_submerchant_id(post, options)
+        add_processor(post, options)
 
         commit(:capture, post)
       end
@@ -167,6 +174,7 @@ module ActiveMerchant #:nodoc:
         add_echo(post, options)
         add_submerchant_id(post, options)
         post[:a1] = generate_unique_id
+        add_processor(post, options)
 
         commit(:void, post, reference_action)
       end
@@ -178,6 +186,7 @@ module ActiveMerchant #:nodoc:
         add_customer_data(post, options)
         add_echo(post, options)
         add_submerchant_id(post, options)
+        add_processor(post, options)
 
         commit(:refund, post)
       end
@@ -191,6 +200,7 @@ module ActiveMerchant #:nodoc:
         add_echo(post, options)
         add_submerchant_id(post, options)
         add_transaction_type(post, options)
+        add_processor(post, options)
 
         commit(:credit, post)
       end
@@ -264,8 +274,56 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_3d_secure(post, options)
-        return unless options[:eci] && options[:xid]
-        post[:i8] = "#{options[:eci]}:#{(options[:cavv] || "none")}:#{options[:xid]}"
+        if options[:eci] && options[:xid]
+          add_3d_secure_1_data(post, options)
+        elsif options[:execute_threed] && options[:three_ds_2]
+          three_ds_2_options = options[:three_ds_2]
+          browser_info = three_ds_2_options[:browser_info]
+          post[:'3ds_initiate'] = options[:three_ds_initiate] || '01'
+          post[:'3ds_purchasedate'] = Time.now.utc.strftime('%Y%m%d%I%M%S')
+          post[:'3ds_channel'] = '02'
+          post[:'3ds_redirect_url'] = three_ds_2_options[:notification_url]
+          post[:'3ds_challengewindowsize'] = options[:three_ds_challenge_window_size] || '03'
+          post[:'3ds_version'] = options[:three_ds_version] if options[:three_ds_version]
+          post[:d5] = browser_info[:user_agent]
+          post[:'3ds_transtype'] = options[:transaction_type] || '01'
+          post[:'3ds_browsertz'] = browser_info[:timezone]
+          post[:'3ds_browserscreenwidth'] = browser_info[:width]
+          post[:'3ds_browserscreenheight'] = browser_info[:height]
+          post[:'3ds_browsercolordepth'] = browser_info[:depth]
+          post[:d6] = browser_info[:language]
+          post[:'3ds_browserjavaenabled'] = browser_info[:java]
+          post[:'3ds_browseracceptheader'] = browser_info[:accept_header]
+          if (shipping_address = options[:shipping_address])
+            post[:'3ds_shipaddrstate'] = shipping_address[:state]
+            post[:'3ds_shipaddrpostcode'] = shipping_address[:zip]
+            post[:'3ds_shipaddrline2'] = shipping_address[:address2]
+            post[:'3ds_shipaddrline1'] = shipping_address[:address1]
+            post[:'3ds_shipaddrcountry'] = shipping_address[:country]
+            post[:'3ds_shipaddrcity'] = shipping_address[:city]
+          end
+        elsif options[:three_d_secure]
+          add_normalized_3d_secure_2_data(post, options)
+        end
+      end
+
+      def add_3d_secure_1_data(post, options)
+        post[:i8] = build_i8(options[:eci], options[:cavv], options[:xid])
+      end
+
+      def add_normalized_3d_secure_2_data(post, options)
+        three_d_secure_options = options[:three_d_secure]
+
+        post[:i8] = build_i8(
+          three_d_secure_options[:eci],
+          three_d_secure_options[:cavv]
+        )
+        post[:'3ds_version'] = three_d_secure_options[:version]
+        post[:'3ds_dstrxid'] = three_d_secure_options[:ds_transaction_id]
+      end
+
+      def build_i8(eci, cavv=nil, xid=nil)
+        "#{eci}:#{cavv || 'none'}:#{xid || 'none'}"
       end
 
       def add_echo(post, options)
@@ -280,6 +338,12 @@ module ActiveMerchant #:nodoc:
 
       def add_transaction_type(post, options)
         post[:a9] = options[:transaction_type] if options[:transaction_type]
+        post[:a2] = '3' if options.dig(:metadata, :manual_entry)
+      end
+
+      def add_processor(post, options)
+        post[:r1] = options[:processor] || 'CREDORAX'
+        post[:r2] = options[:processor_merchant_id] if options[:processor_merchant_id]
       end
 
       ACTIONS = {
@@ -291,7 +355,8 @@ module ActiveMerchant #:nodoc:
         credit: '6',
         purchase_void: '7',
         refund_void: '8',
-        capture_void: '9'
+        capture_void: '9',
+        threeds_completion: '92'
       }
 
       def commit(action, params, reference_action = nil)

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

@@ -1,7 +1,7 @@
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     # Initial setup instructions can be found in
-    # http://cybersource.com/support_center/implementation/downloads/soap_api/SOAP_toolkits.pdf
+    # http://apps.cybersource.com/library/documentation/dev_guides/SOAP_Toolkits/SOAP_toolkits.pdf
     #
     # Important Notes
     # * For checks you can purchase and store.
@@ -24,10 +24,12 @@ module ActiveMerchant #:nodoc:
       self.test_url = 'https://ics2wstesta.ic3.com/commerce/1.x/transactionProcessor'
       self.live_url = 'https://ics2wsa.ic3.com/commerce/1.x/transactionProcessor'
 
-      XSD_VERSION = '1.153'
+      # Schema files can be found here: https://ics2ws.ic3.com/commerce/1.x/transactionProcessor/
+      TEST_XSD_VERSION = '1.159'
+      PRODUCTION_XSD_VERSION = '1.159'
 
       self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb, :dankort, :maestro, :elo]
-      self.supported_countries = %w(US BR CA CN DK FI FR DE IN JP MX NO SE GB SG LB)
+      self.supported_countries = %w(US BR CA CN DK FI FR DE IN JP MX NO SE GB SG LB PK)
 
       self.default_currency = 'USD'
       self.currencies_without_fractions = %w(JPY)
@@ -256,6 +258,7 @@ module ActiveMerchant #:nodoc:
       def build_auth_request(money, creditcard_or_reference, options)
         xml = Builder::XmlMarkup.new :indent => 2
         add_payment_method_or_subscription(xml, money, creditcard_or_reference, options)
+        add_threeds_2_ucaf_data(xml, creditcard_or_reference, options)
         add_decision_manager_fields(xml, options)
         add_mdd_fields(xml, options)
         add_auth_service(xml, creditcard_or_reference, options)
@@ -263,6 +266,8 @@ module ActiveMerchant #:nodoc:
         add_payment_network_token(xml) if network_tokenization?(creditcard_or_reference)
         add_business_rules_data(xml, creditcard_or_reference, options)
         add_stored_credential_options(xml, options)
+        add_issuer_additional_data(xml, options)
+
         xml.target!
       end
 
@@ -291,6 +296,7 @@ module ActiveMerchant #:nodoc:
       def build_purchase_request(money, payment_method_or_reference, options)
         xml = Builder::XmlMarkup.new :indent => 2
         add_payment_method_or_subscription(xml, money, payment_method_or_reference, options)
+        add_threeds_2_ucaf_data(xml, payment_method_or_reference, options)
         add_decision_manager_fields(xml, options)
         add_mdd_fields(xml, options)
         if !payment_method_or_reference.is_a?(String) && card_brand(payment_method_or_reference) == 'check'
@@ -301,6 +307,8 @@ module ActiveMerchant #:nodoc:
           add_payment_network_token(xml) if network_tokenization?(payment_method_or_reference)
           add_business_rules_data(xml, payment_method_or_reference, options) unless options[:pinless_debit_card]
         end
+        add_issuer_additional_data(xml, options)
+
         xml.target!
       end
 
@@ -485,6 +493,14 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_issuer_additional_data(xml, options)
+        return unless options[:issuer_additional_data]
+
+        xml.tag! 'issuer' do
+          xml.tag! 'additionalData', options[:issuer_additional_data]
+        end
+      end
+
       def add_mdd_fields(xml, options)
         return unless options.keys.any? { |key| key.to_s.start_with?('mdd_field') }
 
@@ -516,19 +532,41 @@ module ActiveMerchant #:nodoc:
           add_auth_network_tokenization(xml, payment_method, options)
         else
           xml.tag! 'ccAuthService', {'run' => 'true'} do
-            check_for_stored_cred_commerce_indicator(xml, options)
+            if options[:three_d_secure]
+              add_normalized_threeds_2_data(xml, payment_method, options)
+            else
+              indicator = options[:commerce_indicator] || stored_credential_commerce_indicator(options)
+              xml.tag!('commerceIndicator', indicator) if indicator
+            end
           end
         end
       end
 
-      def check_for_stored_cred_commerce_indicator(xml, options)
-        return unless options[:stored_credential]
-        if commerce_indicator(options)
-          xml.tag!('commerceIndicator', commerce_indicator(options))
+      def add_normalized_threeds_2_data(xml, payment_method, options)
+        threeds_2_options = options[:three_d_secure]
+
+        xml.tag!('cavv', threeds_2_options[:cavv]) if threeds_2_options[:cavv] && card_brand(payment_method).to_sym != :master
+        xml.tag!('cavvAlgorithm', threeds_2_options[:cavv_algorithm]) if threeds_2_options[:cavv_algorithm]
+        xml.tag!('paSpecificationVersion', threeds_2_options[:version]) if threeds_2_options[:version]
+        xml.tag!('directoryServerTransactionID', threeds_2_options[:ds_transaction_id]) if threeds_2_options[:ds_transaction_id]
+        xml.tag!('commerceIndicator', options[:commerce_indicator]) if options[:commerce_indicator]
+        xml.tag!('eciRaw', threeds_2_options[:eci]) if threeds_2_options[:eci]
+        xml.tag!('xid', threeds_2_options[:xid]) if threeds_2_options[:xid]
+        xml.tag!('veresEnrolled', threeds_2_options[:enrolled]) if threeds_2_options[:enrolled]
+        xml.tag!('paresStatus', threeds_2_options[:authentication_response_status]) if threeds_2_options[:authentication_response_status]
+      end
+
+      def add_threeds_2_ucaf_data(xml, payment_method, options)
+        return unless options[:three_d_secure] && card_brand(payment_method).to_sym == :master
+
+        xml.tag! 'ucaf' do
+          xml.tag!('authenticationData', options[:three_d_secure][:cavv])
+          xml.tag!('collectionIndicator', options[:collection_indicator]) if options[:collection_indicator]
         end
       end
 
-      def commerce_indicator(options)
+      def stored_credential_commerce_indicator(options)
+        return unless options[:stored_credential]
         return if options[:stored_credential][:initial_transaction]
         case options[:stored_credential][:reason_type]
         when 'installment' then 'install'
@@ -550,7 +588,7 @@ module ActiveMerchant #:nodoc:
             xml.tag!('commerceIndicator', 'vbv')
             xml.tag!('xid', payment_method.payment_cryptogram)
           end
-        when :mastercard
+        when :master
           xml.tag! 'ucaf' do
             xml.tag!('authenticationData', payment_method.payment_cryptogram)
             xml.tag!('collectionIndicator', '2')
@@ -713,6 +751,8 @@ module ActiveMerchant #:nodoc:
 
       # Where we actually build the full SOAP request using builder
       def build_request(body, options)
+        xsd_version = test? ? TEST_XSD_VERSION : PRODUCTION_XSD_VERSION
+
         xml = Builder::XmlMarkup.new :indent => 2
         xml.instruct!
         xml.tag! 's:Envelope', {'xmlns:s' => 'http://schemas.xmlsoap.org/soap/envelope/'} do
@@ -725,7 +765,7 @@ module ActiveMerchant #:nodoc:
             end
           end
           xml.tag! 's:Body', {'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance', 'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema'} do
-            xml.tag! 'requestMessage', {'xmlns' => "urn:schemas-cybersource-com:transaction-data-#{XSD_VERSION}"} do
+            xml.tag! 'requestMessage', {'xmlns' => "urn:schemas-cybersource-com:transaction-data-#{xsd_version}"} do
               add_merchant_data(xml, options)
               xml << body
             end

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

@@ -6,7 +6,7 @@ module ActiveMerchant #:nodoc:
 
       self.supported_countries = ['AR', 'BR', 'CL', 'CO', 'MX', 'PE', 'UY', 'TR']
       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://dlocal.com/'
       self.display_name = 'dLocal'

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

@@ -0,0 +1,245 @@
+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'
+
+      self.supported_countries = ['AR']
+      self.money_format = :cents
+      self.default_currency = 'ARS'
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club, :naranja, :cabal]
+
+      self.homepage_url = 'http://www.decidir.com'
+      self.display_name = 'Decidir'
+
+      STANDARD_ERROR_CODE_MAPPING = {
+        1 => STANDARD_ERROR_CODE[:call_issuer],
+        2 => STANDARD_ERROR_CODE[:call_issuer],
+        3 => STANDARD_ERROR_CODE[:config_error],
+        4 => STANDARD_ERROR_CODE[:pickup_card],
+        5 => STANDARD_ERROR_CODE[:card_declined],
+        7 => STANDARD_ERROR_CODE[:pickup_card],
+        12 => STANDARD_ERROR_CODE[:processing_error],
+        14 => STANDARD_ERROR_CODE[:invalid_number],
+        28 => STANDARD_ERROR_CODE[:processing_error],
+        38 => STANDARD_ERROR_CODE[:incorrect_pin],
+        39 => STANDARD_ERROR_CODE[:invalid_number],
+        43 => STANDARD_ERROR_CODE[:pickup_card],
+        45 => STANDARD_ERROR_CODE[:card_declined],
+        46 => STANDARD_ERROR_CODE[:invalid_number],
+        47 => STANDARD_ERROR_CODE[:card_declined],
+        48 => STANDARD_ERROR_CODE[:card_declined],
+        49 => STANDARD_ERROR_CODE[:invalid_expiry_date],
+        51 => STANDARD_ERROR_CODE[:card_declined],
+        53 => STANDARD_ERROR_CODE[:card_declined],
+        54 => STANDARD_ERROR_CODE[:expired_card],
+        55 => STANDARD_ERROR_CODE[:incorrect_pin],
+        56 => STANDARD_ERROR_CODE[:card_declined],
+        57 => STANDARD_ERROR_CODE[:card_declined],
+        76 => STANDARD_ERROR_CODE[:call_issuer],
+        96 => STANDARD_ERROR_CODE[:processing_error],
+        97 => STANDARD_ERROR_CODE[:processing_error],
+      }
+
+      def initialize(options={})
+        requires!(options, :api_key)
+        super
+        @options[:preauth_mode] ||= false
+      end
+
+      def purchase(money, payment, options={})
+        raise ArgumentError, 'Purchase is not supported on Decidir gateways configured with the preauth_mode option' if @options[:preauth_mode]
+
+        post = {}
+        add_auth_purchase_params(post, money, payment, options)
+        commit(:post, 'payments', post)
+      end
+
+      def authorize(money, payment, options={})
+        raise ArgumentError, 'Authorize is not supported on Decidir gateways unless the preauth_mode option is enabled' unless @options[:preauth_mode]
+
+        post = {}
+        add_auth_purchase_params(post, money, payment, options)
+        commit(:post, 'payments', post)
+      end
+
+      def capture(money, authorization, options={})
+        raise ArgumentError, 'Capture is not supported on Decidir gateways unless the preauth_mode option is enabled' unless @options[:preauth_mode]
+
+        post = {}
+        add_amount(post, money, options)
+        commit(:put, "payments/#{authorization}", post)
+      end
+
+      def refund(money, authorization, options={})
+        post = {}
+        add_amount(post, money, options)
+        commit(:post, "payments/#{authorization}/refunds", post)
+      end
+
+      def void(authorization, options={})
+        post = {}
+        commit(:post, "payments/#{authorization}/refunds", post)
+      end
+
+      def verify(credit_card, options={})
+        raise ArgumentError, 'Verify is not supported on Decidir gateways unless the preauth_mode option is enabled' unless @options[:preauth_mode]
+
+        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 supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          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]')
+      end
+
+      private
+
+      def add_auth_purchase_params(post, money, credit_card, options)
+        post[:payment_method_id] = add_payment_method_id(credit_card)
+        post[:site_transaction_id] = options[:order_id]
+        post[:bin] = credit_card.number[0..5]
+        post[:payment_type] = options[:payment_type] || 'single'
+        post[:installments] = options[:installments] ? options[:installments].to_i : 1
+        post[:description] = options[:description] if options[:description]
+        post[:email] = options[:email] if options[:email]
+        post[:sub_payments] = []
+
+        add_invoice(post, money, options)
+        add_payment(post, credit_card, options)
+      end
+
+      def add_payment_method_id(credit_card)
+        if options[:payment_method_id]
+          options[:payment_method_id].to_i
+        elsif CreditCard.brand?(credit_card.number) == 'cabal'
+          63
+        elsif CreditCard.brand?(credit_card.number) == 'naranja'
+          24
+        else
+          1
+        end
+      end
+
+      def add_invoice(post, money, options)
+        add_amount(post, money, options)
+        post[:currency] = (options[:currency] || currency(money))
+      end
+
+      def add_amount(post, money, options)
+        currency = (options[:currency] || currency(money))
+        post[:amount] = localized_amount(money, currency).to_i
+      end
+
+      def add_payment(post, credit_card, options)
+        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
+
+        # 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 headers(options = {})
+        {
+          'apikey' => @options[:api_key],
+          'Content-type'  => 'application/json',
+          'Cache-Control' => 'no-cache'
+        }
+      end
+
+      def commit(method, endpoint, parameters, options={})
+        url = "#{(test? ? test_url : live_url)}/#{endpoint}"
+
+        begin
+          raw_response = ssl_request(method, url, post_data(parameters), headers(options))
+          response = parse(raw_response)
+        rescue ResponseError => e
+          raw_response = e.response.body
+          response = parse(raw_response)
+        end
+
+        success = success_from(response)
+        Response.new(
+          success,
+          message_from(success, response),
+          response,
+          authorization: authorization_from(response),
+          test: test?,
+          error_code: success ? nil : error_code_from(response)
+        )
+      end
+
+      def post_data(parameters = {})
+        parameters.to_json
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      rescue JSON::ParserError
+        {
+          'message' => "A non-JSON response was received from Decidir where one was expected. The raw response was:\n\n#{body}"
+        }
+      end
+
+      def message_from(success, response)
+        return response['status'] if success
+        return response['message'] if response['message']
+
+        message = nil
+
+        if error = response.dig('status_details', 'error')
+          message = error.dig('reason', 'description')
+        elsif response['error_type']
+          if response['validation_errors']
+            message = response['validation_errors'].map { |errors| "#{errors['code']}: #{errors['param']}" }.join(', ')
+          end
+          message ||= response['error_type']
+        end
+
+        message
+      end
+
+      def success_from(response)
+        response['status'] == 'approved' || response['status'] == 'pre_approved'
+      end
+
+      def authorization_from(response)
+        response['id']
+      end
+
+      def error_code_from(response)
+        error_code = nil
+        if error = response.dig('status_details', 'error')
+          code = error.dig('reason', 'id')
+          error_code = STANDARD_ERROR_CODE_MAPPING[code]
+          error_code ||= error['type']
+        elsif response['error_type']
+          error_code = response['error_type'] if response['validation_errors']
+        end
+
+        error_code || STANDARD_ERROR_CODE[:processing_error]
+      end
+    end
+  end
+end