solidus_core_devise_token_auth 2.8.0.alpha.0

data/app/models/spree/shipping_rate.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Spree
+  # Records the costs of different shipping methods for a shipment and which
+  # method has been selected to deliver the shipment.
+  #
+  class ShippingRate < Spree::Base
+    belongs_to :shipment, class_name: 'Spree::Shipment', touch: true
+    belongs_to :shipping_method, -> { with_deleted }, class_name: 'Spree::ShippingMethod', inverse_of: :shipping_rates
+
+    has_many :taxes,
+             class_name: "Spree::ShippingRateTax",
+             foreign_key: "shipping_rate_id",
+             inverse_of: :shipping_rate,
+             dependent: :destroy
+
+    delegate :order, :currency, to: :shipment
+    delegate :name, :tax_category, :tax_category_id, to: :shipping_method
+    delegate :code, to: :shipping_method, prefix: true
+    alias_attribute :amount, :cost
+
+    alias_method :discounted_amount, :amount
+    deprecate discounted_amount: :total_before_tax, deprecator: Spree::Deprecation
+    alias_method :total_before_tax, :amount
+
+    extend DisplayMoney
+    money_methods :amount
+
+    def display_price
+      price = display_amount.to_s
+
+      return price if taxes.to_a.empty? || amount == 0
+
+      tax_explanations = taxes.map(&:label).join(tax_label_separator)
+
+      I18n.t 'spree.shipping_rate.display_price.display_price_with_explanations',
+             price: price,
+             explanations: tax_explanations
+    end
+    alias_method :display_cost, :display_price
+
+    private
+
+    def tax_label_separator
+      I18n.t 'spree.shipping_rate.display_price.tax_label_separator'
+    end
+  end
+end

data/app/models/spree/shipping_rate_tax.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Spree
+  # Used to persist shipping rate tax estimations.
+  # @attr [Spree::ShippingRate] shipping_rate The shipping rate to be taxed
+  # @attr [Spree::TaxRate] tax_rate The tax rate used to calculate the tax amount
+  # @since 1.3.0
+  # @see Spree::Tax::ShippingRateTaxer
+  class ShippingRateTax < ActiveRecord::Base
+    belongs_to :shipping_rate, class_name: "Spree::ShippingRate"
+    belongs_to :tax_rate, class_name: "Spree::TaxRate"
+
+    extend DisplayMoney
+    money_methods :absolute_amount
+
+    delegate :currency, to: :shipping_rate, allow_nil: true
+
+    def label
+      I18n.t translation_key,
+        scope: 'spree.shipping_rate_tax.label',
+        amount: display_absolute_amount,
+        tax_rate_name: tax_rate.name
+    end
+
+    def absolute_amount
+      amount.abs
+    end
+
+    private
+
+    def translation_key
+      if tax_rate.included_in_price?
+         :vat
+       else
+         :sales_tax
+      end
+    end
+  end
+end

data/app/models/spree/state.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Spree
+  class State < Spree::Base
+    belongs_to :country, class_name: 'Spree::Country'
+    has_many :addresses, dependent: :nullify
+
+    validates :country, :name, presence: true
+
+    scope :with_name_or_abbr, ->(name_or_abbr) do
+      where(
+        arel_table[:name].matches(name_or_abbr).or(
+          arel_table[:abbr].matches(name_or_abbr)
+        )
+      )
+    end
+    class << self
+      alias_method :find_all_by_name_or_abbr, :with_name_or_abbr
+      deprecate find_all_by_name_or_abbr: :with_name_or_abbr, deprecator: Spree::Deprecation
+    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] = [] }
+      order(:name).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,17 @@
+# frozen_string_literal: true
+
+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/stock/availability.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Spree
+  module Stock
+    # This class manages checking stock availability efficiently for a set of
+    # Variants and StockLocations.
+    #
+    # This serves a similar role to Spree::Stock::Quantifier, but is more
+    # efficient by checking multiple variants at once.
+    class Availability
+      # @param variants [Array<Spree::Variant>] variants to check stock of
+      # @param stock_locations [Array<Spree::StockLocation>] stock_locations to check for stock in
+      def initialize(variants:, stock_locations: Spree::StockLocation.active)
+        @variants = variants
+        @variant_map = variants.index_by(&:id)
+        @stock_locations = stock_locations
+      end
+
+      # Get the on_hand stock quantities
+      # @return [Hash<Integer=>Spree::StockQuantities>] A map of stock_location_ids to the stock quantities available in that location
+      def on_hand_by_stock_location_id
+        counts_on_hand.to_a.group_by do |(_, stock_location_id), _|
+          stock_location_id
+        end.transform_values do |values|
+          Spree::StockQuantities.new(
+            values.map do |(variant_id, _), count|
+              variant = @variant_map[variant_id]
+              count = Float::INFINITY if !variant.should_track_inventory?
+              count = 0 if count < 0
+              [variant, count]
+            end.to_h
+          )
+        end
+      end
+
+      # Get the on_hand stock quantities
+      # @return [Hash<Integer=>Spree::StockQuantities>] A map of stock_location_ids to the stock quantities available in that location
+      def backorderable_by_stock_location_id
+        backorderables.group_by(&:second).transform_values do |variant_ids|
+          Spree::StockQuantities.new(
+            variant_ids.map do |variant_id, _|
+              variant = @variant_map[variant_id]
+              [variant, Float::INFINITY]
+            end.to_h
+          )
+        end
+      end
+
+      private
+
+      def counts_on_hand
+        @counts_on_hand ||=
+          stock_item_scope.
+            group(:variant_id, :stock_location_id).
+            sum(:count_on_hand)
+      end
+
+      def backorderables
+        @backorderables ||=
+          stock_item_scope.
+            where(backorderable: true).
+            pluck(:variant_id, :stock_location_id)
+      end
+
+      def stock_item_scope
+        Spree::StockItem.
+          where(variant_id: @variants).
+          where(stock_location_id: @stock_locations)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Spree
+  module Stock
+    class AvailabilityValidator < ActiveModel::Validator
+      def validate(line_item)
+        if is_valid?(line_item)
+          true
+        else
+          variant = line_item.variant
+          display_name = variant.name.to_s
+          display_name += %{ (#{variant.options_text})} unless variant.options_text.blank?
+
+          line_item.errors[:quantity] << I18n.t(
+            'spree.selected_quantity_not_available',
+            item: display_name.inspect
+          )
+          false
+        end
+      end
+
+      private
+
+      def is_valid?(line_item)
+        if line_item.inventory_units.empty?
+          Stock::Quantifier.new(line_item.variant).can_supply?(line_item.quantity)
+        else
+          quantity_by_stock_location_id = line_item.inventory_units.pending.joins(:shipment).group(:stock_location_id).count
+          quantity_by_stock_location_id.all? do |stock_location_id, quantity|
+            Stock::Quantifier.new(line_item.variant, stock_location_id).can_supply?(quantity)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+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
+        line_item.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/differentiator.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+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,71 @@
+# frozen_string_literal: true
+
+module Spree
+  module Stock
+    class Estimator
+      class ShipmentRequired < StandardError; end
+      class OrderRequired < StandardError; 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)
+        raise ShipmentRequired if package.shipment.nil?
+        raise OrderRequired if package.shipment.order.nil?
+
+        rates = calculate_shipping_rates(package)
+        rates.select! { |rate| rate.shipping_method.available_to_users? } if frontend_only
+        choose_default_shipping_rate(rates)
+        Spree::Config.shipping_rate_sorter_class.new(rates).sort
+      end
+
+      private
+
+      def choose_default_shipping_rate(shipping_rates)
+        unless shipping_rates.empty?
+          default_shipping_rate = Spree::Config.shipping_rate_selector_class.new(shipping_rates).find_default
+          default_shipping_rate.selected = true
+        end
+      end
+
+      def calculate_shipping_rates(package)
+        tax_calculator_class = Spree::Config.shipping_rate_tax_calculator_class
+        tax_calculator = tax_calculator_class.new(package.shipment.order)
+        shipping_methods(package).map do |shipping_method|
+          cost = shipping_method.calculator.compute(package)
+          if cost
+            rate = shipping_method.shipping_rates.new(
+              cost: cost,
+              shipment: package.shipment
+            )
+            tax_calculator.calculate(rate).each do |tax|
+              rate.taxes.new(
+                amount: tax.amount,
+                tax_rate: tax.tax_rate
+              )
+            end
+            rate
+          end
+        end.compact
+      end
+
+      def shipping_methods(package)
+        package.shipping_methods
+          .available_to_store(package.shipment.order.store)
+          .available_for_address(package.shipment.order.ship_address)
+          .includes(:calculator)
+          .to_a
+          .select do |ship_method|
+          calculator = ship_method.calculator
+          calculator.available?(package) &&
+            (calculator.preferences[:currency].blank? ||
+             calculator.preferences[:currency] == package.shipment.order.currency)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Spree
+  module Stock
+    class InventoryUnitBuilder
+      def initialize(order)
+        @order = order
+      end
+
+      def units
+        @order.line_items.flat_map do |line_item|
+          Array.new(line_item.quantity) do
+            Spree::InventoryUnit.new(
+              pending: true,
+              variant: line_item.variant,
+              line_item: line_item
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+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] << I18n.t(
+            'spree.inventory_not_available',
+            item: line_item.variant.name
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Spree
+  module Stock
+    module LocationSorter
+      # Stock location sorters are used to determine the order in which
+      # inventory units will be allocated when packaging a shipment.
+      #
+      # This allows you, for example, to allocate inventory from the default
+      # stock location first.
+      #
+      # @abstract To implement your own location sorter, subclass and
+      #   implement {#sort}.
+      class Base
+        # @!attribute [r] stock_locations
+        #   @return [Enumerable<Spree::StockLocation>]
+        #     a collection of locations to sort
+        attr_reader :stock_locations
+
+        # Initializes the stock location sorter.
+        #
+        # @param stock_locations [Enumerable<Spree::StockLocation>]
+        #   a collection of locations to sort
+        def initialize(stock_locations)
+          @stock_locations = stock_locations
+        end
+
+        # Sorts the stock locations.
+        #
+        # @return [Enumerable<Spree::StockLocation>]
+        #   a collection of sorted stock locations
+        def sort
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/app/models/spree/stock/location_sorter/default_first.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Spree
+  module Stock
+    module LocationSorter
+      # This stock location sorter will give priority to the default stock
+      # location.
+      class DefaultFirst < Spree::Stock::LocationSorter::Base
+        def sort
+          stock_locations.order_default
+        end
+      end
+    end
+  end
+end

data/app/models/spree/stock/location_sorter/unsorted.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Spree
+  module Stock
+    module LocationSorter
+      # This stock location sorter will leave the stock locations unsorted.
+      class Unsorted < Spree::Stock::LocationSorter::Base
+        def sort
+          stock_locations
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Spree
+  module Stock
+    class Package
+      attr_reader :stock_location, :contents
+      attr_accessor :shipment
+
+      # @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
+      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(:line_item).try(:order) }.try(:line_item).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
+        Spree::ShippingCategory.where(id: shipping_category_ids)
+      end
+
+      # @return [ActiveRecord::Relation] the [Spree::ShippingMethod]s available
+      #   for this pacakge based on the stock location and shipping categories.
+      def shipping_methods
+        Spree::ShippingMethod.
+          with_all_shipping_category_ids(shipping_category_ids).
+          available_in_stock_location(stock_location)
+      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(
+          order: order,
+          stock_location: stock_location,
+          inventory_units: contents.map(&:inventory_unit)
+        )
+      end
+
+      private
+
+      # @return [Array<Fixnum>] the unique ids of all shipping categories of
+      #   variants in this package
+      def shipping_category_ids
+        contents.map { |item| item.variant.shipping_category_id }.compact.uniq
+      end
+    end
+  end
+end