vibedeck-activemerchant 1.18.2

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,260 @@
+require 'time'
+require 'date'
+require 'active_merchant/billing/expiry_date'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    # A +CreditCard+ object represents a physical credit card, and is capable of validating the various
+    # data associated with these.
+    #
+    # At the moment, the following credit card types are supported:
+    #
+    # * Visa
+    # * MasterCard
+    # * Discover
+    # * American Express
+    # * Diner's Club
+    # * JCB
+    # * Switch
+    # * Solo
+    # * Dankort
+    # * Maestro
+    # * Forbrugsforeningen
+    # * Laser
+    #
+    # For testing purposes, use the 'bogus' credit card type. This skips the vast majority of
+    # validations, allowing you to focus on your core concerns until you're ready to be more concerned
+    # with the details of particular credit cards 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::ClassMethods#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
+
+      cattr_accessor :require_verification_value
+      self.require_verification_value = true
+
+      # Returns or sets the credit card number.
+      #
+      # @return [String]
+      attr_accessor :number
+
+      # Returns or sets the expiry month for the card.
+      #
+      # @return [Integer]
+      attr_accessor :month
+
+      # Returns or sets the expiry year for the card.
+      #
+      # @return [Integer]
+      attr_accessor :year
+
+      # Returns or sets the credit card type.
+      #
+      # Valid card types are
+      #
+      # * +'visa'+
+      # * +'master'+
+      # * +'discover'+
+      # * +'american_express'+
+      # * +'diners_club'+
+      # * +'jcb'+
+      # * +'switch'+
+      # * +'solo'+
+      # * +'dankort'+
+      # * +'maestro'+
+      # * +'forbrugsforeningen'+
+      # * +'laser'+
+      #
+      # Or, if you wish to test your implementation, +'bogus'+.
+      #
+      # @return (String) the credit card type
+      attr_accessor :type
+
+      # Returns or sets the first name of the card holder.
+      #
+      # @return [String]
+      attr_accessor :first_name
+
+      # Returns or sets the last name of the card holder.
+      #
+      # @return [String]
+      attr_accessor :last_name
+
+      # Required for Switch / Solo cards
+      attr_accessor :start_month, :start_year, :issue_number
+
+      # Returns or sets the card verification value.
+      #
+      # This attribute is optional but recommended. The verification value is
+      # a {card security code}[http://en.wikipedia.org/wiki/Card_security_code]. If provided,
+      # the gateway will attempt to validate the value.
+      #
+      # @return [String] the verification value
+      attr_accessor :verification_value
+
+      alias_method :brand, :type
+
+      # Provides proxy access to an expiry date object
+      #
+      # @return [ExpiryDate]
+      def expiry_date
+        ExpiryDate.new(@month, @year)
+      end
+
+      # Returns whether the credit card has expired.
+      #
+      # @return +true+ if the card has expired, +false+ otherwise
+      def expired?
+        expiry_date.expired?
+      end
+
+      # Returns whether either the +first_name+ or the +last_name+ attributes has been set.
+      def name?
+        first_name? || last_name?
+      end
+
+      # Returns whether the +first_name+ attribute has been set.
+      def first_name?
+        @first_name.present?
+      end
+
+      # Returns whether the +last_name+ attribute has been set.
+      def last_name?
+        @last_name.present?
+      end
+
+      # Returns the full name of the card holder.
+      #
+      # @return [String] the full name of the card holder
+      def name
+        [@first_name, @last_name].compact.join(' ')
+      end
+
+      def name=(full_name)
+        names = full_name.split
+        self.last_name  = names.pop
+        self.first_name = names.join(" ")
+      end
+
+      def verification_value?
+        !@verification_value.blank?
+      end
+
+      # Returns a display-friendly version of the card number.
+      #
+      # All but the last 4 numbers are replaced with an "X", and hyphens are
+      # inserted in order to improve legibility.
+      #
+      # @example
+      #   credit_card = CreditCard.new(:number => "2132542376824338")
+      #   credit_card.display_number  # "XXXX-XXXX-XXXX-4338"
+      #
+      # @return [String] a display-friendly version of the card number
+      def display_number
+        self.class.mask(number)
+      end
+
+      def last_digits
+        self.class.last_digits(number)
+      end
+
+      # Validates the credit card details.
+      #
+      # Any validation errors are added to the {#errors} attribute.
+      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:
+        if number.blank?
+          errors.add :number, "is required"
+        elsif !CreditCard.valid_number?(number)
+          errors.add :number, "is not a valid credit card number"
+        end
+
+        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? && number.present?
+        errors.add :type, "is invalid"  unless type.blank? || 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?
+
+        if @month.to_i.zero? || @year.to_i.zero?
+          errors.add :month, "is required"  if @month.to_i.zero?
+          errors.add :year,  "is required"  if @year.to_i.zero?
+        else
+          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
+      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

data/lib/active_merchant/billing/credit_card_formatting.rb

@@ -0,0 +1,21 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module CreditCardFormatting
+      
+      # This method is used to format numerical information pertaining to credit cards. 
+      # 
+      #   format(2005, :two_digits)  # => "05"
+      #   format(05,   :four_digits) # => "0005"
+      def format(number, option)
+        return '' if number.blank?
+        
+        case option
+          when :two_digits  ; sprintf("%.2i", number)[-2..-1]
+          when :four_digits ; sprintf("%.4i", number)[-4..-1]
+          else number
+        end
+      end
+      
+    end
+  end
+end

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}|64[4-9]\d)\d{12}|(62\d{14})$/,
+        '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