aba 0.0.1 → 0.5.0

data/lib/aba/entry.rb

@@ -0,0 +1,17 @@
+class Aba
+  class Entry
+    def initialize(attrs = {})
+      attrs.each do |key, value|
+        send("#{key}=", value)
+      end
+    end
+
+    def credit?
+      (50..57).include?(transaction_code.to_i)
+    end
+
+    def debit?
+      transaction_code.to_i == 13
+    end
+  end
+end

data/lib/aba/return.rb

@@ -0,0 +1,72 @@
+class Aba
+  class Return < Entry
+    include Aba::Validations
+
+    attr_accessor :account_number, :transaction_code, :amount, :account_name,
+                  :bsb, :trace_bsb, :trace_account_number, :name_of_remitter,
+                  :return_code, :lodgement_reference,
+                  :original_processing_day, :original_user_id
+
+    # BSB
+    validates_bsb               :bsb
+
+    # Account Number
+    validates_account_number    :account_number
+
+    # Indicator
+    validates_return_code       :return_code
+
+    # Transaction Code
+    validates_transaction_code  :transaction_code
+
+    # Amount
+    validates_amount            :amount
+
+    # Original Day of Processing
+    validates_integer           :original_processing_day, :unsigned
+
+    # Original User Id
+    validates_max_length        :original_user_id, 6
+    validates_integer           :original_user_id, :unsigned
+
+    # Account Name
+    validates_max_length        :account_name, 32
+    validates_becs              :account_name
+
+    # Lodgement Reference
+    validates_max_length        :lodgement_reference, 18
+    validates_becs              :lodgement_reference
+
+    # Trace Record
+    validates_bsb               :trace_bsb
+    validates_account_number    :trace_account_number
+
+    # Name of Remitter
+    validates_max_length        :name_of_remitter, 16
+    validates_becs              :name_of_remitter
+
+
+    # Allow dashes to be input, but remove them from output
+    def account_number
+      @account_number ? @account_number.to_s.delete('-') : nil
+    end
+
+    def to_s
+      raise 'Transaction data is invalid - check the contents of `errors`' unless valid?
+
+      format('2%-7s%9s%1d%2d%010d%-32s%-18s%-7s%9s%-16s%02d%6s',
+             bsb,
+             account_number,
+             return_code,
+             transaction_code,
+             amount.to_i.abs,
+             account_name,
+             lodgement_reference,
+             trace_bsb,
+             trace_account_number,
+             name_of_remitter,
+             original_processing_day.to_i,
+             original_user_id)
+    end
+  end
+end

data/lib/aba/transaction.rb

@@ -1,31 +1,90 @@
 class Aba
-  class Transaction
+  class Transaction < Entry
     include Aba::Validations
 
-    attr_accessor :account_number, :transaction_code, :amount, :account_name, :payment_id, 
-                  :bsb, :trace_bsb, :trace_account_number, :name_of_remitter, :witholding_amount, 
-                  :indicator, :lodgement_reference
-
-    validates_presence_of :bsb, :account_number, :amount, :account_name, :payment_id, :transaction_code,
-                          :lodgement_reference, :trace_bsb, :trace_account_number, :name_of_remitter
-    
-    validates_bsb :bsb, :trace_bsb
-
-    validates_max_length :account_number,         9
-    validates_max_length :indicator,              1
-    validates_max_length :transaction_code,       2
-    validates_max_length :account_name,           32
-    validates_max_length :lodgement_reference,    18
-    validates_max_length :trace_account_number,   9
-    validates_max_length :name_of_remitter,       16
-
-    def initialize(attrs = {})
-      attrs.each do |key, value|
-        send("#{key}=", value)
-      end
+    attr_accessor :account_number, :transaction_code, :amount, :account_name,
+                  :bsb, :trace_bsb, :trace_account_number, :name_of_remitter,
+                  :witholding_amount, :indicator, :lodgement_reference
+
+    # BSB
+    validates_bsb               :bsb
+
+    # Account Number
+    validates_account_number    :account_number
+
+    # Indicator
+    validates_indicator         :indicator
+
+    # Transaction Code
+    validates_transaction_code  :transaction_code
+
+    # Amount
+    validates_amount            :amount
+
+    # Account Name
+    validates_max_length        :account_name, 32
+    validates_becs              :account_name
+
+    # Lodgement Reference
+    validates_max_length        :lodgement_reference, 18
+    validates_becs              :lodgement_reference
+
+    # Trace Record
+    validates_bsb               :trace_bsb
+    validates_account_number    :trace_account_number
+
+    # Name of Remitter
+    validates_max_length        :name_of_remitter, 16
+    validates_becs              :name_of_remitter
+
+
+    # Allow dashes to be input, but remove them from output
+    def account_number
+      @account_number ? @account_number.to_s.gsub('-', '') : nil
+    end
+
+    # Fall back to blank string
+    def indicator
+      @indicator || Aba::Validations::INDICATORS.first
+    end
+
+    # Fall back to 50
+    def transaction_code
+      @transaction_code || 50
     end
-    
+
+    # Fall back to 0
+    def amount
+      @amount || 0
+    end
+
+    # Fall back to empty string
+    def account_name
+      @account_name || ''
+    end
+
+    # Fall back to empty string
+    def lodgement_reference
+      @lodgement_reference || ''
+    end
+
+    # Fall back to BSB
+    def trace_bsb
+      @trace_bsb || bsb
+    end
+
+    # Fall back to Account Number
+    def trace_account_number
+      @trace_account_number ? @trace_account_number.to_s.gsub('-', '') : account_number
+    end
+
+    def name_of_remitter
+      @name_of_remitter || ''
+    end
+
     def to_s
+      raise RuntimeError, 'Transaction data is invalid - check the contents of `errors`' unless valid?
+
       # Record type
       output = "1"
 
@@ -33,44 +92,49 @@ class Aba
       output += bsb
 
       # Account number
+      #raise RuntimeError, 'Transaction is missing account_number' unless account_number
       output += account_number.to_s.rjust(9, " ")
 
       # Withholding Tax Indicator
       # "N" – for new or varied Bank/State/Branch number or name details, otherwise blank filled.
+      # "T" - for a drawing under a Transaction Negotiation Authority.
       # "W" – dividend paid to a resident of a country where a double tax agreement is in force.
       # "X" – dividend paid to a resident of any other country.
       # "Y" – interest paid to all non-residents.
       output += indicator.to_s.ljust(1, " ")
 
       # Transaction Code
-      # 50 General Credit. 
-      # 53 Payroll. 
-      # 54 Pension. 
-      # 56 Dividend. 
-      # 57 Debenture Interest. 
+      # 50 General Credit.
+      # 53 Payroll.
+      # 54 Pension.
+      # 56 Dividend.
+      # 57 Debenture Interest.
       # 13 General Debit.
       output += transaction_code.to_s
 
       # Amount to be credited or debited
-      output += amount.abs.to_s.rjust(10, "0")
+      output += amount.to_i.abs.to_s.rjust(10, "0")
 
       # Title of Account
-      output += account_name.ljust(32, " ")
+      # Full BECS character set valid
+      output += account_name.to_s.ljust(32, " ")
 
-      # Lodgement Reference Produced on the recipient’s Account Statement. 
-      output += lodgement_reference.ljust(18, " ")     
+      # Lodgement Reference Produced on the recipient’s Account Statement.
+      # Full BECS character set valid
+      output += lodgement_reference.to_s.ljust(18, " ")
 
       # Trace BSB Number
       output += trace_bsb
 
-      # Trace Account Number 
+      # Trace Account Number
       output += trace_account_number.to_s.rjust(9, " ")
 
       # Name of Remitter Produced on the recipient’s Account Statement
-      output += name_of_remitter.ljust(16, " ")
+      # Full BECS character set valid
+      output += name_of_remitter.to_s.ljust(16, " ")
 
       # Withholding amount in cents
       output += (witholding_amount || 0).abs.to_s.rjust(8, "0")
     end
   end
-end
+end

data/lib/aba/validations.rb

@@ -1,6 +1,9 @@
 class Aba
   module Validations
-    attr_accessor :errors
+    attr_accessor :error_collection
+
+    BECS_PATTERN = /\A[\w\+\-\@\ \$\!\%\&\(\)\*\.\/\#\=\:\;\?\,\'\[\]\_\^]*\Z/
+    INDICATORS = [' ', 'N', 'T', 'W', 'X', 'Y']
 
     def self.included(base)
       base.instance_eval do
@@ -10,9 +13,17 @@ class Aba
       base.send :extend, ClassMethods
     end
 
-    # Run all validations
     def valid?
-      self.errors = []
+      !has_errors?
+    end
+
+    alias_method 'errors', 'error_collection'
+
+    private
+
+    # Run all validations
+    def has_errors?
+      self.error_collection = []
 
       self.class.instance_variable_get(:@_validations).each do |attribute, validations|
         value = send(attribute)
@@ -20,35 +31,94 @@ class Aba
         validations.each do |type, param|
           case type
           when :presence
-            self.errors << "#{attribute} is empty" if value.nil? || value.to_s.empty?
+            self.error_collection << "#{attribute} is empty" if value.nil? || value.to_s.empty?
           when :bsb
-            self.errors << "#{attribute} format is incorrect" unless value =~ /^\d{3}-\d{3}$/
+            unless((param && value.nil?) || value =~ /^\d{3}-\d{3}$/)
+              self.error_collection << "#{attribute} format is incorrect"
+            end
           when :max_length
-            self.errors << "#{attribute} length must not exceed #{param} characters" if value.to_s.length > param
+            self.error_collection << "#{attribute} length must not exceed #{param} characters" if value.to_s.length > param
+          when :length
+            self.error_collection << "#{attribute} length must be exactly #{param} characters" if value.to_s.length != param
+          when :integer
+            if param
+              self.error_collection << "#{attribute} must be a number" unless value.to_s =~ /\A[+-]?\d+\Z/
+            else
+              self.error_collection << "#{attribute} must be an unsigned number" unless value.to_s =~ /\A\d+\Z/
+            end
+          when :matches_transaction_code
+            if debit? && value.to_i > 0
+              self.error_collection << "#{attribute} is positive but the transaction type is a debit"
+            elsif credit? && value.to_i < 0
+              self.error_collection << "#{attribute} is negative but the transaction type is a credit"
+            end
+          when :account_number
+            if value.to_s =~ /\A[0\ ]+\Z/ || value.to_s !~ /\A[a-z\d\ ]{1,9}\Z/
+              self.error_collection << "#{attribute} must be a valid account number"
+            end
+          when :becs
+            self.error_collection << "#{attribute} must not contain invalid characters" unless value.to_s =~ BECS_PATTERN
+          when :indicator
+            list = INDICATORS.join('\', \'')
+            self.error_collection << "#{attribute} must be a one of '#{list}'" unless INDICATORS.include?(value.to_s)
+          when :transaction_code
+            self.error_collection << "#{attribute} must be a 2 digit number" unless value.to_s =~ /\A\d{2,2}\Z/
           end
         end
       end
 
-      self.errors.empty?
+      !self.error_collection.empty?
     end
-   
+
     module ClassMethods
       def validates_presence_of(*attributes)
-        attributes.each do |a| 
+        attributes.each do |a|
           add_validation_attribute(a, :presence)
         end
       end
 
-      def validates_bsb(*attributes)
-        attributes.each do |a| 
-          add_validation_attribute(a, :bsb)
-        end
+      def validates_bsb(attribute, options = {})
+        options[:allow_blank] ||= false
+        add_validation_attribute(attribute, :bsb, options[:allow_blank])
       end
 
       def validates_max_length(attribute, length)
         add_validation_attribute(attribute, :max_length, length)
       end
 
+      def validates_length(attribute, length)
+        add_validation_attribute(attribute, :length, length)
+      end
+
+      def validates_integer(attribute, signed = true)
+        add_validation_attribute(attribute, :integer, signed)
+      end
+
+      def validates_amount(attribute)
+        add_validation_attribute(attribute, :integer, true)
+        add_validation_attribute(attribute, :matches_transaction_code)
+      end
+
+      def validates_account_number(attribute)
+        add_validation_attribute(attribute, :account_number)
+      end
+
+      def validates_becs(attribute)
+        add_validation_attribute(attribute, :becs)
+      end
+
+      def validates_indicator(attribute)
+        add_validation_attribute(attribute, :indicator)
+      end
+
+      def validates_transaction_code(attribute)
+        add_validation_attribute(attribute, :transaction_code)
+      end
+
+      def validates_return_code(attribute)
+        add_validation_attribute(attribute, :integer, :return_code)
+      end
+
       private
 
       def add_validation_attribute(attribute, type, param = true)
@@ -57,4 +127,4 @@ class Aba
       end
     end
   end
-end
+end

data/lib/aba/version.rb

@@ -1,3 +1,3 @@
 class Aba
-  VERSION = "0.0.1"
+  VERSION = "0.5.0"
 end

data/spec/lib/aba/batch_spec.rb

@@ -0,0 +1,101 @@
+# encoding: UTF-8
+
+require "spec_helper"
+
+describe Aba::Batch do
+  subject(:batch) { Aba::Batch.new(financial_institution: "WPC", user_name: "John Doe",
+                      user_id: "466364", description: "Payroll", process_at: "190615") }
+  let(:transaction_amounts) { [[53, 30], [13, -20]] }
+  let(:transactions) do
+    transaction_amounts.map do |(transaction_code, amount)|
+      Aba::Transaction.new(bsb: '342-342', account_number: '3244654', amount: amount,
+      account_name: 'John Doe', transaction_code: transaction_code,
+      lodgement_reference: 'R435564', trace_bsb: '453-543',
+      trace_account_number: '45656733', name_of_remitter: 'Remitter')
+    end
+  end
+  before { transactions.each { |trx| batch.add_transaction(trx) } }
+
+  let(:return_amounts) { [[53, 3], [13, -2]] }
+  let(:returns) do
+    return_amounts.map do |(transaction_code, amount)|
+      Aba::Return.new(bsb: '453-543', account_number: '45656733', amount: amount,
+                      account_name: 'John Doe', transaction_code: transaction_code,
+                      lodgement_reference: 'R435564', trace_bsb: '342-342',
+                      trace_account_number: '3244654', name_of_remitter: 'Remitter',
+                      return_code: 8, original_user_id: 654321,
+                      original_processing_day: 12,
+
+      )
+    end
+  end
+  before { returns.each { |trx| batch.add_return(trx) } }
+
+  describe "#to_s" do
+
+    context 'when descriptive record' do
+
+      context 'without bsb' do
+        it "should return a string containing the descriptive record without the bsb" do
+          expect(batch.to_s).to include("0                 01WPC       John Doe                  466364Payroll     190615                                        \r\n")
+        end
+      end
+
+      context 'with bsb' do
+        before { batch.bsb = "123-345" }
+        it "should return a string containing the descriptive record with the bsb" do
+          expect(batch.to_s).to include("0123-345          01WPC       John Doe                  466364Payroll     190615                                        \r\n")
+        end
+      end
+    end
+
+
+    context 'when detail record' do
+
+      it "should contain transaction & return records" do
+        expect(batch.to_s).to include("1342-342  3244654 530000000030John Doe                        R435564           453-543 45656733Remitter        00000000\r\n")
+        expect(batch.to_s).to include("1342-342  3244654 130000000020John Doe                        R435564           453-543 45656733Remitter        00000000\r\n")
+        expect(batch.to_s).to include("2453-543 456567338530000000003John Doe                        R435564           342-342  3244654Remitter        12654321\r\n")
+        expect(batch.to_s).to include("2453-543 456567338130000000002John Doe                        R435564           342-342  3244654Remitter        12654321\r\n")
+      end
+    end
+
+    context 'when file total record' do
+
+      context 'with unbalanced transactions' do
+        it "should return a string where the net total is not zero" do
+          expect(batch.to_s).to include("7999-999            000000001100000000330000000022                        000004                                        ")
+        end
+      end
+
+      context 'with balanced transactions' do
+        let(:transaction_amounts) { [[50, 30], [50, 30], [13, -60]] }
+        let(:return_amounts) { [[50, 3], [50, 3], [13, -6]] }
+        it "should return a string where the net total is zero" do
+          expect(batch.to_s).to include("7999-999            000000000000000000660000000066                        000006                                        ")
+        end
+      end
+    end
+  end
+
+  describe "#errors" do
+
+    let(:errors) { subject.errors }
+
+    it "is empty" do
+      expect(errors).to be_nil
+    end
+
+    context "with an invalid amount" do
+      let(:transaction_amounts) do
+        [[53, 1], [53, -1], [13, 'def']]
+      end
+      it "reports the errors" do
+        expect(errors).to eq(:entries => {
+            1 => ["amount is negative but the transaction type is a credit"],
+            2 => ["amount must be a number"]
+        })
+      end
+    end
+  end
+end