yetanothernguyen-activemerchant 1.16.0

data/lib/active_merchant/billing/integrations/valitor/return.rb

@@ -0,0 +1,13 @@
+require 'active_merchant/billing/integrations/valitor/response_fields'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module Valitor
+        class Return < ActiveMerchant::Billing::Integrations::Return
+          include ResponseFields
+        end
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/integrations/world_pay.rb

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/world_pay/helper.rb'
+require File.dirname(__FILE__) + '/world_pay/notification.rb'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module WorldPay 
+       
+        # production and test have the same endpoint
+        mattr_accessor :production_url
+        self.production_url = 'https://secure.wp3.rbsworldpay.com/wcc/purchase'
+        
+        def self.service_url
+          production_url
+        end
+
+        def self.notification(post, options = {})
+          Notification.new(post, options)
+        end
+        
+        def self.return(post, options = {})
+          Return.new(post, options)
+        end
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/integrations/world_pay/helper.rb

@@ -0,0 +1,100 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module WorldPay
+        class Helper < ActiveMerchant::Billing::Integrations::Helper
+          mapping :account, 'instId'
+          mapping :amount, 'amount'
+          mapping :order, 'cartId'
+          mapping :currency, 'currency'
+
+          mapping :customer, :email => 'email',
+                             :phone => 'tel'
+
+          mapping :billing_address, :zip => 'postcode',
+                                    :country  => 'country'
+
+          mapping :description, 'desc'
+          mapping :notify_url, 'MC_callback'
+          
+          
+          # WorldPay supports two different test modes - :always_succeed and :always_fail
+          def initialize(order, account, options = {})
+            super
+            
+            if ActiveMerchant::Billing::Base.integration_mode == :test || options[:test]
+              test_mode = case options[:test]
+              when :always_fail
+                101
+              when false
+                0
+              else
+                100
+              end
+              add_field('testMode', test_mode.to_s)
+            elsif ActiveMerchant::Billing::Base.integration_mode == :always_succeed
+              add_field('testMode', '100')
+            elsif ActiveMerchant::Billing::Base.integration_mode == :always_fail
+              add_field('testMode', '101')
+            end
+          end
+          
+          # WorldPay only supports a single address field so we 
+          # have to concat together - lines are separated using &#10;
+          def billing_address(params={})
+            add_field(mappings[:billing_address][:zip], params[:zip])
+            add_field(mappings[:billing_address][:country], lookup_country_code(params[:country]))
+            
+            address = [params[:address1], params[:address2], params[:city], params[:state]].compact
+            add_field('address', address.join('&#10;'))
+          end
+          
+          # WorldPay only supports a single name field so we have to concat
+          def customer(params={})
+            add_field(mappings[:customer][:email], params[:email])
+            add_field(mappings[:customer][:phone], params[:phone])
+            add_field('name', "#{params[:first_name]} #{params[:last_name]}")
+          end
+          
+          # Support for a MD5 hash of selected fields to prevent tampering
+          # For futher information read the tech note at the address below: 
+          # http://support.worldpay.com/kb/integration_guides/junior/integration/help/tech_notes/sjig_tn_009.html
+          def encrypt(secret, fields = [:amount, :currency, :account, :order])
+            signature_fields = fields.collect{ |field| mappings[field] }
+            add_field('signatureFields', signature_fields.join(':'))
+
+            field_values = fields.collect{ |field| form_fields[mappings[field]] }
+            signature    = "#{secret}:#{field_values.join(':')}"            
+            add_field('signature', Digest::MD5.hexdigest(signature))
+          end
+          
+          # Add a time window for which the payment can be completed. Read the link below for how they work
+          # http://support.worldpay.com/kb/integration_guides/junior/integration/help/appendicies/sjig_10100.html
+          def valid_from(from_time)
+            add_field('authValidFrom', from_time.to_i.to_s + '000')
+          end
+          
+          def valid_to(to_time)
+            add_field('authValidTo', to_time.to_i.to_s + '000')
+          end
+          
+          # WorldPay supports the passing of custom parameters prefixed with the following:
+          # C_          : These parameters can be used in the response pages hosted on WorldPay's site
+          # M_          : These parameters are passed through to the callback script (if enabled)
+          # MC_ or CM_  : These parameters are availble both in the response and callback contexts
+          def response_params(params={})
+            params.each{|k,v| add_field("C_#{k}",v)}
+          end
+          
+          def callback_params(params={})
+            params.each{|k,v| add_field("M_#{k}",v)}
+          end
+          
+          def combined_params(params={})
+            params.each{|k,v| add_field("MC_#{k}",v)}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/integrations/world_pay/notification.rb

@@ -0,0 +1,160 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module WorldPay
+        class Notification < ActiveMerchant::Billing::Integrations::Notification
+          def complete?
+            status == 'Completed'
+          end 
+
+          def account
+            params['instId']
+          end
+
+          def item_id
+            params['cartId']
+          end
+
+          def transaction_id
+            params['transId']
+          end
+
+          # Time this payment was received by the client in UTC time.
+          def received_at
+            Time.at(params['transTime'].to_i / 1000).utc
+          end
+
+          # Callback password set in the WorldPay CMS
+          def security_key
+            params['callbackPW']
+          end
+
+          # the money amount we received in X.2 decimal.
+          def gross
+            params['authAmount']
+          end
+          
+          def currency
+            params['authCurrency']
+          end
+
+          # Was this a test transaction?
+          def test?
+            params.key?('testMode') && params['testMode'] != '0'
+          end
+
+          def status
+            params['transStatus'] == 'Y' ? 'Completed' : 'Cancelled'
+          end
+          
+          def name
+            params['name']
+          end
+          
+          def address
+            params['address']
+          end
+          
+          def postcode
+            params['postcode']
+          end
+          
+          def country
+            params['country']
+          end
+          
+          def phone_number
+            params['tel']
+          end
+          
+          def fax_number
+            params['fax']
+          end
+          
+          def email_address
+            params['email']
+          end
+          
+          def card_type
+            params['cardType']
+          end
+          
+          # WorldPay extended fraud checks returned as a 4 character string
+          #   1st char: Credit card CVV check
+          #   2nd char: Postcode AVS check
+          #   3rd char: Address AVS check
+          #   4th char: Country comparison check
+          # Possible values are:
+          #   :not_supported   -  0
+          #   :not_checked     -  1
+          #   :matched         -  2
+          #   :not_matched     -  4
+          #   :partial_match   -  8
+          def cvv_status
+            return avs_value_to_symbol(params['AVS'][0].chr)
+          end
+
+          def postcode_status
+            return avs_value_to_symbol(params['AVS'][1].chr)
+          end
+
+          def address_status
+            return avs_value_to_symbol(params['AVS'][2].chr)
+          end
+
+          def country_status
+            return avs_value_to_symbol(params['AVS'][3].chr)
+          end
+
+          def acknowledge
+            return true
+          end
+          
+          # WorldPay supports the passing of custom parameters through to the callback script
+          def custom_params
+            return @custom_params ||= read_custom_params
+          end
+          
+          
+          private
+
+          # Take the posted data and move the relevant data into a hash
+          def parse(post)
+            @raw = post
+            for line in post.split('&')
+              key, value = *line.scan( %r{^(\w+)\=(.*)$} ).flatten
+              params[key] = value
+            end
+          end
+          
+          # Read the custom params into a hash
+          def read_custom_params
+            custom = {}
+            params.each do |key, value|
+              if /\A(M_|MC_|CM_)/ === key
+                custom[key.gsub(/\A(M_|MC_|CM_)/, '').to_sym] = value
+              end
+            end
+            custom
+          end
+          
+          # Convert a AVS value to a symbol - see above for more about AVS
+          def avs_value_to_symbol(value)
+            case value.to_s
+            when '8'
+              :partial_match
+            when '4'
+              :no_match
+            when '2'
+              :matched
+            when '1'
+              :not_checked
+            else
+              :not_supported
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/response.rb

@@ -0,0 +1,32 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+  
+    class Error < ActiveMerchantError #:nodoc:
+    end
+  
+    class Response
+      attr_reader :params, :message, :test, :authorization, :avs_result, :cvv_result
+      
+      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]
+        @avs_result = AVSResult.new(options[:avs_result]).to_hash
+        @cvv_result = CVVResult.new(options[:cvv_result]).to_hash
+      end
+    end
+  end
+end

data/lib/active_merchant/common.rb

@@ -0,0 +1,14 @@
+module ActiveMerchant  
+  autoload :Connection,                'active_merchant/common/connection'
+  autoload :Country,                   'active_merchant/common/country'
+  autoload :ActiveMerchantError,       'active_merchant/common/error'
+  autoload :ConnectionError,           'active_merchant/common/error'
+  autoload :RetriableConnectionError,  'active_merchant/common/error'
+  autoload :ResponseError,             'active_merchant/common/error'
+  autoload :ClientCertificateError,    'active_merchant/common/error'
+  autoload :PostData,                  'active_merchant/common/post_data'
+  autoload :PostsData,                 'active_merchant/common/posts_data'
+  autoload :RequiresParameters,        'active_merchant/common/requires_parameters'
+  autoload :Utils,                     'active_merchant/common/utils'
+  autoload :Validateable,              'active_merchant/common/validateable'
+end

data/lib/active_merchant/common/connection.rb

@@ -0,0 +1,177 @@
+require 'uri'
+require 'net/http'
+require 'net/https'
+require 'benchmark'
+
+module ActiveMerchant  
+  class ConnectionError < ActiveMerchantError # :nodoc:
+  end
+  
+  class RetriableConnectionError < ConnectionError # :nodoc:
+  end
+  
+  class ResponseError < ActiveMerchantError # :nodoc:
+    attr_reader :response
+
+    def initialize(response, message = nil)
+      @response = response
+      @message  = message
+    end
+
+    def to_s
+      "Failed with #{response.code} #{response.message if response.respond_to?(:message)}"
+    end
+  end
+  
+  class Connection
+    MAX_RETRIES = 3
+    OPEN_TIMEOUT = 60
+    READ_TIMEOUT = 60
+    VERIFY_PEER = true
+    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 :retry_safe
+    attr_accessor :pem
+    attr_accessor :pem_password
+    attr_accessor :wiredump_device
+    attr_accessor :logger
+    attr_accessor :tag
+    attr_accessor :ignore_http_status
+    
+    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
+      @ignore_http_status = false
+    end
+    
+    def request(method, body, headers = {})
+      retry_exceptions do 
+        begin
+          info "#{method.to_s.upcase} #{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))
+            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
+        rescue EOFError => e
+          raise ConnectionError, "The remote server dropped the connection"
+        rescue Errno::ECONNRESET => e
+          raise ConnectionError, "The remote server reset the connection"
+        rescue Errno::ECONNREFUSED => e
+          raise RetriableConnectionError, "The remote server refused the connection"
+        rescue OpenSSL::X509::CertificateError => e
+          raise ClientCertificateError, "The remote server did not accept the provided SSL certificate"
+        rescue Timeout::Error, Errno::ETIMEDOUT => e
+          raise ConnectionError, "The connection to the remote server timed out"
+        end
+      end
+    end
+    
+    private
+    def http
+      http = Net::HTTP.new(endpoint.host, endpoint.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
+      
+      if verify_peer
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        http.ca_file     = File.dirname(__FILE__) + '/../../certs/cacert.pem'
+      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 retry_exceptions
+      retries = MAX_RETRIES
+      begin
+        yield
+      rescue RetriableConnectionError => e
+        retries -= 1
+        retry unless retries.zero?
+        raise ConnectionError, e.message
+      rescue ConnectionError
+        retries -= 1
+        retry if retry_safe && !retries.zero?
+        raise
+      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 log(level, message, tag)
+      message = "[#{tag}] #{message}" if tag
+      logger.send(level, message) if logger
+    end
+  end
+end