spree_core 5.6.1 → 6.0.0.beta2

data/app/models/spree/seller_requirement.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+module Spree
+  # One thing a marketplace asks of its sellers before it will let them
+  # trade — accepting the terms, giving a returns address, uploading a
+  # business registration (docs/plans/6.0-seller-onboarding-requirements.md).
+  #
+  # A row is a configured instance of a *kind* (an STI subclass registered in
+  # `Spree.seller_requirements`), so the operator composes the checklist from
+  # the dashboard and only a genuinely new kind of check needs code. Rows are
+  # configuration; what a particular seller has done about one is either
+  # computed from their own data or recorded as a
+  # {Spree::SellerRequirementSubmission}.
+  class SellerRequirement < Spree.base_class
+    include Spree::SingleStoreResource
+    include Spree::HasListPosition
+    include Spree::PreferenceSchema
+    include Spree::Metadata
+
+    has_prefix_id :selreq
+
+    acts_as_list scope: :store
+
+    #
+    # Associations
+    #
+    belongs_to :store, class_name: 'Spree::Store', inverse_of: :seller_requirements
+    has_many :submissions, class_name: 'Spree::SellerRequirementSubmission',
+                           foreign_key: :seller_requirement_id, inverse_of: :requirement, dependent: :destroy
+
+    #
+    # Validations
+    #
+    validates :type, presence: true
+    validate :type_must_be_registered
+    # Most kinds answer one question, so a second row of the same kind would
+    # either repeat it or contradict it. The generic kinds — where the
+    # question is the operator's own words — opt out.
+    validates :type, uniqueness: { scope: [:store_id, *spree_base_uniqueness_scope] },
+                     unless: -> { self.class.allow_multiple? }
+    # A kind that can appear more than once has nothing else to tell the
+    # seller apart by, so its label is the row's own.
+    validates :name, presence: true, if: -> { self.class.allow_multiple? }
+
+    registers_subclasses_via { Spree.seller_requirements }
+
+    #
+    # Scopes
+    #
+    scope :active, -> { where(active: true) }
+    scope :required, -> { where(required: true) }
+
+    # The kinds a marketplace starts with, in the order a seller meets them:
+    # agree to the terms, say who you are, tell us where to invoice and where
+    # returns go, have a way to ship, then list something.
+    #
+    # Only the kinds that ask a question core already knows how to answer.
+    # The generic ones (an attestation, a document, a manual check) are absent
+    # on purpose — they mean nothing until the operator has written what they
+    # are asking for.
+    DEFAULT_KINDS = %w[
+      Spree::SellerRequirements::AcceptTerms
+      Spree::SellerRequirements::CompleteProfile
+      Spree::SellerRequirements::BillingAddress
+      Spree::SellerRequirements::ReturnsAddress
+      Spree::SellerRequirements::DeliveryMethod
+      Spree::SellerRequirements::PackageType
+      Spree::SellerRequirements::MinimumProducts
+    ].freeze
+
+    # Writes the default checklist for a store, skipping kinds it already
+    # has. Idempotent, so a store seeded before a kind existed picks it up on
+    # the next run — but a requirement the operator deleted stays deleted
+    # only until then, which is the same bargain the seeded commission rate
+    # makes.
+    #
+    # @param store [Spree::Store]
+    # @return [Array<Spree::SellerRequirement>] the rows created
+    def self.provision_defaults(store)
+      registered = Spree.seller_requirements.map(&:to_s)
+      # `reorder(nil)`: the association orders by position, and PostgreSQL
+      # refuses SELECT DISTINCT with an ORDER BY on a column it does not select.
+      existing = store.seller_requirements.where(type: DEFAULT_KINDS).reorder(nil).distinct.pluck(:type)
+
+      ((DEFAULT_KINDS & registered) - existing).map do |kind|
+        store.seller_requirements.create!(type: kind)
+      end
+    end
+
+    # @return [String] the localized name of the kind, used by operator pickers
+    def self.human_name
+      Spree.t("seller_requirement_types.#{api_type}.name", default: api_type.titleize)
+    end
+
+    # @return [String] the localized description of the kind
+    def self.human_description
+      Spree.t("seller_requirement_types.#{api_type}.description", default: '')
+    end
+
+    # Whether the operator may configure this kind more than once per store.
+    # True for the kinds whose meaning comes from the operator's own copy.
+    #
+    # @return [Boolean]
+    def self.allow_multiple?
+      false
+    end
+
+    # Whether a seller can record having done this themselves. False for
+    # computed kinds, where a submission would be a second, disagreeing
+    # answer to a question the data already settles.
+    #
+    # @return [Boolean]
+    def self.accepts_submissions?
+      false
+    end
+
+    # Whether a seller's submission waits for someone to confirm it.
+    #
+    # @return [Boolean]
+    def self.reviewed_by_operator?
+      false
+    end
+
+    # Whether a submission has to carry a file to mean anything. Declared by
+    # the kind rather than tested for by class, so a gem shipping its own
+    # document-style kind gets the same enforcement.
+    #
+    # @return [Boolean]
+    def self.requires_file?
+      false
+    end
+
+    # Content types a submission's file may carry. Empty accepts anything.
+    # Declared beside {.requires_file?} so a kind that collects files gets
+    # both halves of the contract rather than only the one it remembered.
+    #
+    # @return [Array<String>]
+    def self.accepted_content_types
+      []
+    end
+
+    delegate :accepted_content_types, to: :class
+
+    # @return [String] what the seller sees; the kind's name unless the
+    #   operator wrote their own
+    def display_name
+      name.presence || self.class.human_name
+    end
+
+    # @return [String, nil]
+    def display_description
+      description.presence || self.class.human_description.presence
+    end
+
+    # Whether this requirement applies to the given seller at all. A kind
+    # narrows itself here — a payout-account kind only applies once the store
+    # has a payout provider — and a requirement that does not apply is absent
+    # from the checklist rather than shown as unmet.
+    #
+    # @param _seller [Spree::Seller]
+    # @return [Boolean]
+    def applicable?(_seller)
+      true
+    end
+
+    # Whether this requirement stands met for the seller.
+    #
+    # A waiver settles it whatever the kind would otherwise say: the operator
+    # is recording that they dealt with this outside the marketplace, and a
+    # kind reading its own data — the terms column, the address — would
+    # never see that. Not overridable for exactly that reason; kinds
+    # override {#met_by_seller?} instead.
+    #
+    # Whether this evaluation may answer from what Spree already knows rather
+    # than asking the outside world. Set by `Spree::Sellers::Requirements` for
+    # a listing, where one network call per row is the difference between a
+    # page that loads and one that does not. A kind that never leaves the
+    # database can ignore it; one that calls a provider should read the value
+    # it last recorded instead.
+    #
+    # False everywhere it matters — the two approval gates and a seller's own
+    # page ask for the current answer.
+    attr_accessor :prefer_cached
+
+    # @param seller [Spree::Seller]
+    # @return [Boolean]
+    def satisfied?(seller)
+      return true if latest_submission(seller)&.waived?
+
+      met_by_seller?(seller)
+    end
+
+    # Whether the seller themselves has met this requirement. Computed kinds
+    # override this to read seller data; the default answers from the latest
+    # submission, which is what the attested and verified kinds need.
+    #
+    # @param seller [Spree::Seller]
+    # @return [Boolean]
+    def met_by_seller?(seller)
+      submission = latest_submission(seller)
+
+      submission.present? && submission.satisfies_requirement?
+    end
+
+    # The seller's standing on this requirement.
+    #
+    # `pending` means someone else has to act — an operator review, a
+    # provider still working through its own checks — which is worth telling
+    # the seller apart from "you have not done this yet".
+    #
+    # @param seller [Spree::Seller]
+    # @return [String] complete | incomplete | pending | rejected
+    def status_for(seller)
+      return Spree::SellerRequirementStatus::COMPLETE if satisfied?(seller)
+
+      case latest_submission(seller)&.status
+      when 'pending' then Spree::SellerRequirementStatus::PENDING
+      when 'rejected' then Spree::SellerRequirementStatus::REJECTED
+      else Spree::SellerRequirementStatus::INCOMPLETE
+      end
+    end
+
+    # Somewhere for the seller to go to get this done — a hosted onboarding
+    # link, for instance. Nil when the seller finishes it inside their own
+    # panel, which is the usual case.
+    #
+    # @param _seller [Spree::Seller]
+    # @return [String, nil]
+    def action_url(_seller)
+      nil
+    end
+
+    # Why this line is not done, when the answer is somewhere the seller
+    # cannot see. Nil for every kind whose own description already says what
+    # is wanted, which is nearly all of them — a requirement asking for an
+    # address explains itself.
+    #
+    # @param _seller [Spree::Seller]
+    # @return [Hash, nil] `{ state:, message: }`
+    def blocker(_seller)
+      nil
+    end
+
+    # The submission that decides this requirement's standing for a seller:
+    # the most recent one. Earlier rows are the audit trail.
+    #
+    # Read through the seller rather than through this requirement: a seller
+    # has a handful of submissions, a requirement has one per seller on the
+    # marketplace, and evaluating a checklist asks about one seller. The
+    # seller's association loads once and every requirement reads from it.
+    #
+    # @param seller [Spree::Seller]
+    # @return [Spree::SellerRequirementSubmission, nil]
+    def latest_submission(seller)
+      return nil if seller.nil?
+
+      seller.requirement_submissions
+            .select { |submission| submission.seller_requirement_id == id }
+            .max_by { |submission| [submission.created_at, submission.id] }
+    end
+
+    private
+
+    def type_must_be_registered
+      return if type.blank?
+      return if Spree.seller_requirements.any? { |kind| kind.to_s == type }
+
+      errors.add(
+        :type, :invalid_seller_requirement, message: Spree.t(:invalid_seller_requirement, scope: [:errors, :messages],
+                                             default: 'is not a registered seller requirement')
+      )
+    end
+  end
+end

data/app/models/spree/seller_requirement_custom_field.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Spree
+  # Joins a requirement to a custom field definition it asks the seller to
+  # fill in. A concrete row rather than a key in preferences: a definition
+  # that is renamed keeps its id, and one that is deleted takes this row with
+  # it — a stored key would survive both and quietly satisfy every seller.
+  class SellerRequirementCustomField < Spree.base_class
+    belongs_to :seller_requirement, class_name: 'Spree::SellerRequirement'
+    belongs_to :custom_field_definition, class_name: 'Spree::CustomFieldDefinition'
+
+    validates :custom_field_definition_id, uniqueness: { scope: :seller_requirement_id }, allow_nil: true
+    validate :definition_must_describe_a_seller
+    validate :definition_must_belong_to_the_same_store
+
+    private
+
+    # A definition for products or orders asks the seller for something they
+    # have no field to answer with, so the requirement could never be met.
+    def definition_must_describe_a_seller
+      return if custom_field_definition.nil?
+      return if custom_field_definition.resource_type == Spree::Seller.to_s
+
+      errors.add(:custom_field_definition, :invalid,
+                 message: Spree.t('seller_requirements.custom_field_not_for_sellers',
+                                  default: 'must be a custom field defined for sellers'))
+    end
+
+    # Both sides are store-owned, so a marketplace can only ask its sellers
+    # for fields it defined itself.
+    def definition_must_belong_to_the_same_store
+      return if custom_field_definition.nil? || seller_requirement.nil?
+      return if custom_field_definition.store_id == seller_requirement.store_id
+
+      errors.add(:custom_field_definition, :must_belong_to_same_store)
+    end
+  end
+end

data/app/models/spree/seller_requirement_status.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Spree
+  # One line of a seller's onboarding checklist: a requirement evaluated
+  # against a seller. A value object — the answer is derived from the
+  # seller's own data and their submissions every time it is asked for, so
+  # there is nothing here worth storing and a stored copy would go stale the
+  # moment a product or an address changed.
+  #
+  # See {Spree::Sellers::Requirements}, which builds these.
+  class SellerRequirementStatus
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+
+    COMPLETE = 'complete'
+    INCOMPLETE = 'incomplete'
+    PENDING = 'pending'
+    REJECTED = 'rejected'
+
+    STATUSES = [COMPLETE, INCOMPLETE, PENDING, REJECTED].freeze
+
+    # The requirement's prefixed id, so a client can act on it.
+    attribute :id, :string
+    # The kind, e.g. 'accept_terms' — what a frontend keys presentation off.
+    attribute :kind, :string
+    attribute :name, :string
+    attribute :description, :string
+    attribute :required, :boolean, default: true
+    attribute :position, :integer
+    attribute :status, :string
+    attribute :action_url, :string
+
+    # Why this line is stuck, when the reason lives somewhere the seller
+    # cannot see — a payout provider still checking their identity, say.
+    #
+    # `state` is one of `action` (they must do something), `pending` (the
+    # provider is looking, and nobody can hurry it) or `rejected`. `message`
+    # is the provider's own sentence when it wrote one: best-effort and
+    # unlocalized, so it is shown as detail beside translated copy rather
+    # than in place of it.
+    #
+    # @return [Hash, nil]
+    attr_accessor :blocker
+
+    # The submission behind the status, when there is one.
+    # @return [Spree::SellerRequirementSubmission, nil]
+    attr_accessor :submission
+
+    # The requirement this was evaluated from.
+    #
+    # Carried so a serializer can ask the kind its own questions — which
+    # custom fields it names, whether it takes a file — without re-fetching a
+    # row the evaluator has already loaded. Not serialized itself: what a
+    # client needs is the answers, not the configuration row.
+    #
+    # @return [Spree::SellerRequirement, nil]
+    attr_accessor :requirement
+
+    # The seller this was evaluated against, so kind-specific readers can ask
+    # about them without the caller passing them a second time.
+    #
+    # @return [Spree::Seller, nil]
+    attr_accessor :seller
+
+    # The custom fields this line asks for, each paired with the seller's
+    # current answer — empty for every kind that asks for none.
+    #
+    # Built here rather than in the serializer because it is the answer to
+    # "what does this requirement want", which is the value object's job; the
+    # serializer only decides how to render it.
+    #
+    # @return [Array<Hash>] `{ definition:, custom_field: }` pairs
+    def custom_fields
+      return @custom_fields if defined?(@custom_fields)
+      return @custom_fields = [] if seller.nil? || !requirement.respond_to?(:custom_field_definitions)
+
+      answered = seller.custom_fields.index_by(&:custom_field_definition_id)
+
+      @custom_fields = requirement.custom_field_definitions.map do |definition|
+        { definition: definition, custom_field: answered[definition.id] }
+      end
+    end
+
+    # The legal document this line asks for, when its kind asks for one —
+    # nil for every other kind.
+    #
+    # Same job as {#custom_fields}: the value object answers "what does this
+    # requirement want", so the seller panel can offer to create that exact
+    # document rather than making the seller retype its name.
+    #
+    # @return [String, nil]
+    def required_policy_name
+      return nil unless requirement.respond_to?(:required_policy_name)
+
+      requirement.required_policy_name.presence
+    end
+
+    # The marketplace terms this line asks the seller to accept, as
+    # sanitized markup. Nil for every other kind, and nil while the
+    # marketplace has not written any.
+    #
+    # @return [String, nil]
+    def terms_html
+      return nil unless requirement.respond_to?(:terms_html)
+
+      requirement.terms_html
+    end
+
+    # The policy the seller actually published against this line, when they
+    # have — nil for every other kind, and nil while the document is still
+    # owed.
+    #
+    # What the operator reads before approving: a line that says "Done"
+    # without showing what was written is not something anyone can approve on.
+    #
+    # @return [Spree::Policy, nil]
+    def published_policy
+      return @published_policy if defined?(@published_policy)
+
+      name = required_policy_name
+      return @published_policy = nil if name.nil? || seller.nil?
+
+      @published_policy = seller.policies.detect do |policy|
+        policy.name.to_s.strip.casecmp?(name) && policy.with_body?
+      end
+    end
+
+    # ActiveModel::Attributes gives readers, not predicates.
+    def required?
+      !!required
+    end
+
+    def complete?
+      status == COMPLETE
+    end
+
+    # Whether this is standing between the seller and approval.
+    #
+    # @return [Boolean]
+    def blocking?
+      required? && !complete?
+    end
+  end
+end

data/app/models/spree/seller_requirement_submission.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Spree
+  # What a seller did about one requirement, and what the operator made of
+  # it (docs/plans/6.0-seller-onboarding-requirements.md).
+  #
+  # Only the requirements a seller attests to, or someone verifies, need a
+  # row: the computed kinds read the seller's own data and would be
+  # contradicted by a stored answer. The latest row for a
+  # (seller, requirement) pair decides the standing; the ones before it are
+  # the record of how the marketplace got there.
+  class SellerRequirementSubmission < Spree.base_class
+    include Spree::HasStatus
+    include Spree::Metadata
+
+    has_prefix_id :selsub
+
+    publishes_lifecycle_events
+
+    # `waived` is the operator excusing one seller from something the store
+    # asks of everyone — a requirement they have already satisfied off the
+    # marketplace, say. It reads as met without pretending the seller did it.
+    has_status :pending, :accepted, :rejected, :waived, default: :pending
+
+    #
+    # Associations
+    #
+    belongs_to :seller, class_name: 'Spree::Seller', inverse_of: :requirement_submissions
+    belongs_to :requirement, class_name: 'Spree::SellerRequirement',
+                             foreign_key: :seller_requirement_id, inverse_of: :submissions
+    belongs_to :submitted_by, class_name: Spree.admin_user_class.to_s, optional: true
+    belongs_to :reviewed_by, class_name: Spree.admin_user_class.to_s, optional: true
+
+    #
+    # Attachments
+    #
+    # Private, and served only through the admin and seller branches: these
+    # are business registrations and identity documents.
+    has_one_attached :file, service: Spree.private_storage_service_name
+
+    #
+    # Validations
+    #
+    validate :requirement_belongs_to_sellers_store
+
+    validates :file,
+              size: { less_than_or_equal_to: ->(_record) { Spree::Config.max_seller_document_upload_size } },
+              if: -> { file.attached? }
+
+    # Sellers are the marketplace's lower-trust writers and an operator opens
+    # these files on their own machine, so the bytes decide what a file is,
+    # not the header the uploader sent: without that check a script named
+    # `certificate.pdf` passes.
+    #
+    # The accepted list comes from the requirement's own kind, the same value
+    # the seller API serializes so the panel's picker can hint it.
+    validates_with Spree::AttachmentContentTypeValidator,
+                   attributes: [:file],
+                   in: ->(record) { record.requirement&.accepted_content_types || [] },
+                   if: -> { file.attached? }
+
+    #
+    # Scopes
+    #
+    scope :for_seller, ->(seller) { where(seller_id: seller.id) }
+
+    self.whitelisted_ransackable_attributes = %w[status created_at reviewed_at]
+    self.whitelisted_ransackable_associations = %w[seller requirement]
+
+    # Whether this row counts as the requirement being met.
+    #
+    # @return [Boolean]
+    def satisfies_requirement?
+      accepted? || waived?
+    end
+
+    private
+
+    # A submission joins a seller to a requirement, and both belong to a
+    # store — so a mismatch means one of the two ids came from somewhere it
+    # should not have. Cheaper to refuse here than to rely on every caller
+    # having scope-fetched both.
+    def requirement_belongs_to_sellers_store
+      return if seller.nil? || requirement.nil?
+      return if seller.store_id == requirement.store_id
+
+      errors.add(:requirement, :seller_requirement_store_mismatch, message: Spree.t('errors.messages.seller_requirement_store_mismatch',
+                                       default: 'must belong to the same store as the seller'))
+    end
+  end
+end

data/app/models/spree/seller_requirements/accept_terms.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Spree
+  module SellerRequirements
+    # The seller has accepted the marketplace's terms.
+    #
+    # `terms_effective_from` is how a marketplace asks again after rewriting
+    # them: everyone who accepted before that date falls back to unmet, and
+    # the seller sees the requirement return to their checklist.
+    class AcceptTerms < Spree::SellerRequirement
+      # What the seller reads in the panel. Optional: a marketplace that
+      # already publishes customer Terms of Service can leave this blank
+      # and the checklist falls back to that policy, so the two cannot
+      # drift. A seller agreement that is not the shopper-facing document
+      # is written here instead.
+      preference :terms_body, :text, default: nil, nullable: true
+      # `:date`, so the dashboard renders a date picker rather than a text box
+      # an operator can type a malformed date into. The value stays a
+      # `yyyy-MM-dd` string on the wire and in storage — see `effective_from`
+      # for why the timezone is applied on read rather than at coercion.
+      preference :terms_effective_from, :date, default: nil
+      # A published copy of the same terms, for a marketplace that also
+      # hosts them on a public page. Optional — the panel renders the
+      # body above; this is the "open the full document" link.
+      preference :terms_url, :string, default: nil
+
+      # A date nobody can parse would otherwise read as "no date at all", and
+      # this requirement would quietly count sellers on years-old terms as
+      # having accepted the current ones. Refused on save so it cannot be
+      # stored, rather than interpreted generously afterwards.
+      validate :terms_effective_from_must_be_a_date
+
+      def met_by_seller?(seller)
+        accepted_at = seller.terms_accepted_at
+        return false if accepted_at.blank?
+        return true if effective_from.blank?
+
+        accepted_at >= effective_from
+      end
+
+      # The terms themselves, so the seller can read what they are accepting.
+      # `action_url` is the checklist's existing "go here" channel for a
+      # published copy; the body is what the panel renders inline.
+      #
+      # @return [String, nil]
+      def action_url(_seller)
+        preferred_terms_url.presence
+      end
+
+      # Sanitized markup the seller reads before accepting. The requirement's
+      # own body wins; otherwise the store's Terms of Service, so a
+      # marketplace that already wrote that policy does not write it twice.
+      #
+      # @return [String, nil]
+      def terms_html
+        source = preferred_terms_body.presence || store_terms_body
+        return if source.blank?
+
+        Spree::RichTextSanitizer.sanitize(source).presence
+      end
+
+      # `iso8601`, not `parse`: parse fills in whatever a value leaves out, so
+      # "09:00" becomes nine o'clock *today* and the threshold would move every
+      # midnight — sellers who met it yesterday would fall out of compliance
+      # overnight. A cut-off has to be a fixed instant.
+      #
+      # Read in the store's timezone, not the server's: a date the operator
+      # types means midnight where they trade, and interpreting "2026-01-01"
+      # in UTC would move the deadline by hours for everyone else.
+      #
+      # @return [ActiveSupport::TimeWithZone, nil]
+      def effective_from
+        return nil if preferred_terms_effective_from.blank?
+
+        # `find_zone` answers nil for a zone it does not know, so a store
+        # carrying a bad value falls back rather than raising here.
+        zone = Time.find_zone(store&.preferred_timezone.to_s) || Time.zone
+
+        zone.iso8601(preferred_terms_effective_from.to_s)
+      rescue ArgumentError, Date::Error
+        nil
+      end
+
+      private
+
+      def terms_effective_from_must_be_a_date
+        return if preferred_terms_effective_from.blank?
+        return if effective_from.present?
+
+        # On the preference rather than :base, so the operator's form marks the
+        # field they got wrong instead of only showing a summary line.
+        errors.add(:preferred_terms_effective_from, :invalid_terms_effective_from,
+                   message: Spree.t('seller_requirements.invalid_terms_effective_from',
+                                    default: 'Terms effective from is not a date'))
+      end
+
+      def store_terms_body
+        return if store.nil?
+
+        store.policies.with_matching_name(Spree.t(:terms_of_service)).detect(&:with_body?)&.body
+      end
+    end
+  end
+end

data/app/models/spree/seller_requirements/attestation.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Spree
+  module SellerRequirements
+    # Something the marketplace asks the seller to confirm in their own
+    # right — that their delivery rates are correct, that they hold the
+    # licence their category needs. The seller ticks it and it is met; the
+    # value is the record that they were asked and answered.
+    #
+    # The question is whatever the operator wrote in the row's name and
+    # description, so a store may configure as many as it likes.
+    class Attestation < Spree::SellerRequirement
+      def self.allow_multiple?
+        true
+      end
+
+      def self.accepts_submissions?
+        true
+      end
+    end
+  end
+end

data/app/models/spree/seller_requirements/billing_address.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Spree
+  module SellerRequirements
+    # Where the seller is invoiced — what a commission invoice is addressed
+    # to, so a marketplace charging commission cannot do without it.
+    class BillingAddress < Spree::SellerRequirement
+      def met_by_seller?(seller)
+        seller.billing_address.present? && seller.billing_address.persisted?
+      end
+    end
+  end
+end