goca-spree-core 3.1.14.rails.5.0

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

@@ -0,0 +1,27 @@
+# Used by Prioritizer to adjust item quantities
+# see prioritizer_spec for use cases
+module Spree
+  module Stock
+    class Adjuster
+      attr_accessor :inventory_unit, :status, :fulfilled
+
+      def initialize(inventory_unit, status)
+        @inventory_unit = inventory_unit
+        @status = status
+        @fulfilled = false
+      end
+
+      def adjust(package)
+        if fulfilled?
+          package.remove(inventory_unit)
+        else
+          self.fulfilled = true
+        end
+      end
+
+      def fulfilled?
+        fulfilled
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+module Spree
+  module Stock
+    class AvailabilityValidator < ActiveModel::Validator
+      def validate(line_item)
+        unit_count = line_item.inventory_units.size
+        return if unit_count >= line_item.quantity
+
+        quantity = line_item.quantity - unit_count
+        return if quantity.zero?
+
+        return if item_available?(line_item, quantity)
+
+        variant = line_item.variant
+        display_name = "#{variant.name}"
+        display_name += " (#{variant.options_text})" unless variant.options_text.blank?
+
+        line_item.errors[:quantity] << Spree.t(
+          :selected_quantity_not_available,
+          item: display_name.inspect
+        )
+      end
+
+      private
+
+      def item_available?(line_item, quantity)
+        Stock::Quantifier.new(line_item.variant).can_supply?(quantity)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Spree
+  module Stock
+    class ContentItem
+      attr_accessor :inventory_unit, :state
+
+      def initialize(inventory_unit, state = :on_hand)
+        @inventory_unit = inventory_unit
+        @state = state
+      end
+
+      with_options allow_nil: true do
+        delegate :line_item,
+                 :variant, to: :inventory_unit
+        delegate :price, to: :variant
+        delegate :dimension,
+                 :volume,
+                 :weight, to: :variant, prefix: true
+      end
+
+      def weight
+        variant_weight * quantity
+      end
+
+      def on_hand?
+        state.to_s == "on_hand"
+      end
+
+      def backordered?
+        state.to_s == "backordered"
+      end
+
+
+      def amount
+        price * quantity
+      end
+
+      def quantity
+        # Since inventory units don't have a quantity,
+        # make this always 1 for now, leaving ourselves
+        # open to a different possibility in the future,
+        # but this massively simplifies things for now
+        1
+      end
+
+      def volume
+        variant_volume * quantity
+      end
+
+      def dimension
+        variant_dimension * quantity
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module Spree
+  module Stock
+    class Coordinator
+      attr_reader :order, :inventory_units
+
+      def initialize(order, inventory_units = nil)
+        @order = order
+        @inventory_units = inventory_units || InventoryUnitBuilder.new(order).units
+      end
+
+      def shipments
+        packages.map do |package|
+          package.to_shipment.tap { |s| s.address = order.ship_address }
+        end
+      end
+
+      def packages
+        packages = build_packages
+        packages = prioritize_packages(packages)
+        packages = estimate_packages(packages)
+      end
+
+      def build_packages(packages = Array.new)
+        stock_locations_with_requested_variants.each do |stock_location|
+          packages += build_packer(stock_location, inventory_units).packages
+        end
+
+        packages
+      end
+
+      private
+
+      def stock_locations_with_requested_variants
+        Spree::StockLocation.active.joins(:stock_items).
+          where(spree_stock_items: { variant_id: requested_variant_ids })
+      end
+
+      def requested_variant_ids
+        inventory_units.map(&:variant_id).uniq
+      end
+
+      def prioritize_packages(packages)
+        prioritizer = Prioritizer.new(inventory_units, packages)
+        prioritizer.prioritized_packages
+      end
+
+      def estimate_packages(packages)
+        estimator = Estimator.new(order)
+        packages.each do |package|
+          package.shipping_rates = estimator.shipping_rates(package)
+        end
+        packages
+      end
+
+      def build_packer(stock_location, inventory_units)
+        Packer.new(stock_location, inventory_units, splitters(stock_location))
+      end
+
+      def splitters(stock_location)
+        # extension point to return custom splitters for a location
+        Rails.application.config.spree.stock_splitters
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Spree
+  module Stock
+    class Differentiator
+      attr_reader :missing, :packed, :required, :packages, :order
+
+      def initialize(order, packages)
+        @order = order
+        @packages = packages
+        build_packed
+        build_required
+        build_missing
+      end
+
+      def missing?
+        missing.values.any? { |v| v > 0 }
+      end
+
+      private
+      def build_missing
+        @missing = Hash.new(0)
+        required.keys.each do |variant|
+           missing = required[variant] - packed[variant]
+           @missing[variant] = missing if missing > 0
+        end
+      end
+
+      def build_packed
+        @packed = Hash.new(0)
+        packages.each do |package|
+          package.contents.each do |content_item|
+            @packed[content_item.variant] += content_item.quantity
+          end
+        end
+      end
+
+      def build_required
+        @required = Hash.new(0)
+        order.line_items.each do |line_item|
+          @required[line_item.variant] = line_item.quantity
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module Spree
+  module Stock
+    class Estimator
+      include VatPriceCalculation
+
+      attr_reader :order, :currency
+
+      def initialize(order)
+        @order = order
+        @currency = order.currency
+      end
+
+      def shipping_rates(package, shipping_method_filter = ShippingMethod::DISPLAY_ON_FRONT_END)
+        rates = calculate_shipping_rates(package, shipping_method_filter)
+        choose_default_shipping_rate(rates)
+        sort_shipping_rates(rates)
+      end
+
+      private
+      def choose_default_shipping_rate(shipping_rates)
+        unless shipping_rates.empty?
+          shipping_rates.min_by(&:cost).selected = true
+        end
+      end
+
+      def sort_shipping_rates(shipping_rates)
+        shipping_rates.sort_by!(&:cost)
+      end
+
+      def calculate_shipping_rates(package, ui_filter)
+        shipping_methods(package, ui_filter).map do |shipping_method|
+          cost = shipping_method.calculator.compute(package)
+
+          shipping_method.shipping_rates.new(
+            cost: gross_amount(cost, taxation_options_for(shipping_method)),
+            tax_rate: first_tax_rate_for(shipping_method.tax_category)
+          ) if cost
+        end.compact
+      end
+
+      # Override this if you need the prices for shipping methods to be handled just like the
+      # prices for products in terms of included tax manipulation.
+      #
+      def taxation_options_for(shipping_method)
+        {
+          tax_category: shipping_method.tax_category,
+          tax_zone: @order.tax_zone
+        }
+      end
+
+      def first_tax_rate_for(tax_category)
+        return unless @order.tax_zone && tax_category
+        Spree::TaxRate.for_tax_category(tax_category).
+          potential_rates_for_zone(@order.tax_zone).first
+      end
+
+      def shipping_methods(package, display_filter)
+        package.shipping_methods.select do |ship_method|
+          calculator = ship_method.calculator
+
+          ship_method.available_to_display(display_filter) &&
+          ship_method.include?(order.ship_address) &&
+          calculator.available?(package) &&
+          (calculator.preferences[:currency].blank? ||
+           calculator.preferences[:currency] == currency)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Spree
+  module Stock
+    class InventoryUnitBuilder
+      def initialize(order)
+        @order = order
+      end
+
+      def units
+        @order.line_items.flat_map do |line_item|
+          line_item.quantity.times.map do |i|
+            @order.inventory_units.build(
+              pending: true,
+              variant: line_item.variant,
+              line_item: line_item,
+              order: @order
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+module Spree
+  module Stock
+    class Package
+      attr_reader :stock_location, :contents
+      attr_accessor :shipping_rates
+
+      def initialize(stock_location, contents=[])
+        @stock_location = stock_location
+        @contents = contents
+        @shipping_rates = Array.new
+      end
+
+      def add(inventory_unit, state = :on_hand)
+        contents << ContentItem.new(inventory_unit, state) unless find_item(inventory_unit)
+      end
+
+      def add_multiple(inventory_units, state = :on_hand)
+        inventory_units.each { |inventory_unit| add(inventory_unit, state) }
+      end
+
+      def remove(inventory_unit)
+        item = find_item(inventory_unit)
+        @contents -= [item] if item
+      end
+
+      # Fix regression that removed package.order.
+      # Find it dynamically through an inventory_unit.
+      def order
+        contents.detect {|item| !!item.try(:inventory_unit).try(:order) }.try(:inventory_unit).try(:order)
+      end
+
+      def weight
+        contents.sum(&:weight)
+      end
+
+      def on_hand
+        contents.select(&:on_hand?)
+      end
+
+      def backordered
+        contents.select(&:backordered?)
+      end
+
+      def find_item(inventory_unit, state = nil)
+        contents.detect do |item|
+          item.inventory_unit == inventory_unit &&
+            (!state || item.state.to_s == state.to_s)
+        end
+      end
+
+      def quantity(state = nil)
+        matched_contents = state.nil? ? contents : contents.select { |c| c.state.to_s == state.to_s }
+        matched_contents.map(&:quantity).sum
+      end
+
+      def empty?
+        quantity == 0
+      end
+
+      def currency
+        order.currency
+      end
+
+      def shipping_categories
+        contents.map { |item| item.variant.shipping_category }.compact.uniq
+      end
+
+      def shipping_methods
+        shipping_categories.map(&:shipping_methods).reduce(:&).to_a
+      end
+
+      def inspect
+        contents.map do |content_item|
+          "#{content_item.variant.name} #{content_item.state}"
+        end.join(' / ')
+      end
+
+      def to_shipment
+        # At this point we should only have one content item per inventory unit
+        # across the entire set of inventory units to be shipped, which has been
+        # taken care of by the Prioritizer
+        contents.each { |content_item| content_item.inventory_unit.state = content_item.state.to_s }
+
+        Spree::Shipment.new(
+          stock_location: stock_location,
+          shipping_rates: shipping_rates,
+          inventory_units: contents.map(&:inventory_unit)
+        )
+      end
+
+      def contents_by_weight
+        contents.sort { |x, y| y.weight <=> x.weight }
+      end
+
+      def volume
+        contents.sum(&:volume)
+      end
+
+      def dimension
+        contents.sum(&:dimension)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Spree
+  module Stock
+    class Packer
+      attr_reader :stock_location, :inventory_units, :splitters
+
+      def initialize(stock_location, inventory_units, splitters=[Splitter::Base])
+        @stock_location = stock_location
+        @inventory_units = inventory_units
+        @splitters = splitters
+      end
+
+      def packages
+        if splitters.empty?
+          [default_package]
+        else
+          build_splitter.split [default_package]
+        end
+      end
+
+      def default_package
+        package = Package.new(stock_location)
+        inventory_units.group_by(&:variant).each do |variant, variant_inventory_units|
+          units = variant_inventory_units.clone
+          if variant.should_track_inventory?
+            next unless stock_location.stock_item(variant)
+
+            on_hand, backordered = stock_location.fill_status(variant, units.size)
+            package.add_multiple units.slice!(0, on_hand), :on_hand if on_hand > 0
+            package.add_multiple units.slice!(0, backordered), :backordered if backordered > 0
+          else
+            package.add_multiple units
+          end
+
+        end
+        package
+      end
+
+      private
+      def build_splitter
+        splitter = nil
+        splitters.reverse.each do |klass|
+          splitter = klass.new(self, splitter)
+        end
+        splitter
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Spree
+  module Stock
+    class Prioritizer
+      attr_reader :packages, :inventory_units
+
+      def initialize(inventory_units, packages, adjuster_class=Adjuster)
+        @inventory_units = inventory_units
+        @packages = packages
+        @adjuster_class = adjuster_class
+      end
+
+      def prioritized_packages
+        sort_packages
+        adjust_packages
+        prune_packages
+        packages
+      end
+
+      private
+      def adjust_packages
+        inventory_units.each do |inventory_unit|
+          adjuster = @adjuster_class.new(inventory_unit, :on_hand)
+
+          visit_packages(adjuster)
+
+          adjuster.status = :backordered
+          visit_packages(adjuster)
+        end
+      end
+
+      def visit_packages(adjuster)
+        packages.each do |package|
+          item = package.find_item adjuster.inventory_unit, adjuster.status
+          adjuster.adjust(package) if item
+        end
+      end
+
+      def sort_packages
+        # order packages by preferred stock_locations
+      end
+
+      def prune_packages
+        packages.reject! { |pkg| pkg.empty? }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Spree
+  module Stock
+    class Quantifier
+      attr_reader :stock_items, :variant
+
+      def initialize(variant)
+        @variant = variant
+        @stock_items = @variant.stock_items.with_active_stock_location
+      end
+
+      def total_on_hand
+        if variant.should_track_inventory?
+          stock_items.sum(:count_on_hand)
+        else
+          Float::INFINITY
+        end
+      end
+
+      def backorderable?
+        stock_items.any?(&:backorderable)
+      end
+
+      def can_supply?(required = 1)
+        variant.available? && (total_on_hand >= required || backorderable?)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+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.size > 0
+              split_packages << build_package(package.on_hand)
+            end
+
+            if package.backordered.size > 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,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,34 @@
+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
+            contents = package.contents_by_weight
+            break if contents.size == 1
+            # Deleting the second heaviest item in the package should yield best results
+            removed << package.contents.delete(contents[1])
+          end
+          removed
+        end
+      end
+    end
+  end
+end
+