harpiya_core 4.3.0.alpha

data/app/models/harpiya/stock/splitter/shipping_category.rb

@@ -0,0 +1,31 @@
+module Harpiya
+  module Stock
+    module Splitter
+      class ShippingCategory < Harpiya::Stock::Splitter::Base
+        def split(packages)
+          split_packages = packages.flat_map(&method(:split_by_category))
+          return_next(split_packages)
+        end
+
+        private
+
+        def split_by_category(package)
+          # group package items by shipping category
+          grouped_packages = package.contents.group_by(&method(:shipping_category_for))
+          hash_to_packages(grouped_packages)
+        end
+
+        def hash_to_packages(grouped_packages)
+          # select values from packages grouped by shipping categories and build new packages
+          grouped_packages.values.map(&method(:build_package))
+        end
+
+        # optimization: save variant -> shipping_category correspondence
+        def shipping_category_for(item)
+          @item_shipping_category ||= {}
+          @item_shipping_category[item.inventory_unit.variant_id] ||= item.variant.shipping_category_id
+        end
+      end
+    end
+  end
+end

data/app/models/harpiya/stock/splitter/weight.rb

@@ -0,0 +1,84 @@
+module Harpiya
+  module Stock
+    module Splitter
+      class Weight < Harpiya::Stock::Splitter::Base
+        attr_reader :packer, :next_splitter
+
+        cattr_accessor(:threshold) { 150 }
+
+        def split(packages)
+          generated_packages = packages.flat_map(&method(:reduce))
+          packages.push(*generated_packages)
+          return_next(packages)
+        end
+
+        private
+
+        def reduce(package)
+          contents = split_package_contents_over_threshold(package).sort { |x, y| y.weight <=> x.weight }
+          # Treat current package as one of the generated packages for convenience and add the heaviest item
+          # This also prevents an additional package if no fit is possible
+          package.contents.clear
+          package.contents << contents.shift
+          split_packages = [package]
+
+          while contents.present?
+            package_to_use = choose_package(split_packages, contents.first)
+
+            if package_to_use.nil?
+              package_to_use = build_package
+              split_packages << package_to_use
+            end
+
+            package_to_use.contents << contents.shift
+          end
+
+          split_packages.drop(1)
+        end
+
+        def choose_package(generated_packages, content_to_add)
+          # Implements worst fit, add to package with most space left over after addition.
+          # See: http://www.labri.fr/perso/eyraud/pmwiki/uploads/Main/BinPackingSurvey.pdf,
+          # for survey of other techniques
+          package_to_use     = nil
+          available_space    = -1
+
+          generated_packages.each do |generated_package|
+            generated_package_weight = generated_package.weight
+
+            weight_exceed = (generated_package_weight + content_to_add.weight) > threshold
+            space_left = available_space >= (threshold - generated_package_weight)
+
+            next if weight_exceed || space_left
+
+            package_to_use = generated_package
+            available_space = threshold - generated_package_weight
+          end
+
+          package_to_use
+        end
+
+        def split_package_contents_over_threshold(package)
+          package.contents.flat_map do |content|
+            if content.weight > threshold && content.splittable_by_weight?
+              split_content_item_over_threshold(content)
+            else
+              content
+            end
+          end
+        end
+
+        def split_content_item_over_threshold(content_item)
+          per_content_max_quantity = (threshold / content_item.variant_weight).floor
+          per_content_max_quantity = 1 if per_content_max_quantity.zero?
+          content_items = [content_item]
+          while content_item.quantity > per_content_max_quantity
+            split_inventory = InventoryUnit.split(content_item.inventory_unit, per_content_max_quantity)
+            content_items << ContentItem.new(split_inventory, content_item.state)
+          end
+          content_items
+        end
+      end
+    end
+  end
+end

data/app/models/harpiya/stock_item.rb

@@ -0,0 +1,101 @@
+module Harpiya
+  class StockItem < Harpiya::Base
+    acts_as_paranoid
+
+    with_options inverse_of: :stock_items do
+      belongs_to :stock_location, class_name: 'Harpiya::StockLocation'
+      belongs_to :variant, -> { with_deleted }, class_name: 'Harpiya::Variant'
+    end
+    has_many :stock_movements, inverse_of: :stock_item
+
+    validates :stock_location, :variant, presence: true
+    validates :variant_id, uniqueness: { scope: %i[stock_location_id deleted_at] }
+
+    validates :count_on_hand, numericality: {
+      greater_than_or_equal_to: 0,
+      less_than_or_equal_to: 2**31 - 1,
+      only_integer: true
+    }, if: :verify_count_on_hand?
+
+    delegate :weight, :should_track_inventory?, to: :variant
+    delegate :name, to: :variant, prefix: true
+    delegate :product, to: :variant
+
+    after_save :conditional_variant_touch, if: :saved_changes?
+    after_touch { variant.touch }
+    after_destroy { variant.touch }
+
+    self.whitelisted_ransackable_attributes = %w[count_on_hand stock_location_id variant_id]
+    self.whitelisted_ransackable_associations = ['variant']
+
+    scope :with_active_stock_location, -> { joins(:stock_location).merge(Harpiya::StockLocation.active) }
+
+    def backordered_inventory_units
+      Harpiya::InventoryUnit.backordered_for_stock_item(self)
+    end
+
+    def adjust_count_on_hand(value)
+      with_lock do
+        set_count_on_hand(count_on_hand + value)
+      end
+    end
+
+    def set_count_on_hand(value)
+      self.count_on_hand = value
+      process_backorders(count_on_hand - count_on_hand_was)
+
+      save!
+    end
+
+    def in_stock?
+      count_on_hand > 0
+    end
+
+    # Tells whether it's available to be included in a shipment
+    def available?
+      in_stock? || backorderable?
+    end
+
+    def reduce_count_on_hand_to_zero
+      set_count_on_hand(0) if count_on_hand > 0
+    end
+
+    private
+
+    def verify_count_on_hand?
+      count_on_hand_changed? && !backorderable? && (count_on_hand < count_on_hand_was) && (count_on_hand < 0)
+    end
+
+    # Process backorders based on amount of stock received
+    # If stock was -20 and is now -15 (increase of 5 units), then we can process atmost 5 inventory orders.
+    # If stock was -20 but then was -25 (decrease of 5 units), do nothing.
+    def process_backorders(number)
+      return unless number.positive?
+
+      units = backordered_inventory_units.first(number) # We can process atmost n backorders
+
+      units.each do |unit|
+        break unless number.positive?
+
+        if unit.quantity > number
+          # if required quantity is greater than available
+          # split off and fullfill that
+          split = unit.split_inventory!(number)
+          split.fill_backorder
+        else
+          unit.fill_backorder
+        end
+        number -= unit.quantity
+      end
+    end
+
+    def conditional_variant_touch
+      # the variant_id changes from nil when a new stock location is added
+      stock_changed = (saved_change_to_count_on_hand? &&
+                        saved_change_to_count_on_hand.any?(&:zero?)) ||
+        saved_change_to_variant_id?
+
+      variant.touch if !Harpiya::Config.binary_inventory_cache || stock_changed
+    end
+  end
+end

data/app/models/harpiya/stock_location.rb

@@ -0,0 +1,138 @@
+module Harpiya
+  class StockLocation < Harpiya::Base
+    has_many :shipments
+    has_many :stock_items, dependent: :delete_all, inverse_of: :stock_location
+    has_many :stock_movements, through: :stock_items
+
+    belongs_to :state, class_name: 'Harpiya::State', optional: true
+    belongs_to :country, class_name: 'Harpiya::Country'
+
+    validates :name, presence: true, uniqueness: { allow_blank: true, case_sensitive: false }
+
+    scope :active, -> { where(active: true) }
+    scope :order_default, -> { order(default: :desc, name: :asc) }
+
+    after_create :create_stock_items, if: :propagate_all_variants?
+    after_save :ensure_one_default
+
+    def state_text
+      state.try(:abbr) || state.try(:name) || state_name
+    end
+
+    # Wrapper for creating a new stock item respecting the backorderable config
+    def propagate_variant(variant)
+      stock_items.create!(variant: variant, backorderable: backorderable_default)
+    end
+
+    # Return either an existing stock item or create a new one. Useful in
+    # scenarios where the user might not know whether there is already a stock
+    # item for a given variant
+    def set_up_stock_item(variant)
+      stock_item(variant) || propagate_variant(variant)
+    end
+
+    # Returns an instance of StockItem for the variant id.
+    #
+    # @param variant_id [String] The id of a variant.
+    #
+    # @return [StockItem] Corresponding StockItem for the StockLocation's variant.
+    def stock_item(variant_id)
+      stock_items.where(variant_id: variant_id).order(:id).first
+    end
+
+    def stocks?(variant)
+      stock_items.exists?(variant: variant)
+    end
+
+    # Attempts to look up StockItem for the variant, and creates one if not found.
+    # This method accepts an instance of the variant.
+    # Other methods in this model attempt to pass a variant,
+    # but controller actions can pass just the variant id as a parameter.
+    #
+    # @param variant [Variant] Variant instance.
+    #
+    # @return [StockItem] Corresponding StockItem for the StockLocation's variant.
+    def stock_item_or_create(variant)
+      stock_item(variant) || stock_items.create(variant_id: variant.id)
+    end
+
+    def count_on_hand(variant)
+      stock_item(variant).try(:count_on_hand)
+    end
+
+    def backorderable?(variant)
+      stock_item(variant).try(:backorderable?)
+    end
+
+    def restock(variant, quantity, originator = nil)
+      move(variant, quantity, originator)
+    end
+
+    def restock_backordered(variant, quantity, _originator = nil)
+      item = stock_item_or_create(variant)
+      item.update_columns(
+        count_on_hand: item.count_on_hand + quantity,
+        updated_at: Time.current
+      )
+    end
+
+    def unstock(variant, quantity, originator = nil)
+      move(variant, -quantity, originator)
+    end
+
+    def move(variant, quantity, originator = nil)
+      stock_item_or_create(variant).stock_movements.create!(quantity: quantity,
+                                                            originator: originator)
+    end
+
+    def fill_status(variant, quantity)
+      if item = stock_item(variant)
+
+        if item.count_on_hand >= quantity
+          on_hand = quantity
+          backordered = 0
+        else
+          on_hand = item.count_on_hand
+          on_hand = 0 if on_hand < 0
+          backordered = item.backorderable? ? (quantity - on_hand) : 0
+        end
+
+        [on_hand, backordered]
+      else
+        [0, 0]
+      end
+    end
+
+    private
+
+    def create_stock_items
+      variants_scope = Harpiya::Variant
+
+      if self.class.method_defined?(:insert_all) && self.class.method_defined?(:touch_all)
+        prepared_stock_items = variants_scope.ids.map do |variant_id|
+          Hash[
+            'stock_location_id', id,
+            'variant_id', variant_id,
+            'backorderable', backorderable_default,
+            'created_at', Time.current,
+            'updated_at', Time.current
+          ]
+        end
+        if prepared_stock_items.any?
+          stock_items.insert_all(prepared_stock_items)
+          variants_scope.touch_all
+        end
+      else
+        variants_scope.find_each do |variant|
+          propagate_variant(variant)
+        end
+      end
+    end
+
+    def ensure_one_default
+      if default
+        StockLocation.where(default: true).where.not(id: id).update_all(default: false)
+      end
+    end
+  end
+end

data/app/models/harpiya/stock_movement.rb

@@ -0,0 +1,38 @@
+module Harpiya
+  class StockMovement < Harpiya::Base
+    QUANTITY_LIMITS = {
+      max: 2**31 - 1,
+      min: -2**31
+    }.freeze
+
+    belongs_to :stock_item, class_name: 'Harpiya::StockItem', inverse_of: :stock_movements
+    belongs_to :originator, polymorphic: true
+
+    after_create :update_stock_item_quantity
+
+    with_options presence: true do
+      validates :stock_item
+      validates :quantity, numericality: {
+        greater_than_or_equal_to: QUANTITY_LIMITS[:min],
+        less_than_or_equal_to: QUANTITY_LIMITS[:max],
+        only_integer: true
+      }
+    end
+
+    scope :recent, -> { order(created_at: :desc) }
+
+    self.whitelisted_ransackable_attributes = ['quantity']
+
+    def readonly?
+      persisted?
+    end
+
+    private
+
+    def update_stock_item_quantity
+      return unless stock_item.should_track_inventory?
+
+      stock_item.adjust_count_on_hand quantity
+    end
+  end
+end

data/app/models/harpiya/stock_transfer.rb

@@ -0,0 +1,50 @@
+module Harpiya
+  class StockTransfer < Harpiya::Base
+    include Harpiya::Core::NumberGenerator.new(prefix: 'T')
+
+    has_many :stock_movements, as: :originator
+
+    belongs_to :source_location, class_name: 'StockLocation', optional: true
+    belongs_to :destination_location, class_name: 'StockLocation'
+
+    validates :number, uniqueness: true
+
+    self.whitelisted_ransackable_attributes = %w[reference source_location_id destination_location_id number]
+
+    def to_param
+      number
+    end
+
+    def source_movements
+      find_stock_location_with_location_id(source_location_id)
+    end
+
+    def destination_movements
+      find_stock_location_with_location_id(destination_location_id)
+    end
+
+    def transfer(source_location, destination_location, variants)
+      transaction do
+        variants.each_pair do |variant, quantity|
+          source_location&.unstock(variant, quantity, self)
+          destination_location.restock(variant, quantity, self)
+
+          self.source_location = source_location
+          self.destination_location = destination_location
+          save!
+        end
+      end
+    end
+
+    # receive inventory from external vendor
+    def receive(destination_location, variants)
+      transfer(nil, destination_location, variants)
+    end
+
+    private
+
+    def find_stock_location_with_location_id(location_id)
+      stock_movements.joins(:stock_item).where('harpiya_stock_items.stock_location_id' => location_id)
+    end
+  end
+end