borutus 0.1.0

data/app/controllers/borutus/application_controller.rb

@@ -0,0 +1,4 @@
+module Borutus
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/controllers/borutus/entries_controller.rb

@@ -0,0 +1,34 @@
+module Borutus
+  # This controller provides restful route handling for Entries.
+  #
+  # The controller supports ActiveResource, and provides for
+  # HMTL, XML, and JSON presentation.
+  #
+  # == Security:
+  # Only GET requests are supported. You should ensure that your application
+  # controller enforces its own authentication and authorization, which this
+  # controller will inherit.
+  #
+  # @author Michael Bulat
+  class EntriesController <  Borutus::ApplicationController
+    unloadable
+    # @example
+    #   GET /entries
+    #   GET /entries.xml
+    #   GET /entries.json
+    def index
+      if params[:order] == 'ascending'
+        order = 'ASC'
+      else
+        order = 'DESC'
+      end
+      @entries = Entry.page(params[:page]).per(params[:limit]).order("date #{order}")
+
+      respond_to do |format|
+        format.html # index.html.erb
+        format.xml  { render :xml => @entries }
+        format.json  { render :json => @entries }
+      end
+    end
+  end
+end

data/app/controllers/borutus/reports_controller.rb

@@ -0,0 +1,40 @@
+module Borutus
+  # == Security:
+  # Only GET requests are supported. You should ensure that your application
+  # controller enforces its own authentication and authorization, which this
+  # controller will inherit.
+  #
+  # @author Michael Bulat
+  class ReportsController < ::Borutus::ApplicationController
+    unloadable
+
+    # @example
+    #   GET /reports/balance_sheet
+    def balance_sheet
+      first_entry = Borutus::Entry.order('date ASC').first
+      @from_date = first_entry ? first_entry.date: Date.today
+      @to_date = params[:date] ? Date.parse(params[:date]) : Date.today
+      @assets = Borutus::Asset.all
+      @liabilities = Borutus::Liability.all
+      @equity = Borutus::Equity.all
+
+      respond_to do |format|
+        format.html # index.html.erb
+      end
+    end
+
+    # @example
+    #   GET /reports/income_statement
+    def income_statement
+      @from_date = params[:from_date] ? Date.parse(params[:from_date]) : Date.today.at_beginning_of_month
+      @to_date = params[:to_date] ? Date.parse(params[:to_date]) : Date.today
+      @revenues = Borutus::Revenue.all
+      @expenses = Borutus::Expense.all
+
+      respond_to do |format|
+        format.html # index.html.erb
+      end
+    end
+
+  end
+end

data/app/models/borutus/account.rb

@@ -0,0 +1,180 @@
+module Borutus
+  # The Account class represents accounts in the system. Each account must be subclassed as one of the following types:
+  #
+  #   TYPE        | NORMAL BALANCE    | DESCRIPTION
+  #   --------------------------------------------------------------------------
+  #   Asset       | Debit             | Resources owned by the Business Entity
+  #   Liability   | Credit            | Debts owed to outsiders
+  #   Equity      | Credit            | Owners rights to the Assets
+  #   Revenue     | Credit            | Increases in owners equity
+  #   Expense     | Debit             | Assets or services consumed in the generation of revenue
+  #
+  # Each account can also be marked as a "Contra Account". A contra account will have it's
+  # normal balance swapped. For example, to remove equity, a "Drawing" account may be created
+  # as a contra equity account as follows:
+  #
+  #   Borutus::Equity.create(:name => "Drawing", contra => true)
+  #
+  # At all times the balance of all accounts should conform to the "accounting equation"
+  #   Borutus::Assets = Liabilties + Owner's Equity
+  #
+  # Each sublclass account acts as it's own ledger. See the individual subclasses for a
+  # description.
+  #
+  # @abstract
+  #   An account must be a subclass to be saved to the database. The Account class
+  #   has a singleton method {trial_balance} to calculate the balance on all Accounts.
+  #
+  # @see http://en.wikipedia.org/wiki/Accounting_equation Accounting Equation
+  # @see http://en.wikipedia.org/wiki/Debits_and_credits Debits, Credits, and Contra Accounts
+  #
+  # @author Michael Bulat
+  class Account < ActiveRecord::Base
+    class_attribute :normal_credit_balance
+
+    has_many :amounts
+    has_many :credit_amounts, :extend => AmountsExtension, :class_name => 'Borutus::CreditAmount'
+    has_many :debit_amounts, :extend => AmountsExtension, :class_name => 'Borutus::DebitAmount'
+    has_many :entries, through: :amounts, source: :entry
+    has_many :credit_entries, :through => :credit_amounts, :source => :entry, :class_name => 'Borutus::Entry'
+    has_many :debit_entries, :through => :debit_amounts, :source => :entry, :class_name => 'Borutus::Entry'
+
+    validates_presence_of :type
+
+    def self.types
+      [
+        ::Borutus::Asset,
+        ::Borutus::Equity,
+        ::Borutus::Expense,
+        ::Borutus::Liability,
+        ::Borutus::Revenue,
+      ]
+    end
+
+    if Borutus.enable_tenancy
+      include Borutus::Tenancy
+    else
+      include Borutus::NoTenancy
+    end
+
+    # The balance of the account. This instance method is intended for use only
+    # on instances of account subclasses.
+    #
+    # If the account has a normal credit balance, the debits are subtracted from the credits
+    # unless this is a contra account, in which case credits are substracted from debits.
+    #
+    # For a normal debit balance, the credits are subtracted from the debits
+    # unless this is a contra account, in which case debits are subtracted from credits.
+    #
+    # Takes an optional hash specifying :from_date and :to_date for calculating balances during periods.
+    # :from_date and :to_date may be strings of the form "yyyy-mm-dd" or Ruby Date objects
+    #
+    # @example
+    #   >> liability.balance({:from_date => "2000-01-01", :to_date => Date.today})
+    #   => #<BigDecimal:103259bb8,'0.1E4',4(12)>
+    #
+    # @example
+    #   >> liability.balance
+    #   => #<BigDecimal:103259bb8,'0.2E4',4(12)>
+    #
+    # @return [BigDecimal] The decimal value balance
+    def balance(options={})
+      if self.class == Borutus::Account
+        raise(NoMethodError, "undefined method 'balance'")
+      else
+        if self.normal_credit_balance ^ contra
+          credits_balance(options) - debits_balance(options)
+        else
+          debits_balance(options) - credits_balance(options)
+        end
+      end
+    end
+
+    # The credit balance for the account.
+    #
+    # Takes an optional hash specifying :from_date and :to_date for calculating balances during periods.
+    # :from_date and :to_date may be strings of the form "yyyy-mm-dd" or Ruby Date objects
+    #
+    # @example
+    #   >> asset.credits_balance({:from_date => "2000-01-01", :to_date => Date.today})
+    #   => #<BigDecimal:103259bb8,'0.1E4',4(12)>
+    #
+    # @example
+    #   >> asset.credits_balance
+    #   => #<BigDecimal:103259bb8,'0.1E4',4(12)>
+    #
+    # @return [BigDecimal] The decimal value credit balance
+    def credits_balance(options={})
+      credit_amounts.balance(options)
+    end
+
+    # The debit balance for the account.
+    #
+    # Takes an optional hash specifying :from_date and :to_date for calculating balances during periods.
+    # :from_date and :to_date may be strings of the form "yyyy-mm-dd" or Ruby Date objects
+    #
+    # @example
+    #   >> asset.debits_balance({:from_date => "2000-01-01", :to_date => Date.today})
+    #   => #<BigDecimal:103259bb8,'0.1E4',4(12)>
+    #
+    # @example
+    #   >> asset.debits_balance
+    #   => #<BigDecimal:103259bb8,'0.3E4',4(12)>
+    #
+    # @return [BigDecimal] The decimal value credit balance
+    def debits_balance(options={})
+      debit_amounts.balance(options)
+    end
+
+    # This class method is used to return the balance of all accounts
+    # for a given class and is intended for use only on account subclasses.
+    #
+    # Contra accounts are automatically subtracted from the balance.
+    #
+    # Takes an optional hash specifying :from_date and :to_date for calculating balances during periods.
+    # :from_date and :to_date may be strings of the form "yyyy-mm-dd" or Ruby Date objects
+    #
+    # @example
+    #   >> Borutus::Liability.balance({:from_date => "2000-01-01", :to_date => Date.today})
+    #   => #<BigDecimal:103259bb8,'0.1E4',4(12)>
+    #
+    # @example
+    #   >> Borutus::Liability.balance
+    #   => #<BigDecimal:1030fcc98,'0.82875E5',8(20)>
+    #
+    # @return [BigDecimal] The decimal value balance
+    def self.balance(options={})
+      if self.new.class == Borutus::Account
+        raise(NoMethodError, "undefined method 'balance'")
+      else
+        accounts_balance = BigDecimal.new('0')
+        accounts = self.all
+        accounts.each do |account|
+          if account.contra
+            accounts_balance -= account.balance(options)
+          else
+            accounts_balance += account.balance(options)
+          end
+        end
+        accounts_balance
+      end
+    end
+
+    # The trial balance of all accounts in the system. This should always equal zero,
+    # otherwise there is an error in the system.
+    #
+    # @example
+    #   >> Account.trial_balance.to_i
+    #   => 0
+    #
+    # @return [BigDecimal] The decimal value balance of all accounts
+    def self.trial_balance
+      if self.new.class == Borutus::Account
+        Borutus::Asset.balance - (Borutus::Liability.balance + Borutus::Equity.balance + Borutus::Revenue.balance - Borutus::Expense.balance)
+      else
+        raise(NoMethodError, "undefined method 'trial_balance'")
+      end
+    end
+
+  end
+end

data/app/models/borutus/amount.rb

@@ -0,0 +1,24 @@
+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.
+  #
+  # @author Michael Bulat
+  class Amount < ActiveRecord::Base
+    belongs_to :entry, :class_name => 'Borutus::Entry'
+    belongs_to :account, :class_name => 'Borutus::Account'
+
+    validates_presence_of :type, :amount, :entry, :account
+    # attr_accessible :account, :account_name, :amount, :entry
+
+    delegate :name, to: :account, prefix: true, allow_nil: true
+
+    # Assign an account by name
+    def account_name=(name)
+      self.account = Account.find_by_name!(name)
+    end
+
+    protected
+  end
+end

data/app/models/borutus/amounts_extension.rb

@@ -0,0 +1,42 @@
+module Borutus
+  # Association extension for has_many :amounts relations. Internal.
+  module AmountsExtension
+    # Returns a sum of the referenced Amount objects.
+    #
+    # Takes a hash specifying :from_date and :to_date for calculating balances during periods.
+    # :from_date and :to_date may be strings of the form "yyyy-mm-dd" or Ruby Date objects
+    #
+    # This runs the summation in the database, so it only works on persisted records.
+    #
+    # @example
+    #   credit_amounts.balance({:from_date => "2000-01-01", :to_date => Date.today})
+    #   => #<BigDecimal:103259bb8,'0.2E4',4(12)>
+    #
+    # @return [BigDecimal] The decimal value balance
+    def balance(hash={})
+      if hash[:from_date] && hash[:to_date]
+        from_date = hash[:from_date].kind_of?(Date) ? hash[:from_date] : Date.parse(hash[:from_date])
+        to_date = hash[:to_date].kind_of?(Date) ? hash[:to_date] : Date.parse(hash[:to_date])
+        includes(:entry).where('borutus_entries.date' => from_date..to_date).sum(:amount)
+      else
+        sum(:amount)
+      end
+    end
+
+    # Returns a sum of the referenced Amount objects.
+    #
+    # This is used primarly in the validation step in Borutus::Entry
+    # in order to ensure that the debit and credits are canceling out.
+    #
+    # 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')
+      each do |amount_record|
+        if amount_record.amount && !amount_record.marked_for_destruction?
+          balance += amount_record.amount # unless amount_record.marked_for_destruction?
+        end
+      end
+      return balance
+    end
+  end
+end

data/app/models/borutus/asset.rb

@@ -0,0 +1,56 @@
+module Borutus
+  # The Asset class is an account type used to represents resources owned by the business entity.
+  #
+  # === Normal Balance
+  # The normal balance on Asset accounts is a *Debit*.
+  #
+  # @see http://en.wikipedia.org/wiki/Asset Assets
+  #
+  # @author Michael Bulat
+  class Asset < ::Borutus::Account
+
+    self.normal_credit_balance = false
+
+    # The balance of the account.
+    #
+    # Assets have normal debit balances, so the credits are subtracted from the debits
+    # unless this is a contra account, in which debits are subtracted from credits
+    #
+    # Takes an optional hash specifying :from_date and :to_date for calculating balances during periods.
+    # :from_date and :to_date may be strings of the form "yyyy-mm-dd" or Ruby Date objects
+    #
+    # @example
+    #   >> asset.balance({:from_date => "2000-01-01", :to_date => Date.today})
+    #   => #<BigDecimal:103259bb8,'0.1E4',4(12)>
+    #
+    # @example
+    #   >> asset.balance
+    #   => #<BigDecimal:103259bb8,'0.2E4',4(12)>
+    #
+    # @return [BigDecimal] The decimal value balance
+    def balance(options={})
+      super(options)
+    end
+
+    # This class method is used to return
+    # the balance of all Asset accounts.
+    #
+    # Contra accounts are automatically subtracted from the balance.
+    #
+    # Takes an optional hash specifying :from_date and :to_date for calculating balances during periods.
+    # :from_date and :to_date may be strings of the form "yyyy-mm-dd" or Ruby Date objects
+    #
+    # @example
+    #   >> Borutus::Asset.balance({:from_date => "2000-01-01", :to_date => Date.today})
+    #   => #<BigDecimal:103259bb8,'0.1E4',4(12)>
+    #
+    # @example
+    #   >> Borutus::Asset.balance
+    #   => #<BigDecimal:1030fcc98,'0.82875E5',8(20)>
+    #
+    # @return [BigDecimal] The decimal value balance
+    def self.balance(options={})
+      super(options)
+    end
+  end
+end

data/app/models/borutus/credit_amount.rb

@@ -0,0 +1,10 @@
+module Borutus
+  # The CreditAmount class represents credit entries in the entry journal.
+  #
+  # @example
+  #     credit_amount = Borutus::CreditAmount.new(:account => revenue, :amount => 1000)
+  #
+  # @author Michael Bulat
+  class CreditAmount < ::Borutus::Amount
+  end
+end

data/app/models/borutus/debit_amount.rb

@@ -0,0 +1,10 @@
+module Borutus
+  # The DebitAmount class represents debit entries in the entry journal.
+  #
+  # @example
+  #     debit_amount = Borutus::DebitAmount.new(:account => cash, :amount => 1000)
+  #
+  # @author Michael Bulat
+  class DebitAmount < ::Borutus::Amount
+  end
+end

data/app/models/borutus/entry.rb

@@ -0,0 +1,77 @@
+module Borutus
+  # Entries are the recording of debits and credits to various accounts.
+  # This table can be thought of as a traditional accounting Journal.
+  #
+  # Posting to a Ledger can be considered to happen automatically, since
+  # Accounts have the reverse 'has_many' relationship to either it's credit or
+  # debit entries
+  #
+  # @example
+  #   cash = Borutus::Asset.find_by_name('Cash')
+  #   accounts_receivable = Borutus::Asset.find_by_name('Accounts Receivable')
+  #
+  #   debit_amount = Borutus::DebitAmount.new(:account => cash, :amount => 1000)
+  #   credit_amount = Borutus::CreditAmount.new(:account => accounts_receivable, :amount => 1000)
+  #
+  #   entry = Borutus::Entry.new(:description => "Receiving payment on an invoice")
+  #   entry.debit_amounts << debit_amount
+  #   entry.credit_amounts << credit_amount
+  #   entry.save
+  #
+  # @see http://en.wikipedia.org/wiki/Journal_entry Journal Entry
+  #
+  # @author Michael Bulat
+  class Entry < ActiveRecord::Base
+    before_save :default_date
+
+    if ActiveRecord::VERSION::MAJOR > 4
+      belongs_to :commercial_document, :polymorphic => true, optional: true
+    else
+      belongs_to :commercial_document, :polymorphic => true
+    end
+
+    has_many :credit_amounts, :extend => AmountsExtension, :class_name => 'Borutus::CreditAmount', :inverse_of => :entry
+    has_many :debit_amounts, :extend => AmountsExtension, :class_name => 'Borutus::DebitAmount', :inverse_of => :entry
+    has_many :credit_accounts, :through => :credit_amounts, :source => :account, :class_name => 'Borutus::Account'
+    has_many :debit_accounts, :through => :debit_amounts, :source => :account, :class_name => 'Borutus::Account'
+
+    validates_presence_of :description
+    validate :has_credit_amounts?
+    validate :has_debit_amounts?
+    validate :amounts_cancel?
+
+    # Support construction using 'credits' and 'debits' keys
+    accepts_nested_attributes_for :credit_amounts, :debit_amounts, allow_destroy: true
+    alias_method :credits=, :credit_amounts_attributes=
+    alias_method :debits=, :debit_amounts_attributes=
+    # attr_accessible :credits, :debits
+
+    # Support the deprecated .build method
+    def self.build(hash)
+      ActiveSupport::Deprecation.warn('Borutus::Transaction.build() is deprecated (use new instead)', caller)
+      new(hash)
+    end
+
+    def initialize(*args)
+      super
+    end
+
+    private
+      def default_date
+        todays_date = ActiveRecord::Base.default_timezone == :utc ? Time.now.utc : Time.now
+        self.date ||= todays_date
+      end
+
+      def has_credit_amounts?
+        errors[:base] << "Entry must have at least one credit amount" if self.credit_amounts.blank?
+      end
+
+      def has_debit_amounts?
+        errors[:base] << "Entry must have at least one debit amount" if self.debit_amounts.blank?
+      end
+
+      def amounts_cancel?
+        errors[:base] << "The credit and debit amounts are not equal" if credit_amounts.balance_for_new_record != debit_amounts.balance_for_new_record
+      end
+  end
+end