activemerchant 1.93.0 → 1.98.0

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

@@ -544,7 +544,7 @@ module ActiveMerchant #:nodoc:
               end
             end
             doc['v1'].addrLn1 billing_address[:address1] if billing_address[:address1]
-            doc['v1'].addrLn2 billing_address[:address2] if billing_address[:address2]
+            doc['v1'].addrLn2 billing_address[:address2] unless billing_address[:address2].blank?
             doc['v1'].city billing_address[:city] if billing_address[:city]
             doc['v1'].state billing_address[:state] if billing_address[:state]
             doc['v1'].zipCode billing_address[:zip] if billing_address[:zip]
@@ -559,7 +559,7 @@ module ActiveMerchant #:nodoc:
             doc['v1'].ship do
               doc['v1'].fullName fullname unless fullname.blank?
               doc['v1'].addrLn1 shipping_address[:address1] if shipping_address[:address1]
-              doc['v1'].addrLn2 shipping_address[:address2] if shipping_address[:address2]
+              doc['v1'].addrLn2 shipping_address[:address2] unless shipping_address[:address2].blank?
               doc['v1'].city shipping_address[:city] if shipping_address[:city]
               doc['v1'].state shipping_address[:state] if shipping_address[:state]
               doc['v1'].zipCode shipping_address[:zip] if shipping_address[:zip]

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

@@ -104,6 +104,8 @@ module ActiveMerchant #:nodoc:
       TEST_LOGIN = 'TestMerchant'
       TEST_PASSWORD = 'password'
 
+      VOIDABLE_ACTIONS = %w(preauth sale postauth credit)
+
       self.money_format = :cents
       self.supported_cardtypes = [:visa, :master, :discover, :american_express, :diners_club, :jcb]
       self.supported_countries = ['US']
@@ -157,6 +159,8 @@ module ActiveMerchant #:nodoc:
         add_customer_data(parameters, options)
         add_payment_source(parameters, creditcard_or_billing_id)
         add_addresses(parameters, options)
+        add_custom_fields(parameters, options)
+
         commit('preauth', parameters)
       end
 
@@ -172,6 +176,8 @@ module ActiveMerchant #:nodoc:
         add_customer_data(parameters, options)
         add_payment_source(parameters, creditcard_or_billing_id)
         add_addresses(parameters, options)
+        add_custom_fields(parameters, options)
+
         commit('sale', parameters)
       end
 
@@ -179,11 +185,13 @@ module ActiveMerchant #:nodoc:
       # postauth, we preserve active_merchant's nomenclature of capture() for consistency with the rest of the library. To process
       # a postauthorization with TC, you need an amount in cents or a money object, and a TC transid.
       def capture(money, authorization, options = {})
+        transaction_id, _ = split_authorization(authorization)
         parameters = {
           :amount => amount(money),
-          :transid => authorization,
+          :transid => transaction_id,
         }
         add_aggregator(parameters, options)
+        add_custom_fields(parameters, options)
 
         commit('postauth', parameters)
       end
@@ -191,11 +199,15 @@ module ActiveMerchant #:nodoc:
       # refund() allows you to return money to a card that was previously billed. You need to supply the amount, in cents or a money object,
       # that you want to refund, and a TC transid for the transaction that you are refunding.
       def refund(money, identification, options = {})
+        transaction_id, _ = split_authorization(identification)
+
         parameters = {
           :amount => amount(money),
-          :transid => identification
+          :transid => transaction_id
         }
+
         add_aggregator(parameters, options)
+        add_custom_fields(parameters, options)
 
         commit('credit', parameters)
       end
@@ -214,18 +226,26 @@ module ActiveMerchant #:nodoc:
       # TrustCommerce to allow for reversal transactions before you can use this
       # method.
       #
+      # void() is also used to to cancel a capture (postauth), purchase (sale),
+      # or refund (credit) or a before it is sent for settlement.
+      #
       # NOTE: AMEX preauth's cannot be reversed. If you want to clear it more
       # quickly than the automatic expiration (7-10 days), you will have to
       # capture it and then immediately issue a credit for the same amount
       # which should clear the customers credit card with 48 hours according to
       # TC.
       def void(authorization, options = {})
+        transaction_id, original_action = split_authorization(authorization)
+        action = (VOIDABLE_ACTIONS - ['preauth']).include?(original_action) ? 'void' : 'reversal'
+
         parameters = {
-          :transid => authorization,
+          :transid => transaction_id,
         }
+
         add_aggregator(parameters, options)
+        add_custom_fields(parameters, options)
 
-        commit('reversal', parameters)
+        commit(action, parameters)
       end
 
       # recurring() a TrustCommerce account that is activated for Citadel, TrustCommerce's
@@ -284,6 +304,8 @@ module ActiveMerchant #:nodoc:
 
         add_creditcard(parameters, creditcard)
         add_addresses(parameters, options)
+        add_custom_fields(parameters, options)
+
         commit('store', parameters)
       end
 
@@ -294,6 +316,8 @@ module ActiveMerchant #:nodoc:
           :billingid => identification,
         }
 
+        add_custom_fields(parameters, options)
+
         commit('unstore', parameters)
       end
 
@@ -311,6 +335,12 @@ module ActiveMerchant #:nodoc:
 
       private
 
+      def add_custom_fields(params, options)
+        options[:custom_fields]&.each do |key, value|
+          params[key.to_sym] = value
+        end
+      end
+
       def add_aggregator(params, options)
         if @options[:aggregator_id] || application_id != Gateway.application_id
           params[:aggregators] = 1
@@ -409,14 +439,14 @@ module ActiveMerchant #:nodoc:
                  TCLink.send(parameters)
                else
                  parse(ssl_post(self.live_url, post_data(parameters)))
-        end
+               end
 
         # to be considered successful, transaction status must be either "approved" or "accepted"
         success = SUCCESS_TYPES.include?(data['status'])
         message = message_from(data)
         Response.new(success, message, data,
           :test => test?,
-          :authorization => data['transid'],
+          :authorization => authorization_from(action, data),
           :cvv_result => data['cvv'],
           :avs_result => { :code => data['avs'] }
         )
@@ -446,6 +476,15 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def authorization_from(action, data)
+        authorization = data['transid']
+        authorization = "#{authorization}|#{action}" if authorization && VOIDABLE_ACTIONS.include?(action)
+        authorization
+      end
+
+      def split_authorization(authorization)
+        authorization&.split('|')
+      end
     end
   end
 end

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

@@ -33,9 +33,9 @@ module ActiveMerchant #:nodoc:
         '10110' => STANDARD_ERROR_CODE[:incorrect_address],
         '10111' => STANDARD_ERROR_CODE[:incorrect_address],
         '10127' => STANDARD_ERROR_CODE[:card_declined],
-        '10128' => STANDARD_ERROR_CODE[:processing_error],
-        '10132' => STANDARD_ERROR_CODE[:processing_error],
-        '00043' => STANDARD_ERROR_CODE[:call_issuer]
+        '00043' => STANDARD_ERROR_CODE[:call_issuer],
+        '10205' => STANDARD_ERROR_CODE[:card_declined],
+        '10204' => STANDARD_ERROR_CODE[:pickup_card]
       }
 
       def initialize(options = {})
@@ -318,12 +318,15 @@ module ActiveMerchant #:nodoc:
       def commit(action, parameters)
         url = (test? ? self.test_url : self.live_url)
         response = parse(ssl_post(url, post_data(action, parameters)))
-        Response.new(response[:status] == 'Approved', message_from(response), response,
+        approved = response[:status] == 'Approved'
+        error_code = nil
+        error_code = (STANDARD_ERROR_CODE_MAPPING[response[:error_code]] || STANDARD_ERROR_CODE[:processing_error]) unless approved
+        Response.new(approved, message_from(response), response,
           :test           => test?,
           :authorization  => response[:ref_num],
           :cvv_result     => response[:cvv2_result_code],
           :avs_result     => { :code => response[:avs_result_code] },
-          :error_code     => STANDARD_ERROR_CODE_MAPPING[response[:error_code]]
+          :error_code     => error_code
         )
       end
 

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

@@ -7,7 +7,7 @@ module ActiveMerchant #:nodoc:
       self.default_currency = 'GBP'
       self.money_format = :cents
       self.supported_countries = %w(HK GB AU AD AR BE BR CA CH CN CO CR CY CZ DE DK ES FI FR GI GR HU IE IN IT JP LI LU MC MT MY MX NL NO NZ PA PE PL PT SE SG SI SM TR UM VA)
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :maestro, :elo]
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :maestro, :elo, :naranja, :cabal]
       self.currencies_without_fractions = %w(HUF IDR ISK JPY KRW)
       self.currencies_with_three_decimal_places = %w(BHD KWD OMR RSD TND)
       self.homepage_url = 'http://www.worldpay.com/'
@@ -21,7 +21,10 @@ module ActiveMerchant #:nodoc:
         'jcb'              => 'JCB-SSL',
         'maestro'          => 'MAESTRO-SSL',
         'diners_club'      => 'DINERS-SSL',
-        'elo'              => 'ELO-SSL'
+        'elo'              => 'ELO-SSL',
+        'naranja'          => 'NARANJA-SSL',
+        'cabal'            => 'CABAL-SSL',
+        'unknown'          => 'CARD-SSL'
       }
 
       AVS_CODE_MAP = {
@@ -58,10 +61,12 @@ module ActiveMerchant #:nodoc:
 
       def authorize(money, payment_method, options = {})
         requires!(options, :order_id)
-        authorize_request(money, payment_method, options)
+        payment_details = payment_details_from(payment_method)
+        authorize_request(money, payment_method, payment_details.merge(options))
       end
 
       def capture(money, authorization, options = {})
+        authorization = order_id_from_authorization(authorization.to_s)
         MultiResponse.run do |r|
           r.process { inquire_request(authorization, options, 'AUTHORISED') } unless options[:authorization_validated]
           if r.params
@@ -73,6 +78,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def void(authorization, options = {})
+        authorization = order_id_from_authorization(authorization.to_s)
         MultiResponse.run do |r|
           r.process { inquire_request(authorization, options, 'AUTHORISED') } unless options[:authorization_validated]
           r.process { cancel_request(authorization, options) }
@@ -80,6 +86,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def refund(money, authorization, options = {})
+        authorization = order_id_from_authorization(authorization.to_s)
         response = MultiResponse.run do |r|
           r.process { inquire_request(authorization, options, 'CAPTURED', 'SETTLED', 'SETTLED_BY_MERCHANT') }
           r.process { refund_request(money, authorization, options) }
@@ -96,16 +103,22 @@ module ActiveMerchant #:nodoc:
       #   and other transactions should be performed on a normal eCom-flagged
       #   merchant ID.
       def credit(money, payment_method, options = {})
-        credit_request(money, payment_method, options.merge(:credit => true))
+        payment_details = payment_details_from(payment_method)
+        credit_request(money, payment_method, payment_details.merge(:credit => true, **options))
       end
 
-      def verify(credit_card, options={})
+      def verify(payment_method, options={})
         MultiResponse.run(:use_first_response) do |r|
-          r.process { authorize(100, credit_card, options) }
+          r.process { authorize(100, payment_method, options) }
           r.process(:ignore_result) { void(r.authorization, options.merge(:authorization_validated => true)) }
         end
       end
 
+      def store(credit_card, options={})
+        requires!(options, :customer)
+        store_request(credit_card, options)
+      end
+
       def supports_scrubbing
         true
       end
@@ -143,6 +156,10 @@ module ActiveMerchant #:nodoc:
         commit('credit', build_authorization_request(money, payment_method, options), :ok, 'SENT_FOR_REFUND', options)
       end
 
+      def store_request(credit_card, options)
+        commit('store', build_store_request(credit_card, options), options)
+      end
+
       def build_request
         xml = Builder::XmlMarkup.new :indent => 2
         xml.instruct! :xml, :encoding => 'UTF-8'
@@ -183,13 +200,14 @@ module ActiveMerchant #:nodoc:
                 end
               end
               add_payment_method(xml, money, payment_method, options)
-              add_email(xml, options)
+              add_shopper(xml, options)
               if options[:hcg_additional_data]
                 add_hcg_additional_data(xml, options)
               end
               if options[:instalments]
                 add_instalments_data(xml, options)
               end
+              add_moto_flag(xml, options) if options.dig(:metadata, :manual_entry)
             end
           end
         end
@@ -223,6 +241,22 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def build_store_request(credit_card, options)
+        build_request do |xml|
+          xml.tag! 'submit' do
+            xml.tag! 'paymentTokenCreate' do
+              add_authenticated_shopper_id(xml, options)
+              xml.tag! 'createToken'
+              xml.tag! 'paymentInstrument' do
+                xml.tag! 'cardDetails' do
+                  add_card(xml, credit_card, options)
+                end
+              end
+            end
+          end
+        end
+      end
+
       def add_amount(xml, money, options)
         currency = options[:currency] || currency(money)
 
@@ -240,7 +274,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_payment_method(xml, amount, payment_method, options)
-        if payment_method.is_a?(String)
+        if options[:payment_type] == :pay_as_order
           if options[:merchant_code]
             xml.tag! 'payAsOrder', 'orderCode' => payment_method, 'merchantCode' => options[:merchant_code] do
               add_amount(xml, amount, options)
@@ -252,16 +286,14 @@ module ActiveMerchant #:nodoc:
           end
         else
           xml.tag! 'paymentDetails', credit_fund_transfer_attribute(options) do
-            xml.tag! CARD_CODES[card_brand(payment_method)] do
-              xml.tag! 'cardNumber', payment_method.number
-              xml.tag! 'expiryDate' do
-                xml.tag! 'date', 'month' => format(payment_method.month, :two_digits), 'year' => format(payment_method.year, :four_digits)
+            if options[:payment_type] == :token
+              xml.tag! 'TOKEN-SSL', 'tokenScope' => options[:token_scope] do
+                xml.tag! 'paymentTokenID', options[:token_id]
+              end
+            else
+              xml.tag! card_code_for(payment_method) do
+                add_card(xml, payment_method, options)
               end
-
-              xml.tag! 'cardHolderName', options[:execute_threed] ? '3D' : payment_method.name
-              xml.tag! 'cvc', payment_method.verification_value
-
-              add_address(xml, (options[:billing_address] || options[:address]))
             end
             add_stored_credential_options(xml, options)
             if options[:ip] && options[:session_id]
@@ -272,18 +304,37 @@ module ActiveMerchant #:nodoc:
             end
 
             if three_d_secure = options[:three_d_secure]
-              xml.tag! 'info3DSecure' do
-                xml.tag! 'threeDSVersion', three_d_secure[:version]
-                xid_tag = three_d_secure[:version] =~ /^2/ ? 'dsTransactionId' : 'xid'
-                xml.tag! xid_tag, three_d_secure[:xid]
-                xml.tag! 'cavv', three_d_secure[:cavv]
-                xml.tag! 'eci', three_d_secure[:eci]
-              end
+              add_three_d_secure(three_d_secure, xml)
             end
           end
         end
       end
 
+      def add_three_d_secure(three_d_secure, xml)
+        xml.tag! 'info3DSecure' do
+          xml.tag! 'threeDSVersion', three_d_secure[:version]
+          if three_d_secure[:version] =~ /^2/
+            xml.tag! 'dsTransactionId', three_d_secure[:ds_transaction_id]
+          else
+            xml.tag! 'xid', three_d_secure[:xid]
+          end
+          xml.tag! 'cavv', three_d_secure[:cavv]
+          xml.tag! 'eci', three_d_secure[:eci]
+        end
+      end
+
+      def add_card(xml, payment_method, options)
+        xml.tag! 'cardNumber', payment_method.number
+        xml.tag! 'expiryDate' do
+          xml.tag! 'date', 'month' => format(payment_method.month, :two_digits), 'year' => format(payment_method.year, :four_digits)
+        end
+
+        xml.tag! 'cardHolderName', options[:execute_threed] ? '3D' : payment_method.name
+        xml.tag! 'cvc', payment_method.verification_value
+
+        add_address(xml, (options[:billing_address] || options[:address]))
+      end
+
       def add_stored_credential_options(xml, options={})
         if options[:stored_credential]
           add_stored_credential_using_normalized_fields(xml, options)
@@ -320,10 +371,11 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def add_email(xml, options)
-        return unless options[:execute_threed] || options[:email]
+      def add_shopper(xml, options)
+        return unless options[:execute_threed] || options[:email] || options[:customer]
         xml.tag! 'shopper' do
           xml.tag! 'shopperEmailAddress', options[:email] if  options[:email]
+          add_authenticated_shopper_id(xml, options)
           xml.tag! 'browser' do
             xml.tag! 'acceptHeader', options[:accept_header]
             xml.tag! 'userAgentHeader', options[:user_agent]
@@ -331,6 +383,10 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_authenticated_shopper_id(xml, options)
+        xml.tag!('authenticatedShopperID', options[:customer]) if options[:customer]
+      end
+
       def add_address(xml, address)
         return unless address
 
@@ -368,6 +424,10 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_moto_flag(xml, options)
+        xml.tag! 'dynamicInteractionType', 'type' => 'MOTO'
+      end
+
       def address_with_defaults(address)
         address ||= {}
         address.delete_if { |_, v| v.blank? }
@@ -389,14 +449,17 @@ module ActiveMerchant #:nodoc:
       end
 
       def parse_element(raw, node)
+        node_name = node.name.underscore
         node.attributes.each do |k, v|
-          raw["#{node.name.underscore}_#{k.underscore}".to_sym] = v
+          raw["#{node_name}_#{k.underscore}".to_sym] = v
         end
         if node.has_elements?
-          raw[node.name.underscore.to_sym] = true unless node.name.blank?
+          raw[node_name.to_sym] = true unless node.name.blank?
           node.elements.each { |e| parse_element(raw, e) }
+        elsif node.children.count > 1
+          raw[node_name.to_sym] = node.children.join(' ').strip
         else
-          raw[node.name.underscore.to_sym] = node.text unless node.text.nil?
+          raw[node_name.to_sym] = node.text unless node.text.nil?
         end
         raw
       end
@@ -419,13 +482,14 @@ module ActiveMerchant #:nodoc:
           raw[:cookie] = @cookie
           raw[:session_id] = options[:session_id]
         end
-        success, message = success_and_message_from(raw, success_criteria)
+        success = success_from(action, raw, success_criteria)
+        message = message_from(success, raw, success_criteria)
 
         Response.new(
           success,
           message,
           raw,
-          :authorization => authorization_from(raw),
+          :authorization => authorization_from(action, raw, options),
           :error_code => error_code_from(success, raw),
           :test => test?,
           :avs_result => AVSResult.new(code: AVS_CODE_MAP[raw[:avs_result_code_description]]),
@@ -455,19 +519,30 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def success_from(action, raw, success_criteria)
+        success_criteria_success?(raw, success_criteria) || action_success?(action, raw)
+      end
+
+      def message_from(success, raw, success_criteria)
+        return 'SUCCESS' if success
+        raw[:iso8583_return_code_description] || raw[:error] || required_status_message(raw, success_criteria)
+      end
+
       # success_criteria can be:
       #   - a string or an array of strings (if one of many responses)
       #   - An array of strings if one of many responses could be considered a
       #     success.
-      def success_and_message_from(raw, success_criteria)
-        success = (success_criteria.include?(raw[:last_event]) || raw[:ok].present?)
-        if success
-          message = 'SUCCESS'
+      def success_criteria_success?(raw, success_criteria)
+        success_criteria.include?(raw[:last_event]) || raw[:ok].present?
+      end
+
+      def action_success?(action, raw)
+        case action
+        when 'store'
+          raw[:token].present?
         else
-          message = (raw[:iso8583_return_code_description] || raw[:error] || required_status_message(raw, success_criteria))
+          false
         end
-
-        [ success, message ]
       end
 
       def error_code_from(success, raw)
@@ -482,11 +557,64 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def authorization_from(raw)
+      def authorization_from(action, raw, options)
+        order_id = order_id_from(raw)
+
+        case action
+        when 'store'
+          authorization_from_token_details(
+            order_id: order_id,
+            token_id: raw[:payment_token_id],
+            token_scope: 'shopper',
+            customer: options[:customer]
+          )
+        else
+          order_id
+        end
+      end
+
+      def order_id_from(raw)
         pair = raw.detect { |k, v| k.to_s =~ /_order_code$/ }
         (pair ? pair.last : nil)
       end
 
+      def authorization_from_token_details(options={})
+        [options[:order_id], options[:token_id], options[:token_scope], options[:customer]].join('|')
+      end
+
+      def order_id_from_authorization(authorization)
+        token_details_from_authorization(authorization)[:order_id]
+      end
+
+      def token_details_from_authorization(authorization)
+        order_id, token_id, token_scope, customer = authorization.split('|')
+
+        token_details = {}
+        token_details[:order_id] = order_id if order_id.present?
+        token_details[:token_id] = token_id if token_id.present?
+        token_details[:token_scope] = token_scope if token_scope.present?
+        token_details[:customer] = customer if customer.present?
+
+        token_details
+      end
+
+      def payment_details_from(payment_method)
+        payment_details = {}
+        if payment_method.respond_to?(:number)
+          payment_details[:payment_type] = :credit
+        else
+          token_details = token_details_from_authorization(payment_method)
+          payment_details.merge!(token_details)
+          if token_details.has_key?(:token_id)
+            payment_details[:payment_type] = :token
+          else
+            payment_details[:payment_type] = :pay_as_order
+          end
+        end
+
+        payment_details
+      end
+
       def credit_fund_transfer_attribute(options)
         return unless options[:credit]
         {'action' => 'REFUND'}
@@ -502,6 +630,10 @@ module ActiveMerchant #:nodoc:
         return 3 if three_decimal_currency?(currency)
         return 2
       end
+
+      def card_code_for(payment_method)
+        CARD_CODES[card_brand(payment_method)] || CARD_CODES['unknown']
+      end
     end
   end
 end