activemerchant 1.38.0 → 1.78.0

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

@@ -0,0 +1,221 @@
+require "nokogiri"
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class WorldpayUsGateway < Gateway
+      class_attribute :backup_url
+
+      self.display_name = "Worldpay US"
+      self.homepage_url = "http://www.worldpay.com/us"
+
+      # No sandbox, just use test cards.
+      self.live_url   = 'https://trans.worldpay.us/cgi-bin/process.cgi'
+      self.backup_url = 'https://trans.gwtx01.com/cgi-bin/process.cgi'
+
+      self.supported_countries = ['US']
+      self.default_currency = 'USD'
+      self.money_format = :dollars
+      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb]
+
+      def initialize(options={})
+        requires!(options, :acctid, :subid, :merchantpin)
+        super
+      end
+
+      def purchase(money, payment_method, options={})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment_method(post, payment_method)
+        add_customer_data(post, options)
+
+        commit('purchase', options, post)
+      end
+
+      def authorize(money, payment, options={})
+        post = {}
+        add_invoice(post, money, options)
+        add_credit_card(post, payment)
+        add_customer_data(post, options)
+
+        commit('authorize', options, post)
+      end
+
+      def capture(amount, authorization, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_reference(post, authorization)
+        add_customer_data(post, options)
+
+        commit('capture', options, post)
+      end
+
+      def refund(amount, authorization, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_reference(post, authorization)
+        add_customer_data(post, options)
+
+        commit("refund", options, post)
+      end
+
+      def void(authorization, options={})
+        post = {}
+        add_reference(post, authorization)
+
+        commit('void', options, 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((&?merchantpin=)[^&]*)i, '\1[FILTERED]').
+          gsub(%r((&?ccnum=)[^&]*)i, '\1[FILTERED]').
+          gsub(%r((&?ckacct=)[^&]*)i, '\1[FILTERED]').
+          gsub(%r((&?cvv2=)[^&]*)i, '\1[FILTERED]')
+      end
+
+      private
+
+      def url(options)
+        options[:use_backup_url].to_s == "true" ? self.backup_url : self.live_url
+      end
+
+      def add_customer_data(post, options)
+        if(billing_address = (options[:billing_address] || options[:address]))
+          post[:ci_companyname] = billing_address[:company]
+          post[:ci_billaddr1]   = billing_address[:address1]
+          post[:ci_billaddr2]   = billing_address[:address2]
+          post[:ci_billcity]    = billing_address[:city]
+          post[:ci_billstate]   = billing_address[:state]
+          post[:ci_billzip]     = billing_address[:zip]
+          post[:ci_billcountry] = billing_address[:country]
+
+          post[:ci_phone]       = billing_address[:phone]
+          post[:ci_email]       = billing_address[:email]
+          post[:ci_ipaddress]   = billing_address[:ip]
+        end
+
+        if(shipping_address = options[:shipping_address])
+          post[:ci_shipaddr1] = shipping_address[:address1]
+          post[:ci_shipaddr2] = shipping_address[:address2]
+          post[:ci_shipcity] = shipping_address[:city]
+          post[:ci_shipstate] = shipping_address[:state]
+          post[:ci_shipzip]    = shipping_address[:zip]
+          post[:ci_shipcountry]    = shipping_address[:country]
+        end
+      end
+
+      def add_invoice(post, money, options)
+        post[:amount] = amount(money)
+        post[:currencycode] = (options[:currency] || currency(money))
+        post[:merchantordernumber] = options[:order_id] if options[:order_id]
+      end
+
+      def add_payment_method(post, payment_method)
+        if card_brand(payment_method) == 'check'
+          add_check(post, payment_method)
+        else
+          add_credit_card(post, payment_method)
+        end
+      end
+
+      def add_credit_card(post, payment_method)
+        post[:ccname] = payment_method.name
+        post[:ccnum] = payment_method.number
+        post[:cvv2] = payment_method.verification_value
+        post[:expyear] = format(payment_method.year, :four_digits)
+        post[:expmon] = format(payment_method.month, :two_digits)
+      end
+
+      ACCOUNT_TYPES = {
+        "checking" => "1",
+        "savings" => "2",
+      }
+
+      def add_check(post, payment_method)
+        post[:action] = 'ns_quicksale_check'
+        post[:ckacct] = payment_method.account_number
+        post[:ckaba] = payment_method.routing_number
+        post[:ckno] = payment_method.number
+        post[:ckaccttype] = ACCOUNT_TYPES[payment_method.account_type] if ACCOUNT_TYPES[payment_method.account_type]
+      end
+
+      def split_authorization(authorization)
+        historyid, orderid = authorization.split("|")
+        [historyid, orderid]
+      end
+
+      def add_reference(post, authorization)
+        historyid, orderid = split_authorization(authorization)
+        post[:postonly] = historyid
+        post[:historykeyid] = historyid
+        post[:orderkeyid] = orderid
+      end
+
+      def parse(xml)
+        response = {}
+        doc = Nokogiri::XML(xml)
+        message = doc.xpath("//plaintext")
+        message.text.split(/\r?\n/).each do |line|
+          key, value = line.split(%r{=})
+          response[key] = value if key
+        end
+        response
+      end
+
+      ACTIONS = {
+        "purchase" => "ns_quicksale_cc",
+        "refund" => "ns_credit",
+        "authorize" => "ns_quicksale_cc",
+        "capture" => "ns_quicksale_cc",
+        "void" => "ns_void",
+      }
+
+      def commit(action, options, post)
+        post[:action] = ACTIONS[action] unless post[:action]
+        post[:acctid] = @options[:acctid]
+        post[:subid] = @options[:subid]
+        post[:merchantpin] = @options[:merchantpin]
+
+        post[:authonly] = '1' if action == 'authorize'
+
+        raw = parse(ssl_post(url(options), post.to_query))
+
+        succeeded = success_from(raw['result'])
+        Response.new(
+          succeeded,
+          message_from(succeeded, raw),
+          raw,
+          :authorization => authorization_from(raw),
+          :test => test?
+        )
+      end
+
+      def success_from(result)
+        result == '1'
+      end
+
+      def message_from(succeeded, response)
+        if succeeded
+          "Succeeded"
+        else
+          (response['transresult'] || response['Reason'] || "Unable to read error message")
+        end
+      end
+
+      def authorization_from(response)
+        [response['historyid'], response['orderid']].join("|")
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/gateways.rb

@@ -1,17 +1,14 @@
+require 'pathname'
+
 module ActiveMerchant
   module Billing
-    autoload :Gateway, 'active_merchant/billing/gateway'
-
-    Dir[File.dirname(__FILE__) + '/gateways/**/*.rb'].each do |f|
-      # Get camelized class name
-      filename = File.basename(f, '.rb')
-      # Add _gateway suffix
-      gateway_name = filename + '_gateway'
-      # Camelize the string to get the class name
-      gateway_class = gateway_name.camelize
+    load_path = Pathname.new(__FILE__ + '/../../..')
+    Dir[File.dirname(__FILE__) + '/gateways/**/*.rb'].each do |filename|
+      gateway_name      = File.basename(filename, '.rb')
+      gateway_classname = "#{gateway_name}_gateway".camelize
+      gateway_filename  = Pathname.new(filename).relative_path_from(load_path).sub_ext('')
 
-      # Register for autoloading
-      autoload gateway_class, f
+      autoload(gateway_classname, gateway_filename)
     end
   end
 end

data/lib/active_merchant/billing/model.rb

@@ -0,0 +1,30 @@
+require "active_merchant/billing/compatibility"
+require "active_merchant/empty"
+
+module ActiveMerchant
+  module Billing
+    class Model
+      include Compatibility::Model
+      include Empty
+
+      def initialize(attributes = {})
+        attributes.each do |key, value|
+          send("#{key}=", value)
+        end
+      end
+
+      def validate
+        {}
+      end
+
+      private
+
+      def errors_hash(array)
+        array.inject({}) do |hash, (attribute, error)|
+          (hash[attribute] ||= []) << error
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/network_tokenization_credit_card.rb

@@ -0,0 +1,39 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class NetworkTokenizationCreditCard < CreditCard
+      # A +NetworkTokenizationCreditCard+ object represents a tokenized credit card
+      # using the EMV Network Tokenization specification, http://www.emvco.com/specifications.aspx?id=263.
+      #
+      # It includes all fields of the +CreditCard+ class with additional fields for
+      # verification data that must be given to gateways through existing fields (3DS / EMV).
+      #
+      # The only tested usage of this at the moment is with an Apple Pay decrypted PKPaymentToken,
+      # https://developer.apple.com/library/ios/documentation/PassKit/Reference/PaymentTokenJSON/PaymentTokenJSON.html
+
+      # These are not relevant (verification) or optional (name) for Apple Pay
+      self.require_verification_value = false
+      self.require_name = false
+
+      attr_accessor :payment_cryptogram, :eci, :transaction_id
+      attr_writer :source
+
+      SOURCES = %i(apple_pay android_pay google_pay)
+
+      def source
+        if defined?(@source) && SOURCES.include?(@source)
+          @source
+        else
+          :apple_pay
+        end
+      end
+
+      def credit_card?
+        true
+      end
+
+      def type
+        "network_tokenization"
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/payment_token.rb

@@ -0,0 +1,21 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # Base class representation of cryptographic payment data tokens that may be used for EMV-style transactions
+    # like Apple Pay. Payment data may be transmitted via any data type, and may also be padded
+    # with metadata specific to the cryptographer. This metadata should be parsed and interpreted in concrete
+    # implementations of your given cryptographer. Like credit cards, you must also return a string representing
+    # the token's type, like 'apple_pay' or 'stripe' should your target payment gateway process these tokens.
+    class PaymentToken
+      attr_reader :payment_data
+
+      def initialize(payment_data, options = {})
+        @payment_data = payment_data
+        @metadata = options.with_indifferent_access
+      end
+
+      def type
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/rails.rb

@@ -0,0 +1,3 @@
+require "active_merchant/billing/compatibility"
+
+ActiveMerchant::Billing::Compatibility.rails_required!

data/lib/active_merchant/billing/response.rb

@@ -4,7 +4,7 @@ module ActiveMerchant #:nodoc:
     end
 
     class Response
-      attr_reader :params, :message, :test, :authorization, :avs_result, :cvv_result
+      attr_reader :params, :message, :test, :authorization, :avs_result, :cvv_result, :error_code, :emv_authorization
 
       def success?
         @success
@@ -23,6 +23,8 @@ module ActiveMerchant #:nodoc:
         @test = options[:test] || false
         @authorization = options[:authorization]
         @fraud_review = options[:fraud_review]
+        @error_code = options[:error_code]
+        @emv_authorization = options[:emv_authorization]
 
         @avs_result = if options[:avs_result].kind_of?(AVSResult)
           options[:avs_result].to_hash
@@ -39,22 +41,31 @@ module ActiveMerchant #:nodoc:
     end
 
     class MultiResponse < Response
-      def self.run(primary_response = :last, &block)
-        response = new.tap(&block)
-        response.primary_response = primary_response
-        response
+      def self.run(use_first_response = false, &block)
+        new(use_first_response).tap(&block)
       end
 
-      attr_reader :responses
-      attr_writer :primary_response
+      attr_reader :responses, :primary_response
 
-      def initialize
+      def initialize(use_first_response = false)
         @responses = []
-        @primary_response = :last
+        @use_first_response = use_first_response
+        @primary_response = nil
       end
 
-      def process
-        self << yield if(responses.empty? || success?)
+      def process(ignore_result=false)
+        return unless success?
+
+        response = yield
+        self << response
+
+        unless ignore_result
+          if(@use_first_response && response.success?)
+            @primary_response ||= response
+          else
+            @primary_response = response
+          end
+        end
       end
 
       def <<(response)
@@ -66,14 +77,10 @@ module ActiveMerchant #:nodoc:
       end
 
       def success?
-        @responses.all?{|r| r.success?}
-      end
-
-      def primary_response
-        success? && @primary_response == :first ? @responses.first : @responses.last
+        (primary_response ? primary_response.success? : true)
       end
 
-      %w(params message test authorization avs_result cvv_result test? fraud_review?).each do |m|
+      %w(params message test authorization avs_result cvv_result error_code emv_authorization test? fraud_review?).each do |m|
         class_eval %(
           def #{m}
             (@responses.empty? ? nil : primary_response.#{m})

data/lib/active_merchant/billing.rb

@@ -1,9 +1,15 @@
+require 'active_merchant/errors'
+
 require 'active_merchant/billing/avs_result'
 require 'active_merchant/billing/cvv_result'
 require 'active_merchant/billing/credit_card_methods'
 require 'active_merchant/billing/credit_card_formatting'
 require 'active_merchant/billing/credit_card'
+require 'active_merchant/billing/network_tokenization_credit_card'
 require 'active_merchant/billing/base'
 require 'active_merchant/billing/check'
+require 'active_merchant/billing/payment_token'
+require 'active_merchant/billing/apple_pay_payment_token'
 require 'active_merchant/billing/response'
-require 'active_merchant/billing/gateways'
+require 'active_merchant/billing/gateways'
+require 'active_merchant/billing/gateway'

data/lib/active_merchant/connection.rb

@@ -0,0 +1,177 @@
+require 'uri'
+require 'net/http'
+require 'net/https'
+require 'benchmark'
+
+module ActiveMerchant
+  class Connection
+    include NetworkConnectionRetries
+
+    MAX_RETRIES = 3
+    OPEN_TIMEOUT = 60
+    READ_TIMEOUT = 60
+    VERIFY_PEER = true
+    CA_FILE = File.expand_path('../certs/cacert.pem', File.dirname(__FILE__))
+    CA_PATH = nil
+    RETRY_SAFE = false
+    RUBY_184_POST_HEADERS = { "Content-Type" => "application/x-www-form-urlencoded" }
+
+    attr_accessor :endpoint
+    attr_accessor :open_timeout
+    attr_accessor :read_timeout
+    attr_accessor :verify_peer
+    attr_accessor :ssl_version
+    attr_accessor :ca_file
+    attr_accessor :ca_path
+    attr_accessor :pem
+    attr_accessor :pem_password
+    attr_reader :wiredump_device
+    attr_accessor :logger
+    attr_accessor :tag
+    attr_accessor :ignore_http_status
+    attr_accessor :max_retries
+    attr_accessor :proxy_address
+    attr_accessor :proxy_port
+
+    def initialize(endpoint)
+      @endpoint     = endpoint.is_a?(URI) ? endpoint : URI.parse(endpoint)
+      @open_timeout = OPEN_TIMEOUT
+      @read_timeout = READ_TIMEOUT
+      @retry_safe   = RETRY_SAFE
+      @verify_peer  = VERIFY_PEER
+      @ca_file      = CA_FILE
+      @ca_path      = CA_PATH
+      @max_retries  = MAX_RETRIES
+      @ignore_http_status = false
+      @ssl_version = nil
+      @proxy_address = nil
+      @proxy_port = nil
+    end
+
+    def wiredump_device=(device)
+      raise ArgumentError, "can't wiredump to frozen #{device.class}" if device && device.frozen?
+      @wiredump_device = device
+    end
+
+    def request(method, body, headers = {})
+      request_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      retry_exceptions(:max_retries => max_retries, :logger => logger, :tag => tag) do
+        begin
+          info "connection_http_method=#{method.to_s.upcase} connection_uri=#{endpoint}", tag
+
+          result = nil
+
+          realtime = Benchmark.realtime do
+            result = case method
+            when :get
+              raise ArgumentError, "GET requests do not support a request body" if body
+              http.get(endpoint.request_uri, headers)
+            when :post
+              debug body
+              http.post(endpoint.request_uri, body, RUBY_184_POST_HEADERS.merge(headers))
+            when :put
+              debug body
+              http.put(endpoint.request_uri, body, headers)
+            when :patch
+              debug body
+              http.patch(endpoint.request_uri, body, headers)
+            when :delete
+              # It's kind of ambiguous whether the RFC allows bodies
+              # for DELETE requests. But Net::HTTP's delete method
+              # very unambiguously does not.
+              raise ArgumentError, "DELETE requests do not support a request body" if body
+              http.delete(endpoint.request_uri, headers)
+            else
+              raise ArgumentError, "Unsupported request method #{method.to_s.upcase}"
+            end
+          end
+
+          info "--> %d %s (%d %.4fs)" % [result.code, result.message, result.body ? result.body.length : 0, realtime], tag
+          debug result.body
+          result
+        end
+      end
+
+    ensure
+      info "connection_request_total_time=%.4fs" % [Process.clock_gettime(Process::CLOCK_MONOTONIC) - request_start], tag
+    end
+
+    private
+    def http
+      http = Net::HTTP.new(endpoint.host, endpoint.port, proxy_address, proxy_port)
+      configure_debugging(http)
+      configure_timeouts(http)
+      configure_ssl(http)
+      configure_cert(http)
+      http
+    end
+
+    def configure_debugging(http)
+      http.set_debug_output(wiredump_device)
+    end
+
+    def configure_timeouts(http)
+      http.open_timeout = open_timeout
+      http.read_timeout = read_timeout
+    end
+
+    def configure_ssl(http)
+      return unless endpoint.scheme == "https"
+
+      http.use_ssl = true
+      http.ssl_version = ssl_version if ssl_version
+
+      if verify_peer
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        http.ca_file     = ca_file
+        http.ca_path     = ca_path
+      else
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+
+    end
+
+    def configure_cert(http)
+      return if pem.blank?
+
+      http.cert = OpenSSL::X509::Certificate.new(pem)
+
+      if pem_password
+        http.key = OpenSSL::PKey::RSA.new(pem, pem_password)
+      else
+        http.key = OpenSSL::PKey::RSA.new(pem)
+      end
+    end
+
+    def handle_response(response)
+      if @ignore_http_status then
+        return response.body
+      else
+        case response.code.to_i
+        when 200...300
+          response.body
+        else
+          raise ResponseError.new(response)
+        end
+      end
+    end
+
+    def debug(message, tag = nil)
+      log(:debug, message, tag)
+    end
+
+    def info(message, tag = nil)
+      log(:info, message, tag)
+    end
+
+    def error(message, tag = nil)
+      log(:error, message, tag)
+    end
+
+    def log(level, message, tag)
+      message = "[#{tag}] #{message}" if tag
+      logger.send(level, message) if logger
+    end
+  end
+end