activemerchant 1.42.6 → 1.90.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,57 +23,64 @@ 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
-        else
-          AVSResult.new(options[:avs_result]).to_hash
+                        options[:avs_result].to_hash
+                      else
+                        AVSResult.new(options[:avs_result]).to_hash
         end
 
         @cvv_result = if options[:cvv_result].kind_of?(CVVResult)
-          options[:cvv_result].to_hash
-        else
-          CVVResult.new(options[:cvv_result]).to_hash
+                        options[:cvv_result].to_hash
+                      else
+                        CVVResult.new(options[:cvv_result]).to_hash
         end
       end
     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)
         if response.is_a?(MultiResponse)
-          response.responses.each{|r| @responses << r}
+          response.responses.each { |r| @responses << r }
         else
           @responses << response
         end
       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,195 @@
+require 'uri'
+require 'net/http'
+require 'net/https'
+require 'benchmark'
+
+module ActiveMerchant
+  class Connection
+    using NetHttpSslConnection
+    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
+    MIN_VERSION = :TLS1_1
+    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
+    if Net::HTTP.instance_methods.include?(:min_version=)
+      attr_accessor :min_version
+      attr_accessor :max_version
+    end
+    attr_reader :ssl_connection
+    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
+      if Net::HTTP.instance_methods.include?(:min_version=)
+        @min_version = MIN_VERSION
+        @max_version = nil
+      end
+      @ssl_connection = {}
+      @proxy_address = :ENV
+      @proxy_port = nil
+    end
+
+    def wiredump_device=(device)
+      raise ArgumentError, "can't wiredump to frozen #{device.class}" if device&.frozen?
+      @wiredump_device = device
+    end
+
+    def request(method, body, headers = {})
+      request_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      headers = headers.dup
+      headers['connection'] ||= 'close'
+
+      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
+            http.start unless http.started?
+            @ssl_connection = http.ssl_connection
+            info "connection_ssl_version=#{ssl_connection[:version]} connection_ssl_cipher=#{ssl_connection[:cipher]}", tag
+
+            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.
+              if body
+                debug body
+                req = Net::HTTP::Delete.new(endpoint.request_uri, headers)
+                req.body = body
+                http.request(req)
+              else
+                http.delete(endpoint.request_uri, headers)
+              end
+            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
+      http.finish if http.started?
+    end
+
+    private
+
+    def http
+      @http ||= begin
+        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
+    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 http.respond_to?(:min_version=)
+        http.min_version = min_version if min_version
+        http.max_version = max_version if max_version
+      end
+
+      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 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)
+    end
+  end
+end