spree_core 6.0.0.beta4 → 6.0.0.rc2

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/capture.rb

@@ -14,11 +14,13 @@ module Spree
       hooks :validate, :before_capture, :after_capture
 
       # @param payment [Spree::Payment] a completed payment is a no-op
-      # @param amount [Integer, nil] amount in cents; nil captures in full,
-      #   a smaller amount splits the remainder into a new pending payment
+      # @param amount [BigDecimal, nil] in the currency's own units; nil
+      #   captures in full, a smaller amount splits the remainder into a new
+      #   pending payment. An Integer is read as hundredths of the currency,
+      #   the pre-6.0 contract (deprecated, removed in 6.1).
       def perform(payment:, amount: nil)
         super
-        @amount = amount || payment.money.amount_in_cents
+        @amount = capture_amount(amount)
 
         step :ensure_capturable
         # Veto point — fraud holds, manual review. Before any money moves.
@@ -44,6 +46,17 @@ module Spree
 
       attr_reader :response, :remainder
 
+      def capture_amount(amount)
+        return payment.amount if amount.nil?
+        return Spree::Money::Rounding.to_currency(amount, payment.currency) unless amount.is_a?(Integer)
+
+        Spree::Deprecation.warn(
+          'Passing an Integer amount to the payment capture workflow is deprecated and is read as hundredths of ' \
+          'the currency. Pass the amount in the currency\'s own units as a BigDecimal; removed in Spree 6.1.'
+        )
+        Spree::Money::Rounding.from_hundredths(amount)
+      end
+
       # An already-captured payment returns success rather than failing:
       # capture is naturally idempotent and double-submitted admin actions
       # must not surface as errors. A failed payment is capturable — the
@@ -65,7 +78,9 @@ module Spree
       def capture_at_gateway
         @response = payment.protect_from_connection_error do
           instrument_gateway_call(:capture, payment.payment_method) do
-            payment.payment_method.capture(@amount, payment.response_code, payment.gateway_options)
+            payment.payment_method.capture(
+              payment.payment_method.gateway_amount(@amount, payment.currency), payment.response_code, payment.gateway_options
+            )
           end
         end
 
@@ -86,7 +101,7 @@ module Spree
           if Spree::Payment.where(id: payment.id, status: 'completed').exists?
             already_captured = true
           else
-            payment.capture_events.create!(amount: ::Money.new(@amount, payment.currency).to_f)
+            payment.capture_events.create!(amount: @amount)
             # Split before completing, so payment.completed publishes with
             # the captured amount and the order recomputes from correct rows.
             @remainder = payment.split_uncaptured_amount

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
 
@@ -57,7 +57,9 @@ module Spree
 
         response = payment.protect_from_connection_error do
           instrument_gateway_call(verb, payment.payment_method) do
-            payment.payment_method.public_send(verb, payment.money.amount_in_cents, payment.source, payment.gateway_options)
+            payment.payment_method.public_send(
+              verb, payment.payment_method.gateway_amount(payment.amount, payment.currency), payment.source, payment.gateway_options
+            )
           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/price_lists/update.rb

@@ -61,7 +61,9 @@ module Spree
         unless result.success?
           refusal = result.error&.value
           refusal = {} unless refusal.is_a?(Hash)
-          if refusal[:invalid_amounts].present?
+          if refusal[:malformed_amounts].present?
+            price_list.errors.add(:base, :malformed_price)
+          elsif refusal[:invalid_amounts].present?
             price_list.errors.add(:base, :negative_price)
           elsif refusal[:invalid_quantities].present?
             price_list.errors.add(:base, :invalid_quantity)
@@ -76,12 +78,10 @@ module Spree
           end
           return failure(price_list)
         end
-
-        touch_variants(rows.map { |row| row[:variant_id] }.uniq)
       end
 
       def clear_prices
-        variant_ids = price_list.prices.distinct.pluck(:variant_id)
+        variant_ids = price_list.prices.where.not(amount: nil).distinct.pluck(:variant_id)
         price_list.prices.update_all(amount: nil, compare_at_amount: nil, updated_at: Time.current)
         touch_variants(variant_ids)
       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/create.rb

@@ -19,9 +19,10 @@ module Spree
       # @param expected_at [Date, nil]
       # @param reference [String, nil] the supplier's own order number
       # @param notes [String, nil]
+      # @param metadata [Hash, nil]
       # @param created_by [Object, nil]
       def perform(store:, supplier:, destination_location:, items: [], currency: nil,
-                  expected_at: nil, cancel_by: nil, reference: nil, notes: nil, created_by: nil)
+                  expected_at: nil, cancel_by: nil, reference: nil, notes: nil, metadata: nil, created_by: nil)
         super
 
         step :build_purchase_order
@@ -50,6 +51,7 @@ module Spree
           created_by: created_by,
           status: Spree::PurchaseOrder.default_status
         )
+        @purchase_order.metadata = metadata if metadata
 
         Array(items).each do |item|
           @purchase_order.items.build(

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