activemerchant 1.100.0 → 1.133.0

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

@@ -4,40 +4,43 @@ module ActiveMerchant #:nodoc:
       self.test_url = 'https://sandbox.dlocal.com'
       self.live_url = 'https://api.dlocal.com'
 
-      self.supported_countries = ['AR', 'BR', 'CL', 'CO', 'MX', 'PE', 'UY', 'TR']
+      self.supported_countries = %w[AR BD BO BR CL CM CN CO CR DO EC EG GH GT IN ID JP KE MY MX MA NG PA PY PE PH SN SV TH TR TZ UG UY VN ZA]
       self.default_currency = 'USD'
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners_club, :maestro, :naranja, :cabal]
+      self.supported_cardtypes = %i[visa master american_express discover jcb diners_club maestro naranja cabal elo alia carnet]
 
       self.homepage_url = 'https://dlocal.com/'
       self.display_name = 'dLocal'
 
-      def initialize(options={})
+      def initialize(options = {})
         requires!(options, :login, :trans_key, :secret_key)
         super
       end
 
-      def purchase(money, payment, options={})
+      def purchase(money, payment, options = {})
         post = {}
         add_auth_purchase_params(post, money, payment, 'purchase', options)
+        add_three_ds(post, options)
 
         commit('purchase', post, options)
       end
 
-      def authorize(money, payment, options={})
+      def authorize(money, payment, options = {})
         post = {}
         add_auth_purchase_params(post, money, payment, 'authorize', options)
+        add_three_ds(post, options)
+        post[:card][:verify] = true if options[:verify].to_s == 'true'
 
         commit('authorize', post, options)
       end
 
-      def capture(money, authorization, options={})
+      def capture(money, authorization, options = {})
         post = {}
-        post[:payment_id] = authorization
+        post[:authorization_id] = authorization
         add_invoice(post, money, options) if money
         commit('capture', post, options)
       end
 
-      def refund(money, authorization, options={})
+      def refund(money, authorization, options = {})
         post = {}
         post[:payment_id] = authorization
         post[:notification_url] = options[:notification_url]
@@ -45,23 +48,31 @@ module ActiveMerchant #:nodoc:
         commit('refund', post, options)
       end
 
-      def void(authorization, options={})
+      def void(authorization, options = {})
         post = {}
-        post[:payment_id] = authorization
+        post[:authorization_id] = authorization
         commit('void', post, options)
       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
+      def verify(credit_card, options = {})
+        authorize(0, credit_card, options.merge(verify: 'true'))
+      end
+
+      def inquire(authorization, options = {})
+        post = {}
+        post[:payment_id] = authorization
+        action = authorization ? 'status' : 'orders'
+        commit(action, post, options)
       end
 
       def supports_scrubbing?
         true
       end
 
+      def supports_network_tokenization?
+        true
+      end
+
       def scrub(transcript)
         transcript.
           gsub(%r((X-Trans-Key: )\w+), '\1[FILTERED]').
@@ -78,7 +89,9 @@ module ActiveMerchant #:nodoc:
         add_country(post, card, options)
         add_payer(post, card, options)
         add_card(post, card, action, options)
+        add_additional_data(post, options)
         post[:order_id] = options[:order_id] || generate_unique_id
+        post[:original_order_id] = options[:original_order_id] if options[:original_order_id]
         post[:description] = options[:description] if options[:description]
       end
 
@@ -87,13 +100,20 @@ module ActiveMerchant #:nodoc:
         post[:currency] = (options[:currency] || currency(money))
       end
 
+      def add_additional_data(post, options)
+        post[:additional_risk_data] = options[:additional_data]
+      end
+
       def add_country(post, card, options)
         return unless address = options[:billing_address] || options[:address]
+
         post[:country] = lookup_country_code(address[:country])
       end
 
-      def lookup_country_code(country)
-        Country.find(country).code(:alpha2).value
+      def lookup_country_code(country_field)
+        Country.find(country_field).code(:alpha2).value
+      rescue InvalidCountryCodeError
+        nil
       end
 
       def add_payer(post, card, options)
@@ -106,40 +126,87 @@ module ActiveMerchant #:nodoc:
         post[:payer][:document] = options[:document] if options[:document]
         post[:payer][:document2] = options[:document2] if options[:document2]
         post[:payer][:user_reference] = options[:user_reference] if options[:user_reference]
+        post[:payer][:event_uuid] = options[:device_id] if options[:device_id]
+        post[:payer][:onboarding_ip_address] = options[:ip] if options[:ip]
         post[:payer][:address] = add_address(post, card, options)
       end
 
       def add_address(post, card, options)
         return unless address = options[:billing_address] || options[:address]
+
         address_object = {}
         address_object[:state] = address[:state] if address[:state]
         address_object[:city] = address[:city] if address[:city]
-        address_object[:zip_code] = address[:zip_code] if address[:zip_code]
-        address_object[:street] = address[:street] if address[:street]
-        address_object[:number] = address[:number] if address[:number]
+        address_object[:zip_code] = address[:zip] if address[:zip]
+        address_object[:street] = address[:street] || parse_street(address) if parse_street(address)
+        address_object[:number] = address[:number] || parse_house_number(address) if parse_house_number(address)
         address_object
       end
 
-      def add_card(post, card, action, options={})
+      def parse_street(address)
+        return unless address[:address1]
+
+        street = address[:address1].split(/\s+/).keep_if { |x| x !~ /\d/ }.join(' ')
+        street.empty? ? nil : street
+      end
+
+      def parse_house_number(address)
+        return unless address[:address1]
+
+        house = address[:address1].split(/\s+/).keep_if { |x| x =~ /\d/ }.join(' ')
+        house.empty? ? nil : house
+      end
+
+      def add_card(post, card, action, options = {})
         post[:card] = {}
+        if card.is_a?(NetworkTokenizationCreditCard)
+          post[:card][:network_token] = card.number
+          post[:card][:cryptogram] = card.payment_cryptogram
+          post[:card][:eci] = card.eci
+          # used case of Network Token: 'CARD_ON_FILE', 'SUBSCRIPTION', 'UNSCHEDULED_CARD_ON_FILE'
+          if options.dig(:stored_credential, :reason_type) == 'unscheduled'
+            if options.dig(:stored_credential, :initiator) == 'merchant'
+              post[:card][:stored_credential_type] = 'UNSCHEDULED_CARD_ON_FILE'
+            else
+              post[:card][:stored_credential_type] = 'CARD_ON_FILE'
+            end
+          else
+            post[:card][:stored_credential_type] = 'SUBSCRIPTION'
+          end
+          # required for MC debit recurrent in BR 'USED'(subsecuence Payments) . 'FIRST' an inital payment
+          post[:card][:stored_credential_usage] = (options[:stored_credential][:initial_transaction] ? 'FIRST' : 'USED') if options[:stored_credential]
+        else
+          post[:card][:number] = card.number
+          post[:card][:cvv] = card.verification_value
+        end
+
         post[:card][:holder_name] = card.name
         post[:card][:expiration_month] = card.month
         post[:card][:expiration_year] = card.year
-        post[:card][:number] = card.number
-        post[:card][:cvv] = card.verification_value
         post[:card][:descriptor] = options[:dynamic_descriptor] if options[:dynamic_descriptor]
         post[:card][:capture] = (action == 'purchase')
+        post[:card][:installments] = options[:installments] if options[:installments]
+        post[:card][:installments_id] = options[:installments_id] if options[:installments_id]
+        post[:card][:force_type] = options[:force_type].to_s.upcase if options[:force_type]
+        post[:card][:save] = options[:save] if options[:save]
       end
 
       def parse(body)
         JSON.parse(body)
       end
 
-      def commit(action, parameters, options={})
+      def commit(action, parameters, options = {})
+        three_ds_errors = validate_three_ds_params(parameters[:three_dsecure]) if parameters[:three_dsecure].present?
+        return three_ds_errors if three_ds_errors
+
         url = url(action, parameters, options)
         post = post_data(action, parameters)
         begin
-          raw = ssl_post(url, post, headers(post, options))
+          raw = if %w(status orders).include?(action)
+                  ssl_get(url, headers(nil, options))
+                else
+                  ssl_post(url, post, headers(post, options))
+                end
           response = parse(raw)
         rescue ResponseError => e
           raw = e.response.body
@@ -163,7 +230,8 @@ module ActiveMerchant #:nodoc:
       # we count 100 as a success.
       def success_from(action, response)
         return false unless response['status_code']
-        ['100', '200', '400', '600'].include? response['status_code'].to_s
+
+        %w[100 200 400 600 700].include? response['status_code'].to_s
       end
 
       def message_from(action, response)
@@ -176,11 +244,12 @@ module ActiveMerchant #:nodoc:
 
       def error_code_from(action, response)
         return if success_from(action, response)
+
         code = response['status_code'] || response['code']
         code&.to_s
       end
 
-      def url(action, parameters, options={})
+      def url(action, parameters, options = {})
         "#{(test? ? test_url : live_url)}/#{endpoint(action, parameters, options)}/"
       end
 
@@ -193,22 +262,27 @@ module ActiveMerchant #:nodoc:
         when 'refund'
           'refunds'
         when 'capture'
-          "payments/#{parameters[:payment_id]}/capture"
+          'payments'
         when 'void'
-          "payments/#{parameters[:payment_id]}/cancel"
+          "payments/#{parameters[:authorization_id]}/cancel"
+        when 'status'
+          "payments/#{parameters[:payment_id]}/status"
+        when 'orders'
+          "orders/#{options[:order_id]}"
         end
       end
 
-      def headers(post, options={})
+      def headers(post, options = {})
         timestamp = Time.now.utc.iso8601
         headers = {
           'Content-Type' => 'application/json',
           'X-Date' => timestamp,
           'X-Login' => @options[:login],
           'X-Trans-Key' => @options[:trans_key],
+          'X-Version' => '2.1',
           'Authorization' => signature(post, timestamp)
         }
-        headers.merge('X-Idempotency-Key' => options[:idempotency_key]) if options[:idempotency_key]
+        headers['X-Idempotency-Key'] = options[:idempotency_key] if options[:idempotency_key]
         headers
       end
 
@@ -221,6 +295,49 @@ module ActiveMerchant #:nodoc:
       def post_data(action, parameters = {})
         parameters.to_json
       end
+
+      def xid_or_ds_trans_id(three_d_secure)
+        if three_d_secure[:version].to_f >= 2
+          { ds_transaction_id: three_d_secure[:ds_transaction_id] }
+        else
+          { xid: three_d_secure[:xid] }
+        end
+      end
+
+      def add_three_ds(post, options)
+        return unless three_d_secure = options[:three_d_secure]
+
+        post[:three_dsecure] = {
+          mpi: true,
+          three_dsecure_version: three_d_secure[:version],
+          cavv: three_d_secure[:cavv],
+          eci: three_d_secure[:eci],
+          enrollment_response: formatted_enrollment(three_d_secure[:enrolled]),
+          authentication_response: three_d_secure[:authentication_response_status]
+        }.merge(xid_or_ds_trans_id(three_d_secure))
+      end
+
+      def validate_three_ds_params(three_ds)
+        errors = {}
+        supported_version = %w{1.0 2.0 2.1.0 2.2.0}.include?(three_ds[:three_dsecure_version])
+        supported_enrollment = ['Y', 'N', 'U', nil].include?(three_ds[:enrollment_response])
+        supported_auth_response = ['Y', 'N', 'U', nil].include?(three_ds[:authentication_response])
+
+        errors[:three_ds_version] = 'ThreeDs version not supported' unless supported_version
+        errors[:enrollment] = 'Enrollment value not supported' unless supported_enrollment
+        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 formatted_enrollment(val)
+        case val
+        when 'Y', 'N', 'U' then val
+        when true, 'true' then 'Y'
+        when false, 'false' then 'N'
+        end
+      end
     end
   end
 end

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

@@ -6,7 +6,7 @@ module ActiveMerchant
       self.default_currency = 'GBP'
       self.supported_countries = ['GB']
 
-      self.supported_cardtypes = [ :visa, :master, :american_express, :discover, :diners_club, :jcb, :maestro ]
+      self.supported_cardtypes = %i[visa master american_express discover diners_club jcb maestro]
 
       self.homepage_url = 'http://www.datacash.com/'
       self.display_name = 'DataCash'
@@ -92,9 +92,9 @@ module ActiveMerchant
 
       def build_void_or_capture_request(type, money, authorization, options)
         parsed_authorization = parse_authorization_string(authorization)
-        xml = Builder::XmlMarkup.new :indent => 2
+        xml = Builder::XmlMarkup.new indent: 2
         xml.instruct!
-        xml.tag! :Request, :version => '2' do
+        xml.tag! :Request, version: '2' do
           add_authentication(xml)
 
           xml.tag! :Transaction do
@@ -107,7 +107,7 @@ module ActiveMerchant
             if money
               xml.tag! :TxnDetails do
                 xml.tag! :merchantreference, format_reference_number(options[:order_id])
-                xml.tag! :amount, amount(money), :currency => options[:currency] || currency(money)
+                xml.tag! :amount, amount(money), currency: options[:currency] || currency(money)
                 xml.tag! :capturemethod, 'ecomm'
               end
             end
@@ -117,22 +117,20 @@ module ActiveMerchant
       end
 
       def build_purchase_or_authorization_request_with_credit_card_request(type, money, credit_card, options)
-        xml = Builder::XmlMarkup.new :indent => 2
+        xml = Builder::XmlMarkup.new indent: 2
         xml.instruct!
-        xml.tag! :Request, :version => '2' do
+        xml.tag! :Request, version: '2' do
           add_authentication(xml)
 
           xml.tag! :Transaction do
-            if options[:set_up_continuous_authority]
-              xml.tag! :ContAuthTxn, :type => 'setup'
-            end
+            xml.tag! :ContAuthTxn, type: 'setup' if options[:set_up_continuous_authority]
             xml.tag! :CardTxn do
               xml.tag! :method, type
               add_credit_card(xml, credit_card, options[:billing_address])
             end
             xml.tag! :TxnDetails do
               xml.tag! :merchantreference, format_reference_number(options[:order_id])
-              xml.tag! :amount, amount(money), :currency => options[:currency] || currency(money)
+              xml.tag! :amount, amount(money), currency: options[:currency] || currency(money)
               xml.tag! :capturemethod, 'ecomm'
             end
           end
@@ -144,19 +142,19 @@ module ActiveMerchant
         parsed_authorization = parse_authorization_string(authorization)
         raise ArgumentError, 'The continuous authority reference is required for continuous authority transactions' if parsed_authorization[:ca_reference].blank?
 
-        xml = Builder::XmlMarkup.new :indent => 2
+        xml = Builder::XmlMarkup.new indent: 2
         xml.instruct!
-        xml.tag! :Request, :version => '2' do
+        xml.tag! :Request, version: '2' do
           add_authentication(xml)
           xml.tag! :Transaction do
-            xml.tag! :ContAuthTxn, :type => 'historic'
+            xml.tag! :ContAuthTxn, type: 'historic'
             xml.tag! :HistoricTxn do
               xml.tag! :reference, parsed_authorization[:ca_reference]
               xml.tag! :method, type
             end
             xml.tag! :TxnDetails do
               xml.tag! :merchantreference, format_reference_number(options[:order_id])
-              xml.tag! :amount, amount(money), :currency => options[:currency] || currency(money)
+              xml.tag! :amount, amount(money), currency: options[:currency] || currency(money)
               xml.tag! :capturemethod, 'cont_auth'
             end
           end
@@ -166,9 +164,9 @@ module ActiveMerchant
 
       def build_transaction_refund_request(money, authorization)
         parsed_authorization = parse_authorization_string(authorization)
-        xml = Builder::XmlMarkup.new :indent => 2
+        xml = Builder::XmlMarkup.new indent: 2
         xml.instruct!
-        xml.tag! :Request, :version => '2' do
+        xml.tag! :Request, version: '2' do
           add_authentication(xml)
           xml.tag! :Transaction do
             xml.tag! :HistoricTxn do
@@ -187,9 +185,9 @@ module ActiveMerchant
       end
 
       def build_credit_request(money, credit_card, options)
-        xml = Builder::XmlMarkup.new :indent => 2
+        xml = Builder::XmlMarkup.new indent: 2
         xml.instruct!
-        xml.tag! :Request, :version => '2' do
+        xml.tag! :Request, version: '2' do
           add_authentication(xml)
           xml.tag! :Transaction do
             xml.tag! :CardTxn do
@@ -237,23 +235,23 @@ module ActiveMerchant
             # a predefined one
             xml.tag! :ExtendedPolicy do
               xml.tag! :cv2_policy,
-                :notprovided =>   POLICY_REJECT,
-                :notchecked =>    POLICY_REJECT,
-                :matched =>       POLICY_ACCEPT,
-                :notmatched =>    POLICY_REJECT,
-                :partialmatch =>  POLICY_REJECT
+                notprovided: POLICY_REJECT,
+                notchecked: POLICY_REJECT,
+                matched: POLICY_ACCEPT,
+                notmatched: POLICY_REJECT,
+                partialmatch: POLICY_REJECT
               xml.tag! :postcode_policy,
-                :notprovided =>   POLICY_ACCEPT,
-                :notchecked =>    POLICY_ACCEPT,
-                :matched =>       POLICY_ACCEPT,
-                :notmatched =>    POLICY_REJECT,
-                :partialmatch =>  POLICY_ACCEPT
+                notprovided: POLICY_ACCEPT,
+                notchecked: POLICY_ACCEPT,
+                matched: POLICY_ACCEPT,
+                notmatched: POLICY_REJECT,
+                partialmatch: POLICY_ACCEPT
               xml.tag! :address_policy,
-                :notprovided =>   POLICY_ACCEPT,
-                :notchecked =>    POLICY_ACCEPT,
-                :matched =>       POLICY_ACCEPT,
-                :notmatched =>    POLICY_REJECT,
-                :partialmatch =>  POLICY_ACCEPT
+                notprovided: POLICY_ACCEPT,
+                notchecked: POLICY_ACCEPT,
+                matched: POLICY_ACCEPT,
+                notmatched: POLICY_REJECT,
+                partialmatch: POLICY_ACCEPT
             end
           end
         end
@@ -263,9 +261,8 @@ module ActiveMerchant
         response = parse(ssl_post(test? ? self.test_url : self.live_url, request))
 
         Response.new(response[:status] == '1', response[:reason], response,
-          :test => test?,
-          :authorization => "#{response[:datacash_reference]};#{response[:authcode]};#{response[:ca_reference]}"
-        )
+          test: test?,
+          authorization: "#{response[:datacash_reference]};#{response[:authcode]};#{response[:ca_reference]}")
       end
 
       def format_date(month, year)
@@ -298,7 +295,7 @@ module ActiveMerchant
 
       def parse_authorization_string(authorization)
         reference, auth_code, ca_reference = authorization.to_s.split(';')
-        {:reference => reference, :auth_code => auth_code, :ca_reference => ca_reference}
+        { reference: reference, auth_code: auth_code, ca_reference: ca_reference }
       end
     end
   end