aba 0.1.0 → 1.0.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?
+      Validations::CREDIT_TRANSACTION_CODES.include?(transaction_code.to_i)
+    end
+
+    def debit?
+      Validations::DEBIT_TRANSACTION_CODES.include?(transaction_code.to_i)
+    end
+  end
+end

data/lib/aba/return.rb

@@ -0,0 +1,71 @@
+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_integer           :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,60 @@
 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_integer           :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
+
+    # Sane default for majority of use cases as per BECS
+    def indicator
+      @indicator || ' '
     end
-    
+
+    # Optional as per BECS
+    def lodgement_reference
+      @lodgement_reference || ''
+    end
+
     def to_s
+      raise RuntimeError, 'Transaction data is invalid - check the contents of `errors`' unless valid?
+
       # Record type
       output = "1"
 
@@ -33,44 +62,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,11 @@
 class Aba
   module Validations
-    attr_accessor :errors
+    attr_accessor :error_collection
+
+    BECS_PATTERN = /\A[\w\+\-\@\ \$\!\%\&\(\)\*\.\/\#\=\:\;\?\,\'\[\]\_\^]*\Z/
+    INDICATORS = [' ', 'N', 'T', 'W', 'X', 'Y']
+    DEBIT_TRANSACTION_CODES = [13]
+    CREDIT_TRANSACTION_CODES = [50, 51, 52, 53, 54, 55, 56, 57]
 
     def self.included(base)
       base.instance_eval do
@@ -10,9 +15,21 @@ class Aba
       base.send :extend, ClassMethods
     end
 
-    # Run all validations
+    def self.transaction_codes
+      DEBIT_TRANSACTION_CODES + CREDIT_TRANSACTION_CODES
+    end
+
     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 +37,83 @@ 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 :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 one of #{Validations.transaction_codes.join(', ')}" unless Validations.transaction_codes.include?(value.to_i)
           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_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 +122,4 @@ class Aba
       end
     end
   end
-end
+end

data/lib/aba/version.rb

@@ -1,3 +1,3 @@
 class Aba
-  VERSION = "0.1.0"
+  VERSION = "1.0.0"
 end

data/spec/lib/aba/batch_spec.rb

@@ -0,0 +1,133 @@
+# encoding: UTF-8
+
+require "spec_helper"
+
+describe Aba::Batch do
+  subject(:batch) do
+    Aba::Batch.new(
+      financial_institution: "WPC",
+      user_name: "John Doe",
+      user_id: "466364",
+      description: "Payroll",
+      process_at: "190615",
+    )
+  end
+
+  let(:transactions_attributes) { [{amount: 30, transaction_code: 50}, {amount: 20, transaction_code: 13}] }
+  let(:returns_attributes) { [{amount: 3, transaction_code: 50}, {amount: 2, transaction_code: 13}] }
+
+  before do
+    transactions_attributes.each do |attr|
+      transaction = Aba::Transaction.new(
+        bsb: '342-342',
+        account_number: '3244654',
+        amount: attr[:amount],
+        account_name: 'John Doe',
+        transaction_code: attr[:transaction_code],
+        lodgement_reference: 'R435564',
+        trace_bsb: '453-543',
+        trace_account_number: '45656733',
+        name_of_remitter: 'Remitter',
+      )
+
+      batch.add_transaction(transaction)
+    end
+
+    returns_attributes.map do |attr|
+      ret = Aba::Return.new(
+        bsb: '453-543',
+        account_number: '45656733',
+        amount: attr[:amount],
+        account_name: 'John Doe',
+        transaction_code: attr[: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,
+      )
+
+      batch.add_return(ret)
+    end
+  end
+
+  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 500000000030John 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 456567338500000000003John 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                                        ")
+          #                                                  | Total  || Credit || Debit  |
+        end
+      end
+
+      context 'with balanced transactions' do
+        let(:transactions_attributes) do
+          [{amount: 30, transaction_code: 50}, {amount: 30, transaction_code: 13}, {amount: 30, transaction_code: 50}]
+        end
+        let(:returns_attributes) do
+          [{amount: 3, transaction_code: 50}, {amount: 3, transaction_code: 13}, {amount: 30, transaction_code: 13}]
+        end
+
+        it "should return a string where the net total is zero" do
+          expect(batch.to_s).to include("7999-999            000000000000000000630000000063                        000006                                        ")
+          #                                                  | Total  || Credit || Debit  |
+        end
+      end
+
+      context 'with negative values supplied for the amounts' do
+        let(:transactions_attributes) { [{amount: -30, transaction_code: 50}, {amount: -20, transaction_code: 13}] }
+        let(:returns_attributes) { [{amount: -3, transaction_code: 50}, {amount: 2, transaction_code: 13}] }
+
+        it 'should return a string where the amount segments rely on the transaction code, not the amount sign' do
+          expect(batch.to_s).to include("7999-999            000000001100000000330000000022                        000004                                        ")
+          #                                                  | Total  || Credit || Debit  |
+        end
+
+      end
+    end
+  end
+
+  describe "#errors" do
+    it "is empty" do
+      expect(batch.errors).to be_nil
+    end
+
+    context "with an invalid amount" do
+      let(:transactions_attributes) do
+        [{amount: 1, transaction_code: 50}, {amount: 'abc', transaction_code: 13}, {amount: 'def', transaction_code: 50}]
+      end
+
+      it "reports the errors" do
+        expect(batch.errors).to eq(:entries => { 1 => ["amount must be a number"], 2 => ["amount must be a number"] })
+      end
+    end
+  end
+end