stockman-logic 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b1950d32a54e76c7af280dfd15010366d292148d
+  data.tar.gz: a7f9dbf94a3fe7b3ca79f75381dd305c4293aaf7
+SHA512:
+  metadata.gz: 1990b8970e576a275d849424a3a2c30e9f1bec55d031fe5d34373f02136313d2aed82d133a13dc70377bf7dca70a967076684214105e8d6d0596e4558a10216d
+  data.tar.gz: a04285334262c0aea9b369a523b1aed976dfcf52fce0fc73d3b033d037123ed2d58d60441089ac8fdd8b094160f2e04fdfecdc08b4295c338f5f4927cf121530

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.byebug_history

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in stockman-logic.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Vasiliy Reys
+
+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/README.md

@@ -0,0 +1,40 @@
+# Stockman::Logic
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/stockman/logic`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'stockman-logic'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install stockman-logic
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/stockman-logic.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "stockman/logic"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/stockman/logic/kit/content.rb

@@ -0,0 +1,45 @@
+module Stockman
+  module Logic
+    class Kit
+      class Content
+        attr_reader :kit_id, :variant_id, :amount_in_kit
+
+        def initialize(kit_id, variant_id, amount_in_kit)
+          @kit_id        = kit_id.to_i
+          @variant_id    = variant_id.to_i
+          @amount_in_kit = amount_in_kit.to_i
+        end
+
+        def variant
+          @variant ||= Variant.new(variant_id)
+        end
+
+        def warehouse_ids
+          @warehouse_ids ||= variant.warehouse_ids
+        end
+
+        def stock_levels
+          @stock_levels ||= variant.stock_levels
+        end
+
+        def physical_amount(warehouse_id)
+          stock_level_amount(:physical, warehouse_id)
+        end
+
+        def available_amount(warehouse_id)
+          stock_level_amount(:available, warehouse_id)
+        end
+
+        private
+
+        def stock_level_amount(type, warehouse_id)
+          stock_level = stock_levels.find_by_warehouse(warehouse_id)
+
+          return 0 if amount_in_kit.zero? || stock_level.nil?
+
+          stock_level.send(:"#{type}_amount") / amount_in_kit
+        end
+      end
+    end
+  end
+end

data/lib/stockman/logic/kit/contents_collection.rb

@@ -0,0 +1,47 @@
+module Stockman
+  module Logic
+    class Kit
+      class ContentsCollection
+        include Enumerable
+
+        attr_reader :kit_id
+
+        def initialize(kit_id)
+          @kit_id = kit_id.to_i
+        end
+
+        def [](index)
+          contents[index]
+        end
+
+        def each
+          contents.each{ |content| yield content }
+        end
+
+        def minimum_physical_amount(warehouse_id)
+          minimum_amount(:physical, warehouse_id)
+        end
+
+        def minimum_available_amount(warehouse_id)
+          minimum_amount(:available, warehouse_id)
+        end
+
+        def contents
+          @contents ||= load_contents
+        end
+
+        private
+
+        def load_contents
+          Storage.obtain_hash("kits:#{kit_id}:variants").map do |variant_id, amount_in_kit|
+            Content.new(kit_id, variant_id, amount_in_kit)
+          end
+        end
+
+        def minimum_amount(type, warehouse_id)
+          contents.map{|content| content.send(:"#{type}_amount", warehouse_id)}.min
+        end
+      end
+    end
+  end
+end

data/lib/stockman/logic/kit/stock_level.rb

@@ -0,0 +1,26 @@
+module Stockman
+  module Logic
+    class Kit
+      class StockLevel
+        attr_reader :kit_contents, :warehouse_id
+
+        def initialize(kit_contents, warehouse_id)
+          @kit_contents = kit_contents
+          @warehouse_id = warehouse_id.to_i
+        end
+
+        def physical_amount
+          kit_contents.minimum_physical_amount(warehouse_id)
+        end
+
+        def allocated_amount
+          0
+        end
+
+        def available_amount
+          kit_contents.minimum_available_amount(warehouse_id)
+        end
+      end
+    end
+  end
+end

data/lib/stockman/logic/kit/stock_levels_collection.rb

@@ -0,0 +1,51 @@
+module Stockman
+  module Logic
+    class Kit
+      class StockLevelsCollection
+        include Enumerable
+
+        attr_reader :kit_id
+
+        def initialize(kit_id)
+          @kit_id = kit_id.to_i
+        end
+
+        def [](warehouse_id)
+          find_by_warehouse(warehouse_id)
+        end
+
+        def find_by_warehouse(warehouse_id)
+          stock_levels.detect{ |stock_level| stock_level.warehouse_id == warehouse_id }
+        end
+
+        def each
+          stock_levels.each{ |stock_level| yield stock_level }
+        end
+
+        def empty?
+          stock_levels.empty?
+        end
+
+        def contents
+          @contents ||= ContentsCollection.new(kit_id)
+        end
+
+        def stock_levels
+          @stock_levels ||= load_stock_levels
+        end
+
+        def warehouse_ids
+          @warehouse_ids ||= contents.map(&:warehouse_ids).flatten.uniq
+        end
+
+        private
+
+        def load_stock_levels
+          warehouse_ids.inject([]) do |memo, warehouse_id|
+            memo << StockLevel.new(contents, warehouse_id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stockman/logic/kit.rb

@@ -0,0 +1,60 @@
+require_relative "kit/content"
+require_relative "kit/contents_collection"
+require_relative "kit/stock_level"
+require_relative "kit/stock_levels_collection"
+
+module Stockman
+  module Logic
+    class Kit
+      attr_reader :id
+
+      def initialize(id)
+        @id = id.to_i
+      end
+
+      def total_physical_amount
+        stock_levels.sum(&:physical_amount)
+      end
+
+      def total_allocated_amount
+        0
+      end
+
+      def total_available_amount
+        stock_levels.sum(&:available_amount)
+      end
+
+      def stock_levels
+        @stock_levels ||= StockLevelsCollection.new(id)
+      end
+
+      def warehouse_ids
+        stock_levels.map(&:warehouse_id)
+      end
+
+      def summary
+        @summary ||= Summary.from_object(self)
+      end
+
+      def physical_amount(warehouse_id)
+        obtain_stock_level_amount(:physical, warehouse_id)
+      end
+
+      def allocated_amount(warehouse_id)
+        0
+      end
+
+      def available_amount(warehouse_id)
+        obtain_stock_level_amount(:available, warehouse_id)
+      end
+
+      private
+
+      def obtain_stock_level_amount(type, warehouse_id)
+        return 0 unless warehouse_ids.include?(warehouse_id.to_i)
+
+        stock_levels.find_by_warehouse(warehouse_id).send(:"#{type}_amount")
+      end
+    end
+  end
+end

data/lib/stockman/logic/product/sellables_collection.rb

@@ -0,0 +1,35 @@
+module Stockman
+  module Logic
+    class Product
+      class SellablesCollection
+        include Enumerable
+
+        attr_reader :product_id
+
+        def initialize(product_id)
+          @product_id = product_id
+        end
+
+        def sellables
+          @sellables ||= load_sellables
+        end
+
+        def stock_levels
+          @stock_levels ||= sellables.map(&:stock_levels).flatten.map(&:stock_levels).flatten
+        end
+
+        def each
+          sellables.each{ |sellable| yield sellable }
+        end
+
+        private
+
+        def load_sellables
+          Storage.obtain_set("products:#{product_id}:sellables").map do |sellable_data|
+            SellableFactory.build_sellable(sellable_data)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stockman/logic/product/stock_level.rb

@@ -0,0 +1,32 @@
+module Stockman
+  module Logic
+    class Product
+      class StockLevel
+        attr_reader :sellables, :warehouse_id
+
+        def initialize(sellables, warehouse_id)
+          @sellables    = sellables
+          @warehouse_id = warehouse_id.to_i
+        end
+
+        def physical_amount
+          sellables_stock_levels.sum(&:physical_amount)
+        end
+
+        def allocated_amount
+          sellables_stock_levels.sum(&:allocated_amount)
+        end
+
+        def available_amount
+          sellables_stock_levels.sum(&:available_amount)
+        end
+
+        def sellables_stock_levels
+          @sellables_stock_levels ||= sellables.stock_levels.select do |stock_level|
+            stock_level.warehouse_id == warehouse_id
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stockman/logic/product/stock_levels_collection.rb

@@ -0,0 +1,55 @@
+module Stockman
+  module Logic
+    class Product
+      class StockLevelsCollection
+        include Enumerable
+
+        attr_reader :product_id
+
+        def initialize(product_id)
+          @product_id = product_id.to_i
+        end
+
+        def sellables
+          @sellables ||= SellablesCollection.new(product_id)
+        end
+
+        def stock_levels
+          @stock_levels ||= load_stock_levels
+        end
+
+        def warehouse_ids
+          @warehouse_ids ||= load_warehouse_ids
+        end
+
+        def each
+          stock_levels.each{ |stock_level| yield stock_level }
+        end
+
+        def empty?
+          stock_levels.empty?
+        end
+
+        def [](warehouse_id)
+          find_by_warehouse(warehouse_id)
+        end
+
+        def find_by_warehouse(warehouse_id)
+          stock_levels.detect{ |stock_level| stock_level.warehouse_id == warehouse_id }
+        end
+
+        private
+
+        def load_warehouse_ids
+          sellables.map(&:warehouse_ids).flatten.uniq
+        end
+
+        def load_stock_levels
+          warehouse_ids.inject([]) do |memo, warehouse_id|
+            memo << StockLevel.new(sellables, warehouse_id)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stockman/logic/product.rb

@@ -0,0 +1,35 @@
+require_relative "product/sellables_collection"
+require_relative "product/stock_level"
+require_relative "product/stock_levels_collection"
+
+module Stockman
+  module Logic
+    class Product
+      attr_reader :id
+
+      def initialize(id)
+        @id = id
+      end
+
+      def total_physical_amount
+        stock_levels.sum(&:physical_amount)
+      end
+
+      def total_allocated_amount
+        stock_levels.sum(&:allocated_amount)
+      end
+
+      def total_available_amount
+        stock_levels.sum(&:available_amount)
+      end
+
+      def stock_levels
+        @stock_levels ||= StockLevelsCollection.new(id)
+      end
+
+      def summary
+        @summary ||= Summary.from_object(self)
+      end
+    end
+  end
+end

data/lib/stockman/logic/sellable_factory.rb

@@ -0,0 +1,15 @@
+module Stockman
+  module Logic
+    class SellableFactory
+      VALID_SELLABLE_TYPES = ['variants', 'kits']
+
+      def self.build_sellable(sellable_data)
+        type, id = *sellable_data.split(":")
+
+        raise "#{type} is not valid sellable type" unless VALID_SELLABLE_TYPES.include?(type)
+
+        "Stockman::Logic::#{type.singularize.classify}".constantize.new(id.to_i)
+      end
+    end
+  end
+end

data/lib/stockman/logic/storage.rb

@@ -0,0 +1,19 @@
+module Stockman
+  module Logic
+    class Storage
+      def self.obtain_set(key)
+        Logic.redis.smembers(key)
+      end
+
+      def self.obtain_hash(key)
+        Logic.redis.hgetall(key)
+      end
+
+      def self.obtain_amount(key, field)
+        value = Logic.redis.hget(key, field)
+
+        Utils.deserialize_amount(value)
+      end
+    end
+  end
+end

data/lib/stockman/logic/summary.rb

@@ -0,0 +1,78 @@
+module Stockman
+  module Logic
+    class Summary
+      attr_reader :data
+
+      def self.from_hash(hash)
+        data = transform_values(hash, &Utils.method(:deserialize_amount))
+
+        new(data)
+      end
+
+      def self.from_object(object)
+        data = {
+          physical_amount: object.total_physical_amount,
+          allocated_amount: object.total_allocated_amount,
+          available_amount: object.total_available_amount,
+
+          warehouses: object.stock_levels.inject({}) do |memo, stock_level|
+            memo.merge(
+              stock_level.warehouse_id => {
+                physical_amount: stock_level.physical_amount,
+                allocated_amount: stock_level.allocated_amount,
+                available_amount: stock_level.available_amount
+              }
+            )
+          end
+        }
+
+        new(data)
+      end
+
+      def initialize(data)
+        @data = data
+      end
+
+      def total_physical_amount
+        data[:physical_amount]
+      end
+
+      def total_allocated_amount
+        data[:allocated_amount]
+      end
+
+      def total_available_amount
+        data[:available_amount]
+      end
+
+      def warehouses
+        data[:warehouses]
+      end
+
+      def to_hash
+        self.class.transform_values(data, &Utils.method(:serialize_amount))
+      end
+
+      def to_json(_ = nil)
+        JSON.generate(to_hash)
+      end
+
+      private
+
+      def self.transform_values(hash, &block)
+        method = lambda do |memo, data|
+          memo.merge data[0] => yield(data[1])
+        end
+
+        totals = hash.symbolize_keys.slice(:physical_amount, :allocated_amount, :available_amount)
+          .inject({}, &method)
+
+        warehouses = hash.symbolize_keys[:warehouses].inject({}) do |memo, data|
+          memo.merge data[0].to_i => data[1].inject({}, &method).symbolize_keys
+        end
+
+        totals.merge(warehouses: warehouses)
+      end
+    end
+  end
+end

data/lib/stockman/logic/utils.rb

@@ -0,0 +1,21 @@
+module Stockman
+  module Logic
+    class Utils
+      def self.serialize_amount(value)
+        if value == Float::INFINITY
+          'inf'
+        else
+          value.to_i
+        end
+      end
+
+      def self.deserialize_amount(value)
+        if value == 'inf'
+          Float::INFINITY
+        else
+          value.to_i
+        end
+      end
+    end
+  end
+end

data/lib/stockman/logic/variant/stock_level.rb

@@ -0,0 +1,32 @@
+module Stockman
+  module Logic
+    class Variant
+      class StockLevel
+        attr_reader :variant_id, :warehouse_id
+
+        def initialize(variant_id, warehouse_id)
+          @variant_id = variant_id.to_i
+          @warehouse_id = warehouse_id.to_i
+        end
+
+        def physical_amount
+          obtain_amount(:physical)
+        end
+
+        def allocated_amount
+          obtain_amount(:allocated)
+        end
+
+        def available_amount
+          physical_amount - allocated_amount
+        end
+
+        private
+
+        def obtain_amount(type)
+          Storage.obtain_amount("variants:#{variant_id}:stock_levels:#{warehouse_id}", :"#{type}_amount")
+        end
+      end
+    end
+  end
+end

data/lib/stockman/logic/variant/stock_levels_collection.rb

@@ -0,0 +1,37 @@
+module Stockman
+  module Logic
+    class Variant
+      class StockLevelsCollection
+        include Enumerable
+
+        attr_reader :variant_id
+
+        def initialize(variant_id)
+          @variant_id = variant_id.to_i
+        end
+
+        def stock_levels
+          @stock_levels ||= Storage.obtain_set("variants:#{variant_id}:warehouses").map do |warehouse_id|
+            StockLevel.new(variant_id, warehouse_id)
+          end
+        end
+
+        def each
+          stock_levels.each{ |stock_level| yield stock_level }
+        end
+
+        def empty?
+          stock_levels.empty?
+        end
+
+        def [](warehouse_id)
+          find_by_warehouse(warehouse_id)
+        end
+
+        def find_by_warehouse(warehouse_id)
+          stock_levels.detect{ |stock_level| stock_level.warehouse_id == warehouse_id }
+        end
+      end
+    end
+  end
+end

data/lib/stockman/logic/variant.rb

@@ -0,0 +1,58 @@
+require_relative 'variant/stock_level'
+require_relative 'variant/stock_levels_collection'
+
+module Stockman
+  module Logic
+    class Variant
+      attr_reader :id
+
+      def initialize(id)
+        @id = id.to_i
+      end
+
+      def total_physical_amount
+        stock_levels.sum(&:physical_amount)
+      end
+
+      def total_allocated_amount
+        stock_levels.sum(&:allocated_amount)
+      end
+
+      def total_available_amount
+        total_physical_amount - total_allocated_amount
+      end
+
+      def stock_levels
+        @stock_levels ||= StockLevelsCollection.new(id)
+      end
+
+      def warehouse_ids
+        stock_levels.map(&:warehouse_id)
+      end
+
+      def physical_amount(warehouse_id)
+        obtain_stock_level_amount(:physical, warehouse_id)
+      end
+
+      def allocated_amount(warehouse_id)
+        obtain_stock_level_amount(:allocated, warehouse_id)
+      end
+
+      def available_amount(warehouse_id)
+        obtain_stock_level_amount(:available, warehouse_id)
+      end
+
+      def summary
+        @summary ||= Summary.from_object(self)
+      end
+
+      private
+
+      def obtain_stock_level_amount(type, warehouse_id)
+        return 0 unless warehouse_ids.include?(warehouse_id.to_i)
+
+        stock_levels.find_by_warehouse(warehouse_id).send(:"#{type}_amount")
+      end
+    end
+  end
+end

data/lib/stockman/logic/version.rb

@@ -0,0 +1,5 @@
+module Stockman
+  module Logic
+    VERSION = "0.1.0"
+  end
+end

data/lib/stockman/logic.rb

@@ -0,0 +1,20 @@
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/string/inflections"
+require 'active_support/core_ext/hash'
+
+require_relative "logic/version"
+require_relative "logic/utils"
+require_relative "logic/storage"
+require_relative "logic/summary"
+require_relative "logic/variant"
+require_relative "logic/kit"
+require_relative "logic/sellable_factory"
+require_relative "logic/product"
+
+module Stockman
+  module Logic
+    class << self
+      attr_accessor :redis
+    end
+  end
+end

data/lib/stockman.rb

@@ -0,0 +1 @@
+require_relative 'stockman/logic'

data/stockman-storage_api.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'stockman/logic/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "stockman-logic"
+  spec.version       = Stockman::Logic::VERSION
+  spec.authors       = ["Vasiliy Reys"]
+  spec.email         = ["vasiliy.reys@gmail.com"]
+
+  spec.summary       = %q{Stockman stock levels calculation logic}
+  spec.homepage      = "http://veeqo.com"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.2"
+  spec.add_development_dependency "redis", "~> 3.3.3"
+  spec.add_development_dependency "byebug", "~> 9.1.0"
+
+  spec.add_dependency "activesupport", '>= 3.2', '< 5.0'
+end

data/test.rb

@@ -0,0 +1,148 @@
+#!/usr/bin/env ruby
+require 'active_support/core_ext/hash'
+# require 'active_support/hash_with_indifferent_access'
+require 'pp'
+require 'json'
+require 'ostruct'
+
+module Stockman
+  module Logic
+    class Utils
+      def self.deserialize_amount(value)
+        if value == 'inf'
+          Float::INFINITY
+        else
+          value.to_i
+        end
+      end
+
+      def self.serialize_amount(value)
+        if value == Float::INFINITY
+          'inf'
+        else
+          value.to_i
+        end
+      end
+    end
+
+    class Summary
+      attr_reader :data
+
+      def self.from_hash(hash)
+        data = transform_values(hash, &Utils.method(:deserialize_amount))
+
+        new(data)
+      end
+
+      def self.from_object(object)
+        data = {
+          physical_amount: object.total_physical_amount,
+          allocated_amount: object.total_allocated_amount,
+          available_amount: object.total_available_amount,
+
+          warehouses: object.stock_levels.inject({}) do |memo, stock_level|
+            memo.merge(
+              stock_level.warehouse_id => {
+                physical_amount: stock_level.physical_amount,
+                allocated_amount: stock_level.allocated_amount,
+                available_amount: stock_level.available_amount
+              }
+            )
+          end
+        }
+
+        new(data)
+      end
+
+      def initialize(data)
+        @data = data
+      end
+
+      def total_physical_amount
+        data[:physical_amount]
+      end
+
+      def total_allocated_amount
+        data[:allocated_amount]
+      end
+
+      def total_available_amount
+        data[:available_amount]
+      end
+
+      def warehouses
+        data[:warehouses]
+      end
+
+      def to_hash
+        self.class.transform_values(data, &Utils.method(:serialize_amount))
+      end
+
+      def to_json
+        JSON.generate(to_hash)
+      end
+
+      private
+
+      def self.transform_values(hash, &block)
+        method = lambda do |memo, data|
+          memo.merge data[0] => yield(data[1])
+        end
+
+        totals = hash.symbolize_keys.slice(:physical_amount, :allocated_amount, :available_amount)
+          .inject({}, &method)
+
+        warehouses = hash.symbolize_keys[:warehouses].inject({}) do |memo, data|
+          memo.merge data[0].to_i => data[1].inject({}, &method).symbolize_keys
+        end
+
+        totals.merge(warehouses: warehouses)
+      end
+    end
+  end
+end
+
+data = {
+  physical_amount: Float::INFINITY,
+  allocated_amount: 40,
+  available_amount: Float::INFINITY,
+
+  warehouses: {
+    17 => {
+      physical_amount: Float::INFINITY,
+      allocated_amount: 10,
+      available_amount: Float::INFINITY
+    },
+    18 => {
+      physical_amount: 500,
+      allocated_amount: 30,
+      available_amount: 470
+    }
+  }
+}
+
+object = OpenStruct.new(
+  total_physical_amount: Float::INFINITY,
+  total_allocated_amount: 40,
+  total_available_amount: Float::INFINITY,
+  stock_levels: [
+    OpenStruct.new(
+      warehouse_id: 17,
+      physical_amount: Float::INFINITY,
+      allocated_amount: 10,
+      available_amount: Float::INFINITY
+    ),
+    OpenStruct.new(
+      warehouse_id: 18,
+      physical_amount: 500,
+      allocated_amount: 30,
+      available_amount: 470
+    )
+  ]
+)
+
+json = %Q{{"physical_amount":"inf","allocated_amount":40,"available_amount":"inf","warehouses":{"17":{"physical_amount":"inf","allocated_amount":10,"available_amount":"inf"},"18":{"physical_amount":500,"allocated_amount":30,"available_amount":470}}}}
+
+puts Stockman::Logic::Summary.new(data).to_hash
+puts Stockman::Logic::Summary.from_hash(JSON.parse(json)).to_hash
+puts Stockman::Logic::Summary.from_object(object).to_hash

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification
+name: stockman-logic
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Vasiliy Reys
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-08-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.3
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 9.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 9.1.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: 
+email:
+- vasiliy.reys@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/stockman.rb
+- lib/stockman/logic.rb
+- lib/stockman/logic/kit.rb
+- lib/stockman/logic/kit/content.rb
+- lib/stockman/logic/kit/contents_collection.rb
+- lib/stockman/logic/kit/stock_level.rb
+- lib/stockman/logic/kit/stock_levels_collection.rb
+- lib/stockman/logic/product.rb
+- lib/stockman/logic/product/sellables_collection.rb
+- lib/stockman/logic/product/stock_level.rb
+- lib/stockman/logic/product/stock_levels_collection.rb
+- lib/stockman/logic/sellable_factory.rb
+- lib/stockman/logic/storage.rb
+- lib/stockman/logic/summary.rb
+- lib/stockman/logic/utils.rb
+- lib/stockman/logic/variant.rb
+- lib/stockman/logic/variant/stock_level.rb
+- lib/stockman/logic/variant/stock_levels_collection.rb
+- lib/stockman/logic/version.rb
+- stockman-storage_api.gemspec
+- test.rb
+homepage: http://veeqo.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Stockman stock levels calculation logic
+test_files: []