activemerchant 1.64.0 → 1.65.0

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

@@ -686,6 +686,8 @@ module ActiveMerchant #:nodoc:
           response = parse(ssl_post(test? ? self.test_url : self.live_url, build_request(request, options)))
         rescue ResponseError => e
           response = parse(e.response.body)
+        rescue REXML::ParseException => e
+          response = { message: e.to_s }
         end
 
         success = response[:decision] == "ACCEPT"

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

@@ -131,8 +131,8 @@ module ActiveMerchant #:nodoc:
         if payment
           post["order"]["customer"]["personalInformation"] = {
             "name" => {
-              "firstName" => payment.first_name,
-              "surname" => payment.last_name
+              "firstName" => payment.first_name[0..14],
+              "surname" => payment.last_name[0..69]
             }
           }
         end
@@ -262,14 +262,20 @@ EOS
       end
 
       def success_from(response)
-        !response["errorId"]
+        !response["errorId"] && response["status"] != "REJECTED"
       end
 
       def message_from(succeeded, response)
         if succeeded
           "Succeeded"
         else
-          response["errors"][0]["message"] || "Unable to read error message"
+          if errors = response["errors"]
+            errors.first.try(:[], "message")
+          elsif status = response["status"]
+            "Status: " + status
+          else
+            "No message available"
+          end
         end
       end
 
@@ -283,7 +289,13 @@ EOS
 
       def error_code_from(succeeded, response)
         unless succeeded
-          response["errors"][0]["code"] || "Unable to read error code"
+          if errors = response["errors"]
+            errors.first.try(:[], "code")
+          elsif status = response.try(:[], "statusOutput").try(:[], "statusCode")
+            status.to_s
+          else
+            "No error code available"
+          end
         end
       end
 

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

@@ -165,12 +165,15 @@ module ActiveMerchant #:nodoc:
       end
 
       def capture(money, reference, options = {})
-        commit(money, build_capture_request(reference.split(";").first, money, options))
+        split_authorization = reference.split(";")
+        transaction_id = split_authorization[0]
+        token = split_authorization[3]
+        commit(money, build_capture_request(transaction_id, money, options), token)
       end
 
       def void(reference, options = {})
         transaction_id, approval, amount, token = reference.split(";")
-        commit(amount.to_i, build_void_request(amount.to_i, transaction_id, approval, token, options))
+        commit(amount.to_i, build_void_request(amount.to_i, transaction_id, approval, token, options), token)
       end
 
       def credit(money, transaction_id_or_card, options = {})
@@ -183,9 +186,9 @@ module ActiveMerchant #:nodoc:
       end
 
       def refund(money, reference, options = {})
-        params = reference.split(";")
-        transaction_id = params[0]
-        token = params[3]
+        split_authorization = reference.split(";")
+        transaction_id = split_authorization[0]
+        token = split_authorization[3]
         credit_card = options[:credit_card]
         commit(money, build_credit_request('CREDIT', money, transaction_id, credit_card, token, options))
       end
@@ -279,7 +282,7 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def commit(money, request)
+      def commit(money, request, token = nil)
         response = parse(ssl_post(url, request))
 
         success = success?(response)
@@ -287,7 +290,7 @@ module ActiveMerchant #:nodoc:
           success ? 'APPROVED' : message_from(response),
           response,
           :test => test?,
-          :authorization => authorization_from(response, money),
+          :authorization => authorization_from(response, money, token),
           :avs_result => { :code => response[:avs] },
           :cvv_result => response[:cvv2]
         )
@@ -330,9 +333,9 @@ module ActiveMerchant #:nodoc:
         ACTION_CODE_MESSAGES[response[:action_code]]
       end
 
-      def authorization_from(response, money)
+      def authorization_from(response, money, previous_token)
         original_amount = amount(money) if money
-        [ response[:transaction_id], response[:approval], original_amount, response[:token]].join(";")
+        [ response[:transaction_id], response[:approval], original_amount, (response[:token] || previous_token)].join(";")
       end
 
       def add_credit_card(xml, credit_card)

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

@@ -113,6 +113,7 @@ module ActiveMerchant #:nodoc:
         post[:order_id] = options[:order_id]
         post[:device_session_id] = options[:device_session_id]
         post[:currency] = (options[:currency] || currency(money)).upcase
+        post[:use_card_points] = options[:use_card_points] if options[:use_card_points]
         add_creditcard(post, creditcard, options)
         post
       end

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

@@ -417,10 +417,12 @@ module ActiveMerchant #:nodoc:
         #   Do not submit the attribute at all.
         # - http://download.chasepaymentech.com/docs/orbital/orbital_gateway_xml_specification.pdf
         unless creditcard.nil?
-          if %w( visa discover ).include?(creditcard.brand)
-            xml.tag! :CardSecValInd, (creditcard.verification_value? ? '1' : '9')
+          if creditcard.verification_value?
+            if %w( visa discover ).include?(creditcard.brand)
+              xml.tag! :CardSecValInd, '1'
+            end
+            xml.tag! :CardSecVal,  creditcard.verification_value
           end
-          xml.tag! :CardSecVal,  creditcard.verification_value if creditcard.verification_value?
         end
       end
 

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

@@ -37,6 +37,7 @@ module ActiveMerchant
         add_payment_method(params, payment_method)
         add_address(params, options)
         add_amount(params, amount, options)
+        add_soft_descriptors(params, options)
 
         commit(params, options)
       end
@@ -48,6 +49,7 @@ module ActiveMerchant
         add_payment_method(params, payment_method)
         add_address(params, options)
         add_amount(params, amount, options)
+        add_soft_descriptors(params, options)
 
         commit(params, options)
       end
@@ -57,6 +59,7 @@ module ActiveMerchant
 
         add_authorization_info(params, authorization)
         add_amount(params, amount, options)
+        add_soft_descriptors(params, options)
 
         commit(params, options)
       end
@@ -169,6 +172,10 @@ module ActiveMerchant
         params[:amount] = amount(money)
       end
 
+      def add_soft_descriptors(params, options)
+        params[:soft_descriptors] = options[:soft_descriptors] if options[:soft_descriptors]
+      end
+
       def commit(params, options)
         url = if options[:integration]
           integration_url

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

@@ -45,7 +45,7 @@ module ActiveMerchant #:nodoc:
         commit('auth', post)
       end
 
-      def capture(authorization, options={})
+      def capture(amount, authorization, options={})
         post = {}
 
         add_credentials(post, 'SUBMIT_TRANSACTION')

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

@@ -29,6 +29,7 @@ module ActiveMerchant #:nodoc:
         add_creditcard(post, creditcard)
         add_address(post, creditcard, options)
         add_capture(post, options)
+        add_metadata(post, options)
 
         commit(:post, 'charges', post, options)
       end
@@ -141,6 +142,10 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_metadata(post, options)
+        post[:metadata] = options[:metadata] if options[:metadata]
+      end
+
       def headers(params = {})
         result = {
           "Content-Type" => "application/json",

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

@@ -10,16 +10,16 @@ module ActiveMerchant #:nodoc:
       self.abstract_class = true
 
       def self.new(options = {})
-        options.fetch(:login) rescue raise ArgumentError.new("Missing required parameter: login")
+        options.fetch(:login) { raise ArgumentError.new("Missing required parameter: login") }
 
         version = options[:login].to_i < 10000000 ? 10 : 7
         if version <= 7
           QuickpayV4to7Gateway.new(options)
         else
-          QuickpayV10Gateway.new(options)     
+          QuickpayV10Gateway.new(options)
         end
       end
-      
+
     end
   end
 end

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

@@ -13,7 +13,7 @@ module ActiveMerchant #:nodoc:
       self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners]
 
       def initialize(options={})
-        requires!(options, :username, :password, :merchant)
+        requires!(options, :username, :password, :merchant, :pem, :pem_password)
         super
       end
 
@@ -24,19 +24,52 @@ module ActiveMerchant #:nodoc:
         add_payment_method(post, payment_method)
         add_verification_value(post, payment_method)
         add_customer_data(post, options)
+        add_soft_descriptors(post, options)
 
         commit("capture", post)
       end
 
+      def authorize(amount, payment_method, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_order_number(post, options)
+        add_payment_method(post, payment_method)
+        add_verification_value(post, payment_method)
+        add_customer_data(post, options)
+        add_soft_descriptors(post, options)
+
+        commit("preauth", post)
+      end
+
+      def capture(amount, authorization, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_reference(post, authorization, options)
+        add_customer_data(post, options)
+        add_soft_descriptors(post, options)
+
+        commit("captureWithoutAuth", post)
+      end
+
       def refund(amount, authorization, options={})
         post = {}
         add_invoice(post, amount, options)
         add_reference(post, authorization, options)
         add_customer_data(post, options)
+        add_soft_descriptors(post, options)
 
         commit("refund", post)
       end
 
+      def void(authorization, options={})
+        post = {}
+        add_reference(post, authorization, options)
+        add_customer_data(post, options)
+        add_soft_descriptors(post, options)
+
+        commit("reversal", post)
+      end
+
       def store(payment_method, options = {})
         post = {}
         add_payment_method(post, payment_method)
@@ -62,6 +95,16 @@ module ActiveMerchant #:nodoc:
       CURRENCY_CODES["AUD"] = "AUD"
       CURRENCY_CODES["INR"] = "INR"
 
+      def add_soft_descriptors(post, options)
+        post["customer.merchantName"] = options[:customer_merchant_name] if options[:customer_merchant_name]
+        post["customer.merchantStreetAddress"] = options[:customer_merchant_street_address] if options[:customer_merchant_street_address]
+        post["customer.merchantLocation"] = options[:customer_merchant_location] if options[:customer_merchant_location]
+        post["customer.merchantState"] = options[:customer_merchant_state] if options[:customer_merchant_state]
+        post["customer.merchantCountry"] = options[:customer_merchant_country] if options[:customer_merchant_country]
+        post["customer.merchantPostCode"] = options[:customer_merchant_post_code] if options[:customer_merchant_post_code]
+        post["customer.subMerchantId"] = options[:customer_sub_merchant_id] if options[:customer_sub_merchant_id]
+      end
+
       def add_invoice(post, money, options)
         post["order.amount"] = amount(money)
         post["card.currency"] = CURRENCY_CODES[options[:currency] || currency(money)]

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

@@ -0,0 +1,211 @@
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class SafeChargeGateway < Gateway
+      self.test_url = 'https://process.sandbox.safecharge.com/service.asmx/Process'
+      self.live_url = 'https://process.safecharge.com/service.asmx/Process'
+
+      self.supported_countries = ['US']
+      self.default_currency = 'USD'
+      self.supported_cardtypes = [:visa, :master]
+
+      self.homepage_url = 'https://www.safecharge.com'
+      self.display_name = 'SafeCharge'
+
+      VERSION = '4.0.4'
+
+      def initialize(options={})
+        requires!(options, :client_login_id, :client_password)
+        super
+      end
+
+      def purchase(money, payment, options={})
+        post = {}
+        add_transaction_data("Sale", post, money, options)
+        add_payment(post, payment)
+
+        commit(post)
+      end
+
+      def authorize(money, payment, options={})
+        post = {}
+        add_transaction_data("Auth", post, money, options)
+        add_payment(post, payment)
+
+        commit(post)
+      end
+
+      def capture(money, authorization, options={})
+        post = {}
+        add_transaction_data("Settle", post, money, options)
+        auth, transaction_id, token, exp_month, exp_year, _ = authorization.split("|")
+        post[:sg_AuthCode] = auth
+        post[:sg_TransactionID] = transaction_id
+        post[:sg_CCToken] = token
+        post[:sg_ExpMonth] = exp_month
+        post[:sg_ExpYear] = exp_year
+
+        commit(post)
+      end
+
+      def refund(money, authorization, options={})
+        post = {}
+        add_transaction_data("Credit", post, money, options)
+        auth, transaction_id, token, exp_month, exp_year, _ = authorization.split("|")
+        post[:sg_CreditType] = 2
+        post[:sg_AuthCode] = auth
+        post[:sg_TransactionID] = transaction_id
+        post[:sg_CCToken] = token
+        post[:sg_ExpMonth] = exp_month
+        post[:sg_ExpYear] = exp_year
+
+        commit(post)
+      end
+
+      def void(authorization, options={})
+        post = {}
+        auth, transaction_id, token, exp_month, exp_year, original_amount = authorization.split("|")
+        add_transaction_data("Void", post, (original_amount.to_f * 100), options)
+        post[:sg_CreditType] = 2
+        post[:sg_AuthCode] = auth
+        post[:sg_TransactionID] = transaction_id
+        post[:sg_CCToken] = token
+        post[:sg_ExpMonth] = exp_month
+        post[:sg_ExpYear] = exp_year
+
+        commit(post)
+      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
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((sg_ClientPassword=)[^&]+(&?)), '\1[FILTERED]\2').
+          gsub(%r((sg_CardNumber=)[^&]+(&?)), '\1[FILTERED]\2').
+          gsub(%r((sg_CVV2=)\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      def add_transaction_data(trans_type, post, money, options)
+        post[:sg_TransType] = trans_type
+        post[:sg_Currency] = (options[:currency] || currency(money))
+        post[:sg_Amount] = amount(money)
+        post[:sg_ClientLoginID] = @options[:client_login_id]
+        post[:sg_ClientPassword] = @options[:client_password]
+        post[:sg_ResponseFormat] = "4"
+        post[:sg_Version] = VERSION
+      end
+
+      def add_payment(post, payment)
+        post[:sg_NameOnCard] = payment.name
+        post[:sg_CardNumber] = payment.number
+        post[:sg_ExpMonth] = format(payment.month, :two_digits)
+        post[:sg_ExpYear] = format(payment.year, :two_digits)
+        post[:sg_CVV2] = payment.verification_value
+      end
+
+      def parse(xml)
+        response = {}
+
+        doc = Nokogiri::XML(xml)
+        doc.root.xpath('*').each do |node|
+          response[node.name.underscore.downcase.to_sym] = node.text
+        end
+
+        response
+      end
+
+      def childnode_to_response(response, node, childnode)
+        name = "#{node.name.downcase}_#{childnode.name.downcase}"
+        if name == 'payment_method_data' && !childnode.elements.empty?
+          response[name.to_sym] = Hash.from_xml(childnode.to_s).values.first
+        else
+          response[name.to_sym] = childnode.text
+        end
+      end
+
+      def commit(parameters)
+        url = (test? ? test_url : live_url)
+        response = parse(ssl_post(url, post_data(parameters)))
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response, parameters),
+          avs_result: AVSResult.new(code: response[:avs_code]),
+          cvv_result: CVVResult.new(response[:cvv2_reply]),
+          test: test?,
+          error_code: error_code_from(response)
+        )
+      end
+
+      def success_from(response)
+        response[:status] == "APPROVED"
+      end
+
+      def message_from(response)
+        return "Success" if success_from(response)
+        response[:reason_codes] || response[:reason]
+      end
+
+      def authorization_from(response, parameters)
+        [
+          response[:auth_code],
+          response[:transaction_id],
+          response[:token],
+          parameters[:sg_ExpMonth],
+          parameters[:sg_ExpYear],
+          parameters[:sg_Amount]
+        ].join("|")
+      end
+
+      def split_authorization(authorization)
+        auth_code, transaction_id, token, month, year, original_amount = authorization.split("|")
+
+        {
+          auth_code: auth_code,
+          transaction_id: transaction_id,
+          token: token,
+          exp_month: month,
+          exp_year: year,
+          original_amount: amount(original_amount.to_f * 100)
+        }
+      end
+
+      def post_data(params)
+        return nil unless params
+
+        params.map do |key, value|
+          next if value != false && value.blank?
+          "#{key}=#{CGI.escape(value.to_s)}"
+        end.compact.join("&")
+      end
+
+      def error_code_from(response)
+        unless success_from(response)
+          response[:ex_err_code] || response[:err_code]
+        end
+      end
+
+      def underscore(camel_cased_word)
+        camel_cased_word.to_s.gsub(/::/, '/').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          tr("-", "_").
+          downcase
+      end
+    end
+  end
+end