solidus_core_devise_token_auth 2.8.0.alpha.0

data/app/models/spree/stock/quantifier.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Spree
+  module Stock
+    class Quantifier
+      attr_reader :stock_items
+
+      # @param [Variant] variant The variant to check inventory for.
+      # @param [StockLocation, Integer] stock_location The stock_location to check inventory in. If unspecified it will check inventory in all available StockLocations
+      def initialize(variant, stock_location = nil)
+        @variant = variant
+        @stock_items = Spree::StockItem.where(variant_id: variant)
+        if stock_location
+          @stock_items.where!(stock_location: stock_location)
+        else
+          @stock_items.joins!(:stock_location).merge!(Spree::StockLocation.active)
+        end
+      end
+
+      # Returns the total number of inventory units on hand for the variant.
+      #
+      # @return [Fixnum] number of inventory units on hand, or infinity if
+      #   inventory is not tracked on the variant.
+      def total_on_hand
+        if @variant.should_track_inventory?
+          stock_items.sum(:count_on_hand)
+        else
+          Float::INFINITY
+        end
+      end
+
+      # Checks if any of its stock items are backorderable.
+      #
+      # @return [Boolean] true if any stock items are backorderable
+      def backorderable?
+        stock_items.any?(&:backorderable)
+      end
+
+      # Checks if it is possible to supply a given number of units.
+      #
+      # @param required [Fixnum] the number of required stock units
+      # @return [Boolean] true if we have the required amount on hand or the
+      #   variant is backorderable, otherwise false
+      def can_supply?(required)
+        total_on_hand >= required || backorderable?
+      end
+    end
+  end
+end

data/app/models/spree/stock/shipping_rate_selector.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Spree
+  module Stock
+    class ShippingRateSelector
+      attr_reader :shipping_rates
+
+      def initialize(shipping_rates)
+        @shipping_rates = shipping_rates
+      end
+
+      def find_default
+        shipping_rates.min_by(&:cost)
+      end
+    end
+  end
+end

data/app/models/spree/stock/shipping_rate_sorter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Spree
+  module Stock
+    class ShippingRateSorter
+      attr_reader :shipping_rates
+
+      def initialize(shipping_rates)
+        @shipping_rates = shipping_rates
+      end
+
+      def sort
+        shipping_rates.sort_by(&:cost)
+      end
+    end
+  end
+end

data/app/models/spree/stock/simple_coordinator.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Spree
+  module Stock
+    # A simple implementation of Stock Coordination
+    #
+    # The algorithm for allocating inventory is naive:
+    #   * For each available Stock Location
+    #     * Allocate as much on hand inventory as possible from this location
+    #     * Remove the amount allocated from the amount desired
+    #   * Repeat but for backordered inventory
+    #   * Combine allocated and on hand inventory into a single shipment per-location
+    #
+    # After allocation, splitters are run on each Package (as configured in
+    # Spree::Config.environment.stock_splitters)
+    #
+    # Finally, shipping rates are calculated using the class configured as
+    # Spree::Config.stock.estimator_class.
+    class SimpleCoordinator
+      attr_reader :order
+
+      def initialize(order, inventory_units = nil)
+        @order = order
+        @inventory_units = inventory_units || InventoryUnitBuilder.new(order).units
+        @splitters = Spree::Config.environment.stock_splitters
+        @stock_locations = Spree::Config.stock.location_sorter_class.new(Spree::StockLocation.active).sort
+
+        @inventory_units_by_variant = @inventory_units.group_by(&:variant)
+        @desired = Spree::StockQuantities.new(@inventory_units_by_variant.transform_values(&:count))
+        @availability = Spree::Stock::Availability.new(
+          variants: @desired.variants,
+          stock_locations: @stock_locations
+        )
+      end
+
+      def shipments
+        @shipments ||= build_shipments
+      end
+
+      private
+
+      def build_shipments
+        # Allocate any available on hand inventory
+        on_hand_packages = allocate_inventory(@availability.on_hand_by_stock_location_id)
+
+        # allocate any remaining desired inventory from backorders
+        backordered_packages = allocate_inventory(@availability.backorderable_by_stock_location_id)
+
+        unless @desired.empty?
+          raise Spree::Order::InsufficientStock
+        end
+
+        packages = @stock_locations.map do |stock_location|
+          # Combine on_hand and backorders into a single package per-location
+          on_hand = on_hand_packages[stock_location.id] || Spree::StockQuantities.new
+          backordered = backordered_packages[stock_location.id] || Spree::StockQuantities.new
+
+          # Skip this location it has no inventory
+          next if on_hand.empty? && backordered.empty?
+
+          # Turn our raw quantities into a Stock::Package
+          package = Spree::Stock::Package.new(stock_location)
+          package.add_multiple(get_units(on_hand), :on_hand)
+          package.add_multiple(get_units(backordered), :backordered)
+
+          package
+        end.compact
+
+        # Split the packages
+        packages = split_packages(packages)
+
+        # Turn the Stock::Packages into a Shipment with rates
+        packages.map do |package|
+          shipment = package.shipment = package.to_shipment
+          shipment.shipping_rates = Spree::Config.stock.estimator_class.new.shipping_rates(package)
+          shipment
+        end
+      end
+
+      def split_packages(initial_packages)
+        initial_packages.flat_map do |initial_package|
+          stock_location = initial_package.stock_location
+          Spree::Stock::SplitterChain.new(stock_location, @splitters).split([initial_package])
+        end
+      end
+
+      def allocate_inventory(availability_by_location)
+        sorted_availability = sort_availability(availability_by_location)
+
+        sorted_availability.transform_values do |available|
+          # Find the desired inventory which is available at this location
+          packaged = available & @desired
+
+          # Remove found inventory from desired
+          @desired -= packaged
+
+          packaged
+        end
+      end
+
+      def sort_availability(availability)
+        sorted_availability = availability.sort_by do |stock_location_id, _|
+          @stock_locations.find_index do |stock_location|
+            stock_location.id == stock_location_id
+          end
+        end
+
+        Hash[sorted_availability]
+      end
+
+      def get_units(quantities)
+        # Change our raw quantities back into inventory units
+        quantities.flat_map do |variant, quantity|
+          @inventory_units_by_variant[variant].shift(quantity)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Spree
+  module Stock
+    module Splitter
+      class Backordered < Spree::Stock::Splitter::Base
+        def split(packages)
+          split_packages = []
+          packages.each do |package|
+            if package.on_hand.count > 0
+              split_packages << build_package(package.on_hand)
+            end
+
+            if package.backordered.count > 0
+              split_packages << build_package(package.backordered)
+            end
+          end
+          return_next split_packages
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Spree
+  module Stock
+    module Splitter
+      class Base
+        attr_reader :stock_location, :next_splitter
+
+        def initialize(stock_location_or_packer, next_splitter = nil)
+          if stock_location_or_packer.is_a?(Spree::StockLocation)
+            @stock_location = stock_location_or_packer
+          else
+            Spree::Deprecation.warn("Initializing Splitters with a Packer is DEPRECATED. Pass a StockLocation instead.")
+            @stock_location = stock_location_or_packer.stock_location
+          end
+          @next_splitter = next_splitter
+        end
+
+        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,35 @@
+# frozen_string_literal: true
+
+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 @@
+# frozen_string_literal: true
+
+module Spree
+  module Stock
+    module Splitter
+      class Weight < Spree::Stock::Splitter::Base
+        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 > threshold
+            break if package.contents.size == 1
+            removed << package.contents.shift
+          end
+          removed
+        end
+      end
+    end
+  end
+end

data/app/models/spree/stock/splitter_chain.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Spree
+  module Stock
+    class SplitterChain
+      attr_reader :stock_location
+
+      def initialize(stock_location, splitter_classes = [])
+        @stock_location = stock_location
+        @splitter_classes = splitter_classes
+      end
+
+      def split(initial_packages)
+        initial_packages = Array(initial_packages)
+
+        if @splitter_classes.empty?
+          initial_packages
+        else
+          build_splitter.split(initial_packages)
+        end
+      end
+
+      private
+
+      def build_splitter
+        splitter = nil
+        @splitter_classes.reverse_each do |klass|
+          splitter = klass.new(stock_location, splitter)
+        end
+        splitter
+      end
+    end
+  end
+end

data/app/models/spree/stock_item.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require 'discard'
+
+module Spree
+  class StockItem < Spree::Base
+    acts_as_paranoid
+    include Spree::ParanoiaDeprecations
+
+    include Discard::Model
+    self.discard_column = :deleted_at
+
+    belongs_to :stock_location, class_name: 'Spree::StockLocation', inverse_of: :stock_items
+    belongs_to :variant, -> { with_deleted }, class_name: 'Spree::Variant', inverse_of: :stock_items
+    has_many :stock_movements, inverse_of: :stock_item
+
+    validates :stock_location, :variant, presence: true
+    validates :variant_id, uniqueness: { scope: [:stock_location_id, :deleted_at] }, allow_blank: true, unless: :deleted_at
+    validates :count_on_hand, numericality: { greater_than_or_equal_to: 0 }, unless: :backorderable?
+
+    delegate :weight, :should_track_inventory?, to: :variant
+
+    # @return [String] the name of this stock item's variant
+    delegate :name, to: :variant, prefix: true
+
+    after_save :conditional_variant_touch, if: :saved_changes?
+    after_touch { variant.touch }
+
+    self.whitelisted_ransackable_attributes = ['count_on_hand', 'stock_location_id']
+
+    # @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
+
+    # 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)
+      with_lock do
+        self.count_on_hand = count_on_hand + value
+        process_backorders(count_on_hand - count_on_hand_was)
+
+        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)
+
+      save!
+    end
+
+    # @return [Boolean] true if this stock item's count on hand is not zero
+    def in_stock?
+      count_on_hand > 0
+    end
+
+    # @return [Boolean] true if this stock item can be included in a shipment
+    def available?
+      in_stock? || backorderable?
+    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
+      set_count_on_hand(0) if count_on_hand > 0
+    end
+
+    def fill_status(quantity)
+      if count_on_hand >= quantity
+        on_hand = quantity
+        backordered = 0
+      else
+        on_hand = count_on_hand
+        on_hand = 0 if on_hand < 0
+        backordered = backorderable? ? (quantity - on_hand) : 0
+      end
+
+      [on_hand, backordered]
+    end
+
+    private
+
+    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(&:fill_backorder)
+      end
+    end
+
+    def conditional_variant_touch
+      variant.touch if inventory_cache_threshold.nil? || should_touch_variant?
+    end
+
+    def should_touch_variant?
+      # the variant_id changes from nil when a new stock location is added
+      inventory_cache_threshold &&
+        (saved_change_to_count_on_hand && saved_change_to_count_on_hand.any? { |c| c < inventory_cache_threshold }) ||
+        saved_change_to_variant_id?
+    end
+
+    def inventory_cache_threshold
+      # only warn if store is setting binary_inventory_cache (default = false)
+      @cache_threshold ||= if Spree::Config.binary_inventory_cache
+        Spree::Deprecation.warn "Spree::Config.binary_inventory_cache=true is DEPRECATED. Instead use Spree::Config.inventory_cache_threshold=1"
+        1
+      else
+        Spree::Config.inventory_cache_threshold
+      end
+    end
+  end
+end

data/app/models/spree/stock_location.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Spree
+  # Records the name and addresses from which stock items are fulfilled in
+  # cartons.
+  #
+  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'
+
+    has_many :shipping_method_stock_locations, dependent: :destroy
+    has_many :shipping_methods, through: :shipping_method_stock_locations
+
+    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: :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
+
+    # 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.current
+      )
+    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(I18n.t('spree.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)
+        item.fill_status(quantity)
+      else
+        [0, 0]
+      end
+    end
+
+    private
+
+    def create_stock_items
+      Spree::Variant.find_each { |variant| propagate_variant(variant) }
+    end
+
+    def ensure_one_default
+      if default
+        Spree::StockLocation.where(default: true).where.not(id: 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,28 @@
+# frozen_string_literal: true
+
+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) }
+
+    self.whitelisted_ransackable_attributes = ['quantity']
+
+    def readonly?
+      !new_record?
+    end
+
+    private
+
+    def update_stock_item_quantity
+      return unless stock_item.should_track_inventory?
+      stock_item.adjust_count_on_hand quantity
+    end
+  end
+end