spree_core 6.0.0.beta2 → 6.0.0.beta3

data/app/services/spree/stock_locations/stock_items/create.rb

@@ -10,7 +10,7 @@ module Spree
         # @param stock_location [Spree::StockLocation]
         # @param variants_scope [ActiveRecord::Relation]
         # @return [Spree::ServiceModule::Base::Result]
-        def call(stock_location:, variants_scope: Spree::Variant)
+        def call(stock_location:, variants_scope: nil)
           Spree::Deprecation.warn('Spree::StockLocations::StockItems::Create is deprecated and will be removed in Spree 6.1. Use Spree::StockLocations::StockLevels::Create instead.')
           Spree::StockLocations::StockLevels::Create.call(stock_location: stock_location, variants_scope: variants_scope)
         end

data/app/services/spree/stock_locations/stock_levels/create.rb

@@ -4,8 +4,13 @@ module Spree
       class Create
         prepend Spree::ServiceModule::Base
 
-        def call(stock_location:, variants_scope: Spree::Variant)
-          prepared_stock_levels = variants_scope.ids.map do |variant_id|
+        # @param stock_location [Spree::StockLocation]
+        # @param variants_scope [ActiveRecord::Relation, nil] defaults to what the
+        #   location may stock; always narrowed to it, so no caller can seed rows
+        #   for another store's or another seller's variants
+        def call(stock_location:, variants_scope: nil)
+          variant_ids = propagatable_variants(stock_location, variants_scope).ids
+          prepared_stock_levels = variant_ids.map do |variant_id|
             Hash[
               'stock_location_id', stock_location.id,
               'variant_id', variant_id,
@@ -16,9 +21,20 @@ module Spree
           end
           if prepared_stock_levels.any?
             stock_location.stock_levels.insert_all(prepared_stock_levels)
-            variants_scope.touch_all
+            # By id: MySQL refuses an UPDATE whose own table appears in a subquery.
+            Spree::Variant.where(id: variant_ids).touch_all
           end
         end
+
+        private
+
+        # A location stocks its own store's variants, and a seller's location
+        # only the variants that seller sells.
+        def propagatable_variants(stock_location, variants_scope)
+          scope = Spree::Variant.where(id: (variants_scope || Spree::Variant).select(:id))
+          scope = scope.for_seller(stock_location.seller_id) if stock_location.seller_id.present?
+          scope.joins(:product).where(Spree::Product.table_name => { store_id: stock_location.store_id })
+        end
       end
     end
   end

data/app/subscribers/spree/order_status_subscriber.rb

@@ -1,6 +1,6 @@
 module Spree
   # The trigger side of derive-then-persist statuses: any payment, refund,
-  # fulfillment or return change recomputes the owning order's
+  # store credit, fulfillment or return change recomputes the owning order's
   # payment_status / fulfillment_status through the single writer
   # (Spree::Orders::UpdateStatuses). Synchronous so API responses right
   # after a capture/void/fulfill already carry the fresh status. Cart-owned
@@ -15,12 +15,15 @@ module Spree
     subscribes_to 'payment.created', 'payment.updated', 'payment.deleted',
                   'payment.completed', 'payment.captured', 'payment.voided',
                   'refund.created', 'refund.updated',
+                  'store_credit.created', 'store_credit.updated', 'store_credit.deleted',
                   'fulfillment.created', 'fulfillment.updated', 'fulfillment.deleted',
                   'return.received', 'return.refunded', 'return.canceled',
                   async: false
 
     # Events whose payload changes what the customer has actually paid, so
     # payment_total has to be re-summed before statuses derive from it.
+    # Store credit is not one of them: the money stayed with the store, and
+    # payment_total is what came in through payments.
     MONEY_EVENTS = %w[
       payment.created payment.updated payment.deleted payment.completed
       payment.voided refund.created refund.updated
@@ -63,19 +66,24 @@ module Spree
       resource_class = {
         'payment' => Spree::Payment,
         'refund' => Spree::Refund,
+        'store_credit' => Spree::StoreCredit,
         'fulfillment' => Spree::Fulfillment,
         'return' => Spree::Return
       }[event.resource_type]
       return if resource_class.nil?
 
-      record = resource_class.find_by_prefix_id(event.payload['id'])
-      # None of these models are paranoid, so a .deleted event arrives with
-      # its row already gone and a payload carrying no owner — nothing can
-      # lead back to the order. The models whose deletion changes order
-      # money recalculate from their own after_destroy instead.
+      # A paranoid model's .deleted event leaves the row in place but out of
+      # default scope, and a credit that has been withdrawn is exactly the
+      # kind of change the order has to learn about.
+      record = (resource_class.try(:with_deleted) || resource_class).
+               find_by_prefix_id(event.payload['id'])
+      # Neither Payment nor Fulfillment is paranoid, so their .deleted events
+      # arrive with the row already gone and a payload carrying no owner —
+      # nothing can lead back to the order. The models whose deletion changes
+      # order money recalculate from their own after_destroy instead.
       return if record.nil?
 
-      record.try(:owner) || record.try(:order) ||
+      record.try(:owner) || record.try(:order) || record.try(:refunded_order) ||
         record.try(:payment)&.try(:owner)
     end
   end

data/app/workflows/spree/carts/add_item.rb

@@ -1,9 +1,6 @@
 module Spree
   module Carts
     class AddItem < Spree::Workflow
-      # Line item attributes a caller may set through `options`.
-      ITEM_OPTIONS = [:id, :variant_id, :quantity].freeze
-
       hooks :validate, :after_item_added
 
       # Hook handlers read these plus the argument readers. Both are nil
@@ -110,10 +107,11 @@ module Spree
 
         if @line_item.nil?
           # `LineItem#options=` mass-assigns, so the caller's hash is narrowed
-          # first — `options` must not be a way to set arbitrary attributes.
-          # Extensions widen this through the model's permitted attributes.
-          writable = ITEM_OPTIONS +
-                     ::Spree::LineItem.additional_permitted_attributes.flat_map { |a| a.is_a?(Hash) ? a.keys : a }
+          # to the attributes extensions declare. The variant and quantity are
+          # never among them: both were checked and priced above, and an
+          # `options` value replacing them would sell something else.
+          writable = ::Spree::LineItem.additional_permitted_attributes.flat_map { |a| a.is_a?(Hash) ? a.keys : a }.
+                     map(&:to_sym) - [:id, :variant_id, :quantity]
 
           opts = item_options.symbolize_keys.slice(*writable).
                  merge(currency: cart.currency).

data/app/workflows/spree/carts/complete.rb

@@ -207,6 +207,13 @@ module Spree
       # typed money lines re-pointed, fulfillments + selected rates, address
       # copies); money records (payments, sessions, reservations, coupon
       # codes) re-point — external transaction references must never fork.
+      #
+      # The cart's metadata is copied whole: storefronts and checkout
+      # requirements keep what they collected about the purchase there, and it
+      # has to outlive the cart. The order is new at this point, so there is
+      # nothing on it to merge with — the cart's hash simply becomes the
+      # order's. A deep copy, so a later edit to either record can never reach
+      # the other through a shared nested hash.
       def create_draft_order!(cart)
         order = nil
         ApplicationRecord.transaction do
@@ -228,6 +235,7 @@ module Spree
             po_number: cart.po_number,
             gift_card: cart.gift_card,
             last_ip_address: cart.last_ip_address,
+            metadata: cart.metadata.to_h.deep_dup,
             ship_address: cart.ship_address&.snapshot,
             bill_address: cart.bill_address&.snapshot
           )
@@ -407,82 +415,30 @@ module Spree
       # resumes like any other finalize failure.
       def finalize!(cart, order)
         @order = order
-        step :split_by_seller
-        step :allocate_payment_splits
         step :complete_orders
         step :complete_cart
         step :mark_coupon_codes_used
         external_step :commit_tax
       end
 
-      # Divides the paid draft order into one order per seller, under a group.
-      # A cart of one partition — all first-party, or all one seller — is left
-      # exactly as it is: no group, no splits, and the order it already built
-      # is the order the customer gets.
+      # Places what the checkout produced, through the order-side workflow
+      # that owns placement — including dividing the basket between sellers,
+      # which an order raised from the admin needs just as much and which only
+      # that workflow can give both of them.
       #
-      # The draft order built in PREPARE becomes the group's first child rather
-      # than being replaced. It is the record the payment was taken against and
-      # the row carrying the unique cart_id that makes completion replayable,
-      # so it is kept and narrowed to its own partition; the remaining
-      # partitions become new siblings beside it.
-      def split_by_seller
-        @order_group = cart.order_group
-        return if order_group.present?
-        return if order.placed?
-
-        partitions = Spree::Carts::PartitionBySeller.call(purchase: order).value
-
-        if partitions.one?
-          # Nothing to divide, but the sale still belongs to whoever made it:
-          # a basket entirely from one seller is that seller's order, and the
-          # column is what their own order list reads.
-          order.update_columns(seller_id: partitions.first.seller_id) if order.seller_id != partitions.first.seller_id
-          return
-        end
-
-        return if partitions.empty?
+      # It answers with the group when the basket divided, and the first of
+      # its children is the order this checkout carries on with. No child holds
+      # the confirmation: the customer is confirmed from the group.
+      def complete_orders
+        result = Spree.order_complete_workflow.call(order: order, payment_pending: payment_pending)
+        failure(cart, code: 'completion_failed', message: result.error) if result.failure?
 
-        result = Spree::Carts::SplitBySeller.call(cart: cart, order: order, partitions: partitions)
-        failure(cart, code: 'split_failed', message: result.error) if result.failure?
+        return unless result.value.is_a?(Spree::OrderGroup)
 
         @order_group = result.value
-        # Ordered, because which child comes first decides which one carries
-        # the confirmation email — that must not depend on how the rows come
-        # back.
         @order = order_group.orders.order(:id).first
       end
 
-      def allocate_payment_splits
-        return if order_group.nil?
-
-        result = Spree::OrderGroups::AllocatePayments.call(group: order_group)
-        failure(cart, code: 'split_failed', message: result.error) if result.failure?
-      end
-
-      # Places what the checkout produced — the children of a split, or the one
-      # order otherwise. Each child publishes its own order.placed, which is
-      # what gets every seller their own commission lines with no marketplace
-      # code in the commission engine.
-      #
-      # A split checkout's payments were already taken against the whole basket
-      # and moved onto the group, so the children place without processing them
-      # again. One purchase means one confirmation email: the first child
-      # carries the notification and its siblings place silently.
-      def complete_orders
-        split = order_group.present?
-
-        placed_orders.each_with_index do |child, index|
-          result = Spree.order_complete_workflow.call(
-            order: child,
-            payment_pending: split,
-            notify_customer: split && !index.zero? ? false : nil
-          )
-          failure(cart, code: 'completion_failed', message: result.error) if result.failure?
-        end
-
-        order_group&.publish_event('order_group.completed')
-      end
-
       # Tells the tax engine the sale is final. A no-op for the built-in
       # provider, whose rows are already the record; external engines file the
       # document that a tax return is later built from. Outside the
@@ -499,7 +455,7 @@ module Spree
       # otherwise. The single answer to "which orders came out of here", so
       # placement and tax filing can never disagree about the set.
       def placed_orders
-        order_group.present? ? order_group.orders.to_a : [order]
+        order_group.present? ? order_group.orders.to_a.sort_by(&:id) : [order]
       end
 
       def complete_cart

data/app/workflows/spree/carts/recalculate_totals.rb

@@ -137,7 +137,9 @@ module Spree
       # @return [BigDecimal]
       def paid_so_far
         if cart.is_a?(Spree::Order) && cart.grouped?
-          return cart.payment_splits.to_a.sum(&:net_captured_amount)
+          # Reloaded: a share moved since this instance loaded them would be
+          # re-summed at its old figure and persisted back over the correction.
+          return cart.payment_splits.reload.to_a.sum(&:net_captured_amount)
         end
 
         cart.payments.completed.includes(:refunds).inject(0) do |sum, payment|

data/app/workflows/spree/claims/create.rb

@@ -39,6 +39,9 @@ module Spree
         failure(order, :no_items_to_claim) if items.blank?
       end
 
+      # Bounded by what earlier claims left: each claim can pay out what was
+      # paid for its units, so claiming the same units again would pay twice.
+      # A denied or canceled claim settled nothing and frees its units.
       def normalize_items
         @normalized_items = items.map do |item|
           line_item = item[:line_item]
@@ -46,13 +49,40 @@ module Spree
 
           failure(order, :invalid_quantity) unless quantity.positive?
           failure(order, :item_not_on_order) unless line_item&.order_id == order.id
-          failure(order, :invalid_quantity) if quantity > line_item.quantity.to_i
 
           item.merge(line_item: line_item, quantity: quantity)
         end
+
+        ensure_claimable_quantities
+      end
+
+      def ensure_claimable_quantities
+        requested = Hash.new(0)
+
+        @normalized_items.each do |item|
+          line_item = item[:line_item]
+          failure(order, :invalid_quantity) if item[:quantity] > claimable_quantity_for(line_item) - requested[line_item.id]
+
+          requested[line_item.id] += item[:quantity]
+        end
+      end
+
+      def claimable_quantity_for(line_item)
+        claimed = Spree::ClaimLineItem.
+                  joins(:claim).
+                  where(line_item_id: line_item.id).
+                  where.not(Spree::Claim.table_name => { status: %w[denied canceled] }).
+                  sum(:quantity)
+
+        line_item.quantity.to_i - claimed
       end
 
       def build_claim
+        # Again under the order's row lock, so two requests racing for the same
+        # units cannot both pass the check above.
+        Spree::Order.lock.find(order.id)
+        ensure_claimable_quantities
+
         @claim = order.claims.new(
           store: order.store,
           reason: reason,

data/app/workflows/spree/claims/resolve.rb

@@ -130,17 +130,13 @@ module Spree
       end
 
       def issue_store_credit
-        @refunds = [
-          Spree::StoreCredit.create!(
-            store: claim.store,
-            customer: claim.order.customer,
-            amount: @amount_to_refund,
-            currency: claim.currency,
-            created_by: resolver,
-            originator: claim,
-            memo: "Claim #{claim.number}"
-          )
-        ]
+        @refunds = issue_refund_store_credit(
+          order: claim.order,
+          amount: @amount_to_refund,
+          record: claim,
+          memo: "Claim #{claim.number}",
+          refunder: resolver
+        )
       end
 
       def refund_at_gateway

data/app/workflows/spree/exchanges/create.rb

@@ -3,6 +3,8 @@ module Spree
     # Opens an exchange request: items coming back, and what should go out
     # in their place.
     class Create < Spree::Workflow
+      include Spree::Returns::ReturnableQuantity
+
       hooks :validate, :after_create
 
       attr_reader :exchange
@@ -55,9 +57,18 @@ module Spree
 
           { fulfillment_item: fulfillment_item, new_variant: new_variant, quantity: quantity }
         end
+
+        # The credit an exchange pays out is priced on these quantities, so
+        # they can never exceed what was shipped and not yet sent back.
+        ensure_returnable_quantities(@normalized_items, action: 'exchanged')
       end
 
       def build_exchange
+        # Again under the order's row lock, so two requests racing for the same
+        # units cannot both pass the check above.
+        Spree::Order.lock.find(order.id)
+        ensure_returnable_quantities(@normalized_items, action: 'exchanged')
+
         @exchange = order.exchanges.new(
           store: order.store,
           stock_location: stock_location || default_stock_location,

data/app/workflows/spree/exchanges/fulfill.rb

@@ -51,11 +51,23 @@ module Spree
       # Negative price difference means the replacements cost less than what
       # came back, so the customer is owed the difference.
       def credit_due?
-        exchange.price_difference.to_d.negative?
+        settled_difference.negative?
       end
 
       def credit_amount
-        exchange.price_difference.to_d.abs
+        settled_difference.abs
+      end
+
+      # The difference on the units that actually came back — the same units
+      # the replacements are shipped for. Priced on the requested quantity, an
+      # exchange that asked for more than arrived would pay credit for goods
+      # nobody returned.
+      def settled_difference
+        @settled_difference ||= exchange.exchange_line_items.sum(0.to_d) do |line|
+          next 0.to_d if line.quantity.to_i.zero?
+
+          line.price_difference.to_d / line.quantity.to_i * line.received_quantity.to_i
+        end
       end
 
       def ensure_fulfillable
@@ -112,17 +124,13 @@ module Spree
       end
 
       def issue_store_credit
-        @refunds = [
-          Spree::StoreCredit.create!(
-            store: exchange.store,
-            customer: exchange.order.customer,
-            amount: credit_amount,
-            currency: exchange.currency,
-            created_by: refunder,
-            originator: exchange,
-            memo: "Exchange #{exchange.number}"
-          )
-        ]
+        @refunds = issue_refund_store_credit(
+          order: exchange.order,
+          amount: credit_amount,
+          record: exchange,
+          memo: "Exchange #{exchange.number}",
+          refunder: refunder
+        )
       end
 
       def refund_at_gateway

data/app/workflows/spree/orders/complete.rb

@@ -7,6 +7,9 @@ module Spree
     # may still need to process payments). Idempotent: an already-placed
     # order halts successfully, so interrupted completions replay safely.
     class Complete < Spree::Workflow
+      # Set only when the order divided between sellers.
+      attr_reader :order_group
+
       # @param order [Spree::Order]
       # @param payment_pending [Boolean] when true the order places without
       #   processing payments (B2B / invoice-later). With no payment rows the
@@ -15,17 +18,29 @@ module Spree
       #   rollup work's call (docs/plans/6.0-b2b-wholesale-shipping.md phase 7)
       # @param notify_customer [Boolean, nil] admin drafts pass false to
       #   complete silently; nil (checkout) leaves customer notification on
+      # @return [Spree::ServiceModule::Result] value is the order, or the
+      #   Spree::OrderGroup when it divided between sellers
       def perform(order:, payment_pending: false, notify_customer: nil)
         super
 
         order.notify_customer = notify_customer unless notify_customer.nil?
 
-        halt!(order) if order.completed?
+        # Replaying finishes what an interrupted division started — a sibling
+        # left in draft is an order nobody will ever ship — and answers with
+        # what the first run produced, rather than reporting one seller's order
+        # where it first reported the whole purchase.
+        if order.completed?
+          @order_group = order.order_group
+          step :complete_sibling_orders
+          halt!(order_group || order)
+        end
+
         step :ensure_not_canceled
 
         order.with_lock do
           unless order.reload.placed?
             step :process_payments unless payment_pending || !order.payment_required?
+            step :split_by_seller
             step :finalize_fulfillments
             step :place_order
             step :use_coupon_codes
@@ -39,8 +54,9 @@ module Spree
         step :release_stock_reservations
         step :update_statuses
         step :publish_order_placed
+        step :complete_sibling_orders
 
-        success(order)
+        success(order_group || order)
       end
 
       private
@@ -56,6 +72,56 @@ module Spree
         failure(order, Spree.t(:payment_processing_failed)) unless payment_covered?
       end
 
+      # Files the sale under whoever made it, dividing the order into one per
+      # seller when it holds several sellers' goods.
+      #
+      # Here because this is the one home both entry points share. Commission
+      # is charged from the line item's seller while the ledger credits the
+      # order's, so an order that skipped this — as one raised from the admin
+      # used to — is charged for and credited to nobody.
+      #
+      # Runs after payment so the money is settled once against the whole
+      # basket, and before placement so each seller's order is placed in its
+      # own right.
+      def split_by_seller
+        # A sibling arrives already divided.
+        return if order.order_group_id.present?
+
+        partitions = Spree::Carts::PartitionBySeller.call(purchase: order).value
+        return if partitions.empty?
+        return stamp_seller(partitions.first.seller_id) if partitions.one?
+
+        # The cart travels with it: the group becomes what that cart completed
+        # into, and the row carrying its id is the replay anchor.
+        result = Spree::Carts::SplitBySeller.call(order: order, partitions: partitions, cart: order.cart)
+        failure(order, result.error) if result.failure?
+
+        # The division adopts this very order as the group's first child and
+        # reloads it, so it stays the row this workflow locked and the object
+        # carrying the caller's notify_customer, which a freshly loaded one
+        # would not.
+        @order_group = result.value
+        # No child order is the purchase, this one included, so the customer is
+        # confirmed from the group instead and every child places silently.
+        @notify_customer_of_purchase = order.notify_customer
+        order.notify_customer = false
+        step :allocate_payment_splits
+      end
+
+      # Nothing to divide, but the sale still belongs to whoever made it: an
+      # order entirely from one seller is that seller's, and the column is what
+      # their own order list reads.
+      def stamp_seller(seller_id)
+        return if order.seller_id == seller_id
+
+        order.update_columns(seller_id: seller_id, updated_at: Time.current)
+      end
+
+      def allocate_payment_splits
+        result = Spree::OrderGroups::AllocatePayments.call(group: order_group)
+        failure(order, result.error) if result.failure?
+      end
+
       # Typed adjustment rows are frozen once completed — the totals
       # recalculation only re-sums them, never regenerates (see
       # Spree::Carts::RecalculateTotals) — so no per-row locking is needed.
@@ -160,6 +226,37 @@ module Spree
         order.publish_event('order.completed', payload, { deprecated_alias_of: 'order.placed' })
       end
 
+      # Places the orders the division produced beside this one.
+      #
+      # They place without processing payments, because the money was taken
+      # against the whole basket before the division and the group now holds
+      # it, and silently, as every child of a division does. Only the ones
+      # still in draft, so a replay finishes an interrupted division instead of
+      # re-placing what already went out.
+      def complete_sibling_orders
+        return if order_group.nil?
+
+        pending = order_group.orders.where.not(id: order.id).where(status: 'draft').order(:id)
+        pending.each { |sibling| place_sibling(sibling) }
+
+        # The division loaded these children before placing them, and the rows
+        # just placed are not those objects — anything reading the group now
+        # would see drafts that no longer exist.
+        order_group.orders.reset
+
+        return unless order_group.orders.all?(&:placed?)
+
+        order_group.publish_event(
+          'order_group.completed',
+          order_group.event_payload.merge(notify_customer: @notify_customer_of_purchase)
+        )
+      end
+
+      def place_sibling(sibling)
+        result = Spree.order_complete_workflow.call(order: sibling, payment_pending: true, notify_customer: false)
+        failure(order, result.error) if result.failure?
+      end
+
       def payment_covered?
         order.payments.reset
         order.payments.valid.where(status: %w[pending processing completed]).sum(:amount) >= order.amount_due_at_checkout

data/app/workflows/spree/price_lists/update.rb

@@ -65,6 +65,12 @@ module Spree
             price_list.errors.add(:base, :negative_price)
           elsif refusal[:invalid_quantities].present?
             price_list.errors.add(:base, :invalid_quantity)
+          elsif refusal[:quantities_on_base_prices].present?
+            price_list.errors.add(:base, :quantity_on_base_price)
+          elsif refusal[:duplicate_quantities].present?
+            price_list.errors.add(:base, :duplicate_quantity)
+          elsif refusal[:rising_ladders].present?
+            price_list.errors.add(:base, :price_rises_with_quantity)
           else
             price_list.errors.add(:base, :too_many_breaks, count: Spree::Price::MAXIMUM_BREAKS_PER_VARIANT)
           end
@@ -80,7 +86,18 @@ module Spree
         touch_variants(variant_ids)
       end
 
+      # Rows are written with upsert_all, which checks nothing, so a variant
+      # outside the list's store is dropped here rather than trusted to every
+      # caller to filter first.
       def price_rows
+        rows = raw_price_rows
+        store_variant_ids = price_list.store.variants.where(id: rows.map { |row| row[:variant_id] }).
+                            pluck(:id).map(&:to_s).to_set
+
+        rows.select { |row| store_variant_ids.include?(row[:variant_id].to_s) }
+      end
+
+      def raw_price_rows
         Array(@prices).filter_map do |raw|
           row = raw.respond_to?(:to_unsafe_h) ? raw.to_unsafe_h.with_indifferent_access : raw.with_indifferent_access