borutus 0.2.0 → 1.0.0

data/app/models/borutus/amount.rb

@@ -1,13 +1,19 @@
 module Borutus
+
   # The Amount class represents debit and credit amounts in the system.
   #
   # @abstract
-  #   An amount must be a subclass as either a debit or a credit to be saved to the database.
+  #   An amount must be a subclass as either a debit or a credit to be saved
+  #   to the database.
   #
   # @author Michael Bulat
   class Amount < ActiveRecord::Base
-    belongs_to :entry, :class_name => 'Borutus::Entry'
-    belongs_to :account, :class_name => 'Borutus::Account'
+
+    belongs_to :entry, class_name: "Borutus::Entry"
+    belongs_to(:account, {
+      class_name: "Borutus::Account",
+      counter_cache: true,
+    })
 
     validates_presence_of :type, :amount, :entry, :account
     # attr_accessible :account, :account_name, :amount, :entry
@@ -19,6 +25,5 @@ module Borutus
       self.account = Account.find_by_name!(name)
     end
 
-    protected
   end
 end

data/app/models/borutus/amounts_extension.rb

@@ -30,7 +30,7 @@ module Borutus
     #
     # Since this does not use the database for sumation, it may be used on non-persisted records.
     def balance_for_new_record
-      balance = BigDecimal.new('0')
+      balance = BigDecimal('0')
       each do |amount_record|
         if amount_record.amount && !amount_record.marked_for_destruction?
           balance += amount_record.amount # unless amount_record.marked_for_destruction?

data/app/services/borutus/accounts/build_running_balance_query.rb

@@ -0,0 +1,73 @@
+module Borutus
+  module Accounts
+    class BuildRunningBalanceQuery
+
+      STATEMENTS = {
+        coalesce_debit: %{ COALESCE("debit_table"."amount", 0) },
+        coalesce_credit: %{ COALESCE("credit_table"."amount", 0) },
+        amount_sum: %{ SUM("borutus_amounts".amount) AS amount },
+      }.freeze
+
+      extend LightService::Action
+
+      expects :account
+      promises :joins_statement, :select_statement, :group_statement
+
+      executed do |c|
+        account = c.account
+        credit_amounts = account.credit_amounts
+        debit_amounts = account.debit_amounts
+
+        credit_table = credit_amounts.joins(:entry).select(
+          :id,
+          :entry_id,
+          STATEMENTS[:amount_sum],
+        ).group(:entry_id, :id)
+
+        debit_table = debit_amounts.joins(:entry).select(
+          :id,
+          :entry_id,
+          STATEMENTS[:amount_sum],
+        ).group(:entry_id, :id)
+
+        sum_statement = sum_statement_from(account)
+
+        c.joins_statement = joins_statement_from(credit_table, debit_table)
+        c.select_statement = select_statement_from(sum_statement)
+        c.group_statement = group_statement_from
+      end
+
+      def self.sum_statement_from(account)
+        if account.normal_credit_balance
+          %( #{STATEMENTS[:coalesce_credit]} - #{STATEMENTS[:coalesce_debit]} )
+        else
+          %( #{STATEMENTS[:coalesce_debit]} - #{STATEMENTS[:coalesce_credit]} )
+        end
+      end
+      private_class_method :sum_statement_from
+
+      def self.joins_statement_from(credit_table, debit_table)
+        %{
+          LEFT OUTER JOIN (#{credit_table.to_sql}) AS "credit_table" ON "credit_table".entry_id = "borutus_entries".id
+          LEFT OUTER JOIN (#{debit_table.to_sql}) AS "debit_table" ON "debit_table".entry_id = "borutus_entries".id
+        }
+      end
+      private_class_method :joins_statement_from
+
+      def self.select_statement_from(sum_statement)
+        %{
+          "borutus_entries".*,
+          SUM(#{sum_statement}) OVER(ORDER BY "borutus_entries"."created_at") AS balance,
+          #{sum_statement} AS change_amount
+        }
+      end
+      private_class_method :select_statement_from
+
+      def self.group_statement_from
+        %( "borutus_entries".id, "debit_table".amount, "credit_table".amount )
+      end
+      private_class_method :group_statement_from
+
+    end
+  end
+end

data/db/migrate/20191025095830_add_borutus_amount_counter_cache.rb

@@ -0,0 +1,11 @@
+class AddBorutusAmountCounterCache < ActiveRecord::Migration[4.2]
+
+  def up
+    add_column :borutus_accounts, :borutus_amounts_count, :integer
+  end
+
+  def down
+    remove_column :borutus_accounts, :borutus_amounts_count
+  end
+
+end

data/db/migrate/20191025154652_change_borutus_amount_count_column.rb

@@ -0,0 +1,16 @@
+class ChangeBorutusAmountCountColumn < ActiveRecord::Migration[4.2]
+
+  def up
+    remove_column :borutus_accounts, :borutus_amounts_count
+    add_column :borutus_accounts, :amounts_count, :integer
+
+    Borutus::Account.all.pluck(:id).each do |id|
+      Borutus::Account.reset_counters(id, :amounts)
+    end
+  end
+
+  def down
+    remove_column :borutus_accounts, :amounts_count
+  end
+
+end

data/db/migrate/20201116065934_remove_precision_scale.rb

@@ -0,0 +1,9 @@
+class RemovePrecisionScale < ActiveRecord::Migration[5.1]
+  def up
+    change_column :borutus_amounts, :amount, :decimal
+  end
+
+  def down
+    change_column :borutus_amounts, :amount, :decimal, precision: 20, scale: 10
+  end
+end

data/lib/borutus.rb

@@ -1,5 +1,6 @@
 # Borutus
 require "rails"
+require "light-service"
 
 module Borutus
   # ------------------------------ tenancy ------------------------------

data/lib/borutus/version.rb

@@ -1,3 +1,3 @@
 module Borutus
-  VERSION = "0.2.0"
+  VERSION = "1.0.0"
 end

data/spec/controllers/accounts_controller_spec.rb

@@ -5,7 +5,7 @@ module Borutus
     routes { Borutus::Engine.routes }
 
     def mock_account(stubs={})
-      @mock_account ||= FactoryGirl.create(:asset)
+      @mock_account ||= FactoryBot.create(:asset)
     end
 
     describe "GET index" do

data/spec/controllers/entries_controller_spec.rb

@@ -5,7 +5,7 @@ module Borutus
     routes { Borutus::Engine.routes }
 
     def mock_entry(stubs={})
-      @mock_entry ||= FactoryGirl.create(:entry_with_credit_and_debit)
+      @mock_entry ||= FactoryBot.create(:entry_with_credit_and_debit)
     end
 
     describe "GET index" do

data/spec/controllers/reports_controller_spec.rb

@@ -5,7 +5,7 @@ module Borutus
     routes { Borutus::Engine.routes }
 
     def mock_entry(stubs={})
-      @mock_entry ||= FactoryGirl.create(:entry_with_credit_and_debit)
+      @mock_entry ||= FactoryBot.create(:entry_with_credit_and_debit)
     end
 
     describe "GET balance_sheet" do

data/spec/factories/account_factory.rb

@@ -1,32 +1,32 @@
-FactoryGirl.define do
-  factory :account, :class => Borutus::Account do |account|
+FactoryBot.define do
+  factory :account, class: Borutus::Account do |account|
     account.name
-    account.contra false
+    account.contra { false }
   end
 
-  factory :asset, :class => Borutus::Asset do |account|
+  factory :asset, class: Borutus::Asset do |account|
     account.name
-    account.contra false
+    account.contra { false }
   end
 
-  factory :equity, :class => Borutus::Equity do |account|
+  factory :equity, class: Borutus::Equity do |account|
     account.name
-    account.contra false
+    account.contra { false }
   end
 
-  factory :expense, :class => Borutus::Expense do |account|
+  factory :expense, class: Borutus::Expense do |account|
     account.name
-    account.contra false
+    account.contra { false }
   end
 
-  factory :liability, :class => Borutus::Liability do |account|
+  factory :liability, class: Borutus::Liability do |account|
     account.name
-    account.contra false
+    account.contra { false }
   end
 
-  factory :revenue, :class => Borutus::Revenue do |account|
+  factory :revenue, class: Borutus::Revenue do |account|
     account.name
-    account.contra false
+    account.contra { false }
   end
 
   sequence :name do |n|

data/spec/factories/amount_factory.rb

@@ -1,19 +1,19 @@
-FactoryGirl.define do
-  factory :amount, :class => Borutus::Amount do |amount|
-    amount.amount BigDecimal.new('473')
-    amount.association :entry, :factory => :entry_with_credit_and_debit
-    amount.association :account, :factory => :asset
+FactoryBot.define do
+  factory :amount, class: Borutus::Amount do |amount|
+    amount.amount { BigDecimal("473") }
+    amount.association :entry, factory: :entry_with_credit_and_debit
+    amount.association :account, factory: :asset
   end
 
-  factory :credit_amount, :class => Borutus::CreditAmount do |credit_amount|
-    credit_amount.amount BigDecimal.new('473')
-    credit_amount.association :entry, :factory => :entry_with_credit_and_debit
-    credit_amount.association :account, :factory => :revenue
+  factory :credit_amount, class: Borutus::CreditAmount do |credit_amount|
+    credit_amount.amount { BigDecimal("473") }
+    credit_amount.association :entry, factory: :entry_with_credit_and_debit
+    credit_amount.association :account, factory: :revenue
   end
 
-  factory :debit_amount, :class => Borutus::DebitAmount do |debit_amount|
-    debit_amount.amount BigDecimal.new('473')
-    debit_amount.association :entry, :factory => :entry_with_credit_and_debit
-    debit_amount.association :account, :factory => :asset
+  factory :debit_amount, class: Borutus::DebitAmount do |debit_amount|
+    debit_amount.amount { BigDecimal("473") }
+    debit_amount.association :entry, factory: :entry_with_credit_and_debit
+    debit_amount.association :account, factory: :asset
   end
 end

data/spec/factories/entry_factory.rb

@@ -1,11 +1,14 @@
-FactoryGirl.define do
-  factory :entry, :class => Borutus::Entry do |entry|
-    entry.description 'factory description'
-    factory :entry_with_credit_and_debit, :class => Borutus::Entry do |entry_cd|
-      entry_cd.after_build do |t|
-        t.credit_amounts << FactoryGirl.build(:credit_amount, :entry => t)
-        t.debit_amounts << FactoryGirl.build(:debit_amount, :entry => t)
-      end
+FactoryBot.define do
+  factory :entry, class: Borutus::Entry do
+    description { "factory description" }
+  end
+
+  factory :entry_with_credit_and_debit, class: Borutus::Entry do
+    description { "factory description" }
+    
+    after(:build) do |entry|
+      entry.credit_amounts << FactoryBot.build(:credit_amount, entry: entry)
+      entry.debit_amounts << FactoryBot.build(:debit_amount, entry: entry)
     end
   end
 end

data/spec/models/account_spec.rb

@@ -1,39 +1,40 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Borutus
   describe Account do
-    let(:account) { FactoryGirl.build(:account) }
+
+    let(:account) { FactoryBot.build(:account) }
     subject { account }
 
-    it { is_expected.not_to be_valid }  # must construct a child type instead
+    it { is_expected.not_to be_valid } # must construct a child type instead
 
     describe ".types" do
       it "lists the available types" do
-        expect(described_class.types).
-          to match_array([Asset, Equity, Expense, Liability, Revenue])
+        expect(described_class.types)
+          .to match_array([Asset, Equity, Expense, Liability, Revenue])
       end
     end
 
     describe ".entries.with_running_balance" do
-      let(:mock_document) { FactoryGirl.create(:asset) }
+      let(:mock_document) { FactoryBot.create(:asset) }
       let!(:accounts_receivable) do
-        FactoryGirl.create(:asset, name: "Accounts Receivable")
+        FactoryBot.create(:asset, name: "Accounts Receivable")
       end
       let!(:sales_revenue) do
-        FactoryGirl.create(:revenue, name: "Sales Revenue")
+        FactoryBot.create(:revenue, name: "Sales Revenue")
       end
       let!(:sales_tax_payable) do
-        FactoryGirl.create(:liability, name: "Sales Tax Payable")
+        FactoryBot.create(:liability, name: "Sales Tax Payable")
       end
       let!(:entry_1) do
         Borutus::Entry.new({
           description: "Sold some widgets",
           commercial_document: mock_document,
-          debits: [{account: accounts_receivable, amount: 50}],
+          debits: [{ account: accounts_receivable, amount: 50 }],
           credits: [
-            {account: sales_revenue, amount: 45},
-            {account: sales_tax_payable, amount: 5}
-          ]
+            { account: sales_revenue, amount: 45 },
+            { account: sales_tax_payable, amount: 5 },
+          ],
         })
       end
       let!(:entry_2) do
@@ -41,24 +42,24 @@ module Borutus
           description: "Cancel Accounts receivable some widgets again",
           commercial_document: mock_document,
           debits: [
-            {account: accounts_receivable, amount: -30},
+            { account: accounts_receivable, amount: -30 },
           ],
           credits: [
-            {account: sales_revenue, amount: -25},
-            {account: sales_tax_payable, amount: -5},
-          ]
+            { account: sales_revenue, amount: -25 },
+            { account: sales_tax_payable, amount: -5 },
+          ],
         })
       end
       let!(:entry_3) do
         Borutus::Entry.new({
           description: "Cancel Accounts receivable",
           commercial_document: mock_document,
-          debits: [{account: sales_tax_payable, amount: 15}],
-          credits: [{account: accounts_receivable, amount: 15}],
+          debits: [{ account: sales_tax_payable, amount: 15 }],
+          credits: [{ account: accounts_receivable, amount: 15 }],
         })
       end
 
-      it "returns entries for only the account with a balance column" do
+      it "returns entries for only the account with a balance and change_amount columns" do
         entry_1.save
         entry_2.save
         entry_3.save
@@ -66,24 +67,74 @@ module Borutus
         receivable_entries = accounts_receivable.entries.with_running_balance
         expect(receivable_entries.to_a.count).to eq 3
         expect(receivable_entries.first.balance).to eq 50 # inital 50
+        expect(receivable_entries.first.change_amount).to eq 50 # inital 50
         expect(receivable_entries.second.balance).to eq 20 # deduct 30 due to entry_2
+        expect(receivable_entries.second.change_amount).to eq -30 # deduct 30 due to entry_2
         expect(receivable_entries.last.balance).to eq 5 # deduct 5 due to entry_3
+        expect(receivable_entries.last.change_amount).to eq -15 # deduct 5 due to entry_3
 
         payable_entries = sales_tax_payable.entries.with_running_balance
           .order(created_at: :asc)
         expect(payable_entries.to_a.count).to eq 3
         expect(payable_entries.first.balance).to eq 5
+        expect(payable_entries.first.change_amount).to eq 5
         expect(payable_entries.second.balance).to eq 0 # deduct 5 due to entry_2
+        expect(payable_entries.second.change_amount).to eq -5
         expect(payable_entries.last.balance).to eq -15 # deduct 15 due to entry_3
+        expect(payable_entries.last.change_amount).to eq -15
+      end
+    end
+
+    describe ".with_amounts" do
+      let(:mock_document) { FactoryBot.create(:asset) }
+      let!(:cash) do
+        FactoryBot.create(:asset, name: "Cash")
+      end
+      let!(:accounts_receivable) do
+        FactoryBot.create(:asset, name: "Accounts Receivable")
+      end
+      let!(:sales_revenue) do
+        FactoryBot.create(:revenue, name: "Sales Revenue")
+      end
+      let!(:sales_tax_payable) do
+        FactoryBot.create(:liability, name: "Sales Tax Payable")
+      end
+      let!(:entry_1) do
+        Borutus::Entry.new({
+          description: "Sold some widgets",
+          commercial_document: mock_document,
+          debits: [{ account: accounts_receivable, amount: 50 }],
+          credits: [
+            { account: sales_revenue, amount: 45 },
+            { account: sales_tax_payable, amount: 5 },
+          ],
+        })
+      end
+
+      it "only returns with borutus_amounts_count > 0" do
+        entry_1.save
+
+        accounts = Borutus::Account.with_amounts
+        expect(accounts.count).to eq 3
+
+        account_names = accounts.pluck(:name)
+
+        [
+          "Accounts Receivable",
+          "Sales Revenue",
+          "Sales Tax Payable",
+        ].each do |account_name|
+          expect(account_names).to include account_name
+        end
       end
     end
 
     describe "when using a child type" do
-      let(:account) { FactoryGirl.create(:account, type: "Finance::Asset") }
+      let(:account) { FactoryBot.create(:account, type: "Finance::Asset") }
       it { is_expected.to be_valid }
 
       it "should be unique per name" do
-        conflict = FactoryGirl.build(:account, name: account.name, type: account.type)
+        conflict = FactoryBot.build(:account, name: account.name, type: account.type)
         expect(conflict).not_to be_valid
         expect(conflict.errors[:name]).to eq(["has already been taken"])
       end
@@ -108,36 +159,36 @@ module Borutus
       context "when given correct entries" do
         before {
           # credit accounts
-          liability = FactoryGirl.create(:liability)
-          equity = FactoryGirl.create(:equity)
-          revenue = FactoryGirl.create(:revenue)
-          contra_asset = FactoryGirl.create(:asset, :contra => true)
-          contra_expense = FactoryGirl.create(:expense, :contra => true)
+          liability = FactoryBot.create(:liability)
+          equity = FactoryBot.create(:equity)
+          revenue = FactoryBot.create(:revenue)
+          contra_asset = FactoryBot.create(:asset, contra: true)
+          contra_expense = FactoryBot.create(:expense, contra: true)
           # credit amounts
-          ca1 = FactoryGirl.build(:credit_amount, :account => liability, :amount => 100000)
-          ca2 = FactoryGirl.build(:credit_amount, :account => equity, :amount => 1000)
-          ca3 = FactoryGirl.build(:credit_amount, :account => revenue, :amount => 40404)
-          ca4 = FactoryGirl.build(:credit_amount, :account => contra_asset, :amount => 2)
-          ca5 = FactoryGirl.build(:credit_amount, :account => contra_expense, :amount => 333)
+          ca1 = FactoryBot.build(:credit_amount, account: liability, amount: 100_000)
+          ca2 = FactoryBot.build(:credit_amount, account: equity, amount: 1000)
+          ca3 = FactoryBot.build(:credit_amount, account: revenue, amount: 40_404)
+          ca4 = FactoryBot.build(:credit_amount, account: contra_asset, amount: 2)
+          ca5 = FactoryBot.build(:credit_amount, account: contra_expense, amount: 333)
 
           # debit accounts
-          asset = FactoryGirl.create(:asset)
-          expense = FactoryGirl.create(:expense)
-          contra_liability = FactoryGirl.create(:liability, :contra => true)
-          contra_equity = FactoryGirl.create(:equity, :contra => true)
-          contra_revenue = FactoryGirl.create(:revenue, :contra => true)
+          asset = FactoryBot.create(:asset)
+          expense = FactoryBot.create(:expense)
+          contra_liability = FactoryBot.create(:liability, contra: true)
+          contra_equity = FactoryBot.create(:equity, contra: true)
+          contra_revenue = FactoryBot.create(:revenue, contra: true)
           # debit amounts
-          da1 = FactoryGirl.build(:debit_amount, :account => asset, :amount => 100000)
-          da2 = FactoryGirl.build(:debit_amount, :account => expense, :amount => 1000)
-          da3 = FactoryGirl.build(:debit_amount, :account => contra_liability, :amount => 40404)
-          da4 = FactoryGirl.build(:debit_amount, :account => contra_equity, :amount => 2)
-          da5 = FactoryGirl.build(:debit_amount, :account => contra_revenue, :amount => 333)
-
-          FactoryGirl.create(:entry, :credit_amounts => [ca1], :debit_amounts => [da1])
-          FactoryGirl.create(:entry, :credit_amounts => [ca2], :debit_amounts => [da2])
-          FactoryGirl.create(:entry, :credit_amounts => [ca3], :debit_amounts => [da3])
-          FactoryGirl.create(:entry, :credit_amounts => [ca4], :debit_amounts => [da4])
-          FactoryGirl.create(:entry, :credit_amounts => [ca5], :debit_amounts => [da5])
+          da1 = FactoryBot.build(:debit_amount, account: asset, amount: 100_000)
+          da2 = FactoryBot.build(:debit_amount, account: expense, amount: 1000)
+          da3 = FactoryBot.build(:debit_amount, account: contra_liability, amount: 40_404)
+          da4 = FactoryBot.build(:debit_amount, account: contra_equity, amount: 2)
+          da5 = FactoryBot.build(:debit_amount, account: contra_revenue, amount: 333)
+
+          FactoryBot.create(:entry, credit_amounts: [ca1], debit_amounts: [da1])
+          FactoryBot.create(:entry, credit_amounts: [ca2], debit_amounts: [da2])
+          FactoryBot.create(:entry, credit_amounts: [ca3], debit_amounts: [da3])
+          FactoryBot.create(:entry, credit_amounts: [ca4], debit_amounts: [da4])
+          FactoryBot.create(:entry, credit_amounts: [ca5], debit_amounts: [da5])
         }
 
         it { is_expected.to eq(0) }
@@ -146,9 +197,9 @@ module Borutus
 
     describe "#amounts" do
       it "returns all credit and debit amounts" do
-        equity = FactoryGirl.create(:equity)
-        asset = FactoryGirl.create(:asset)
-        expense = FactoryGirl.create(:expense)
+        equity = FactoryBot.create(:equity)
+        asset = FactoryBot.create(:asset)
+        expense = FactoryBot.create(:expense)
 
         investment = Entry.new(
           description: "Initial investment",
@@ -166,17 +217,17 @@ module Borutus
         )
         purchase.save
 
-        expect(equity.amounts.size).to eq 1
-        expect(asset.amounts.size).to eq 2
-        expect(expense.amounts.size).to eq 1
+        expect(equity.reload.amounts.size).to eq 1
+        expect(asset.reload.amounts.size).to eq 2
+        expect(expense.reload.amounts.size).to eq 1
       end
     end
 
     describe "#entries" do
       it "returns all credit and debit entries" do
-        equity = FactoryGirl.create(:equity)
-        asset = FactoryGirl.create(:asset)
-        expense = FactoryGirl.create(:expense)
+        equity = FactoryBot.create(:equity)
+        asset = FactoryBot.create(:asset)
+        expense = FactoryBot.create(:expense)
 
         investment = Entry.new(
           description: "Initial investment",