uk_account_validator_auctionet 0.0.8

data/lib/uk_account_validator/exceptions/exception_12.rb

@@ -0,0 +1,9 @@
+# These are for Nationwide Flex accounts. Where there is a 12 in the exception
+# column for the first check for a sorting code and a 13 in the exception column
+# for the second check for the same sorting code, if either check is successful
+# the account number is deemed valid.
+class Exception12 < BaseException
+  def self.allow_any?
+    true
+  end
+end

data/lib/uk_account_validator/exceptions/exception_14.rb

@@ -0,0 +1,30 @@
+# Perform the modulus 11 check as normal:
+#  * If the check passes (that is, there is no remainder), then the account
+#    number should be considered valid. Do not perform the second check.
+#  * If the first check fails, then the second check must be performed as
+#    specified below.
+#
+# Second check:
+#  * If the 8th digit of the account number (reading from left to right) is not
+#    0, 1 or 9 then the account number fails the second check and is not a valid
+#    Coutts account number
+#  * If the 8th digit is 0, 1 or 9, then remove the digit from the account
+#    number and insert a 0 as the 1st digit for check purposes only
+#  * Perform the modulus 11 check on the modified account number using the same
+#    weightings as specified in the table (that is, 0 0 0 0 0 0 8 7 6 5 4 3 2 1):
+#    - If there is no remainder, then the account number should be considered
+#      valid
+#    - If there is a remainder, then the account number fails the second check
+#      and is not a valid Coutts account number
+class Exception14 < BaseException
+  def self.allow_any?
+    true
+  end
+
+  def apply_account_number_substitutions
+    return account_number unless %w(0 1 9).include?(account_number[7])
+
+    account_number.slice!(7)
+    return '0' + account_number
+  end
+end

data/lib/uk_account_validator/exceptions/exception_2_9.rb

@@ -0,0 +1,68 @@
+# Only occurs for some standard modulus 11 checks, when there is a 2 in the
+# exception column for the first check for a sorting code and a 9 in the
+# exception column for the second check for the same sorting code. This is used
+# specifically for Lloyds euro accounts.
+#
+# Perform the standard check, except:
+#  * If a <> 0 and g <> 9, substitute the weight specified in the modulus weight
+#    table with:
+#      u v w x y z a b c d e  f g h
+#      0 0 1 2 5 3 6 4 8 7 10 9 3 1
+#
+#  * If a <> 0 and g = 9, substitute the weight specified in the modulus weight
+#    table with:
+#      u v w x y z a b c d e f g h
+#      0 0 0 0 0 0 0 0 8 7 10 9 3 1
+#
+# If the first row with exception 2 passes the standard modulus 11 check, you do
+# not need to carry out the second check (ie it is deemed to be a valid sterling
+# account).
+#
+# All Lloyds euro accounts are held at sorting code 30-96-34, however customers
+# may perceive that their euro account is held at the branch where sterling
+# accounts are held and thus quote a sorting code other than 30-96-34. The
+# combination of the "sterling" sorting code and "euro" account number will
+# cause the first standard modulus 11 check to fail. In such cases, carry out
+# the second modulus 11 check, substituting the sorting code with 309634 and the
+# appropriate weighting. If this check passes it is deemed to be a valid euro
+# account.
+
+class Exception29 < BaseException
+  def self.allow_any?
+    true
+  end
+
+  def apply_sort_code_substitutions
+    return '309634' if check_number == 2
+
+    return sort_code
+  end
+
+  def replace_weight(test_digits)
+    return modulus_weight if test_digits[NUMBER_INDEX[:a]] == 0
+    return substitute_modulus_weight if check_number == 2
+
+    if test_digits[NUMBER_INDEX[:g]] != 9
+      return UkAccountValidator::ModulusWeight.new(
+        modulus_weight.sort_code_start,
+        modulus_weight.sort_code_end,
+        modulus_weight.modulus,
+        0, 0, 1, 2, 5, 3, 6, 4, 8, 7, 10, 9, 3, 1,
+        modulus_weight.exception
+      )
+    else
+      return UkAccountValidator::ModulusWeight.new(
+        modulus_weight.sort_code_start,
+        modulus_weight.sort_code_end,
+        modulus_weight.modulus,
+        0, 0, 0, 0, 0, 0, 0, 0, 8, 7, 10, 9, 3, 1,
+        modulus_weight.exception
+      )
+    end
+  end
+
+  # Returns the modulus weight for 309634
+  def substitute_modulus_weight
+    UkAccountValidator.modulus_weights_table.find('309634').first
+  end
+end

data/lib/uk_account_validator/exceptions/exception_3.rb

@@ -0,0 +1,10 @@
+# If c=6 or c=9 the double alternate check does not need to be carried out
+class Exception3 < BaseException
+  def replace_weight(test_digits)
+    c = test_digits[NUMBER_INDEX[:c]]
+
+    return zero_all if c == 6 || c == 9
+
+    return modulus_weight
+  end
+end

data/lib/uk_account_validator/exceptions/exception_4.rb

@@ -0,0 +1,16 @@
+# Perform the standard modulus 11 check.
+# After you have finished the check, ensure that the remainder is the same as
+# the two-digit checkdigit;
+# the checkdigit for exception 4 is gh from the original account number.
+class Exception4 < BaseException
+  def override_test?
+    true
+  end
+
+  def test(modulus, total, test_digits, _test)
+    check_sum = [test_digits[NUMBER_INDEX[:g]], test_digits[NUMBER_INDEX[:h]]].join
+    check_sum = check_sum.to_i
+
+    total % modulus == check_sum
+  end
+end

data/lib/uk_account_validator/exceptions/exception_5.rb

@@ -0,0 +1,48 @@
+# Perform the first check (standard modulus check) except:
+#  * If the sorting code appears in SCSUBTAB.txt, substitute it for the
+#    "substitute with" column (for check purposes only).
+#    If the sorting code is not found, use the original sorting code.
+#
+# For the standard check with exception 5 the checkdigit is g from the original
+# account number.
+#  * After dividing the result by 11:
+#    - if the remainder = 0 and g = 0 the account number is valid
+#    - if the remainder = 1 the account number is invalid
+#    - for all other remainders, take the remainder away from 11. If the number
+#      you get is the same as g then the account number is valid.
+#
+# Perform the second double alternate check, and for the double alternate check
+# with exception 5 the checkdigit is h from the original account number, except:
+#  * After dividing the result by 10:
+#    - if the remainder = 0 and h = 0 the account number is valid
+#    - for all other remainders, take the remainder away from 10. If the number
+#      you get is the same as h then the account number is valid.
+class Exception5 < BaseException
+  def apply_sort_code_substitutions
+    substitutions = UkAccountValidator.read_sort_code_substitution
+
+    return substitutions[sort_code] if substitutions.keys.include?(sort_code)
+
+    return sort_code
+  end
+
+  def override_test?
+    true
+  end
+
+  def test(modulus, total, test_digits, test)
+    if test == :double_alternate
+      check_digit = :h
+    else
+      check_digit = :g
+    end
+
+    check_sum    = total % modulus
+    expected_sum = test_digits[NUMBER_INDEX[check_digit]].to_i
+
+    return false if check_sum == 1 && check_digit == :g
+    return true  if check_sum == 0 && expected_sum == 0
+
+    return (modulus - check_sum) == expected_sum
+  end
+end

data/lib/uk_account_validator/exceptions/exception_6.rb

@@ -0,0 +1,16 @@
+# Indicates that these sorting codes may contain foreign currency accounts which
+# cannot be checked.
+# Perform the first and second checks, except:
+#   If a = 4, 5, 6, 7 or 8, and g and h are the same, the accounts are for a
+#   foreign currency and the checks cannot be used.
+class Exception6 < BaseException
+  def replace_weight(test_digits)
+    a = test_digits[NUMBER_INDEX[:a]]
+    g = test_digits[NUMBER_INDEX[:g]]
+    h = test_digits[NUMBER_INDEX[:h]]
+
+    return zero_all if (a == 4 || a == 5 || a == 6 || a == 7 || a == 8) && g == h
+
+    return modulus_weight
+  end
+end

data/lib/uk_account_validator/exceptions/exception_7.rb

@@ -0,0 +1,9 @@
+# Perform the check as specified, except if g = 9 zeroise weighting positions
+# u-b.
+class Exception7 < BaseException
+  def replace_weight(test_digits)
+    return modulus_weight unless test_digits[NUMBER_INDEX[:g]] == 9
+
+    return zero_u_b
+  end
+end

data/lib/uk_account_validator/exceptions/exception_8.rb

@@ -0,0 +1,7 @@
+# Perform the check as specified, except substitute the sorting code with
+# 090126, for check purposes only
+class Exception8 < BaseException
+  def apply_sort_code_substitutions
+    return '090126'
+  end
+end

data/lib/uk_account_validator/modulus_weight.rb

@@ -0,0 +1,35 @@
+module UkAccountValidator
+  class ModulusWeight
+    attr_reader :sort_code_start, :sort_code_end, :modulus, :u, :v, :w, :x,
+                :y, :z, :a, :b, :c, :d, :e, :f, :g, :h, :exception
+
+    # the size of each column
+    COLUMN_SIZES = [6, 7, 9, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 3]
+
+    # @param definition_line The line from valacdos.txt that defines this weight.
+    def self.from_line(definition_line)
+      # See https://www.ruby-forum.com/topic/184294#805359
+      data = definition_line.unpack("A#{COLUMN_SIZES.join('A')}")
+
+      data.map!(&:strip)
+
+      @sort_code_start, @sort_code_end, @modulus, @u, @v, @w, @x,
+        @y, @z, @a, @b, @c, @d, @e, @f, @g, @h, @exception = data
+
+      ModulusWeight.new(*data)
+    end
+
+    def initialize(sort_code_start, sort_code_end, modulus, u, v, w, x, y, z,
+          a, b, c, d, e, f, g, h, exception)
+
+      @sort_code_start = sort_code_start
+      @sort_code_end   = sort_code_end
+      @modulus         = modulus
+      @exception       = exception
+
+      @u, @v, @w, @x, @y, @z, @a, @b, @c, @d, @e, @f, @g, @h =
+        [u.to_i, v.to_i, w.to_i, x.to_i, y.to_i, z.to_i, a.to_i, b.to_i, c.to_i,
+         d.to_i, e.to_i, f.to_i, g.to_i, h.to_i]
+    end
+  end
+end

data/lib/uk_account_validator/modulus_weights_table.rb

@@ -0,0 +1,35 @@
+module UkAccountValidator
+  class ModulusWeightsTable
+
+    def initialize(path)
+      @weights = []
+
+      File.readlines(path).each do |line|
+        @weights << ModulusWeight.from_line(line)
+      end
+
+      @weights.sort_by! { |weight| -weight.sort_code_start.to_i }
+    end
+
+    def find(sort_code)
+      sort_code = sort_code.to_i
+
+      min_found_weight_index = @weights.bsearch_index do |w|
+        w.sort_code_start.to_i <= sort_code
+      end
+
+      return [] if min_found_weight_index.nil?
+
+      found_weights = []
+      index = min_found_weight_index
+      while index < @weights.size &&
+              @weights[index].sort_code_start.to_i <= sort_code &&
+              sort_code <= @weights[index].sort_code_end.to_i
+        found_weights << @weights[index]
+        index += 1
+      end
+
+      found_weights
+    end
+  end
+end

data/lib/uk_account_validator/number_indices.rb

@@ -0,0 +1,18 @@
+module NumberIndices
+  NUMBER_INDEX = {
+    u: 0,
+    v: 1,
+    w: 2,
+    x: 3,
+    y: 4,
+    z: 5,
+    a: 6,
+    b: 7,
+    c: 8,
+    d: 9,
+    e: 10,
+    f: 11,
+    g: 12,
+    h: 13
+  }
+end

data/lib/uk_account_validator/validator.rb

@@ -0,0 +1,92 @@
+module UkAccountValidator
+  class Validator
+
+    attr_writer   :sort_code
+    attr_accessor :account_number
+
+    def initialize(account_number = nil, sort_code = nil)
+      @account_number = account_number
+      @sort_code      = sort_code
+    end
+
+    def sort_code
+      @sort_code.gsub('-', '')
+    end
+
+    def modulus_weights
+      @modulus_weights ||= UkAccountValidator.modulus_weights_table.find(sort_code)
+    end
+
+    def modulus_validator(modulus)
+      case modulus
+      when 'MOD10'
+        Validators::Modulus10
+      when 'MOD11'
+        Validators::Modulus11
+      when 'DBLAL'
+        Validators::DoubleAlternate
+      else
+        fail NotImplementedError
+      end
+    end
+
+    def valid?
+      return false unless valid_format?
+
+      exceptions = modulus_weights.map(&:exception)
+      exception_class = self.exception_class(exceptions)
+
+      results = modulus_weights.each_with_index.map do |modulus_weight, i|
+        exception = exception_class.new(modulus_weight, account_number, sort_code, i + 1)
+
+        @account_number = exception.apply_account_number_substitutions
+
+        modulus_validator(modulus_weight.modulus).new(
+          account_number, sort_code, modulus_weight, exception
+        ).valid?
+      end
+
+      return results.any? if exception_class.allow_any?
+
+      results.all?
+    end
+
+    def valid_format?
+      return false if account_number =~ /\D/
+      return false if account_number.length < 6
+      return false if account_number.length > 10
+      return false if sort_code.length != 6
+
+      return true
+    end
+
+    def exception_class(exception_strings)
+      case
+      when exception_strings.include?('1')
+        Exception1
+      when exception_strings.include?('2') && exception_strings.include?('9')
+        Exception29
+      when exception_strings.include?('3')
+        Exception3
+      when exception_strings.include?('4')
+        Exception4
+      when exception_strings.include?('5')
+        Exception5
+      when exception_strings.include?('6')
+        Exception6
+      when exception_strings.include?('7')
+        Exception7
+      when exception_strings.include?('8')
+        Exception8
+      when exception_strings.include?('10') && exception_strings.include?('11')
+        Exception10
+      when exception_strings.include?('12') && exception_strings.include?('13')
+        Exception12
+      when exception_strings.include?('14')
+        Exception14
+      else
+        BaseException
+      end
+    end
+  end
+end

data/lib/uk_account_validator/validators/base_validator.rb

@@ -0,0 +1,28 @@
+module UkAccountValidator
+  module Validators
+    class BaseValidator
+      include NumberIndices
+
+      attr_reader :account_number, :sort_code, :modulus_weight, :exception
+
+      def initialize(account_number, sort_code, modulus_weight, exception)
+        @account_number = account_number
+        @sort_code      = sort_code
+        @modulus_weight = modulus_weight
+        @exception      = exception
+
+        @sort_code = exception.apply_sort_code_substitutions
+      end
+
+      def applying_exceptions(test_digits)
+        @modulus_weight = exception.replace_weight(test_digits)
+
+        total = yield
+
+        total = exception.after_calculate_total(total, test_digits)
+
+        total
+      end
+    end
+  end
+end