activemerchant 1.38.0 → 1.78.0

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

@@ -0,0 +1,226 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class CheckoutV2Gateway < Gateway
+      self.display_name = "Checkout.com V2 Gateway"
+      self.homepage_url = "https://www.checkout.com/"
+      self.live_url = "https://api2.checkout.com/v2"
+      self.test_url = "https://sandbox.checkout.com/api2/v2"
+
+      self.supported_countries = ['AD', 'AE', 'AT', 'BE', 'BG', 'CH', 'CY', 'CZ', 'DE', 'DK', 'EE', 'ES', 'FO', 'FI', 'FR', 'GB', 'GI', 'GL', 'GR', 'HR', 'HU', 'IE', 'IS', 'IL', 'IT', 'LI', 'LT', 'LU', 'LV', 'MC', 'MT', 'NL', 'NO', 'PL', 'PT', 'RO', 'SE', 'SI', 'SM', 'SK', 'SJ', 'TR', 'VA']
+      self.default_currency = "USD"
+      self.money_format = :cents
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club]
+
+      def initialize(options={})
+        requires!(options, :secret_key)
+        super
+      end
+
+      def purchase(amount, payment_method, options={})
+        multi = MultiResponse.run do |r|
+          r.process { authorize(amount, payment_method, options) }
+          r.process { capture(amount, r.authorization, options) }
+        end
+
+        merged_params = multi.responses.map { |r| r.params }.reduce({}, :merge)
+        succeeded = success_from(merged_params)
+
+        response(:purchase, succeeded, merged_params)
+      end
+
+      def authorize(amount, payment_method, options={})
+        post = {}
+        post[:autoCapture] = "n"
+        add_invoice(post, amount, options)
+        add_payment_method(post, payment_method)
+        add_customer_data(post, options)
+
+        commit(:authorize, post)
+      end
+
+      def capture(amount, authorization, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_customer_data(post, options)
+
+        commit(:capture, post, authorization)
+      end
+
+      def void(authorization, options={})
+        post = {}
+        commit(:void, post, authorization)
+      end
+
+      def refund(amount, authorization, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_customer_data(post, options)
+
+        commit(:refund, post, authorization)
+      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((Authorization: )[^\\]*)i, '\1[FILTERED]').
+          gsub(%r(("number\\":\\")\d+), '\1[FILTERED]').
+          gsub(%r(("cvv\\":\\")\d+), '\1[FILTERED]')
+      end
+
+      private
+
+      def add_invoice(post, money, options)
+        post[:value] = localized_amount(money, options[:currency])
+        post[:trackId] = options[:order_id]
+        post[:currency] = options[:currency] || currency(money)
+        post[:descriptor] = {}
+        post[:descriptor][:name] = options[:descriptor_name] if options[:descriptor_name]
+        post[:descriptor][:city] = options[:descriptor_city] if options[:descriptor_city]
+      end
+
+      def add_payment_method(post, payment_method)
+        post[:card] = {}
+        post[:card][:name] = payment_method.name
+        post[:card][:number] = payment_method.number
+        post[:card][:cvv] = payment_method.verification_value
+        post[:card][:expiryYear] = format(payment_method.year, :four_digits)
+        post[:card][:expiryMonth] = format(payment_method.month, :two_digits)
+      end
+
+      def add_customer_data(post, options)
+        post[:email] = options[:email] || "unspecified@example.com"
+        post[:customerIp] = options[:ip] if options[:ip]
+        address = options[:billing_address]
+        if(address && post[:card])
+          post[:card][:billingDetails] = {}
+          post[:card][:billingDetails][:addressLine1] = address[:address1]
+          post[:card][:billingDetails][:addressLine2] = address[:address2]
+          post[:card][:billingDetails][:city] = address[:city]
+          post[:card][:billingDetails][:state] = address[:state]
+          post[:card][:billingDetails][:country] = address[:country]
+          post[:card][:billingDetails][:postcode] = address[:zip]
+          post[:card][:billingDetails][:phone] = { number: address[:phone] } unless address[:phone].blank?
+        end
+      end
+
+      def commit(action, post, authorization = nil)
+        begin
+          raw_response = ssl_post(url(post, action, authorization), post.to_json, headers)
+          response = parse(raw_response)
+        rescue ResponseError => e
+          raise unless(e.response.code.to_s =~ /4\d\d/)
+          response = parse(e.response.body)
+        end
+
+        succeeded = success_from(response)
+
+        response(action, succeeded, response)
+      end
+
+      def response(action, succeeded, response)
+        successful_response = succeeded && action == :purchase || action == :authorize
+        avs_result = successful_response ? avs_result(response) : nil
+        cvv_result = successful_response ? cvv_result(response) : nil
+
+        Response.new(
+          succeeded,
+          message_from(succeeded, response),
+          response,
+          authorization: authorization_from(response),
+          error_code: error_code_from(succeeded, response),
+          test: test?,
+          avs_result: avs_result,
+          cvv_result: cvv_result
+        )
+      end
+
+      def headers
+        {
+          "Authorization" => @options[:secret_key],
+          "Content-Type"  => "application/json;charset=UTF-8"
+        }
+      end
+
+      def url(post, action, authorization)
+        if action == :authorize
+          "#{base_url}/charges/card"
+        else
+          "#{base_url}/charges/#{authorization}/#{action}"
+        end
+      end
+
+      def base_url
+        test? ? test_url : live_url
+      end
+
+      def avs_result(response)
+        response['card'] && response['card']['avsCheck'] ? AVSResult.new(code: response['card']['avsCheck']) : nil
+      end
+
+      def cvv_result(response)
+        response['card'] && response['card']['cvvCheck'] ? CVVResult.new(response['card']['cvvCheck']) : nil
+      end
+
+      def parse(body)
+        JSON.parse(body)
+        rescue JSON::ParserError
+          {
+            "message" => "Invalid JSON response received from CheckoutV2Gateway. Please contact CheckoutV2Gateway if you continue to receive this message.",
+            "raw_response" => scrub(body)
+          }
+      end
+
+      def success_from(response)
+        (response["responseCode"] == "10000" && !response["responseMessage"].start_with?("40")) || response["responseCode"] == "10100"
+      end
+
+      def message_from(succeeded, response)
+        if succeeded
+          "Succeeded"
+        elsif response["errors"]
+          response["message"] + ": " + response["errors"].first
+        else
+          response["responseMessage"] || response["message"] || "Unable to read error message"
+        end
+      end
+
+      STANDARD_ERROR_CODE_MAPPING = {
+        "20014" => STANDARD_ERROR_CODE[:invalid_number],
+        "20100" => STANDARD_ERROR_CODE[:invalid_expiry_date],
+        "20054" => STANDARD_ERROR_CODE[:expired_card],
+        "40104" => STANDARD_ERROR_CODE[:incorrect_cvc],
+        "40108" => STANDARD_ERROR_CODE[:incorrect_zip],
+        "40111" => STANDARD_ERROR_CODE[:incorrect_address],
+        "20005" => STANDARD_ERROR_CODE[:card_declined],
+        "20088" => STANDARD_ERROR_CODE[:processing_error],
+        "20001" => STANDARD_ERROR_CODE[:call_issuer],
+        "30004" => STANDARD_ERROR_CODE[:pickup_card]
+      }
+
+      def authorization_from(raw)
+        raw["id"]
+      end
+
+      def error_code_from(succeeded, response)
+        return if succeeded
+        if response["errorCode"] && response["errorMessageCodes"]
+          "#{response["errorCode"]}: #{response["errorMessageCodes"].join(", ")}"
+        elsif response["errorCode"]
+          response["errorCode"]
+        else
+          STANDARD_ERROR_CODE_MAPPING[response["responseCode"]]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module ActiveMerchant
+  module Billing
+    class CitrusPayGateway < Gateway
+      include MastercardGateway
+
+      class_attribute :live_na_url, :live_ap_url, :test_na_url, :test_ap_url
+
+      self.test_na_url = 'https://test-gateway.mastercard.com/api/rest/version/39/'
+      self.test_ap_url = 'https://test-gateway.mastercard.com/api/rest/version/39/'
+
+      self.live_na_url = 'https://na-gateway.mastercard.com/api/rest/version/39/'
+      self.live_ap_url = 'https://ap-gateway.mastercard.com/api/rest/version/39/'
+
+      self.display_name = 'Citrus Pay'
+      self.homepage_url = 'http://www.citruspay.com/'
+      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]
+
+    end
+  end
+end
+

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

@@ -0,0 +1,222 @@
+require 'openssl'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class ClearhausGateway < Gateway
+      self.test_url = 'https://gateway.test.clearhaus.com'
+      self.live_url = 'https://gateway.clearhaus.com'
+
+      self.supported_countries = ['DK', 'NO', 'SE', 'FI', 'DE', 'CH', 'NL', 'AD', 'AT', 'BE', 'BG', 'HR', 'CY', 'CZ', 'FO', 'GL', 'EE', 'FR', 'GR',
+                                  'HU', 'IS', 'IE', 'IT', 'LV', 'LI', 'LT', 'LU', 'MT', 'PL', 'PT', 'RO', 'SK', 'SI', 'ES', 'GB']
+
+      self.default_currency    = 'EUR'
+      self.currencies_without_fractions = %w(BIF BYR DJF GNF JPY KMF KRW PYG RWF VND VUV XAF XOF XPF)
+      self.supported_cardtypes = [:visa, :master]
+
+      self.homepage_url = 'https://www.clearhaus.com'
+      self.display_name = 'Clearhaus'
+      self.money_format = :cents
+
+      ACTION_CODE_MESSAGES = {
+        20000 => 'Approved',
+        40000 => 'General input error',
+        40110 => 'Invalid card number',
+        40120 => 'Invalid CSC',
+        40130 => 'Invalid expire date',
+        40135 => 'Card expired',
+        40140 => 'Invalid currency',
+        40200 => 'Clearhaus rule violation',
+        40300 => '3-D Secure problem',
+        40310 => '3-D Secure authentication failure',
+        40400 => 'Backend problem',
+        40410 => 'Declined by issuer or card scheme',
+        40411 => 'Card restricted',
+        40412 => 'Card lost or stolen',
+        40413 => 'Insufficient funds',
+        40414 => 'Suspected fraud',
+        40415 => 'Amount limit exceeded',
+        50000 => 'Clearhaus error'
+      }
+
+      def initialize(options={})
+        requires!(options, :api_key)
+        options[:private_key] = options[:private_key].strip if options[:private_key]
+        super
+      end
+
+      def purchase(amount, payment, options={})
+        MultiResponse.run(:use_first_response) do |r|
+          r.process { authorize(amount, payment, options) }
+          r.process { capture(amount, r.authorization, options) }
+        end
+      end
+
+      def authorize(amount, payment, options={})
+        post = {}
+        add_invoice(post, amount, options)
+
+        action = if payment.respond_to?(:number)
+           add_payment(post, payment)
+          "/authorizations"
+        elsif payment.kind_of?(String)
+          "/cards/#{payment}/authorizations"
+        else
+          raise ArgumentError.new("Unknown payment type #{payment.inspect}")
+        end
+
+        post[:recurring] = options[:recurring] if options[:recurring]
+        post[:threed_secure] = {pares: options[:pares]} if options[:pares]
+
+        commit(action, post)
+      end
+
+      def capture(amount, authorization, options={})
+        post = {}
+        add_invoice(post, amount, options)
+
+        commit("/authorizations/#{authorization}/captures", post)
+      end
+
+      def refund(amount, authorization, options={})
+        post = {}
+        add_amount(post, amount, options)
+
+        commit("/authorizations/#{authorization}/refunds", post)
+      end
+
+      def void(authorization, options = {})
+        commit("/authorizations/#{authorization}/voids", options)
+      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 store(credit_card, options={})
+        post = {}
+        add_payment(post, credit_card)
+
+        commit("/cards", post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        transcript.
+          gsub(%r((Authorization: Basic )[\w=]+), '\1[FILTERED]').
+          gsub(%r((&?card(?:\[|%5B)csc(?:\]|%5D)=)[^&]*)i, '\1[FILTERED]').
+          gsub(%r((&?card(?:\[|%5B)number(?:\]|%5D)=)[^&]*)i, '\1[FILTERED]')
+      end
+
+      private
+
+      def add_invoice(post, money, options)
+        add_amount(post, money, options)
+        post[:reference] = options[:order_id] if options[:order_id]
+        post[:text_on_statement] = options[:text_on_statement] if options[:text_on_statement]
+      end
+
+      def add_amount(post, amount, options)
+        post[:amount]   = localized_amount(amount, options[:currency] || default_currency)
+        post[:currency] = (options[:currency] || default_currency)
+      end
+
+      def add_payment(post, payment)
+        card = {}
+        card[:number]       = payment.number
+        card[:expire_month] = '%02d'% payment.month
+        card[:expire_year]  = payment.year
+
+        if payment.verification_value?
+          card[:csc]  = payment.verification_value
+        end
+
+        post[:card] = card if card.any?
+      end
+
+      def headers(api_key)
+        {
+          "Authorization"  => "Basic " + Base64.strict_encode64("#{api_key}:"),
+          "User-Agent"     => "Clearhaus ActiveMerchantBindings/#{ActiveMerchant::VERSION}"
+        }
+      end
+
+      def parse(body)
+        JSON.parse(body) rescue body
+      end
+
+      def commit(action, parameters)
+        url = (test? ? test_url : live_url) + action
+        headers = headers(@options[:api_key])
+        body = parameters.to_query
+
+        if @options[:signing_key] && @options[:private_key]
+          begin
+            headers["Signature"] = generate_signature(body)
+          rescue OpenSSL::PKey::RSAError => e
+            return Response.new(false, e.message)
+          end
+        end
+
+        response = begin
+          parse(ssl_post(url, body, headers))
+        rescue ResponseError => e
+          raise unless(e.response.code.to_s =~ /400/)
+          parse(e.response.body)
+        end
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(action, response),
+          test: test?,
+          error_code: error_code_from(response)
+        )
+      end
+
+      def success_from(response)
+        (response && (response['status']['code'] == 20000))
+      end
+
+      def message_from(response)
+        default_message = ACTION_CODE_MESSAGES[response['status']['code']]
+
+        if success_from(response)
+          default_message
+        else
+          (response['status']['message'] || default_message)
+        end
+      end
+
+      def authorization_from(action, response)
+        id_of_auth_for_capture(action) || response['id']
+      end
+
+      def id_of_auth_for_capture(action)
+        match = action.match(/authorizations\/(.+)\/captures/)
+        return nil unless match
+
+        match.captures.first
+      end
+
+      def generate_signature(body)
+        key = OpenSSL::PKey::RSA.new(@options[:private_key])
+        hex = key.sign(OpenSSL::Digest.new('sha256'), body).unpack('H*').first
+
+        "#{@options[:signing_key]} RS256-hex #{hex}"
+      end
+
+      def error_code_from(response)
+        unless success_from(response)
+          response['status']['code']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class CommercegateGateway < Gateway
+      self.test_url = self.live_url = 'https://secure.commercegate.com/gateway/nvp'
+
+      self.supported_countries = %w(
+        AD AT AX BE BG CH CY CZ DE DK ES FI FR GB GG
+        GI GR HR HU IE IM IS IT JE LI LT LU LV MC MT
+        NL NO PL PT RO SE SI SK VA
+      )
+
+      self.money_format = :dollars
+      self.default_currency = 'EUR'
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
+      self.homepage_url = 'http://www.commercegate.com/'
+      self.display_name = 'CommerceGate'
+
+      def initialize(options = {})
+        requires!(options, :login, :password, :site_id, :offer_id)
+        super
+      end
+
+      def authorize(money, creditcard, options = {})
+        post = {}
+        add_creditcard(post, creditcard)
+        add_auth_purchase_options(post, money, options)
+        commit('AUTH', post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {}
+        post[:currencyCode] = (options[:currency] || currency(money))
+        post[:amount] = amount(money)
+        post[:transID] = authorization
+        commit('CAPTURE', post)
+      end
+
+      def purchase(money, creditcard, options = {})
+        post = {}
+        add_creditcard(post, creditcard)
+        add_auth_purchase_options(post, money, options)
+        commit('SALE', post)
+      end
+
+      def refund(money, identification, options = {})
+        post = {}
+        post[:currencyCode] = options[:currency] || currency(money)
+        post[:amount] = amount(money)
+        post[:transID] = identification
+        commit('REFUND', post)
+      end
+
+      def void(identification, options = {})
+        post = {}
+        post[:transID] = identification
+        commit('VOID_AUTH', post)
+      end
+
+      private
+
+      def add_address(post, address)
+        if address
+          post[:address]     = address[:address1]
+          post[:city]        = address[:city]
+          post[:state]       = address[:state]
+          post[:postalCode]  = address[:zip]
+        end
+        post[:countryCode] = ((address && address[:country]) || "US")
+      end
+
+      def add_auth_purchase_options(post, money, options)
+        add_address(post, options[:address])
+
+        post[:customerIP]  = options[:ip] || "127.0.0.1"
+        post[:amount]      = amount(money)
+        post[:email]       = options[:email] || "unknown@example.com"
+        post[:currencyCode]= options[:currency] || currency(money)
+        post[:merchAcct]   = options[:merchant]
+
+      end
+
+      def add_creditcard(params, creditcard)
+        params[:firstName]   = creditcard.first_name
+        params[:lastName]    = creditcard.last_name
+        params[:cardNumber]  = creditcard.number
+        params[:expiryMonth] = creditcard.month
+        params[:expiryYear]  = creditcard.year
+        params[:cvv]         = creditcard.verification_value if creditcard.verification_value?
+      end
+
+      def commit(action, parameters)
+        parameters[:apiUsername] = @options[:login]
+        parameters[:apiPassword] = @options[:password]
+        parameters[:siteID]      = @options[:site_id]
+        parameters[:offerID]     = @options[:offer_id]
+        parameters[:action]      = action
+
+        response = parse(ssl_post(self.live_url, post_data(parameters)))
+
+        Response.new(
+          successful?(response),
+          message_from(response),
+          response,
+          authorization: response['transID'],
+          test: test?,
+          avs_result: {code: response['avsCode']},
+          cvv_result: response['cvvCode']
+        )
+      end
+
+      def parse(body)
+        results = {}
+
+        body.split(/\&/).each do |pair|
+          key,val = pair.split(%r{=})
+          results[key] = CGI.unescape(val)
+        end
+
+        results
+      end
+
+      def successful?(response)
+        response['returnCode'] == '0'
+      end
+
+      def message_from(response)
+        if response['returnText'].present?
+          response['returnText']
+        else
+          "Invalid response received from the CommerceGate API. " +
+          "Please contact CommerceGate support if you continue to receive this message. " +
+          "(The raw response returned by the API was #{response.inspect})"
+        end
+      end
+
+      def post_data(parameters)
+        parameters.collect do |key, value|
+          "#{key}=#{CGI.escape(value.to_s)}"
+        end.join("&")
+      end
+    end
+  end
+end