spree_core 6.0.0.beta4 → 6.0.0.rc1

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

@@ -2,13 +2,19 @@ module Spree
   module Exchanges
     # Ships the replacements and settles the difference in price.
     #
+    # Both halves of the swap carry tax: the units that came back are credited
+    # the tax the customer paid on them, and the replacements are taxed as a
+    # new sale. The difference between the two, tax included, is what settles.
+    #
     # The money branch mirrors Returns::Refund: a credit the customer is owed
     # can be store credit (an internal ledger write, inside the transaction)
-    # or a gateway refund (outside it). A balance the customer owes is left
-    # for the merchant to collect — charging a stored card without a fresh
-    # authorization is not something core should do silently.
+    # or a gateway refund (outside it). A balance the customer owes is put on
+    # the order as a fee for the merchant to collect — charging a stored card
+    # without a fresh authorization is not something core should do silently.
     class Fulfill < Spree::Workflow
       include Spree::Refunds::OrderPayments
+      include Spree::Refunds::TaxCredit
+      include Spree::Fulfillments::Replacements
 
       hooks :validate, :before_settle, :after_fulfill
 
@@ -24,17 +30,22 @@ module Spree
 
         @fulfillments = []
         @refunds = []
-        step :ensure_fulfillable
+        step :ensure_received
+        step :settle_tax
+        step :ensure_refund_method
         run_hooks :validate
 
         ApplicationRecord.transaction do
           step :build_replacement_fulfillments
           run_hooks :before_settle
           step :issue_store_credit if credit_due? && internal_refund?
+          step :charge_balance if balance_owed?
           step :mark_fulfilled
         end
 
         external_step :refund_at_gateway if credit_due? && !internal_refund?
+        external_step :refund_tax
+        external_step :commit_replacement
 
         step :recalculate_order
         run_hooks :after_fulfill
@@ -54,6 +65,10 @@ module Spree
         settled_difference.negative?
       end
 
+      def balance_owed?
+        settled_difference.positive?
+      end
+
       def credit_amount
         settled_difference.abs
       end
@@ -63,64 +78,44 @@ module Spree
       # 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?
+        @settled_difference ||= received_lines.sum(0.to_d) { |line| line.settled_charge - line.settled_credit }
+      end
 
-          line.price_difference.to_d / line.quantity.to_i * line.received_quantity.to_i
-        end
+      def received_lines
+        @received_lines ||= exchange.exchange_line_items.select { |line| line.received_quantity.to_i.positive? }
       end
 
-      def ensure_fulfillable
-        if credit_due? && !Spree::RefundMethods.valid?(refund_method)
-          # :base, not :refund_method — it is a workflow argument, not an
-          # attribute, and ActiveModel raises when an error names one that
-          # does not exist on the record.
-          exchange.errors.add(:base, :invalid_refund_method,
-                           message: Spree.t('errors.messages.invalid_refund_method'))
-          failure(exchange)
-        end
+      def ensure_received
         failure(exchange, :not_received) unless exchange.received?
       end
 
+      # Rewrites both halves' rows for the units that arrived, before any money
+      # moves, so the difference settled is the one the rows record.
+      def settle_tax
+        with_tax_provider(exchange) { exchange.settle_tax! }
+      end
+
+      def ensure_refund_method
+        return unless credit_due? && !Spree::RefundMethods.valid?(refund_method)
+
+        # :base, not :refund_method — it is a workflow argument, not an
+        # attribute, and ActiveModel raises when an error names one that
+        # does not exist on the record.
+        exchange.errors.add(:base, :invalid_refund_method,
+                            message: I18n.t('spree.errors.messages.invalid_refund_method'))
+        failure(exchange)
+      end
+
       # Only lines that actually came back are replaced — a customer who
       # returned two of three items gets two replacements.
       def build_replacement_fulfillments
-        units = exchange.exchange_line_items.filter_map do |line|
-          next if line.received_quantity.to_i.zero?
-
-          exchange.order.fulfillment_items.new(
-            variant: line.new_variant,
-            quantity: line.received_quantity,
-            line_item: line.line_item,
-            order: exchange.order,
-            status: 'on_hand'
-          )
+        items = received_lines.map do |line|
+          { variant: line.new_variant, quantity: line.received_quantity, line_item: line.line_item }
         end
 
-        failure(exchange, :nothing_to_fulfill) if units.empty?
+        failure(exchange, :nothing_to_fulfill) if items.empty?
 
-        @fulfillments = Spree::Stock::Coordinator.new(exchange.order, units).fulfillments
-        if @fulfillments.flat_map(&:fulfillment_items).sum(&:quantity) != units.sum(&:quantity)
-          failure(exchange, :replacement_out_of_stock)
-        end
-
-        exchange.order.fulfillments += @fulfillments
-        exchange.order.save!
-        @fulfillments.each { |fulfillment| allocate_replacement_stock(fulfillment) }
-      end
-
-      # The replacement is promised the moment it exists, exactly as placement
-      # promises an order's own fulfillments. Without this the fulfillment holds
-      # nothing, and dispatch then writes no movement at all — an unallocated
-      # fulfillment is indistinguishable from one created before typed
-      # movements, so the goods would leave the shelf untouched and unrecorded.
-      def allocate_replacement_stock(fulfillment)
-        fulfillment.manifest.each do |item|
-          next unless item.variant.track_inventory?
-          next unless item.quantity.positive?
-
-          fulfillment.stock_location.allocate(item.variant, item.quantity, fulfillment)
-        end
+        @fulfillments = build_replacements(exchange, items)
       end
 
       def issue_store_credit
@@ -138,10 +133,39 @@ module Spree
           order: exchange.order,
           amount: credit_amount,
           record: exchange,
-          refunder: refunder
+          refunder: refunder,
+          tax_amount: received_lines.sum(0.to_d, &:settled_tax)
         )
       end
 
+      # Puts what the customer owes on the order, which then shows it as due
+      # for the merchant to collect through the order's payments.
+      def charge_balance
+        result = Spree.order_fee_create_service.call(
+          order: exchange.order,
+          attributes: {
+            kind: 'exchange',
+            amount: settled_difference,
+            label: I18n.t('spree.exchange_fee_label', number: exchange.number),
+            metadata: { 'exchange_id' => exchange.prefixed_id }
+          }
+        )
+
+        failure(exchange, result.error.value) if result.failure?
+      end
+
+      def refund_tax
+        file_tax_credit(exchange, received_lines, received_lines.sum(0.to_d, &:settled_credit))
+      end
+
+      # Reported rather than raised, as the credit is: the goods have shipped.
+      def commit_replacement
+        order = exchange.order
+        order.tax_provider.commit_replacement(order, received_lines)
+      rescue Spree::Tax::ProviderError => error
+        Rails.error.report(error, handled: true, context: tax_report_context(exchange), source: 'spree.post_sale')
+      end
+
       def mark_fulfilled
         exchange.update!(status: 'fulfilled', fulfilled_at: Time.current)
       end

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

@@ -3,6 +3,8 @@ module Spree
     # Records what came back. Same partial-receipt shape as returns: the
     # warehouse enters actual quantities and flags anything unsellable.
     class Receive < Spree::Workflow
+      include Spree::PostSale::Receipt
+
       hooks :validate, :before_restock, :after_receive
 
       # @param exchange [Spree::Exchange]
@@ -10,76 +12,15 @@ module Spree
       # @param received_by [Object, nil]
       def perform(exchange:, items: nil, received_by: nil)
         super
-
-        step :ensure_receivable
-        step :normalize_items
-        run_hooks :validate
-
-        ApplicationRecord.transaction do
-          step :record_receipt
-          run_hooks :before_restock
-          step :restock_resellable_items
-          step :mark_received
-        end
-
-        run_hooks :after_receive
-        exchange.publish_event('exchange.received')
-        success(exchange.reload)
+        receive
       end
 
       private
 
-      def ensure_receivable
-        failure(exchange, :not_approved) unless exchange.approved?
-      end
-
-      def normalize_items
-        @normalized_items =
-          if items.nil?
-            exchange.exchange_line_items.map do |line|
-              { exchange_line_item: line, quantity: line.quantity, resellable: true }
-            end
-          else
-            items.map { |item| normalize_item(item) }
-          end
-
-        failure(exchange, :no_items_received) if @normalized_items.sum { |item| item[:quantity] }.zero?
-      end
-
-      def normalize_item(item)
-        line = item[:exchange_line_item]
-        quantity = item[:quantity].to_i
-
-        failure(exchange, :item_not_on_exchange) unless line&.exchange_id == exchange.id
-        failure(exchange, :invalid_quantity) if quantity.negative? || quantity > line.quantity
-
-        { exchange_line_item: line, quantity: quantity, resellable: item.fetch(:resellable, true) }
-      end
-
-      def record_receipt
-        @normalized_items.each do |item|
-          item[:exchange_line_item].update!(
-            received_quantity: item[:quantity],
-            resellable: item[:resellable]
-          )
-        end
-      end
-
-      def restock_resellable_items
-        @normalized_items.each do |item|
-          next unless item[:resellable]
-          next unless item[:quantity].positive?
-
-          exchange.stock_location.restock(
-            item[:exchange_line_item].original_variant,
-            item[:quantity],
-            exchange
-          )
-        end
-      end
+      def post_sale_record = exchange
 
-      def mark_received
-        exchange.update!(status: 'received', received_at: Time.current)
+      def restock_variant(line)
+        line.original_variant
       end
     end
   end

data/app/workflows/spree/fulfillments/cancel.rb

@@ -45,7 +45,7 @@ module Spree
       def ensure_cancelable
         return if fulfillment.can_cancel?
 
-        failure(fulfillment, Spree.t('fulfillments.errors.cannot_cancel'))
+        failure(fulfillment, I18n.t('spree.fulfillments.errors.cannot_cancel'))
       end
 
       # Withdraws the promise this fulfillment held. Nothing physical comes

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

@@ -1,6 +1,6 @@
 module Spree
   module Fulfillments
-    # Manually creates a fulfillment (Spree::Shipment) on a completed order,
+    # Manually creates a fulfillment (Spree::Fulfillment) on a completed order,
     # bypassing order routing. Moves the requested quantities of each line
     # item's not-yet-shipped inventory units out of their current shipments
     # into the new fulfillment, mirroring externally-managed fulfillment
@@ -13,12 +13,19 @@ module Spree
     # new fulfillment, unless the caller provides its own +cost+ /
     # +delivery_method+.
     #
+    # Order-wide, replacement units sent by an exchange or a claim are never
+    # moved: they belong to the record that sent them, not to the goods the
+    # customer bought on the line they are filed under. Given a
+    # +source_fulfillment+, units move only out of that one, replacements
+    # included — splitting a parcel, or re-sending a canceled one, moves what
+    # that parcel holds.
+    #
     # The resulting cost is frozen only for fulfillments registered with
-    # status: 'shipped' (rate refresh skips shipped shipments). Pending/ready
-    # fulfillments participate in the standard rate machinery — this workflow
-    # re-prices them from the delivery method calculators before the final
-    # totals recalculation (repricing a completed order's delivery is an
-    # explicit post-placement edit, never a side effect of a totals refresh).
+    # status: 'shipped' (rate refresh skips shipped shipments). A pending new
+    # fulfillment participates in the standard rate machinery — this workflow
+    # re-prices it from the delivery method calculators before the final
+    # totals recalculation. Only the new fulfillment is re-priced; the order's
+    # other fulfillments keep their cost.
     #
     # In the workflow tier for its hooks and its transaction discipline:
     # 3PL and courier integrations need to contribute provider payload and
@@ -35,9 +42,11 @@ module Spree
       # @param order [Spree::Order] completed order to fulfill
       # @param stock_location [Spree::StockLocation] location the fulfillment ships from
       # @param items [Array<Hash>, nil] `[{ line_item: Spree::LineItem, quantity: Integer }]`;
-      #   nil fulfills every not-yet-shipped unit on the order
+      #   nil moves every not-yet-shipped unit, drawn as +source_fulfillment+ describes
+      # @param source_fulfillment [Spree::Fulfillment, nil] the only fulfillment units are moved from;
+      #   nil takes the customer's bought units from every unshipped fulfillment on the order
       # @param tracking [String, nil] carrier tracking number
-      # @param delivery_method [Spree::ShippingMethod, nil] carrier; stored as the selected rate.
+      # @param delivery_method [Spree::DeliveryMethod, nil] carrier; stored as the selected rate.
       #   Defaults to the delivery method of the drained source fulfillment(s)
       # @param cost [String, Numeric, nil] explicit shipping cost (e.g. the 3PL's price).
       #   Defaults to the summed cost of the drained source fulfillment(s), keeping the
@@ -47,7 +56,7 @@ module Spree
       # @param status [String, nil] pass 'shipped' to register an already-shipped fulfillment
       # @param metadata [Hash, nil] metadata stored on the fulfillment
       # @return [Spree::ServiceModule::Result] the created shipment on success
-      def perform(order:, stock_location:, items: nil, tracking: nil, delivery_method: nil, cost: nil, status: nil, metadata: nil)
+      def perform(order:, stock_location:, items: nil, source_fulfillment: nil, tracking: nil, delivery_method: nil, cost: nil, status: nil, metadata: nil)
         super
 
         step :ensure_valid_status
@@ -83,7 +92,7 @@ module Spree
       def ensure_valid_status
         return if status.nil? || status == 'shipped'
 
-        failure(nil, Spree.t('fulfillments.errors.invalid_status'))
+        failure(nil, I18n.t('spree.fulfillments.errors.invalid_status'))
       end
 
       # parse_cost returns a failure Result for an unparseable value; step
@@ -93,8 +102,8 @@ module Spree
       end
 
       def ensure_order_fulfillable
-        failure(nil, Spree.t('fulfillments.errors.order_not_completed')) unless order.completed?
-        failure(nil, Spree.t('fulfillments.errors.order_canceled')) if order.canceled?
+        failure(nil, I18n.t('spree.fulfillments.errors.order_not_completed')) unless order.completed?
+        failure(nil, I18n.t('spree.fulfillments.errors.order_canceled')) if order.canceled?
       end
 
       def build_fulfillment
@@ -126,38 +135,32 @@ module Spree
         mark_shipped(fulfillment) if status == 'shipped'
       end
 
-      def reprice_and_recalculate
-        reprice_pending_fulfillments(order.reload)
-        order.recalculate_totals!
-      end
-
-      # Moved here from the old updater completed-order branch: pending/ready
-      # fulfillments re-price from backoffice-visible delivery methods;
-      # fulfilled ones keep their frozen cost.
-      #
       # A caller that priced this parcel itself is honoured rather than
-      # re-quoted.
-      def reprice_pending_fulfillments(order)
-        order.fulfillments.each do |candidate|
-          next unless candidate.persisted?
-          next if candidate.fulfilled?
-          next if @requested_cost && candidate.id == fulfillment.id
-
-          candidate.refresh_rates(Spree::DeliveryMethod::BACKOFFICE)
-          candidate.update_amounts
+      # re-quoted, and a shipped one keeps its frozen cost.
+      def reprice_and_recalculate
+        unless @requested_cost || fulfillment.fulfilled?
+          fulfillment.reload.refresh_rates(Spree::DeliveryMethod::BACKOFFICE)
+          fulfillment.update_amounts
         end
+
+        order.reload.recalculate_totals!
       end
 
       # Units that can still be moved into a manual fulfillment: on-hand or
-      # backordered units sitting in shipments that haven't shipped. A
-      # canceled shipment's units are included — cancellation kills that
-      # attempt, not the obligation to ship, so the goods are still owed and
-      # a fresh fulfillment is the only way left to send them (the canceled
-      # record itself can never be fulfilled). Loaded in one query, on-hand
-      # first so moved units stay shippable, grouped by line item for both
-      # validation and moving.
+      # backordered units sitting in shipments that haven't shipped — the
+      # source's own units when one is named, otherwise the customer's bought
+      # units across the order. A canceled shipment's units are included —
+      # cancellation kills that attempt, not the obligation to ship, so the
+      # goods are still owed and a fresh fulfillment is the only way left to
+      # send them (the canceled record itself can never be fulfilled). Loaded
+      # in one query, bought before replacement (a request names only the
+      # line) and on-hand first so moved units stay shippable, grouped by line
+      # item for both validation and moving.
       def fulfillable_units(order)
-        order.fulfillment_items.
+        units = order.fulfillment_items
+        units = source_fulfillment ? units.where(fulfillment_id: source_fulfillment.id).order(:replacement) : units.where(replacement: false)
+
+        units.
           on_hand_or_backordered.
           joins(:fulfillment).
           merge(Spree::Fulfillment.ready_or_pending.or(Spree::Fulfillment.canceled)).
@@ -174,12 +177,12 @@ module Spree
             quantity = available_for.call(line_item)
             { line_item: line_item, quantity: quantity } if quantity.positive?
           end
-          failure(nil, Spree.t('fulfillments.errors.no_items_to_fulfill')) if derived.empty?
+          failure(nil, I18n.t('spree.fulfillments.errors.no_items_to_fulfill')) if derived.empty?
 
           return derived
         end
 
-        failure(nil, Spree.t('fulfillments.errors.no_items_to_fulfill')) if items.empty?
+        failure(nil, I18n.t('spree.fulfillments.errors.no_items_to_fulfill')) if items.empty?
 
         # Merge duplicate line item entries, then validate quantities.
         merged = items.group_by { |item| item[:line_item].id }.values.map do |grouped|
@@ -191,14 +194,14 @@ module Spree
           quantity = item[:quantity]
 
           unless quantity.positive?
-            failure(nil, Spree.t('fulfillments.errors.invalid_quantity', item: line_item.prefixed_id))
+            failure(nil, I18n.t('spree.fulfillments.errors.invalid_quantity', item: line_item.prefixed_id))
           end
 
           available = available_for.call(line_item)
           if quantity > available
             failure(
               nil,
-              Spree.t('fulfillments.errors.insufficient_quantity',
+              I18n.t('spree.fulfillments.errors.insufficient_quantity',
                       item: line_item.prefixed_id, requested: quantity, available: available)
             )
           end
@@ -212,7 +215,7 @@ module Spree
       # carries each moved unit's allocation across with it so the promise
       # follows the fulfillment that will ship it.
       #
-      # @return [Array<Spree::Shipment>] the shipments units were taken from
+      # @return [Array<Spree::Fulfillment>] the shipments units were taken from
       def move_units(order, fulfillment, requested, units_by_line_item)
         source_shipments = []
         stock_moves = Hash.new(0)
@@ -231,7 +234,8 @@ module Spree
               status: unit.status,
               variant_id: unit.variant_id,
               line_item_id: unit.line_item_id,
-              order_id: order.id
+              order_id: order.id,
+              replacement: unit.replacement
             )
             target.pending = unit.pending
             # The quantity column has a database default of 1, so a fresh
@@ -282,7 +286,7 @@ module Spree
       # deleted along with the shipment. The delivery method lookup costs
       # queries, so it is skipped when the caller provided its own.
       #
-      # @return [Hash] `{ cost: BigDecimal, delivery_method: Spree::ShippingMethod or nil }`
+      # @return [Hash] `{ cost: BigDecimal, delivery_method: Spree::DeliveryMethod or nil }`
       def destroy_drained_shipments(source_shipments, capture_delivery_method:)
         inherited = { cost: 0, delivery_method: nil }
 
@@ -325,11 +329,11 @@ module Spree
         return if cost.blank?
 
         parsed = cost.is_a?(String) ? BigDecimal(cost.strip) : cost
-        failure(nil, Spree.t('fulfillments.errors.invalid_cost')) if parsed.negative?
+        failure(nil, I18n.t('spree.fulfillments.errors.invalid_cost')) if parsed.negative?
 
         parsed
       rescue ArgumentError
-        failure(nil, Spree.t('fulfillments.errors.invalid_cost'))
+        failure(nil, I18n.t('spree.fulfillments.errors.invalid_cost'))
       end
 
       # Registers an externally-completed fulfillment: backorders are filled

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

@@ -56,9 +56,12 @@ module Spree
 
         # The split has to land before the provider is involved: the label is
         # for the actual parcel, and a partial shipment's parcel only exists
-        # after the split.
-        ApplicationRecord.transaction do
+        # after the split. requires_new: #call rescues a failure, so joining a
+        # caller's open transaction (the API's order lock) would let it commit
+        # a split the shelf check refused.
+        ApplicationRecord.transaction(requires_new: true) do
           step :split_off_requested_units
+          step :ensure_shelf_can_cover_dispatch
           step :apply_tracking
         end
 
@@ -67,7 +70,7 @@ module Spree
         # box, hand it over), and the ordering that lets the shipped email
         # carry the tracking number the provider discovered instead of racing
         # it. No-op when a label was already bought through
-        # Spree::Fulfillments::PurchaseLabel (the flow where a failure is
+        # Spree::ShippingLabels::Purchase (the flow where a failure is
         # loud), or when the provider has no dispatch mechanics (Manual). A
         # failure here still degrades to "no label yet" — a carrier outage
         # must never stop a merchant recording a parcel that physically left.
@@ -102,11 +105,10 @@ module Spree
       end
 
       def ensure_fulfillable
-        failure(@source, Spree.t('fulfillments.errors.cannot_fulfill')) unless @source.can_fulfill?
+        failure(@source, I18n.t('spree.fulfillments.errors.cannot_fulfill')) unless @source.can_fulfill?
 
         ensure_order_placed
         ensure_ready_to_hand_over
-        ensure_shelf_can_cover_dispatch
         ensure_requested_units_available
       end
 
@@ -116,7 +118,7 @@ module Spree
       def ensure_order_placed
         return unless @source.order&.draft?
 
-        failure(@source, Spree.t('fulfillments.errors.order_draft'))
+        failure(@source, I18n.t('spree.fulfillments.errors.order_draft'))
       end
 
       # What the pending/ready statuses used to encode, asked once at the
@@ -132,7 +134,7 @@ module Spree
         return if order.nil?
 
         if @source.fulfillment_items.any?(&:backordered?)
-          failure(@source, Spree.t('fulfillments.errors.backordered_units'))
+          failure(@source, I18n.t('spree.fulfillments.errors.backordered_units'))
         end
 
         # An order that owes nothing is ready to hand over, which the old
@@ -152,7 +154,7 @@ module Spree
         pending = order.settlement_pending_payments
         return if pending.any? && pending.all? { |payment| payment.payment_method&.capture_at_checkout? == false }
 
-        failure(@source, Spree.t('fulfillments.errors.order_not_paid'))
+        failure(@source, I18n.t('spree.fulfillments.errors.order_not_paid'))
       end
 
       # The shelf has to be able to cover what is about to leave it. A dispatch
@@ -163,7 +165,10 @@ module Spree
       #
       # Refused here rather than at the stock write so it renders as a 422 the
       # merchant can act on, instead of a validation exception surfacing from
-      # inside the dispatch transaction.
+      # inside the dispatch transaction. Checked after the split, which the
+      # refusal rolls back, so a partial dispatch is measured on the units that
+      # actually moved: a line's request can move a replacement of another
+      # variant.
       def ensure_shelf_can_cover_dispatch
         return if force
 
@@ -173,12 +178,12 @@ module Spree
         variants = Spree::Variant.with_deleted.where(id: quantities.keys).index_by(&:id)
 
         quantities.each do |variant_id, quantity|
-          stock_level = @source.stock_location.stock_level(variant_id)
+          stock_level = @fulfillment.stock_location.stock_level(variant_id)
           next if stock_level.nil? || stock_level.count_on_hand >= quantity
 
           failure(
             @source,
-            Spree.t('fulfillments.errors.insufficient_stock_on_hand',
+            I18n.t('spree.fulfillments.errors.insufficient_stock_on_hand',
                     item: variants[variant_id]&.name,
                     on_hand: stock_level.count_on_hand,
                     requested: quantity)
@@ -186,28 +191,18 @@ module Spree
         end
       end
 
-      # What each variant will actually ship: its outstanding promise, capped
-      # by what this dispatch covers. A partial dispatch splits first and the
-      # split carries min(promise, moved quantity), so the two agree.
+      # What each variant will actually ship: the parcel's outstanding promise,
+      # capped by the units it holds.
       #
       # @return [Hash{Integer => Integer}]
       def dispatch_quantity_by_variant
-        held = @source.fulfillment_items.group(:variant_id).sum(:quantity)
-
-        allocated = @source.allocated_quantities
+        allocated = @fulfillment.allocated_quantities
         return {} if allocated.empty?
 
-        wanted =
-          if @requested.empty?
-            held
-          else
-            @requested.each_with_object(Hash.new(0)) do |item, totals|
-              totals[item[:line_item].variant_id] += item[:quantity]
-            end
-          end
+        held = @fulfillment.fulfillment_items.group(:variant_id).sum(:quantity)
 
         allocated.each_with_object({}) do |(variant_id, promised), totals|
-          quantity = [promised, wanted[variant_id].to_i].min
+          quantity = [promised, held[variant_id].to_i].min
           totals[variant_id] = quantity if quantity.positive?
         end
       end
@@ -226,7 +221,7 @@ module Spree
 
           failure(
             @source,
-            Spree.t('fulfillments.errors.not_in_fulfillment',
+            I18n.t('spree.fulfillments.errors.not_in_fulfillment',
                     item: item[:line_item].prefixed_id, requested: item[:quantity], available: held)
           )
         end
@@ -244,6 +239,7 @@ module Spree
           order: @source.order,
           stock_location: @source.stock_location,
           items: @requested,
+          source_fulfillment: @source,
           delivery_method: @source.delivery_method,
           # Delivery was bought once, at checkout. Charging the rate again
           # would bill the customer for the warehouse's decision.

data/app/workflows/spree/fulfillments/mark_delivered.rb

@@ -45,7 +45,7 @@ module Spree
       def ensure_deliverable
         return if fulfillment.can_mark_delivered?
 
-        failure(fulfillment, Spree.t('fulfillments.errors.cannot_mark_delivered'))
+        failure(fulfillment, I18n.t('spree.fulfillments.errors.cannot_mark_delivered'))
       end
 
       # A human saying "it arrived" outranks a carrier that never sent the