start_activemerchant 1.50.0

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

@@ -0,0 +1,216 @@
+require 'rubygems'
+require 'nokogiri'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class CheckoutGateway < Gateway
+      self.default_currency = 'USD'
+      self.money_format = :decimals
+
+      self.supported_countries = ['AT', 'BE', 'BG', 'CY', 'CZ', 'DE', 'DK', 'EE', 'ES', 'FI', 'FR', 'GR', 'HR', 'HU', 'IE', 'IS', 'IT', 'LI', 'LT', 'LU', 'LV', 'MT', 'MU', 'NL', 'NO', 'PL', 'PT', 'RO', 'SE', 'SI', 'SK', 'US']
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club]
+
+      self.homepage_url = 'https://www.checkout.com/'
+      self.display_name = 'Checkout.com'
+
+      self.live_url = 'https://api.checkout.com/Process/gateway.aspx'
+
+      ACTIONS = {
+        'purchase' => '1',
+        'authorize' => '4',
+        'capture' => '5',
+        'refund' => '2',
+        'void_purchase' => '3',
+        'void_authorize' => '9',
+        'void_capture' => '7'
+      }
+
+      def initialize(options = {})
+        requires!(options, :merchant_id, :password)
+        super
+      end
+
+      def purchase(amount, payment_method, options)
+        requires!(options, :order_id)
+
+        commit('purchase', amount, options) do |xml|
+          add_credentials(xml, options)
+          add_invoice(xml, amount, options)
+          add_track_id(xml, options[:order_id])
+          add_payment_method(xml, payment_method)
+          add_billing_info(xml, options)
+          add_shipping_info(xml, options)
+          add_user_defined_fields(xml, options)
+          add_other_fields(xml, options)
+        end
+      end
+
+      def authorize(amount, payment_method, options)
+        requires!(options, :order_id)
+
+        commit('authorize', amount, options) do |xml|
+          add_credentials(xml, options)
+          add_invoice(xml, amount, options)
+          add_track_id(xml, options[:order_id])
+          add_payment_method(xml, payment_method)
+          add_billing_info(xml, options)
+          add_shipping_info(xml, options)
+          add_user_defined_fields(xml, options)
+          add_other_fields(xml, options)
+        end
+      end
+
+      def capture(amount, authorization, options = {})
+        commit('capture', amount, options) do |xml|
+          add_credentials(xml, options)
+          add_reference(xml, authorization)
+          add_invoice(xml, amount, options)
+          add_user_defined_fields(xml, options)
+          add_other_fields(xml, options)
+        end
+      end
+
+      def void(authorization, options = {})
+        _, _, orig_action, amount, currency = split_authorization(authorization)
+        commit("void_#{orig_action}") do |xml|
+          add_credentials(xml, options)
+          add_invoice(xml, amount.to_i, options.merge(currency: currency))
+          add_reference(xml, authorization)
+        end
+      end
+
+      def refund(amount, authorization, options = {})
+        commit('refund') do |xml|
+          add_credentials(xml, options)
+          add_invoice(xml, amount.to_i, options)
+          add_reference(xml, authorization)
+        end
+      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
+
+      private
+
+      def add_credentials(xml, options)
+        xml.merchantid_ @options[:merchant_id]
+        xml.password_ @options[:password]
+      end
+
+      def add_invoice(xml, amount, options)
+        xml.bill_amount_ amount(amount)
+        xml.bill_currencycode_ options[:currency] || currency(amount)
+      end
+
+      def add_payment_method(xml, payment_method)
+        xml.bill_cardholder_ payment_method.name
+        xml.bill_cc_ payment_method.number
+        xml.bill_expmonth_ format(payment_method.month, :two_digits)
+        xml.bill_expyear_ format(payment_method.year, :four_digits)
+        if payment_method.verification_value?
+          xml.bill_cvv2_ payment_method.verification_value
+        end
+      end
+
+      def add_billing_info(xml, options)
+        if options[:billing_address]
+          xml.bill_address_ options[:billing_address][:address1]
+          xml.bill_city_    options[:billing_address][:city]
+          xml.bill_state_   options[:billing_address][:state]
+          xml.bill_postal_  options[:billing_address][:zip]
+          xml.bill_country_ options[:billing_address][:country]
+          xml.bill_phone_   options[:billing_address][:phone]
+        end
+      end
+
+      def add_shipping_info(xml, options)
+        if options[:shipping_address]
+          xml.ship_address_   options[:shipping_address][:address1]
+          xml.ship_address2_  options[:shipping_address][:address2]
+          xml.ship_city_    options[:shipping_address][:city]
+          xml.ship_state_   options[:shipping_address][:state]
+          xml.ship_postal_  options[:shipping_address][:zip]
+          xml.ship_country_   options[:shipping_address][:country]
+          xml.ship_phone_   options[:shipping_address][:phone]
+        end
+      end
+
+      def add_user_defined_fields(xml, options)
+        xml.udf1_ options[:udf1]
+        xml.udf2_ options[:udf2]
+        xml.udf3_ options[:udf3]
+        xml.udf4_ options[:udf4]
+        xml.udf5_ options[:udf5]
+      end
+
+      def add_other_fields(xml, options)
+        xml.bill_email_   options[:email]
+        xml.bill_customerip_ options[:ip]
+        xml.merchantcustomerid_ options[:customer]
+      end
+
+      def add_reference(xml, authorization)
+        transid, trackid, _, _, _ = split_authorization(authorization)
+        xml.transid transid
+        add_track_id(xml, trackid)
+      end
+
+      def add_track_id(xml, trackid)
+        xml.trackid(trackid) if trackid
+      end
+
+      def commit(action, amount=nil, options={}, &builder)
+        response = parse_xml(ssl_post(live_url, build_xml(action, &builder)))
+        Response.new(
+          (response[:responsecode] == "0"),
+          (response[:result] || response[:error_text] || "Unknown Response"),
+          response,
+          authorization: authorization_from(response, action, amount, options),
+          test: test?
+        )
+      end
+
+      def build_xml(action)
+        Nokogiri::XML::Builder.new do |xml|
+          xml.request do
+            xml.action_ ACTIONS[action]
+            yield xml
+          end
+        end.to_xml
+      end
+
+      def parse_xml(xml)
+        response = {}
+
+        Nokogiri::XML(CGI.unescapeHTML(xml)).xpath("//response").children.each do |node|
+          if node.text?
+            next
+          elsif (node.elements.size == 0)
+            response[node.name.downcase.to_sym] = node.text
+          else
+            node.elements.each do |childnode|
+              name = "#{node.name.downcase}_#{childnode.name.downcase}"
+              response[name.to_sym] = childnode.text
+            end
+          end
+        end
+
+        response
+      end
+
+      def authorization_from(response, action,  amount, options)
+        currency = options[:currency] || currency(amount)
+        [response[:tranid], response[:trackid], action, amount, currency].join("|")
+      end
+
+      def split_authorization(authorization)
+        transid, trackid, action, amount, currency = authorization.split("|")
+        [transid, trackid, action, amount, currency]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,200 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class CheckoutV2Gateway < Gateway
+      self.display_name = "Checkout.com V2 Gateway"
+      self.homepage_url = "https://www.checkout.com/"
+      self.test_url = "https://api2.checkout.com/v2"
+      self.live_url = "http://sandbox.checkout.com/api2/v2"
+
+      self.supported_countries = ['AT', 'BE', 'BG', 'CY', 'CZ', 'DE', 'DK', 'EE', 'ES', 'FI', 'FR', 'GR', 'HR', 'HU', 'IE', 'IS', 'IT', 'LI', 'LT', 'LU', 'LV', 'MT', 'MU', 'NL', 'NO', 'PL', 'PT', 'RO', 'SE', 'SI', 'SK', 'US']
+      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={})
+        MultiResponse.run do |r|
+          r.process { authorize(amount, payment_method, options) }
+          r.process { capture(amount, r.authorization, options) }
+        end
+      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] = amount(money)
+        post[:trackId] = options[:order_id]
+        post[:currency] = options[:currency] || currency(money)
+      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"
+        address = options[:billing_address]
+        if(address && post[:card])
+          post[:card][:billingDetails] = {}
+          post[:card][:billingDetails][:address1] = address[:address1]
+          post[:card][:billingDetails][:address2] = 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] }
+        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.new(
+          succeeded,
+          message_from(succeeded, response),
+          response,
+          authorization: authorization_from(response),
+          error_code: error_code_from(succeeded, response),
+          test: test?,
+          avs_result: avs_result(action, response),
+          cvv_result: cvv_result(action, response))
+      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(action, response)
+        action == :purchase ? AVSResult.new(code: response["card"]["avsCheck"]) : nil
+      end
+
+      def cvv_result(action, response)
+        action == :purchase ? 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" || "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)
+        succeeded ? nil : STANDARD_ERROR_CODE_MAPPING[response["responseCode"]]
+      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