spree_core 6.0.0.beta4 → 6.0.0.rc1

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Spree
+  module Fulfillments
+    # Sends replacement goods for an exchange or a claim.
+    #
+    # Replacement units hang off the line they replace but are flagged, so an
+    # edit of that line counts only what the customer bought — otherwise the
+    # replacement reads as a unit the line already holds, and raising the
+    # quantity adds nothing.
+    module Replacements
+      extend ActiveSupport::Concern
+
+      private
+
+      def build_replacements(record, items)
+        order = record.order
+
+        # By id, not through the association writers: with has_many inversing
+        # each writer adds the template to its owner's collection, and the
+        # owner's next save persists it beside the packed copy.
+        units = items.map do |item|
+          Spree::FulfillmentItem.new(
+            order_id: order.id,
+            line_item_id: item[:line_item].id,
+            variant_id: item[:variant].id,
+            quantity: item[:quantity],
+            status: 'on_hand',
+            replacement: true
+          )
+        end
+
+        fulfillments = Spree::Stock::Coordinator.new(order, units).fulfillments
+        if fulfillments.flat_map(&:fulfillment_items).sum(&:quantity) != units.sum(&:quantity)
+          failure(record, :replacement_out_of_stock)
+        end
+
+        order.fulfillments += fulfillments
+        order.save!
+        fulfillments.each { |fulfillment| allocate_replacement_stock(fulfillment) }
+        fulfillments
+      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
+      end
+    end
+  end
+end

data/app/workflows/spree/gift_cards/apply.rb

@@ -185,7 +185,7 @@ module Spree
       end
 
       def amount
-        @amount ||= [gift_card.amount_remaining, order.total].min
+        @amount ||= [gift_card.spendable_amount, order.total].min
       end
 
       def issue_store_credit
@@ -224,7 +224,7 @@ module Spree
           payment_method = order.store.payment_methods.find_or_initialize_by(
             type: 'Spree::PaymentMethod::StoreCredit'
           )
-          payment_method.name ||= Spree.t(:store_credit_name)
+          payment_method.name ||= I18n.t('spree.store_credit_name')
           payment_method.active = true
           payment_method.save! if payment_method.new_record?
           payment_method

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

@@ -5,7 +5,11 @@ module Spree
     # behavior can diverge without branching one implementation.
     class AddItem < Spree::Carts::AddItem
       def perform(order:, **rest)
-        super(cart: order, **rest)
+        result = super(cart: order, **rest)
+        # Placed orders take items through here too, and their payment
+        # status is measured against the total that just moved.
+        order.update_statuses!
+        result
       end
     end
   end

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

@@ -63,7 +63,7 @@ module Spree
         external_step :void_tax
         step :recompute_totals, with: -> { Spree.order_recalculate_totals_workflow }
         step :update_statuses, with: -> { Spree.order_update_statuses_service }
-        order.publish_event('order.canceled', order.event_payload.merge(notify_customer: notify_customer))
+        order.publish_event('order.canceled', nil, notify_customer: notify_customer)
         success(order.reload)
       rescue ActiveRecord::RecordInvalid
         failure(order)
@@ -74,7 +74,7 @@ module Spree
       def ensure_cancellable
         return if order.allow_cancel?
 
-        order.errors.add(:base, :not_cancellable, message: Spree.t('errors.messages.not_cancellable'))
+        order.errors.add(:base, :not_cancellable, message: I18n.t('spree.errors.messages.not_cancellable'))
         failure(order)
       end
 
@@ -86,7 +86,7 @@ module Spree
       def ensure_refund_amount_is_settleable
         return if refund_amount.blank? || order.grouped?
 
-        order.errors.add(:base, :refund_amount_requires_shared_payment, message: Spree.t('errors.messages.refund_amount_requires_shared_payment'))
+        order.errors.add(:base, :refund_amount_requires_shared_payment, message: I18n.t('spree.errors.messages.refund_amount_requires_shared_payment'))
         failure(order)
       end
 

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

@@ -52,6 +52,7 @@ module Spree
 
         step :ensure_placed_status
         step :release_stock_reservations
+        step :cancel_unused_payment_sessions
         step :update_statuses
         step :publish_order_placed
         step :complete_sibling_orders
@@ -69,7 +70,7 @@ module Spree
         order.process_payments! unless payment_covered?
 
         failure(order, order.errors.full_messages.to_sentence) if order.errors.any?
-        failure(order, Spree.t(:payment_processing_failed)) unless payment_covered?
+        failure(order, I18n.t('spree.payment_processing_failed')) unless payment_covered?
       end
 
       # Files the sale under whoever made it, dividing the order into one per
@@ -212,6 +213,15 @@ module Spree
         Spree::StockReservations::Release.call(owner: order)
       end
 
+      # A session left behind by a switched method or a second tab could still
+      # be paid, charging the buyer twice. One provider call per session, so
+      # it runs in a job rather than holding up placement.
+      def cancel_unused_payment_sessions
+        return unless order.payment_sessions.unused.exists?
+
+        Spree::Payments::CancelUnusedSessionsJob.perform_later(order.id)
+      end
+
       def update_statuses
         Spree::Orders::UpdateStatuses.call(order: order)
       end
@@ -221,9 +231,10 @@ module Spree
       # order.completed is a one-release alias for 5.x webhook consumers;
       # wildcard subscribers dedupe on the metadata marker.
       def publish_order_placed
-        payload = order.event_payload.merge(notify_customer: order.notify_customer)
-        order.publish_event('order.placed', payload)
-        order.publish_event('order.completed', payload, { deprecated_alias_of: 'order.placed' })
+        metadata = { notify_customer: order.notify_customer }
+        payload = order.event_payload
+        order.publish_event('order.placed', payload, metadata)
+        order.publish_event('order.completed', payload, metadata.merge(deprecated_alias_of: 'order.placed'))
       end
 
       # Places the orders the division produced beside this one.
@@ -246,10 +257,7 @@ module Spree
 
         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)
-        )
+        order_group.publish_event('order_group.completed', nil, notify_customer: @notify_customer_of_purchase)
       end
 
       def place_sibling(sibling)

data/app/workflows/spree/payments/process.rb

@@ -36,11 +36,11 @@ module Spree
         halt!(payment) if payment.processing?
         return unless payment.payment_method&.source_required?
 
-        failure(payment, Spree.t(:payment_processing_failed)) if payment.source.blank?
+        failure(payment, I18n.t('spree.payment_processing_failed')) if payment.source.blank?
 
         unless payment.payment_method.supports?(payment.source) || payment.token_based?
           payment.invalidate!
-          failure(payment, Spree.t(:payment_method_not_supported))
+          failure(payment, I18n.t('spree.payment_method_not_supported'))
         end
       end
 

data/app/workflows/spree/post_sale/approval.rb

@@ -0,0 +1,35 @@
+module Spree
+  module PostSale
+    # Approval shared by returns, exchanges and claims. The including
+    # workflow names the record it approves (`post_sale_record`) and the
+    # status that record must be in (`approvable_status`).
+    module Approval
+      private
+
+      def approve
+        step :ensure_approvable
+        run_hooks :validate
+
+        ApplicationRecord.transaction do
+          step :mark_approved
+        end
+
+        run_hooks :after_approve
+        post_sale_record.publish_event("#{post_sale_record.event_prefix}.approved")
+        success(post_sale_record.reload)
+      end
+
+      def ensure_approvable
+        failure(post_sale_record, :"not_#{approvable_status}") unless post_sale_record.status == approvable_status
+      end
+
+      def mark_approved
+        post_sale_record.update!(
+          status: 'approved',
+          approved_at: Time.current,
+          created_by: post_sale_record.created_by || approver
+        )
+      end
+    end
+  end
+end

data/app/workflows/spree/post_sale/cancellation.rb

@@ -0,0 +1,44 @@
+module Spree
+  module PostSale
+    # Cancellation shared by returns, exchanges and claims. The including
+    # workflow names the record it cancels (`post_sale_record`) and the
+    # statuses it may be cancelled from (`cancellable_statuses`). A block
+    # runs after the cancellation commits, for work outside the database.
+    module Cancellation
+      include Spree::Refunds::TaxCredit
+
+      private
+
+      def cancel
+        step :ensure_cancellable
+        run_hooks :validate
+
+        ApplicationRecord.transaction do
+          step :mark_canceled
+          step :clear_tax
+        end
+
+        yield if block_given?
+
+        run_hooks :after_cancel
+        post_sale_record.publish_event("#{post_sale_record.event_prefix}.canceled")
+        success(post_sale_record.reload)
+      end
+
+      def ensure_cancellable
+        return if post_sale_record.status.in?(cancellable_statuses)
+
+        failure(post_sale_record, :not_cancellable)
+      end
+
+      def mark_canceled
+        memo = [post_sale_record.memo, reason].compact_blank.join("\n")
+        post_sale_record.update!(status: 'canceled', canceled_at: Time.current, memo: memo.presence)
+      end
+
+      def clear_tax
+        clear_tax_credit(post_sale_record)
+      end
+    end
+  end
+end

data/app/workflows/spree/post_sale/receipt.rb

@@ -0,0 +1,92 @@
+module Spree
+  module PostSale
+    # Records what the warehouse actually received for a return or an
+    # exchange. The including workflow names the record (`post_sale_record`);
+    # its lines, the item key callers pass (`return_line_item:` or
+    # `exchange_line_item:`) and the error codes follow from the record's
+    # event prefix. `restock_variant` says which variant a line puts back.
+    #
+    # Partial and damaged receipt is the normal case, not an edge case: the
+    # customer said three items were coming, two arrived, one of those is not
+    # resellable. Quantities and resellable flags therefore come from the
+    # caller rather than from the request.
+    module Receipt
+      private
+
+      def receive
+        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
+        post_sale_record.publish_event("#{post_sale_kind}.received")
+        success(post_sale_record.reload)
+      end
+
+      def post_sale_kind
+        post_sale_record.event_prefix
+      end
+
+      def restock_variant(line)
+        line.variant
+      end
+
+      def ensure_receivable
+        failure(post_sale_record, :not_approved) unless post_sale_record.approved?
+      end
+
+      def normalize_items
+        @normalized_items =
+          if items.nil?
+            post_sale_record.public_send(:"#{post_sale_kind}_line_items").map do |line|
+              { line: line, quantity: line.quantity, resellable: true }
+            end
+          else
+            items.map { |item| normalize_item(item) }
+          end
+
+        failure(post_sale_record, :no_items_received) if @normalized_items.sum { |item| item[:quantity] }.zero?
+      end
+
+      def normalize_item(item)
+        line = item[:"#{post_sale_kind}_line_item"]
+        quantity = item[:quantity].to_i
+
+        unless line&.public_send(:"#{post_sale_kind}_id") == post_sale_record.id
+          failure(post_sale_record, :"item_not_on_#{post_sale_kind}")
+        end
+        failure(post_sale_record, :invalid_quantity) if quantity.negative? || quantity > line.quantity
+
+        { line: line, quantity: quantity, resellable: item.fetch(:resellable, true) }
+      end
+
+      def record_receipt
+        @normalized_items.each do |item|
+          item[:line].update!(received_quantity: item[:quantity], resellable: item[:resellable])
+        end
+      end
+
+      # Only resellable goods go back into sellable stock — a damaged item
+      # is received but never restocked.
+      def restock_resellable_items
+        @normalized_items.each do |item|
+          next unless item[:resellable]
+          next unless item[:quantity].positive?
+
+          post_sale_record.stock_location.restock(restock_variant(item[:line]), item[:quantity], post_sale_record)
+        end
+      end
+
+      def mark_received
+        post_sale_record.update!(status: 'received', received_at: Time.current)
+      end
+    end
+  end
+end

data/app/workflows/spree/products/nested_attributes.rb

@@ -228,7 +228,7 @@ module Spree
             # it rather than attaching it wrongly.
             blob = ActiveStorage::Blob.find_signed(signed_id)
             unless blob && blob.service_name.to_s == Spree.private_storage_service_name.to_s
-              asset.errors.add(:attachment, :digital_assets_attachment_must_be_private, message: Spree.t(:digital_assets_attachment_must_be_private))
+              asset.errors.add(:attachment, :digital_assets_attachment_must_be_private, message: I18n.t('spree.digital_assets_attachment_must_be_private'))
               raise ActiveRecord::RecordInvalid.new(asset)
             end
 

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

@@ -40,7 +40,7 @@ module Spree
       def ensure_cancelable
         return unless purchase_order.closed?
 
-        failure(purchase_order, Spree.t('purchase_order.errors.already_closed'))
+        failure(purchase_order, I18n.t('spree.purchase_order.errors.already_closed'))
       end
 
       def uncount_awaited_units

data/app/workflows/spree/purchase_orders/close.rb

@@ -8,7 +8,7 @@ module Spree
     # lets the outstanding count stand on each line as the record of the gap.
     # No stock moves — the units were never here.
     class Close < Spree::Workflow
-      include Spree::Receivables::IncomingCounter
+      include Spree::Receivables::ClosingShort
 
       hooks :validate, :after_close
 
@@ -18,40 +18,12 @@ module Spree
       # @param reason [String, nil] why the balance is not expected
       def perform(purchase_order:, reason: nil)
         super
-
-        purchase_order.with_lock do
-          step :ensure_closable
-          run_hooks :validate
-          step :uncount_awaited_units
-          step :close_short
-        end
-
-        run_hooks :after_close
-        purchase_order.publish_event('purchase_order.received')
-        success(purchase_order.reload)
+        close
       end
 
       private
 
-      def ensure_closable
-        return if purchase_order.partially_received?
-
-        failure(purchase_order, Spree.t('purchase_order.errors.not_partially_received'))
-      end
-
-      # The merchant has just said the balance is not coming, so it leaves
-      # the destination's incoming figure; the outstanding count on each line
-      # keeps the record of what never arrived.
-      def uncount_awaited_units
-        uncount_incoming(purchase_order)
-      end
-
-      def close_short
-        now = Time.current
-        attributes = { status: 'received', received_at: now, closed_short_at: now, close_reason: reason.presence }
-
-        failure(purchase_order) unless purchase_order.update(attributes)
-      end
+      def receivable = purchase_order
     end
   end
 end

data/app/workflows/spree/purchase_orders/mark_draft.rb

@@ -32,8 +32,8 @@ module Spree
       private
 
       def ensure_returnable
-        failure(purchase_order, Spree.t('purchase_order.errors.already_receiving')) if purchase_order.stock_receipts.exists?
-        failure(purchase_order, Spree.t('purchase_order.errors.not_ordered_for_draft')) unless purchase_order.ordered?
+        failure(purchase_order, I18n.t('spree.purchase_order.errors.already_receiving')) if purchase_order.stock_receipts.exists?
+        failure(purchase_order, I18n.t('spree.purchase_order.errors.not_ordered_for_draft')) unless purchase_order.ordered?
       end
 
       # Nothing has been received, so this is every unit the order placed.

data/app/workflows/spree/purchase_orders/mark_ordered.rb

@@ -32,8 +32,8 @@ module Spree
       private
 
       def ensure_draft
-        failure(purchase_order, Spree.t('purchase_order.errors.not_draft')) unless purchase_order.draft?
-        failure(purchase_order, Spree.t('purchase_order.errors.must_have_variant')) if purchase_order.items.empty?
+        failure(purchase_order, I18n.t('spree.purchase_order.errors.not_draft')) unless purchase_order.draft?
+        failure(purchase_order, I18n.t('spree.purchase_order.errors.must_have_variant')) if purchase_order.items.empty?
       end
 
       def mark_ordered

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

@@ -50,7 +50,7 @@ module Spree
       def ensure_receivable
         return if purchase_order.ordered? || purchase_order.partially_received?
 
-        failure(purchase_order, Spree.t('purchase_order.errors.not_ordered'))
+        failure(purchase_order, I18n.t('spree.purchase_order.errors.not_ordered'))
       end
 
       def line_belongs?(line)

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

@@ -4,6 +4,8 @@ module Spree
     # ordered is a matter of record between two businesses — so this refuses
     # anything past `draft`.
     class Update < Spree::Workflow
+      include Spree::Receivables::DraftEditing
+
       hooks :validate, :after_update
 
       # @param purchase_order [Spree::PurchaseOrder]
@@ -13,44 +15,13 @@ module Spree
       #   unit_cost: }]` replacing the current lines; nil leaves them alone
       def perform(purchase_order:, attributes: {}, items: nil)
         super
-
-        step :ensure_editable
-        run_hooks :validate
-
-        ApplicationRecord.transaction do
-          step :apply_changes
-          step :save_purchase_order
-        end
-
-        run_hooks :after_update
-        success(purchase_order.reload)
+        edit
       end
 
       private
 
-      def ensure_editable
-        return if purchase_order.editable?
-
-        failure(purchase_order, Spree.t('purchase_order.errors.not_editable'))
-      end
-
-      def apply_changes
-        purchase_order.assign_attributes(attributes) if attributes.present?
-        return if items.nil?
-
-        purchase_order.items.destroy_all
-        Array(items).each do |item|
-          purchase_order.items.build(
-            variant: item[:variant],
-            quantity_ordered: item[:quantity_ordered],
-            unit_cost: item[:unit_cost]
-          )
-        end
-      end
-
-      def save_purchase_order
-        failure(purchase_order) unless purchase_order.save
-      end
+      def receivable = purchase_order
+      def item_attributes = %i[quantity_ordered unit_cost]
     end
   end
 end

data/app/workflows/spree/receivables/closing_short.rb

@@ -0,0 +1,46 @@
+module Spree
+  module Receivables
+    # Ends a purchase order or transfer whose missing units are not going to
+    # turn up. Nothing is written to any shelf: closing short keeps what was
+    # received, records why the rest never arrived, and leaves the outstanding
+    # count on each line as the record of the gap. The including workflow
+    # names the document (`receivable`).
+    module ClosingShort
+      include IncomingCounter
+
+      private
+
+      def close
+        receivable.with_lock do
+          step :ensure_closable
+          run_hooks :validate
+          step :uncount_awaited_units
+          step :close_short
+        end
+
+        run_hooks :after_close
+        receivable.publish_event("#{receivable.event_prefix}.received")
+        success(receivable.reload)
+      end
+
+      def ensure_closable
+        return if receivable.partially_received?
+
+        failure(receivable, I18n.t("spree.#{receivable.event_prefix}.errors.not_partially_received"))
+      end
+
+      # The balance is not coming, so it leaves the destination's incoming
+      # figure; each line's outstanding count keeps the record.
+      def uncount_awaited_units
+        uncount_incoming(receivable)
+      end
+
+      def close_short
+        now = Time.current
+        attributes = { status: 'received', received_at: now, closed_short_at: now, close_reason: reason.presence }
+
+        failure(receivable) unless receivable.update(attributes)
+      end
+    end
+  end
+end

data/app/workflows/spree/receivables/draft_editing.rb

@@ -0,0 +1,48 @@
+module Spree
+  module Receivables
+    # Edits a draft purchase order or transfer. Past `draft` the document is a
+    # matter of record, so the edit is refused rather than quietly rewriting
+    # something a supplier or warehouse is already acting on. The including
+    # workflow names the document (`receivable`) and the line columns callers
+    # may set (`item_attributes`).
+    module DraftEditing
+      private
+
+      def edit
+        step :ensure_editable
+        run_hooks :validate
+
+        ApplicationRecord.transaction do
+          step :apply_changes
+          step :save_document
+        end
+
+        run_hooks :after_update
+        success(receivable.reload)
+      end
+
+      def ensure_editable
+        return if receivable.editable?
+
+        failure(receivable, I18n.t("spree.#{receivable.event_prefix}.errors.not_editable"))
+      end
+
+      # A whole-list replacement rather than a per-line diff: a draft's lines
+      # are what the merchant is still deciding, and sending the list they
+      # want is simpler for a client than working out which rows to delete.
+      def apply_changes
+        receivable.assign_attributes(attributes) if attributes.present?
+        return if items.nil?
+
+        receivable.items.destroy_all
+        Array(items).each do |item|
+          receivable.items.build(variant: item[:variant], **item_attributes.index_with { |key| item[key] })
+        end
+      end
+
+      def save_document
+        failure(receivable) unless receivable.save
+      end
+    end
+  end
+end

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

@@ -26,7 +26,9 @@ module Spree
       #   Required only when the payment is shared by a split checkout, where
       #   it covers several orders and the payment cannot say which one this
       #   refund is for; otherwise the payment's own order is taken.
-      def perform(payment:, amount: nil, reason: nil, refunder: nil, originator: nil, order: nil)
+      # @param tax_amount [BigDecimal, Numeric] the tax inside +amount+, when
+      #   what is being refunded carried tax (see Spree::Refund#tax_amount)
+      def perform(payment:, amount: nil, reason: nil, refunder: nil, originator: nil, order: nil, tax_amount: 0)
         super
 
         step :ensure_refundable
@@ -96,7 +98,8 @@ module Spree
             order: order || payment.order,
             reason: reason || Spree::RefundReason.return_processing_reason(refund_store),
             refunder: refunder,
-            originator: originator
+            originator: originator,
+            tax_amount: tax_amount
           )
         end
       end