spree_core 1.3.5 → 2.0.0.rc1

data/app/models/spree/shipping_rate.rb

@@ -1,10 +1,13 @@
 module Spree
-  class ShippingRate < Struct.new(:id, :shipping_method, :name, :cost, :currency)
-    def initialize(attributes = {})
-      attributes.each do |k, v|
-        self.send("#{k}=", v)
-      end
-    end
+  class ShippingRate < ActiveRecord::Base
+    belongs_to :shipment, class_name: 'Spree::Shipment'
+    belongs_to :shipping_method, class_name: 'Spree::ShippingMethod'
+
+    attr_accessible :id, :shipping_method, :shipment,
+                    :name, :cost, :selected, :shipping_method_id
+
+    delegate :order, :currency, to: :shipment
+    delegate :name, to: :shipping_method
 
     def display_price
       if Spree::Config[:shipment_inc_vat]
@@ -13,7 +16,7 @@ module Spree
         price = cost
       end
 
-      Spree::Money.new(price, { :currency => currency })
+      Spree::Money.new(price, { currency: currency })
     end
   end
 end

data/app/models/spree/state.rb

@@ -1,8 +1,8 @@
 module Spree
   class State < ActiveRecord::Base
-    belongs_to :country
+    belongs_to :country, class_name: 'Spree::Country'
 
-    validates :country, :name, :presence => true
+    validates :country, :name, presence: true
 
     attr_accessible :name, :abbr
 

data/app/models/spree/state_change.rb

@@ -1,7 +1,7 @@
 module Spree
   class StateChange < ActiveRecord::Base
     belongs_to :user
-    belongs_to :stateful, :polymorphic => true
+    belongs_to :stateful, polymorphic: true
     before_create :assign_user
 
     def <=>(other)

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

@@ -0,0 +1,28 @@
+# Used by Prioritizer to adjust item quantities
+# see prioritizer_spec for use cases
+module Spree
+  module Stock
+    class Adjuster
+      attr_accessor :variant, :need, :status
+
+      def initialize(variant, quantity, status)
+        @variant = variant
+        @need = quantity
+        @status = status
+      end
+
+      def adjust(item)
+        if item.quantity >= need
+          item.quantity = need
+          @need = 0
+        elsif item.quantity < need
+          @need -= item.quantity
+        end
+      end
+
+      def fulfilled?
+        @need == 0
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Spree
+  module Stock
+    class AvailabilityValidator < ActiveModel::Validator
+
+      def validate(line_item)
+        quantifier = Stock::Quantifier.new(line_item.variant_id)
+
+        unless quantifier.can_supply? line_item.quantity
+          line_item.errors[:quantity] << I18n.t('validation.exceeds_available_stock')
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Spree
+  module Stock
+    class Coordinator
+      attr_reader :order
+
+      def initialize(order)
+        @order = order
+      end
+
+      def packages
+        packages = Array.new
+        packages = build_packages(packages)
+        packages = prioritize_packages(packages)
+        packages = estimate_packages(packages)
+      end
+
+      private
+      def build_packages(packages)
+        StockLocation.active.each do |stock_location|
+          packer = build_packer(stock_location, order)
+          packages += packer.packages
+        end
+        packages
+      end
+
+      def prioritize_packages(packages)
+        prioritizer = Prioritizer.new(order, 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, order)
+        Packer.new(stock_location, order, 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,39 @@
+module Spree
+  module Stock
+    class Estimator
+      attr_reader :order, :currency
+
+      def initialize(order)
+        @order = order
+        @currency = order.currency
+      end
+
+      def shipping_rates(package)
+        shipping_rates = Array.new
+        shipping_methods = shipping_methods(package)
+        return [] unless shipping_methods
+        shipping_methods.each do |shipping_method|
+          cost = calculate_cost(shipping_method, package)
+
+          shipping_rates << ShippingRate.new( :shipping_method => shipping_method,
+                                              :cost => cost)
+        end
+        shipping_rates.first.selected = true unless shipping_rates.empty?
+        shipping_rates
+      end
+
+      private
+      def shipping_methods(package)
+        shipping_methods = package.shipping_methods
+        shipping_methods.delete_if { |ship_method| !ship_method.calculator.available?(package.contents) }
+        shipping_methods.delete_if { |ship_method| !ship_method.include?(order.ship_address) }
+        shipping_methods.delete_if { |ship_method| !(ship_method.calculator.preferences[:currency].nil? || ship_method.calculator.preferences[:currency] == currency) }
+        shipping_methods
+      end
+
+      def calculate_cost(shipping_method, package)
+        shipping_method.calculator.compute(package)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Spree
+  module Stock
+    class OrderCounter
+      attr_reader :order
+
+      def initialize(order)
+        @order = order
+        @ordered_counts = count_line_items
+        @assigned_counts = count_inventory_units
+      end
+
+      def variants
+        @ordered_counts.keys
+      end
+
+      def variants_with_remaining
+        variants.select { |variant| remaining(variant) > 0 }
+      end
+
+      def remaining?
+        not variants_with_remaining.empty?
+      end
+
+      def ordered(variant)
+        @ordered_counts[variant]
+      end
+
+      def assigned(variant)
+        @assigned_counts[variant]
+      end
+
+      def remaining(variant)
+        @ordered_counts[variant] - @assigned_counts[variant]
+      end
+
+      private
+      def count_line_items
+        counts = Hash.new(0)
+        order.line_items.each do |line_item|
+          counts[line_item.variant] += line_item.quantity
+        end
+        counts
+      end
+
+      def count_inventory_units
+        counts = Hash.new(0)
+        order.inventory_units.each do |inventory_unit|
+          counts[inventory_unit.variant] += 1
+        end
+        counts
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,116 @@
+module Spree
+  module Stock
+    class Package
+      ContentItem = Struct.new(:variant, :quantity, :state)
+
+      attr_reader :stock_location, :order, :contents
+      attr_accessor :shipping_rates
+
+      def initialize(stock_location, order, contents=[])
+        @stock_location = stock_location
+        @order = order
+        @contents = contents
+        @shipping_rates = Array.new
+      end
+
+      def add(variant, quantity, state=:on_hand)
+        contents << ContentItem.new(variant, quantity, state)
+      end
+
+      def weight
+        contents.sum { |item| item.variant.weight * item.quantity }
+      end
+
+      def on_hand
+        contents.select { |item| item.state == :on_hand }
+      end
+
+      def backordered
+        contents.select { |item| item.state == :backordered }
+      end
+
+      def find_item(variant, state=:on_hand)
+        contents.select do |item|
+          item.variant == variant &&
+          item.state == state
+        end.first
+      end
+
+      def quantity(state=nil)
+        case state
+        when :on_hand
+          on_hand.sum { |item| item.quantity }
+        when :backordered
+          backordered.sum { |item| item.quantity }
+        else
+          contents.sum { |item| item.quantity }
+        end
+      end
+
+      def empty?
+        quantity == 0
+      end
+
+      def flattened
+        flat = []
+        contents.each do |item|
+          item.quantity.times do
+            flat << ContentItem.new(item.variant, 1, item.state)
+          end
+        end
+        flat
+      end
+
+      def flattened=(flattened)
+        contents.clear
+        flattened.each do |item|
+          current_item = find_item(item.variant, item.state)
+          if current_item
+            current_item.quantity += 1
+          else
+            add(item.variant, item.quantity, item.state)
+          end
+        end
+      end
+
+      def currency
+        #TODO calculate from first variant?
+      end
+
+      def shipping_categories
+        contents.map { |item| item.variant.shipping_category }.compact.uniq
+      end
+
+      def shipping_methods
+        shipping_categories.map { |sc| sc.shipping_methods }.flatten.uniq
+      end
+
+      def inspect
+        out = "#{order} - "
+        out << contents.map do |content_item|
+          "#{content_item.variant.name} #{content_item.quantity} #{content_item.state}"
+        end.join('/')
+        out
+      end
+
+      def to_shipment
+        shipment = Spree::Shipment.new
+        shipment.order = order
+        shipment.stock_location = stock_location
+        shipment.shipping_rates = shipping_rates
+
+        contents.each do |item|
+          item.quantity.times do |n|
+            unit = shipment.inventory_units.build
+            unit.pending = true
+            unit.order = order
+            unit.variant = item.variant
+            unit.state = item.state.to_s
+          end
+        end
+
+        shipment
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Spree
+  module Stock
+    class Packer
+      attr_reader :stock_location, :order, :splitters
+
+      def initialize(stock_location, order, splitters=[Splitter::Base])
+        @stock_location = stock_location
+        @order = order
+        @splitters = splitters
+      end
+
+      def packages
+        build_splitter.split [default_package]
+      end
+
+      def default_package
+        package = Package.new(stock_location, order)
+        order.line_items.each do |line_item|
+          on_hand, backordered = stock_location.fill_status(line_item.variant, line_item.quantity)
+          package.add line_item.variant, on_hand, :on_hand if on_hand > 0
+          package.add line_item.variant, backordered, :backordered if backordered > 0
+        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, :order
+
+      def initialize(order, packages, adjuster_class=Adjuster)
+        @order = order
+        @packages = packages
+        @adjuster_class = adjuster_class
+      end
+
+      def prioritized_packages
+        sort_packages
+        adjust_packages
+        prune_packages
+        packages
+      end
+
+      private
+      def adjust_packages
+        order.line_items.each do |line_item|
+          adjuster = @adjuster_class.new(line_item.variant, line_item.quantity, :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.variant, adjuster.status
+          adjuster.adjust(item) 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,28 @@
+module Spree
+  module Stock
+    class Quantifier
+      attr_reader :stock_items
+
+      def initialize(variant)
+        @variant = variant
+        @stock_items = Spree::StockItem.joins(:stock_location).where(:variant_id => @variant, Spree::StockLocation.table_name =>{ :active => true})
+      end
+
+      def total_on_hand
+        if Spree::Config.track_inventory_levels
+          stock_items.sum(&:count_on_hand)
+        else
+          Float::INFINITY
+        end
+      end
+
+      def backorderable?
+        stock_items.any?(&:backorderable)
+      end
+
+      def can_supply?(required)
+        total_on_hand >= required || backorderable?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Spree
+  module Stock
+    class RemainingPacker < Packer
+      attr_reader :order_counter
+
+      def initialize(stock_location, order, order_counter=nil)
+        super
+        @order_counter = order_counter || Stock::OrderCounter.new(order)
+      end
+
+      def default_package
+        package = Package.new(stock_location, order)
+        order_counter.variants_with_remaining.each do |variant|
+          on_hand, backordered = stock_status(variant, order_counter.remaining(variant))
+          package.add variant, on_hand, :on_hand if on_hand > 0
+          package.add variant, backordered, :backordered if backordered > 0
+        end
+        package
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Spree
+  module Stock
+    module Splitter
+      class Backordered < 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,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, :order, :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, order, 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 < 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 < 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
+