spatten-bookkeeper 0.2.0

data/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + "/rails/init"

data/lib/bookkeeper.rb

@@ -0,0 +1,8 @@
+require 'find'
+
+require File.join(File.dirname(__FILE__), 'immutable-attribute-plugin', 'init')
+
+# require everything in lib/
+Find.find(File.join(File.dirname(__FILE__), 'bookkeeper')) do |file|
+  require file if !File.directory?(file) && File.extname(file) == '.rb'
+end

data/lib/bookkeeper/account.rb

@@ -0,0 +1,95 @@
+class Account < ActiveRecord::Base
+  acts_as_tree
+
+  has_many  :postings
+  belongs_to :accountable, :polymorphic => true
+  
+  validate :validate_account_created_through_a_subclass
+  validate :validate_subaccount_same_type_as_parent, :if => :is_subaccount
+  validate :validate_name_not_set, :if => :accountable_has_own_name
+  validates_presence_of :name, :unless => :accountable_has_own_name
+  
+  def debit(amount, options = {})
+    new_posting(:debit, amount, options)
+  end
+  
+  def credit(amount, options = {})
+    new_posting(:credit, amount, options)
+  end
+  
+  def deposit(transaction)
+    gross = transaction.notification.amount.cents.to_f / 100
+    
+    journal = Journal::Deposit.new(:transactable => transaction)
+    
+    journal.postings |= transaction.to_postings
+    journal.postings << self.credit(gross)
+    
+    journal.save!
+  end
+  
+  def account_type
+    self.class::ACCOUNT_TYPE
+  end
+  
+  def name
+    accountable_has_own_name ? accountable.name : self[:name]
+  end
+  
+  def postings_with_recursion
+    (self_and_all_children.collect { |account| account.postings_without_recursion }).flatten
+  end
+  alias_method_chain :postings, :recursion
+  
+  def balance
+    postings.inject(0) { |balance, p| 
+      amount_from_account_perspective = [:asset,:expense].include?(account_type) ? -p.amount : p.amount
+      balance + amount_from_account_perspective
+    }
+  end
+  
+  def is_subaccount
+    self != self.root
+  end
+  
+  def destroy
+    raise ActiveRecord::IndestructibleRecord
+  end
+  
+  class << self
+    def accounts_payable; roots.find_by_name('Accounts Payable'); end
+    def accounts_receivable; roots.find_by_name('Accounts Receivable'); end
+  end
+  
+  private
+    def new_posting(type, amount, params)
+      params.assert_valid_keys(:asset_type)
+      
+      params.merge!(:account => self)
+      
+      case type
+      when :debit
+        params.merge!(:amount => -amount)
+      when :credit
+        params.merge!(:amount => amount)
+      end
+      
+      Posting.new(params)
+    end
+    
+    def accountable_has_own_name
+      !self.accountable.name.nil? unless self.accountable.nil?
+    end
+    
+    def validate_account_created_through_a_subclass
+      errors.add_to_base 'Accounts may only be created by instantiating a subclass of Account.' if self.class == Account
+    end
+    
+    def validate_subaccount_same_type_as_parent
+      errors.add_to_base 'Subaccounts must be of the same type as their parent.' if self.class != self.parent.class
+    end
+    
+    def validate_name_not_set
+      errors.add :name, 'should not be set on an account with an accountable that has a name.'
+    end
+end

data/lib/bookkeeper/account/asset.rb

@@ -0,0 +1,3 @@
+class Account::Asset < Account
+  ACCOUNT_TYPE = :asset
+end

data/lib/bookkeeper/account/expense.rb

@@ -0,0 +1,3 @@
+class Account::Expense < Account
+  ACCOUNT_TYPE = :expense
+end

data/lib/bookkeeper/account/liability.rb

@@ -0,0 +1,3 @@
+class Account::Liability < Account
+  ACCOUNT_TYPE = :liability
+end

data/lib/bookkeeper/account/revenue.rb

@@ -0,0 +1,3 @@
+class Account::Revenue < Account
+  ACCOUNT_TYPE = :revenue
+end

data/lib/bookkeeper/asset_type.rb

@@ -0,0 +1,3 @@
+class AssetType < ActiveRecord::Base
+  ensures_immutability_of :all
+end

data/lib/bookkeeper/asset_type/cad.rb

@@ -0,0 +1,2 @@
+class AssetType::CAD < AssetType
+end

data/lib/bookkeeper/asset_type/usd.rb

@@ -0,0 +1,2 @@
+class AssetType::USD < AssetType
+end

data/lib/bookkeeper/batch.rb

@@ -0,0 +1,62 @@
+class Batch < ActiveRecord::Base
+  has_many :journals
+  
+  def pay(payment_transaction)
+    # Get all of the bills associated with this batch
+    bills = journals
+
+    # What kind of fee have we paid as part of this payment?
+    fee = BigDecimal(payment_transaction.notification.fee)
+    if fee > 0
+      logger.info "Recording the MassPay fee for MassPay subpayment #{payment_transaction.transaction_id}"
+      fee_journal = Journal::Disbursement.new(:transactable => payment_transaction)
+
+      fee_journal.postings << payment_transaction.payer_account.credit(fee)
+      fee_journal.postings << Account.paypal_fees_account.debit(fee)
+
+      fee_journal.save!
+    end
+    
+    # How much cash have we paid as part of this payment?
+    payment_dollars = BigDecimal(payment_transaction.notification.gross)
+            
+    while bills.length > 0
+      bill = bills.shift
+      amount_to_pay = bill.amount - bill.amount_paid
+      
+      logger.info "We have #{payment_dollars} left, and #{amount_to_pay} to pay for bill #{bill.id}, with #{bills.length} bills left to pay."
+      if(payment_dollars < amount_to_pay)
+        warn_mispayment(:under, bill.id, (amount_to_pay - payment_dollars))
+        amount_to_pay = payment_dollars
+      elsif(bills.length == 0 and payment_dollars > amount_to_pay)
+        warn_mispayment(:over, bill.id, (payment_dollars - amount_to_pay))
+        amount_to_pay = payment_dollars
+      end
+      
+      if(amount_to_pay > 0)
+        # Record a bill payment in the ledger
+        logger.info "Recording a bill payment for bill #{bill.id}"
+      
+        journal = Journal::Disbursement.new(:transactable => payment_transaction)
+
+        journal.postings << payment_transaction.payer_account.credit(amount_to_pay)
+        journal.postings << Account.accounts_payable.debit(amount_to_pay)
+
+        bill.payments << journal
+        bill.save!
+        
+        payment_dollars -= amount_to_pay
+      end
+    end
+  end
+  
+  private
+    def warn_mispayment(extreme, bill_id, amount)
+      case extreme
+      when :over
+        logger.warn "About to overpay bill #{bill_id} by $#{amount}."
+      when :under
+        logger.warn "About to underpay bill #{bill_id} by $#{amount}."
+      end
+    end
+end

data/lib/bookkeeper/journal.rb

@@ -0,0 +1,29 @@
+class Journal < ActiveRecord::Base
+  has_many   :postings
+  belongs_to :transactable, :polymorphic => true
+  belongs_to :batch
+  
+  ensures_immutability_of :all
+  
+  validates_size_of :postings, :minimum => 2
+  validates_associated :postings
+  validate :validate_postings_sum_to_zero
+  
+  def destroy
+    raise ActiveRecord::IndestructibleRecord
+  end
+  
+  def transactable_type=(sType)
+    super(sType.to_s.classify.constantize.base_class.to_s)
+  end
+  
+  protected    
+    def validate_postings_sum_to_zero
+      errors.add :postings, 'must sum to zero.' unless postings_sum_to_zero
+    end
+    
+    def postings_sum_to_zero
+      sum = self.postings.inject(0) { |sum, posting| sum + posting.amount }
+      sum == 0
+    end
+end

data/lib/bookkeeper/journal/bill.rb

@@ -0,0 +1,32 @@
+class Journal::Bill < Journal
+  has_many   :payments, :as => :payable, :class_name => '::Journal'
+  belongs_to :creditor, :polymorphic => true
+  
+  def amount
+    postings.find(:first, :conditions => {:account_id => Account.accounts_payable}).amount
+  end
+  
+  def amount_paid
+    payments.inject(0) { |sum, payment| sum - payment.postings.find(:first, :conditions => {:account_id => Account.accounts_payable}).amount }
+  end
+  
+  def paid_in_full?
+    amount_paid >= amount
+  end
+  
+  def overpaid?
+    amount_paid > amount
+  end
+  
+  def pay(payment_transaction)
+    gross = payment_transaction.notification.amount.cents.to_f / 100
+    
+    journal = Journal::Disbursement.new(:transactable => payment_transaction)
+    
+    journal.postings |= payment_transaction.to_postings
+    journal.postings << Account.accounts_payable.debit(gross)
+    
+    payments << journal
+    save!
+  end
+end

data/lib/bookkeeper/journal/deposit.rb

@@ -0,0 +1,7 @@
+class Journal::Deposit < Journal
+  belongs_to :payable, :polymorphic => true
+  
+  def payable_type=(sType)
+    super(sType.to_s.classify.constantize.base_class.to_s)
+  end
+end

data/lib/bookkeeper/journal/disbursement.rb

@@ -0,0 +1,7 @@
+class Journal::Disbursement < Journal
+  belongs_to :payable, :polymorphic => true
+  
+  def payable_type=(sType)
+    super(sType.to_s.classify.constantize.base_class.to_s)
+  end
+end

data/lib/bookkeeper/journal/invoice.rb

@@ -0,0 +1,4 @@
+class Journal::Invoice < Journal
+  has_many   :payments, :as => :payable, :class_name => '::Journal'
+  belongs_to :debtor, :polymorphic => true
+end

data/lib/bookkeeper/journal/transfer.rb

@@ -0,0 +1,7 @@
+class Journal::Transfer < Journal
+  belongs_to :payable, :polymorphic => true
+  
+  def payable_type=(sType)
+    super(sType.to_s.classify.constantize.base_class.to_s)
+  end
+end

data/lib/bookkeeper/paypal_transaction.rb

@@ -0,0 +1,12 @@
+class PaypalTransaction < ActiveRecord::Base
+  include ActiveMerchant::Billing::Integrations
+  
+  serialize :notification, Paypal::Notification
+    
+  has_one :journal, :as => :transactable
+  
+  private
+    def account
+      @account ||= Account::Asset.find_by_account_number(self.notification.account)
+    end
+end

data/lib/bookkeeper/paypal_transaction/masspay_subpayment.rb

@@ -0,0 +1,17 @@
+class PaypalTransaction::MasspaySubpayment < PaypalTransaction
+  
+  def to_postings
+    gross = self.notification.amount.cents.to_f / 100
+    fee = self.notification.fee.to_f
+    
+    postings = []
+    postings << payer_account.credit(gross + fee)
+    postings << Account.paypal_fees_account.debit(fee) if(fee > 0)
+    
+    postings
+  end
+  
+  def payer_account
+    @payer_account ||= Account::Asset.find_by_account_number(self.notification.params['payer_email'])
+  end
+end

data/lib/bookkeeper/paypal_transaction/single.rb

@@ -0,0 +1,14 @@
+class PaypalTransaction::Single < PaypalTransaction
+  
+  def to_postings
+    gross = self.notification.amount.cents.to_f / 100
+    fee = self.notification.fee.to_f
+    
+    postings = []
+    postings << account.debit(gross - fee)
+    postings << Account.paypal_fees_account.debit(fee) if(fee > 0)
+    
+    postings
+  end
+
+end

data/lib/bookkeeper/posting.rb

@@ -0,0 +1,32 @@
+class Posting < ActiveRecord::Base
+  belongs_to  :account
+  belongs_to  :journal
+  belongs_to  :asset_type
+  
+  ensures_immutability_of :all
+  
+  before_validation_on_create :default_to_us_dollars, :unless => :asset_type
+  
+  validates_presence_of :account
+  validates_presence_of :asset_type
+  validate :validate_belongs_to_a_journal
+  
+  def destroy
+    raise ActiveRecord::IndestructibleRecord
+  end
+  
+  private
+    def validate_belongs_to_a_journal
+      parent_journal = self.journal
+
+      if !parent_journal
+        ObjectSpace.each_object(Journal) {|j| parent_journal = j if j.postings.include?(self)}
+      end
+      
+      errors.add :journal, 'must be set.' if !parent_journal      
+    end
+    
+    def default_to_us_dollars
+      self.asset_type = AssetType::USD.find(:first)
+    end
+end

data/lib/immutable-attribute-plugin/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Wesley Moxam - Savvica Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/immutable-attribute-plugin/README

@@ -0,0 +1,35 @@
+EnsuresImmutabilityOf
+=====================
+
+There are many cases where a model attribute should not be changed once it's set. This plugin makes it dead simple.
+
+Example
+=======
+
+class Account < ActiveRecord::Base
+  ensures_immutability_of :username, :email
+end
+
+account = Account.create(:username => 'jgreen')
+...
+account.update(:username => 'jgreen')  # raises ActiveRecord::ImmutableAttributeError
+
+Entire models can be made immutable by passing the symbol :all to ensures_immutability_of
+
+class Account < ActiveRecord::Base
+  ensures_immutability_of :all
+end
+
+Collections can all be immutable as well (thanks to Dmitry Ratnikov on #rubyonrails)
+
+class Account  < ActiveRecord::Base
+  has_many :infos
+  ensures_immutability_of :username, :email, :infos   # note: this must come after the has_many declaration, otherwise
+                                                      # AR will overwrite the setter
+end
+
+account = Account.create(:username => 'wmoxam')
+account.infos = Info.find(:all, :conditions => ["id < ?", 3]
+account.infos =  Info.find(:all, :conditions => ["id > ?", 3]  # raises ActiveRecord::ImmutableAttributeError
+
+Copyright (c) 2007-2008 Wesley Moxam - Savvica Inc, released under the MIT license