start_activemerchant 1.50.0

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

@@ -0,0 +1,181 @@
+require "nokogiri"
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class WorldpayUsGateway < Gateway
+      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.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', post)
+      end
+
+      def authorize(money, payment, options={})
+        post = {}
+        add_invoice(post, money, options)
+        add_payment_method(post, payment)
+        add_customer_data(post, options)
+
+        commit('authorize', post)
+      end
+
+      def capture(amount, authorization, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_reference(post, authorization)
+        add_customer_data(post, options)
+
+        commit('capture', post)
+      end
+
+      def refund(amount, authorization, options={})
+        post = {}
+        add_invoice(post, amount, options)
+        add_reference(post, authorization)
+        add_customer_data(post, options)
+
+        commit("refund", post)
+      end
+
+      def void(authorization, options={})
+        post = {}
+        add_reference(post, authorization)
+
+        commit('void', 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
+
+      private
+
+      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)
+        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
+
+      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, post)
+        post[:action] = ACTIONS[action] if ACTIONS[action]
+        post[:acctid] = @options[:acctid]
+        post[:subid] = @options[:subid]
+        post[:merchantpin] = @options[:merchantpin]
+
+        post[:authonly] = '1' if action == 'authorize'
+
+        raw = parse(ssl_post(live_url, post.to_query))
+
+        succeeded = success_from(raw['transresult'])
+        Response.new(
+          succeeded,
+          message_from(succeeded, raw),
+          raw,
+          :authorization => authorization_from(raw),
+          :test => test?
+        )
+      end
+
+      def success_from(result)
+        result == 'APPROVED'
+      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/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,24 @@
+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
+
+      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

@@ -0,0 +1,92 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class Error < ActiveMerchantError #:nodoc:
+    end
+
+    class Response
+      attr_reader :params, :message, :test, :authorization, :avs_result, :cvv_result, :error_code, :emv_authorization
+
+      def success?
+        @success
+      end
+
+      def test?
+        @test
+      end
+
+      def fraud_review?
+        @fraud_review
+      end
+
+      def initialize(success, message, params = {}, options = {})
+        @success, @message, @params = success, message, params.stringify_keys
+        @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
+        end
+
+        @cvv_result = if options[:cvv_result].kind_of?(CVVResult)
+          options[:cvv_result].to_hash
+        else
+          CVVResult.new(options[:cvv_result]).to_hash
+        end
+      end
+    end
+
+    class MultiResponse < Response
+      def self.run(use_first_response = false, &block)
+        new(use_first_response).tap(&block)
+      end
+
+      attr_reader :responses, :primary_response
+
+      def initialize(use_first_response = false)
+        @responses = []
+        @use_first_response = use_first_response
+        @primary_response = nil
+      end
+
+      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}
+        else
+          @responses << response
+        end
+      end
+
+      def success?
+        (primary_response ? primary_response.success? : true)
+      end
+
+      %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})
+          end
+        )
+      end
+    end
+  end
+end

data/lib/active_merchant/connection.rb

@@ -0,0 +1,172 @@
+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_accessor :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 request(method, body, headers = {})
+      request_start = Time.now.to_f
+
+      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" % [Time.now.to_f - 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