solidus_core 1.0.0.pre

data/app/models/spree/shipping_calculator.rb

@@ -0,0 +1,22 @@
+module Spree
+  class ShippingCalculator < Calculator
+
+    def compute_shipment(shipment)
+      raise NotImplementedError, "Please implement 'compute_shipment(shipment)' in your calculator: #{self.class.name}"
+    end
+
+    def compute_package(package)
+      raise NotImplementedError, "Please implement 'compute_package(package)' in your calculator: #{self.class.name}"
+    end
+
+    def available?(package)
+      true
+    end
+
+    private
+    def total(content_items)
+      content_items.map(&:amount).sum
+    end
+  end
+end
+

data/app/models/spree/shipping_category.rb

@@ -0,0 +1,8 @@
+module Spree
+  class ShippingCategory < Spree::Base
+    validates :name, presence: true
+    has_many :products, inverse_of: :shipping_category
+    has_many :shipping_method_categories, inverse_of: :shipping_category
+    has_many :shipping_methods, through: :shipping_method_categories
+  end
+end

data/app/models/spree/shipping_manifest.rb

@@ -0,0 +1,23 @@
+class Spree::ShippingManifest
+  ManifestItem = Struct.new(:line_item, :variant, :quantity, :states)
+
+  def initialize(inventory_units:)
+    @inventory_units = inventory_units
+  end
+
+  def items
+    # Grouping by the ID means that we don't have to call out to the association accessor
+    # This makes the grouping by faster because it results in less SQL cache hits.
+    @inventory_units.group_by(&:variant_id).map do |variant_id, units|
+      units.group_by(&:line_item_id).map do |line_item_id, units|
+
+        states = {}
+        units.group_by(&:state).each { |state, iu| states[state] = iu.count }
+
+        line_item = units.first.line_item
+        variant = units.first.variant
+        ManifestItem.new(line_item, variant, units.length, states)
+      end
+    end.flatten
+  end
+end

data/app/models/spree/shipping_method.rb

@@ -0,0 +1,69 @@
+module Spree
+  class ShippingMethod < Spree::Base
+    acts_as_paranoid
+    include Spree::CalculatedAdjustments
+    DISPLAY = [:both, :front_end, :back_end]
+
+    default_scope -> { where(deleted_at: nil) }
+
+    has_many :shipping_method_categories, :dependent => :destroy
+    has_many :shipping_categories, through: :shipping_method_categories
+    has_many :shipping_rates, inverse_of: :shipping_method
+    has_many :shipments, :through => :shipping_rates
+    has_many :cartons, inverse_of: :shipping_method
+
+    has_and_belongs_to_many :zones, :join_table => 'spree_shipping_methods_zones',
+                                    :class_name => 'Spree::Zone',
+                                    :foreign_key => 'shipping_method_id'
+
+    belongs_to :tax_category, :class_name => 'Spree::TaxCategory'
+
+    validates :name, presence: true
+
+    validate :at_least_one_shipping_category
+
+    def include?(address)
+      return false unless address
+      zones.any? do |zone|
+        zone.include?(address)
+      end
+    end
+
+    def build_tracking_url(tracking)
+      return if tracking.blank? || tracking_url.blank?
+      tracking_url.gsub(/:tracking/, ERB::Util.url_encode(tracking)) # :url_encode exists in 1.8.7 through 2.1.0
+    end
+
+    def self.calculators
+      spree_calculators.send(model_name_without_spree_namespace).select{ |c| c < Spree::ShippingCalculator }
+    end
+
+    # Some shipping methods are only meant to be set via backend
+    def frontend?
+      self.display_on != "back_end"
+    end
+
+    def tax_category
+      Spree::TaxCategory.unscoped { super }
+    end
+
+    private
+      def compute_amount(calculable)
+        self.calculator.compute(calculable)
+      end
+
+      def at_least_one_shipping_category
+        if self.shipping_categories.empty?
+          self.errors[:base] << "You need to select at least one shipping category"
+        end
+      end
+
+      def self.on_backend_query
+        "#{table_name}.display_on != 'front_end' OR #{table_name}.display_on IS NULL"
+      end
+
+      def self.on_frontend_query
+        "#{table_name}.display_on != 'back_end' OR #{table_name}.display_on IS NULL"
+      end
+  end
+end

data/app/models/spree/shipping_method_category.rb

@@ -0,0 +1,6 @@
+module Spree
+  class ShippingMethodCategory < Spree::Base
+    belongs_to :shipping_method, class_name: 'Spree::ShippingMethod'
+    belongs_to :shipping_category, class_name: 'Spree::ShippingCategory', inverse_of: :shipping_method_categories
+  end
+end

data/app/models/spree/shipping_rate.rb

@@ -0,0 +1,57 @@
+module Spree
+  class ShippingRate < Spree::Base
+    belongs_to :shipment, class_name: 'Spree::Shipment'
+    belongs_to :shipping_method, class_name: 'Spree::ShippingMethod', inverse_of: :shipping_rates
+    belongs_to :tax_rate, class_name: 'Spree::TaxRate'
+
+    delegate :order, :currency, to: :shipment
+    delegate :name, to: :shipping_method
+
+    def display_base_price
+      Spree::Money.new(cost, currency: currency)
+    end
+
+    def calculate_tax_amount
+      tax_rate.calculator.compute_shipping_rate(self)
+    end
+
+    def display_price
+      price = display_base_price.to_s
+      if tax_rate
+        tax_amount = calculate_tax_amount
+        if tax_amount != 0
+          if tax_rate.included_in_price?
+            if tax_amount > 0
+              amount = "#{display_tax_amount(tax_amount)} #{tax_rate.name}"
+              price += " (#{Spree.t(:incl)} #{amount})"
+            else
+              amount = "#{display_tax_amount(tax_amount*-1)} #{tax_rate.name}"
+              price += " (#{Spree.t(:excl)} #{amount})"
+            end
+          else
+            amount = "#{display_tax_amount(tax_amount)} #{tax_rate.name}"
+            price += " (+ #{amount})"
+          end
+        end
+      end
+      price
+    end
+    alias_method :display_cost, :display_price
+
+    def display_tax_amount(tax_amount)
+      Spree::Money.new(tax_amount, currency: currency)
+    end
+
+    def shipping_method
+      Spree::ShippingMethod.unscoped { super }
+    end
+
+    def shipping_method_code
+      shipping_method.code
+    end
+
+    def tax_rate
+      Spree::TaxRate.unscoped { super }
+    end
+  end
+end

data/app/models/spree/state.rb

@@ -0,0 +1,30 @@
+module Spree
+  class State < Spree::Base
+    belongs_to :country, class_name: 'Spree::Country'
+    has_many :addresses, dependent: :nullify
+
+    validates :country, :name, presence: true
+
+    def self.find_all_by_name_or_abbr(name_or_abbr)
+      where('name = ? OR abbr = ?', name_or_abbr, name_or_abbr)
+    end
+
+    # table of { country.id => [ state.id , state.name ] }, arrays sorted by name
+    # blank is added elsewhere, if needed
+    def self.states_group_by_country_id
+      state_info = Hash.new { |h, k| h[k] = [] }
+      self.order('name ASC').each { |state|
+        state_info[state.country_id.to_s].push [state.id, state.name]
+      }
+      state_info
+    end
+
+    def <=>(other)
+      name <=> other.name
+    end
+
+    def to_s
+      name
+    end
+  end
+end

data/app/models/spree/state_change.rb

@@ -0,0 +1,15 @@
+module Spree
+  class StateChange < Spree::Base
+    belongs_to :user
+    belongs_to :stateful, polymorphic: true
+    before_create :assign_user
+
+    def <=>(other)
+      created_at <=> other.created_at
+    end
+
+    def assign_user
+      true   # don't stop the filters
+    end
+  end
+end

data/app/models/spree/static_model_preferences.rb

@@ -0,0 +1,32 @@
+module Spree
+  class StaticModelPreferences
+    def initialize(model_class, name, preferences={})
+      @name = name
+      @model_class = model_class
+      @preferences = preferences.dup.freeze
+
+      validate_preferences
+    end
+
+    delegate :keys, :fetch, to: :@preferences
+
+    def []=(name, value)
+      puts "Ignoring assignment of preference #{name}"
+    end
+
+    private
+
+    def validate_preferences
+      model_preferences = @model_class.defined_preferences
+      defined_preferences = @preferences.keys
+
+      (model_preferences - defined_preferences).each do |pref|
+        puts "WARNING: Missing definition for #{pref}"
+      end
+
+      (defined_preferences - model_preferences).each do |pref|
+        puts "WARNING: Unknown preference #{pref}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Spree
+  module Stock
+    # Used by Prioritizer to adjust item quantities.
+    #
+    # See spec/models/spree/stock/prioritizer_spec.rb for use cases.
+    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,35 @@
+module Spree
+  module Stock
+    class AvailabilityValidator < ActiveModel::Validator
+      def validate(line_item)
+        units_by_shipment = line_item.inventory_units.group_by(&:shipment)
+
+        if units_by_shipment.blank?
+          ensure_in_stock(line_item, line_item.quantity)
+        else
+          units_by_shipment.each do |shipment, inventory_units|
+            ensure_in_stock(line_item, inventory_units.size, shipment.stock_location)
+          end
+        end
+
+        line_item.errors[:quantity].empty?
+      end
+
+      private
+
+      def ensure_in_stock(line_item, quantity, stock_location = nil)
+        quantifier = Stock::Quantifier.new(line_item.variant, stock_location)
+        unless quantifier.can_supply?(quantity)
+          variant = line_item.variant
+          display_name = %Q{#{variant.name}}
+          display_name += %Q{ (#{variant.options_text})} unless variant.options_text.blank?
+
+          line_item.errors[:quantity] << Spree.t(
+            :selected_quantity_not_available,
+            item: display_name.inspect
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+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
+
+      def variant
+        inventory_unit.variant
+      end
+
+      def weight
+        variant.weight * quantity
+      end
+
+      def line_item
+        inventory_unit.line_item
+      end
+
+      def on_hand?
+        state.to_s == "on_hand"
+      end
+
+      def backordered?
+        state.to_s == "backordered"
+      end
+
+      def price
+        variant.price
+      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
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+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
+        @preallocated_inventory_units = []
+      end
+
+      def shipments
+        packages.map do |package|
+          package.to_shipment.tap { |s| s.address = order.ship_address }
+        end
+      end
+
+      def packages
+        packages = build_location_configured_packages
+        packages = build_packages(packages)
+        packages = prioritize_packages(packages)
+        packages = estimate_packages(packages)
+      end
+
+      # Build packages for the inventory units that have preferred stock locations first
+      #
+      # Certain variants have been selected to be fulfilled from a particular stock
+      # location during the process of the order being created. The rest of the
+      # service objects the coordinator uses do a lot of automated logic to
+      # determine which stock location is best for the inventory unit to be
+      # fulfilled from, but for these special snowflakes we KNOW which stock
+      # location they should be fulfilled from. So rather than sending these units
+      # through the rest of the packing / prioritization, lets just put them
+      # in packages we know they should be in and deal with other automatically-
+      # handled inventory units otherwise.
+      def build_location_configured_packages(packages = Array.new)
+        order.order_stock_locations.where(shipment_fulfilled: false).group_by(&:stock_location).each do |stock_location, stock_location_configurations|
+          units = stock_location_configurations.flat_map do |stock_location_configuration|
+            unallocated_inventory_units.select { |iu| iu.variant == stock_location_configuration.variant }.take(stock_location_configuration.quantity)
+          end
+          packer = build_packer(stock_location, units)
+          packages += packer.packages
+          @preallocated_inventory_units += units
+        end
+        packages
+      end
+
+      # Build packages as per stock location
+      #
+      # It needs to check whether each stock location holds at least one stock
+      # item for the order. In case none is found it wouldn't make any sense
+      # to build a package because it would be empty. Plus we avoid errors down
+      # the stack because it would assume the stock location has stock items
+      # for the given order
+      #
+      # Returns an array of Package instances
+      def build_packages(packages = Array.new)
+        StockLocation.active.each do |stock_location|
+          units_for_location = unallocated_inventory_units.select { |unit| stock_location.stock_item(unit.variant) }
+          next unless units_for_location.any?
+          packer = build_packer(stock_location, units_for_location)
+          packages += packer.packages
+        end
+        packages
+      end
+
+      private
+
+      def unallocated_inventory_units
+        inventory_units - @preallocated_inventory_units
+      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