activemerchant 1.38.0 → 1.78.0

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

@@ -0,0 +1,227 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class KushkiGateway < Gateway
+      self.display_name = "Kushki"
+      self.homepage_url = "https://www.kushkipagos.com"
+
+      self.test_url = "https://api-uat.kushkipagos.com/v1/"
+      self.live_url = "https://api.kushkipagos.com/v1/"
+
+      self.supported_countries = ["CO", "EC"]
+      self.default_currency = "USD"
+      self.money_format = :dollars
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :diners_club]
+
+      def initialize(options={})
+        requires!(options, :public_merchant_id, :private_merchant_id)
+        super
+      end
+
+      def purchase(amount, payment_method, options={})
+        MultiResponse.run() do |r|
+          r.process { tokenize(amount, payment_method, options) }
+          r.process { charge(amount, r.authorization, options) }
+        end
+      end
+
+      def refund(amount, authorization, options={})
+        action = "refund"
+
+        post = {}
+        post[:ticketNumber] = authorization
+
+        commit(action, post)
+      end
+
+      def void(authorization, options={})
+        action = "void"
+
+        post = {}
+        post[:ticketNumber] = authorization
+
+        commit(action, post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Private-Merchant-Id: )\d+), '\1[FILTERED]').
+          gsub(%r((\"card\\\":{\\\"number\\\":\\\")\d+), '\1[FILTERED]').
+          gsub(%r((\"cvv\\\":\\\")\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      def tokenize(amount, payment_method, options)
+        action = "tokenize"
+
+        post = {}
+        add_invoice(action, post, amount, options)
+        add_payment_method(post, payment_method, options)
+
+        commit(action, post)
+      end
+
+      def charge(amount, authorization, options)
+        action = "charge"
+
+        post = {}
+        add_reference(post, authorization, options)
+        add_invoice(action, post, amount, options)
+
+        commit(action, post)
+      end
+
+      def add_invoice(action, post, money, options)
+        if action == "tokenize"
+          post[:totalAmount] = amount(money).to_f
+          post[:currency] = options[:currency] || currency(money)
+          post[:isDeferred] = false
+        else
+          sum = {}
+          sum[:currency] = options[:currency] || currency(money)
+          add_amount_defaults(sum, money, options)
+          add_amount_by_country(sum, options)
+          post[:amount] = sum
+        end
+      end
+
+      def add_amount_defaults(sum, money, options)
+        sum[:subtotalIva] = amount(money).to_f
+        sum[:iva] = 0
+        sum[:subtotalIva0] = 0
+
+        if sum[:currency] == "COP"
+          extra_taxes = {}
+          extra_taxes[:propina] = 0
+          extra_taxes[:tasaAeroportuaria] = 0
+          extra_taxes[:agenciaDeViaje] = 0
+          extra_taxes[:iac] = 0
+          sum[:extraTaxes] = extra_taxes
+        else
+          sum[:ice] = 0
+        end
+      end
+
+      def add_amount_by_country(sum, options)
+        if amount = options[:amount]
+          sum[:subtotalIva] = amount[:subtotal_iva].to_f if amount[:subtotal_iva]
+          sum[:iva] = amount[:iva].to_f if amount[:iva]
+          sum[:subtotalIva0] = amount[:subtotal_iva_0].to_f if amount[:subtotal_iva_0]
+          sum[:ice] = amount[:ice].to_f if amount[:ice]
+          if extra_taxes = amount[:extra_taxes] && sum[:currency] == "COP"
+            sum[:extraTaxes][:propina] = extra_taxes[:propina].to_f if extra_taxes[:propina]
+            sum[:extraTaxes][:tasaAeroportuaria] = extra_taxes[:tasa_aeroportuaria].to_f if extra_taxes[:tasa_aeroportuaria]
+            sum[:extraTaxes][:agenciaDeViaje] = extra_taxes[:agencia_de_viaje].to_f if extra_taxes[:agencia_de_viaje]
+            sum[:extraTaxes][:iac] = extra_taxes[:iac].to_f if extra_taxes[:iac]
+          end
+        end
+      end
+
+      def add_payment_method(post, payment_method, options)
+        card = {}
+        card[:number] = payment_method.number
+        card[:cvv] = payment_method.verification_value
+        card[:expiryMonth] = format(payment_method.month, :two_digits)
+        card[:expiryYear] = format(payment_method.year, :two_digits)
+        card[:name] = payment_method.name
+        post[:card] = card
+      end
+
+      def add_reference(post, authorization, options)
+        post[:token] = authorization
+      end
+
+      ENDPOINT = {
+        "tokenize" => "tokens",
+        "charge" => "charges",
+        "void" => "charges",
+        "refund" => "refund"
+      }
+
+      def commit(action, params)
+        response = begin
+          parse(ssl_invoke(action, params))
+        rescue ResponseError => e
+          parse(e.response.body)
+        end
+
+        success = success_from(response)
+
+        Response.new(
+          success,
+          message_from(success, response),
+          response,
+          authorization: success ? authorization_from(response) : nil,
+          error_code: success ? nil : error_from(response),
+          test: test?
+        )
+      end
+
+      def ssl_invoke(action, params)
+        if ["void", "refund"].include?(action)
+          ssl_request(:delete, url(action, params), nil, headers(action))
+        else
+          ssl_post(url(action, params), post_data(params), headers(action))
+        end
+      end
+
+      def headers(action)
+        hfields = {}
+        hfields["Public-Merchant-Id"] = @options[:public_merchant_id] if action == "tokenize"
+        hfields["Private-Merchant-Id"] = @options[:private_merchant_id] unless action == "tokenize"
+        hfields["Content-Type"] = "application/json"
+        hfields
+      end
+
+      def post_data(params)
+        params.to_json
+      end
+
+      def url(action, params)
+        base_url = test? ? test_url : live_url
+
+        if ["void", "refund"].include?(action)
+          base_url + ENDPOINT[action] + "/" + params[:ticketNumber].to_s
+        else
+          base_url + ENDPOINT[action]
+        end
+      end
+
+      def parse(body)
+        begin
+          JSON.parse(body)
+        rescue JSON::ParserError
+          message = "Invalid JSON response received from KushkiGateway. Please contact KushkiGateway if you continue to receive this message."
+          message += " (The raw response returned by the API was #{body.inspect})"
+          {
+            "message" => message
+          }
+        end
+      end
+
+      def success_from(response)
+        return true if response["token"] || response["ticketNumber"] || response["code"] == "K000"
+      end
+
+      def message_from(succeeded, response)
+        if succeeded
+          "Succeeded"
+        else
+          response["message"]
+        end
+      end
+
+      def authorization_from(response)
+        response["token"] || response["ticketNumber"]
+      end
+
+      def error_from(response)
+        response["code"]
+      end
+    end
+  end
+end

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
@@ -166,6 +168,8 @@ module ActiveMerchant #:nodoc:
       # :comments               Uh... comments
       #
       def recurring(money, creditcard, options={})
+        ActiveMerchant.deprecated RECURRING_DEPRECATION_MESSAGE
+
         requires!(options, [:periodicity, :bimonthly, :monthly, :biweekly, :weekly, :yearly, :daily], :installments, :order_id )
 
         options.update(
@@ -239,10 +243,21 @@ module ActiveMerchant #:nodoc:
       end
 
       def credit(money, identification, options = {})
-        deprecated CREDIT_DEPRECATION_MESSAGE
+        ActiveMerchant.deprecated CREDIT_DEPRECATION_MESSAGE
         refund(money, identification, options)
       end
 
+      def supports_scrubbing
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )\w+), '\1[FILTERED]').
+          gsub(%r((<cardnumber>)\d+(</cardnumber>))i, '\1[FILTERED]\2').
+          gsub(%r((<cvmvalue>)\d+(</cvmvalue>))i, '\1[FILTERED]\2')
+      end
+
       private
       # Commit the transaction by posting the XML file to the LinkPoint server
       def commit(money, creditcard, options = {})
@@ -277,7 +292,7 @@ module ActiveMerchant #:nodoc:
           if key == :items
             build_items(elem, value)
           else
-            for k, v in params[key]
+            for k, _ in params[key]
               elem.add_element(k.to_s).text = params[key][k].to_s if params[key][k]
             end
           end
@@ -428,17 +443,6 @@ module ActiveMerchant #:nodoc:
         response
       end
 
-      # Make a ruby type out of the response string
-      def normalize(field)
-        case field
-        when "true"   then true
-        when "false"  then false
-        when ""       then nil
-        when "null"   then nil
-        else field
-        end
-      end
-
       def format_creditcard_expiry_year(year)
         sprintf("%.4i", year)[-2..-1]
       end