event_sourced_accounting 0.1.0

data/app/models/esa/context.rb

@@ -0,0 +1,218 @@
+module ESA
+  # The Context provides a persisted filtered view on the objects related to a Chart.
+  #
+  # @author Lenno Nagel
+  class Context < ActiveRecord::Base
+    attr_accessible :chart, :chart_id, :parent, :parent_id, :type, :name, :namespace, :position
+    attr_accessible :chart, :chart_id, :parent, :parent_id, :type, :name, :namespace, :position, :start_date, :end_date, :as => :admin
+    attr_readonly   :chart, :parent
+
+    belongs_to :chart
+    has_many :accounts, :through => :chart
+    has_many :rulesets, :through => :chart
+
+    has_many :unscoped_events, :through => :rulesets, :source => :events, :uniq => true
+    has_many :unscoped_flags, :through => :rulesets, :source => :flags, :uniq => true
+    has_many :unscoped_transactions, :through => :accounts, :source => :transactions, :uniq => true
+    has_many :unscoped_amounts, :through => :accounts, :source => :amounts, :uniq => true, :extend => Associations::AmountsExtension
+
+    belongs_to :parent, :class_name => "Context"
+    has_many :subcontexts, :class_name => "Context", :foreign_key => "parent_id", :dependent => :destroy
+
+    after_initialize :default_values, :initialize_filters
+    before_validation :update_name, :update_position
+    validates_presence_of :chart, :name
+    validate :validate_parent
+    before_save :enforce_persistence_rule
+
+    scope :roots, lambda { where(parent_id: nil) }
+    scope :subs,  lambda { where("esa_contexts.parent_id is not null") }
+
+    def is_root?
+      self.parent_id.nil?
+    end
+
+    def is_subcontext?
+      self.parent_id.present?
+    end
+
+    def events
+      self.apply(self.unscoped_events)
+    end
+
+    def flags
+      self.apply(self.unscoped_flags)
+    end
+
+    def transactions
+      self.apply(self.unscoped_transactions)
+    end
+
+    def amounts
+      self.apply(self.unscoped_amounts)
+    end
+
+    def apply(relation)
+      self.effective_contexts.inject(relation) do |r,context|
+        context.inject_filters(r)
+      end
+    end
+
+    def last_transaction_time
+      if defined? @last_transaction_time
+        @last_transaction_time
+      else
+        @last_transaction_time = self.transactions.maximum(:created_at)
+      end
+    end
+
+    def check_freshness(depth=0)
+      if self.is_update_needed?
+        self.update!
+      end
+
+      if depth > 0 and self.last_transaction_time.present?
+        self.subcontexts.each do |sub|
+          if sub.freshness.nil? or sub.freshness <= self.last_transaction_time
+            sub.check_freshness(depth - 1)
+          end
+        end
+      end
+    end
+
+    def is_update_needed?
+      if self.freshness.present?
+        if self.last_transaction_time.present?
+          self.freshness <= self.last_transaction_time
+        else
+          false
+        end
+      else
+        true
+      end
+    end
+
+    def update!
+      self.freshness = Time.zone.now
+
+      Config.context_checkers.each do |checker|
+        if checker.respond_to? :check
+          checker.check(self)
+        end
+      end
+
+      self.update_name
+      self.save if self.can_be_persisted?
+    end
+
+    def subcontext_namespaces
+      self.subcontexts.pluck(:namespace).compact.uniq
+    end
+
+    def effective_contexts
+      self.parents_and_self
+    end
+
+    def effective_path
+      self.effective_contexts.map{|ctx| ctx.namespace || ""}
+    end
+
+    def effective_start_date
+      self.effective_contexts.map(&:start_date).compact.max
+    end
+
+    def effective_end_date
+      self.effective_contexts.map(&:end_date).compact.min
+    end
+
+    def opening_context
+      if self.effective_start_date.present?
+        end_date = self.effective_start_date - 1.day
+        Contexts::OpenCloseContext.new(chart: self.chart, parent: self, end_date: end_date, namespace: 'opening')
+      else
+        Contexts::EmptyContext.new(chart: self.chart, parent: self, namespace: 'opening')
+      end
+    end
+
+    def closing_context
+      if self.effective_end_date.present?
+        Contexts::OpenCloseContext.new(chart: self.chart, parent: self, end_date: self.effective_end_date, namespace: 'closing')
+      else
+        Contexts::OpenCloseContext.new(chart: self.chart, parent: self, namespace: 'closing')
+      end
+    end
+
+    def change_total
+      if self.debits_total.present? and self.credits_total.present?
+        self.debits_total - self.credits_total
+      else
+        nil
+      end
+    end
+
+    def can_be_persisted?
+      self.type.present?
+    end
+
+    protected
+
+    def validate_parent
+      if self.parent == self
+        errors[:parent] = "cannot self-reference, that would create a loop"
+      end
+    end
+
+    def default_values
+      self.chart ||= self.parent.chart if self.chart_id.nil? and not self.parent_id.nil?
+      self.namespace ||= (self.type || self.class.name).demodulize.underscore.gsub(/_context$/, '')
+    end
+
+    def update_name
+      self.name = self.create_name
+    end
+
+    def create_name
+      if self.type.nil?
+        self.chart.name unless self.chart.nil?
+      else
+        "#{self.type.demodulize} \##{self.id}"
+      end
+    end
+
+    def update_position
+      self.position = self.create_position
+    end
+
+    def create_position
+      nil
+    end
+
+    def initialize_filters
+      @filters = []
+    end
+
+    def inject_filters(relation)
+      @filters.select{|f| f.is_a? Proc}.
+      inject(relation) do |r,filter|
+        filter.call(r)
+      end
+    end
+
+    def parents_and_self
+      contexts = [self]
+      while contexts.last.parent_id.present? and 
+            not contexts.last.parent_id.in? contexts.map(&:id) and
+            contexts.count < 16 do
+        # found a valid parent
+        contexts << contexts.last.parent
+      end
+      contexts.reverse
+    end
+
+    def enforce_persistence_rule
+      if not self.can_be_persisted?
+        raise "#{self.class.name} objects are not intended to be persisted"
+      end
+    end
+  end
+end

data/app/models/esa/context_provider.rb

@@ -0,0 +1,52 @@
+module ESA
+  class ContextProvider
+    def self.provided_types
+      []
+    end
+
+    def self.check_subcontexts(context, namespace, options = {})
+      existing = existing_subcontexts(context, namespace)
+      contained = contained_subcontexts(context, namespace, existing, options)
+
+      created = contained - existing
+      created.each do |sub|
+        sub.save if sub.new_record? or sub.changed?
+      end
+
+      unregistered = contained - context.subcontexts
+      context.subcontexts += unregistered
+
+      removed = existing - contained
+      context.subcontexts -= removed
+
+      removed.each(&:destroy) if context.can_be_persisted?
+
+      contained
+    end
+
+    def self.context_id(context, options = {})
+      []
+    end
+
+    def self.contained_ids(context, options = {})
+      []
+    end
+
+    def self.existing_subcontexts(context, namespace, options = {})
+      context.subcontexts.where(type: provided_types, namespace: namespace).all
+    end
+
+    def self.contained_subcontexts(context, namespace, existing, options = {})
+      contained_ids = contained_ids(context, options)
+      existing_ids = existing.map{|sub| context_id(sub, options)}
+
+      new_ids = contained_ids - existing_ids
+
+      new_subcontexts = new_ids.map do |id|
+        instantiate(context, namespace, id, options)
+      end
+
+      new_subcontexts + existing.select{|sub| context_id(sub).in? contained_ids}
+    end
+  end
+end

data/app/models/esa/context_providers/account_context_provider.rb

@@ -0,0 +1,21 @@
+module ESA
+  module ContextProviders
+    class AccountContextProvider < ESA::ContextProvider
+      def self.provided_types
+        ["ESA::Contexts::AccountContext"]
+      end
+
+      def self.context_id(context, options = {})
+        context.account_id
+      end
+
+      def self.contained_ids(context, options = {})
+        context.amounts.pluck(:account_id).uniq
+      end
+
+      def self.instantiate(parent, namespace, id, options = {})
+        ESA::Contexts::AccountContext.new(chart_id: parent.chart_id, parent_id: parent.id, namespace: namespace, account_id: id)
+      end
+    end
+  end
+end

data/app/models/esa/context_providers/accountable_context_provider.rb

@@ -0,0 +1,22 @@
+module ESA
+  module ContextProviders
+    class AccountableContextProvider < ESA::ContextProvider
+      def self.provided_types
+        ["ESA::Contexts::AccountableContext"]
+      end
+
+      def self.context_id(context, options = {})
+        [context.accountable_id, context.accountable_type]
+      end
+
+      def self.contained_ids(context, options = {})
+        context.transactions.pluck([:accountable_id, :accountable_type]).uniq
+      end
+
+      def self.instantiate(parent, namespace, id, options = {})
+        accountable_id, accountable_type = id
+        ESA::Contexts::AccountableContext.new(chart_id: parent.chart_id, parent_id: parent.id, namespace: namespace, accountable_id: accountable_id, accountable_type: accountable_type)
+      end
+    end
+  end
+end

data/app/models/esa/context_providers/accountable_type_context_provider.rb

@@ -0,0 +1,21 @@
+module ESA
+  module ContextProviders
+    class AccountableTypeContextProvider < ESA::ContextProvider
+      def self.provided_types
+        ["ESA::Contexts::AccountableTypeContext"]
+      end
+
+      def self.context_id(context, options = {})
+        context.accountable_type
+      end
+
+      def self.contained_ids(context, options = {})
+        context.transactions.pluck(:accountable_type).uniq
+      end
+
+      def self.instantiate(parent, namespace, id, options = {})
+        ESA::Contexts::AccountableTypeContext.new(chart_id: parent.chart_id, parent_id: parent.id, namespace: namespace, accountable_type: id)
+      end
+    end
+  end
+end

data/app/models/esa/context_providers/date_context_provider.rb

@@ -0,0 +1,33 @@
+module ESA
+  module ContextProviders
+    class DateContextProvider < ESA::ContextProvider
+      def self.provided_types
+        ["ESA::Contexts::DateContext"]
+      end
+
+      def self.context_id(context, options = {})
+        [context.start_date, context.end_date]
+      end
+
+      def self.contained_ids(context, options = {})
+        dates = context.transactions.pluck("date(esa_transactions.time)").uniq.sort
+
+        if options[:period].present? and options[:period] == :month
+          dates.group_by{|d| [d.year, d.month]}.keys.
+          map do |year,month|
+            start_date = Date.new(year, month, 1)
+            end_date = start_date.end_of_month
+            [start_date, end_date]
+          end
+        else
+          dates.zip dates
+        end
+      end
+
+      def self.instantiate(parent, namespace, id, options = {})
+        start_date, end_date = id
+        ESA::Contexts::DateContext.new(chart_id: parent.chart_id, parent_id: parent.id, namespace: namespace, start_date: start_date, end_date: end_date)
+      end
+    end
+  end
+end

data/app/models/esa/contexts/account_context.rb

@@ -0,0 +1,26 @@
+module ESA
+  module Contexts
+    class AccountContext < ESA::Context
+      attr_accessible :account, :account_id
+      attr_readonly   :account, :account_id
+
+      belongs_to :account
+
+      validates_presence_of :account
+
+      protected
+
+      def create_name
+        self.account.name unless self.account.nil?
+      end
+
+      def create_position
+        self.account.code.gsub(/[^0-9]/, '').to_i unless self.account.nil? or self.account.code.nil?
+      end
+
+      def initialize_filters
+        @filters = [lambda { |relation| relation.with_account(self.account_id) }]
+      end
+    end
+  end
+end

data/app/models/esa/contexts/accountable_context.rb

@@ -0,0 +1,26 @@
+module ESA
+  module Contexts
+    class AccountableContext < ESA::Context
+      attr_accessible :accountable, :accountable_id, :accountable_type
+      attr_readonly   :accountable, :accountable_id, :accountable_type
+
+      belongs_to :accountable, :polymorphic => true
+
+      validates_presence_of :accountable
+
+      protected
+
+      def create_name
+        "#{self.accountable_type} #{self.accountable_id}" unless self.accountable_type.nil?
+      end
+
+      def initialize_filters
+        @filters = []
+
+        if self.accountable_id.present? and self.accountable_type.present?
+          @filters << lambda { |relation| relation.with_accountable(self.accountable_id, self.accountable_type) }
+        end
+      end
+    end
+  end
+end

data/app/models/esa/contexts/accountable_type_context.rb

@@ -0,0 +1,24 @@
+module ESA
+  module Contexts
+    class AccountableTypeContext < ESA::Context
+      attr_accessible :accountable_type
+      attr_readonly   :accountable_type
+
+      validates_presence_of :accountable_type
+
+      protected
+
+      def create_name
+        "#{self.accountable_type} accountables" unless self.accountable_type.nil?
+      end
+
+      def initialize_filters
+        @filters = []
+
+        if self.accountable_type.present?
+          @filters << lambda { |relation| relation.with_accountable_type(self.accountable_type) }
+        end
+      end
+    end
+  end
+end

data/app/models/esa/contexts/created_at_context.rb

@@ -0,0 +1,26 @@
+module ESA
+  module Contexts
+    class CreatedAtContext < ESA::Context
+      def created_at
+        @created_at
+      end
+
+      def created_at=(timespec)
+        @created_at = timespec
+        @filters = [lambda { |relation| relation.where(created_at: timespec) }]
+      end
+
+      def effective_path
+        if self.parent_id.blank?
+          []
+        else
+          self.parent.effective_path
+        end
+      end
+
+      def can_be_persisted?
+        false
+      end
+    end
+  end
+end

data/app/models/esa/contexts/date_context.rb

@@ -0,0 +1,71 @@
+module ESA
+  module Contexts
+    class DateContext < ESA::Context
+      attr_accessible :start_date, :end_date
+      attr_readonly   :start_date, :end_date
+
+      validate :validate_dates
+
+      def preceeding_context
+        if self.start_date.present?
+          DateContext.new chart: self.chart,
+                          end_date: self.start_date - 1.day
+        else
+          nil
+        end
+      end
+
+      def following_context
+        if self.end_date.present?
+          DateContext.new chart: self.chart,
+                          start_date: self.end_date + 1.day
+        else
+          nil
+        end
+      end
+
+      protected
+
+      def validate_dates
+        if self.start_date.nil? and self.end_date.nil?
+          errors[:start_date] = "at least one of the two dates must be provided"
+          errors[:end_date] = "at least one of the two dates must be provided"
+        end
+      end
+
+      def create_name
+        if self.start_date.present? and self.end_date.present?
+          if self.start_date == self.end_date
+            "#{self.start_date.to_s}"
+          else
+            "#{self.start_date.to_s} - #{self.end_date.to_s}"
+          end
+        elsif self.start_date.present?
+          "#{self.start_date.to_s} - ..."
+        elsif self.end_date.present?
+          "... - #{self.end_date.to_s}"
+        end
+      end
+
+      def create_position
+        if self.start_date.present?
+          self.start_date.to_time.to_i
+        elsif self.end_date.present?
+          self.end_date.to_time.to_i
+        end
+      end
+
+      def initialize_filters
+        @filters = []
+
+        if self.start_date.present? and self.end_date.present?
+          @filters << lambda { |relation| relation.between_dates(self.start_date, self.end_date) }
+        elsif self.start_date.present?
+          @filters << lambda { |relation| relation.with_date_gte(self.start_date) }
+        elsif self.end_date.present?
+          @filters << lambda { |relation| relation.with_date_lte(self.end_date) }
+        end
+      end
+    end
+  end
+end

data/app/models/esa/contexts/empty_context.rb

@@ -0,0 +1,19 @@
+module ESA
+  module Contexts
+    class EmptyContext < ESA::Context
+      def effective_contexts
+        [self]
+      end
+
+      protected
+
+      def create_name
+        "Empty"
+      end
+
+      def initialize_filters
+        @filters = [lambda { |relation| relation.where('1=0') }]
+      end
+    end
+  end
+end

data/app/models/esa/contexts/filter_context.rb

@@ -0,0 +1,11 @@
+module ESA
+  module Contexts
+    class FilterContext < ESA::Context
+      attr_accessor :filters
+
+      def can_be_persisted?
+        false
+      end
+    end
+  end
+end

data/app/models/esa/contexts/open_close_context.rb

@@ -0,0 +1,15 @@
+module ESA
+  module Contexts
+    class OpenCloseContext < DateContext
+      def effective_contexts
+        self.parents_and_self.reject{|ctx| ctx.type == DateContext.to_s}
+      end
+
+      protected
+
+      def validate_dates
+        # OpenCloseContext can be initialized with no dates
+      end
+    end
+  end
+end

data/app/models/esa/event.rb

@@ -0,0 +1,33 @@
+module ESA
+  # The Event class represents an event of significance to accounting,
+  # which triggers the creation of Flags, which in turn create Transactions.
+  #
+  # @author Lenno Nagel
+  class Event < ActiveRecord::Base
+    include Traits::Extendable
+    extend ::Enumerize
+
+    attr_accessible :time, :nature, :accountable, :ruleset
+    attr_readonly   :time, :nature, :accountable, :ruleset
+
+    belongs_to :accountable, :polymorphic => true
+    belongs_to :ruleset
+    has_many   :flags
+    has_many   :transactions, :through => :flags
+    has_many   :amounts, :through => :transactions, :extend => Associations::AmountsExtension
+
+    enumerize :nature, in: [:unknown, :adjustment]
+
+    after_initialize :default_values
+    validates_presence_of :time, :nature, :accountable, :ruleset
+    validates_inclusion_of :processed, :in => [true, false]
+
+    private
+
+    def default_values
+      self.time ||= Time.zone.now if self.time.nil?
+      self.ruleset ||= Ruleset.extension_instance(self.accountable) if self.ruleset_id.nil? and not self.accountable_id.nil?
+      self.processed ||= false
+    end
+  end
+end

data/app/models/esa/filters/account_filter.rb

@@ -0,0 +1,42 @@
+module ESA
+  module Filters
+    module AccountFilter
+      module FlagTransactionAmountAccount
+        extend ActiveSupport::Concern
+
+        included do
+          scope :with_account, lambda { |account| joins(:flags => {:transactions => :amounts}).where(esa_amounts: {account_id: account}) }
+        end
+      end
+
+      module TransactionAmountAccount
+        extend ActiveSupport::Concern
+
+        included do
+          scope :with_account, lambda { |account| joins(:transactions => :amounts).where(esa_amounts: {account_id: account}) }
+        end
+      end
+
+      module AmountAccount
+        extend ActiveSupport::Concern
+
+        included do
+          scope :with_account, lambda { |account| joins(:amounts).where(esa_amounts: {account_id: account}) }
+        end
+      end
+
+      module ObjectAccount
+        extend ActiveSupport::Concern
+
+        included do
+          scope :with_account, lambda { |account| where(account_id: account) }
+        end
+      end
+    end
+  end
+end
+
+ESA::Amount.send :include, ESA::Filters::AccountFilter::ObjectAccount
+ESA::Event.send :include, ESA::Filters::AccountFilter::FlagTransactionAmountAccount
+ESA::Flag.send :include, ESA::Filters::AccountFilter::TransactionAmountAccount
+ESA::Transaction.send :include, ESA::Filters::AccountFilter::AmountAccount