spree_core 5.6.1 → 6.0.0.beta2

data/app/models/spree/channel_stock_location.rb

@@ -0,0 +1,8 @@
+module Spree
+  class ChannelStockLocation < Spree.base_class
+    belongs_to :channel, class_name: 'Spree::Channel', inverse_of: :channel_stock_locations
+    belongs_to :stock_location, class_name: 'Spree::StockLocation'
+
+    validates :stock_location_id, uniqueness: { scope: :channel_id }
+  end
+end

data/app/models/spree/claim.rb

@@ -0,0 +1,69 @@
+module Spree
+  # A customer reports a problem with a delivery and the merchant makes it
+  # right without necessarily asking for the goods back. What went wrong is
+  # recorded on {Spree::ClaimReason}, the merchant-owned vocabulary.
+  #
+  # New in 6.0 — there was previously no way to model "send a replacement
+  # without asking for the original back". Transitions are workflows
+  # (docs/plans/6.0-returns-exchanges-claims.md).
+  class Claim < Spree.base_class
+    has_prefix_id :claim
+
+    has_spree_number prefix: 'CLM'
+    include Spree::ActedBy
+    include Spree::NumberIdentifier
+    include Spree::SingleStoreResource
+    include Spree::HasStatus
+    include Spree::HasCustomFields
+    include Spree::Metadata
+
+    publishes_lifecycle_events
+
+    has_status :open, :approved, :resolved, :denied, :canceled, default: :open
+
+    # Each resolution drives real behaviour in Spree::Claims::Resolve, so this
+    # stays closed — an unrecognised value would silently do nothing.
+    RESOLUTIONS = %w[refund replacement refund_and_replacement].freeze
+
+    belongs_to :store, class_name: 'Spree::Store'
+    belongs_to :order, class_name: 'Spree::Order', inverse_of: :claims
+    belongs_to :reason, class_name: 'Spree::ClaimReason', optional: true, inverse_of: :claims
+    acted_by :created_by
+
+    has_many :claim_line_items, class_name: 'Spree::ClaimLineItem',
+                                dependent: :destroy, inverse_of: :claim
+    has_many :refunds, class_name: 'Spree::Refund', as: :originator, dependent: :nullify
+
+    validates :claim_line_items, presence: true, on: :create
+    validates :resolution, inclusion: { in: RESOLUTIONS }, allow_nil: true
+
+    accepts_nested_attributes_for :claim_line_items, allow_destroy: true
+
+    delegate :currency, to: :order
+
+    self.whitelisted_ransackable_attributes = %w[number status created_at]
+    self.whitelisted_ransackable_associations = %w[order reason]
+
+    def refund_total
+      claim_line_items.sum(&:refund_amount)
+    end
+
+    # What a refund from this claim paid for, line by line — each line already
+    # carries the amount agreed for it.
+    #
+    # @return [Hash{Integer => BigDecimal}] line item id => amount
+    def refunded_line_amounts
+      claim_line_items.each_with_object(Hash.new(0)) do |line, amounts|
+        amounts[line.line_item_id] += line.refund_amount.to_d
+      end
+    end
+
+    def display_refund_total
+      Spree::Money.new(refund_total, currency: currency)
+    end
+
+    def replacement_line_items
+      claim_line_items.select(&:send_replacement)
+    end
+  end
+end

data/app/models/spree/claim_line_item.rb

@@ -0,0 +1,46 @@
+module Spree
+  # One problem item on a {Spree::Claim}, and how it is being made right:
+  # money back, a replacement, or both.
+  class ClaimLineItem < Spree.base_class
+    has_prefix_id :cli
+
+    belongs_to :claim, class_name: 'Spree::Claim', inverse_of: :claim_line_items
+    belongs_to :line_item, class_name: 'Spree::LineItem'
+    belongs_to :variant, -> { with_deleted }, class_name: 'Spree::Variant'
+    # Nil means "send the same thing again"; a different variant swaps it.
+    belongs_to :replacement_variant, -> { with_deleted }, class_name: 'Spree::Variant', optional: true
+
+    # Photographic evidence of damage, supplied by the customer.
+    has_many_attached :images
+
+    validates :quantity, numericality: { greater_than: 0 }
+    validates :refund_amount, numericality: { greater_than_or_equal_to: 0 }
+
+    before_validation :set_variant_from_line_item, on: :create
+
+    delegate :order, :currency, to: :claim
+
+    # What the customer paid for the affected units, after discounts — the
+    # ceiling for a refund on this line.
+    def paid_amount
+      return 0 if line_item.nil? || line_item.quantity.to_i.zero?
+
+      (line_item.amount / line_item.quantity) * quantity.to_i
+    end
+
+    def display_refund_amount
+      Spree::Money.new(refund_amount, currency: currency)
+    end
+
+    # What actually ships when the claim is resolved with a replacement.
+    def variant_to_send
+      replacement_variant || variant
+    end
+
+    private
+
+    def set_variant_from_line_item
+      self.variant ||= line_item&.variant
+    end
+  end
+end

data/app/models/spree/claim_reason.rb

@@ -0,0 +1,24 @@
+module Spree
+  # Why a customer raised a claim — "arrived damaged", "never arrived",
+  # "wrong item sent". A different vocabulary from {Spree::ReturnReason}:
+  # a claim is about something the merchant got wrong, not about a customer
+  # changing their mind.
+  class ClaimReason < Spree.base_class
+    has_prefix_id :clr
+
+    include Spree::NamedType
+    include Spree::Metadata
+
+    self.whitelisted_ransackable_attributes = %w[name active]
+
+    has_many :claims, class_name: 'Spree::Claim', inverse_of: :reason, dependent: :restrict_with_error
+
+    # Mirrors what `dependent: :restrict_with_error` enforces, so the dashboard
+    # can hide the delete control rather than offer one the model will refuse.
+    #
+    # @return [Boolean]
+    def can_be_deleted?
+      !claims.exists?
+    end
+  end
+end

data/app/models/spree/classification.rb

@@ -1,52 +1,10 @@
-module Spree
-  class Classification < Spree.base_class
-    self.table_name = 'spree_products_taxons'
-    acts_as_list scope: :taxon
-
-    with_options inverse_of: :classifications, touch: true do
-      belongs_to :product, class_name: 'Spree::Product', counter_cache: :classification_count
-      belongs_to :taxon, class_name: 'Spree::Taxon', counter_cache: :classification_count
-    end
-
-    validates :taxon, :product, presence: true
-    validates :position, numericality: { only_integer: true, allow_blank: true, allow_nil: true }
-    # For #3494
-    validates :taxon_id, uniqueness: { scope: :product_id, message: :already_linked, allow_blank: true }
-
-    # Keep the taxon's descendant-inclusive products_count (and its ancestors')
-    # in sync on direct create/destroy. Bulk Taxons::AddProducts/RemoveProducts
-    # skip these callbacks and recompute explicitly.
-    after_create :recalculate_taxon_products_count
-    after_destroy :recalculate_taxon_products_count
+# frozen_string_literal: true
 
-    self.whitelisted_ransackable_attributes = ['taxon_id', 'product_id']
-
-    scope :by_best_selling, lambda { |order_direction = :desc|
-      left_joins(product: :orders).
-        select("#{Spree::Classification.table_name}.*, COUNT(#{Spree::Order.table_name}.id) AS completed_orders_count, SUM(#{Spree::Order.table_name}.total) AS completed_orders_total").
-        where(Spree::Order.table_name => { id: nil }).
-        or(where.not(Spree::Order.table_name => { completed_at: nil })).
-        group("#{Spree::Classification.table_name}.id").
-        reorder(completed_orders_count: order_direction, completed_orders_total: order_direction)
-    }
-
-    scope :grouped_taxon_ids_for_products, lambda { |product_ids, taxon_groups|
-      where(product_id: product_ids, taxon_id: taxon_groups).
-        group(:product_id).
-        then do |query|
-        case ActiveRecord::Base.connection.adapter_name
-        when 'PostgreSQL'
-          query.pluck(:product_id, Arel.sql("STRING_AGG(taxon_id::text, ',')"))
-        when 'Mysql2', 'SQLite'
-          query.pluck(:product_id, Arel.sql('GROUP_CONCAT(taxon_id)'))
-        end
-      end
-    }
-
-    private
+module Spree
+  # Deprecation alias for Spree::ProductCategory, renamed from Spree::Classification
+  # in 6.0. A true constant alias (AR-safe); the warning fires when this file loads.
+  # Removed in 6.1.
+  Classification = ProductCategory
 
-    def recalculate_taxon_products_count
-      Spree::Taxon.recalculate_products_count(taxon_id)
-    end
-  end
+  Spree::Deprecation.warn('Spree::Classification is deprecated and will be removed in Spree 6.1. Use Spree::ProductCategory instead.')
 end

data/app/models/spree/collection.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+require 'stringex'
+
+module Spree
+  class Collection < Spree.base_class
+    include Spree::SingleStoreResource
+    include Spree::HasListPosition
+
+    has_prefix_id :coll
+
+    RULES_MATCH_POLICIES = %w[all any].freeze
+    # Space format (e.g. 'price asc') is required by the search sort pipeline:
+    # FiltersAggregator#to_api_sort splits on a space, and apply_sort maps to 'price'/etc.
+    SORT_ORDERS = [
+      'manual',
+      'best_selling',
+      'price asc',
+      'price desc',
+      'available_on desc',
+      'available_on asc',
+      'name asc',
+      'name desc'
+    ].freeze
+
+    include Spree::TranslatableResource
+    include Spree::TranslatableResourceSlug
+    include Spree::HasCustomFields
+    include Spree::Metadata
+    include Spree::SanitizableRichText
+    include Spree::HasLibraryMedia
+
+    #
+    # Slug / permalink — FriendlyId with history (mirrors Spree::Category; flat, no hierarchy).
+    # `use: :history` keeps old permalinks resolving via the shared friendly_id_slugs table
+    # after a rename. Declared before `translates` (as in Taxon). Within-store uniqueness is
+    # still enforced by the validation + DB index below — a collision errors (as in Taxon),
+    # it does not auto-suffix.
+    #
+    extend FriendlyId
+    friendly_id :permalink, slug_column: :permalink, use: :history
+
+    TRANSLATABLE_FIELDS = %i[name description permalink].freeze
+    RICH_TEXT_TRANSLATABLE_FIELDS = %i[description].freeze
+    translates(*TRANSLATABLE_FIELDS, column_fallback: Spree.mobility_column_fallback)
+
+    #
+    # Rich text
+    #
+    has_spree_rich_text :description
+
+    self::Translation.class_eval do
+      include Spree::SanitizableRichText
+
+      sanitizes_rich_text :description
+    end
+
+    #
+    # Associations
+    #
+    belongs_to :store, class_name: 'Spree::Store'
+
+    has_many :product_collections, class_name: 'Spree::ProductCollection', dependent: :destroy_async, inverse_of: :collection
+    has_many :products, through: :product_collections
+
+    has_many :rules, class_name: 'Spree::CollectionRule', dependent: :destroy, inverse_of: :collection
+    accepts_nested_attributes_for :rules, allow_destroy: true, reject_if: proc { |attributes|
+      attributes['value'].blank?
+    }
+
+    #
+    # Attachments
+    #
+    has_one_attached :image, service: Spree.public_storage_service_name
+    has_one_attached :square_image, service: Spree.public_storage_service_name
+    # The slots double as media-library placements, so an upload here is
+    # visible and reusable there (Spree::HasLibraryMedia).
+    has_library_media :image, :square_image
+
+    #
+    # Positioning (flat, store-scoped)
+    #
+    acts_as_list scope: :store_id
+
+    #
+    # Validations
+    #
+    validates :name, presence: true
+    validates :permalink, uniqueness: { scope: :store_id, case_sensitive: false, allow_blank: true }
+    validates :rules_match_policy, inclusion: { in: RULES_MATCH_POLICIES }, presence: true
+    validates :sort_order, inclusion: { in: SORT_ORDERS }, presence: true
+
+    before_validation :set_permalink, if: :name
+
+    #
+    # Scopes
+    #
+    scope :manual, -> { where.not(automatic: true) }
+    scope :automatic, -> { where(automatic: true) }
+
+    #
+    # Ransack
+    #
+    self.whitelisted_ransackable_attributes = %w[permalink automatic sort_order products_count]
+
+    #
+    # Automatic (rule-based) membership
+    #
+    after_commit :regenerate_products, on: [:update], if: -> { automatic? && (saved_change_to_automatic? || saved_change_to_rules_match_policy?) }
+    attribute :marked_for_regenerate_products, :boolean, default: true
+
+    def manual?
+      !automatic?
+    end
+
+    def manual_sort_order?
+      sort_order == 'manual'
+    end
+
+    def slug
+      permalink
+    end
+
+    def slug=(value)
+      self.permalink = value
+    end
+
+    # Rebuild the materialized ProductCollection membership from the rules.
+    # Pass only_once: true to fire at most once per object lifecycle.
+    #
+    # @param only_once [Boolean]
+    # @return [void]
+    def regenerate_products(only_once: false)
+      return unless marked_for_regenerate_products?
+
+      Spree::Collections::RegenerateProducts.call(collection: self)
+      self.marked_for_regenerate_products = false if !frozen? && only_once
+    end
+
+    # Products matching the automatic rules (mirrors Spree::Category#products_matching_rules).
+    #
+    # @return [ActiveRecord::Relation]
+    def products_matching_rules(opts = {})
+      return Spree::Product.none if manual? || rules.empty?
+
+      currency = opts[:currency] || store.default_currency
+      storefront = opts[:storefront] || false
+
+      all_products = store.products.not_archived
+      all_products = all_products.active(currency: currency) if storefront
+
+      any_rules_match_policy = rules_match_policy == 'any'
+      products = any_rules_match_policy ? Spree::Product.none : all_products
+
+      rules.each do |rule|
+        if any_rules_match_policy
+          product_ids = rule.apply(all_products).ids
+          products = products.or(all_products.where(id: product_ids)) if product_ids.any?
+        else
+          products = rule.apply(products)
+        end
+      end
+
+      products
+    end
+
+    # Maps a wire `type` onto a registered rule class name. Accepts both the
+    # `/collection_rules/types` shorthand (`tag`) and the STI class name,
+    # matching how every other subclassed resource is written.
+    #
+    # Matching is string-only against the in-memory registry — nothing from the
+    # wire is ever constantized. An unregistered value resolves to nil, which
+    # leaves the record as the abstract base class so it fails CollectionRule's
+    # type validation with a 422 (assigning it would make ActiveRecord raise
+    # SubclassNotFound, a 500).
+    #
+    # @param type [String, nil] wire shorthand or STI class name
+    # @return [String, nil] the registered class name, or nil when unregistered
+    def self.resolve_rule_type(type)
+      return nil if type.blank?
+
+      Rails.application.config.spree.collection_rules.
+        find { |klass| klass.api_type == type.to_s }&.to_s
+    end
+
+    # Syncs automatic rules from an array of attribute hashes by mutating the
+    # in-memory `rules` association: hashes with an id update the matching rule
+    # (accepting the prefixed `crule_` id), hashes without an id build a new
+    # rule (the STI `type` selects the subclass), and any existing rule absent
+    # from the payload is destroyed. Autosave persists the whole set in the
+    # parent's save transaction. Mirrors Spree::OptionType#option_values= so the
+    # Admin API can send the full desired rule set and have it round-trip.
+    #
+    # Falls back to the association writer when given CollectionRule records
+    # (non-API callers / accepts_nested_attributes_for).
+    #
+    # @param rules_params [Array<Hash>] array of rule attribute hashes
+    # @return [void]
+    def rules=(rules_params)
+      return super if rules_params.blank? || rules_params.first.is_a?(Spree::CollectionRule)
+
+      existing_by_id = rules.to_a.index_by(&:id)
+      retained_ids = []
+
+      rules_params.each do |rule_data|
+        data = rule_data.to_h.with_indifferent_access
+        rule_id = data.delete(:id)
+        data[:type] = self.class.resolve_rule_type(data[:type]) if data.key?(:type)
+
+        record = if rule_id.present?
+                   existing_by_id[Spree::PrefixedId.decode_prefixed_id(rule_id) || rule_id] ||
+                     raise(ActiveRecord::RecordNotFound.new("Couldn't find Spree::CollectionRule with param=#{rule_id}", 'Spree::CollectionRule'))
+                 else
+                   rules.build(data)
+                 end
+        record.assign_attributes(data) if rule_id.present?
+        retained_ids << record.id if record.persisted?
+      end
+
+      existing_by_id.each_value do |existing|
+        existing.mark_for_destruction unless retained_ids.include?(existing.id)
+      end
+    end
+
+    # Slug generation, flat (no parent hierarchy). Mirrors Spree::Category's dual set_permalink:
+    # with translations off, the model writes the base permalink column directly (which
+    # column_fallback routes the default locale to, bypassing the Translation before_save);
+    # with translations on, each Translation generates its own. An existing permalink is
+    # sticky — renaming the collection does not rewrite it (set permalink explicitly to change).
+    def set_permalink
+      if Spree.use_translations?
+        translations.each(&:set_permalink)
+      else
+        self.permalink = generate_slug
+      end
+    end
+
+    def generate_slug
+      permalink.blank? ? name.to_url : permalink.to_url
+    end
+
+    # Per-locale slug accessors + generation on the Mobility translation.
+    self::Translation.class_eval do
+      before_save :set_permalink
+
+      def slug
+        permalink
+      end
+
+      def slug=(value)
+        self.permalink = value
+      end
+
+      def set_permalink
+        self.permalink = generate_slug
+      end
+
+      def name_with_fallback
+        name.blank? ? translated_model[:name] : name
+      end
+
+      private
+
+      def generate_slug
+        permalink.blank? ? name_with_fallback.to_url : permalink.to_url
+      end
+    end
+  end
+end

data/app/models/spree/collection_rule.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Spree
+  class CollectionRule < Spree.base_class
+    has_prefix_id :crule
+
+    MATCH_POLICIES = %w[is_equal_to is_not_equal_to contains does_not_contain].freeze
+
+    belongs_to :collection, class_name: 'Spree::Collection', inverse_of: :rules, touch: true
+
+    validates :type, :value, presence: true
+    validates :match_policy, inclusion: { in: MATCH_POLICIES }, presence: true
+
+    after_commit :regenerate_collection_products,
+                 if: -> { saved_change_to_value? || destroyed? || saved_change_to_match_policy? }
+
+    delegate :store, to: :collection
+
+    validate :type_must_be_registered
+
+    # @return [String] localized display name for the rule kind, used by admin pickers
+    def self.human_name
+      Spree.t("collection_rule_types.#{api_type}.name", default: api_type.titleize)
+    end
+
+    # @return [String] localized description for the rule kind
+    def self.human_description
+      Spree.t("collection_rule_types.#{api_type}.description", default: '')
+    end
+
+    # Feeds the `description` field of `subclasses_with_preference_schema`
+    # (the `/types` discovery payload), which only reads `.description`.
+    def self.description
+      human_description
+    end
+
+    def human_name = self.class.human_name
+    def human_description = self.class.human_description
+
+    registers_subclasses_via { Rails.application.config.spree.collection_rules }
+
+    private
+
+    # Guards against an arbitrary class name reaching the STI `type` column
+    # through the API.
+    def type_must_be_registered
+      return if type.blank?
+      return if Rails.application.config.spree.collection_rules.any? { |rule| rule.to_s == type }
+
+      errors.add(:type, :invalid_collection_rule, message: Spree.t(:invalid_collection_rule, scope: [:errors, :messages],
+                                                          default: 'is not a registered collection rule'))
+    end
+
+    def regenerate_collection_products
+      collection.regenerate_products(only_once: true)
+    end
+  end
+end

data/app/models/spree/collection_rules/available_on.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Spree
+  module CollectionRules
+    class AvailableOn < Spree::CollectionRule
+      # value is the number of days; matches products created/available within that window.
+      def apply(scope)
+        timezone = collection.store.preferred_timezone
+        date = value.to_i.days.ago.beginning_of_day.in_time_zone(timezone)
+
+        if match_policy == 'is_equal_to'
+          scope.where(['spree_products.created_at >= ?', date]).or(
+            scope.where(['spree_products.available_on >= ?', date])
+          )
+        else
+          scope
+        end
+      end
+    end
+  end
+end

data/app/models/spree/collection_rules/sale.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Spree
+  module CollectionRules
+    class Sale < Spree::CollectionRule
+      def apply(scope)
+        case match_policy
+        when 'is_equal_to', 'contains'
+          scope.on_sale(store.default_currency)
+        when 'is_not_equal_to', 'does_not_contain'
+          scope.where.not(id: scope.on_sale(store.default_currency))
+        else
+          scope
+        end
+      end
+    end
+  end
+end

data/app/models/spree/collection_rules/tag.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Spree
+  module CollectionRules
+    class Tag < Spree::CollectionRule
+      def apply(scope)
+        if match_policy == 'is_equal_to'
+          scope.tagged_with(value)
+        elsif match_policy == 'is_not_equal_to'
+          scope.tagged_with(value, exclude: true)
+        elsif match_policy == 'contains'
+          scope.tagged_with(value, any: true)
+        elsif match_policy == 'does_not_contain'
+          scope.tagged_with(value, any: true, exclude: true)
+        else
+          scope
+        end
+      end
+    end
+  end
+end

data/app/models/spree/commission_line.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Spree
+  # What one sale earned the marketplace, frozen at placement.
+  #
+  # Deliberately **not** a Spree::Fee. A fee is buyer-facing and rolls into the
+  # order total; a commission is a platform↔seller settlement the customer
+  # never sees, so it lives off the order and never touches its totals. It
+  # merely follows the same typed-line design — concrete FKs, no polymorphic
+  # source, no state machine.
+  #
+  # Every field is a snapshot: the rate that applied, what it charged, and the
+  # VAT charged on top of it. Editing the Spree::CommissionRate afterwards
+  # changes nothing here, and neither does deleting it.
+  #
+  # `tax_amount` is the EU piece and the reason this model exists rather than a
+  # single `amount` column: the marketplace's commission is its own taxable B2B
+  # supply to the seller, separate from the consumer's item sale, so the two
+  # VATs are computed independently and never mix.
+  class CommissionLine < Spree.base_class
+    has_prefix_id :cline
+
+    include Spree::Metadata
+
+    # Where the fee was taxed, validated against the ISO registry like every
+    # other geography column. The seller's own jurisdiction, not the shopper's.
+    has_iso_geography
+
+    #
+    # Associations
+    #
+    belongs_to :order, class_name: 'Spree::Order'
+    belongs_to :seller, class_name: 'Spree::Seller'
+    # Exactly one of these: the item that was commissioned, or the delivery,
+    # when the rate carries include_shipping.
+    belongs_to :line_item, class_name: 'Spree::LineItem', optional: true
+    belongs_to :fulfillment, class_name: 'Spree::Fulfillment', optional: true
+    # Optional because configuration outlives its use the other way round: the
+    # rate may be deleted while this record has to stay readable.
+    belongs_to :commission_rate, class_name: 'Spree::CommissionRate', optional: true
+
+    #
+    # Validations
+    #
+    validates :amount, :tax_amount, :total, :rate, :tax_rate, numericality: true
+    # Deliberately Spree::TaxLine's vocabulary rather than a second one: an
+    # invoice explaining why a marketplace fee was zero-rated or reverse-charged
+    # should use the same words as the one explaining it for goods, and a
+    # provider registering a new treatment registers it once. Read through the
+    # lambda so a reason added after boot is accepted, as it is there.
+    validates :taxability_reason,
+              inclusion: { in: ->(_line) { Spree::TaxLine.taxability_reasons } },
+              allow_nil: true
+    validates :currency, presence: true
+    validates :kind, presence: true, inclusion: { in: Spree::CommissionRate::KINDS }
+    validate :exactly_one_subject
+
+    #
+    # Scopes
+    #
+    scope :for_line_items, -> { where.not(line_item_id: nil) }
+    scope :for_fulfillments, -> { where.not(fulfillment_id: nil) }
+
+    self.whitelisted_ransackable_attributes = %w[amount tax_amount total currency kind rate]
+    self.whitelisted_ransackable_associations = %w[order seller commission_rate]
+
+    extend Spree::DisplayMoney
+    money_methods :amount, :tax_amount, :total
+
+    # What this row was charged against.
+    #
+    # @return [Spree::LineItem, Spree::Fulfillment, nil]
+    def subject
+      line_item || fulfillment
+    end
+
+    private
+
+    def exactly_one_subject
+      return if [line_item_id, fulfillment_id].compact.one?
+
+      errors.add(:base, :exactly_one_of_line_item_or_fulfillment, message: Spree.t('errors.messages.exactly_one_of_line_item_or_fulfillment'))
+    end
+  end
+end