Open Source Platform for DTC, B2B Commerce, Marketplaces & Omnichannel. REST APIs, TypeScript SDKs, and production-ready Next.js storefront. Self-host it. Own your data. No vendor lock-in. Zero platform fees.
Ruby b2b-commercee-commerceecommerceecommerce-apiecommerce-frameworkecommerce-platformheadlessheadless-commerceheadless-ecommercemarketplacemulti-tenantmulti-vendormulti-vendor-ecommerceopen-sourcespree-commerce
Slim Cart and Order into shared Purchase concerns
Damian Legawiec415fec8fcaed
diff --git a/spree/core/app/models/concerns/spree/purchase/checkout_steps.rb b/spree/core/app/models/concerns/spree/purchase/checkout_steps.rbnew file mode 100644index 0000000000..787721ebba--- /dev/null+++ b/spree/core/app/models/concerns/spree/purchase/checkout_steps.rb@@ -0,0 +1,65 @@+module Spree+ module Purchase+ # Data-driven checkout-step introspection shared by Spree::Cart and+ # Spree::Order — computed from what the record actually requires+ # (Spree::Checkout::Requirements), never from a state column. The host+ # supplies delivery_required? (always true for orders, computed for+ # carts).+ module CheckoutSteps+ # @return [Array<String>]+ def checkout_steps+ steps = ['address']+ steps << 'delivery' if delivery_required?+ steps << 'payment' if payment_required?+ steps << 'confirm' if confirmation_required?+ steps << 'complete'+ steps+ end++ def has_checkout_step?(step)+ step.present? && checkout_steps.include?(step.to_s)+ end++ def checkout_step_index(step)+ checkout_steps.index(step).to_i+ end++ # Customer-facing checkout step. Completed/canceled records are past+ # checkout; open ones report the first unmet requirement's step+ # ('cart' — missing line items — is not customer-facing and reports+ # as 'address').+ #+ # @return [String]+ def current_checkout_step+ return 'complete' if completed? || canceled?++ first_unmet = Spree::Checkout::Requirements.new(self).call.first+ step = first_unmet ? first_unmet[:step].to_s : 'complete'+ step == 'cart' ? 'address' : step+ end++ # Checkout steps before {#current_checkout_step}; never includes+ # 'complete'.+ #+ # @return [Array<String>]+ def completed_checkout_steps+ steps = checkout_steps.reject { |step| step == 'complete' }+ return steps if current_checkout_step == 'complete'++ index = steps.index(current_checkout_step) || 0+ steps.first(index)+ end++ # Free checkouts skip the payment step.+ def payment_required?+ total.to_f > 0.0+ end++ # Whether the confirm/review step exists — computed from data only.+ def confirmation_required?+ Spree::Config[:always_include_confirm_step] ||+ payments.valid.map(&:payment_method).compact.any?(&:confirmation_required?)+ end+ end+ end+enddiff --git a/spree/core/app/models/concerns/spree/purchase/digital_items.rb b/spree/core/app/models/concerns/spree/purchase/digital_items.rbnew file mode 100644index 0000000000..5c3fa6d7fe--- /dev/null+++ b/spree/core/app/models/concerns/spree/purchase/digital_items.rb@@ -0,0 +1,49 @@+module Spree+ module Purchase+ # Digitality predicates over line items, shared by Spree::Cart and+ # Spree::Order (fulfillment-side digital delivery stays order-only in+ # Spree::Order::Digital).+ module DigitalItems+ # @return [Boolean] true when every line item is digital+ def digital?+ if total_quantity.zero? || line_items.empty?+ false+ else+ line_items.includes(variant: :product).all?(&:digital?)+ end+ end++ # @return [Boolean] true when any line item is digital+ def some_digital?+ if total_quantity.zero? || line_items.empty?+ false+ else+ line_items.includes(variant: :product).any?(&:digital?)+ end+ end++ # @return [Boolean] true when any line item has digital assets+ def with_digital_assets?+ if total_quantity.zero? || line_items.empty?+ false+ else+ line_items.includes(:variant).any?(&:with_digital_assets?)+ end+ end++ # @return [ActiveRecord::Relation<Spree::LineItem>]+ def digital_line_items+ line_items.joins(:variant).with_digital_assets.distinct+ end++ # @return [Array<Spree::DigitalLink>]+ def digital_links+ digital_line_items.map(&:digital_links).flatten+ end++ def requires_ship_address?+ !digital?+ end+ end+ end+enddiff --git a/spree/core/app/models/spree/order/gift_card.rb b/spree/core/app/models/concerns/spree/purchase/gift_cards.rbsimilarity index 51%rename from spree/core/app/models/spree/order/gift_card.rbrename to spree/core/app/models/concerns/spree/purchase/gift_cards.rbindex 2ad011f019..6dc1b6ad88 100644--- a/spree/core/app/models/spree/order/gift_card.rb+++ b/spree/core/app/models/concerns/spree/purchase/gift_cards.rb@@ -1,71 +1,67 @@module Spree- class Order < Spree.base_class- module GiftCard+ module Purchase+ # Gift-card application surface shared by Spree::Cart and Spree::Order.+ # One gift card can be used on many carts/orders, until it runs out.+ module GiftCardsextend ActiveSupport::Concernincluded do- # one GiftCard can be used on many orders, until it runs outbelongs_to :gift_card, class_name: 'Spree::GiftCard', optional: truemoney_methods :gift_card_totalend- # Returns the total amount of the gift card applied to the order- # @return [Decimal]+ # The amount of the gift card applied to this record.+ #+ # @return [BigDecimal]def gift_card_totalreturn 0.to_d unless gift_card.present?store_credit_ids = payments.store_credits.valid.pluck(:source_id)- store_credits = Spree::StoreCredit.where(id: store_credit_ids, originator: gift_card)+ Spree::StoreCredit.where(id: store_credit_ids, originator: gift_card).sum(:amount)+ end- store_credits.sum(:amount)+ def total_minus_gift_cards+ total - gift_card_totalend- # Applies a gift card to the order- # @param gift_card [Spree::GiftCard] the gift card to apply- # @return [Spree::Order] the order with the gift card applied+ # @param gift_card [Spree::GiftCard]def apply_gift_card(gift_card)Spree.gift_card_apply_service.call(gift_card: gift_card, order: self)end- # Removes a gift card from the order- # @return [Spree::Order] the order with the gift card removeddef remove_gift_cardSpree.gift_card_remove_service.call(order: self)end- # Recalculates the gift card payment amount based on the current order total.- # Updates the existing payment in place instead of remove + re-apply- # to avoid creating unnecessary invalid payment records.+ def redeem_gift_card+ return unless gift_card.present?++ Spree.gift_card_redeem_service.call(gift_card: gift_card)+ end++ # In-lock read-compute-write keeping the gift-card payment amount in+ # sync with the current total. Updates the payment in place instead+ # of remove + re-apply to avoid creating invalid payment records.def recalculate_gift_cardreturn unless gift_card.present?payment = payments.checkout.store_credits.where(source: gift_card.store_credits).firstreturn unless payment- # with_lock acquires a row lock and wraps in a transaction.- # The entire read-compute-write must be inside the lock to prevent- # stale amount_remaining from concurrent requests.gift_card.with_lock donew_amount = [gift_card.amount_remaining + payment.amount, total].minnext if payment.amount == new_amountdifference = new_amount - payment.amount- # Uses update_column to bypass Payment#max_amount validation which- # can fail during recalculation due to stale in-memory order state.- # Bounds are enforced via min() above.+ # update_column bypasses Payment#max_amount validation which can+ # fail on stale in-memory state; bounds enforced via min() above.payment.update_column(:amount, new_amount)payment.source.update_column(:amount, new_amount)gift_card.amount_used += differencegift_card.save!endend-- def redeem_gift_card- return unless gift_card.present?-- Spree.gift_card_redeem_service.call(gift_card: gift_card)- endendendenddiff --git a/spree/core/app/models/spree/order/currency_updater.rb b/spree/core/app/models/concerns/spree/purchase/line_item_currencies.rbsimilarity index 58%rename from spree/core/app/models/spree/order/currency_updater.rbrename to spree/core/app/models/concerns/spree/purchase/line_item_currencies.rbindex 199f5997ef..7a9b754ac4 100644--- a/spree/core/app/models/spree/order/currency_updater.rb+++ b/spree/core/app/models/concerns/spree/purchase/line_item_currencies.rb@@ -1,28 +1,24 @@module Spree- class Order < Spree.base_class- module CurrencyUpdater- extend ActiveSupport::Concern # FIXME: this module is not required to be a concern-- included do- def homogenize_line_item_currencies- update_line_item_currencies!- recalculate_totals!- end+ module Purchase+ # Re-prices line items after a currency change, shared by Spree::Cart+ # and Spree::Order (a line item with no price in the new currency is+ # removed).+ module LineItemCurrencies+ def homogenize_line_item_currencies+ update_line_item_currencies!+ recalculate_totals!end- # Updates prices of order's line itemsdef update_line_item_currencies!line_items.where.not(currency: currency).each do |line_item|update_line_item_price!(line_item)endend- # Returns the price object from given itemdef price_from_line_item(line_item)line_item.variant.prices.where(currency: currency).firstend- # Updates price from given line itemdef update_line_item_price!(line_item)price = price_from_line_item(line_item)diff --git a/spree/core/app/models/concerns/spree/purchase/payment_processing.rb b/spree/core/app/models/concerns/spree/purchase/payment_processing.rbnew file mode 100644index 0000000000..e6281b10d0--- /dev/null+++ b/spree/core/app/models/concerns/spree/purchase/payment_processing.rb@@ -0,0 +1,49 @@+module Spree+ module Purchase+ # Payment processing shared by Spree::Cart and Spree::Order.+ module PaymentProcessing+ # Processes any pending payments. Returns true when every pending+ # payment processed successfully; a GatewayError converts to the+ # allow_checkout_on_gateway_error preference.+ def process_payments!+ with_lock { process_payments_with(:process!) }+ end++ def authorize_payments!+ process_payments_with(:authorize!)+ end++ def capture_payments!+ process_payments_with(:purchase!)+ end++ def pending_payments+ payments.pending+ end++ def unprocessed_payments+ payments.select(&:checkout?)+ end++ private++ def process_payments_with(method)+ # Don't run if there is nothing to pay.+ return if payment_total >= total+ # Don't run if there are authorized payments+ return if pending_payments.any? && unprocessed_payments.empty?+ # Never complete without a successfully processed payment.+ raise Spree::Core::GatewayError, Spree.t(:no_payment_found) if unprocessed_payments.empty?++ unprocessed_payments.each do |payment|+ break if payment_total >= total++ payment.public_send(method)+ end+ rescue Spree::Core::GatewayError => e+ result = !!Spree::Config[:allow_checkout_on_gateway_error]+ errors.add(:base, e.message) && (return result)+ end+ end+ end+enddiff --git a/spree/core/app/models/spree/order/store_credit.rb b/spree/core/app/models/concerns/spree/purchase/store_credits.rbsimilarity index 65%rename from spree/core/app/models/spree/order/store_credit.rbrename to spree/core/app/models/concerns/spree/purchase/store_credits.rbindex ddcb4525f3..8893e4f292 100644--- a/spree/core/app/models/spree/order/store_credit.rb+++ b/spree/core/app/models/concerns/spree/purchase/store_credits.rb@@ -1,6 +1,8 @@module Spree- class Order < Spree.base_class- module StoreCredit+ module Purchase+ # Store-credit application surface shared by Spree::Cart and+ # Spree::Order (carts reach user through the customer alias).+ module StoreCreditsdef add_store_credit_payments(amount = nil)Spree.checkout_add_store_credit_service.call(order: self, amount: amount)end@@ -14,19 +16,16 @@ module Spreeendalias covered_by_store_credit covered_by_store_credit?- # Returns the total amount of store credits available to the user associated with the order.- # Returns only store credit for this store and same currency as order+ # Only store credit for this store and the record's currency.#- # @return [BigDecimal] The total amount of store credits available to the user associated with the order.+ # @return [BigDecimal]def total_available_store_creditreturn 0.0 unless useruser.total_available_store_credit(currency, store)end- # Returns the available store credits for the user associated with the order.- #- # @return [Array<Spree::StoreCredit>] The available store credits for the user associated with the order.+ # @return [Array<Spree::StoreCredit>]def available_store_creditsreturn Spree::StoreCredit.none if user.nil?@@ -39,22 +38,16 @@ module Spreetotal_available_store_credit > 0end- # Returns the total amount of the order minus the total amount of store credits applied to the order.- #- # @return [BigDecimal] The total amount of the order minus the total amount of store credits applied to the order.def order_total_after_store_credittotal - total_applicable_store_creditend- # Returns the total amount of the order minus the total amount of store credits applied to the order.- #- # @return [BigDecimal] The total amount of the order minus the total amount of store credits applied to the order.def total_minus_store_creditstotal - total_applied_store_creditenddef total_applicable_store_credit- # Once payments exist (or the order completed), report what was+ # Once payments exist (or the record completed), report what was# actually applied; before that, what could be applied.if completed? || payments.valid.any?total_applied_store_credit@@ -63,9 +56,7 @@ module Spreeendend- # Returns the total amount of store credits applied to the order.- #- # @return [BigDecimal] The total amount of store credits applied to the order.+ # @return [BigDecimal]def total_applied_store_creditif payments.loaded?payments.@@ -77,9 +68,6 @@ module Spreeendend- # Returns true if the order is using store credit.- #- # @return [Boolean] True if the order is using store credit, false otherwise.def using_store_credit?total_applied_store_credit > 0enddiff --git a/spree/core/app/models/concerns/spree/purchase/taxation.rb b/spree/core/app/models/concerns/spree/purchase/taxation.rbnew file mode 100644index 0000000000..007a4ca329--- /dev/null+++ b/spree/core/app/models/concerns/spree/purchase/taxation.rb@@ -0,0 +1,33 @@+module Spree+ module Purchase+ # Tax location and pre-tax sums shared by Spree::Cart and Spree::Order.+ module Taxation+ # The address tax is computed against, honoring the+ # tax_using_ship_address preference.+ #+ # @return [Spree::Address, nil]+ def tax_address+ Spree::Config[:tax_using_ship_address] ? ship_address : bill_address+ end++ # @return [Spree::Zone, nil]+ def tax_zone+ @tax_zone ||= Spree::Zone.match(tax_address) || Spree::Zone.default_tax+ end++ def tax_total+ included_tax_total + additional_tax_total+ end++ # Sum of all line item amounts pre-tax+ def pre_tax_item_amount+ line_items.sum(:pre_tax_amount)+ end++ # Sum of all line item and fulfillment amounts pre-tax+ def pre_tax_total+ pre_tax_item_amount + fulfillments.sum(:pre_tax_amount)+ end+ end+ end+enddiff --git a/spree/core/app/models/spree/cart.rb b/spree/core/app/models/spree/cart.rbindex 05104479b3..04409054e3 100644--- a/spree/core/app/models/spree/cart.rb+++ b/spree/core/app/models/spree/cart.rb@@ -36,6 +36,14 @@ module Spreemoney_methods :item_total, :adjustment_total, :included_tax_total, :additional_tax_total,:discount_total, :fee_total, :delivery_total, :total, :payment_total, :outstanding_balance,:tax_total, :pre_tax_item_amount, :pre_tax_total, :amount_due++ include Spree::Purchase::CheckoutSteps+ include Spree::Purchase::DigitalItems+ include Spree::Purchase::Taxation+ include Spree::Purchase::StoreCredits+ include Spree::Purchase::GiftCards+ include Spree::Purchase::LineItemCurrencies+ include Spree::Purchase::PaymentProcessingalias display_promo_total display_discount_totalalias display_ship_total display_delivery_totalalias_attribute :ship_total, :delivery_total@@ -46,7 +54,6 @@ module Spreebelongs_to :customer, class_name: "::#{Spree.user_class}", optional: truebelongs_to :ship_address, class_name: 'Spree::Address', optional: true, dependent: :destroybelongs_to :bill_address, class_name: 'Spree::Address', optional: true, dependent: :destroy- belongs_to :gift_card, class_name: 'Spree::GiftCard', optional: true# Normalizes like the legacy Order writer so lookups stay case-insensitive.def coupon_code=(code)normalized = begin@@ -183,23 +190,6 @@ module Spreefalseend- class_attribute :update_hooks, default: Set.new-- # Mirrors Spree::Order.register_update_hook for cart-side hooks.- def self.register_update_hook(hook)- update_hooks.add(hook)- end-- # Legacy extensions register their hooks on Spree::Order and expect them- # to fire during checkout — include those alongside cart-registered ones.- def update_hooks- self.class.update_hooks | Spree::Order.update_hooks- end-- def updater- @updater ||= Spree::CartUpdater.new(self)- end-# Recomputes and persists money totals (item, tax, promotion, delivery)# and derived item counts. Convenience for# {Spree::Carts::RecalculateTotals}.@@ -207,25 +197,6 @@ module SpreeSpree.cart_recalculate_totals_workflow.call(cart: self)end- # @deprecated Use {#recalculate_totals!}; removed in 6.1.- def update_with_updater!- Spree::Deprecation.warn('Spree::Cart#update_with_updater! is deprecated and will be removed in Spree 6.1. Use #recalculate_totals! instead.')- recalculate_totals!- end-- # The address tax is computed against, honoring the tax_using_ship_address- # preference (mirrors Spree::Order#tax_address).- #- # @return [Spree::Address, nil]- def tax_address- Spree::Config[:tax_using_ship_address] ? ship_address : bill_address- end-- # @return [Spree::Zone, nil]- def tax_zone- Spree::Zone.match(tax_address) || Spree::Zone.default_tax- end-def currencyself[:currency] || store&.default_currencyend@@ -250,29 +221,12 @@ module Spreeoutstanding_balance != 0end- def payment_required?- total.to_f > 0.0- end-- def confirmation_required?- Spree::Config[:always_include_confirm_step] ||- payments.valid.map(&:payment_method).compact.any?(&:payment_profiles_supported?)- end-# Whether every line item can be delivered without a shipping address# (digital-only carts skip the address/delivery steps).def delivery_required?line_items.any? && !digital?end- def digital?- line_items.any? && line_items.includes(variant: :product).all? { |line_item| line_item.variant.product.digital? }- end-- def requires_ship_address?- !digital?- end-def paid?total.positive? && payment_total >= totalend@@ -350,8 +304,9 @@ module Spreedef set_fulfillments_costfulfillments.each(&:update_amounts)- updater.update_delivery_total- updater.persist_totals+ calculator = Spree::CartUpdater.new(self)+ calculator.update_delivery_total+ calculator.persist_totalsendalias set_shipments_cost set_fulfillments_costalias create_proposed_fulfillments rebuild_fulfillments!@@ -382,147 +337,11 @@ module Spreerecalculate_totals!end- # Duck-type parity with the order-side inventory hooks: carts have no- # named steps, only the delivery requirement.- def has_checkout_step?(step)- step.to_s == 'delivery' ? delivery_required? : true- end-- # Checkout-step introspection (mirrors Order::Checkout, computed from- # requirements)- def checkout_steps- steps = ['address']- steps << 'delivery' if delivery_required?- steps << 'payment' if payment_required?- steps << 'confirm' if confirmation_required?- steps << 'complete'- steps- end-- def current_checkout_step- return 'complete' if completed?-- first_unmet = Spree::Checkout::Requirements.new(self).call.first- step = first_unmet ? first_unmet[:step].to_s : 'complete'- # `cart` (missing line items) is not a customer-facing checkout step- step == 'cart' ? 'address' : step- end-- def completed_checkout_steps- steps = checkout_steps.reject { |step| step == 'complete' }- return steps if current_checkout_step == 'complete'-- index = steps.index(current_checkout_step) || 0- steps.first(index)- end-- def available_store_credits- return Spree::StoreCredit.none if customer.nil?-- customer.store_credits.for_store(store).where(currency: currency).available.sort_by(&:amount_remaining).reverse- end-- def total_available_store_credit- return 0.0 unless customer-- customer.total_available_store_credit(currency, store)- end-- def could_use_store_credit?- return false if store.payment_methods.store_credit.available.empty?-- total_available_store_credit > 0- end-- def total_applied_store_credit- payments.store_credits.valid.sum(:amount)- end-- def covered_by_store_credit?- customer.present? && total_applied_store_credit.positive? && total_applied_store_credit >= total- end-- def using_store_credit?- total_applied_store_credit.positive?- end-- def display_total_applied_store_credit- Spree::Money.new(-total_applied_store_credit, currency: currency)- end-- def order_total_after_store_credit- total - total_applied_store_credit- end-- def total_minus_store_credits- total - total_applied_store_credit- end-- def tax_total- included_tax_total + additional_tax_total- end-- def pre_tax_item_amount- line_items.sum(:pre_tax_amount)- end-- def pre_tax_total- pre_tax_item_amount + fulfillments.sum(:pre_tax_amount)- enddef amount_due[outstanding_balance - total_applied_store_credit, 0].maxend- def gift_card_total- return 0.to_d unless gift_card.present?-- store_credit_ids = payments.store_credits.valid.pluck(:source_id)- Spree::StoreCredit.where(id: store_credit_ids, originator: gift_card).sum(:amount)- end-- def apply_gift_card(gift_card)- Spree.gift_card_apply_service.call(gift_card: gift_card, order: self)- end-- def remove_gift_card- Spree.gift_card_remove_service.call(order: self)- end-- def redeem_gift_card- return unless gift_card.present?-- Spree.gift_card_redeem_service.call(gift_card: gift_card)- end-- # See Spree::Order::GiftCard#recalculate_gift_card — same in-lock- # read-compute-write to keep the payment amount in sync with the total.- def recalculate_gift_card- return unless gift_card.present?-- payment = payments.checkout.store_credits.where(source: gift_card.store_credits).first- return unless payment-- gift_card.with_lock do- new_amount = [gift_card.amount_remaining + payment.amount, total].min- next if payment.amount == new_amount-- difference = new_amount - payment.amount- payment.update_column(:amount, new_amount)- payment.source.update_column(:amount, new_amount)- gift_card.amount_used += difference- gift_card.save!- end- end-- def display_gift_card_total- Spree::Money.new(gift_card_total, currency: currency)- end-- def total_minus_gift_cards- total - gift_card_total- end-# Serializer surface: available payment methods for this cart.def payment_methodscollect_frontend_payment_methods@@ -555,7 +374,7 @@ module Spree# (mirrors Order#remove_out_of_stock_items!).def remove_out_of_stock_items!existing_warnings = warnings- result = Spree::Carts::RemoveOutOfStockItems.call(order: self)+ result = Spree::Carts::RemoveOutOfStockItems.call(cart: self)return self unless result.success?cart, _messages, new_warnings = result.valuediff --git a/spree/core/app/models/spree/cart_updater.rb b/spree/core/app/models/spree/cart_updater.rbindex 776ba56926..a8b445d754 100644--- a/spree/core/app/models/spree/cart_updater.rb+++ b/spree/core/app/models/spree/cart_updater.rb@@ -6,6 +6,9 @@ module Spreeclass CartUpdater < OrderUpdateralias cart order+ # Carts have no legacy update hooks.+ def run_hooks; end+def update_payment_totalcart.payment_total = payments.completed.includes(:refunds).inject(0) { |sum, payment| sum + payment.amount - payment.refunds.sum(:amount) }enddiff --git a/spree/core/app/models/spree/order.rb b/spree/core/app/models/spree/order.rbindex 027ea2d92e..92f708ccec 100644--- a/spree/core/app/models/spree/order.rb+++ b/spree/core/app/models/spree/order.rb@@ -1,9 +1,3 @@-require_dependency 'spree/order/checkout'-require_dependency 'spree/order/currency_updater'-require_dependency 'spree/order/digital'-require_dependency 'spree/order/payments'-require_dependency 'spree/order/store_credit'-require_dependency 'spree/order/gift_card'module Spreeclass Order < Spree.base_class@@ -24,15 +18,15 @@ module Spreeextend Spree::DisplayMoney- include Spree::Order::Checkout- include Spree::Order::CurrencyUpdater- include Spree::Order::Digital- include Spree::Order::Payments- include Spree::Order::StoreCredit+ include Spree::Purchase::CheckoutSteps+ include Spree::Purchase::DigitalItems+ include Spree::Purchase::Taxation+ include Spree::Purchase::StoreCredits+ include Spree::Purchase::GiftCards+ include Spree::Purchase::LineItemCurrencies+ include Spree::Purchase::PaymentProcessinginclude Spree::Order::AddressBook- include Spree::Order::Webhooksinclude Spree::Core::NumberGenerator.new(prefix: 'R')- include Spree::Order::GiftCardinclude Spree::NumberIdentifierinclude Spree::SingleStoreResource@@ -126,7 +120,6 @@ module Spree# Set to false on admin-initiated flows to suppress customer-facing emails.attr_accessor :notify_customer- attribute :state_machine_resumed, :booleanSTATUSES = %w[draft placed canceled].freeze@@ -366,11 +359,6 @@ module Spreeline_items.inject(0.0) { |sum, li| sum + li.amount }end- # Sum of all line item amounts pre-tax- def pre_tax_item_amount- line_items.sum(:pre_tax_amount)- end-# Sum of the eligible promotion adjustments applied to the order itself# (whole-order discounts created by Promotion::Actions::CreateAdjustment,# distributed proportionally across line items), as opposed to promotions@@ -381,11 +369,6 @@ module Spreediscounts.promotion.where(promotion_action_id: promotion_actions_of_scope(:order)).sum(:amount)end- # Sum of all line item and shipment pre-tax- def pre_tax_total- pre_tax_item_amount + fulfillments.sum(:pre_tax_amount)- end-# Promotion actions of the given discount scope, covering both the 6.0# class names and the legacy STI names still present in the type column# until the 6.1 data migration.@@ -435,12 +418,6 @@ module Spreedraft? && !completed? && email.blank? && ship_address_id.blank?end- # @deprecated machine vocabulary — resumption is tracked by the transient- # flag only; removed in 6.1.- def resumed?- !!state_machine_resumed- end-# Derived, not stored (Decision 8): some but not all fulfillments canceled.def partially_canceled?!canceled? && fulfillments.canceled.any? && fulfillments.where.not(status: 'canceled').any?@@ -481,19 +458,6 @@ module Spreetrue # true for Spree, can be decoratedend- # Is this a free order in which case the payment step should be skipped- def payment_required?- total.to_f > 0.0- end-- # If true, causes the confirmation step to happen during the checkout process- # Computed from data only — whether the confirm/review step exists never- # falls back to a machine state (the #4117 hack died with the machine).- def confirmation_required?- Spree::Config[:always_include_confirm_step] ||- payments.valid.map(&:payment_method).compact.any?(&:confirmation_required?)- end-def email_required?require_emailend@@ -526,15 +490,6 @@ module Spree# Returns the relevant zone (if any) to be used for taxation purposes.# Uses default tax zone unless there is a specific match- def tax_zone- @tax_zone ||= Zone.match(tax_address) || Zone.default_tax- end-- # Returns the address for taxation based on configuration- def tax_address- Spree::Config[:tax_using_ship_address] ? ship_address : bill_address- end-def updater@updater ||= Spree.order_updater.new(self)end@@ -728,18 +683,14 @@ module Spreetouch :completed_at- # Completion side effects previously wired as machine transition- # callbacks — each guards its own idempotency.+ # Completion side effects — each guards its own idempotency. The+ # customer-facing ones (newsletter, account creation, risk) live in+ # Spree::OrderPlacedSubscriber, triggered by the order.placed event+ # published below.use_all_coupon_codesredeem_gift_card- subscribe_to_newsletter- create_user_record-- auto_fulfill_provider_fulfillments- send_order_placed_webhook-- consider_risk+ Spree::Fulfillments::AutoFulfill.call(order: self)publish_order_placed_eventend@@ -990,9 +941,7 @@ module Spreeenddef resume- result = Spree.order_resume_workflow.call(order: self)- self.state_machine_resumed = true if result.success?- result.success?+ Spree.order_resume_workflow.call(order: self).success?enddef resume!@@ -1044,10 +993,6 @@ module SpreeSpree.order_approve_service.call(order: self)end- def tax_total- included_tax_total + additional_tax_total- end-def quantityline_items.sum(:quantity)end@@ -1126,10 +1071,6 @@ module Spreeline_itemsend- def requires_ship_address?- !digital?- end-privatedef valid_order_routing_strategy_class(klass_name)diff --git a/spree/core/app/models/spree/order/address_book.rb b/spree/core/app/models/spree/order/address_book.rbindex 577c503624..8f1bb77128 100644--- a/spree/core/app/models/spree/order/address_book.rb+++ b/spree/core/app/models/spree/order/address_book.rb@@ -1,6 +1,15 @@module Spreeclass Order < Spree.base_classmodule AddressBook+ def assign_default_addresses!+ return unless user++ self.bill_address = user.bill_address if !bill_address_id && user.bill_address&.valid?+ # Skip the ship address for orders without a delivery step to+ # avoid triggering shipping-address validations+ self.ship_address = user.ship_address if !ship_address_id && user.ship_address&.valid? && checkout_steps.include?('delivery')+ end+def clone_shipping_addressself.bill_address = ship_address if ship_addressuser.bill_address = ship_address if should_assign_user_default_address?(ship_address)diff --git a/spree/core/app/models/spree/order/checkout.rb b/spree/core/app/models/spree/order/checkout.rbdeleted file mode 100644index 5b9dc663e9..0000000000--- a/spree/core/app/models/spree/order/checkout.rb+++ /dev/null@@ -1,81 +0,0 @@-module Spree- class Order < Spree.base_class- # Data-driven checkout surface. The checkout state machine is gone- # (docs/plans/6.0-cart-order-split.md): progression lives on the Cart via- # Spree::Checkout::Requirements, and this module keeps only the- # step-introspection API that serializers and completed orders still- # need — computed from order data, never from a state column.- module Checkout- def self.included(klass)- klass.class_eval do- define_callbacks :updating_from_params-- # Steps derive from what the order actually requires.- #- # @return [Array<String>]- def checkout_steps- steps = ['address']- steps << 'delivery' if delivery_required?- steps << 'payment' if payment_required?- steps << 'confirm' if respond_to?(:confirmation_required?) && confirmation_required?- steps << 'complete'- steps- end-- def has_checkout_step?(step)- step.present? && checkout_steps.include?(step.to_s)- end-- def checkout_step_index(step)- checkout_steps.index(step).to_i- end-- # Customer-facing checkout step. Completed/canceled orders are past- # checkout; open drafts report the first unmet requirement's step.- #- # @return [String]- def current_checkout_step- return 'complete' if completed? || canceled?-- first_unmet = Spree::Checkout::Requirements.new(self).call.first- first_unmet ? first_unmet[:step].to_s : 'complete'- end-- # Checkout steps that have already been completed, i.e. all steps- # before {#current_checkout_step}. Does not include +'complete'+.- #- # @return [Array<String>]- def completed_checkout_steps- steps = checkout_steps.reject { |step| step == 'complete' }- return steps if current_checkout_step == 'complete'-- index = steps.index(current_checkout_step) || 0- steps.first(index)- end-- def subscribe_to_newsletter- return unless accept_marketing?-- Spree::NewsletterSubscriber.subscribe(email: email, user: user, store: store)- end-- def assign_default_addresses!- if user- self.bill_address = user.bill_address if !bill_address_id && user.bill_address&.valid?- # Skip the ship address for orders without a delivery step to- # avoid triggering shipping-address validations- self.ship_address = user.ship_address if !ship_address_id && user.ship_address&.valid? && checkout_steps.include?('delivery')- end- end-- def create_user_record- return if user.present?- return unless signup_for_an_account?-- Spree::Orders::CreateUserAccount.call(order: self, accepts_email_marketing: accept_marketing?)- end- end- end- end- end-enddiff --git a/spree/core/app/models/spree/order/digital.rb b/spree/core/app/models/spree/order/digital.rbdeleted file mode 100644index 9ca8f3c809..0000000000--- a/spree/core/app/models/spree/order/digital.rb+++ /dev/null@@ -1,88 +0,0 @@-module Spree- class Order < Spree.base_class- module Digital- # Returns true if all order line items are digital- #- # @return [Boolean]- def digital?- if total_quantity.zero? || line_items.empty?- false- else- line_items.includes(variant: :product).all?(&:digital?)- end- end-- # Returns true if any order line item is digital- #- # @return [Boolean]- def some_digital?- if total_quantity.zero? || line_items.empty?- false- else- line_items.includes(variant: :product).any?(&:digital?)- end- end-- # Returns true if any order line item has digital assets- #- # @return [Boolean]- def with_digital_assets?- if total_quantity.zero? || line_items.empty?- false- else- line_items.includes(:variant).any?(&:with_digital_assets?)- end- end-- # Returns all line items with digital assets- #- # @return [Array<Spree::LineItem>]- def digital_line_items- line_items.joins(:variant).with_digital_assets.distinct- end-- # Returns all digital links for the order- #- # @return [Array<Spree::DigitalLink>]- def digital_links- digital_line_items.map(&:digital_links).flatten- end-- # @deprecated DigitalLinks are created by- # Spree::FulfillmentProvider::Digital on order completion- # (idempotently, per quantity); removed in 6.1.- def create_digital_links- Spree::Deprecation.warn('Spree::Order#create_digital_links is deprecated and will be removed in Spree 6.1. Digital links are created by Spree::FulfillmentProvider::Digital on order completion.')- provider = Spree::FulfillmentProvider::Digital.new- digital_line_items.includes(variant: :digitals).each do |line_item|- provider.ensure_links_for(line_item)- end- end-- # Fires providers that auto-fulfill on completion (digital delivery):- # forces the fulfillment to ready and fulfills it through the machine so- # all hooks (links, events, webhooks) run. Line items with digital- # assets that ship through other providers (physical + download combos)- # still get their links here, idempotently and per quantity.- def auto_fulfill_provider_fulfillments- handled_line_item_ids = []-- fulfillments.reload.each do |fulfillment|- next unless fulfillment.provider.auto_fulfill?- next if fulfillment.fulfilled? || fulfillment.canceled?-- fulfillment.update_columns(status: 'ready', updated_at: Time.current) unless fulfillment.ready?- fulfillment.fulfill!- handled_line_item_ids.concat(fulfillment.line_items.map(&:id))- end-- return unless with_digital_assets?-- provider = Spree::FulfillmentProvider::Digital.new- digital_line_items.where.not(id: handled_line_item_ids).includes(variant: :digitals).each do |line_item|- provider.ensure_links_for(line_item)- end- end- end- end-enddiff --git a/spree/core/app/models/spree/order/payments.rb b/spree/core/app/models/spree/order/payments.rbdeleted file mode 100644index 6c0b3cee83..0000000000--- a/spree/core/app/models/spree/order/payments.rb+++ /dev/null@@ -1,64 +0,0 @@-module Spree- class Order < Spree.base_class- module Payments- extend ActiveSupport::Concern # FIXME: this module is not required to be a concern- included do- # processes any pending payments and must return a boolean as it's- # return value is used by the checkout state_machine to determine- # success or failure of the 'complete' event for the order- #- # Returns:- #- # - true if all pending_payments processed successfully- #- # - true if a payment failed, ie. raised a GatewayError- # which gets rescued and converted to TRUE when- # :allow_checkout_gateway_error is set to true- #- # - false if a payment failed, ie. raised a GatewayError- # which gets rescued and converted to FALSE when- # :allow_checkout_on_gateway_error is set to false- #- def process_payments!- with_lock { process_payments_with(:process!) }- end-- def authorize_payments!- process_payments_with(:authorize!)- end-- def capture_payments!- process_payments_with(:purchase!)- end-- def pending_payments- payments.pending- end-- def unprocessed_payments- payments.select(&:checkout?)- end-- private-- def process_payments_with(method)- # Don't run if there is nothing to pay.- return if payment_total >= total- # Don't run if there are authorized payments- return if pending_payments.any? && unprocessed_payments.empty?- # Prevent orders from transitioning to complete without a successfully processed payment.- raise Core::GatewayError, Spree.t(:no_payment_found) if unprocessed_payments.empty?-- unprocessed_payments.each do |payment|- break if payment_total >= total-- payment.public_send(method)- end- rescue Core::GatewayError => e- result = !!Spree::Config[:allow_checkout_on_gateway_error]- errors.add(:base, e.message) && (return result)- end- end- end- end-enddiff --git a/spree/core/app/models/spree/order/webhooks.rb b/spree/core/app/models/spree/order/webhooks.rbdeleted file mode 100644index 552f590fc2..0000000000--- a/spree/core/app/models/spree/order/webhooks.rb+++ /dev/null@@ -1,19 +0,0 @@-module Spree- class Order < Spree.base_class- module Webhooks- extend ActiveSupport::Concern-- def send_order_canceled_webhook- # Implement your logic of sending cancale webhooks- end-- def send_order_placed_webhook- # Implement your logic of sending order placed webhooks- end-- def send_order_resumed_webhook- # Implement your logic of sending after resume webhooks- end- end- end-enddiff --git a/spree/core/app/services/spree/carts/empty.rb b/spree/core/app/services/spree/carts/empty.rbindex 41ba802ac3..07e9b84f46 100644--- a/spree/core/app/services/spree/carts/empty.rb+++ b/spree/core/app/services/spree/carts/empty.rb@@ -24,7 +24,7 @@ module Spreedef empty_order(cart:)ActiveRecord::Base.transaction docart.line_items.destroy_all- cart.updater.update_item_count+ Spree::CartUpdater.new(cart).update_item_countcart.tax_lines.destroy_allcart.discounts.destroy_allcart.fees.destroy_alldiff --git a/spree/core/app/services/spree/checkout/add_store_credit.rb b/spree/core/app/services/spree/checkout/add_store_credit.rbindex a1f9d8f300..58025f702c 100644--- a/spree/core/app/services/spree/checkout/add_store_credit.rb+++ b/spree/core/app/services/spree/checkout/add_store_credit.rb@@ -22,7 +22,8 @@ module Spreeendif @order.reload.payments.store_credits.valid.any?- @order.updater.run_hooks+ # Legacy update hooks are an order-side extension seam; carts have none.+ @order.update_hooks.each { |hook| @order.send(hook) } if @order.respond_to?(:update_hooks)success(@order)elsefailure(@order)diff --git a/spree/core/app/services/spree/fulfillments/auto_fulfill.rb b/spree/core/app/services/spree/fulfillments/auto_fulfill.rbnew file mode 100644index 0000000000..6fc4270a05--- /dev/null+++ b/spree/core/app/services/spree/fulfillments/auto_fulfill.rb@@ -0,0 +1,36 @@+module Spree+ module Fulfillments+ # Fires providers that auto-fulfill on completion (digital delivery):+ # forces each auto-fulfill fulfillment to ready and fulfills it through+ # the machine so all hooks (links, events, webhooks) run. Line items+ # with digital assets that ship through other providers (physical ++ # download combos) still get their links, idempotently and per+ # quantity. Runs during finalize, before the confirmation email+ # subscriber reads the links.+ class AutoFulfill+ prepend Spree::ServiceModule::Base++ def call(order:)+ handled_line_item_ids = []++ order.fulfillments.reload.each do |fulfillment|+ next unless fulfillment.provider.auto_fulfill?+ next if fulfillment.fulfilled? || fulfillment.canceled?++ fulfillment.update_columns(status: 'ready', updated_at: Time.current) unless fulfillment.ready?+ fulfillment.fulfill!+ handled_line_item_ids.concat(fulfillment.line_items.map(&:id))+ end++ return success(order) unless order.with_digital_assets?++ provider = Spree::FulfillmentProvider::Digital.new+ order.digital_line_items.where.not(id: handled_line_item_ids).includes(variant: :digitals).each do |line_item|+ provider.ensure_links_for(line_item)+ end++ success(order)+ end+ end+ end+enddiff --git a/spree/core/app/subscribers/spree/order_placed_subscriber.rb b/spree/core/app/subscribers/spree/order_placed_subscriber.rbnew file mode 100644index 0000000000..45a0cd6ebf--- /dev/null+++ b/spree/core/app/subscribers/spree/order_placed_subscriber.rb@@ -0,0 +1,31 @@+module Spree+ # Completion side effects decoupled from Order#finalize! — each guards+ # its own idempotency. Runs synchronously on order.placed.+ class OrderPlacedSubscriber < Spree::Subscriber+ subscribes_to 'order.placed', async: false++ def handle(event)+ order = Spree::Order.find_by_prefix_id(event.payload['id'])+ return unless order++ subscribe_to_newsletter(order)+ create_user_record(order)+ order.consider_risk+ end++ private++ def subscribe_to_newsletter(order)+ return unless order.accept_marketing?++ Spree::NewsletterSubscriber.subscribe(email: order.email, user: order.user, store: order.store)+ end++ def create_user_record(order)+ return if order.user.present?+ return unless order.signup_for_an_account?++ Spree::Orders::CreateUserAccount.call(order: order, accepts_email_marketing: order.accept_marketing?)+ end+ end+enddiff --git a/spree/core/app/workflows/spree/carts/recalculate.rb b/spree/core/app/workflows/spree/carts/recalculate.rbindex 576be049ac..22722fb655 100644--- a/spree/core/app/workflows/spree/carts/recalculate.rb+++ b/spree/core/app/workflows/spree/carts/recalculate.rb@@ -30,10 +30,10 @@ module Spree# Totals must be current before the proposal rebuild — delivery rate# calculators (e.g. price sack) read them.def refresh_totals- updater = cart.updater- updater.update_item_count- updater.update_totals- updater.persist_totals+ calculator = cart.is_a?(Spree::Order) ? Spree::OrderUpdater.new(cart) : Spree::CartUpdater.new(cart)+ calculator.update_item_count+ calculator.update_totals+ calculator.persist_totalsenddef rebuild_delivery_proposalsdiff --git a/spree/core/app/workflows/spree/carts/recalculate_totals.rb b/spree/core/app/workflows/spree/carts/recalculate_totals.rbindex 85dc5d60ad..55da908b33 100644--- a/spree/core/app/workflows/spree/carts/recalculate_totals.rb+++ b/spree/core/app/workflows/spree/carts/recalculate_totals.rb@@ -38,15 +38,19 @@ module Spreeenddef update_item_count- cart.updater.update_item_count+ calculator.update_item_countenddef update_money_totals- cart.updater.update_totals+ calculator.update_totalsenddef persist_totals- cart.updater.persist_totals+ calculator.persist_totals+ end++ def calculator+ @calculator ||= cart.is_a?(Spree::Order) ? Spree::OrderUpdater.new(cart) : Spree::CartUpdater.new(cart)endendenddiff --git a/spree/core/app/workflows/spree/orders/cancel.rb b/spree/core/app/workflows/spree/orders/cancel.rbindex 8e9edb0d91..06c8519626 100644--- a/spree/core/app/workflows/spree/orders/cancel.rb+++ b/spree/core/app/workflows/spree/orders/cancel.rb@@ -47,7 +47,6 @@ module Spreeexternal_step :settle_paymentsstep :recompute_totals, with: -> { Spree.order_recalculate_totals_workflow }step :recompute_statuses, with: -> { Spree::Orders::RecomputeStatuses }- order.send_order_canceled_webhookorder.publish_event('order.canceled', order.event_payload.merge(notify_customer: notify_customer))success(order.reload)rescue ActiveRecord::RecordInvalid, StateMachines::InvalidTransitiondiff --git a/spree/core/app/workflows/spree/orders/resume.rb b/spree/core/app/workflows/spree/orders/resume.rbindex ad11e04d85..cf4cd94642 100644--- a/spree/core/app/workflows/spree/orders/resume.rb+++ b/spree/core/app/workflows/spree/orders/resume.rb@@ -22,7 +22,6 @@ module Spreeorder.consider_riskstep :recompute_statuses, with: -> { Spree::Orders::RecomputeStatuses }- order.send_order_resumed_webhookorder.publish_event('order.resumed')success(order.reload)rescue ActiveRecord::RecordInvalid, StateMachines::InvalidTransitiondiff --git a/spree/core/lib/spree/core/engine.rb b/spree/core/lib/spree/core/engine.rbindex a9cfeb0425..00b5215624 100644--- a/spree/core/lib/spree/core/engine.rb+++ b/spree/core/lib/spree/core/engine.rb@@ -410,6 +410,7 @@ module Spree# Note: Spree::EventLogSubscriber is attached in to_prepare (below) so it# survives Zeitwerk code reloads in development.Spree.subscribers.concat [+ Spree::OrderPlacedSubscriber,Spree::ExportSubscriber,Spree::ReportSubscriber,Spree::InvitationEmailSubscriber,diff --git a/spree/core/spec/models/spree/order/checkout_spec.rb b/spree/core/spec/models/spree/order/checkout_spec.rbindex ffde77d63b..b7895f1230 100644--- a/spree/core/spec/models/spree/order/checkout_spec.rb+++ b/spree/core/spec/models/spree/order/checkout_spec.rb@@ -107,7 +107,7 @@ describe Spree::Order, type: :model docontext 'when newsletter is accepted for the order' dolet(:accept_marketing) { true }- it 'subscribes to newsletter' do+ it 'subscribes to newsletter', :events doexpect(Spree::NewsletterSubscriber).to receive(:subscribe).with(email: order.email, user: order.user, store: order.store)order.finalize!end@@ -157,12 +157,13 @@ describe Spree::Order, type: :model docontext 'with signup_for_an_account set to true' dobefore do- allow(order).to receive(:signup_for_an_account?).and_return(true)+ order.update_column(:signup_for_an_account, true)end- it 'creates a new user' do+ it 'creates a new user', :events doexpect { order.finalize! }.to change { Spree.user_class.count }.by(1)- expect(order.user).to be_present+ # The subscriber attaches the user on its own loaded instance.+ expect(order.reload.user).to be_presentexpect(order.user.email).to eq(order.email)endenddiff --git a/spree/core/spec/models/spree/order/finalizing_spec.rb b/spree/core/spec/models/spree/order/finalizing_spec.rbindex cd05b87791..20a2fb3175 100644--- a/spree/core/spec/models/spree/order/finalizing_spec.rb+++ b/spree/core/spec/models/spree/order/finalizing_spec.rb@@ -57,12 +57,11 @@ describe Spree::Order, type: :model docontext 'order is considered risky' dobefore do- allow(order).to receive_messages is_risky?: true+ allow_any_instance_of(Spree::Order).to receive_messages(is_risky?: true)end- it 'changes state to risky' do- expect(order).to receive(:considered_risky!)- order.finalize!+ it 'changes state to risky', :events do+ expect { order.finalize! }.to change { order.reload.considered_risky }.to(true)endcontext 'and order is approved' dodiff --git a/spree/core/spec/models/spree/order_spec.rb b/spree/core/spec/models/spree/order_spec.rbindex 01ab842ce5..d2afcab99e 100644--- a/spree/core/spec/models/spree/order_spec.rb+++ b/spree/core/spec/models/spree/order_spec.rb@@ -440,12 +440,11 @@ describe Spree::Order, type: :model docontext 'order is considered risky' dobefore do- allow(order).to receive_messages is_risky?: true+ allow_any_instance_of(Spree::Order).to receive_messages(is_risky?: true)end- it 'changes state to risky' do- expect(order).to receive(:considered_risky!)- order.finalize!+ it 'changes state to risky', :events do+ expect { order.finalize! }.to change { order.reload.considered_risky }.to(true)endcontext 'and order is approved' dodiff --git a/spree/core/spec/models/spree/order_updater_spec.rb b/spree/core/spec/models/spree/order_updater_spec.rbindex e8d0c1b0a3..432e6aa845 100644--- a/spree/core/spec/models/spree/order_updater_spec.rb+++ b/spree/core/spec/models/spree/order_updater_spec.rb@@ -220,12 +220,9 @@ module Spreebefore { order.update(completed_at: Time.current) }describe '#update' do- it 'delegates to Carts::RecalculateTotals with a deprecation warning, money only' do+ it 'delegates to the RecalculateTotals workflow with a deprecation warning' doexpect(Spree::Deprecation).to receive(:warn).with(/updater#update is deprecated/i)- expect(updater).not_to receive(:update_payment_state)- expect(updater).not_to receive(:update_fulfillments)- expect(updater).to receive(:update_totals).and_call_original- expect(updater).to receive(:persist_totals).and_call_original+ expect(Spree::Carts::RecalculateTotals).to receive(:call).with(cart: order).and_call_originalupdater.updateendend@@ -301,7 +298,7 @@ module Spreelet(:order) { ::OrderWalkthrough.up_to(:delivery) }it 'resets shipping method to frontend-available' do- order.updater.update_shipments+ Spree::CartUpdater.new(order).update_shipmentsexpect(order.fulfillments.first.delivery_method).to eq Spree::ShippingMethod.find_by(display_on: 'both')endend