spree_core 5.6.1 → 6.0.0.beta1

data/app/models/spree/order_cancellation_reason.rb

@@ -0,0 +1,25 @@
+module Spree
+  # Why an order was canceled — "Customer changed their mind", "Payment
+  # declined", "Out of stock". Merchant-owned like {Spree::ReturnReason} and
+  # {Spree::ClaimReason} rather than a fixed list, because nothing branches on
+  # the value and every merchant cancels for reasons of their own.
+  class OrderCancellationReason < Spree.base_class
+    has_prefix_id :ocr
+
+    include Spree::NamedType
+    include Spree::Metadata
+
+    self.whitelisted_ransackable_attributes = %w[name active]
+
+    has_many :orders, class_name: 'Spree::Order', inverse_of: :cancel_reason,
+                      foreign_key: :cancel_reason_id, dependent: :restrict_with_error
+
+    # Mirrors what `dependent: :restrict_with_error` enforces, so the dashboard
+    # can hide the delete control rather than offer one the model will refuse.
+    #
+    # @return [Boolean]
+    def can_be_deleted?
+      !orders.exists?
+    end
+  end
+end

data/app/models/spree/order_group.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+module Spree
+  # N orders placed together as one customer checkout.
+  #
+  # Deliberately domain-neutral. Multi-vendor is its first consumer — a mixed
+  # cart splits into one order per seller — but the same container serves
+  # split-by-fulfillment-location, split-by-availability and B2B
+  # split-by-company-location, none of which involve a seller. The seller
+  # therefore lives on the child order and never here
+  # (docs/plans/6.0-multi-vendor-marketplace.md, Decision 8).
+  #
+  # The group owns what the customer experienced once: the payment they made,
+  # the addresses they entered, the contact email. Children own what varies per
+  # seller: line items, fulfillments, totals, and their own money lines.
+  #
+  # Status is derived across the children rather than stored, because a column
+  # would be a second source of truth for something the children already
+  # answer, and it would need re-writing on every child transition.
+  class OrderGroup < Spree.base_class
+    has_prefix_id :ogrp
+
+    include Spree::Metadata
+    include Spree::SingleStoreResource
+    # The same number rules an order follows — the group's number seeds its
+    # children's, so a difference in case or length would show up between a
+    # group and the orders named after it.
+    include Spree::NumberIdentifier
+    # A payment is validated and sized against whatever it was made against, so
+    # the group has to answer the same store-credit questions a cart or an
+    # order does — it is what the customer paid.
+    include Spree::Purchase::StoreCredits
+
+    # Shares the order counter rather than running one of its own: a group and
+    # an order are both things a customer calls "my order", and two counters
+    # behind one `R` prefix would eventually issue the same string for both.
+    # In practice the split copies the number from the order it adopts, so this
+    # only fires for a group created some other way.
+    has_spree_number prefix: 'R', key: :order
+
+    publishes_lifecycle_events
+
+    #
+    # Associations
+    #
+    belongs_to :store, class_name: 'Spree::Store'
+    belongs_to :customer, class_name: "::#{Spree.customer_class}", optional: true
+    # The cart this group was completed from — unique, and the replay key that
+    # makes a retried completion return this group instead of building another.
+    belongs_to :cart, class_name: 'Spree::Cart', optional: true, inverse_of: :order_group
+
+    # restrict_with_error, never cascade: these are completed orders, and a
+    # container going away is not a reason to lose them.
+    has_many :orders, class_name: 'Spree::Order', inverse_of: :order_group, dependent: :restrict_with_error
+    has_many :payments, class_name: 'Spree::Payment', inverse_of: :order_group, dependent: :restrict_with_error
+    has_many :payment_splits, through: :payments, class_name: 'Spree::PaymentSplit', source: :payment_splits
+
+    # Brings the ship/bill pair with the shipping_address/billing_address
+    # aliases every other purchase surface reads them by.
+    #
+    # Only the associations and aliases apply here. The concern's checkout
+    # helpers — shipping_address_required?, assign_default_addresses! — reach
+    # for line items, fulfillments and digital goods, none of which a group
+    # has: they belong to its children, which answer those questions for
+    # themselves. A group's addresses are copies made when the checkout
+    # divided, so nothing asks it to work them out.
+    include Spree::Purchase::Addresses
+    # What a marketplace asks about a group. Kept out of the class itself so
+    # this stays the neutral primitive its other consumers need.
+    include Spree::Marketplace::OrderGroup
+
+    #
+    # Validations
+    #
+    validates :currency, presence: true
+
+    #
+    # Scopes
+    #
+    self.whitelisted_ransackable_attributes = %w[number email currency created_at]
+    self.whitelisted_ransackable_associations = %w[orders customer]
+
+    extend Spree::DisplayMoney
+    money_methods :total, :item_total
+
+    # What the customer was charged for the whole checkout, and what it was
+    # charged for — the sums of what each child independently computed. Never
+    # prorated downward: the children are the record, these are the roll-up,
+    # and a gateway asking what it is charging for gets the whole basket
+    # because the whole basket is what the one charge covers.
+    #
+    # Summed in Ruby rather than by SQL aggregate: anything reading these has
+    # the children loaded already (a serializer renders them, a gateway call
+    # reads four of these in a row), and an aggregate per figure would issue a
+    # query each time even against rows sitting in memory.
+    ROLLED_UP_TOTALS = %i[
+      total item_total delivery_total additional_tax_total included_tax_total
+      discount_total fee_total
+    ].freeze
+
+    ROLLED_UP_TOTALS.each do |figure|
+      define_method(figure) do
+        rolled_up_totals[figure]
+      end
+    end
+
+    alias ship_total delivery_total
+
+    # Where the checkout was made from, carried on the children because they
+    # are what the checkout produced.
+    #
+    # @return [String, nil]
+    def last_ip_address
+      orders.first&.last_ip_address
+    end
+
+    # @return [String, nil] the group's fulfillment position, in the same
+    #   vocabulary a single order uses, rolled up across children
+    def fulfillment_status
+      roll_up(orders.map(&:fulfillment_status)) do |statuses|
+        # Canceled siblings do not make the group canceled — a recalled parcel
+        # does not describe the purchase while another is still coming.
+        live = statuses - ['canceled']
+        next 'canceled' if live.empty?
+
+        live.one? ? live.first : 'partial'
+      end
+    end
+
+    # The payment is shared, but each child reports its own share of it — so
+    # this rolls those up rather than reading the payment, and a checkout with
+    # one seller shipped and another not says so.
+    #
+    # @return [String, nil]
+    def payment_status
+      roll_up(orders.map(&:payment_status))
+    end
+
+    #
+    # The payment-owner contract. A payment reads these off whatever it was
+    # made against — the group answers them by rolling up its children rather
+    # than from columns of its own, since the children are the record of what
+    # was sold and this is only the container they were bought in.
+    #
+
+    # @return [BigDecimal] completed payments on this group, less their refunds
+    #
+    # Reads the persisted rows rather than filtering the loaded association: a
+    # payment still being validated is already held by `payments` (the
+    # association is inverse_of this group), and counting it here would have the
+    # group treat money it has not taken yet as settled — which is what
+    # `max_amount` then subtracts from the total.
+    def payment_total
+      @payment_total ||= begin
+        settled = payments.completed.to_a
+        settled.sum(&:amount) - Spree::Refund.where(payment_id: settled.map(&:id)).sum(:amount)
+      end
+    end
+
+    # Nothing to persist — payment_total is derived here — but the payment path
+    # calls this after settling, so it must exist, and it must forget what it
+    # last worked out or a settled payment would go unnoticed.
+    #
+    # @return [BigDecimal]
+    def refresh_payment_total!
+      forget_derived_money
+      payment_total
+    end
+
+    # Drops the memoized roll-ups. Money moves through the children and their
+    # payments, not through this record, so nothing here is dirtied by a write
+    # that changes what it reports.
+    def forget_derived_money
+      @rolled_up_totals = nil
+      @payment_total = nil
+      # The figures are summed in Ruby off these associations, so dropping the
+      # memo alone would recompute from the same stale rows — a payment that
+      # settled after they were loaded would go unnoticed, which is the exact
+      # case refresh_payment_total! exists to answer.
+      return unless persisted?
+
+      association(:payments).reset
+      association(:orders).reset
+    end
+
+    # @return [BigDecimal] still to collect across the whole checkout
+    def outstanding_balance
+      total - payment_total
+    end
+
+    # @return [Boolean]
+    def paid?
+      total.positive? && payment_total >= total
+    end
+
+    # The gift card this checkout was paid with, if any.
+    #
+    # A group holds no card of its own — the children carry it, each copied
+    # from the one cart — so it answers with theirs. A payment method asks its
+    # owner this when deciding whether it may be used, and the owner of a
+    # grouped payment is this record.
+    #
+    # @return [Spree::GiftCard, nil]
+    def gift_card
+      orders.filter_map(&:gift_card).first
+    end
+
+    # A group only ever exists because a checkout finished, so it is completed
+    # by construction. Store-credit reporting asks, to tell what was applied
+    # from what could still be.
+    #
+    # @return [Boolean]
+    def completed?
+      true
+    end
+
+    def number_store
+      store
+    end
+
+    private
+
+    # One pass over the children for every figure, so reading four of them
+    # costs what reading one does.
+    def rolled_up_totals
+      @rolled_up_totals ||= orders.to_a.each_with_object(Hash.new(BigDecimal(0))) do |order, totals|
+        ROLLED_UP_TOTALS.each { |figure| totals[figure] += order.public_send(figure).to_d }
+      end
+    end
+
+    # Collapses the children's answers into one word: nothing to say, the one
+    # they agree on, or a mixture. What a mixture means is the caller's, since
+    # only it knows which of its values absorb the others.
+    #
+    # @return [String, nil]
+    def roll_up(statuses)
+      statuses = statuses.compact.uniq
+      return if statuses.empty?
+      return statuses.first if statuses.one?
+
+      block_given? ? yield(statuses) : 'partial'
+    end
+  end
+end

data/app/models/spree/order_inventory.rb

@@ -8,7 +8,13 @@ module Spree
       @variant = line_item.variant
     end
 
-    delegate :inventory_units, to: :line_item
+    delegate :fulfillment_items, to: :line_item
+
+    # @deprecated Use {#fulfillment_items}; removed in 6.1.
+    def inventory_units
+      Spree::Deprecation.warn('Spree::OrderInventory#inventory_units is deprecated and will be removed in Spree 6.1. Use #fulfillment_items instead.')
+      fulfillment_items
+    end
 
     # Only verify inventory for completed orders (as orders in frontend checkout
     # have inventory assigned via +order.create_proposed_shipment+) or when
@@ -20,13 +26,13 @@ module Spree
     def verify(shipment = nil, is_updated: false, removing: false)
       return unless order.completed? || shipment.present?
 
-      units_count = inventory_units.reload.sum(&:quantity)
+      units_count = fulfillment_items.reload.sum(&:quantity)
       line_item_changed = is_updated ? !line_item.saved_changes? : !line_item.changed?
 
       if removing
         # When the line item is being destroyed, only remove existing inventory.
         # Adding here would create units that the LineItem `dependent: :destroy`
-        # cascade can't see (set_up_inventory writes through shipment.inventory_units,
+        # cascade can't see (set_up_inventory writes through shipment.fulfillment_items,
         # leaving line_item.inventory_units stale), producing an orphaned unit.
         #
         # Bypass `remove` because it routes through `set_quantity_to_remove` which
@@ -36,7 +42,7 @@ module Spree
       elsif units_count < line_item.quantity
         quantity = line_item.quantity - units_count
 
-        shipment ||= determine_target_shipment
+        shipment ||= determine_target_fulfillment
         add_to_shipment(shipment, quantity)
       elsif (units_count > line_item.quantity) || (units_count == line_item.quantity && line_item_changed)
         remove(units_count, shipment)
@@ -45,13 +51,13 @@ module Spree
 
     private
 
-    def remove(units_count, target_shipment = nil)
+    def remove(units_count, target_fulfillment = nil)
       quantity = set_quantity_to_remove(units_count)
 
-      if target_shipment.present?
-        remove_from_shipment(target_shipment, quantity)
+      if target_fulfillment.present?
+        remove_from_shipment(target_fulfillment, quantity)
       else
-        order.shipments.each do |shipment|
+        order.fulfillments.each do |shipment|
           break if quantity.zero?
 
           quantity -= remove_from_shipment(shipment, quantity)
@@ -59,11 +65,11 @@ module Spree
       end
     end
 
-    def remove_all_units(quantity, target_shipment = nil)
-      if target_shipment.present?
-        remove_from_shipment(target_shipment, quantity)
+    def remove_all_units(quantity, target_fulfillment = nil)
+      if target_fulfillment.present?
+        remove_from_shipment(target_fulfillment, quantity)
       else
-        order.shipments.each do |shipment|
+        order.fulfillments.each do |shipment|
           break if quantity.zero?
 
           quantity -= remove_from_shipment(shipment, quantity)
@@ -83,19 +89,19 @@ module Spree
     #
     # first unshipped that already includes this variant
     # first unshipped that's leaving from a stock_location that stocks this variant
-    def determine_target_shipment
-      target_shipment = order.shipments.detect do |shipment|
+    def determine_target_fulfillment
+      target_fulfillment = order.fulfillments.detect do |shipment|
         shipment.ready_or_pending? && shipment.include?(variant)
       end
 
-      target_shipment || order.shipments.detect do |shipment|
+      target_fulfillment || order.fulfillments.detect do |shipment|
         shipment.ready_or_pending? && variant.stock_location_ids.include?(shipment.stock_location_id)
       end
     end
 
     def add_to_shipment(shipment, quantity)
       if shipment.nil?
-        shipment = order.create_proposed_shipments.first
+        shipment = order.rebuild_fulfillments!.first
       elsif variant.should_track_inventory?
         on_hand, back_order = shipment.stock_location.fill_status(variant, quantity)
 
@@ -105,18 +111,19 @@ module Spree
         shipment.set_up_inventory('on_hand', variant, order, line_item, quantity)
       end
 
-      # adding to this shipment, and removing from stock_location
+      # Editing a placed order changes what is promised, not what is on the
+      # shelf — the goods only leave when the fulfillment ships.
       if order.completed? && variant.should_track_inventory?
-        shipment.stock_location.unstock(variant, quantity, shipment)
+        shipment.stock_location.allocate(variant, quantity, shipment)
       end
 
       quantity
     end
 
     def remove_from_shipment(shipment, quantity)
-      return 0 if quantity.zero? || shipment.shipped?
+      return 0 if quantity.zero? || shipment.fulfilled?
 
-      shipment_units = shipment.inventory_units_for_item(line_item, variant).reject(&:shipped?).sort_by(&:state)
+      shipment_units = shipment.inventory_units_for_item(line_item, variant).reject(&:shipped?).sort_by(&:status)
 
       removed_quantity = 0
       removed_backordered = 0
@@ -136,21 +143,23 @@ module Spree
         inventory_unit.save! if inventory_unit.persisted?
       end
 
-      shipment.destroy if shipment.inventory_units.sum(:quantity).zero?
-
-      # removing this from shipment, and adding to stock_location
-      if order.completed?
-        current_on_hand = shipment.stock_location.count_on_hand(variant)
-
-        if current_on_hand&.negative? && current_on_hand.abs < removed_backordered
-          shipment.stock_location.restock_backordered variant, current_on_hand.abs, shipment
-        else
-          shipment.stock_location.restock_backordered variant, removed_backordered, shipment
-        end
-
-        shipment.stock_location.restock variant, removed_quantity - removed_backordered, shipment
+      # Removing units from a placed order withdraws their promise. On-hand
+      # and backordered units go back the same way now — nothing physical
+      # moved either way.
+      #
+      # Before the fulfillment is destroyed, never after: a destroyed record
+      # reports no allocation (`allocated_quantities` reads nothing for a
+      # record that is not persisted), so releasing afterwards would withdraw
+      # zero and strand the promise on the level with nothing left to release
+      # it.
+      if order.completed? && removed_quantity.positive? && variant.should_track_inventory?
+        # Only this fulfillment's own promise can be withdrawn.
+        released = [removed_quantity, shipment.allocated_quantities[variant.id].to_i].min
+        shipment.stock_location.release(variant, released, shipment) if released.positive?
       end
 
+      shipment.destroy if shipment.fulfillment_items.sum(:quantity).zero?
+
       removed_quantity
     end
   end

data/app/models/spree/order_merger.rb

@@ -1,13 +1,16 @@
 module Spree
+  # @deprecated Use {Spree::Carts::Merge} (guest cart adoption on sign-in);
+  #   removed in 6.1.
   class OrderMerger
     attr_accessor :order
     delegate :updater, to: :order
 
     def initialize(order)
+      Spree::Deprecation.warn('Spree::OrderMerger is deprecated and will be removed in Spree 6.1. Use Spree::Carts::Merge instead.')
       @order = order
     end
 
-    def merge!(other_order, user = nil, discard_merged: true)
+    def merge!(other_order, customer = nil, discard_merged: true)
       handle_gift_card(other_order)
       other_order.line_items.each do |other_order_line_item|
         next unless other_order_line_item.currency == order.currency
@@ -16,7 +19,7 @@ module Spree
         handle_merge(current_line_item, other_order_line_item)
       end
 
-      set_user(user)
+      set_customer(customer)
       clear_addresses(other_order) if discard_merged
       persist_merge
 
@@ -41,8 +44,8 @@ module Spree
       end
     end
 
-    def set_user(user = nil)
-      order.associate_user!(user) if !order.user && !user.blank?
+    def set_customer(customer = nil)
+      order.associate_customer!(customer) if !order.customer && !customer.blank?
     end
 
     def clear_addresses(other_order)
@@ -58,7 +61,9 @@ module Spree
         handle_error(current_line_item) unless current_line_item.save
       else
         order.line_items << other_order_line_item
-        other_order_line_item.adjustments.update_all(order_id: order.id)
+        other_order_line_item.discounts.update_all(order_id: order.id)
+        other_order_line_item.tax_lines.update_all(order_id: order.id)
+        other_order_line_item.fees.update_all(order_id: order.id)
         handle_error(other_order_line_item) unless other_order_line_item.save
       end
     end
@@ -69,7 +74,7 @@ module Spree
     end
 
     def persist_merge
-      updater.update
+      Spree::Orders::RecalculateTotals.call(order: order)
     end
 
     def handle_gift_card(other_order)

data/app/models/spree/order_promotion.rb

@@ -2,20 +2,46 @@ module Spree
   class OrderPromotion < Spree.base_class
     has_prefix_id :discount
 
-    belongs_to :order, class_name: 'Spree::Order'
+    # Owner — exactly one (cart during checkout, copied to the order at
+    # completion)
+    belongs_to :order, class_name: 'Spree::Order', optional: true, inverse_of: :order_promotions
+    belongs_to :cart, class_name: 'Spree::Cart', optional: true, inverse_of: :order_promotions
     belongs_to :promotion, class_name: 'Spree::Promotion'
 
-    delegate :name, :description, :code, :public_metadata, to: :promotion
-    delegate :currency, to: :order
+    delegate :name, :description, :code, to: :promotion
+    delegate :currency, to: :owner
 
-    validates :order, :promotion, presence: true
-    validates :order, uniqueness: { scope: :promotion }
+    validates :order, uniqueness: { scope: :promotion }, allow_nil: true
+    validates :cart, uniqueness: { scope: :promotion }, allow_nil: true
+    validate :exactly_one_owner
 
     extend Spree::DisplayMoney
     money_methods :amount
 
+    # @return [Spree::Cart, Spree::Order, nil]
+    def owner
+      order || cart
+    end
+
+    # Bridge for legacy callers assigning +current_order+ (now a Spree::Cart)
+    # to the order association — routes carts to the cart FK instead.
+    def order=(record)
+      if record.is_a?(Spree::Cart)
+        self.cart = record
+        super(nil)
+      else
+        super
+      end
+    end
+
     def amount
-      order.all_adjustments.promotion.where(source: promotion.actions).sum(:amount)
+      owner.discounts.promotion.where(promotion_action_id: promotion.actions.ids).sum(:amount)
+    end
+
+    private
+
+    def exactly_one_owner
+      errors.add(:base, :exactly_one_of_cart_or_order, message: Spree.t('errors.messages.exactly_one_of_cart_or_order')) unless [order, cart].compact.one?
     end
   end
 end

data/app/models/spree/order_routing/has_strategy_preference.rb

@@ -19,8 +19,7 @@ module Spree
         return if Spree.order_routing.strategies.any? { |strategy| strategy.to_s == value.to_s }
 
         errors.add(
-          :preferred_order_routing_strategy,
-          Spree.t(:invalid_order_routing_strategy, scope: [:errors, :messages], default: 'is not a registered order routing strategy')
+          :preferred_order_routing_strategy, :invalid_order_routing_strategy, message: Spree.t(:invalid_order_routing_strategy, scope: [:errors, :messages], default: 'is not a registered order routing strategy')
         )
       end
     end

data/app/models/spree/order_routing/rules/minimize_splits.rb

@@ -8,7 +8,7 @@ module Spree
       class MinimizeSplits < Spree::OrderRoutingRule
         def rank(order, locations)
           demand = required_quantity_by_variant(order)
-          counts = stock_item_counts(demand.keys, locations)
+          counts = stock_level_counts(demand.keys, locations)
 
           locations.map do |loc|
             coverage = demand.count do |variant_id, qty|
@@ -30,14 +30,14 @@ module Spree
         end
 
         # One query for the entire location × variant matrix instead of
-        # N variants × M locations stock_item lookups.
-        def stock_item_counts(variant_ids, locations)
+        # N variants × M locations stock_level lookups.
+        def stock_level_counts(variant_ids, locations)
           return {} if variant_ids.empty? || locations.empty?
 
-          Spree::StockItem
+          Spree::StockLevel
             .where(stock_location_id: locations.map(&:id), variant_id: variant_ids)
-            .pluck(:stock_location_id, :variant_id, :count_on_hand)
-            .each_with_object({}) { |(loc_id, var_id, count), h| h[[loc_id, var_id]] = count }
+            .pluck(:stock_location_id, :variant_id, :count_on_hand, :allocated_count)
+            .each_with_object({}) { |(loc_id, var_id, on_hand, allocated), h| h[[loc_id, var_id]] = on_hand - allocated }
         end
       end
     end

data/app/models/spree/order_routing/strategy/rules.rb

@@ -40,9 +40,9 @@ module Spree
         end
 
         def eligible_locations
-          Spree::StockLocation.active
-            .joins(:stock_items)
-            .where(spree_stock_items: { variant_id: requested_variant_ids })
+          order.store.stock_locations.active
+            .joins(:stock_levels)
+            .where(Spree::StockLevel.table_name => { variant_id: requested_variant_ids })
             .distinct
             .to_a
         end
@@ -60,23 +60,27 @@ module Spree
         # honors the routing decision.
         def build_packages(locations)
           locations.flat_map do |location|
-            Spree::Stock::Packer.new(location, inventory_units, Spree.stock_splitters).packages
+            Spree::Stock::Packer.new(location, inventory_units, Spree.stock_splitters, owner: order).packages
           end
         end
 
         # Prioritizer's Adjuster distributes each inventory_unit across
         # packages: the first package with on-hand stock fulfills the unit,
         # and downstream packages have that unit removed. Packages whose
-        # items all get stripped are pruned.
+        # items all get stripped are pruned. Rank only decides between origins
+        # that can reach the destination — the Prioritizer demotes the rest.
         def prioritize_packages(packages)
-          Spree::Stock::Prioritizer.new(packages).prioritized_packages
+          Spree::Stock::Prioritizer.new(packages, estimator: estimator).prioritized_packages
         end
 
         def estimate_rates(packages)
-          estimator = Spree::Stock::Estimator.new(order)
-          packages.each { |pkg| pkg.shipping_rates = estimator.shipping_rates(pkg) }
+          packages.each { |pkg| pkg.delivery_rates = estimator.delivery_rates(pkg) }
           packages
         end
+
+        def estimator
+          @estimator ||= Spree::Stock::Estimator.new(order)
+        end
       end
     end
   end