subledger 0.7.7

data/lib/subledger/path.rb

@@ -0,0 +1,106 @@
+module Subledger
+  module Path
+    def self.for_collection args
+      "/#{ API_VERSION }#{ path args }"
+    end
+
+    def self.for_entity args
+      "#{ for_collection args }/#{ args[ :anchor ].id }"
+    end
+
+    def self.for_entity_without_api_version args
+      "#{ path args }/#{ args[ :anchor ].id }"
+    end
+
+    def self.for_collect args
+      action          = args[:action]
+      state           = args[:state]
+      limit           = args[:limit]
+      collection_name = args[:collection_name]
+
+      key   = key_for args
+      value = URI.escape value_for( args ).to_s
+
+      path = for_collection( args ) + '?'
+
+      query_params = []
+
+      query_params << "state=#{    state  }" unless collection_name == :account_lines
+      query_params << "action=#{   action }"
+      query_params << "#{ key }=#{ value  }" unless value.respond_to?( :length ) and value.length.zero?
+      query_params << "limit=#{    limit  }" unless limit.nil?
+
+      path + query_params.join('&')
+    end
+
+    private
+
+    COLLECTION_PATHS = {
+                         :identities        => lambda { |anchor| 'identities' },
+                         :keys              => lambda { |anchor| "identities/#{anchor.identity.id}/keys" },
+                         :controls          => lambda { |anchor| "identities/#{anchor.identity.id}/controls" },
+                         :orgs              => lambda { |anchor| 'orgs' },
+                         :books             => lambda { |anchor| "orgs/#{anchor.org.id}/books" },
+                         :accounts          => lambda { |anchor| "orgs/#{anchor.book.org.id}/books/#{anchor.book.id}/accounts" },
+                         :journal_entries   => lambda { |anchor| "orgs/#{anchor.book.org.id}/books/#{anchor.book.id}/journal_entries" },
+                         :lines             => lambda { |anchor| "orgs/#{anchor.journal_entry.book.org.id}/books/#{anchor.journal_entry.book.id}/journal_entries/#{anchor.journal_entry.id}/lines" },
+                         :account_lines     => lambda { |anchor| "orgs/#{anchor.account.book.org.id}/books/#{anchor.account.book.id}/accounts/#{anchor.account.id}/lines" },
+                         :reports           => lambda { |anchor| "orgs/#{anchor.book.org.id}/books/#{anchor.book.id}/reports" },
+                         :categories        => lambda { |anchor| "orgs/#{anchor.book.org.id}/books/#{anchor.book.id}/categories" },
+                         :report_renderings => lambda { |anchor| "orgs/#{anchor.book.org.id}/books/#{anchor.book.id}/report_renderings" }
+                       }
+
+    def self.path args
+      anchor = args[:anchor]
+
+      collection_name = CollectionName.without_state args
+
+      path = COLLECTION_PATHS[collection_name].call anchor
+
+      "/#{path}"
+    end
+
+    KEY_FOR = { :books             => 'description',
+                :accounts          => 'description',
+                :journal_entries   => 'effective_at',
+                :lines             => 'order',
+                :account_lines     => 'effective_at',
+                :reports           => 'description',
+                :categories        => 'description',
+                :report_renderings => 'rendered_at'
+              }
+
+    def self.key_for args
+      action = args[:action]
+
+      if [ :preceding, :following ].include? action
+        'id'
+      else
+        KEY_FOR[ CollectionName.without_state args ]
+      end
+    end
+
+    VALUE_FOR = { :books             => lambda { |anchor| anchor.description },
+                  :accounts          => lambda { |anchor| anchor.description },
+                  :journal_entries   => lambda { |anchor| anchor.effective_at.iso8601(3) },
+                  :lines             => lambda { |anchor| anchor.order },
+                  :account_lines     => lambda { |anchor| anchor.effective_at.iso8601(3) },
+                  :reports           => lambda { |anchor| anchor.description },
+                  :categories        => lambda { |anchor| anchor.description },
+                  :report_renderings => lambda { |anchor| anchor.rendered_at.iso8601(3) }
+                }
+
+    def self.value_for args
+      action = args[:action]
+      anchor = args[:anchor]
+
+      if [ :preceding, :following ].include? action
+        anchor.id
+      else
+        collection_name = CollectionName.without_state args
+
+        VALUE_FOR[collection_name].call anchor
+      end
+    end
+  end
+end

data/lib/subledger/rest.rb

@@ -0,0 +1,128 @@
+module Subledger
+  module Rest
+    def self.to_args rest_args, client
+      args = { }
+
+      rest_args.each do |key, value|
+        key_symbol = key.to_sym
+
+        unless value.nil?
+          code = LAMBDAS[key]
+
+          args[key_symbol] = if code.nil? or value.kind_of? Domain
+                               value
+                             else
+                               code.call client, args, key, value
+                             end
+        end
+      end
+
+      args
+    end
+
+    def self.to_balance rest_args, client
+      to_args( rest_args, client )[:balance]
+    end
+
+    def self.present_entity entity
+      { entity.entity_name => entity.serializable_hash }
+    end
+
+    def self.present_collection entity_name, collection
+      entities = collection.collect { |entity| entity.serializable_hash }
+
+      { entity_name => entities }
+    end
+
+    private
+
+    ACCOUNT = lambda do |client, args, key, value|
+                client.account :id => value
+              end
+
+    # TODO eliminate if condition in BALANCE LAMBDA
+
+    BALANCE = lambda do |client, args, key, value|
+                if value.has_key? :debit_value
+                  client.balance :debit_value  => debit_value(  client, value[:debit_value ]['amount'] ),
+                                 :credit_value => credit_value( client, value[:credit_value]['amount'] )
+                else
+                  client.balance :debit_value  => debit_value(  client, value['debit_value' ]['amount'] ),
+                                 :credit_value => credit_value( client, value['credit_value']['amount'] )
+                end
+              end
+
+    BOOK = lambda do |client, args, key, value|
+             client.book :id => value
+            end
+
+    CATEGORIES = lambda do |client, args, key, value|
+                   args[:categories] = MultiJson.dump value
+                 end
+
+    IDENTITY = lambda do |client, args, key, value|
+                 client.identity :id => value
+               end
+
+    JOURNAL_ENTRY = lambda do |client, args, key, value|
+                      client.journal_entry :id => value
+                    end
+
+    MODE = lambda do |client, args, key, value|
+             value.to_sym
+           end
+
+    NB   = lambda do | client, args, key, value |
+             client.send value
+           end
+
+    ORG = lambda do |client, args, key, value|
+            client.org :id => value
+          end
+
+    TIME = lambda do |client, args, key, value|
+             Subledger.parse_time key, value
+           end
+
+    VALUE = lambda do |client, args, key, value|
+              client.send value['type'], value['amount']
+            end
+
+    VERSION = lambda do |client, args, key, value|
+                value.to_i
+              end
+
+    REPORT = lambda do |client, args, key, value|
+               client.report :id => value
+             end
+
+    LAMBDAS = {
+      'account'        => ACCOUNT,
+      'balance'        => BALANCE,
+      'book'           => BOOK,
+      'categories'     => CATEGORIES,
+      'completed_at'   => TIME,
+      'credit_value'   => VALUE,
+      'debit_value'    => VALUE,
+      'effective_at'   => TIME,
+      'identity'       => IDENTITY,
+      'journal_entry'  => JOURNAL_ENTRY,
+      'mode'           => MODE,
+      'normal_balance' => NB,
+      'org'            => ORG,
+      'posted_at'      => TIME,
+      'rendered_at'    => TIME,
+      'report'         => REPORT,
+      'value'          => VALUE,
+      'version'        => VERSION
+    }
+
+    def self.debit_value client, amount
+      BigDecimal( amount ) == 0 ? client.zero : client.debit( amount )
+    end
+
+    def self.credit_value client, amount
+      BigDecimal( amount ) == 0 ? client.zero : client.credit( amount )
+    end
+  end
+end

data/lib/subledger/server.rb

@@ -0,0 +1,3 @@
+require 'bundler/setup'
+
+require 'subledger/server/v1'

data/lib/subledger/store/api/errors.rb

@@ -0,0 +1,95 @@
+module Subledger
+  module Store
+    module Api
+      module Errors
+        # Raised when the Subledger API returns a 400 status code
+        class BadRequest < Error; end
+
+        # Raised when the Subledger API returns a 401 status code
+        class Unauthorized < Error; end
+
+        # Raised when the Subledger API returns a 403 status code
+        class Forbidden < Error; end
+
+        # Raised when the Subledger API returns a 404 status code
+        class NotFound < Error; end
+
+        # Raised when the Subledger API returns a 406 status code
+        class NotAcceptable < Error; end
+
+        # Raised when the Subledger API returns a 409 status code
+        class Conflict < Error; end
+
+        # Raised when the Subledger API returns a 422 status code
+        class UnprocessableEntity < Error; end
+
+        # Raised when the Subledger API returns a 500 status code
+        class InternalServerError < Error; end
+
+        # Raised when the Subledger API returns a 501 status code
+        class NotImplemented < Error; end
+
+        # Raised when the Subledger API returns a 502 status code
+        class BadGateway < Error; end
+
+        # Raised when the Subledger API returns a 503 status code
+        class ServiceUnavailable < Error; end
+
+        # Raise when the Subledger API returns any other status code
+        class HttpError < Error; end
+
+        class ServerNotAvailable < Error
+          def initialize wrapped
+            @wrapped = wrapped
+          end
+
+          def message
+            "#{super} was not avaiable. Please check your configuration. (#{@wrapped.message})"
+          end
+        end
+
+        class ResponseError < Faraday::Response::Middleware
+
+          EXCEPTIONS = {
+            400 => BadRequest,
+            401 => Unauthorized,
+            403 => Forbidden,
+            404 => NotFound,
+            406 => NotAcceptable,
+            409 => Store::UpdateConflictError,
+            422 => UnprocessableEntity,
+            500 => InternalServerError,
+            501 => NotImplemented,
+            502 => BadGateway,
+            503 => ServiceUnavailable
+          }
+
+          def call env
+            @app.call(env).on_complete do
+              status = env[:status].to_i
+
+              if ( 400..600 ).include? status
+                raise exception_for( status ), response_for( env )
+              end
+            end
+          end
+
+          def exception_for status
+            EXCEPTIONS[status] || HttpError
+          end
+
+          def response_for env
+            { :status  => env[:status],
+              :url     => url_for( env ),
+              :headers => env[:response_headers],
+              :body    => env[:body] }
+          end
+
+          def url_for env
+            env[:url].to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/subledger/store/api/roles/activate.rb

@@ -0,0 +1,21 @@
+module Subledger
+  module Store
+    module Api
+      module Activate
+        def activate activatable
+          path = Path.for_entity( :anchor => activatable ) + '/activate'
+
+          begin
+            json_body = http.post do |req|
+                          req.url path
+                        end.body
+          rescue Exception => e
+            raise ActivateError, "Cannot activate #{activatable}: #{e}"
+          end
+
+          new_or_initialize json_body, activatable
+        end
+      end
+    end
+  end
+end

data/lib/subledger/store/api/roles/archive.rb

@@ -0,0 +1,21 @@
+module Subledger
+  module Store
+    module Api
+      module Archive
+        def archive archivable
+          path = Path.for_entity( :anchor => archivable ) + '/archive'
+
+          begin
+            json_body = http.post do |req|
+                          req.url path
+                        end.body
+          rescue Exception => e
+            raise ArchiveError, "Cannot archive #{archivable}: #{e}"
+          end
+
+          new_or_initialize json_body, archivable
+        end
+      end
+    end
+  end
+end

data/lib/subledger/store/api/roles/balance.rb

@@ -0,0 +1,39 @@
+module Subledger
+  module Store
+    module Api
+      module Balance
+        def account_balance args
+          client  = args[:client]
+          account = args[:account]
+          at      = args[:at].iso8601(3)
+
+          path = Path.for_entity( :anchor => account ) + '/balance?at=' + at
+
+          begin
+            response_hash = parse_json(
+                              http.get( path ).body )
+          rescue Exception => e
+            raise BalanceError, "Cannot balance #{account}: #{e}"
+          end
+
+          Rest.to_balance response_hash, client
+        end
+
+        def journal_entry_balance args
+          client        = args[:client]
+          journal_entry = args[:journal_entry]
+
+          path = Path.for_entity( :anchor => journal_entry ) + '/balance'
+
+          begin
+            response_hash = parse_json( http.get( path ).body )
+          rescue Exception => e
+            raise BalanceError, "Cannot balance #{journal_entry}: #{e}"
+          end
+
+          Rest.to_balance response_hash, client
+        end
+      end
+    end
+  end
+end

data/lib/subledger/store/api/roles/categories.rb

@@ -0,0 +1,51 @@
+module Subledger
+  module Store
+    module Api
+      module Categories
+        def attach_account_to_category args
+          category = args[:category]
+          account  = args[:account]
+
+          path = Path.for_entity( :anchor => category ) + '/attach'
+
+          attach_post_hash = { 'account' => account.id }
+
+          begin
+            json_body = http.post do |req|
+                          req.url    path
+                          req.body = attach_post_hash
+                        end.body
+          rescue Exception => e
+            raise AttachError, "Cannot attach #{account}: #{e}"
+          end
+
+          account
+        end
+
+        def detach_account_from_category args
+          category = args[:category]
+          account  = args[:account]
+
+          path = Path.for_entity( :anchor => category ) + '/detach'
+
+          detach_post_hash = { 'account' => account.id }
+
+          begin
+            json_body = http.post do |req|
+                          req.url    path
+                          req.body = detach_post_hash
+                        end.body
+          rescue Exception => e
+            raise DetachError, "Cannot detach #{account}: #{e}"
+          end
+
+          account
+        end
+
+        def collect_accounts_for_category category
+          raise CategoryError, 'category#accounts is not yet implemented'
+        end
+      end
+    end
+  end
+end

data/lib/subledger/store/api/roles/collect.rb

@@ -0,0 +1,58 @@
+module Subledger
+  module Store
+    module Api
+      module Collect
+
+        private
+
+        def before args
+          collect_with args
+        end
+
+        def ending args
+          collect_with args
+        end
+
+        def starting args
+          collect_with args
+        end
+
+        def after args
+          collect_with args
+        end
+
+        def preceding args
+          collect_with args
+        end
+
+        def following args
+          collect_with args
+        end
+
+        def collect_with args
+          path = Path.for_collect args
+
+          anchor = args[:anchor]
+
+          klass = anchor.class
+
+          begin
+            collection = parse_json http.get( path ).body
+          rescue Exception => e
+            raise CollectError, "Cannot collect: #{e}"
+          end
+
+          client = anchor.client
+
+          key = collection.keys.first
+
+          collection[key].collect do |response_hash|
+            args = Rest.to_args response_hash, client
+
+            client.send key, args
+          end
+        end
+      end
+    end
+  end
+end

data/lib/subledger/store/api/roles/create.rb

@@ -0,0 +1,26 @@
+module Subledger
+  module Store
+    module Api
+      module Create
+        def create creatable
+          unless creatable.id.nil?
+            raise CreateError, 'cannot create an object with an :id'
+          end
+
+          path = Path.for_collection :anchor => creatable
+
+          begin
+            json_body = http.post do |req|
+                          req.url    path
+                          req.body = creatable.post_hash
+                        end.body
+          rescue Exception => e
+            raise CreateError, "Cannot create #{creatable}: #{e}"
+          end
+
+          new_or_initialize json_body, creatable
+        end
+      end
+    end
+  end
+end

data/lib/subledger/store/api/roles/create_and_post.rb

@@ -0,0 +1,35 @@
+module Subledger
+  module Store
+    module Api
+      module CreateAndPost
+        def create_and_post args
+          dje       = args[:active_journal_entry]
+          dje_lines = args[:active_lines]
+          pje       = args[:posting_journal_entry]
+
+          path = Path.for_collection( :anchor => dje ) + '/create_and_post'
+
+          json_body = http.post do |req|
+                        req.url path
+
+                        unless dje.post_delay.zero?
+                          req.headers['X-Subledger-Post-Slowly'] = 'true'
+                        end
+
+                        req.body = create_and_post_hash( dje, dje_lines )
+                      end.body
+
+          new_or_initialize json_body, pje
+        end
+
+        private
+
+        def create_and_post_hash dje, dje_lines
+          lines = dje_lines.collect { |line| line.post_hash }
+
+          dje.post_hash.merge :lines => lines
+        end
+      end
+    end
+  end
+end

data/lib/subledger/store/api/roles/create_identity.rb

@@ -0,0 +1,39 @@
+module Subledger
+  module Store
+    module Api
+      module CreateIdentity
+        ACTIVE_IDENTITY = 'active_identity'
+        ACTIVE_KEY      = 'active_key'
+
+        def create_identity identity
+          client = identity.client
+
+          path = Path.for_collection :anchor => identity
+
+          begin
+            json_body = http.post do |req|
+                          req.url    path
+                          req.body = identity.post_hash
+                        end.body
+          rescue Exception => e
+            raise CreateError, "Cannot create #{identity.class}: #{e}"
+          end
+
+          response_hash = parse_json json_body
+
+          identity_hash = { 'active_identity' => response_hash[ACTIVE_IDENTITY] }
+          identity_json = MultiJson.dump identity_hash
+
+          new_identity = new_or_initialize identity_json, identity
+
+          identity.send :initialize, new_identity.attributes
+
+          key_args = Rest.to_args response_hash[ACTIVE_KEY], client
+          key      = client.active_keys key_args
+
+          return identity, key
+        end
+      end
+    end
+  end
+end

data/lib/subledger/store/api/roles/create_line.rb

@@ -0,0 +1,24 @@
+module Subledger
+  module Store
+    module Api
+      module CreateLine
+        def create_line args
+          begin
+            line = args[:line]
+
+            path = Path.for_entity( :anchor => line.journal_entry ) + '/create_line'
+
+            json_body = http.post do |req|
+                          req.url    path
+                          req.body = line.post_hash
+                        end.body
+          rescue Exception => e
+            raise CreateLineError, "Cannot create #{line}: #{e}"
+          end
+
+          new_or_initialize json_body, line
+        end
+      end
+    end
+  end
+end

data/lib/subledger/store/api/roles/first_and_last_line.rb

@@ -0,0 +1,31 @@
+module Subledger
+  module Store
+    module Api
+      module FirstAndLastLine
+
+        def first_and_last_line args
+          anchor = args[:account]
+          client = anchor.client
+
+          path = Path.for_entity( :anchor => anchor ) + '/first_and_last_line'
+
+          klass = anchor.class
+
+          begin
+            collection = parse_json http.get( path ).body
+          rescue Exception => e
+            raise FirstAndLastLineError, "Cannot get first and last line: #{e}"
+          end
+
+          key = collection.keys.first
+
+          collection[key].collect do |response_hash|
+            args = Rest.to_args response_hash, client
+
+            client.send key, args
+          end
+        end
+      end
+    end
+  end
+end