activemerchant 1.56.0 → 1.66.0

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

@@ -0,0 +1,416 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class Latitude19Gateway < Gateway
+      self.display_name = "Latitude19 Gateway"
+      self.homepage_url = "http://www.l19tech.com"
+
+      self.live_url = "https://gateway.l19tech.com/payments/"
+      self.test_url = "https://gateway-sb.l19tech.com/payments/"
+
+      self.supported_countries = ["US", "CA"]
+      self.default_currency = "USD"
+      self.money_format = :cents
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club, :jcb]
+
+      RESPONSE_CODE_MAPPING = {
+        '100' => 'Approved',
+        '101' => 'Local duplicate detected',
+        '102' => 'Accepted local capture with no match',
+        '103' => 'Auth succeeded but capture failed',
+        '104' => 'Auth succeeded but failed to save info',
+        '200' => STANDARD_ERROR_CODE[:card_declined],
+        '300' => 'Processor reject',
+        '301' => 'Local reject on user/password',
+        '302' => 'Local reject',
+        '303' => 'Processor unknown response',
+        '304' => 'Error parsing processor response',
+        '305' => 'Processor auth succeeded but settle failed',
+        '306' => 'Processor auth succeeded settle status unknown',
+        '307' => 'Processor settle status unknown',
+        '308' => 'Processor duplicate',
+        '400' => 'Not submitted',
+        '401' => 'Terminated before request submitted',
+        '402' => 'Local server busy',
+        '500' => 'Submitted not returned',
+        '501' => 'Terminated before response returned',
+        '502' => 'Processor returned timeout status',
+        '600' => 'Failed local capture with no match',
+        '601' => 'Failed local capture',
+        '700' => 'Failed local void (not in capture file)',
+        '701' => 'Failed local void',
+        '800' => 'Failed local refund (not authorized)',
+        '801' => 'Failed local refund'
+      }
+
+      BRAND_MAP = {
+        "master" => "MC",
+        "visa" => "VI",
+        "american_express" => "AX",
+        "discover" => "DS",
+        "diners_club" => "DC",
+        "jcb" => "JC"
+      }
+
+      def initialize(options={})
+        requires!(options, :account_number, :configuration_id, :secret)
+        super
+      end
+
+      def purchase(amount, payment_method, options={})
+        if payment_method.is_a?(String)
+          auth_or_sale("sale", payment_method, amount, nil, options)
+        else
+          MultiResponse.run() do |r|
+            r.process { get_session(options) }
+            r.process { get_token(r.authorization, payment_method, options) }
+            r.process { auth_or_sale("sale", r.authorization, amount, payment_method, options) }
+          end
+        end
+      end
+
+      def authorize(amount, payment_method, options={})
+        if payment_method.is_a?(String)
+          auth_or_sale("auth", payment_method, amount, nil, options)
+        else
+          MultiResponse.run() do |r|
+            r.process { get_session(options) }
+            r.process { get_token(r.authorization, payment_method, options) }
+            r.process { auth_or_sale("auth", r.authorization, amount, payment_method, options) }
+          end
+        end
+      end
+
+      def capture(amount, authorization, options={})
+        post = {}
+        post[:method] = "deposit"
+        add_request_id(post)
+
+        params = {}
+
+        _, params[:pgwTID] = split_authorization(authorization)
+
+        add_invoice(params, amount, options)
+        add_credentials(params, post[:method])
+
+        post[:params] = [params]
+        commit("v1/", post)
+      end
+
+      def void(authorization, options={})
+        method, pgwTID = split_authorization(authorization)
+        case method
+        when "auth"
+          reverse_or_void("reversal", pgwTID, options)
+        when "deposit", "sale"
+          reverse_or_void("void", pgwTID, options)
+        else
+          message = "Unsupported operation: successful Purchase, Authorize and unsettled Capture transactions can only be voided."
+          return Response.new(false, message)
+        end
+      end
+
+      def credit(amount, payment_method, options={})
+        if payment_method.is_a?(String)
+          refundWithCard(payment_method, amount, nil, options)
+        else
+          MultiResponse.run() do |r|
+            r.process { get_session(options) }
+            r.process { get_token(r.authorization, payment_method, options) }
+            r.process { refundWithCard(r.authorization, amount, payment_method, options) }
+          end
+        end
+      end
+
+      def verify(payment_method, options={}, action=nil)
+        if payment_method.is_a?(String)
+          verifyOnly(action, payment_method, nil, options)
+        else
+          MultiResponse.run() do |r|
+            r.process { get_session(options) }
+            r.process { get_token(r.authorization, payment_method, options) }
+            r.process { verifyOnly(action, r.authorization, payment_method, options) }
+          end
+        end
+      end
+
+      def store(payment_method, options={})
+        verify(payment_method, options, "store")
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((\"cardNumber\\\":\\\")\d+), '\1[FILTERED]').
+          gsub(%r((\"cvv\\\":\\\")\d+), '\1[FILTERED]')
+      end
+
+
+      private
+
+      def add_request_id(post)
+        post[:id] = SecureRandom.hex(16)
+      end
+
+      def add_timestamp()
+        Time.now.getutc.strftime("%Y%m%d%H%M%S")
+      end
+
+      def add_hmac(params, method)
+        if method == "getSession"
+          hmac_message = params[:pgwAccountNumber] + "|" + params[:pgwConfigurationId] + "|" + params[:requestTimeStamp] + "|" + method
+        else
+          hmac_message = params[:pgwAccountNumber] + "|" + params[:pgwConfigurationId] + "|" + (params[:orderNumber] || "") + "|" + method + "|" + (params[:amount] || "") + "|" + (params[:sessionToken] || "") + "|" + (params[:accountToken] || "")
+        end
+
+        OpenSSL::HMAC.hexdigest('sha512', @options[:secret], hmac_message)
+      end
+
+      def add_credentials(params, method)
+        params[:pgwAccountNumber] = @options[:account_number]
+        params[:pgwConfigurationId] = @options[:configuration_id]
+
+        params[:requestTimeStamp] = add_timestamp() if method == "getSession"
+
+        params[:pgwHMAC] = add_hmac(params, method)
+      end
+
+      def add_invoice(params, money, options)
+        params[:amount] = amount(money)
+        params[:orderNumber] = options[:order_id]
+        params[:transactionClass] = options[:transaction_class] || "eCommerce"
+      end
+
+      def add_payment_method(params, credit_card)
+        params[:cardExp] = format(credit_card.month, :two_digits).to_s + "/" + format(credit_card.year, :two_digits).to_s
+        params[:cardType] = BRAND_MAP[credit_card.brand.to_s]
+        params[:cvv] = credit_card.verification_value
+        params[:firstName] = credit_card.first_name
+        params[:lastName] = credit_card.last_name
+      end
+
+      def add_customer_data(params, options)
+        if (billing_address = options[:billing_address] || options[:address])
+          params[:address1] = billing_address[:address1]
+          params[:address2] = billing_address[:address2]
+          params[:city] = billing_address[:city]
+          params[:stateProvince] = billing_address[:state]
+          params[:zipPostalCode] = billing_address[:zip]
+          params[:countryCode] = billing_address[:country]
+        end
+      end
+
+      def get_session(options={})
+        post = {}
+        post[:method] = "getSession"
+        add_request_id(post)
+
+        params = {}
+        add_credentials(params, post[:method])
+
+        post[:params] = [params]
+        commit("session", post)
+      end
+
+      def get_token(authorization, payment_method, options={})
+        post = {}
+        post[:method] = "tokenize"
+        add_request_id(post)
+
+        params = {}
+        _, params[:sessionId] = split_authorization(authorization)
+        params[:cardNumber] = payment_method.number
+
+        post[:params] = [params]
+        commit("token", post)
+      end
+
+      def auth_or_sale(method, authorization, amount, credit_card, options={})
+        post = {}
+        post[:method] = method
+        add_request_id(post)
+
+        params = {}
+        if credit_card
+          _, params[:sessionToken] = split_authorization(authorization)
+          add_payment_method(params, credit_card)
+          add_customer_data(params, options)
+        else
+          _, params[:accountToken] = split_authorization(authorization)
+        end
+        add_invoice(params, amount, options)
+        add_credentials(params, post[:method])
+
+        post[:params] = [params]
+        commit("v1/", post)
+      end
+
+      def verifyOnly(action, authorization, credit_card, options={})
+        post = {}
+        post[:method] = "verifyOnly"
+        add_request_id(post)
+
+        params = {}
+        if credit_card
+          _, params[:sessionToken] = split_authorization(authorization)
+          add_payment_method(params, credit_card)
+          add_customer_data(params, options)
+        else
+          _, params[:accountToken] = split_authorization(authorization)
+        end
+        params[:requestAccountToken] = "1" if action == "store"
+        add_invoice(params, 0, options)
+        add_credentials(params, post[:method])
+
+        post[:params] = [params]
+        commit("v1/", post)
+      end
+
+      def refundWithCard(authorization, amount, credit_card, options={})
+        post = {}
+        post[:method] = "refundWithCard"
+        add_request_id(post)
+
+        params = {}
+        if credit_card
+          _, params[:sessionToken] = split_authorization(authorization)
+          add_payment_method(params, credit_card)
+        else
+          _, params[:accountToken] = split_authorization(authorization)
+        end
+        add_invoice(params, amount, options)
+        add_credentials(params, post[:method])
+
+        post[:params] = [params]
+        commit("v1/", post)
+      end
+
+      def reverse_or_void(method, pgwTID, options={})
+        post = {}
+        post[:method] = method
+        add_request_id(post)
+
+        params = {}
+        params[:orderNumber] = options[:order_id]
+        params[:pgwTID] = pgwTID
+        add_credentials(params, post[:method])
+
+        post[:params] = [params]
+        commit("v1/", post)
+      end
+
+      def commit(endpoint, post)
+        begin
+          raw_response = ssl_post(url() + endpoint, post_data(post), headers)
+          response = parse(raw_response)
+        rescue ResponseError => e
+          raw_response = e.response.body
+          response_error(raw_response)
+        rescue JSON::ParserError
+          unparsable_response(raw_response)
+        else
+          success = success_from(response)
+          Response.new(
+            success,
+            message_from(response),
+            response,
+            authorization: success ? authorization_from(response, post[:method]) : nil,
+            avs_result: success ? avs_from(response) : nil,
+            cvv_result: success ? cvv_from(response) : nil,
+            error_code: success ? nil : error_from(response),
+            test: test?
+          )
+        end
+      end
+
+      def headers
+        {
+          "Content-Type"  => "application/json"
+        }
+      end
+
+      def post_data(params)
+        params.to_json
+      end
+
+      def url
+        test? ? test_url : live_url
+      end
+
+      def parse(body)
+        JSON.parse(body)
+      end
+
+      def success_from(response)
+        return false if response["result"].nil? || response["error"]
+
+        if response["result"].key?("pgwResponseCode")
+          response["error"].nil? && response["result"]["lastActionSucceeded"] == 1 && response["result"]["pgwResponseCode"] == "100"
+        else
+          response["error"].nil? && response["result"]["lastActionSucceeded"] == 1
+        end
+      end
+
+      def message_from(response)
+        return response["error"] if response["error"]
+        return "Failed" unless response.key?("result")
+
+        if response["result"].key?("pgwResponseCode")
+          RESPONSE_CODE_MAPPING[response["result"]["pgwResponseCode"]] || response["result"]["responseText"]
+        else
+          response["result"]["lastActionSucceeded"] == 1 ? "Succeeded" : "Failed"
+        end
+      end
+
+      def error_from(response)
+        return response["error"] if response["error"]
+        return "Failed" unless response.key?("result")
+        return response["result"]["pgwResponseCode"] || response["result"]["processor"]["responseCode"] || "Failed"
+      end
+
+      def authorization_from(response, method)
+        method + "|" + (
+          response["result"]["sessionId"] ||
+          response["result"]["sessionToken"] ||
+          response["result"]["pgwTID"] ||
+          response["result"]["accountToken"]
+        )
+      end
+
+      def split_authorization(authorization)
+        authorization.split("|")
+      end
+
+      def avs_from(response)
+        response["result"].key?("avsResponse") ? AVSResult.new(code: response["result"]["avsResponse"]) : nil
+      end
+
+      def cvv_from(response)
+        response["result"].key?("cvvResponse") ? CVVResult.new(response["result"]["cvvResponse"]) : nil
+      end
+
+      def response_error(raw_response)
+        begin
+          response = parse(raw_response)
+        rescue JSON::ParserError
+          unparsable_response(raw_response)
+        else
+          return Response.new(
+            false,
+            message_from(response),
+            response,
+            :test => test?
+          )
+        end
+      end
+
+      def unparsable_response(raw_response)
+        message = "Invalid JSON response received from Latitude19Gateway. Please contact Latitude19Gateway if you continue to receive this message."
+        message += " (The raw response returned by the API was #{raw_response.inspect})"
+        return Response.new(false, message)
+      end
+    end
+  end
+end

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

@@ -144,6 +144,8 @@ module ActiveMerchant #:nodoc:
         }.update(options)
 
         raise ArgumentError, "You need to pass in your pem file using the :pem parameter or set it globally using ActiveMerchant::Billing::LinkpointGateway.pem_file = File.read( File.dirname(__FILE__) + '/../mycert.pem' ) or similar" if @options[:pem].blank?
+
+        @options[:pem].strip!
       end
 
       # Send a purchase request with periodic options

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

@@ -34,7 +34,7 @@ module ActiveMerchant #:nodoc:
           end
         end
 
-        commit(:sale, request)
+        commit(:sale, request, money)
       end
 
       def authorize(money, payment_method, options={})
@@ -45,11 +45,11 @@ module ActiveMerchant #:nodoc:
           end
         end
 
-        commit(:authorization, request)
+        commit(:authorization, request, money)
       end
 
       def capture(money, authorization, options={})
-        transaction_id, _ = split_authorization(authorization)
+        transaction_id, _, _ = split_authorization(authorization)
 
         request = build_xml_request do |doc|
           add_authentication(doc)
@@ -60,7 +60,7 @@ module ActiveMerchant #:nodoc:
           end
         end
 
-        commit(:capture, request)
+        commit(:capture, request, money)
       end
 
       def credit(money, authorization, options = {})
@@ -69,7 +69,7 @@ module ActiveMerchant #:nodoc:
       end
 
       def refund(money, authorization, options={})
-        transaction_id, _ = split_authorization(authorization)
+        transaction_id, _, _ = split_authorization(authorization)
 
         request = build_xml_request do |doc|
           add_authentication(doc)
@@ -91,12 +91,13 @@ module ActiveMerchant #:nodoc:
       end
 
       def void(authorization, options={})
-        transaction_id, kind = split_authorization(authorization)
+        transaction_id, kind, money = split_authorization(authorization)
 
         request = build_xml_request do |doc|
           add_authentication(doc)
           doc.send(void_type(kind), transaction_attributes(options)) do
             doc.litleTxnId(transaction_id)
+            doc.amount(money) if void_type(kind) == :authReversal
           end
         end
 
@@ -120,6 +121,21 @@ module ActiveMerchant #:nodoc:
         commit(:registerToken, request)
       end
 
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((<user>).+(</user>)), '\1[FILTERED]\2').
+          gsub(%r((<password>).+(</password>)), '\1[FILTERED]\2').
+          gsub(%r((<number>).+(</number>)), '\1[FILTERED]\2').
+          gsub(%r((<cardValidationNum>).+(</cardValidationNum>)), '\1[FILTERED]\2').
+          gsub(%r((<accountNumber>).+(</accountNumber>)), '\1[FILTERED]\2').
+          gsub(%r((<paypageRegistrationId>).+(</paypageRegistrationId>)), '\1[FILTERED]\2').
+          gsub(%r((<authenticationValue>).+(</authenticationValue>)), '\1[FILTERED]\2')
+      end
+
       private
       CARD_TYPE = {
         'visa'             => 'VI',
@@ -243,7 +259,7 @@ module ActiveMerchant #:nodoc:
       def add_order_source(doc, payment_method, options)
         if options[:order_source]
           doc.orderSource(options[:order_source])
-        elsif payment_method.is_a?(NetworkTokenizationCreditCard)
+        elsif payment_method.is_a?(NetworkTokenizationCreditCard) && payment_method.source == :apple_pay
           doc.orderSource('applepay')
         elsif payment_method.respond_to?(:track_data) && payment_method.track_data.present?
           doc.orderSource('retail')
@@ -290,11 +306,11 @@ module ActiveMerchant #:nodoc:
         parsed
       end
 
-      def commit(kind, request)
+      def commit(kind, request, money=nil)
         parsed = parse(kind, ssl_post(url, request, headers))
 
         options = {
-          authorization: authorization_from(kind, parsed),
+          authorization: authorization_from(kind, parsed, money),
           test: test?,
           :avs_result => { :code => AVS_RESPONSE_CODE[parsed[:fraudResult_avsResult]] },
           :cvv_result => parsed[:fraudResult_cardValidationResult]
@@ -308,13 +324,13 @@ module ActiveMerchant #:nodoc:
         %w(000 801 802).include?(parsed[:response])
       end
 
-      def authorization_from(kind, parsed)
-        (kind == :registerToken) ? parsed[:litleToken] : "#{parsed[:litleTxnId]};#{kind}"
+      def authorization_from(kind, parsed, money)
+        (kind == :registerToken) ? parsed[:litleToken] : "#{parsed[:litleTxnId]};#{kind};#{money}"
       end
 
       def split_authorization(authorization)
-        transaction_id, kind = authorization.to_s.split(';')
-        [transaction_id, kind]
+        transaction_id, kind, money = authorization.to_s.split(';')
+        [transaction_id, kind, money]
       end
 
       def transaction_attributes(options)