spree_core 5.6.0 → 6.0.0.beta1

data/app/models/spree/search_provider/database.rb

@@ -10,6 +10,11 @@ module Spree
       def search_and_filter(scope:, query: nil, filters: {}, sort: nil, page: 1, limit: 25)
         filters = filters.is_a?(Hash) ? filters.dup : {}
         option_value_ids = filters.delete('with_option_value_ids') || filters.delete(:with_option_value_ids)
+        # Which grouping a 'manual' (position) sort orders within. The in_category /
+        # in_collection filter (applied just below) already JOINs and scopes that
+        # grouping's position table, so we only need to know *which* grouping is
+        # active
+        grouping = manual_sort_grouping(filters)
 
         scope = apply_search_and_filters(scope, query: query, filters: filters)
         scope = scope.with_option_value_ids(Array(option_value_ids)) if option_value_ids.present?
@@ -18,7 +23,7 @@ module Spree
         total = scope.distinct.count
 
         # Sorting + pagination
-        scope = apply_sort(scope, sort)
+        scope = apply_sort(scope, sort, grouping: grouping)
         page = [page.to_i, 1].max
         limit = limit.to_i.clamp(1, 100)
         products = scope.offset((page - 1) * limit).limit(limit)
@@ -33,6 +38,7 @@ module Spree
       def filters(scope:, query: nil, filters: {})
         filters = filters.is_a?(Hash) ? filters.dup : {}
         category = filters.delete('_category') || filters.delete(:_category)
+        collection = filters.delete('_collection') || filters.delete(:_collection)
         option_value_ids = Array(filters.delete('with_option_value_ids') || filters.delete(:with_option_value_ids))
 
         # Apply text search + ransack filters (without option values)
@@ -45,7 +51,8 @@ module Spree
                                scope_before_options
                              end
 
-        filter_facets = build_facets(scope_with_options, category: category, option_value_ids: option_value_ids, scope_before_options: scope_before_options)
+        filter_facets = build_facets(scope_with_options, category: category, sort_order: collection&.sort_order, option_value_ids: option_value_ids, scope_before_options: scope_before_options)
+        filter_facets[:sort_options] = filter_facets[:sort_options] + custom_field_sort_options
 
         FiltersResult.new(
           filters: filter_facets[:filters],
@@ -58,7 +65,10 @@ module Spree
       private
 
       def apply_search_and_filters(scope, query: nil, filters: {})
-        scope = scope.search(query) if query.present?
+        scope = scope.search(query, store) if query.present?
+
+        filters = filters.to_unsafe_h if filters.respond_to?(:to_unsafe_h)
+        scope, filters = scope.with_custom_field_filters(filters, schema: custom_field_schema)
 
         ransack_filters = sanitize_filters(filters)
         if ransack_filters.present?
@@ -73,13 +83,14 @@ module Spree
         Pagy::Offset.new(count: count, page: page, limit: limit)
       end
 
-      def build_facets(scope, category: nil, option_value_ids: [], scope_before_options: nil)
-        return { filters: [], sort_options: available_sort_options, default_sort: 'manual', total_count: scope.distinct.count } unless defined?(Spree::Api::V3::FiltersAggregator)
+      def build_facets(scope, category: nil, sort_order: nil, option_value_ids: [], scope_before_options: nil)
+        return { filters: [], sort_options: built_in_sort_options, default_sort: 'manual', total_count: scope.distinct.count } unless defined?(Spree::Api::V3::FiltersAggregator)
 
         Spree::Api::V3::FiltersAggregator.new(
           scope: scope,
           currency: currency,
           category: category,
+          sort_order: sort_order,
           option_value_ids: option_value_ids,
           scope_before_options: scope_before_options || scope
         ).call
@@ -89,15 +100,23 @@ module Spree
         return {} if filters.blank?
 
         filters = filters.to_unsafe_h if filters.respond_to?(:to_unsafe_h)
-        filters.except('search', :search, '_category', :_category, 'with_option_value_ids', :with_option_value_ids)
+        filters.except('search', :search, '_category', :_category, '_collection', :_collection, 'with_option_value_ids', :with_option_value_ids)
       end
 
-      def apply_sort(scope, sort)
+      def apply_sort(scope, sort, grouping: nil)
+        # A category/collection page defaults to the merchant's manual (position)
+        # order when `sort` is omitted — matching the `default_sort: 'manual'` the
+        # filters endpoint advertises.
+        sort = 'manual' if sort.blank? && grouping.present?
         return scope if sort.blank?
 
+        return manual_sort(scope, grouping) if sort == 'manual'
+
         scope_method = CUSTOM_SORT_SCOPES[sort]
         if scope_method
           scope.reorder(nil).send(scope_method)
+        elsif (parsed = custom_field_schema.parse_sort(sort))
+          apply_custom_field_sort(scope, parsed)
         else
           # Standard Ransack sort: 'name' → 'name asc', '-name' → 'name desc'
           ransack_sort = sort.split(',').map { |field|
@@ -112,8 +131,86 @@ module Spree
         end
       end
 
-      def available_sort_options
-        %w[price -price best_selling name -name -available_on available_on].map { |id| { id: id } }
+      # Which grouping a 'manual' sort orders within, inferred from the filter that
+      # was applied (and therefore joined its position table). Only single-grouping
+      # PLPs sort manually — in_categories (plural) has no single position axis.
+      def manual_sort_grouping(filters)
+        return :collection if filters.key?('in_collection') || filters.key?(:in_collection)
+        return :category if filters.key?('in_category') || filters.key?(:in_category)
+
+        nil
+      end
+
+      # 'manual' sort = the merchant's hand-set position within the grouping. The
+      # in_category / in_collection filter already joined and scoped the position
+      # table, so we just order by it — no re-resolution, no extra query. With no
+      # grouping, 'manual' falls back to the unsorted scope (nothing to order by).
+      def manual_sort(scope, grouping)
+        case grouping
+        when :collection
+          # Flat: one product_collections row per product, so order by its position.
+          # The filtered scope is DISTINCT and PostgreSQL requires ORDER BY columns
+          # in the SELECT list, so select the position too.
+          position = "#{Spree::ProductCollection.table_name}.position"
+          scope.reorder(nil).
+            select("#{Spree::Product.table_name}.*", position).
+            order(Arel.sql("#{position} ASC"))
+        when :category
+          # Hierarchical: a product under a category AND its descendants has several
+          # product_categories rows (in_category joins the whole subtree), so collapse
+          # to MIN(position) grouped by product.
+          position = "MIN(#{Spree::ProductCategory.table_name}.position)"
+          scope.reorder(nil).
+            select("#{Spree::Product.table_name}.*", "#{position} AS manual_position").
+            group("#{Spree::Product.table_name}.id").
+            order(Arel.sql("#{position} ASC"))
+        else
+          scope
+        end
+      end
+
+      # Project the ORDER BY expression into the SELECT list so PostgreSQL
+      # accepts it when DISTINCT is applied. Null-rank keeps products without
+      # the custom_field last for both ASC and DESC.
+      def apply_custom_field_sort(scope, parsed)
+        definition = custom_field_schema.entry_for(parsed[:attribute])
+        return scope unless definition
+
+        products = Spree::Product.arel_table
+        # Aliased so this join can't collide with the `filter_cf` correlated
+        # subquery when a cf_* filter and a cf_* sort are combined.
+        custom_fields = Spree::CustomField.arel_table.alias('sort_cf')
+
+        sort_expr = Spree::Product.custom_field_value_expression(custom_fields[:value], definition.field_type)
+        # NULL-rank so products missing the custom_field sort last (Meilisearch parity).
+        # Projected as cf_sort_missing because PostgreSQL rejects (alias IS NULL) in ORDER BY.
+        null_rank = sort_expr.eq(nil)
+
+        direction = parsed[:direction] == 'desc' ? :desc : :asc
+
+        join = products.
+               outer_join(custom_fields).
+               on(
+                 custom_fields[:resource_type].eq('Spree::Product').
+                 and(custom_fields[:resource_id].eq(products[:id])).
+                 and(custom_fields[:custom_field_definition_id].eq(definition.id))
+               ).
+               join_sources
+
+        scope.
+          joins(join).
+          select(products[Arel.star]).
+          select(Arel::Nodes::As.new(sort_expr, Arel.sql('cf_sort_value'))).
+          select(Arel::Nodes::As.new(null_rank, Arel.sql('cf_sort_missing'))).
+          reorder(Arel.sql('cf_sort_missing').asc, sort_expr.public_send(direction))
+      end
+
+      def built_in_sort_options
+        %w[price -price best_selling name -name -available_on available_on].map { |id| { id: id, label: nil } }
+      end
+
+      def custom_field_sort_options
+        custom_field_schema.sort_options
       end
     end
   end

data/app/models/spree/search_provider.rb

@@ -0,0 +1,29 @@
+module Spree
+  module SearchProvider
+    # Meilisearch moved out of core into the spree_meilisearch gem at 6.0, taking
+    # the document presenter with it. Applications configure the provider by
+    # class name, so resolve the old constants to the new ones for one release
+    # rather than failing at boot with a bare NameError.
+    MOVED_TO_SPREE_MEILISEARCH = {
+      Meilisearch: 'SpreeMeilisearch::SearchProvider',
+      ProductPresenter: 'SpreeMeilisearch::ProductPresenter'
+    }.freeze
+
+    def self.const_missing(name)
+      replacement = MOVED_TO_SPREE_MEILISEARCH[name]
+      return super if replacement.nil?
+
+      unless Object.const_defined?(replacement)
+        raise NameError, "Spree::SearchProvider::#{name} moved to #{replacement} in Spree 6.0. " \
+                         "Add `gem 'spree_meilisearch'` to your Gemfile."
+      end
+
+      Spree::Deprecation.warn(
+        "Spree::SearchProvider::#{name} is deprecated and will be removed in Spree 6.1. " \
+        "Use #{replacement} instead."
+      ) if defined?(Spree::Deprecation)
+
+      replacement.constantize
+    end
+  end
+end

data/app/models/spree/seller.rb

@@ -0,0 +1,475 @@
+# frozen_string_literal: true
+
+module Spree
+  # A selling party on a marketplace: the store is the tenant, the seller is a
+  # seller within it (docs/plans/6.0-multi-vendor-marketplace.md).
+  #
+  # A seller owns roles, so its team is the people holding them — the same
+  # machinery the store's own back office uses, pointed at the seller.
+  class Seller < Spree.base_class
+    has_prefix_id :sel
+
+    acts_as_paranoid
+
+    include Spree::SingleStoreResource
+    include Spree::UserManagement
+    include Spree::TranslatableResource
+    include Spree::HasCustomFields
+    include Spree::Metadata
+    include Spree::MemoizedData
+    include Spree::SanitizableRichText
+    # The seller's account with whichever provider pays them — see
+    # #payout_account_reference.
+    include Spree::HasExternalReferences
+
+    MEMOIZED_METHODS = %w[onboarding_requirements onboarding_progress products_count returns_location].freeze
+
+    publishes_lifecycle_events
+
+    # Where a seller is in its life on the marketplace. Transitions belong to
+    # workflows (Spree::Sellers::Approve and friends) rather than a state
+    # machine: approving sends mail and provisions payouts, which is exactly
+    # the work that must not run inside a save callback.
+    #
+    #   pending → invited → onboarding → ready_for_review → approved
+    #
+    # `approve` also lifts a suspension, and a rejected seller can be revived,
+    # so the reachable set is deliberately wider than that line suggests.
+    include Spree::HasStatus
+    has_status :pending, :invited, :canceled, :onboarding, :ready_for_review,
+               :approved, :rejected, :suspended, default: :pending
+
+    # Who remits consumer tax on this seller's sales. `seller` means they are
+    # merchant of record; `platform` is the marketplace-facilitator case, and
+    # only Enterprise decides a seller belongs there — core just reads it.
+    TAX_REMITTANCES = %w[seller platform].freeze
+    PAYOUT_INTERVALS = %w[daily weekly biweekly monthly manual].freeze
+
+    TRANSLATABLE_FIELDS = %i[name about].freeze
+    RICH_TEXT_TRANSLATABLE_FIELDS = %i[about].freeze
+    translates(*TRANSLATABLE_FIELDS, column_fallback: Spree.mobility_column_fallback)
+
+    self::Translation.class_eval do
+      include Spree::SanitizableRichText
+      sanitizes_rich_text :about
+
+      acts_as_paranoid
+      # A deleted seller's translations still have to render — its storefront
+      # profile outlives the row for as long as anything links to it.
+      default_scope { unscope(where: :deleted_at) }
+    end
+
+    #
+    # Associations
+    #
+    belongs_to :store, class_name: 'Spree::Store'
+    # The address knows it is a seller's from its owner, so it is read back
+    # with the business rules — no personal name insisted on, the company line
+    # required. Not `dependent: :destroy`: a seller is paranoid, so destroy is
+    # a soft delete, and taking the address with it would hard-delete a row
+    # historical commission invoices still point at.
+    belongs_to :billing_address, class_name: 'Spree::Address', optional: true
+
+    # `update_only` edits the existing row rather than building a replacement
+    # and orphaning it; the association carries the saving and validation that
+    # go with it.
+    accepts_nested_attributes_for :billing_address, update_only: true
+
+    # The API reads and writes this under one name, so the writer takes the
+    # attributes a client sends as well as a record. Never an id: an address
+    # carries no store of its own, so binding one by id would reach another
+    # store's rows.
+    def billing_address=(value)
+      case value
+      when Hash, ActionController::Parameters
+        self.billing_address_attributes = value
+      when Spree::Address
+        super(value.tap { |address| address.owner = self })
+      else
+        super
+      end
+    end
+
+    # The seller holds the foreign key, so nothing on the address side says
+    # whose it is — an association cannot declare that for us. This is the one
+    # path Rails builds the row on, so it is where the row is told, and what
+    # it asks for follows: no personal name, the company line required.
+    def billing_address_attributes=(attributes)
+      super
+      billing_address&.owner = self
+    end
+
+    # Where this seller keeps stock, and so where their returns land. Released
+    # rather than destroyed for the same reason products are: the operator
+    # decides what becomes of a departed seller's inventory.
+    has_many :stock_locations, class_name: 'Spree::StockLocation', dependent: :nullify,
+                               inverse_of: :seller
+
+    # How this seller ships: their own methods, priced and retired by them,
+    # against the marketplace's profiles and zones
+    # (docs/plans/6.0-multi-vendor-marketplace.md, Decision 13).
+    #
+    # Deliberately NOT `dependent: :nullify`, unlike stock locations: a nil
+    # `seller_id` IS the marketplace's own method, so releasing a departed
+    # seller's rows would hand the operator their pricing and start quoting it
+    # on first-party packages. The seller is paranoid, so the rows keep
+    # pointing at a record that still resolves; retiring them is the
+    # operator's call.
+    has_many :delivery_methods, class_name: 'Spree::DeliveryMethod', dependent: nil,
+                                inverse_of: :seller
+
+    # What this seller packs their goods into: their own boxes, cartons and
+    # pallets, beside the marketplace's shared vocabulary they may also use
+    # (docs/plans/6.0-seller-package-types.md).
+    #
+    # `dependent: nil` for the same reason as delivery methods above: a nil
+    # `seller_id` IS the marketplace's row, so nullifying a departed seller's
+    # rows would give the operator a second default box and start quoting this
+    # seller's tare on first-party parcels.
+    has_many :package_types, class_name: 'Spree::PackageType', dependent: nil,
+                             inverse_of: :seller
+
+    # The box this seller's parcels are quoted with. Nil until they record
+    # one, and `Stock::Package` then falls back to the marketplace's.
+    has_one :default_package_type, -> { where(default: true) }, class_name: 'Spree::PackageType',
+            dependent: nil, inverse_of: :seller
+
+    # The seller's tax registrations — the VAT number the commission invoice
+    # needs, with the validation verdict and evidence the model carries.
+    #
+    # Deliberately not `dependent: :destroy`, for the same reason as the
+    # billing address above: a seller is paranoid, so destroy is a soft
+    # delete, while a TaxIdentifier is not — cascading would permanently
+    # erase the evidence behind commission invoices already issued, which is
+    # exactly what it exists to preserve.
+    has_many :tax_identifiers, class_name: 'Spree::TaxIdentifier', as: :owner,
+                               dependent: nil, inverse_of: :owner
+
+    # Products and stock survive the seller leaving: the operator decides what
+    # happens to a departed seller's catalog, so it is never cascade-deleted.
+    # Both levels are released — a variant can carry the seller on its own
+    # (the shared catalog), and one left pointing at a departed seller would
+    # read as first-party to the buy box while its id still said otherwise.
+    has_many :products, class_name: 'Spree::Product', dependent: :nullify
+    has_many :variants, class_name: 'Spree::Variant', dependent: :nullify
+
+    # What this seller has been charged. Deliberately neither destroyed nor
+    # nullified when the seller goes: a seller is paranoid, so it is still
+    # there to be read, and a settlement record that forgot who owed it would
+    # be worse than no record at all.
+    has_many :commission_lines, class_name: 'Spree::CommissionLine', dependent: nil
+
+    # This seller's own orders — the child orders a split checkout produced,
+    # and whole orders on a single-seller checkout. Left alone when the seller
+    # goes, for the same reason as commission lines: a completed sale outlives
+    # the party that made it.
+    has_many :orders, class_name: 'Spree::Order', dependent: nil
+    has_many :payment_splits, through: :orders, class_name: 'Spree::PaymentSplit', source: :payment_splits
+
+    # The two levels of the fund ledger: what this seller has earned, and what
+    # has been settled to them. Left alone when the seller goes, for the same
+    # reason as their orders and commission — money that moved is a fact about
+    # the past.
+    has_many :seller_transfers, class_name: 'Spree::SellerTransfer', dependent: nil
+    has_many :seller_payouts, class_name: 'Spree::SellerPayout', dependent: nil
+    # CSV files this seller asked for. Destroyed with the seller: an export is
+    # a copy of records held elsewhere, so nothing is lost by dropping it, and
+    # a file of one seller's orders should not outlive them.
+    has_many :exports, class_name: 'Spree::Export', dependent: :destroy_async, inverse_of: :seller
+
+    # What this seller has done about the marketplace's requirements — their
+    # attestations, the documents they uploaded, what the operator made of
+    # them. Goes with the seller, since it means nothing without them.
+    has_many :requirement_submissions, class_name: 'Spree::SellerRequirementSubmission',
+                                       dependent: :destroy, inverse_of: :seller
+
+    # This seller's own legal documents — shipping, returns, whatever the
+    # marketplace asks of them. Unlike a store, a seller is born with none:
+    # what they must publish is a `SellerRequirements::Policy` decision, not
+    # a set of empty rows every seller carries whether or not it applies.
+    has_many :policies, class_name: 'Spree::Policy', dependent: :destroy, as: :owner
+
+    #
+    # Attachments
+    #
+    has_one_attached :logo, service: Spree.public_storage_service_name
+    has_one_attached :square_logo, service: Spree.public_storage_service_name
+    has_one_attached :cover_photo, service: Spree.public_storage_service_name
+
+    #
+    # Validations
+    #
+    validates :name, presence: true
+    # Scoped to the store, not global: two marketplaces on one installation
+    # may each have a "sparks". Backed by the unique index on the pair.
+    validates :slug, presence: true,
+                     uniqueness: { scope: [*spree_base_uniqueness_scope, :store_id], case_sensitive: false }
+    validates :tax_remittance, inclusion: { in: TAX_REMITTANCES }
+    validates :payouts_schedule_interval, inclusion: { in: PAYOUT_INTERVALS }, allow_nil: true
+    validates :minimum_payout_amount, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true
+
+    has_spree_rich_text :about
+
+    #
+    # Scopes
+    #
+    scope :sellable, -> { approved.where(holiday_mode_until: [nil, ..Time.current]) }
+
+    #
+    # Callbacks
+    #
+    before_validation :normalize_slug
+    # Roles refuse to be destroyed while anyone still holds them, which is
+    # right when a role is deleted on its own and wrong when the whole seller
+    # goes: its roles govern nothing else. Dissolving the team first lets the
+    # cascade through, so an invited seller stays deletable.
+    before_destroy :dissolve_team, prepend: true
+
+    # Which audience of the permission catalog this seller's own super-role is
+    # born holding. A seller's role cannot take the store super-role's
+    # short-circuit (`Role#admin?` requires `staff?`), so without these keys
+    # whoever runs the seller would hold nothing and every endpoint on their
+    # own panel would refuse them.
+    #
+    # @return [Symbol]
+    def role_audience
+      :seller
+    end
+
+    # Whether the seller is currently away. The catalog stays visible; what
+    # stops is selling.
+    #
+    # @return [Boolean]
+    def on_holiday?
+      holiday_mode_until.present? && holiday_mode_until > Time.current
+    end
+
+    # Whether customers may buy from this seller right now.
+    #
+    # @return [Boolean]
+    def sellable?
+      approved? && !on_holiday?
+    end
+
+    # @return [Boolean]
+    def terms_accepted?
+      terms_accepted_at.present?
+    end
+
+    # What the marketplace still owes this seller in one currency.
+    #
+    # Derived rather than stored: it is the whole point of keeping both ledger
+    # levels, and a column would be a second answer that could disagree with
+    # the rows. Per currency because nothing is ever converted — a seller
+    # trading in two currencies accrues two balances and is paid twice.
+    #
+    # Only settlements known to have completed count against it, so one whose
+    # outcome was never established still reads as owed. That is the honest
+    # answer while nobody knows, and it cannot be paid twice by mistake: those
+    # earnings stay claimed by the settlement holding them until it resolves.
+    #
+    # Answered in the currency the money can actually be sent in: a seller whose
+    # account settles in another currency is owed what their account holds, not
+    # what the sale was priced in.
+    #
+    # @param currency [String] a settlement currency
+    # @return [BigDecimal]
+    def balance(currency)
+      earnings = seller_transfers.completed.settling_in(currency)
+
+      earnings.settlement_total -
+        earnings.joins(:payout).merge(Spree::SellerPayout.completed).settlement_total
+    end
+
+    # The currencies this seller can actually be paid in — the ones their
+    # account settles in, which is not the same as the ones they sold in.
+    #
+    # @return [Array<String>]
+    def payable_currencies
+      seller_transfers.unsettled.settlement_currencies
+    end
+
+    # The seller's position in every currency they have earned or been paid
+    # in, for the ledger screens. Empty before their first fulfilled sale.
+    #
+    # Only rows that contribute a figure decide the list: a currency whose
+    # every transfer failed would otherwise show a row of zeros on a money
+    # screen, which reads as a balance rather than as nothing having happened.
+    #
+    # One position per (sale currency, settlement currency) pair, so a seller
+    # who sells in dollars and banks in pounds sees both sides of the one
+    # relationship rather than two unrelated ledgers.
+    #
+    # @return [Array<Spree::SellerBalance>]
+    def balances
+      pairs = seller_transfers.where.not(status: 'failed').
+              distinct.pluck(:currency, :settled_currency)
+
+      pairs.sort.map { |currency, settlement| Spree::SellerBalance.for(self, currency, settlement) }
+    end
+
+    # The seller's account with whichever provider pays them — a Stripe Connect
+    # `acct_…`, or whatever a SEPA or PayPal provider issues.
+    #
+    # Kept as an external reference rather than a column because that is
+    # exactly what it is: this seller's identity in somebody else's system.
+    # Keying it by the provider means a marketplace that migrates keeps the old
+    # account on the record instead of overwriting it, and the reverse lookup a
+    # webhook needs — "which seller is acct_123?" — is a uniquely indexed read
+    # rather than a scan.
+    #
+    # @param provider [Class] the payout provider whose account is wanted;
+    #   defaults to the one the store is configured to pay through
+    # @return [String, nil]
+    def payout_account_reference(provider = store.payout_provider_class)
+      external_id_for(provider.reference_system)
+    end
+
+    # Records the account a provider issued this seller.
+    #
+    # @param provider [Class] the provider that issued it — stated by the
+    #   caller rather than read from the store, since a gem writes the account
+    #   it minted whatever the store is currently configured to pay through
+    # @param account_reference [String, nil] blank forgets the account
+    # @return [void]
+    def set_payout_account_reference(provider, account_reference)
+      set_external_id(provider.reference_system, account_reference)
+    end
+
+    # A seller keeps no clock of their own: a date means whatever the
+    # marketplace says it means, so their panel reads timestamps in the
+    # store's zone rather than in whichever one their browser sits in.
+    delegate :preferred_timezone, to: :store, allow_nil: true
+
+    # Sellers holding an account with one provider, for the reverse lookup a
+    # provider webhook does — it knows the account, not the seller.
+    #
+    # @param store [Spree::Store]
+    # @param provider [Class]
+    # @param account_reference [String]
+    # @return [ActiveRecord::Relation]
+    def self.with_payout_account(store, provider, account_reference)
+      store.sellers.with_external_id(provider.reference_system, account_reference)
+    end
+
+    # Whether a provider says this seller may be sent money yet.
+    #
+    # A marketplace settling offline never asks, so a seller with no account
+    # reference is payable by definition — it is only a provider that executes
+    # transfers which can refuse one.
+    #
+    # @return [Boolean]
+    def payouts_enabled?
+      return true unless store.payout_provider_class.requires_payout_account?
+
+      payouts_enabled_at.present?
+    end
+
+    # What this seller's settlement schedule is, falling back to the store's.
+    #
+    # @return [String]
+    def resolved_payouts_schedule_interval
+      payouts_schedule_interval.presence || store.preferred_default_payouts_schedule_interval
+    end
+
+    # The balance a settlement must reach before it is worth sending, falling
+    # back to the store's. Below it, the balance simply carries to next time.
+    #
+    # @return [BigDecimal]
+    def resolved_minimum_payout_amount
+      (minimum_payout_amount || store.preferred_default_minimum_payout_amount).to_d
+    end
+
+    # Where customers send returns — this seller's default stock location.
+    #
+    # A location rather than a loose address because a received return has to
+    # restock somewhere the catalog believes in: stock movements anchor to a
+    # location, so an address alone would leave the goods arriving nowhere.
+    #
+    # @return [Spree::StockLocation, nil]
+    # Where this seller's goods come back to. Prefers a location that accepts
+    # returns; falls back to any active one, since a seller with none marked
+    # still has to receive what customers send back.
+    def returns_location
+      @returns_location ||= stock_locations.active.returns_enabled.order_default.first ||
+                            stock_locations.active.order_default.first
+    end
+
+    # The postal address a shopper is given for returns.
+    #
+    # Nil until the location is postable: it builds an address from its own
+    # columns on demand, so an incomplete one would otherwise answer with a
+    # blank address that reads as configured.
+    #
+    # @return [Spree::Address, nil]
+    def returns_address
+      location = returns_location
+      return unless location&.postable?
+
+      location.address
+    end
+
+    # @return [Integer] how many products this seller lists
+    def products_count
+      @products_count ||= products.count
+    end
+
+    # Where this seller stands against the marketplace's checklist
+    # (docs/plans/6.0-seller-onboarding-requirements.md), for the operator's
+    # views of them. Computed on read, never stored: a column would be wrong
+    # the moment a product was deleted or a document sent back.
+    #
+    # Reads the store's checklist off its loaded association when the store
+    # was eager-loaded with it (the admin list and profile do), so a page of
+    # sellers loads the rows once; a seller reached any other way queries.
+    #
+    # @return [Array<Spree::SellerRequirementStatus>]
+    def onboarding_requirements
+      @onboarding_requirements ||= Spree::Sellers::Requirements.new(
+        self,
+        preloaded: store&.association(:seller_requirements)&.loaded? || false,
+        cached: onboarding_requirements_cached
+      ).statuses
+    end
+
+    # Whether this seller's checklist may answer from what Spree already knows
+    # rather than asking a payment provider. Set by a caller rendering many
+    # sellers at once, where one network call per row is the difference
+    # between a list that loads and one that does not.
+    #
+    # Deliberately not inferred from the checklist being eager-loaded: a
+    # single-seller read shares that preload, and there the operator is
+    # looking at exactly this seller and wants the current answer.
+    attr_writer :onboarding_requirements_cached
+
+    def onboarding_requirements_cached
+      @onboarding_requirements_cached || false
+    end
+
+    # @return [Hash{Symbol => Integer}] done and total over the whole
+    #   checklist, optional requirements included
+    def onboarding_progress
+      @onboarding_progress ||= Spree::Sellers::Requirements.progress_of(onboarding_requirements)
+    end
+
+    # @return [Boolean] whether nothing required is outstanding
+    def onboarding_complete?
+      onboarding_requirements.none?(&:blocking?)
+    end
+
+    private
+
+
+    def normalize_slug
+      self.slug = (slug.presence || name).to_s.parameterize.presence
+    end
+
+    # Memberships and outstanding invitations are what make a role undeletable.
+    # They mean nothing once the seller is gone, so they go first.
+    def dissolve_team
+      Spree::RoleUser.where(role_id: roles.ids).delete_all
+      invitations.destroy_all
+      roles.each { |role| role.update_columns(mutable: true) unless role.mutable? }
+    end
+  end
+end