gonow-activemerchant 1.15.0

data/lib/active_merchant/billing.rb

@@ -0,0 +1,9 @@
+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/response'
+require 'active_merchant/billing/gateways'

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 W Z ),
+        'X' => %w( G S ),
+        nil => %w( E F I P 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,178 @@
+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
+
+      alias_method :brand, :type
+      
+      # 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.present?
+      end
+
+      def last_name?
+        @last_name.present?
+      end
+
+      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
+
+      # 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:
+        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