activemerchant 1.62.0 → 1.79.2

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

@@ -20,7 +20,8 @@ module ActiveMerchant #:nodoc:
         :void => 'VOID',
         :abort => 'ABORT',
         :store => 'TOKEN',
-        :unstore => 'REMOVETOKEN'
+        :unstore => 'REMOVETOKEN',
+        :repeat => 'REPEAT'
       }
 
       CREDIT_CARDS = {
@@ -36,13 +37,20 @@ module ActiveMerchant #:nodoc:
         :jcb => "JCB"
       }
 
-      AVS_CVV_CODE = {
+      AVS_CODE = {
         "NOTPROVIDED" => nil,
         "NOTCHECKED" => 'X',
         "MATCHED" => 'Y',
         "NOTMATCHED" => 'N'
       }
 
+      CVV_CODE = {
+        "NOTPROVIDED" => 'S',
+        "NOTCHECKED" => 'X',
+        "MATCHED" => 'M',
+        "NOTMATCHED" => 'N'
+      }
+
       OPTIONAL_REQUEST_FIELDS = {
         paypal_callback_url: :PayPalCallbackURL,
         basket: :Basket,
@@ -87,7 +95,7 @@ module ActiveMerchant #:nodoc:
         add_customer_data(post, options)
         add_optional_data(post, options)
 
-        commit(:purchase, post)
+        commit((past_purchase_reference?(payment_method) ? :repeat : :purchase), post)
       end
 
       def authorize(money, payment_method, options = {})
@@ -130,7 +138,7 @@ module ActiveMerchant #:nodoc:
 
         post = {}
 
-        add_credit_reference(post, identification)
+        add_related_reference(post, identification)
         add_amount(post, money, options)
         add_invoice(post, options)
 
@@ -195,7 +203,7 @@ module ActiveMerchant #:nodoc:
         add_pair(post, :SecurityKey, security_key)
       end
 
-      def add_credit_reference(post, identification)
+      def add_related_reference(post, identification)
         order_id, transaction_id, authorization, security_key = identification.split(';')
 
         add_pair(post, :RelatedVendorTxCode, order_id)
@@ -267,10 +275,14 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_payment_method(post, payment_method, options)
-        if payment_method.respond_to?(:number)
-          add_credit_card(post, payment_method)
+        if payment_method.is_a?(String)
+          if past_purchase_reference?(payment_method)
+            add_related_reference(post, payment_method)
+          else
+            add_token_details(post, payment_method, options)
+          end
         else
-          add_token_details(post, payment_method, options)
+          add_credit_card(post, payment_method)
         end
       end
 
@@ -343,10 +355,10 @@ module ActiveMerchant #:nodoc:
           :test => test?,
           :authorization => authorization_from(response, parameters, action),
           :avs_result => {
-            :street_match => AVS_CVV_CODE[ response["AddressResult"] ],
-            :postal_match => AVS_CVV_CODE[ response["PostCodeResult"] ],
+            :street_match => AVS_CODE[ response["AddressResult"] ],
+            :postal_match => AVS_CODE[ response["PostCodeResult"] ],
           },
-          :cvv_result => AVS_CVV_CODE[ response["CV2Result"] ]
+          :cvv_result => CVV_CODE[ response["CV2Result"] ]
         )
       end
 
@@ -356,9 +368,9 @@ module ActiveMerchant #:nodoc:
           response['Token']
         else
          [ params[:VendorTxCode],
-           response["VPSTxId"],
+           response["VPSTxId"] || params[:VPSTxId],
            response["TxAuthNo"],
-           response["SecurityKey"],
+           response["SecurityKey"] || params[:SecurityKey],
            action ].join(";")
         end
       end
@@ -419,6 +431,10 @@ module ActiveMerchant #:nodoc:
         post[key] = value if !value.blank? || options[:required]
       end
 
+      def past_purchase_reference?(payment_method)
+        return false unless payment_method.is_a?(String)
+        payment_method.split(';').last == 'purchase'
+      end
     end
 
   end

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

@@ -61,8 +61,19 @@ module ActiveMerchant #:nodoc:
         refund(money, authorization, options)
       end
 
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((<CARDNUMBER>)\d+(</CARDNUMBER>))i, '\1[FILTERED]\2').
+          gsub(%r((<CARDCODE>)\d+(</CARDCODE>))i, '\1[FILTERED]\2').
+          gsub(%r((<SECUREKEY>).+(</SECUREKEY>))i, '\1[FILTERED]\2')
+      end
 
       private
+
       def commit(request)
         xml = build_request(request)
         url = test? ? self.test_url : self.live_url
@@ -255,4 +266,3 @@ module ActiveMerchant #:nodoc:
     end
   end
 end
-

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

@@ -103,6 +103,18 @@ module ActiveMerchant #:nodoc:
         commit_periodic(build_periodic_item(:remove_triggered, options[:amount], nil, options))
       end
 
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((<merchantID>).+(</merchantID>)), '\1[FILTERED]\2').
+          gsub(%r((<password>).+(</password>)), '\1[FILTERED]\2').
+          gsub(%r((<cardNumber>).+(</cardNumber>)), '\1[FILTERED]\2').
+          gsub(%r((<cvv>).+(</cvv>)), '\1[FILTERED]\2')
+      end
+
       private
 
       def build_purchase_request(money, credit_card, options)

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

@@ -229,7 +229,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def commit(action, money, parameters)
-        parameters[:amount]  = amount(money) if money
+        parameters[:amount]  = localized_amount(money, parameters[:currency] || default_currency) if money
         response = parse( ssl_post(self.live_url, post_data(action,parameters)) )
         Response.new(response["response"] == "1", message_from(response), response,
           :authorization => (response["transactionid"] || response["customer_vault_id"]),

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

@@ -44,7 +44,7 @@ module ActiveMerchant #:nodoc:
           purchase_with_token(money, payment_method, options)
         else
           MultiResponse.run do |r|
-            r.process { save_card(false, payment_method, options) }
+            r.process { save_card(options[:store], payment_method, options) }
             r.process { purchase_with_token(money, r.authorization, options) }
           end
         end
@@ -62,7 +62,7 @@ module ActiveMerchant #:nodoc:
           authorize_with_token(money, payment_method, options)
         else
           MultiResponse.run do |r|
-            r.process { save_card(false, payment_method, options) }
+            r.process { save_card(options[:store], payment_method, options) }
             r.process { authorize_with_token(money, r.authorization, options) }
           end
         end
@@ -88,6 +88,24 @@ module ActiveMerchant #:nodoc:
         commit("transactions/#{authorization}/void.xml", '')
       end
 
+
+      # Public: Determine whether a credit card is chargeable card and available for purchases.
+      #
+      # payment_method - The CreditCard or the Spreedly payment method token.
+      # options        - A hash of options:
+      #                  :store - Retain the payment method if the verify
+      #                           succeeds.  Defaults to false.  (optional)
+      def verify(payment_method, options = {})
+        if payment_method.is_a?(String)
+          verify_with_token(payment_method, options)
+        else
+          MultiResponse.run do |r|
+            r.process { save_card(options[:store], payment_method, options) }
+            r.process { verify_with_token(r.authorization, options) }
+          end
+        end
+      end
+
       # Public: Store a credit card in the Spreedly vault and retain it.
       #
       # credit_card    - The CreditCard to store
@@ -106,6 +124,25 @@ module ActiveMerchant #:nodoc:
         commit("payment_methods/#{authorization}/redact.xml", '', :put)
       end
 
+      # Public: Get the transaction with the given token.
+      def find(transaction_token)
+        commit("transactions/#{transaction_token}.xml", nil, :get)
+      end
+
+      alias_method :status, :find
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r((<number>).+(</number>)), '\1[FILTERED]\2').
+          gsub(%r((<verification_value>).+(</verification_value>)), '\1[FILTERED]\2').
+          gsub(%r((<payment_method_token>).+(</payment_method_token>)), '\1[FILTERED]\2')
+      end
+
       private
 
       def save_card(retain, credit_card, options)
@@ -128,10 +165,20 @@ module ActiveMerchant #:nodoc:
         commit("gateways/#{@options[:gateway_token]}/authorize.xml", request)
       end
 
+      def verify_with_token(payment_method_token, options)
+        request = build_xml_request('transaction') do |doc|
+          add_invoice(doc, nil, options)
+          doc.payment_method_token(payment_method_token)
+          doc.retain_on_success(true) if options[:store]
+          add_extra_options(:gateway_specific_fields, doc, options)
+        end
+
+        commit("gateways/#{@options[:gateway_token]}/verify.xml", request)
+      end
+
       def auth_purchase_request(money, payment_method_token, options)
         build_xml_request('transaction') do |doc|
           add_invoice(doc, money, options)
-          doc.ip(options[:ip])
           add_extra_options(:gateway_specific_fields, doc, options)
           doc.payment_method_token(payment_method_token)
           doc.retain_on_success(true) if options[:store]
@@ -139,11 +186,11 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_invoice(doc, money, options)
-        doc.amount amount(money)
+        doc.amount amount(money) unless money.nil?
         doc.currency_code(options[:currency] || currency(money) || default_currency)
         doc.order_id(options[:order_id])
-        doc.ip(options[:ip])
-        doc.description(options[:description])
+        doc.ip(options[:ip]) if options[:ip]
+        doc.description(options[:description]) if options[:description]
       end
 
       def add_credit_card(doc, credit_card, options)
@@ -244,4 +291,3 @@ module ActiveMerchant #:nodoc:
     end
   end
 end
-

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

@@ -25,7 +25,7 @@ module ActiveMerchant #:nodoc:
       self.default_currency = 'USD'
       self.money_format = :cents
       self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners_club, :maestro]
-      self.currencies_without_fractions = %w(BIF CLP DJF GNF JPY KMF KRW MGA PYG RWF VND VUV XAF XOF XPF)
+      self.currencies_without_fractions = %w(BIF CLP DJF GNF JPY KMF KRW MGA PYG RWF VND VUV XAF XOF XPF UGX)
 
       self.homepage_url = 'https://stripe.com/'
       self.display_name = 'Stripe'
@@ -43,7 +43,8 @@ module ActiveMerchant #:nodoc:
         'call_issuer' => STANDARD_ERROR_CODE[:call_issuer],
         'processing_error' => STANDARD_ERROR_CODE[:processing_error],
         'incorrect_pin' => STANDARD_ERROR_CODE[:incorrect_pin],
-        'test_mode_live_card' => STANDARD_ERROR_CODE[:test_mode_live_card]
+        'test_mode_live_card' => STANDARD_ERROR_CODE[:test_mode_live_card],
+        'pickup_card' => STANDARD_ERROR_CODE[:pickup_card]
       }
 
       BANK_ACCOUNT_HOLDER_TYPE_MAPPING = {
@@ -71,7 +72,6 @@ module ActiveMerchant #:nodoc:
         requires!(options, :login)
         @api_key = options[:login]
         @fee_refund_api_key = options[:fee_refund_login]
-
         super
       end
 
@@ -113,6 +113,7 @@ module ActiveMerchant #:nodoc:
           end
           r.process do
             post = create_post_for_auth_or_purchase(money, payment, options)
+            post[:card][:processing_method] = 'quick_chip' if quickchip_payment?(payment)
             commit(:post, 'charges', post, options)
           end
         end.responses.last
@@ -127,6 +128,7 @@ module ActiveMerchant #:nodoc:
         else
           add_application_fee(post, options)
           add_amount(post, money, options)
+          add_exchange_rate(post, options)
           commit(:post, "charges/#{CGI.escape(authorization)}/capture", post, options)
         end
       end
@@ -149,25 +151,24 @@ module ActiveMerchant #:nodoc:
         MultiResponse.run(:first) do |r|
           r.process { commit(:post, "charges/#{CGI.escape(identification)}/refunds", post, options) }
 
-          return r unless options[:refund_fee_amount]
-
-          r.process { fetch_application_fees(identification, options) }
-          r.process { refund_application_fee(options[:refund_fee_amount], application_fee_from_response(r.responses.last), options) }
+          if options[:refund_fee_amount] && options[:refund_fee_amount].to_s != '0'
+            r.process { fetch_application_fee(identification, options) }
+            r.process { refund_application_fee(options[:refund_fee_amount].to_i, application_fee_from_response(r.responses.last), options) }
+          end
         end
       end
 
       def verify(payment, options = {})
         MultiResponse.run(:use_first_response) do |r|
           r.process { authorize(auth_minimum_amount(options), payment, options) }
+          options[:idempotency_key] = nil
           r.process(:ignore_result) { void(r.authorization, options) }
         end
       end
 
       def application_fee_from_response(response)
         return unless response.success?
-
-        application_fees = response.params["data"].select { |fee| fee["object"] == "application_fee" }
-        application_fees.first["id"] unless application_fees.empty?
+        response.params["application_fee"] unless response.params["application_fee"].empty?
       end
 
       def refund_application_fee(money, identification, options = {})
@@ -175,9 +176,11 @@ module ActiveMerchant #:nodoc:
 
         post = {}
         add_amount(post, money, options)
-        options.merge!(:key => @fee_refund_api_key)
+        options.merge!(:key => @fee_refund_api_key) if @fee_refund_api_key
+        options.delete(:stripe_account)
 
-        commit(:post, "application_fees/#{CGI.escape(identification)}/refund", post, options)
+        refund_fee = commit(:post, "application_fees/#{CGI.escape(identification)}/refunds", post, options)
+        application_fee_response!(refund_fee, "Application fee could not be refunded: #{refund_fee.message}")
       end
 
       # Note: creating a new credit card will not change the customer's existing default credit card (use :set_default => true)
@@ -303,7 +306,10 @@ module ActiveMerchant #:nodoc:
           add_creditcard(post, payment, options)
         end
 
-        unless emv_payment?(payment)
+        if emv_payment?(payment)
+          add_statement_address(post, options)
+          add_emv_metadata(post, payment)
+        else
           add_amount(post, money, options, true)
           add_customer_data(post, options)
           post[:description] = options[:description]
@@ -315,6 +321,7 @@ module ActiveMerchant #:nodoc:
 
         add_metadata(post, options)
         add_application_fee(post, options)
+        add_exchange_rate(post, options)
         add_destination(post, options)
         post
       end
@@ -329,8 +336,16 @@ module ActiveMerchant #:nodoc:
         post[:application_fee] = options[:application_fee] if options[:application_fee]
       end
 
+      def add_exchange_rate(post, options)
+        post[:exchange_rate] = options[:exchange_rate] if options[:exchange_rate]
+      end
+
       def add_destination(post, options)
-        post[:destination] = options[:destination] if options[:destination]
+        if options[:destination]
+          post[:destination] = {}
+          post[:destination][:account] = options[:destination]
+          post[:destination][:amount] = options[:destination_amount] if options[:destination_amount]
+        end
       end
 
       def add_expand_parameters(post, options)
@@ -365,12 +380,23 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_statement_address(post, options)
+        return unless statement_address = options[:statement_address]
+        return unless [:address1, :city, :zip, :state].all? { |key| statement_address[key].present? }
+
+        post[:statement_address] = {}
+        post[:statement_address][:line1] = statement_address[:address1]
+        post[:statement_address][:line2] = statement_address[:address2] if statement_address[:address2].present?
+        post[:statement_address][:city] = statement_address[:city]
+        post[:statement_address][:postal_code] = statement_address[:zip]
+        post[:statement_address][:state] = statement_address[:state]
+      end
+
       def add_creditcard(post, creditcard, options)
         card = {}
         if emv_payment?(creditcard)
           add_emv_creditcard(post, creditcard.icc_data)
-          post[:card][:read_method] = "contactless" if creditcard.contactless_emv
-          post[:card][:read_method] = "contactless_magstripe_mode" if creditcard.contactless_magstripe
+          post[:card][:read_method] = "contactless" if creditcard.read_method == 'contactless'
           if creditcard.encrypted_pin_cryptogram.present? && creditcard.encrypted_pin_ksn.present?
             post[:card][:encrypted_pin] = creditcard.encrypted_pin_cryptogram
             post[:card][:encrypted_pin_key_id] = creditcard.encrypted_pin_ksn
@@ -378,9 +404,11 @@ module ActiveMerchant #:nodoc:
         elsif creditcard.respond_to?(:number)
           if creditcard.respond_to?(:track_data) && creditcard.track_data.present?
             card[:swipe_data] = creditcard.track_data
-            card[:fallback_reason] = creditcard.fallback_reason if creditcard.fallback_reason
-            card[:read_method] = "contactless" if creditcard.contactless_emv
-            post[:read_method] = "contactless_magstripe_mode" if creditcard.contactless_magstripe
+            if creditcard.respond_to?(:read_method)
+              card[:fallback_reason] = 'no_chip' if creditcard.read_method == 'fallback_no_chip'
+              card[:fallback_reason] = 'chip_error' if creditcard.read_method == 'fallback_chip_error'
+              card[:read_method] = "contactless_magstripe_mode" if creditcard.read_method == 'contactless_magstripe'
+            end
           else
             card[:number] = creditcard.number
             card[:exp_month] = creditcard.month
@@ -432,16 +460,27 @@ module ActiveMerchant #:nodoc:
       end
 
       def add_metadata(post, options = {})
-        post[:metadata] = options[:metadata] || {}
+        post[:metadata] ||= {}
+        post[:metadata].merge!(options[:metadata]) if options[:metadata]
         post[:metadata][:email] = options[:email] if options[:email]
         post[:metadata][:order_id] = options[:order_id] if options[:order_id]
         post.delete(:metadata) if post[:metadata].empty?
       end
 
-      def fetch_application_fees(identification, options = {})
+      def add_emv_metadata(post, creditcard)
+        post[:metadata] ||= {}
+        post[:metadata][:card_read_method] = creditcard.read_method if creditcard.respond_to?(:read_method)
+      end
+
+      def fetch_application_fee(identification, options = {})
         options.merge!(:key => @fee_refund_api_key)
 
-        commit(:get, "application_fees?charge=#{identification}", nil, options)
+        fetch_charge = commit(:get, "charges/#{CGI.escape(identification)}", nil, options)
+        application_fee_response!(fetch_charge, "Application fee id could not be retrieved: #{fetch_charge.message}")
+      end
+
+      def application_fee_response!(response, message)
+        response.success? ? response : Response.new(false, message)
       end
 
       def parse(body)
@@ -475,7 +514,7 @@ module ActiveMerchant #:nodoc:
           "Authorization" => "Basic " + Base64.encode64(key.to_s + ":").strip,
           "User-Agent" => "Stripe/v1 ActiveMerchantBindings/#{ActiveMerchant::VERSION}",
           "Stripe-Version" => api_version(options),
-          "X-Stripe-Client-User-Agent" => user_agent,
+          "X-Stripe-Client-User-Agent" => stripe_client_user_agent(options),
           "X-Stripe-Client-User-Metadata" => {:ip => options[:ip]}.to_json
         }
         headers.merge!("Idempotency-Key" => idempotency_key) if idempotency_key
@@ -483,6 +522,11 @@ module ActiveMerchant #:nodoc:
         headers
       end
 
+      def stripe_client_user_agent(options)
+        return user_agent unless options[:application]
+        JSON.dump(JSON.parse(user_agent).merge!({application: options[:application]}))
+      end
+
       def api_version(options)
         options[:version] || @options[:version] || "2015-04-07"
       end
@@ -505,14 +549,14 @@ module ActiveMerchant #:nodoc:
         add_expand_parameters(parameters, options) if parameters
         response = api_request(method, url, parameters, options)
 
-        success = !response.key?("error")
+        success = success_from(response)
 
         card = card_from_response(response)
         avs_code = AVS_CODE_TRANSLATOR["line1: #{card["address_line1_check"]}, zip: #{card["address_zip_check"]}"]
         cvc_code = CVC_CODE_TRANSLATOR[card["cvc_check"]]
 
         Response.new(success,
-          success ? "Transaction approved" : response["error"]["message"],
+          message_from(success, response),
           response,
           :test => response_is_test?(response),
           :authorization => authorization_from(success, url, method, response),
@@ -524,7 +568,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def authorization_from(success, url, method, response)
-        return response["error"]["charge"] unless success
+        return response.fetch("error", {})["charge"] unless success
 
         if url == "customers"
           [response["id"], response["sources"]["data"].first["id"]].join("|")
@@ -535,6 +579,14 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def message_from(success, response)
+        success ? "Transaction approved" : response.fetch("error", {"message" => "No error details"})["message"]
+      end
+
+      def success_from(response)
+        !response.key?("error") && response["status"] != "failed"
+      end
+
       def response_error(raw_response)
         begin
           parse(raw_response)
@@ -567,6 +619,10 @@ module ActiveMerchant #:nodoc:
         payment.respond_to?(:emv?) && payment.emv?
       end
 
+      def quickchip_payment?(payment)
+        payment.respond_to?(:read_method) && payment.read_method == 'contact_quickchip'
+      end
+
       def card_from_response(response)
         response["card"] || response["active_card"] || response["source"] || {}
       end
@@ -578,6 +634,8 @@ module ActiveMerchant #:nodoc:
       end
 
       def error_code_from(response)
+        return STANDARD_ERROR_CODE_MAPPING['processing_error'] unless response['error']
+
         code = response['error']['code']
         decline_code = response['error']['decline_code'] if code == 'card_declined'
 

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

@@ -16,7 +16,6 @@ module ActiveMerchant
       self.supported_countries = %w(AR AU BR FR DE HK MX NZ SG GB US)
       self.default_currency = 'USD'
       self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb, :maestro, :laser]
-      self.ssl_version = :TLSv1
 
     end
   end

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

@@ -1,4 +1,5 @@
 module ActiveMerchant #:nodoc:
+
   module Billing #:nodoc:
     class TransFirstGateway < Gateway
       self.test_url = 'https://ws.cert.transfirst.com'
@@ -16,7 +17,7 @@ module ActiveMerchant #:nodoc:
       ACTIONS = {
         purchase: "CCSale",
         purchase_echeck: "ACHDebit",
-        refund: "CreditCardAutoRefundorVoid",
+        refund: "CreditCardCredit",
         refund_echeck: "ACHVoidTransaction",
         void: "CreditCardAutoRefundorVoid",
       }
@@ -52,6 +53,7 @@ module ActiveMerchant #:nodoc:
         transaction_id, payment_type = split_authorization(authorization)
         add_amount(post, money)
         add_pair(post, :TransID, transaction_id)
+        add_pair(post, :RefID, options[:order_id], required: true)
 
         commit((payment_type == "check" ? :refund_echeck : :refund), post)
       end
@@ -169,7 +171,6 @@ module ActiveMerchant #:nodoc:
 
       def commit(action, params)
         response = parse(ssl_post(url(action), post_data(action, params)))
-
         Response.new(
           success_from(response),
           message_from(response),