spree_core 5.4.3 → 5.5.0.rc1

data/app/services/spree/newsletter/subscribe.rb

@@ -1,42 +1,64 @@
 module Spree
   module Newsletter
     class Subscribe
-      def initialize(email:, current_user: nil)
+      def initialize(email:, current_user: nil, current_store: nil, redirect_url: nil)
         @email = email
         @current_user = current_user
+        @current_store = current_store || Spree::Store.current
+        @redirect_url = redirect_url
       end
 
       def call
-        return existed_subscription if existed_subscription.present?
+        if existed_subscription.present?
+          Spree::Newsletter::LinkUser.new(subscriber: existed_subscription, user: known_user).call
+          return existed_subscription
+        end
 
         ActiveRecord::Base.transaction do
           upsert_subscriber
           return subscriber if subscriber.errors.any?
 
+          Spree::Newsletter::LinkUser.new(subscriber: subscriber, user: known_user).call
+
           if subscriber.email == current_user&.email
-            # no need to verified since user email is already verified
+            # User's email is already verified by login — skip the double opt-in.
             Spree::Newsletter::Verify.new(subscriber: subscriber).call
           end
         end
 
-        # publish event to trigger email delivery via subscriber
-        subscriber.publish_event('newsletter_subscriber.subscribed') unless subscriber.verified?
+        subscriber.publish_event('newsletter_subscriber.subscription_requested', subscription_requested_payload) unless subscriber.verified?
         subscriber
       end
 
       private
 
-      attr_reader :email, :current_user
+      attr_reader :email, :current_user, :current_store, :redirect_url
+
+      def subscription_requested_payload
+        payload = {
+          id: subscriber.prefixed_id,
+          email: subscriber.email,
+          verification_token: subscriber.verification_token,
+          store_id: current_store.prefixed_id,
+          customer_id: subscriber.user&.prefixed_id
+        }
+        payload[:redirect_url] = redirect_url if redirect_url.present?
+        payload
+      end
 
       def upsert_subscriber
-        @upsert_subscriber ||= Spree::NewsletterSubscriber.find_or_create_by(email: email) do |new_record|
-          new_record.user = Spree.user_class.find_by(email: new_record.email) || current_user
+        @upsert_subscriber ||= Spree::NewsletterSubscriber.find_or_create_by(email: email, store: current_store) do |new_record|
+          new_record.user = known_user
         end
       end
       alias_method :subscriber, :upsert_subscriber
 
       def existed_subscription
-        @existed_subscription ||= Spree::NewsletterSubscriber.verified.find_by(email: email)
+        @existed_subscription ||= Spree::NewsletterSubscriber.verified.find_by(email: email, store: current_store)
+      end
+
+      def known_user
+        @known_user ||= current_user || Spree.user_class.find_by(email: email)
       end
     end
   end

data/app/services/spree/orders/approve.rb

@@ -3,16 +3,37 @@ module Spree
     class Approve
       prepend Spree::ServiceModule::Base
 
-      def call(order:, approver: nil)
-        changes = { considered_risky: false, approved_at: Time.current }
-        if approver.present?
-          changes[:approver_id] = approver.id
+      # Approves an order and records a Spree::OrderApproval history record.
+      #
+      # The legacy keyword `approver:` remains valid; new keywords (`level:`, `note:`)
+      # are additive and stored on the approval record.
+      #
+      # @param order [Spree::Order]
+      # @param approver [Object, nil] the user/admin who approved
+      # @param level [String, nil] approval level (used by 6.0 multi-level B2B flow)
+      # @param note [String, nil] staff-facing note
+      # @return [Spree::ServiceModule::Result]
+      def call(order:, approver: nil, level: nil, note: nil)
+        decided_at = Time.current
+
+        order.transaction do
+          order.approvals.create!(
+            status: 'approved',
+            level: level,
+            note: note,
+            approver: approver,
+            decided_at: decided_at,
+            created_at: decided_at
+          )
+
+          changes = { considered_risky: false, approved_at: decided_at }
+          changes[:approver_id] = approver.id if approver.present?
+          order.update_columns(changes)
         end
-        order.update_columns(changes)
 
         order.publish_event('order.approved')
         success(order.reload)
-      rescue ActiveRecord::Rollback, ActiveRecord::RecordInvalid, StateMachines::InvalidTransition
+      rescue ActiveRecord::RecordInvalid, StateMachines::InvalidTransition
         failure(order)
       end
     end

data/app/services/spree/orders/build_shipments.rb

@@ -0,0 +1,29 @@
+module Spree
+  module Orders
+    # Shared shipment-building step for admin order Create / Update.
+    #
+    # Rebuilds shipments from scratch (Stock::Coordinator), then layers in
+    # tax, costs, and free-shipping promotions so totals reflect delivery
+    # before payment is requested. Without this, draft orders would expose
+    # delivery_total: 0.0 until completion is attempted — which is too late.
+    #
+    # No-op when the order has no shipping address, no line items, or does
+    # not require delivery (digital orders, etc.).
+    class BuildShipments
+      prepend Spree::ServiceModule::Base
+
+      def call(order:)
+        return success(order) unless order.ship_address_id.present?
+        return success(order) unless order.line_items.any?
+        return success(order) unless order.delivery_required?
+
+        order.create_proposed_shipments
+        order.create_shipment_tax_charge!
+        order.set_shipments_cost
+        order.apply_free_shipping_promotions
+
+        success(order)
+      end
+    end
+  end
+end

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

@@ -3,19 +3,50 @@ module Spree
     class Cancel
       prepend Spree::ServiceModule::Base
 
-      def call(order:, canceler: nil, canceled_at: nil)
+      DEFAULT_REASON = 'other'.freeze
+
+      # Cancels an order and records a Spree::OrderCancellation history record.
+      # Legacy `canceler:` and `canceled_at:` remain valid; new keywords are additive.
+      #
+      # @param order [Spree::Order]
+      # @param canceler [Object, nil] the user/admin who initiated the cancellation
+      # @param canceled_at [Time, nil] timestamp (defaults to Time.current)
+      # @param reason [String] one of Spree::OrderCancellation::REASONS
+      # @param note [String, nil] staff-facing note
+      # @param restock_items [Boolean] whether to return inventory
+      # @param refund_payments [Boolean] whether to refund captured payments
+      # @param refund_amount [BigDecimal, Numeric, nil] amount to refund;
+      #   when refund_payments is true and this is nil, defaults to order.payment_total
+      # @param notify_customer [Boolean] hint for subscribers
+      # @return [Spree::ServiceModule::Result]
+      def call(order:, canceler: nil, canceled_at: nil,
+               reason: DEFAULT_REASON, note: nil,
+               restock_items: false, refund_payments: false, refund_amount: nil,
+               notify_customer: false)
         canceled_at ||= Time.current
+        refund_amount ||= order.payment_total if refund_payments
 
         order.transaction do
+          order.cancellations.create!(
+            reason: reason,
+            note: note,
+            restock_items: restock_items,
+            refund_payments: refund_payments,
+            refund_amount: refund_amount,
+            notify_customer: notify_customer,
+            canceled_by: canceler,
+            created_at: canceled_at
+          )
+
           changes = { canceled_at: canceled_at }
           changes[:canceler_id] = canceler.id if canceler.present?
           order.update_columns(changes)
           order.cancel!
         end
 
-        order.publish_event('order.canceled')
+        order.publish_event('order.canceled', order.event_payload.merge(notify_customer: notify_customer))
         success(order.reload)
-      rescue ActiveRecord::Rollback, ActiveRecord::RecordInvalid, StateMachines::InvalidTransition
+      rescue ActiveRecord::RecordInvalid, StateMachines::InvalidTransition
         failure(order)
       end
     end

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

@@ -0,0 +1,53 @@
+module Spree
+  module Orders
+    # Admin-side order completion.
+    #
+    # Distinct from Spree::Carts::Complete (storefront checkout). Callers must
+    # wrap invocation in Spree::Api::V3::OrderLock#with_order_lock — this
+    # service does not lock the row itself.
+    #
+    # @param order [Spree::Order]
+    # @param payment_pending [Boolean] if true, completes the order without
+    #   processing payments. Order is placed but `payment_status` may be
+    #   'balance_due'. Useful for B2B / invoice-later flows.
+    # @param notify_customer [Boolean] if true, the customer receives the
+    #   standard order confirmation email. Defaults to false — admin orders
+    #   complete silently unless explicitly opted in.
+    # @return [Spree::ServiceModule::Result]
+    class Complete
+      prepend Spree::ServiceModule::Base
+
+      def call(order:, payment_pending: false, notify_customer: false)
+        order.notify_customer = notify_customer
+
+        return success(order) if order.completed?
+        return failure(order, 'Order is canceled') if order.canceled?
+
+        process_payments!(order) if order.payment_required? && !payment_pending
+
+        return failure(order, order.errors.full_messages.to_sentence) if order.errors.any?
+
+        advance_to_complete!(order)
+
+        if order.reload.complete?
+          success(order)
+        else
+          failure(order, order.errors.full_messages.to_sentence.presence || 'Could not complete order')
+        end
+      end
+
+      private
+
+      def process_payments!(order)
+        return if order.payment_total >= order.total
+        return if order.payments.valid.any?(&:completed?) && order.unprocessed_payments.empty?
+
+        order.process_payments!
+      end
+
+      def advance_to_complete!(order)
+        order.next until order.complete? || order.errors.present?
+      end
+    end
+  end
+end

data/app/services/spree/orders/create.rb

@@ -0,0 +1,156 @@
+module Spree
+  module Orders
+    # Admin-side order creation. One-shot: customer, items, addresses, currency,
+    # market, locale, notes, metadata, and a coupon code in a single call.
+    # Invalid coupons are non-fatal — the order is created and `result.value`
+    # carries `discount_application_errors`.
+    #
+    # Standalone from Spree::Carts::Create (storefront). Admin-created orders
+    # are first-class Spree::Order records (status: 'draft') in 5.x and remain
+    # so in 6.0 — Spree::Cart in 6.0 is storefront-only.
+    class Create
+      prepend Spree::ServiceModule::Base
+
+      attr_reader :discount_application_errors
+
+      # @param store [Spree::Store]
+      # @param user [Object, nil] resolved customer (Spree.user_class instance)
+      # @param params [Hash] order params (see admin API docs)
+      # @return [Spree::ServiceModule::Result]
+      def call(store:, user: nil, params: {})
+        @store = store
+        @user = user
+        @params = params.to_h.deep_symbolize_keys
+        @discount_application_errors = []
+
+        return failure(:store_is_required) if store.nil?
+
+        order = nil
+        ApplicationRecord.transaction do
+          order = build_order
+          assign_addresses(order)
+          order.tags = @params[:tags] if @params[:tags]
+          order.save!
+
+          add_items(order) if @params[:items].present?
+          build_shipments(order)
+          apply_coupon(order) if @params[:coupon_code].present?
+          order.update_with_updater!
+        end
+
+        success(order.reload)
+      rescue ActiveRecord::RecordInvalid => e
+        failure(e.record, e.record.errors.full_messages.to_sentence)
+      end
+
+      private
+
+      def build_order
+        attrs = {
+          user: @user,
+          email: @params[:email] || @user&.email,
+          currency: @params[:currency].presence&.upcase || @store.default_currency,
+          locale: @params[:locale] || Spree::Current.locale,
+          customer_note: @params[:customer_note],
+          internal_note: @params[:internal_note],
+          metadata: @params[:metadata].to_h,
+          token: Spree::GenerateToken.new.call(Spree::Order),
+          status: 'draft'
+        }
+
+        attrs[:market] = resolve_market if @params[:market_id].present?
+        attrs[:channel] = resolve_channel if @params[:channel_id].present?
+        attrs[:preferred_stock_location] = resolve_preferred_stock_location if @params[:preferred_stock_location_id].present?
+        attrs.compact_blank!
+
+        @store.orders.new(attrs)
+      end
+
+      def resolve_market
+        @store.markets.find_by_param!(@params[:market_id])
+      end
+
+      def resolve_channel
+        @store.channels.find_by_param!(@params[:channel_id])
+      end
+
+      def resolve_preferred_stock_location
+        Spree::StockLocation.for_store(@store).find_by_param!(@params[:preferred_stock_location_id])
+      end
+
+      def assign_addresses(order)
+        if @params[:use_customer_default_address] && @user
+          @user.association(:bill_address).load_target
+          @user.association(:ship_address).load_target
+          order.bill_address = @user.bill_address&.dup
+          order.ship_address = @user.ship_address&.dup
+        end
+
+        assign_address(order, :ship_address, @params[:shipping_address_id], @params[:shipping_address])
+        assign_address(order, :bill_address, @params[:billing_address_id], @params[:billing_address])
+      end
+
+      def assign_address(order, association, address_id, address_attrs)
+        if address_id.present?
+          address = resolve_user_address(address_id)
+          order.public_send(:"#{association}_id=", address.id) if address
+        elsif address_attrs.present?
+          order.public_send(:"#{association}_attributes=", address_attrs)
+        end
+      end
+
+      def resolve_user_address(address_id)
+        return unless @user
+
+        @user.addresses.find_by_param(address_id)
+      end
+
+      def add_items(order)
+        result = Spree::Orders::UpsertItems.call(order: order, items: @params[:items])
+        return if result.success?
+
+        propagate_step_failure!(order, result, fallback: 'Failed to add items to order')
+      end
+
+      def build_shipments(order)
+        result = Spree::Orders::BuildShipments.call(order: order)
+        return if result.success?
+
+        propagate_step_failure!(order, result, fallback: 'Failed to build shipments')
+      end
+
+      # Surface the failing record's errors on the order so the API response
+      # carries an actionable message instead of an empty +processing_error+.
+      # Falls back to a static message when neither the record nor the result
+      # carry one — better than raising +RecordInvalid+ with an empty errors
+      # collection.
+      def propagate_step_failure!(order, result, fallback:)
+        record = result.value
+        if record.respond_to?(:errors) && record.errors.any?
+          record.errors.full_messages.each { |msg| order.errors.add(:base, msg) }
+        elsif result.error.to_s.present?
+          order.errors.add(:base, result.error.to_s)
+        else
+          order.errors.add(:base, fallback)
+        end
+        raise ActiveRecord::RecordInvalid, order
+      end
+
+      def apply_coupon(order)
+        order.coupon_code = @params[:coupon_code]
+        handler = Spree::PromotionHandler::Coupon.new(order).apply
+
+        if handler.successful?
+          order.save!
+        else
+          @discount_application_errors << {
+            code: handler.status_code,
+            message: handler.error,
+            coupon_code: @params[:coupon_code]
+          }
+          order.coupon_code = nil
+        end
+      end
+    end
+  end
+end

data/app/services/spree/orders/update.rb

@@ -0,0 +1,51 @@
+module Spree
+  module Orders
+    # Admin-side order update.
+    #
+    # Updates Order attributes plus optional line items via a flat `items: [...]`
+    # array (matches POST shape and Store API convention). Standalone from
+    # Spree::Carts::Update (storefront).
+    class Update
+      prepend Spree::ServiceModule::Base
+
+      def call(order:, params: {})
+        @order = order
+        @params = params.to_h.deep_symbolize_keys
+
+        items_param = @params.delete(:items)
+
+        ApplicationRecord.transaction do
+          ship_address_id_before = @order.ship_address_id
+
+          if @order.update(@params)
+            process_items(items_param) if items_param
+          else
+            return failure(@order, @order.errors.full_messages.to_sentence)
+          end
+
+          if items_param || @order.ship_address_id != ship_address_id_before
+            build_shipments
+          end
+
+          @order.update_with_updater!
+        end
+
+        success(@order.reload)
+      rescue ActiveRecord::RecordInvalid => e
+        failure(e.record, e.record.errors.full_messages.to_sentence)
+      end
+
+      private
+
+      def process_items(items)
+        result = Spree::Orders::UpsertItems.call(order: @order, items: items)
+        raise ActiveRecord::RecordInvalid, @order if result.failure?
+      end
+
+      def build_shipments
+        result = Spree::Orders::BuildShipments.call(order: @order)
+        raise ActiveRecord::RecordInvalid, @order if result.failure?
+      end
+    end
+  end
+end

data/app/services/spree/orders/upsert_items.rb

@@ -0,0 +1,70 @@
+module Spree
+  module Orders
+    # Bulk upsert line items on an order. Mirrors Spree::Carts::UpsertItems
+    # but is admin/order-side (separate from the cart pipeline per the 6.0
+    # cart/order split — see docs/plans/6.0-cart-order-split.md).
+    #
+    # For each entry in +items+:
+    # - If a line item for the variant already exists -> sets its quantity
+    # - If no line item exists -> creates one with the given quantity
+    #
+    # Order totals are NOT recalculated here. Callers (Spree::Orders::Create
+    # and Spree::Orders::Update) are responsible for running shipment
+    # rebuilding and a final `order.update_with_updater!` once their
+    # full pipeline (items, shipments, coupons) has run.
+    class UpsertItems
+      prepend Spree::ServiceModule::Base
+
+      def call(order:, items:)
+        items = Array(items)
+        return success(order) if items.empty?
+
+        store = order.store || Spree::Current.store
+
+        ApplicationRecord.transaction do
+          items.each do |item_params|
+            item_params = item_params.to_h.deep_symbolize_keys
+            variant = resolve_variant(store, item_params[:variant_id])
+            next unless variant
+
+            quantity = (item_params[:quantity] || 1).to_i
+            next if quantity <= 0
+
+            return failure(variant, "#{variant.name} is not available in #{order.currency}") if variant.amount_in(order.currency).nil?
+
+            line_item = Spree.line_item_by_variant_finder.new.execute(order: order, variant: variant)
+
+            if line_item
+              line_item.quantity = quantity
+              line_item.metadata = line_item.metadata.merge(item_params[:metadata].to_h) if item_params[:metadata].present?
+            else
+              line_item = order.line_items.new(quantity: quantity, variant: variant, options: { currency: order.currency })
+              line_item.metadata = item_params[:metadata].to_h if item_params[:metadata].present?
+            end
+
+            return failure(line_item) unless line_item.save
+          end
+        end
+
+        success(order)
+      end
+
+      private
+
+      def resolve_variant(store, variant_id)
+        return nil if variant_id.blank?
+
+        variant = store.variants.find_by_param(variant_id)
+
+        raise ActiveRecord::RecordNotFound.new(
+          "Variant '#{variant_id}' not found in this store",
+          'Spree::Variant',
+          'id',
+          variant_id
+        ) unless variant
+
+        variant
+      end
+    end
+  end
+end