spree_core 5.4.2 → 5.5.0.rc1

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

data/app/services/spree/payments/handle_webhook.rb

@@ -28,6 +28,8 @@ module Spree
 
       private
 
+      # `Spree::Payment#confirm!` honors the payment method's `auto_capture?` setting:
+      # auto_capture → complete! + capture_event; otherwise → pend! (auth-only, payment_state=balance_due).
       def handle_success(payment_session, order, metadata)
         order.with_lock do
           # Idempotency: if the session was already completed (by the API
@@ -36,19 +38,10 @@ module Spree
             return success(payment_session)
           end
 
-          # Ensure payment record exists
           payment = payment_session.find_or_create_payment!(metadata)
-
-          # Mark payment as completed — the webhook confirms the gateway processed it
-          if payment.present? && !payment.completed?
-            payment.started_processing! if payment.checkout?
-            payment.complete! if payment.can_complete?
-          end
-
-          # Mark session as completed
+          payment.confirm! if payment.present? && !payment.completed?
           payment_session.complete if payment_session.can_complete?
 
-          # Complete order if not already done
           unless order.reload.completed?
             Spree::Dependencies.carts_complete_service.constantize.call(cart: order)
           end

data/app/services/spree/prices/bulk_upsert.rb

@@ -0,0 +1,201 @@
+module Spree
+  module Prices
+    # Bulk-writes Spree::Price rows and sweeps stale placeholder rows in
+    # one transaction.
+    #
+    # `spree_prices` is guarded by two partial unique indexes on PG/SQLite
+    # (collapsed to one composite index on MySQL):
+    #   - base prices (price_list_id IS NULL): unique on (variant_id, currency)
+    #   - overrides   (price_list_id IS NOT NULL): unique on (variant_id, currency, price_list_id)
+    # A single `upsert_all` can only target one index, so rows ship in two
+    # batches — base vs override — each routed to the correct ON CONFLICT.
+    #
+    # Both indexes are also partial on `amount IS NOT NULL`, so `upsert_all`
+    # can't see placeholder rows (amount IS NULL) as conflict targets —
+    # filling in a placeholder via upsert inserts a sibling row instead of
+    # updating. The post-write sweep removes those.
+    class BulkUpsert
+      prepend Spree::ServiceModule::Base
+
+      # Two partial unique indexes guard `spree_prices` on PG/SQLite:
+      #   - base prices (price_list_id IS NULL): unique on (variant_id, currency)
+      #   - overrides   (price_list_id IS NOT NULL): unique on (variant_id, currency, price_list_id)
+      # A single `upsert_all` can only target one index, so base-price rows
+      # and override rows ship in separate batches.
+      BASE_UNIQUE_BY = %i[variant_id currency].freeze
+      OVERRIDE_UNIQUE_BY = %i[variant_id currency price_list_id].freeze
+
+      # @param rows [Array<Hash>] each row must carry
+      #   `variant_id`, `currency`, and `amount`; `price_list_id` and
+      #   `compare_at_amount` are optional. A blank `amount` is treated
+      #   as "clear this price."
+      # @return [Spree::ServiceModule::Result] success carries
+      #   `{ price_count: N }` — the number of rows passed to
+      #   `upsert_all`.
+      def call(rows:)
+        rows = Array(rows).map { |r| r.with_indifferent_access }
+        keyed = rows.select { |r| r[:variant_id].present? && r[:currency].present? }
+        # PG rejects an upsert with two rows hitting the same unique-key
+        # triple in one statement ("ON CONFLICT DO UPDATE command cannot
+        # affect row a second time"). Last-write-wins: keep the last
+        # occurrence of each triple.
+        deduped = keyed.reverse.uniq { |r| [r[:variant_id], r[:currency], r[:price_list_id]] }.reverse
+        upsert_rows, clear_rows = deduped.partition { |r| r[:amount].present? }
+
+        payload = build_payload(upsert_rows)
+        affected_keys = deduped.map { |r| [r[:variant_id], r[:currency], r[:price_list_id]] }
+
+        return success(price_count: 0) if affected_keys.empty?
+
+        base_rows, override_rows = payload.partition { |r| r[:price_list_id].nil? }
+
+        Spree::Price.transaction do
+          # MySQL treats NULL values as distinct in unique indexes, so
+          # `ON DUPLICATE KEY UPDATE` never fires for base prices —
+          # `upsert_all` would silently insert a sibling row. Route base
+          # rows through a SELECT-then-UPDATE/INSERT path on MySQL only.
+          if base_rows.any? && mysql?
+            upsert_base_rows_for_mysql(base_rows)
+          else
+            upsert_batch(base_rows, BASE_UNIQUE_BY)
+          end
+          upsert_batch(override_rows, OVERRIDE_UNIQUE_BY)
+          sweep(affected_keys, clear_rows)
+          # `upsert_all` and `delete_all` both skip AR callbacks, so the
+          # `Price -> Variant -> Product` `touch:` chain never fires —
+          # downstream caches (`cache_key_with_version`) would stay stale.
+          # Re-trigger the chain with one `.touch` per affected variant.
+          touch_variants(affected_keys.map(&:first).uniq)
+        end
+
+        success(price_count: payload.length)
+      end
+
+      private
+
+      # `update_only` lists only domain columns. Rails adds `updated_at`
+      # automatically (when `record_timestamps` is on, which it is for
+      # `Spree::Price`); listing it explicitly here produces
+      # `SET updated_at = …, updated_at = …` on PG and the statement fails
+      # with "multiple assignments to same column".
+      def upsert_batch(rows, unique_by)
+        return if rows.empty?
+
+        Spree::Price.upsert_all(
+          rows,
+          update_only: %i[amount compare_at_amount],
+          **upsert_opts(unique_by)
+        )
+      end
+
+      def build_payload(rows)
+        now = Time.current
+        rows.map do |row|
+          {
+            variant_id: row[:variant_id],
+            currency: row[:currency],
+            price_list_id: row[:price_list_id],
+            amount: parse_amount(row[:amount]),
+            compare_at_amount: parse_amount(row[:compare_at_amount]),
+            created_at: now,
+            updated_at: now
+          }
+        end
+      end
+
+      # Parses locale-aware decimal input ("1.234,56" in DE, "1,234.56"
+      # in en-US). Numeric values pass through; blank values become nil.
+      def parse_amount(value)
+        return nil if value.blank?
+        return value if value.is_a?(Numeric)
+
+        Spree::LocalizedNumber.parse(value)
+      end
+
+      def sweep(affected_keys, clear_rows)
+        cleared_keys = clear_rows.map { |r| [r[:variant_id], r[:currency], r[:price_list_id]] }.to_set
+        affected_set = affected_keys.to_set
+
+        candidates = Spree::Price
+          .where(
+            variant_id: affected_keys.map(&:first).uniq,
+            currency: affected_keys.map { |k| k[1] }.uniq,
+            price_list_id: affected_keys.map(&:last).uniq
+          )
+          .pluck(:id, :variant_id, :currency, :price_list_id, :amount)
+
+        doomed_ids = candidates.filter_map do |id, variant_id, currency, price_list_id, amount|
+          key = [variant_id, currency, price_list_id]
+          next unless affected_set.include?(key)
+          next id if amount.nil?
+          next id if cleared_keys.include?(key)
+
+          nil
+        end
+
+        Spree::Price.where(id: doomed_ids).delete_all if doomed_ids.any?
+      end
+
+      # Bumps `updated_at` on the affected variants and their parent
+      # products to invalidate `cache_key_with_version`-based caches —
+      # `upsert_all` and `delete_all` skip the `Price -> Variant` and
+      # `Variant -> Product` `touch:` chains otherwise.
+      #
+      # We deliberately bypass AR callbacks: invoking `Variant#touch`
+      # would fire `after_commit :remove_prices_from_master_variant`,
+      # which `delete_all`s the master's prices whenever a non-master
+      # sibling has any prices — wiping exactly the rows the bulk
+      # upsert just persisted on a freshly-created list. `touch_all`
+      # gives us the cache bust without that side effect.
+      def touch_variants(variant_ids)
+        return if variant_ids.empty?
+
+        variants = Spree::Variant.where(id: variant_ids)
+        product_ids = variants.pluck(:product_id).uniq
+        variants.touch_all
+        Spree::Product.where(id: product_ids).touch_all if product_ids.any?
+      end
+
+      # MySQL infers conflict targets from its own unique indexes and
+      # rejects an explicit `unique_by`.
+      def upsert_opts(unique_by)
+        return {} if mysql?
+
+        { unique_by: unique_by }
+      end
+
+      def mysql?
+        ActiveRecord::Base.connection.adapter_name == 'Mysql2'
+      end
+
+      # MySQL-only path: NULLs are distinct in unique indexes, so
+      # `(variant_id, currency, NULL)` doesn't conflict with another
+      # `(variant_id, currency, NULL)` — `upsert_all` would insert a
+      # sibling instead of updating. Look up existing base rows first,
+      # update them one by one, and `insert_all` the rest.
+      def upsert_base_rows_for_mysql(rows)
+        rows_by_key = rows.index_by { |r| [r[:variant_id], r[:currency]] }
+
+        Spree::Price.where(
+          variant_id: rows.map { |r| r[:variant_id] }.uniq,
+          currency: rows.map { |r| r[:currency] }.uniq,
+          price_list_id: nil
+        ).find_each do |price|
+          # The `IN (...)` query can return cross-pairs (e.g. `v=1,c=EUR`
+          # exists in the DB even though the caller only passed `v=1,c=USD`
+          # and `v=2,c=EUR`). Skip rows the caller didn't request.
+          row = rows_by_key.delete([price.variant_id, price.currency])
+          next unless row
+
+          price.update_columns(
+            amount: row[:amount],
+            compare_at_amount: row[:compare_at_amount],
+            updated_at: row[:updated_at]
+          )
+        end
+
+        Spree::Price.insert_all(rows_by_key.values) if rows_by_key.any?
+      end
+    end
+  end
+end

data/app/services/spree/products/duplicator.rb

@@ -28,7 +28,7 @@ module Spree
           new_product.status = :draft
           new_product.name = "COPY OF #{product.name}"
           new_product.taxons = product.taxons
-          new_product.stores = product.stores
+          new_product.channels = product.channels
           new_product.created_at = nil
           new_product.deleted_at = nil
           new_product.updated_at = nil

data/app/services/spree/products/prepare_nested_attributes.rb

@@ -67,14 +67,8 @@ module Spree
           end
         end
 
-        # ensure there is at least one store
-        params[:store_ids] = [store.id] if params[:store_ids].blank?
-
-        # Preserve taxon associations from other stores
-        # Only merge taxon_ids from other stores if taxon_ids are being updated
-        if params.key?(:taxon_ids)
-          params[:taxon_ids] = merge_taxons_from_other_stores(params[:taxon_ids])
-        end
+        # ensure the product is owned by a store
+        params[:store_id] = store.id if params[:store_id].blank? && product.store_id.blank?
 
         # Add empty list for option_type_ids and mark variants as removed if there are no variants and options
         if params[:variants_attributes].blank? && variants_to_remove.any? && !params.key?(:option_type_ids)
@@ -186,28 +180,6 @@ module Spree
         attributes
       end
 
-      # Merges taxon IDs from other stores with submitted taxon IDs from current store.
-      #
-      # This prevents the loss of taxon associations from other stores when a product
-      # is edited in one store. Each store's taxonomy is independent, so editing
-      # categories in Store A should not affect categories in Store B.
-      #
-      # @param submitted_taxon_ids [Array<String>] Taxon IDs from the current store
-      # @return [Array<String>] Combined unique taxon IDs
-      def merge_taxons_from_other_stores(submitted_taxon_ids)
-        return submitted_taxon_ids if product.new_record?
-
-        # Get taxon IDs from other stores that should be preserved
-        other_stores_taxon_ids = product.taxons
-                                        .joins(:taxonomy)
-                                        .where.not(spree_taxonomies: { store_id: store.id })
-                                        .pluck(:id)
-                                        .map(&:to_s)
-
-        # Merge with submitted taxon IDs from current store and remove duplicates
-        (submitted_taxon_ids + other_stores_taxon_ids).uniq
-      end
-
       def update_option_value_variants(option_value_params, existing_variant)
         return {} unless option_value_params.present?
         return {} unless can_manage_option_types?