subledger 0.7.7

data/lib/subledger/domain/org.rb

@@ -0,0 +1,110 @@
+module Subledger
+  module Domain
+    class OrgError < Error; end
+
+    class Org
+
+      include Domain
+
+      include Roles::Attributable
+      include Roles::Describable
+      include Roles::Identifiable
+      include Roles::Storable
+      include Roles::Versionable
+
+      include Roles::Creatable
+      include Roles::Readable
+      include Roles::Updatable
+
+      include Roles::Activatable
+      include Roles::Archivable
+
+      include Roles::Restable
+
+      attr_accessor :bucket_name
+
+      def self.root_klass
+        Org
+      end
+
+      def self.post_keys
+        [ :description, :reference, :bucket_name ]
+      end
+
+      def self.patch_keys
+        [ :id, :description, :reference, :bucket_name, :version ]
+      end
+
+      def self.sub_klasses
+        [ active_klass, archived_klass ]
+      end
+
+      def self.active_klass
+        ActiveOrg
+      end
+
+      def self.archived_klass
+        ArchivedOrg
+      end
+
+      def self.create args
+        org = super
+
+        args[:store].add_initial_controls_for org
+
+        org
+      end
+
+      def initialize args
+        describable args
+        identifiable args
+        storable args
+        versionable args
+
+        @bucket_name = args[:bucket_name]
+      end
+
+      class Entity < Grape::Entity
+        root 'orgs', 'org'
+
+        expose :id,          :documentation => { :type => 'string',  :desc => 'org ID' }
+
+        expose :description, :documentation => { :type => 'string',  :desc => 'description' }
+
+        expose :reference,   :documentation => { :type => 'string',  :desc => 'reference URI' }
+
+        expose :bucket_name, :documentation => { :type => 'string',  :desc => 'backup URI' }
+
+        expose :version,     :documentation => { :type => 'integer', :desc => 'version' }
+      end
+
+      private
+
+      def self.raise_unless_creatable args
+        store = args[:store]
+
+        store.raise_unless_bucket_name_valid args
+      end
+    end
+
+    class ArchivedOrg < Org
+      class Entity < Org::Entity
+        root 'archived_orgs', 'archived_org'
+      end
+
+      def self.sub_klasses
+        [ archived_klass ]
+      end
+    end
+
+    class ActiveOrg < Org
+      class Entity < Org::Entity
+        root 'active_orgs', 'active_org'
+      end
+
+      def self.sub_klasses
+        [ active_klass ]
+      end
+    end
+  end
+end

data/lib/subledger/domain/report.rb

@@ -0,0 +1,247 @@
+module Subledger
+  module Domain
+    class ReportError < Error; end
+
+    class Report
+
+      include Domain
+
+      include Roles::Attributable
+      include Roles::Describable
+      include Roles::Identifiable
+      include Roles::Storable
+      include Roles::Versionable
+
+      include Roles::Creatable
+      include Roles::Readable
+      include Roles::Updatable
+
+      include Roles::Collectable
+
+      include Roles::Activatable
+      include Roles::Archivable
+
+      include Roles::Restable
+
+      attr_reader :book
+
+      def self.post_keys
+        [ :description, :reference ]
+      end
+
+      def self.patch_keys
+        [ :id, :description, :reference, :version ]
+      end
+
+      def self.root_klass
+        Report
+      end
+
+      def self.sub_klasses
+        [ active_klass, archived_klass ]
+      end
+
+      def self.active_klass
+        ActiveReport
+      end
+
+      def self.archived_klass
+        ArchivedReport
+      end
+
+      def initialize args
+        describable args
+        identifiable args
+        storable args
+        versionable args
+
+        @book = args[:book]
+      end
+
+      class Entity < Grape::Entity
+        root 'reports', 'report'
+
+        expose :id,          :documentation => { :type => 'string',  :desc => 'report ID' }
+
+        expose :book,        :format_with   => :id,
+                             :documentation => { :type => 'string',  :desc => 'book ID' }
+
+        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 BookError, ':book is required and must be a Book'
+        elsif UUID.invalid? book.id
+          raise BookError, ':book must have a valid :id'
+        end
+      end
+
+      def structure
+        store.report_structure_for self
+      end
+    end
+
+    class ArchivedReport < Report
+      class Entity < Report::Entity
+        root 'archived_reports', 'archived_report'
+      end
+
+      def self.sub_klasses
+        [ archived_klass ]
+      end
+    end
+
+    class ActiveReport < Report
+      class Entity < Report::Entity
+        root 'active_reports', 'active_report'
+      end
+
+      def self.sub_klasses
+        [ active_klass ]
+      end
+
+      def categories &block
+        begin
+          store.collect_categories_for_report self, &block
+        rescue Store::CollectError => e
+          raise ReportError, e
+        end
+      end
+
+      def attach args
+        validate_attach args
+
+        category = args[:category]
+        parent   = args[:parent]
+
+        if category.nil? or category.id.nil?
+          raise ReportError, ':category is required and must have an id'
+        end
+
+        if not parent.nil? and parent.id.nil?
+          raise ReportError, ':parent must have an id'
+        end
+
+        begin
+          store.attach_category_to_report :report   => self,
+                                          :category => category,
+                                          :parent   => parent
+        rescue Store::AttachError => e
+          raise ReportError, e
+        end
+
+        category
+      end
+
+      def detach args
+        category = args[:category]
+
+        if category.nil? or category.id.nil?
+          raise ReportError, ':category is required and must have an id'
+        end
+
+        begin
+          store.detach_category_from_report :report   => self,
+                                            :category => category
+        rescue Store::DetachError => e
+          raise ReportError, e
+        end
+
+        category
+      end
+
+      def render args
+        at = args[:at]
+
+        if at.nil? or not at.kind_of? Time
+          raise ReportError, ':at is required and must be a Time'
+        end
+
+        building_report_rendering = client.building_report_rendering :effective_at => at,
+                                                                     :report       => self
+
+        store.render args.merge! :building_report_rendering => building_report_rendering
+      end
+
+      private
+
+      def add_categories_to report_hash, sub_structure, effective_at
+        categories_hash = report_hash[:categories] = { }
+
+        categories_balance = Balance.new
+
+        sub_structure.each do |category, category_hash|
+          categories_hash[category.id] = category.serializable_hash
+
+          category_balance = add_categories_to categories_hash[category.id], category_hash, effective_at
+
+          category_balance += add_accounts_to categories_hash[category.id], category, effective_at
+
+          categories_hash[category.id][:balance] = category_balance.serializable_hash
+
+          categories_balance += category_balance
+        end
+
+        categories_balance
+      end
+
+      def add_accounts_to report_category_hash, category, effective_at
+        accounts_hash = report_category_hash[:accounts] = { }
+
+        accounts_balance = Balance.new
+
+        category.accounts.each do |account|
+          accounts_hash[account.id] = account.serializable_hash
+
+          account_balance = add_balance_to accounts_hash[account.id], account, effective_at
+
+          accounts_balance += account_balance
+        end
+
+        accounts_balance
+      end
+
+      def add_balance_to report_category_account_hash, account, effective_at
+        balance = account.balance :at => effective_at
+
+        report_category_account_hash[:balance] = balance.serializable_hash
+
+        balance
+      end
+
+      def validate_attach args
+        if UUID.invalid? id
+          raise ReportError, ':report must have a valid :id'
+        end
+
+        category = args[:category]
+
+        if category.nil? or not category.kind_of? Category
+          raise ReportError, ':category is required and must be a Category'
+        elsif UUID.invalid? category.id
+          raise ReportError, ':category must have a valid :id'
+        end
+
+        parent = args[:parent]
+
+        unless parent.nil?
+          if not parent.kind_of? Category
+            raise ReportError, ':parent must be a Category'
+          elsif UUID.invalid? parent.id
+            raise ReportError, ':parent must have a valid :id'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/subledger/domain/report_rendering.rb

@@ -0,0 +1,233 @@
+module Subledger
+  module Domain
+    class ReportRenderingError < Error; end
+
+    class ReportRendering
+
+      include Domain
+
+      include Roles::Attributable
+      include Roles::DescribableReportRendering
+      include Roles::Identifiable
+      include Roles::Storable
+      include Roles::Timeable
+
+      include Roles::Creatable
+      include Roles::Readable
+
+      include Roles::Collectable
+
+      include Roles::Restable
+
+      attr_reader :book, :report, :effective_at, :rendered_at,
+                  :balanced_accounts, :total_accounts
+
+      def self.post_keys
+        [ :description, :reference, :report, :effective_at ]
+      end
+
+      def self.root_klass
+        ReportRendering
+      end
+
+      def self.sub_klasses
+        [ building_klass, completed_klass ]
+      end
+
+      def self.building_klass
+        BuildingReportRendering
+      end
+
+      # TODO create uses active_klass, should use creation_klass
+      def self.active_klass
+        building_klass
+      end
+
+      def self.completed_klass
+        CompletedReportRendering
+      end
+
+      def initialize args
+        describable_report_rendering args
+        identifiable args
+        storable args
+
+        @book              = args[:book]
+        @report            = args[:report]
+        @effective_at      = round args[:effective_at]
+        @rendered_at       = utc_or_now args[:rendered_at]
+
+        @balanced_accounts = args[:balanced_accounts] || 0
+        @total_accounts    = args[:total_accounts]    || 0
+
+        specialized_initialization args
+      end
+
+      def progress
+        if total_accounts.zero?
+          0
+        else
+          ( ( balanced_accounts.to_f / total_accounts ) * 99 ).to_i
+        end
+      end
+
+      class Entity < Grape::Entity
+        root 'report_renderings', 'report_rendering'
+
+        expose :id
+        expose :book,           :format_with => :id
+        expose :report,         :format_with => :id
+        expose :description
+        expose :reference
+        expose :effective_at,   :format_with => :time_full_second
+        expose :total_accounts, :format_with => :integer
+        expose :progress,       :format_with => :progress
+        expose :rendered_at,    :format_with => :time
+      end
+
+      private
+
+      def self.raise_unless_creatable args
+
+        book = args[:book]
+
+        if book.nil? or not book.kind_of? Book
+          raise ReportRenderingError, ':book is required and must be a Book'
+        elsif UUID.invalid? book.id
+          raise ReportRenderingError, ':book must have a valid :id'
+        end
+
+        report = args[:report]
+
+        if report.nil? or not report.kind_of? Report
+          raise ReportRenderingError, ':report is required and must be a Report'
+        elsif UUID.invalid? report.id
+          raise ReportRenderingError, ':report must have a valid :id'
+        end
+
+        effective_at = args[:effective_at]
+
+        if effective_at.nil? or not effective_at.kind_of? Time
+          raise ReportRenderingError, ':effective_at is required and must be a Time'
+        end
+      end
+
+      def round effective_at
+        Time.at( utc_or_nil( effective_at ).to_i ).utc
+      end
+
+      TOTAL_ACCOUNTS_SEMAPHORE = Mutex.new
+
+      def increase_total_accounts_by count
+        TOTAL_ACCOUNTS_SEMAPHORE.synchronize do
+          @total_accounts += count
+        end
+      end
+
+      BALANCED_ACCOUNTS_SEMAPHORE = Mutex.new
+
+      def increase_balanced_accounts_by count
+        BALANCED_ACCOUNTS_SEMAPHORE.synchronize do
+          @balanced_accounts += count
+        end
+      end
+
+      def specialized_initialization args
+      end
+    end
+
+    class BuildingReportRendering < ReportRendering
+      class Entity < ReportRendering::Entity
+        root 'building_report_renderings', 'building_report_rendering'
+      end
+
+      def self.sub_klasses
+        [ building_klass ]
+      end
+
+      # TODO this should probably move to Domain module
+
+      def to_json
+        MultiJson.dump serializable_hash
+      end
+
+      private
+
+      def complete args
+        store.send :become, :becomable  => self,
+                            :klass      => self.class.completed_klass,
+                            :extra_args => args
+      end
+    end
+
+    class CompletedReportRendering < ReportRendering
+      attr_reader :completed_at, :categories, :balance, :warnings
+
+      def self.sub_klasses
+        [ completed_klass ]
+      end
+
+      def progress
+        100
+      end
+
+      def to_json
+        @json ||= if location[0..4] == 's3://'
+                    ExceptionHandler.new( :name => 'completed_report_rendering to_json' ).with_retry do
+                      s3_bucket.objects[id].read
+                    end
+                  elsif location[0..6] == 'file://'
+                    File.open( location[7..-1], 'r' ).read
+                  else
+                    raise ReportRenderingError, "unknown URL scheme: #{location}"
+                  end
+      end
+
+      def categories
+        @categories ||= as_hash['categories']
+      end
+
+      def balance
+        balance_hash = { 'balance' => as_hash['balance'] }
+
+        @balance ||= Rest.to_balance balance_hash, client
+      end
+
+      def warnings
+        @warnings ||= as_hash['warnings']
+      end
+
+      class Entity < ReportRendering::Entity
+        root 'completed_report_renderings', 'completed_report_rendering'
+
+        expose :completed_at, :format_with => :time
+        expose :categories
+        expose :balance,      :format_with => :balance
+        expose :warnings
+      end
+
+      private
+
+      attr_reader :location
+
+      def s3_bucket
+        @s3_bucket ||= Store::Aws.s3_client.buckets[RENDERED_REPORTS_BUCKET]
+      end
+
+      def as_hash
+        @hash ||= MultiJson.load to_json
+      end
+
+      def specialized_initialization args
+        @completed_at = utc_or_nil args[:completed_at]
+        @location     = args[:location]
+        @json         = args[:json]
+
+        @balance      = nil
+        @categories   = nil
+        @hash         = nil
+        @warnings     = nil
+      end
+    end
+  end
+end

data/lib/subledger/domain/roles/activatable.rb

@@ -0,0 +1,11 @@
+module Subledger
+  module Domain
+    module Roles
+      module Activatable
+        def activate
+          store.activate self
+        end
+      end
+    end
+  end
+end

data/lib/subledger/domain/roles/archivable.rb

@@ -0,0 +1,11 @@
+module Subledger
+  module Domain
+    module Roles
+      module Archivable
+        def archive
+          store.archive self
+        end
+      end
+    end
+  end
+end

data/lib/subledger/domain/roles/attributable.rb

@@ -0,0 +1,14 @@
+module Subledger
+  module Domain
+    module Roles
+      module Attributable
+        def attributes
+          instance_variables.inject( { } ) do | attrs, ivar |
+            attrs[ ivar.to_s[1..-1].to_sym ] = instance_variable_get ivar
+            attrs
+          end
+        end
+      end
+    end
+  end
+end