subledger 0.7.7

data/lib/subledger/domain/journal_entry.rb

@@ -0,0 +1,293 @@
+module Subledger
+  module Domain
+    class JournalEntryError < Error; end
+
+    class JournalEntry
+
+      include Domain
+
+      include Roles::Attributable
+      include Roles::Describable
+      include Roles::Identifiable
+      include Roles::Storable
+      include Roles::Timeable
+      include Roles::Versionable
+
+      include Roles::Creatable
+      include Roles::Readable
+      include Roles::Updatable
+
+      include Roles::Progressable
+      include Roles::Collectable
+
+      include Roles::Restable
+
+      attr_reader :org, :book, :post_delay
+
+      attr_accessor :effective_at
+
+      def self.post_keys
+        [ :effective_at, :description, :reference ]
+      end
+
+      def self.patch_keys
+        [ :id, :effective_at, :description, :reference, :version ]
+      end
+
+      def self.root_klass
+        JournalEntry
+      end
+
+      def self.sub_klasses
+        [ active_klass, archived_klass, posting_klass, posted_klass ]
+      end
+
+      def self.active_klass
+        ActiveJournalEntry
+      end
+
+      def self.archived_klass
+        ArchivedJournalEntry
+      end
+
+      def self.posting_klass
+        PostingJournalEntry
+      end
+
+      def self.posted_klass
+        PostedJournalEntry
+      end
+
+      def self.create_and_post args
+        begin
+          client = args[:client]
+
+          active_journal_entry = client.active_journal_entry args
+
+          JournalEntry.send :validate_creatability, active_journal_entry.attributes
+
+          order = 1
+
+          arg_lines = args[:lines]
+
+          arg_lines.each do |line_args|
+            if line_args[:description].nil?
+              line_args.merge! :description => active_journal_entry.description
+            end
+
+            if line_args[:reference].nil?
+              line_args.merge! :reference => active_journal_entry.reference
+            end
+
+            line_args.merge! :order => '%07.2f' % order
+
+            order += 1
+          end
+
+          store = args[:store]
+
+          active_lines = []
+
+          arg_lines.each do |line_args|
+            line_args.merge! :journal_entry => active_journal_entry
+
+            line = client.active_line line_args.merge( :id => UUID.as_string )
+
+            Line.send :raise_unless_create_and_postable, line.attributes
+            Line.send :validate_creatability_modules, line.attributes
+
+            active_lines << line
+          end
+
+          store.create_and_post(
+                  :active_journal_entry  => active_journal_entry,
+                  :active_lines          => active_lines,
+                  :posting_journal_entry => client.posting_journal_entry( { } ) )
+
+        rescue Exception => e
+          raise JournalEntryError, "Cannot create and post: #{e}"
+        end
+      end
+
+      def initialize args
+        describable args
+        identifiable args
+        storable args
+        versionable args
+
+        @org          = args[:org]
+        @book         = args[:book]
+        @effective_at = utc_or_nil args[:effective_at]
+        @post_delay   = args[:post_delay] || 0
+
+        @reason = args[:reason] if args.has_key? :reason
+      end
+
+      def line args
+        client.lines args.merge( :journal_entry => self )
+      end
+
+      def lines args={ }, &block
+        args.merge! :action        => args[:action] || :starting,
+                    :state         => args[:state]  || line_state,
+                    :order         => args[:order]  || '0',
+                    :journal_entry => self
+
+        client.lines.collect args, &block
+      end
+
+      def balance
+        store.journal_entry_balance :store         => store,
+                                    :client        => client,
+                                    :journal_entry => self,
+                                    :state         => line_state
+      end
+
+      def balanced?
+        balance.balanced?
+      end
+
+      class Entity < Grape::Entity
+        root 'journal_entries', 'journal_entry'
+
+        expose :id,           :documentation => { :type => 'string',  :desc => 'journal entry ID' }
+
+        expose :book,         :format_with   => :id,
+                              :documentation => { :type => 'string',  :desc => 'book ID' }
+
+        expose :effective_at, :format_with   => :time,
+                              :documentation => { :type => 'string',  :desc => 'effective at date' }
+
+        expose :description,  :documentation => { :type => 'string',  :desc => 'description' }
+
+        expose :reference,    :documentation => { :type => 'string',  :desc => 'reference URI' }
+
+        expose :version,      :documentation => { :type => 'integer', :desc => 'version' }
+      end
+
+      private
+
+      def self.raise_unless_creatable args
+        book = args[:book]
+
+        if book.nil? or not book.kind_of? Book
+          raise JournalEntryError, ':book is required and must be a Book'
+        elsif UUID.invalid? book.id
+          raise JournalEntryError, ':book must have a valid :id'
+        end
+
+        effective_at = args[:effective_at]
+
+        if effective_at.nil? or not effective_at.kind_of? Time
+          raise JournalEntryError, ':effective_at is required and must be a Time'
+        end
+      end
+
+      def line_state
+        :active
+      end
+    end
+
+    class ArchivedJournalEntry < JournalEntry
+      include Roles::Activatable
+      include Roles::Archivable
+
+      class Entity < JournalEntry::Entity
+        root 'archived_journal_entries', 'archived_journal_entry'
+      end
+
+      def self.sub_klasses
+        [ archived_klass ]
+      end
+    end
+
+    class ActiveJournalEntry < JournalEntry
+
+      include Roles::Postable
+      include Roles::Activatable
+      include Roles::Archivable
+
+      attr_reader :reason
+
+      class Entity < JournalEntry::Entity
+        root 'active_journal_entries', 'active_journal_entry'
+
+        expose :reason
+      end
+
+      def self.sub_klasses
+        [ active_klass ]
+      end
+
+      def create_line args
+        args.merge! :client        => client,
+                    :journal_entry => self,
+                    :effective_at  => effective_at
+
+        Line.raise_on_duplicate_orders args
+
+        client.active_lines.validate_creatability args
+
+        active_line = client.active_lines args
+
+        store.create_line :line => active_line
+      end
+
+      private
+
+      def set_reason reason
+        @reason = reason
+      end
+    end
+
+    class PostingJournalEntry < JournalEntry
+      include Roles::Postable
+
+      class Entity < JournalEntry::Entity
+        root 'posting_journal_entries', 'posting_journal_entry'
+      end
+
+      def self.sub_klasses
+        [ posting_klass ]
+      end
+
+      def self.update args
+        raise JournalEntryError, 'posting journal entries are not updatable'
+      end
+
+      def update
+        self.class.update( { } )
+      end
+
+      def balance
+        raise JournalEntryError, 'cannot call balance on a PostingJournalEntry'
+      end
+    end
+
+    class PostedJournalEntry < JournalEntry
+      include Roles::Postable
+
+      class Entity < JournalEntry::Entity
+        root 'posted_journal_entries', 'posted_journal_entry'
+      end
+
+      def self.sub_klasses
+        [ posted_klass ]
+      end
+
+      def self.update args
+        raise JournalEntryError, 'posted journal entries are not updatable'
+      end
+
+      def update
+        self.class.update( { } )
+      end
+
+      private
+
+      def line_state
+        :posted
+      end
+    end
+  end
+end

data/lib/subledger/domain/key.rb

@@ -0,0 +1,113 @@
+module Subledger
+  module Domain
+    class KeyError < Error; end
+
+    class Key
+
+      include Domain
+
+      include Roles::Attributable
+      include Roles::Identifiable
+      include Roles::Storable
+
+      include Roles::Creatable
+      include Roles::Readable
+      include Roles::Collectable
+
+      include Roles::Activatable
+      include Roles::Archivable
+
+      include Roles::Restable
+
+      attr_reader :identity, :secret
+
+      def self.post_keys
+        [ :id, :identity ]
+      end
+
+      def self.root_klass
+        Key
+      end
+
+      def self.sub_klasses
+        [ archived_klass, active_klass ]
+      end
+
+      def self.active_klass
+        ActiveKey
+      end
+
+      def self.archived_klass
+        ArchivedKey
+      end
+
+      def initialize args
+        identifiable args
+        storable args
+
+        @identity = args[:identity]
+
+        # TODO separate new and create
+
+        if args[:bcrypt].nil?
+          @secret = args[:secret] || UUID.as_string
+
+          @bcrypt = BCrypt::Password.create( @secret, :cost => 5 )
+        elsif args[:bcrypt]
+          @secret = args[:secret]
+
+          @bcrypt = BCrypt::Password.new args[:bcrypt]
+        end
+      end
+
+      def authenticates? this_secret
+        bcrypt == this_secret
+      end
+
+      class Entity < Grape::Entity
+        root 'keys', 'key'
+
+        expose :id,       :documentation => { :type => 'string',  :desc => 'key ID' }
+
+        expose :identity, :format_with => :id,
+                          :documentation => { :type => 'string',  :desc => 'identity ID' }
+
+        expose :secret,   :documentation => { :type => 'string',  :desc => 'key secret' }
+      end
+
+      private
+
+      attr_reader :bcrypt
+
+      def self.raise_unless_creatable args
+        identity = args[:identity]
+
+        if identity.nil? or not identity.kind_of? Identity
+          raise KeyError, ':identity is required and must be an Identity'
+        elsif UUID.invalid? identity.id
+          raise KeyError, ':identity must have a valid :id'
+        end
+      end
+    end
+
+    class ArchivedKey < Key
+      class Entity < Key::Entity
+        root 'archived_keys', 'archived_key'
+      end
+
+      def self.sub_klasses
+        [ archived_klass ]
+      end
+    end
+
+    class ActiveKey < Key
+      class Entity < Key::Entity
+        root 'active_keys', 'active_key'
+      end
+
+      def self.sub_klasses
+        [ active_klass ]
+      end
+    end
+  end
+end

data/lib/subledger/domain/line.rb

@@ -0,0 +1,272 @@
+module Subledger
+  module Domain
+    class LineError < Error; end
+
+    class Line
+
+      include Domain::Value
+      include Domain
+
+      include Roles::Attributable
+      include Roles::Describable
+      include Roles::Identifiable
+      include Roles::Storable
+      include Roles::Timeable
+      include Roles::Versionable
+
+      include Roles::Creatable
+      include Roles::Readable
+
+      include Roles::Collectable
+
+      include Roles::Restable
+
+      attr_reader   :journal_entry
+      attr_accessor :account, :value, :order
+
+      def self.root_klass
+        Line
+      end
+
+      def self.sub_klasses
+        [ archived_klass, active_klass, posted_klass ]
+      end
+
+      def self.archived_klass
+        ArchivedLine
+      end
+
+      def self.active_klass
+        ActiveLine
+      end
+
+      def self.posted_klass
+        PostedLine
+      end
+
+      def self.update args
+        raise_on_duplicate_orders args
+
+        super
+      end
+
+      def self.specialized_raise_unless_creatable args
+      end
+
+      def initialize args
+        describable args
+        identifiable args
+        storable args
+        versionable args
+
+        @journal_entry = args[:journal_entry]
+        @account       = args[:account]
+        @value         = args[:value]
+        @order         = args[:order]
+
+        specialized_initialization args
+      end
+
+      def amount
+        value.amount
+      end
+
+      class Entity < Grape::Entity
+        root 'lines', 'line'
+
+        expose :id,            :documentation => { :type => 'string',  :desc => 'line ID' }
+
+        expose :journal_entry, :format_with   => :id,
+                               :documentation => { :type => 'string',  :desc => 'journal entry ID' }
+
+        expose :account,       :format_with   => :id,
+                               :documentation => { :type => 'string',  :desc => 'account ID' }
+
+        expose :description,   :documentation => { :type => 'string',  :desc => 'description' }
+
+        expose :reference,     :documentation => { :type => 'string',  :desc => 'reference URI' }
+
+        expose :value,         :format_with   => :value,
+                               :documentation => { :type => 'string',  :desc => 'value' }
+
+        expose :order,         :documentation => { :type => 'string',  :desc => 'order' }
+
+        expose :version,       :documentation => { :type => 'integer', :desc => 'version' }
+      end
+
+      private
+
+      def self.specialized_keys
+        []
+      end
+
+      def self.raise_on_duplicate_orders args
+        client = args[:client]
+
+        journal_entry = client.journal_entry :id => args[:journal_entry].id
+
+        order = BigDecimal args[:order]
+
+        journal_entry.lines.each do |line|
+          if order == BigDecimal( line.order )
+            raise LineError, "lines must have unique orders: #{args[:orders]}"
+          end
+        end
+      end
+
+      def self.raise_unless_creatable args
+        raise_on_duplicate_orders args
+
+        raise_unless_create_and_postable args
+
+        journal_entry = args[:journal_entry]
+
+        if UUID.invalid? journal_entry.id
+          raise LineError, ':journal_entry must have a valid :id'
+        end
+      end
+
+      def self.raise_unless_create_and_postable args
+        journal_entry = args[:journal_entry]
+
+        if journal_entry.nil? or not journal_entry.kind_of? JournalEntry
+          raise LineError, ':journal_entry is required and must be a JournalEntry'
+        end
+
+        account = args[:account]
+
+        if account.nil? or not account.kind_of? Account
+          raise LineError, ':account is required and must be an Account'
+        elsif UUID.invalid? account.id
+          raise LineError, ':account must have a valid :id'
+        end
+
+        value = args[:value]
+
+        if value.nil? or not value.kind_of? Value
+          raise LineError, ':value is required and must be a Value'
+        end
+
+        order = args[:order]
+
+        if order.nil? or
+           order !~ /^\d{1,4}[.]?\d{0,2}$/
+          raise LineError, ':order is required and in the form [###]#[.##]'
+        end
+
+        bd_order = BigDecimal order
+
+        if bd_order <= 0 or bd_order >= 10_000
+          raise LineError, ':order must be > 0 and < 10,000'
+        end
+
+        specialized_raise_unless_creatable args
+      end
+
+      def specialized_initialization args
+      end
+    end
+
+    class ArchivedLine < Line
+
+      include Roles::Updatable
+      include Roles::Archivable
+      include Roles::Activatable
+
+      class Entity < Line::Entity
+        root 'archived_lines', 'archived_line'
+      end
+
+      def self.sub_klasses
+        [ archived_klass ]
+      end
+
+      def self.post_keys
+        [ :account, :journal_entry, :description, :reference, :value, :order ]
+      end
+
+      def self.patch_keys
+        [ :id, :account, :description, :reference, :value, :order, :version ]
+      end
+
+      def posted?
+        false
+      end
+    end
+
+    class ActiveLine < Line
+
+      include Roles::Updatable
+      include Roles::Archivable
+      include Roles::Activatable
+
+      class Entity < Line::Entity
+        root 'active_lines', 'active_line'
+      end
+
+      def self.sub_klasses
+        [ active_klass ]
+      end
+
+      def self.post_keys
+        [ :account, :journal_entry, :description, :reference, :value, :order ]
+      end
+
+      def self.patch_keys
+        [ :id, :account, :description, :reference, :value, :order, :version ]
+      end
+
+      def posted?
+        false
+      end
+    end
+
+    class PostedLineError < Error; end
+
+    class PostedLine < Line
+      attr_reader :effective_at, :posted_at, :balance
+
+      class Entity < Line::Entity
+        root 'posted_lines', 'posted_line'
+
+        expose :effective_at, :format_with   => :time,
+                              :documentation => { :type => 'string',  :desc => 'effective time' }
+
+        expose :posted_at,    :format_with   => :time,
+                              :documentation => { :type => 'string',  :desc => 'posted time' }
+
+        expose :balance,      :format_with   => :balance
+      end
+
+      def self.sub_klasses
+        [ posted_klass ]
+      end
+
+      def posted?
+        true
+      end
+
+      private
+
+      attr_writer :balance
+
+      def self.specialized_raise_unless_creatable args
+        effective_at = args[:effective_at]
+
+        if effective_at.nil? or not effective_at.kind_of? Time
+          raise PostedLineError, ':effective_at is required and must be a Time'
+        end
+
+        if args[:posted_at].nil?
+          raise PostedLineError, ':posted_at is required'
+        end
+      end
+
+      def specialized_initialization args
+        @effective_at = utc_or_nil args[:effective_at]
+        @posted_at    = utc_or_nil args[:posted_at]
+        @balance      = args[:balance]
+      end
+    end
+  end
+end