solidus_core 1.0.0.pre

data/app/models/spree/stock/splitter/base.rb

@@ -0,0 +1,28 @@
+module Spree
+  module Stock
+    module Splitter
+      class Base
+        attr_reader :packer, :next_splitter
+
+        def initialize(packer, next_splitter=nil)
+          @packer = packer
+          @next_splitter = next_splitter
+        end
+        delegate :stock_location, to: :packer
+
+        def split(packages)
+          return_next(packages)
+        end
+
+        private
+        def return_next(packages)
+          next_splitter ? next_splitter.split(packages) : packages
+        end
+
+        def build_package(contents=[])
+          Spree::Stock::Package.new(stock_location, contents)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Spree
+  module Stock
+    module Splitter
+      class ShippingCategory < Spree::Stock::Splitter::Base
+        def split(packages)
+          split_packages = []
+          packages.each do |package|
+            split_packages += split_by_category(package)
+          end
+          return_next split_packages
+        end
+
+        private
+        def split_by_category(package)
+          categories = Hash.new { |hash, key| hash[key] = [] }
+          package.contents.each do |item|
+            categories[item.variant.shipping_category_id] << item
+          end
+          hash_to_packages(categories)
+        end
+
+        def hash_to_packages(categories)
+          packages = []
+          categories.each do |id, contents|
+            packages << build_package(contents)
+          end
+          packages
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Spree
+  module Stock
+    module Splitter
+      class Weight < Spree::Stock::Splitter::Base
+        attr_reader :packer, :next_splitter
+
+        cattr_accessor :threshold do
+          150
+        end
+
+        def split(packages)
+          packages.each do |package|
+            removed_contents = reduce package
+            packages << build_package(removed_contents) unless removed_contents.empty?
+          end
+          return_next packages
+        end
+
+        private
+        def reduce(package)
+          removed = []
+          while package.weight > self.threshold
+            break if package.contents.size == 1
+            removed << package.contents.shift
+          end
+          removed
+        end
+      end
+    end
+  end
+end
+

data/app/models/spree/stock_item.rb

@@ -0,0 +1,107 @@
+module Spree
+  class StockItem < Spree::Base
+    acts_as_paranoid
+
+    belongs_to :stock_location, class_name: 'Spree::StockLocation', inverse_of: :stock_items
+    belongs_to :variant, class_name: 'Spree::Variant', inverse_of: :stock_items
+    has_many :stock_movements, inverse_of: :stock_item
+
+    validates_presence_of :stock_location, :variant
+    validates_uniqueness_of :variant_id, scope: [:stock_location_id, :deleted_at]
+    validates :count_on_hand, numericality: { greater_than_or_equal_to: 0 }, if: :verify_count_on_hand?
+
+    delegate :weight, :should_track_inventory?, to: :variant
+
+    after_save :conditional_variant_touch, if: :changed?
+    after_touch { variant.touch }
+
+    # @return [Array<Spree::InventoryUnit>] the backordered inventory units
+    #   associated with this stock item
+    def backordered_inventory_units
+      Spree::InventoryUnit.backordered_for_stock_item(self)
+    end
+
+    # @return [String] the name of this stock item's variant
+    def variant_name
+      variant.name
+    end
+
+    # Adjusts the count on hand by a given value.
+    #
+    # @note This will cause backorders to be processed.
+    # @param value [Fixnum] the amount to change the count on hand by, positive
+    #   or negative values are valid
+    def adjust_count_on_hand(value)
+      self.with_lock do
+        self.count_on_hand = self.count_on_hand + value
+        process_backorders(count_on_hand - count_on_hand_was)
+
+        self.save!
+      end
+    end
+
+    # Sets this stock item's count on hand.
+    #
+    # @note This will cause backorders to be processed.
+    # @param value [Fixnum] the desired count on hand
+    def set_count_on_hand(value)
+      self.count_on_hand = value
+      process_backorders(count_on_hand - count_on_hand_was)
+
+      self.save!
+    end
+
+    # @return [Boolean] true if this stock item's count on hand is not zero
+    def in_stock?
+      self.count_on_hand > 0
+    end
+
+    # @return [Boolean] true if this stock item can be included in a shipment
+    def available?
+      self.in_stock? || self.backorderable?
+    end
+
+    # @note This returns the variant regardless of whether it was soft
+    #   deleted.
+    # @return [Spree::Variant] this stock item's variant.
+    def variant
+      Spree::Variant.unscoped { super }
+    end
+
+    # Sets the count on hand to zero if it not already zero.
+    #
+    # @note This processes backorders if the count on hand is not zero.
+    def reduce_count_on_hand_to_zero
+      self.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
+
+      def count_on_hand=(value)
+        write_attribute(:count_on_hand, value)
+      end
+
+      # Process backorders based on amount of stock received
+      # If stock was -20 and is now -15 (increase of 5 units), then we should process 5 inventory orders.
+      # If stock was -20 but then was -25 (decrease of 5 units), do nothing.
+      def process_backorders(number)
+        if number > 0
+          backordered_inventory_units.first(number).each do |unit|
+            unit.fill_backorder
+          end
+        end
+      end
+
+      def conditional_variant_touch
+        # the variant_id changes from nil when a new stock location is added
+        stock_changed = (count_on_hand_changed? && count_on_hand_change.any? { |c| c < 1 }) || variant_id_changed?
+
+        if !Spree::Config.binary_inventory_cache || stock_changed
+          variant.touch
+        end
+      end
+  end
+end

data/app/models/spree/stock_location.rb

@@ -0,0 +1,128 @@
+module Spree
+  class StockLocation < Spree::Base
+    class InvalidMovementError < StandardError; end
+
+    has_many :shipments
+    has_many :stock_items, dependent: :delete_all, inverse_of: :stock_location
+    has_many :cartons, inverse_of: :stock_location
+    has_many :stock_movements, through: :stock_items
+    has_many :user_stock_locations, dependent: :delete_all
+    has_many :users, through: :user_stock_locations
+
+    belongs_to :state, class_name: 'Spree::State'
+    belongs_to :country, class_name: 'Spree::Country'
+
+    validates_presence_of :name
+    validates_uniqueness_of :code, 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 => "self.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)
+      self.stock_items.create!(variant: variant, backorderable: self.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)
+      self.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
+
+    # Attempts to look up StockItem for the variant, and creates one if not found.
+    # This method accepts an id or instance of the variant since it is used in
+    # multiple ways. Other methods in this model attempt to pass a variant,
+    # but controller actions can pass just the variant id as a parameter.
+    #
+    # @return [StockItem] Corresponding StockItem for the StockLocation's variant.
+    def stock_item_or_create(variant)
+      vid = if variant.is_a?(Variant)
+        variant.id
+      else
+        variant
+      end
+      stock_item(vid) || stock_items.create(variant_id: vid)
+    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.now
+      )
+    end
+
+    def unstock(variant, quantity, originator = nil)
+      move(variant, -quantity, originator)
+    end
+
+    def move(variant, quantity, originator = nil)
+      if quantity < 1 && !stock_item(variant)
+        raise InvalidMovementError.new(Spree.t(:negative_movement_absent_item))
+      end
+      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
+        Variant.find_each { |variant| self.propagate_variant(variant) }
+      end
+
+      def ensure_one_default
+        if self.default
+          StockLocation.where(default: true).where.not(id: self.id).each do |stock_location|
+            stock_location.default = false
+            stock_location.save!
+          end
+        end
+      end
+  end
+end

data/app/models/spree/stock_movement.rb

@@ -0,0 +1,26 @@
+module Spree
+  class StockMovement < Spree::Base
+    belongs_to :stock_item, class_name: 'Spree::StockItem', inverse_of: :stock_movements
+    belongs_to :originator, polymorphic: true
+
+    after_create :update_stock_item_quantity
+
+    validates :stock_item, presence: true
+    validates :quantity, presence: true
+
+    scope :recent, -> { order('created_at DESC') }
+
+    def readonly?
+      !new_record?
+    end
+
+    private
+
+    def update_stock_item_quantity
+      return unless self.stock_item.should_track_inventory?
+      stock_item.adjust_count_on_hand quantity
+    end
+
+  end
+end
+

data/app/models/spree/stock_transfer.rb

@@ -0,0 +1,108 @@
+module Spree
+  class StockTransfer < Spree::Base
+    class InvalidTransferMovement < StandardError; end
+
+    acts_as_paranoid
+
+    has_many :stock_movements, :as => :originator
+    has_many :transfer_items, inverse_of: :stock_transfer
+
+    belongs_to :created_by, :class_name => Spree.user_class.to_s
+    belongs_to :finalized_by, :class_name => Spree.user_class.to_s
+    belongs_to :closed_by, :class_name => Spree.user_class.to_s
+    belongs_to :source_location, :class_name => 'Spree::StockLocation'
+    belongs_to :destination_location, :class_name => 'Spree::StockLocation'
+
+    validates_presence_of :source_location
+    validates_presence_of :destination_location, if: :finalized?
+
+    make_permalink field: :number, prefix: 'T'
+
+    before_destroy :ensure_not_finalized
+
+    def to_param
+      number
+    end
+
+    def finalized?
+      finalized_at.present?
+    end
+
+    def closed?
+      closed_at.present?
+    end
+
+    def shipped?
+      shipped_at.present?
+    end
+
+    def finalizable?
+      !finalized? && !shipped? && !closed?
+    end
+
+    def receivable?
+      finalized? && shipped? && !closed?
+    end
+
+    def ship(tracking_number: nil, shipped_at: nil)
+      update_attributes!(tracking_number: tracking_number, shipped_at: shipped_at)
+    end
+
+    def received_item_count
+      transfer_items.sum(:received_quantity)
+    end
+
+    def expected_item_count
+      transfer_items.sum(:expected_quantity)
+    end
+
+    def source_movements
+      stock_movements.joins(:stock_item)
+        .where('spree_stock_items.stock_location_id' => source_location_id)
+    end
+
+    def destination_movements
+      stock_movements.joins(:stock_item)
+        .where('spree_stock_items.stock_location_id' => destination_location_id)
+    end
+
+    def finalize(finalized_by)
+      if finalizable?
+        self.update_attributes({ finalized_at: Time.now, finalized_by: finalized_by })
+      else
+        errors.add(:base, Spree.t(:stock_transfer_cannot_be_finalized))
+        false
+      end
+    end
+
+    def transfer
+      transaction do
+        transfer_items.each do |item|
+          raise InvalidTransferMovement unless item.valid?
+          source_location.unstock(item.variant, item.expected_quantity, self)
+        end
+      end
+    rescue InvalidTransferMovement
+      errors.add(:base, Spree.t(:not_enough_stock))
+      false
+    end
+
+    def close(closed_by)
+      if receivable?
+        self.update_attributes({ closed_at: Time.now, closed_by: closed_by })
+      else
+        errors.add(:base, Spree.t(:stock_transfer_must_be_receivable))
+        false
+      end
+    end
+
+    private
+
+    def ensure_not_finalized
+      if finalized?
+        errors.add(:base, Spree.t('errors.messages.cannot_delete_finalized_stock_transfer'))
+        return false
+      end
+    end
+  end
+end