activemerchant-est 1.4.2.5

data/init.rb

@@ -0,0 +1,3 @@
+require 'active_merchant'
+require 'active_merchant/billing/integrations/action_view_helper'
+ActionView::Base.send(:include, ActiveMerchant::Billing::Integrations::ActionViewHelper)

data/lib/active_merchant.rb

@@ -0,0 +1,66 @@
+#--
+# Copyright (c) 2005-2007 Tobias Luetke
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+                    
+$:.unshift File.dirname(__FILE__)
+
+# Include rails' active support for all the core extensions we love
+begin
+  require 'active_support'
+rescue LoadError
+  require 'rubygems'
+  gem 'activesupport', ">=2.0.0"
+  require 'active_support'
+end
+
+begin
+  require 'builder'
+rescue LoadError
+  require 'rubygems'
+  require 'builder'
+end
+
+require 'cgi'
+require 'rexml/document'
+require 'active_merchant/lib/utils'
+require 'active_merchant/lib/error'
+require 'active_merchant/lib/validateable'
+require 'active_merchant/lib/connection'
+require 'active_merchant/lib/posts_data'
+require 'active_merchant/lib/post_data'
+require 'active_merchant/lib/requires_parameters'
+require 'active_merchant/lib/country'
+
+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/base'
+require 'active_merchant/billing/check'
+require 'active_merchant/billing/gateways'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:    
+    autoload :Integrations, 'active_merchant/billing/integrations'    
+  end
+end

data/lib/active_merchant/billing/avs_result.rb

@@ -0,0 +1,98 @@
+#!ruby19
+# encoding: utf-8
+
+module ActiveMerchant
+  module Billing 
+    # Implements the Address Verification System
+    # https://www.wellsfargo.com/downloads/pdf/biz/merchant/visa_avs.pdf
+    # http://en.wikipedia.org/wiki/Address_Verification_System
+    # http://apps.cybersource.com/library/documentation/dev_guides/CC_Svcs_IG/html/app_avs_cvn_codes.htm#app_AVS_CVN_codes_7891_48375
+    # http://imgserver.skipjack.com/imgServer/5293710/AVS%20and%20CVV2.pdf
+    # http://www.emsecommerce.net/avs_cvv2_response_codes.htm
+    class AVSResult
+      MESSAGES = {
+        'A' => 'Street address matches, but 5-digit and 9-digit postal code do not match.',
+        'B' => 'Street address matches, but postal code not verified.',
+        'C' => 'Street address and postal code do not match.',
+        'D' => 'Street address and postal code match.',
+        'E' => 'AVS data is invalid or AVS is not allowed for this card type.',
+        'F' => 'Card member\'s name does not match, but billing postal code matches.',
+        'G' => 'Non-U.S. issuing bank does not support AVS.',
+        'H' => 'Card member\'s name does not match. Street address and postal code match.',
+        'I' => 'Address not verified.',
+        'J' => 'Card member\'s name, billing address, and postal code match. Shipping information verified and chargeback protection guaranteed through the Fraud Protection Program.',
+        'K' => 'Card member\'s name matches but billing address and billing postal code do not match.',
+        'L' => 'Card member\'s name and billing postal code match, but billing address does not match.',
+        'M' => 'Street address and postal code match.',
+        'N' => 'Street address and postal code do not match.',
+        'O' => 'Card member\'s name and billing address match, but billing postal code does not match.',
+        'P' => 'Postal code matches, but street address not verified.',
+        'Q' => 'Card member\'s name, billing address, and postal code match. Shipping information verified but chargeback protection not guaranteed.',
+        'R' => 'System unavailable.',
+        'S' => 'U.S.-issuing bank does not support AVS.',
+        'T' => 'Card member\'s name does not match, but street address matches.',
+        'U' => 'Address information unavailable.',
+        'V' => 'Card member\'s name, billing address, and billing postal code match.',
+        'W' => 'Street address does not match, but 9-digit postal code matches.',
+        'X' => 'Street address and 9-digit postal code match.',
+        'Y' => 'Street address and 5-digit postal code match.',
+        'Z' => 'Street address does not match, but 5-digit postal code matches.'
+      }
+      
+      # Map vendor's AVS result code to a postal match code
+      POSTAL_MATCH_CODE = {
+        'Y' => %w( D H F H J L M P Q V W X Y Z ),
+        'N' => %w( A C K N O ),
+        'X' => %w( G S ),
+        nil => %w( B E I R T U )
+      }.inject({}) do |map, (type, codes)|
+        codes.each { |code| map[code] = type }
+        map
+      end
+      
+      # Map vendor's AVS result code to a street match code
+      STREET_MATCH_CODE = {
+        'Y' => %w( A B D H J M O Q T V X Y ),
+        'N' => %w( C K L N P W Z ),
+        'X' => %w( G S ),
+        nil => %w( E F I R U )
+      }.inject({}) do |map, (type, codes)|
+        codes.each { |code| map[code] = type }
+        map
+      end
+      
+      attr_reader :code, :message, :street_match, :postal_match
+      
+      def self.messages
+        MESSAGES
+      end
+      
+      def initialize(attrs)
+        attrs ||= {}
+        
+        @code = attrs[:code].upcase unless attrs[:code].blank?
+        @message = self.class.messages[code]
+        
+        if attrs[:street_match].blank?
+          @street_match = STREET_MATCH_CODE[code]
+        else  
+          @street_match = attrs[:street_match].upcase
+        end
+          
+        if attrs[:postal_match].blank?
+          @postal_match = POSTAL_MATCH_CODE[code]
+        else  
+          @postal_match = attrs[:postal_match].upcase
+        end
+      end
+    
+      def to_hash
+        { 'code' => code,
+          'message' => message,
+          'street_match' => street_match,
+          'postal_match' => postal_match
+        }
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/base.rb

@@ -0,0 +1,57 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Base
+      # Set ActiveMerchant gateways in test mode.
+      #
+      #   ActiveMerchant::Billing::Base.gateway_mode = :test
+      mattr_accessor :gateway_mode
+      
+      # Set ActiveMerchant integrations in test mode.
+      #
+      #   ActiveMerchant::Billing::Base.integration_mode = :test
+      mattr_accessor :integration_mode
+      
+      # Set both the mode of both the gateways and integrations
+      # at once
+      mattr_reader :mode
+
+      def self.mode=(mode)
+        @@mode = mode
+        self.gateway_mode = mode
+        self.integration_mode = mode
+      end
+
+      self.mode = :production
+                                                                
+      # Return the matching gateway for the provider
+      # * <tt>bogus</tt>: BogusGateway - Does nothing (for testing)
+      # * <tt>moneris</tt>: MonerisGateway
+      # * <tt>authorize_net</tt>: AuthorizeNetGateway
+      # * <tt>trust_commerce</tt>: TrustCommerceGateway
+      # 
+      #   ActiveMerchant::Billing::Base.gateway('moneris').new
+      def self.gateway(name)
+        Billing.const_get("#{name.to_s.downcase}_gateway".camelize)
+      end
+      
+
+      # Return the matching integration module
+      # You can then get the notification from the module
+      # * <tt>bogus</tt>: Bogus - Does nothing (for testing)      
+      # * <tt>chronopay</tt>: Chronopay - Does nothing (for testing)
+      # * <tt>paypal</tt>: Chronopay - Does nothing (for testing)
+      #   
+      #   chronopay = ActiveMerchant::Billing::Base.integration('chronopay')
+      #   notification = chronopay.notification(raw_post)
+      #
+      def self.integration(name)
+        Billing::Integrations.const_get("#{name.to_s.downcase}".camelize)
+      end
+      
+      # A check to see if we're in test mode
+      def self.test?
+        self.gateway_mode == :test
+      end
+    end             
+  end
+end

data/lib/active_merchant/billing/check.rb

@@ -0,0 +1,68 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # The Check object is a plain old Ruby object, similar to CreditCard. It supports validation
+    # of necessary attributes such as checkholder's name, routing and account numbers, but it is
+    # not backed by any database.
+    # 
+    # You may use Check in place of CreditCard with any gateway that supports it. Currently, only
+    # +BrainTreeGateway+ supports the Check object.
+    class Check
+      include Validateable
+      
+      attr_accessor :first_name, :last_name, :routing_number, :account_number, :account_holder_type, :account_type, :number
+      
+      # Used for Canadian bank accounts
+      attr_accessor :institution_number, :transit_number
+      
+      def name
+        @name ||= "#{@first_name} #{@last_name}".strip
+      end
+      
+      def name=(value)
+        return if value.blank?
+
+        @name = value
+        segments = value.split(' ')
+        @last_name = segments.pop
+        @first_name = segments.join(' ')
+      end
+      
+      def validate
+        [:name, :routing_number, :account_number].each do |attr|
+          errors.add(attr, "cannot be empty") if self.send(attr).blank?
+        end
+        
+        errors.add(:routing_number, "is invalid") unless valid_routing_number?
+        
+        errors.add(:account_holder_type, "must be personal or business") if
+            !account_holder_type.blank? && !%w[business personal].include?(account_holder_type.to_s)
+        
+        errors.add(:account_type, "must be checking or savings") if
+            !account_type.blank? && !%w[checking savings].include?(account_type.to_s)
+      end
+      
+      def type
+        'check'
+      end
+      
+      # Routing numbers may be validated by calculating a checksum and dividing it by 10. The
+      # formula is:
+      #   (3(d1 + d4 + d7) + 7(d2 + d5 + d8) + 1(d3 + d6 + d9))mod 10 = 0
+      # See http://en.wikipedia.org/wiki/Routing_transit_number#Internal_checksums
+      def valid_routing_number?
+        d = routing_number.to_s.split('').map(&:to_i).select { |d| (0..9).include?(d) }
+        case d.size
+          when 9 then
+            checksum = ((3 * (d[0] + d[3] + d[6])) +
+                        (7 * (d[1] + d[4] + d[7])) +
+                             (d[2] + d[5] + d[8])) % 10
+            case checksum
+              when 0 then true
+              else        false
+            end
+          else false
+        end
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/credit_card.rb

@@ -0,0 +1,159 @@
+require 'time'
+require 'date'
+require 'active_merchant/billing/expiry_date'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # == Description
+    # This credit card object can be used as a stand alone object. It acts just like an ActiveRecord object
+    # but doesn't support the .save method as its not backed by a database.
+    # 
+    # For testing purposes, use the 'bogus' credit card type. This card skips the vast majority of 
+    # validations. This allows you to focus on your core concerns until you're ready to be more concerned 
+    # with the details of particular creditcards or your gateway.
+    # 
+    # == Testing With CreditCard
+    # Often when testing we don't care about the particulars of a given card type. When using the 'test' 
+    # mode in your Gateway, there are six different valid card numbers: 1, 2, 3, 'success', 'fail', 
+    # and 'error'.
+    # 
+    #--
+    # For details, see CreditCardMethods#valid_number?
+    #++
+    # 
+    # == Example Usage
+    #   cc = CreditCard.new(
+    #     :first_name => 'Steve', 
+    #     :last_name  => 'Smith', 
+    #     :month      => '9', 
+    #     :year       => '2010', 
+    #     :type       => 'visa', 
+    #     :number     => '4242424242424242'
+    #   )
+    #   
+    #   cc.valid? # => true
+    #   cc.display_number # => XXXX-XXXX-XXXX-4242
+    #
+    class CreditCard
+      include CreditCardMethods
+      include Validateable
+      
+      ## Attributes
+      
+      cattr_accessor :require_verification_value
+      self.require_verification_value = true
+      
+      # Essential attributes for a valid, non-bogus creditcards
+      attr_accessor :number, :month, :year, :type, :first_name, :last_name
+      
+      # Required for Switch / Solo cards
+      attr_accessor :start_month, :start_year, :issue_number
+
+      # Optional verification_value (CVV, CVV2 etc). Gateways will try their best to 
+      # run validation on the passed in value if it is supplied
+      attr_accessor :verification_value
+
+      # Provides proxy access to an expiry date object
+      def expiry_date
+        ExpiryDate.new(@month, @year)
+      end
+
+      def expired?
+        expiry_date.expired?
+      end
+      
+      def name?
+        first_name? && last_name?
+      end
+      
+      def first_name?
+        !@first_name.blank?
+      end
+      
+      def last_name?
+        !@last_name.blank?
+      end
+            
+      def name
+        "#{@first_name} #{@last_name}"
+      end
+            
+      def verification_value?
+        !@verification_value.blank?
+      end
+
+      # Show the card number, with all but last 4 numbers replace with "X". (XXXX-XXXX-XXXX-4338)
+      def display_number
+        self.class.mask(number)
+      end
+      
+      def last_digits
+        self.class.last_digits(number)
+      end
+      
+      def validate
+        validate_essential_attributes
+
+        # Bogus card is pretty much for testing purposes. Lets just skip these extra tests if its used
+        return if type == 'bogus'
+
+        validate_card_type
+        validate_card_number
+        validate_verification_value
+        validate_switch_or_solo_attributes
+      end
+      
+      def self.requires_verification_value?
+        require_verification_value
+      end
+      
+      private
+      
+      def before_validate #:nodoc: 
+        self.month = month.to_i
+        self.year  = year.to_i
+        self.start_month = start_month.to_i unless start_month.nil?
+        self.start_year = start_year.to_i unless start_year.nil?
+        self.number = number.to_s.gsub(/[^\d]/, "")
+        self.type.downcase! if type.respond_to?(:downcase)
+        self.type = self.class.type?(number) if type.blank?
+      end
+      
+      def validate_card_number #:nodoc:
+        errors.add :number, "is not a valid credit card number" unless CreditCard.valid_number?(number)
+        unless errors.on(:number) || errors.on(:type)
+          errors.add :type, "is not the correct card type" unless CreditCard.matching_type?(number, type)
+        end
+      end
+      
+      def validate_card_type #:nodoc:
+        errors.add :type, "is required" if type.blank?
+        errors.add :type, "is invalid"  unless CreditCard.card_companies.keys.include?(type)
+      end
+      
+      def validate_essential_attributes #:nodoc:
+        errors.add :first_name, "cannot be empty"      if @first_name.blank?
+        errors.add :last_name,  "cannot be empty"      if @last_name.blank?
+        errors.add :month,      "is not a valid month" unless valid_month?(@month)
+        errors.add :year,       "expired"              if expired?
+        errors.add :year,       "is not a valid year"  unless valid_expiry_year?(@year)
+      end
+      
+      def validate_switch_or_solo_attributes #:nodoc:
+        if %w[switch solo].include?(type)
+          unless valid_month?(@start_month) && valid_start_year?(@start_year) || valid_issue_number?(@issue_number)
+            errors.add :start_month,  "is invalid"      unless valid_month?(@start_month)
+            errors.add :start_year,   "is invalid"      unless valid_start_year?(@start_year)
+            errors.add :issue_number, "cannot be empty" unless valid_issue_number?(@issue_number)
+          end
+        end
+      end
+      
+      def validate_verification_value #:nodoc:
+        if CreditCard.requires_verification_value?
+          errors.add :verification_value, "is required" unless verification_value? 
+        end
+      end
+    end
+  end
+end