projectdx_activemerchant 1.7.1.20100817.1

data/lib/active_merchant/billing/credit_card_methods.rb

@@ -0,0 +1,125 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # Convenience methods that can be included into a custom Credit Card object, such as an ActiveRecord based Credit Card object.
+    module CreditCardMethods
+      CARD_COMPANIES = { 
+        'visa'               => /^4\d{12}(\d{3})?$/,
+        'master'             => /^(5[1-5]\d{4}|677189)\d{10}$/,
+        'discover'           => /^(6011|65\d{2})\d{12}$/,
+        'american_express'   => /^3[47]\d{13}$/,
+        'diners_club'        => /^3(0[0-5]|[68]\d)\d{11}$/,
+        'jcb'                => /^35(28|29|[3-8]\d)\d{12}$/,
+        'switch'             => /^6759\d{12}(\d{2,3})?$/,  
+        'solo'               => /^6767\d{12}(\d{2,3})?$/,
+        'dankort'            => /^5019\d{12}$/,
+        'maestro'            => /^(5[06-8]|6\d)\d{10,17}$/,
+        'forbrugsforeningen' => /^600722\d{10}$/,
+        'laser'              => /^(6304|6706|6771|6709)\d{8}(\d{4}|\d{6,7})?$/
+      }
+    
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      def valid_month?(month)
+        (1..12).include?(month.to_i)
+      end
+      
+      def valid_expiry_year?(year)
+        (Time.now.year..Time.now.year + 20).include?(year.to_i)
+      end
+      
+      def valid_start_year?(year)
+        year.to_s =~ /^\d{4}$/ && year.to_i > 1987
+      end
+      
+      def valid_issue_number?(number)
+        number.to_s =~ /^\d{1,2}$/
+      end
+      
+      module ClassMethods
+        # Returns true if it validates. Optionally, you can pass a card type as an argument and 
+        # make sure it is of the correct type.
+        #
+        # References:
+        # - http://perl.about.com/compute/perl/library/nosearch/P073000.htm
+        # - http://www.beachnet.com/~hstiles/cardtype.html
+        def valid_number?(number)
+          valid_test_mode_card_number?(number) || 
+            valid_card_number_length?(number) && 
+            valid_checksum?(number)
+        end
+        
+        # Regular expressions for the known card companies.
+        # 
+        # References: 
+        # - http://en.wikipedia.org/wiki/Credit_card_number 
+        # - http://www.barclaycardbusiness.co.uk/information_zone/processing/bin_rules.html 
+        def card_companies
+          CARD_COMPANIES
+        end
+        
+        # Returns a string containing the type of card from the list of known information below.
+        # Need to check the cards in a particular order, as there is some overlap of the allowable ranges
+        #--
+        # TODO Refactor this method. We basically need to tighten up the Maestro Regexp. 
+        # 
+        # Right now the Maestro regexp overlaps with the MasterCard regexp (IIRC). If we can tighten 
+        # things up, we can boil this whole thing down to something like... 
+        # 
+        #   def type?(number)
+        #     return 'visa' if valid_test_mode_card_number?(number)
+        #     card_companies.find([nil]) { |type, regexp| number =~ regexp }.first.dup
+        #   end
+        # 
+        def type?(number)
+          return 'bogus' if valid_test_mode_card_number?(number)
+
+          card_companies.reject { |c,p| c == 'maestro' }.each do |company, pattern|
+            return company.dup if number =~ pattern 
+          end
+          
+          return 'maestro' if number =~ card_companies['maestro']
+
+          return nil
+        end
+        
+        def last_digits(number)     
+          number.to_s.length <= 4 ? number : number.to_s.slice(-4..-1) 
+        end
+        
+        def mask(number)
+          "XXXX-XXXX-XXXX-#{last_digits(number)}"
+        end
+        
+        # Checks to see if the calculated type matches the specified type
+        def matching_type?(number, type)
+          type?(number) == type
+        end
+        
+        private
+        
+        def valid_card_number_length?(number) #:nodoc:
+          number.to_s.length >= 12
+        end
+        
+        def valid_test_mode_card_number?(number) #:nodoc:
+          ActiveMerchant::Billing::Base.test? && 
+            %w[1 2 3 success failure error].include?(number.to_s)
+        end
+        
+        # Checks the validity of a card number by use of the the Luhn Algorithm. 
+        # Please see http://en.wikipedia.org/wiki/Luhn_algorithm for details.
+        def valid_checksum?(number) #:nodoc:
+          sum = 0
+          for i in 0..number.length
+            weight = number[-1 * (i + 2), 1].to_i * (2 - (i % 2))
+            sum += (weight < 10) ? weight : weight - 9
+          end
+          
+          (number[-1,1].to_i == (10 - sum % 10) % 10)
+        end
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/cvv_result.rb

@@ -0,0 +1,38 @@
+module ActiveMerchant
+  module Billing
+    # Result of the Card Verification Value check
+    # http://www.bbbonline.org/eExport/doc/MerchantGuide_cvv2.pdf
+    # Check additional codes from cybersource website
+    class CVVResult
+      
+      MESSAGES = {
+        'D'  =>  'Suspicious transaction',
+        'I'  =>  'Failed data validation check',
+        'M'  =>  'Match',
+        'N'  =>  'No Match',
+        'P'  =>  'Not Processed',
+        'S'  =>  'Should have been present',
+        'U'  =>  'Issuer unable to process request',
+        'X'  =>  'Card does not support verification'
+      }
+      
+      def self.messages
+        MESSAGES
+      end
+      
+      attr_reader :code, :message
+      
+      def initialize(code)
+        @code = code.upcase unless code.blank?
+        @message = MESSAGES[@code]
+      end
+      
+      def to_hash
+        {
+          'code' => code,
+          'message' => message
+        }
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/expiry_date.rb

@@ -0,0 +1,34 @@
+require 'date'
+
+module ActiveMerchant
+  module Billing
+    class CreditCard
+      class ExpiryDate #:nodoc:
+        attr_reader :month, :year
+        def initialize(month, year)
+          @month = month.to_i
+          @year = year.to_i
+        end
+        
+        def expired? #:nodoc:
+          Time.now.utc > expiration
+        end
+        
+        def expiration #:nodoc:
+          begin
+            Time.utc(year, month, month_days, 23, 59, 59)
+          rescue ArgumentError
+            Time.at(0).utc
+          end
+        end
+        
+        private
+        def month_days
+          mdays = [nil,31,28,31,30,31,30,31,31,30,31,30,31]
+          mdays[2] = 29 if Date.leap?(year)
+          mdays[month]
+        end
+      end
+    end
+  end
+end

data/lib/active_merchant/billing/gateway.rb

@@ -0,0 +1,163 @@
+require 'net/http'
+require 'net/https'
+require 'active_merchant/billing/response'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # 
+    # == Description
+    # The Gateway class is the base class for all ActiveMerchant gateway implementations. 
+    # 
+    # The standard list of gateway functions that most concrete gateway subclasses implement is:
+    # 
+    # * <tt>purchase(money, creditcard, options = {})</tt>
+    # * <tt>authorize(money, creditcard, options = {})</tt>
+    # * <tt>capture(money, authorization, options = {})</tt>
+    # * <tt>void(identification, options = {})</tt>
+    # * <tt>credit(money, identification, options = {})</tt>
+    #
+    # Some gateways include features for recurring billing
+    #
+    # * <tt>recurring(money, creditcard, options = {})</tt>
+    #
+    # Some gateways also support features for storing credit cards:
+    #
+    # * <tt>store(creditcard, options = {})</tt>
+    # * <tt>unstore(identification, options = {})</tt>
+    # 
+    # === Gateway Options
+    # The options hash consists of the following options:
+    #
+    # * <tt>:order_id</tt> - The order number
+    # * <tt>:ip</tt> - The IP address of the customer making the purchase
+    # * <tt>:customer</tt> - The name, customer number, or other information that identifies the customer
+    # * <tt>:invoice</tt> - The invoice number
+    # * <tt>:merchant</tt> - The name or description of the merchant offering the product
+    # * <tt>:description</tt> - A description of the transaction
+    # * <tt>:email</tt> - The email address of the customer
+    # * <tt>:currency</tt> - The currency of the transaction.  Only important when you are using a currency that is not the default with a gateway that supports multiple currencies.
+    # * <tt>:billing_address</tt> - A hash containing the billing address of the customer.
+    # * <tt>:shipping_address</tt> - A hash containing the shipping address of the customer.
+    # 
+    # The <tt>:billing_address</tt>, and <tt>:shipping_address</tt> hashes can have the following keys:
+    # 
+    # * <tt>:name</tt> - The full name of the customer.
+    # * <tt>:company</tt> - The company name of the customer.
+    # * <tt>:address1</tt> - The primary street address of the customer.
+    # * <tt>:address2</tt> - Additional line of address information.
+    # * <tt>:city</tt> - The city of the customer.
+    # * <tt>:state</tt> - The state of the customer.  The 2 digit code for US and Canadian addresses. The full name of the state or province for foreign addresses.
+    # * <tt>:country</tt> - The [ISO 3166-1-alpha-2 code](http://www.iso.org/iso/country_codes/iso_3166_code_lists/english_country_names_and_code_elements.htm) for the customer.
+    # * <tt>:zip</tt> - The zip or postal code of the customer.
+    # * <tt>:phone</tt> - The phone number of the customer.
+    #
+    # == Implmenting new gateways
+    #
+    # See the {ActiveMerchant Guide to Contributing}[http://code.google.com/p/activemerchant/wiki/Contributing]
+    #
+    class Gateway
+      include PostsData
+      include RequiresParameters
+      include CreditCardFormatting
+      include Utils
+      
+      DEBIT_CARDS = [ :switch, :solo ]
+      
+      cattr_reader :implementations
+      @@implementations = []
+      
+      def self.inherited(subclass)
+        super
+        @@implementations << subclass
+      end
+    
+      # The format of the amounts used by the gateway
+      # :dollars => '12.50'
+      # :cents => '1250'
+      class_inheritable_accessor :money_format
+      self.money_format = :dollars
+      
+      # The default currency for the transactions if no currency is provided
+      class_inheritable_accessor :default_currency
+      
+      # The countries of merchants the gateway supports
+      class_inheritable_accessor :supported_countries
+      self.supported_countries = []
+      
+      # The supported card types for the gateway
+      class_inheritable_accessor :supported_cardtypes
+      self.supported_cardtypes = []
+      
+      class_inheritable_accessor :homepage_url
+      class_inheritable_accessor :display_name
+      
+      # The application making the calls to the gateway
+      # Useful for things like the PayPal build notation (BN) id fields
+      superclass_delegating_accessor :application_id
+      self.application_id = 'ActiveMerchant'
+      
+      attr_reader :options
+      
+      # Use this method to check if your gateway of interest supports a credit card of some type
+      def self.supports?(card_type)
+        supported_cardtypes.include?(card_type.to_sym)
+      end
+      
+      def self.card_brand(source)
+        result = source.respond_to?(:brand) ? source.brand : source.type
+        result.to_s.downcase
+      end
+    
+      def card_brand(source)
+        self.class.card_brand(source)
+      end
+    
+      # Initialize a new gateway.
+      # 
+      # See the documentation for the gateway you will be using to make sure there are no other 
+      # required options.
+      def initialize(options = {})
+      end
+                                     
+      # Are we running in test mode?
+      def test?
+        Base.gateway_mode == :test
+      end
+            
+      private # :nodoc: all
+
+      def name 
+        self.class.name.scan(/\:\:(\w+)Gateway/).flatten.first
+      end
+      
+      def amount(money)
+        return nil if money.nil?
+        cents = if money.respond_to?(:cents)
+          warn "Support for Money objects is deprecated and will be removed from a future release of ActiveMerchant. Please use an Integer value in cents"
+          money.cents
+        else
+          money
+        end
+
+        if money.is_a?(String) or cents.to_i < 0
+          raise ArgumentError, 'money amount must be a positive Integer in cents.' 
+        end
+
+        if self.money_format == :cents
+          cents.to_s
+        else
+          sprintf("%.2f", cents.to_f / 100)
+        end
+      end
+      
+      def currency(money)
+        money.respond_to?(:currency) ? money.currency : self.default_currency
+      end
+      
+      def requires_start_date_or_issue_number?(credit_card)
+        return false if card_brand(credit_card).blank?
+        DEBIT_CARDS.include?(card_brand(credit_card).to_sym)
+      end
+    end
+  end
+end