activemerchant 1.38.0 → 1.79.2

data/lib/active_merchant/billing/credit_card_methods.rb

@@ -2,9 +2,9 @@ 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}$/,
+      CARD_COMPANIES = {
+        'visa'               => /^4\d{12}(\d{3})?(\d{3})?$/,
+        'master'             => /^(5[1-5]\d{4}|677189|222[1-9]\d{2}|22[3-9]\d{3}|2[3-6]\d{4}|27[01]\d{3}|2720\d{2})\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}$/,
@@ -14,128 +14,227 @@ module ActiveMerchant #:nodoc:
         'dankort'            => /^5019\d{12}$/,
         'maestro'            => /^(5[06-8]|6\d)\d{10,17}$/,
         'forbrugsforeningen' => /^600722\d{10}$/,
-        'laser'              => /^(6304|6706|6709|6771(?!89))\d{8}(\d{4}|\d{6,7})?$/
+        'laser'              => /^(6304|6706|6709|6771(?!89))\d{8}(\d{4}|\d{6,7})?$/,
+        'sodexo'             => /^(606071|603389|606070|606069|606068|600818)\d{8}$/,
+        'vr'                 => /^(627416|637036)\d{8}$/
       }
-    
+
+      # http://www.barclaycard.co.uk/business/files/bin_rules.pdf
+      ELECTRON_RANGES = [
+        [400115],
+        (400837..400839),
+        (412921..412923),
+        [417935],
+        (419740..419741),
+        (419773..419775),
+        [424519],
+        (424962..424963),
+        [437860],
+        [444000],
+        [459472],
+        (484406..484411),
+        (484413..484414),
+        (484418..484418),
+        (484428..484455),
+        (491730..491759),
+      ]
+
       def self.included(base)
         base.extend(ClassMethods)
       end
-      
+
       def valid_month?(month)
         (1..12).include?(month.to_i)
       end
-      
+
+      def credit_card?
+        true
+      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
+        ((year.to_s =~ /^\d{4}$/) && (year.to_i > 1987))
+      end
+
+      # Credit card providers have 3 digit verification values
+      # This isn't standardised, these are called various names such as
+      # CVC, CVV, CID, CSC and more
+      # See: http://en.wikipedia.org/wiki/Card_security_code
+      # American Express is the exception with 4 digits
+      #
+      # Below are links from the card providers with their requirements
+      # visa:             http://usa.visa.com/personal/security/3-digit-security-code.jsp
+      # master:           http://www.mastercard.com/ca/merchant/en/getstarted/Anatomy_MasterCard.html
+      # jcb:              http://www.jcbcard.com/security/info.html
+      # diners_club:      http://www.dinersclub.com/assets/DinersClub_card_ID_features.pdf
+      # discover:         https://www.discover.com/credit-cards/help-center/glossary.html
+      # american_express: https://online.americanexpress.com/myca/fuidfyp/us/action?request_type=un_fuid&Face=en_US
+      def valid_card_verification_value?(cvv, brand)
+        cvv.to_s =~ /^\d{#{card_verification_value_length(brand)}}$/
+      end
+
+      def card_verification_value_length(brand)
+        brand == 'american_express' ? 4 : 3
       end
-      
+
       def valid_issue_number?(number)
-        number.to_s =~ /^\d{1,2}$/
+        (number.to_s =~ /^\d{1,2}$/)
+      end
+
+      # Returns if the card matches known Electron BINs
+      def electron?
+        self.class.electron?(number)
       end
-      
+
       module ClassMethods
-        # Returns true if it validates. Optionally, you can pass a card brand as an argument and 
+        # Returns true if it validates. Optionally, you can pass a card brand as an argument and
         # make sure it is of the correct brand.
         #
         # 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_test_mode_card_number?(number) ||
+            valid_card_number_length?(number) &&
+            valid_card_number_characters?(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 
+        #
+        # 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 brand 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... 
-        # 
+        # 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 brand?(number)
         #     return 'visa' if valid_test_mode_card_number?(number)
         #     card_companies.find([nil]) { |brand, regexp| number =~ regexp }.first.dup
         #   end
-        # 
+        #
         def brand?(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 
+            return company.dup if number =~ pattern
           end
-          
+
           return 'maestro' if number =~ card_companies['maestro']
 
           return nil
         end
 
+        def electron?(number)
+          return false unless [16, 19].include?(number.length)
+
+          # don't recalculate for each range
+          bank_identification_number = first_digits(number).to_i
+
+          ELECTRON_RANGES.any? do |range|
+            range.include?(bank_identification_number)
+          end
+        end
+
         def type?(number)
-          deprecated "CreditCard#type? is deprecated and will be removed from a future release of ActiveMerchant. Please use CreditCard#brand? instead."
+          ActiveMerchant.deprecated "CreditCard#type? is deprecated and will be removed from a future release of ActiveMerchant. Please use CreditCard#brand? instead."
           brand?(number)
         end
-        
+
         def first_digits(number)
-          number.to_s.slice(0,6) 
+          number.to_s.slice(0,6)
         end
-        
-        def last_digits(number)     
-          number.to_s.length <= 4 ? number : number.to_s.slice(-4..-1) 
+
+        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 brand matches the specified brand
         def matching_brand?(number, brand)
           brand?(number) == brand
         end
 
         def matching_type?(number, brand)
-          deprecated "CreditCard#matching_type? is deprecated and will be removed from a future release of ActiveMerchant. Please use CreditCard#matching_brand? instead."
+          ActiveMerchant.deprecated "CreditCard#matching_type? is deprecated and will be removed from a future release of ActiveMerchant. Please use CreditCard#matching_brand? instead."
           matching_brand?(number, brand)
         end
 
-        def deprecated(message)
-          warn(Kernel.caller[1] + message)
-        end
-        
         private
-        
+
         def valid_card_number_length?(number) #:nodoc:
           number.to_s.length >= 12
         end
-        
+
+        def valid_card_number_characters?(number) #:nodoc:
+          !number.to_s.match(/\D/)
+        end
+
         def valid_test_mode_card_number?(number) #:nodoc:
-          ActiveMerchant::Billing::Base.test? && 
+          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. 
+
+        ODD_LUHN_VALUE = {
+          48 => 0,
+          49 => 1,
+          50 => 2,
+          51 => 3,
+          52 => 4,
+          53 => 5,
+          54 => 6,
+          55 => 7,
+          56 => 8,
+          57 => 9,
+          nil => 0
+        }.freeze
+
+        EVEN_LUHN_VALUE = {
+          48 => 0, # 0 * 2
+          49 => 2, # 1 * 2
+          50 => 4, # 2 * 2
+          51 => 6, # 3 * 2
+          52 => 8, # 4 * 2
+          53 => 1, # 5 * 2 - 9
+          54 => 3, # 6 * 2 - 9
+          55 => 5, # etc ...
+          56 => 7,
+          57 => 9,
+        }.freeze
+
+        # Checks the validity of a card number by use of the Luhn Algorithm.
         # Please see http://en.wikipedia.org/wiki/Luhn_algorithm for details.
-        def valid_checksum?(number) #:nodoc:
+        # This implementation is from the luhn_checksum gem, https://github.com/zendesk/luhn_checksum.
+        def valid_checksum?(numbers) #: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
+
+          odd = true
+          numbers.reverse.bytes.each do |number|
+            if odd
+              odd = false
+              sum += ODD_LUHN_VALUE[number]
+            else
+              odd = true
+              sum += EVEN_LUHN_VALUE[number]
+            end
           end
-          
-          (number[-1,1].to_i == (10 - sum % 10) % 10)
+
+          sum % 10 == 0
         end
       end
     end

data/lib/active_merchant/billing/cvv_result.rb

@@ -4,29 +4,29 @@ module ActiveMerchant
     # 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'
+        'D'  =>  'CVV check flagged transaction as suspicious',
+        'I'  =>  'CVV failed data validation check',
+        'M'  =>  'CVV matches',
+        'N'  =>  'CVV does not match',
+        'P'  =>  'CVV not processed',
+        'S'  =>  'CVV should have been present',
+        'U'  =>  'CVV request unable to be processed by issuer',
+        'X'  =>  'CVV check not supported for card'
       }
-      
+
       def self.messages
         MESSAGES
       end
-      
+
       attr_reader :code, :message
-      
+
       def initialize(code)
-        @code = code.upcase unless code.blank?
+        @code = (code.blank? ? nil : code.upcase)
         @message = MESSAGES[@code]
       end
-      
+
       def to_hash
         {
           'code' => code,
@@ -35,4 +35,4 @@ module ActiveMerchant
       end
     end
   end
-end
+end

data/lib/active_merchant/billing/gateway.rb

@@ -10,19 +10,16 @@ module ActiveMerchant #:nodoc:
     #
     # 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>purchase(money, credit_card, options = {})</tt>
+    # * <tt>authorize(money, credit_card, 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>
+    # * <tt>refund(money, identification, options = {})</tt>
+    # * <tt>verify(credit_card, options = {})</tt>
     #
     # Some gateways also support features for storing credit cards:
     #
-    # * <tt>store(creditcard, options = {})</tt>
+    # * <tt>store(credit_card, options = {})</tt>
     # * <tt>unstore(identification, options = {})</tt>
     #
     # === Gateway Options
@@ -51,19 +48,57 @@ module ActiveMerchant #:nodoc:
     # * <tt>:zip</tt> - The zip or postal code of the customer.
     # * <tt>:phone</tt> - The phone number of the customer.
     #
-    # == Implmenting new gateways
+    # == Implementing new gateways
     #
-    # See the {ActiveMerchant Guide to Contributing}[https://github.com/Shopify/active_merchant/wiki/Contributing]
+    # See the {ActiveMerchant Guide to Contributing}[https://github.com/activemerchant/active_merchant/wiki/Contributing]
     #
     class Gateway
       include PostsData
-      include RequiresParameters
       include CreditCardFormatting
-      include Utils
 
       DEBIT_CARDS = [ :switch, :solo ]
-      CURRENCIES_WITHOUT_FRACTIONS = [ 'JPY', 'HUF', 'TWD' ]
+
       CREDIT_DEPRECATION_MESSAGE = "Support for using credit to refund existing transactions is deprecated and will be removed from a future release of ActiveMerchant. Please use the refund method instead."
+      RECURRING_DEPRECATION_MESSAGE = "Recurring functionality in ActiveMerchant is deprecated and will be removed in a future version. Please contact the ActiveMerchant maintainers if you have an interest in taking ownership of a separate gem that continues support for it."
+
+      # == Standardized Error Codes
+      #
+      # :incorrect_number - Card number does not comply with ISO/IEC 7812 numbering standard
+      # :invalid_number - Card number was not matched by processor
+      # :invalid_expiry_date - Expiry date does not match correct formatting
+      # :invalid_cvc - Security codes does not match correct format (3-4 digits)
+      # :expired_card - Card number is expired
+      # :incorrect_cvc - Security code was not matched by the processor
+      # :incorrect_zip - Zip code is not in correct format
+      # :incorrect_address - Billing address info was not matched by the processor
+      # :incorrect_pin - Card PIN is incorrect
+      # :card_declined - Card number declined by processor
+      # :processing_error - Processor error
+      # :call_issuer - Transaction requires voice authentication, call issuer
+      # :pickup_card - Issuer requests that you pickup the card from merchant
+      # :test_mode_live_card - Card was declined. Request was in test mode, but used a non test card.
+      # :unsupported_feature - Transaction failed due to gateway or merchant
+      #                        configuration not supporting a feature used, such
+      #                        as network tokenization.
+
+      STANDARD_ERROR_CODE = {
+        :incorrect_number => 'incorrect_number',
+        :invalid_number => 'invalid_number',
+        :invalid_expiry_date => 'invalid_expiry_date',
+        :invalid_cvc => 'invalid_cvc',
+        :expired_card => 'expired_card',
+        :incorrect_cvc => 'incorrect_cvc',
+        :incorrect_zip => 'incorrect_zip',
+        :incorrect_address => 'incorrect_address',
+        :incorrect_pin => 'incorrect_pin',
+        :card_declined => 'card_declined',
+        :processing_error => 'processing_error',
+        :call_issuer => 'call_issuer',
+        :pickup_card => 'pick_up_card',
+        :config_error => 'config_error',
+        :test_mode_live_card => 'test_mode_live_card',
+        :unsupported_feature => 'unsupported_feature',
+      }
 
       cattr_reader :implementations
       @@implementations = []
@@ -73,6 +108,10 @@ module ActiveMerchant #:nodoc:
         @@implementations << subclass
       end
 
+      def generate_unique_id
+        SecureRandom.hex(16)
+      end
+
       # The format of the amounts used by the gateway
       # :dollars => '12.50'
       # :cents => '1250'
@@ -82,14 +121,14 @@ module ActiveMerchant #:nodoc:
       # The default currency for the transactions if no currency is provided
       class_attribute :default_currency
 
-      # The countries of merchants the gateway supports
-      class_attribute :supported_countries
-      self.supported_countries = []
-
       # The supported card types for the gateway
       class_attribute :supported_cardtypes
       self.supported_cardtypes = []
 
+      class_attribute :currencies_without_fractions, :currencies_with_three_decimal_places
+      self.currencies_without_fractions = %w(BIF BYR CLP CVE DJF GNF ISK JPY KMF KRW PYG RWF UGX VND VUV XAF XOF XPF)
+      self.currencies_with_three_decimal_places = %w()
+
       class_attribute :homepage_url
       class_attribute :display_name
 
@@ -101,8 +140,8 @@ module ActiveMerchant #:nodoc:
 
       # 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'
+      class_attribute :application_id, instance_writer: false
+      self.application_id = nil
 
       attr_reader :options
 
@@ -116,6 +155,23 @@ module ActiveMerchant #:nodoc:
         result.to_s.downcase
       end
 
+      def self.supported_countries=(country_codes)
+        country_codes.each do |country_code|
+          unless ActiveMerchant::Country.find(country_code)
+            raise ActiveMerchant::InvalidCountryCodeError, "No country could be found for the country #{country_code}"
+          end
+        end
+        @supported_countries = country_codes.dup
+      end
+
+      def self.supported_countries
+        @supported_countries ||= []
+      end
+
+      def supported_countries
+        self.class.supported_countries
+      end
+
       def card_brand(source)
         self.class.card_brand(source)
       end
@@ -133,6 +189,51 @@ module ActiveMerchant #:nodoc:
         (@options.has_key?(:test) ? @options[:test] : Base.test?)
       end
 
+      # Does this gateway know how to scrub sensitive information out of HTTP transcripts?
+      def supports_scrubbing?
+        false
+      end
+
+      def scrub(transcript)
+        raise RuntimeError.new("This gateway does not support scrubbing.")
+      end
+
+      def supports_network_tokenization?
+        false
+      end
+
+      protected # :nodoc: all
+
+      def normalize(field)
+        case field
+          when "true"   then true
+          when "false"  then false
+          when ""       then nil
+          when "null"   then nil
+          else field
+        end
+      end
+
+      def user_agent
+        @@ua ||= JSON.dump({
+          :bindings_version => ActiveMerchant::VERSION,
+          :lang => 'ruby',
+          :lang_version => "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})",
+          :platform => RUBY_PLATFORM,
+          :publisher => 'active_merchant'
+        })
+      end
+
+      def strip_invalid_xml_chars(xml)
+        begin
+          REXML::Document.new(xml)
+        rescue REXML::ParseException
+          xml = xml.gsub(/&(?!(?:[a-z]+|#[0-9]+|x[a-zA-Z0-9]+);)/, '&amp;')
+        end
+
+        xml
+      end
+
       private # :nodoc: all
 
       def name
@@ -142,7 +243,7 @@ module ActiveMerchant #:nodoc:
       def amount(money)
         return nil if money.nil?
         cents = if money.respond_to?(:cents)
-          deprecated "Support for Money objects is deprecated and will be removed from a future release of ActiveMerchant. Please use an Integer value in cents"
+          ActiveMerchant.deprecated "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
@@ -159,23 +260,68 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def non_fractional_currency?(currency)
+        self.currencies_without_fractions.include?(currency.to_s)
+      end
+
+      def three_decimal_currency?(currency)
+        self.currencies_with_three_decimal_places.include?(currency.to_s)
+      end
+
       def localized_amount(money, currency)
         amount = amount(money)
-        non_fractional_currency?(currency) ? amount.split('.').first : amount
-      end
 
-      def non_fractional_currency?(currency)
-        CURRENCIES_WITHOUT_FRACTIONS.include?(currency.to_s)
+        return amount unless non_fractional_currency?(currency) || three_decimal_currency?(currency)
+        if non_fractional_currency?(currency)
+          if self.money_format == :cents
+            sprintf("%.0f", amount.to_f / 100)
+          else
+            amount.split('.').first
+          end
+        elsif three_decimal_currency?(currency)
+          if self.money_format == :cents
+            amount.to_s
+          else
+            sprintf("%.3f", (amount.to_f / 10))
+          end
+        end
       end
 
       def currency(money)
         money.respond_to?(:currency) ? money.currency : self.default_currency
       end
 
+      def truncate(value, max_size)
+        return nil unless value
+        value.to_s[0, max_size]
+      end
+
+      def split_names(full_name)
+        names = (full_name || "").split
+        return [nil, nil] if names.size == 0
+
+        last_name  = names.pop
+        first_name = names.join(" ")
+        [first_name, last_name]
+      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
+
+      def requires!(hash, *params)
+        params.each do |param|
+          if param.is_a?(Array)
+            raise ArgumentError.new("Missing required parameter: #{param.first}") unless hash.has_key?(param.first)
+
+            valid_options = param[1..-1]
+            raise ArgumentError.new("Parameter: #{param.first} must be one of #{valid_options.to_sentence(:words_connector => 'or')}") unless valid_options.include?(hash[param.first])
+          else
+            raise ArgumentError.new("Missing required parameter: #{param}") unless hash.has_key?(param)
+          end
+        end
+      end
     end
   end
 end