solidus_core 1.0.0.pre

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
+      attr_reader :order, :currency
+
+      # @param order [Spree::Order] the order whose shipping rates to estimate
+      def initialize(order)
+        @order = order
+        @currency = order.currency
+      end
+
+      # Estimate the shipping rates for a package.
+      #
+      # @param package [Spree::Stock::Package] the package to be shipped
+      # @param frontend_only [Boolean] restricts the shipping methods to only
+      #   those marked frontend if truthy
+      # @return [Array<Spree::ShippingRate>] the shipping rates sorted by
+      #   descending cost, with the least costly marked "selected"
+      def shipping_rates(package, frontend_only = true)
+        rates = calculate_shipping_rates(package)
+        rates.select! { |rate| rate.shipping_method.frontend? } if frontend_only
+        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)
+        shipping_methods(package).map do |shipping_method|
+          cost = shipping_method.calculator.compute(package)
+          tax_category = shipping_method.tax_category
+          if tax_category
+            tax_rate = tax_category.tax_rates.detect do |rate|
+              # If the rate's zone matches the order's zone, a positive adjustment will be applied.
+              # If the rate is from the default tax zone, then a negative adjustment will be applied.
+              # See the tests in shipping_rate_spec.rb for an example of this.d
+              rate.zone == order.tax_zone || rate.zone.default_tax?
+            end
+          end
+
+          if cost
+            rate = shipping_method.shipping_rates.new(cost: cost)
+            rate.tax_rate = tax_rate if tax_rate
+          end
+
+          rate
+        end.compact
+      end
+
+      def shipping_methods(package)
+        package.shipping_methods.select do |ship_method|
+          calculator = ship_method.calculator
+          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/inventory_validator.rb

@@ -0,0 +1,14 @@
+module Spree
+  module Stock
+    class InventoryValidator < ActiveModel::Validator
+      def validate(line_item)
+        if line_item.inventory_units.count != line_item.quantity
+          line_item.errors[:inventory] << Spree.t(
+            :inventory_not_available,
+            item: line_item.variant.name
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+module Spree
+  module Stock
+    class Package
+      attr_reader :stock_location, :contents
+      attr_accessor :shipping_rates
+
+      # @param stock_location [Spree::StockLocation] the stock location this package originates from
+      # @param contents [Array<Spree::Stock::ContentItem>] the contents of this package
+      def initialize(stock_location, contents=[])
+        @stock_location = stock_location
+        @contents = contents
+        @shipping_rates = Array.new
+      end
+
+      # Adds an inventory unit to this package.
+      #
+      # @param inventory_unit [Spree::InventoryUnit] an inventory unit to be
+      #   added to this package
+      # @param state [:on_hand, :backordered] the state of the item to be
+      #   added to this package
+      def add(inventory_unit, state = :on_hand)
+        contents << ContentItem.new(inventory_unit, state) unless find_item(inventory_unit)
+      end
+
+      # Adds multiple inventory units to this package.
+      #
+      # @param inventory_units [Array<Spree::InventoryUnit>] a collection of
+      #   inventory units to be added to this package
+      # @param state [:on_hand, :backordered] the state of the items to be
+      #   added to this package
+      def add_multiple(inventory_units, state = :on_hand)
+        inventory_units.each { |inventory_unit| add(inventory_unit, state) }
+      end
+
+      # Removes a given inventory unit from this package.
+      #
+      # @param inventory_unit [Spree::InventoryUnit] the inventory unit to be
+      #   removed from this package
+      def remove(inventory_unit)
+        item = find_item(inventory_unit)
+        @contents -= [item] if item
+      end
+
+      # @return [Spree::Order] the order associated with this package
+      def order
+        # Fix regression that removed package.order.
+        # Find it dynamically through an inventory_unit.
+        contents.detect {|item| !!item.try(:inventory_unit).try(:order) }.try(:inventory_unit).try(:order)
+      end
+
+      # @return [Float] the summed weight of the contents of this package
+      def weight
+        contents.sum(&:weight)
+      end
+
+      # @return [Array<Spree::Stock::ContentItem>] the content items in this
+      #   package which are on hand
+      def on_hand
+        contents.select(&:on_hand?)
+      end
+
+      # @return [Array<Spree::Stock::ContentItem>] the content items in this
+      #   package which are backordered
+      def backordered
+        contents.select(&:backordered?)
+      end
+
+      # Find a content item in this package by inventory unit and optionally
+      # state.
+      #
+      # @param inventory_unit [Spree::InventoryUnit] the desired inventory
+      #   unit
+      # @param state [:backordered, :on_hand, nil] the state of the desired
+      #   content item, or nil for any state
+      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
+
+      # @param state [:backordered, :on_hand, nil] the state of the content
+      #   items of which we want the quantity, or nil for the full quantity
+      # @return [Fixnum] the number of inventory units in the package,
+      #   counting only those in the given state if it was specified
+      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
+
+      # @return [Boolean] true if there are no inventory units in this
+      #   package
+      def empty?
+        quantity == 0
+      end
+
+      # @return [String] the currency of the order this package belongs to
+      def currency
+        order.currency
+      end
+
+      # @return [Array<Spree::ShippingCategory>] the shipping categories of the
+      #   variants in this package
+      def shipping_categories
+        contents.map { |item| item.variant.shipping_category }.compact.uniq
+      end
+
+      # @return [Array<Spree::ShippingMethod>] the shipping methods available
+      #   for this pacakges shipping categories
+      def shipping_methods
+        shipping_categories.map(&:shipping_methods).reduce(:&).to_a
+      end
+
+      # @return [Spree::Shipment] a new shipment containing this package's
+      #   inventory units, with the appropriate shipping rates and associated
+      #   with the correct stock location
+      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
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+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.count)
+            raise Spree::Order::InsufficientStock unless on_hand > 0 || backordered > 0
+            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,47 @@
+module Spree
+  module Stock
+    class Quantifier
+      attr_reader :stock_items
+
+      def initialize(variant, stock_location = nil)
+        @variant = variant
+        where_args = { variant_id: @variant }
+        if stock_location
+          where_args.merge!(stock_location: stock_location)
+        else
+          where_args.merge!(Spree::StockLocation.table_name => { active: true })
+        end
+        @stock_items = Spree::StockItem.joins(:stock_location).where(where_args)
+      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/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.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