spree_cm_commissioner 2.15.0 → 2.15.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b32073d2114c66c1a2f712bbcfb05712cb153b8a651c2c33800665b0422d2541
-  data.tar.gz: 790420e894c681441fba0109c0aafc51bbcbd19a3c076743404db71dd0c6ce7b
+  metadata.gz: a5538af5130244a626ceca3f818410469c93ea7975f5cbc51b212b7536361b8e
+  data.tar.gz: 4e272e66836c76b1296aad6a65488cd17e3ef9517a4a8112594047875de4a185
 SHA512:
-  metadata.gz: 79d3b977f4d3d63523ff5920cc17c7598eb320ed3b6e3dae89bff7d3ee3a0d3f40744a2788e033910da0fa61fcddeaff589414d2b6d9373c52b9f444fe44ff2a
-  data.tar.gz: ca37c84b2064fe10e2187b9610385c6db5ab1016aa64df2f8e34b520fd65f37c59566f1d879aedb822fa43467f43da8f2acda7609ae9aba56ea67d40dc807e72
+  metadata.gz: 80bc600859e7bdf199590d0a5e7982b9b03bbef4ddc9b19e03fbbbe6be76ceca11817687b1d358db20be3b9b7665154d9a05db59412e690448982cf70f543e4d
+  data.tar.gz: 646dea4a475811f6452137087b603d3bb36b6832bd6550339713b84a82f7ee0c71054b81632aebd4ddd041eef14ceca479402e679b0ab49fbf40d87f0e69ec15

data/Gemfile.lock

@@ -34,7 +34,7 @@ GIT
 PATH
   remote: .
   specs:
-    spree_cm_commissioner (2.15.0)
+    spree_cm_commissioner (2.15.2)
       activerecord-multi-tenant
       activerecord_json_validator (~> 2.1, >= 2.1.3)
       aws-sdk-cloudfront

data/app/controllers/spree/api/v2/storefront/transit/draft_orders_controller.rb

@@ -25,7 +25,8 @@ module Spree
                 outbound_legs: @outbound_legs,
                 inbound_legs: @inbound_legs,
                 user: spree_current_user,
-                include_return: ActiveModel::Type::Boolean.new.cast(params[:include_return])
+                include_return: ActiveModel::Type::Boolean.new.cast(params[:include_return]),
+                oauth_application_id: doorkeeper_token&.application_id
               )
 
               if result.success?

data/app/controllers/spree/api/v2/tenant/transit/draft_orders_controller.rb

@@ -25,7 +25,8 @@ module Spree
                 outbound_legs: @outbound_legs,
                 inbound_legs: @inbound_legs,
                 user: spree_current_user,
-                include_return: ActiveModel::Type::Boolean.new.cast(params[:include_return])
+                include_return: ActiveModel::Type::Boolean.new.cast(params[:include_return]),
+                oauth_application_id: doorkeeper_token&.application_id
               )
 
               if result.success?

data/app/jobs/spree_cm_commissioner/seats/auto_assign_job.rb

@@ -0,0 +1,16 @@
+module SpreeCmCommissioner
+  module Seats
+    class AutoAssignJob < ApplicationJob
+      def perform(options = {})
+        order = Spree::Order.find(options[:order_id])
+        SpreeCmCommissioner::Seats::AutoAssign.call(order: order)
+
+        # Lets the vpago processing page move past "assigning your seats" (Order#pending_completion_steps),
+        # once the assignment has committed. Every outcome counts as done: the party's tickets are valid
+        # either way, and a split or unseated party shows on the line item. A failed write raises, so the
+        # retry re-sends it; re-seating is a no-op.
+        order.user_informer.notify_step(:seats_assigning, status: :done)
+      end
+    end
+  end
+end

data/app/models/concerns/spree_cm_commissioner/line_item_seat_selection.rb

@@ -4,6 +4,15 @@ module SpreeCmCommissioner
 
     included do
       before_create :set_required_seat_selection_flag
+
+      # Where an auto-assign party is in seat assignment; nil for every other line item.
+      #
+      #   pending  — paid, waiting for Seats::AutoAssignJob (set by OrderSeatAutoAssignable)
+      #   together / split / unseated — the job's outcome (Seats::AutoAssign)
+      #
+      # A column so parties can be queried by it (e.g. split ones for the organizer). The app reads it
+      # only for a guest without a seat_number yet: after a resume, one party can hold both.
+      enum seat_assignment_status: { pending: 0, together: 1, split: 2, unseated: 3 }, _prefix: :seat_assignment
     end
 
     # Caches the required_seat_selection flag from the trip in private_metadata.
@@ -24,16 +33,29 @@ module SpreeCmCommissioner
       ActiveModel::Type::Boolean.new.cast(private_metadata['required_seat_selection'])
     end
 
+    # Cached at creation alongside required_seat_selection, and mutually exclusive with it: the
+    # customer either picks seats or Seats::AutoAssignJob assigns them once the order completes.
+    # Flipping the product flag mid-sale therefore never changes how an existing order completes.
+    def auto_assign_seats?
+      ActiveModel::Type::Boolean.new.cast(private_metadata['auto_assign_seats']) == true
+    end
+
     private
 
     def set_required_seat_selection_flag
       return if private_metadata.key?('required_seat_selection')
       return if product.nil?
 
-      private_metadata['required_seat_selection'] = if product.trip.present?
-                                                      product.trip.allow_seat_selection && variant.blocks.any?
+      has_blocks = variant.blocks.any?
+      auto_assign = product.auto_assign_seats? && has_blocks
+
+      private_metadata['auto_assign_seats'] = auto_assign
+      private_metadata['required_seat_selection'] = if auto_assign
+                                                      false
+                                                    elsif product.trip.present?
+                                                      product.trip.allow_seat_selection && has_blocks
                                                     else
-                                                      variant.blocks.any?
+                                                      has_blocks
                                                     end
     end
   end

data/app/models/concerns/spree_cm_commissioner/order_seat_auto_assignable.rb

@@ -0,0 +1,73 @@
+module SpreeCmCommissioner
+  # Order side of seat auto-assign: hands paid orders to Seats::AutoAssignJob and, on resume, sends
+  # guests whose seat was resold meanwhile back to it.
+  #
+  # Include before OrderStateMachine: its before_transition to :resumed must run ahead of that
+  # concern's around_transition unstock_inventory!, whose reserve_order_holds! re-reserves the seats
+  # kept here (state_machines runs before and around callbacks in definition order).
+  module OrderSeatAutoAssignable
+    extend ActiveSupport::Concern
+
+    included do
+      state_machine.before_transition to: :resumed, do: :unseat_guests_with_resold_seats!, if: :auto_assign_seats?
+
+      # Seats are assigned in the background: payment and stock are final by now, and choosing seats
+      # inside completion would hold its locks while buyers compete for them. Runs inside the
+      # transition's transaction on purpose: `pending` rolls back with a failed completion, and
+      # Seats::AutoAssign row-locks this order before seating anyone, so the job waits for the
+      # transition to commit, and skips it on rollback.
+      state_machine.after_transition to: %i[complete resumed], do: :queue_seat_auto_assign, if: :auto_assign_seats?
+    end
+
+    def auto_assign_seats?
+      line_items.any?(&:auto_assign_seats?)
+    end
+
+    # Keeps the vpago processing page on "assigning your seats" until Seats::AutoAssignJob finishes;
+    # appended to Order#pending_completion_steps by OrderDecorator.
+    def seat_assignment_pending?
+      line_items.seat_assignment_pending.exists?
+    end
+
+    private
+
+    # Only parties with someone left to seat: on resume, a party whose seats were all kept keeps its
+    # outcome, since the job would find nobody to seat and never move it off `pending`.
+    def queue_seat_auto_assign
+      waiting = line_items.select(&:auto_assign_seats?).select { |line_item| line_item.guests.exists?(block_id: nil) }
+      return if waiting.empty?
+
+      Spree::LineItem.where(id: waiting.map(&:id)).update_all(seat_assignment_status: :pending) # rubocop:disable Rails/SkipsModelValidations
+      SpreeCmCommissioner::Seats::AutoAssignJob.perform_later(order_id: id)
+    end
+
+    # Cancelling released the seat rows but left guest.block_id pointing at them, and they may have
+    # been resold since. A guest whose seat was resold is unseated here, which queue_seat_auto_assign
+    # then hands to Seats::AutoAssignJob; the rest keep their seat, which
+    # reserve_order_holds! re-reserves in this same transition.
+    def unseat_guests_with_resold_seats!
+      line_items.select(&:auto_assign_seats?).each do |line_item|
+        inventory_item = line_item.inventory_items.first
+        next if inventory_item.nil?
+
+        line_item.guests.where.not(block_id: nil).find_each do |guest|
+          guest.update!(block_id: nil) if resold?(guest, inventory_item)
+        end
+      end
+
+      # Guest#preload_order_block_ids refreshed another instance of this order; the transition's
+      # save of this one would write the stale list back.
+      self.preload_block_ids = blocks.pluck(:id)
+    end
+
+    # Row-locked until the transition commits, so Seats::AutoAssign cannot give a kept seat to
+    # another order before reserve_order_holds! re-reserves it. A locked row has no guest, so an
+    # operator lock counts as resold too.
+    def resold?(guest, inventory_item)
+      row = SpreeCmCommissioner::ReservedBlock.lock.find_by(inventory_item_id: inventory_item.id, block_id: guest.block_id)
+      return false if row.nil?
+
+      (row.reserved? || row.locked? || row.active_on_hold?) && row.guest_id != guest.id
+    end
+  end
+end

data/app/models/concerns/spree_cm_commissioner/product_seat_auto_assignable.rb

@@ -0,0 +1,29 @@
+module SpreeCmCommissioner
+  # Seats are picked by the server once the order completes, instead of by the customer. Turning it
+  # on is guarded by Seats::AutoAssignValidator so the product can never sell more units than there
+  # are linked seats to hand out.
+  #
+  # Needs StoreMetadata included first.
+  module ProductSeatAutoAssignable
+    extend ActiveSupport::Concern
+
+    included do
+      store_public_metadata :auto_assign_seats, :boolean, default: false
+
+      validates_with SpreeCmCommissioner::Seats::AutoAssignValidator, if: :enabling_auto_assign_seats?
+    end
+
+    private
+
+    # Only on the off → on flip: re-checking on every later save would block unrelated edits mid-sale
+    # whenever stock and seats briefly disagree (the async DB stock sync lags Redis).
+    def enabling_auto_assign_seats?
+      return false unless auto_assign_seats?
+
+      previous = attribute_in_database(:public_metadata)
+      previous = {} unless previous.is_a?(Hash)
+
+      !ActiveModel::Type::Boolean.new.cast(previous['auto_assign_seats'])
+    end
+  end
+end

data/app/models/concerns/spree_cm_commissioner/promotion/rules/oauth_application_scoped.rb

@@ -0,0 +1,44 @@
+module SpreeCmCommissioner
+  module Promotion
+    module Rules
+      # The OAuth applications a promotion rule is scoped to, shared by every rule that narrows by
+      # app. Kept in `cm_oauth_application_promotion_rules` rather than a preference so "which
+      # promotions use this app" is a join, and deleting an app cannot leave a dead id in a rule.
+      # How an empty list behaves is up to the rule.
+      module OauthApplicationScoped
+        extend ActiveSupport::Concern
+
+        included do
+          has_many :oauth_application_promotion_rules,
+                   class_name: 'SpreeCmCommissioner::OauthApplicationPromotionRule',
+                   foreign_key: :promotion_rule_id,
+                   inverse_of: :promotion_rule,
+                   autosave: true,
+                   dependent: :destroy
+
+          # For reading and reporting. Not written through: that would load and validate every
+          # Spree::OauthApplication (whose `api_key` is encrypted) just to link it, and the admin form
+          # posts ids anyway.
+          has_many :oauth_applications, through: :oauth_application_promotion_rules, class_name: 'Spree::OauthApplication'
+        end
+
+        # Reads the join rows, loaded once per rule instance: eligibility is re-checked several times in
+        # one cart update, and a plain `pluck` would query every time. Join rows rather than
+        # `oauth_applications`, which would load every app just to get its id.
+        def oauth_application_ids
+          oauth_application_promotion_rules.load.reject(&:marked_for_destruction?).map(&:oauth_application_id)
+        end
+
+        # What the admin form posts. Only the join rows change, saved with the rule. The blank value a
+        # multi-select always submits is dropped.
+        def oauth_application_ids=(ids)
+          wanted = Array(ids).compact_blank.map(&:to_i).uniq
+          existing = oauth_application_promotion_rules.load.to_a
+
+          existing.each { |row| row.mark_for_destruction unless wanted.include?(row.oauth_application_id) }
+          (wanted - existing.map(&:oauth_application_id)).each { |id| oauth_application_promotion_rules.build(oauth_application_id: id) }
+        end
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/block.rb

@@ -26,6 +26,12 @@ module SpreeCmCommissioner
     validates :rotation, presence: true, numericality: { greater_than_or_equal_to: -360, less_than_or_equal_to: 360 }
     validates :shape_path, format: { with: /\A\s*[Mm]/, message: 'must start with a move command' }, allow_blank: true # rubocop:disable Rails/I18nLocaleTexts
 
+    # Position in its ticket type's seat order on this layout (written only by
+    # SeatLayouts::SaveSeatOrder): consecutive numbers are side by side, a skipped number is a break,
+    # lower sells first.
+    validates :seat_index, numericality: { only_integer: true, greater_than: 0 }, allow_nil: true
+    before_validation :clear_seat_index, if: :leaves_seat_order?
+
     validate :cannot_unassign_variant_with_active_blocks
 
     before_validation :assign_layout_from_section, if: -> { seat_layout.nil? && seat_section.present? }
@@ -60,6 +66,17 @@ module SpreeCmCommissioner
 
     private
 
+    # A seat that changes ticket type, or stops being a seat, leaves its row: its number belongs to its
+    # old type's order. Cleared rather than rejected, so a layout builder edit never fails over Seat
+    # order; the gap reads as a break, and Seats::AutoAssignValidator reports the seat as unlinked.
+    def leaves_seat_order?
+      seat_index.present? && (!seatable? || (persisted? && variant_id_changed?))
+    end
+
+    def clear_seat_index
+      self.seat_index = nil
+    end
+
     # Deleting a seat would cascade into its locked rows, dropping the deduction without giving the
     # quantity back. Unlock first.
     #

data/app/models/spree_cm_commissioner/line_item_decorator.rb

@@ -164,6 +164,10 @@ module SpreeCmCommissioner
       return false unless variant.should_track_inventory?
       return false if required_seat_selection?
 
+      # The count hold is what guarantees an auto-assigned seat exists at completion, so these lines
+      # take it regardless of the product's enable_inventory_hold setting.
+      return true if auto_assign_seats?
+
       return true if ENV.fetch('INVENTORY_HOLD_ENABLED', nil) == 'true'
       return true if product.enable_inventory_hold?
 

data/app/models/spree_cm_commissioner/oauth_application_promotion_rule.rb

@@ -0,0 +1,8 @@
+module SpreeCmCommissioner
+  class OauthApplicationPromotionRule < Base
+    belongs_to :promotion_rule, class_name: 'Spree::PromotionRule'
+    belongs_to :oauth_application, class_name: 'Spree::OauthApplication'
+
+    validates :oauth_application_id, uniqueness: { scope: :promotion_rule_id }
+  end
+end

data/app/models/spree_cm_commissioner/order_decorator.rb

@@ -1,11 +1,12 @@
 module SpreeCmCommissioner
-  module OrderDecorator
+  module OrderDecorator # rubocop:disable Metrics/ModuleLength
     def self.prepended(base) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
       base.include SpreeCmCommissioner::OrderChannelBitwise
       base.include SpreeCmCommissioner::StoreMetadata
       base.include SpreeCmCommissioner::PhoneNumberSanitizer
       base.include SpreeCmCommissioner::OrderIntegration
       base.include SpreeCmCommissioner::OrderHoldable
+      base.include SpreeCmCommissioner::OrderSeatAutoAssignable
       base.include SpreeCmCommissioner::OrderStateMachine
       base.include SpreeCmCommissioner::RouteOrderCountable
       base.include SpreeCmCommissioner::OrderScopes
@@ -88,6 +89,15 @@ module SpreeCmCommissioner
       end
     end
 
+    # override: Spree::Api::Webhooks::OrderDecorator#after_resume ends with
+    # `self.state_machine_resumed = false`, and state_machines halts the after_transition chain when
+    # a callback returns false — so every `after_transition to: :resumed` registered after core's
+    # (OrderStateMachine's precalculate_conversion, Seats::AutoAssignJob) silently never ran.
+    def after_resume
+      super
+      true
+    end
+
     # override: imported orders are bulk-loaded from CSV and the contact email
     # often belongs to a third party (organizer, importer) rather than the buyer,
     # so the cancellation email would notify the wrong recipient. Normal orders
@@ -191,6 +201,12 @@ module SpreeCmCommissioner
       super
     end
 
+    # override Vpago::OrderDecorator. Must live here, not in OrderSeatAutoAssignable: vpago's decorator
+    # is prepended above the included concerns, so a definition there would never be reached.
+    def pending_completion_steps
+      seat_assignment_pending? ? super + [:seats_assigning] : super
+    end
+
     # Must live here, not in OrderStateMachine: that concern is included (below Spree::Order),
     # while Spree::Emails::OrderDecorator is prepended above it and never calls super, so an
     # override there is silently dead.

data/app/models/spree_cm_commissioner/product_decorator.rb

@@ -11,6 +11,7 @@ module SpreeCmCommissioner
       base.include SpreeCmCommissioner::StoreMetadata
       base.include SpreeCmCommissioner::HomepageSectionRelatableConcern
       base.include SpreeCmCommissioner::PurchaseLimitable
+      base.include SpreeCmCommissioner::ProductSeatAutoAssignable
 
       base.delegate :is_open_dated, :is_open_dated?, to: :trip, allow_nil: true
 

data/app/models/spree_cm_commissioner/promotion/rules/customer_order_count.rb

@@ -0,0 +1,87 @@
+module SpreeCmCommissioner
+  module Promotion
+    module Rules
+      # Limits a promotion to a customer's Nth booking: 2 → 2 is "2nd booking only", 5 → (empty) is
+      # "5th booking and later". With apps chosen, only bookings placed through them count (the 2nd
+      # Wing booking); with none, bookings from every app count. Narrow by vendor with its own rule.
+      class CustomerOrderCount < Spree::PromotionRule
+        include OauthApplicationScoped
+
+        # Bookings that still stand. Also exactly the predicate of the partial index
+        # `idx_orders_user_for_limits` (user_id WHERE state IN complete, resumed), so the count is an
+        # index lookup on one user's rows.
+        COUNTED_STATES = %w[complete resumed].freeze
+
+        preference :min_order_number, :integer, default: 2
+        # Spree casts an empty integer field to 0, so 0 (or empty) means "no upper limit".
+        preference :max_order_number, :integer, default: 0
+
+        validate :order_number_range_valid
+
+        # Line items too: PromotionHandler::Cart activates a promotion when it is eligible for the
+        # line item just added, and a rule that does not apply to line items is skipped there.
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::LineItem)
+        end
+
+        def eligible?(promotable, _options = {})
+          order = promotable.is_a?(Spree::LineItem) ? promotable.order : promotable
+
+          if order.user_id.nil?
+            eligibility_errors.add(:base, eligibility_error_message(:customer_order_count_login_required))
+          elsif !order_number_in_range?(order_number(order))
+            eligibility_errors.add(:base, eligibility_error_message(:customer_order_count_not_eligible))
+          end
+
+          eligibility_errors.empty?
+        end
+
+        # Which booking this order is for its customer, counted no further than the range needs.
+        # Memoized: one cart update calls eligible? several times (line item, order, each adjustment)
+        # and the answer can't change within it.
+        def order_number(order)
+          @order_numbers ||= {}
+          @order_numbers[[order.id, order.completed_at]] ||= previous_orders(order).limit(count_cap).count + 1
+        end
+
+        def min_order_number
+          preferred_min_order_number.to_i
+        end
+
+        def max_order_number
+          max = preferred_max_order_number.to_i
+          max.positive? ? max : nil
+        end
+
+        private
+
+        # A completed order counts only bookings completed before it, so re-checking it later
+        # (recalculation, cancel) isn't changed by bookings the customer made afterwards.
+        def previous_orders(order)
+          scope = Spree::Order.where(user_id: order.user_id, state: COUNTED_STATES).where.not(id: order.id)
+          app_ids = oauth_application_ids
+          scope = scope.where(oauth_application_id: app_ids) if app_ids.any?
+          order.completed_at ? scope.where(completed_at: ...order.completed_at) : scope
+        end
+
+        # Counting past this can't change the answer, so a customer with 300 bookings costs the
+        # same as one with 3.
+        def count_cap
+          max_order_number || min_order_number
+        end
+
+        def order_number_in_range?(number)
+          number >= min_order_number && (max_order_number.nil? || number <= max_order_number)
+        end
+
+        def order_number_range_valid
+          if min_order_number < 1
+            errors.add(:base, :customer_order_count_min_too_low)
+          elsif max_order_number && max_order_number < min_order_number
+            errors.add(:base, :customer_order_count_max_below_min)
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/promotion/rules/oauth_applications.rb

@@ -0,0 +1,34 @@
+module SpreeCmCommissioner
+  module Promotion
+    module Rules
+      # Limits a promotion to orders placed through chosen OAuth applications — a tenant app or a
+      # mini app (Wing, ACLEDA, Vattanac), each of which logs its users in with its own client.
+      #
+      # Unlike Vendors/GuestAgeGroup, an empty list matches nothing: a channel promotion saved
+      # before anyone picked a channel must not leak to every channel. An order with no
+      # `oauth_application_id` (older orders, or a path that does not record it) never matches.
+      class OauthApplications < Spree::PromotionRule
+        include OauthApplicationScoped
+
+        # Line items too: PromotionHandler::Cart activates a promotion when it is eligible for the
+        # line item just added, and a rule that does not apply to line items is skipped there — so
+        # an order-only rule let every cart attach the promotion with a dead (ineligible) adjustment.
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::LineItem)
+        end
+
+        # Reads the column rather than the association, so eligibility — re-checked on every cart
+        # recalculation — costs no query.
+        def eligible?(promotable, _options = {})
+          order = promotable.is_a?(Spree::LineItem) ? promotable.order : promotable
+
+          unless oauth_application_ids.include?(order.oauth_application_id)
+            eligibility_errors.add(:base, eligibility_error_message(:oauth_application_not_eligible))
+          end
+
+          eligibility_errors.empty?
+        end
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/seats/auto_assign_validator.rb

@@ -0,0 +1,63 @@
+module SpreeCmCommissioner
+  module Seats
+    # Guards switching a product's auto_assign_seats on: every seat is linked in Seat order, and there is
+    # a free seat for every ticket still to be sold. Checks each variant that has seats on an active
+    # layout; every problem becomes one error on :auto_assign_seats.
+    #
+    #   validates_with SpreeCmCommissioner::Seats::AutoAssignValidator
+    class AutoAssignValidator < ActiveModel::Validator
+      def validate(product)
+        seated = product.variants_including_master.filter_map do |variant|
+          seats = seats_for(variant)
+          [variant, seats] if seats.exists?
+        end
+
+        return product.errors.add(:auto_assign_seats, 'has no seats on an active seat layout to assign') if seated.empty?
+
+        seated.each do |variant, seats|
+          [unlinked_seats_error(variant, seats), *not_enough_seats_errors(variant, seats)].compact.each do |message|
+            product.errors.add(:auto_assign_seats, message)
+          end
+        end
+      end
+
+      private
+
+      def seats_for(variant)
+        SpreeCmCommissioner::Block.joins(:seat_layout)
+                                  .where(variant_id: variant.id, block_type: %i[seat sleeping_seat])
+                                  .where(cm_seat_layouts: { status: SpreeCmCommissioner::SeatLayout.statuses[:active] })
+      end
+
+      # A seat left out of Seat order (no seat_index) is never handed out, while its ticket still sells.
+      #
+      #   20 seats, 18 linked → 'VIP: 2 seats are not linked in Seat order'
+      def unlinked_seats_error(variant, seats)
+        count = seats.where(seat_index: nil).count
+        return if count.zero?
+
+        "#{variant.descriptive_name}: #{count} #{count == 1 ? 'seat is' : 'seats are'} not linked in Seat order"
+      end
+
+      # Every ticket still to be sold needs a free seat, per date (one undated item for an event).
+      # Fewer seats than tickets means a paid guest with no seat; more is fine, the extra stays empty.
+      #
+      # Tickets still to be sold: public stock + public carts + private-sale pool + its carts. A seat
+      # locked with Seats::LockBlocks is in neither side: it already lowered quantity_available, and its
+      # ReservedBlock marks it taken.
+      #
+      #   100 seats, 5 taken, 98 tickets to sell → 'VIP on 2026-12-01: 98 tickets can still be sold but only 95 seats are free'
+      def not_enough_seats_errors(variant, seats)
+        variant.inventory_items.active.filter_map do |item|
+          taken = SpreeCmCommissioner::ReservedBlock.unavailable.where(inventory_item_id: item.id).select(:block_id)
+          free = seats.where.not(id: taken).count
+          to_sell = item.quantity_available + item.quantity_on_hold + item.quantity_locked + item.quantity_locked_on_hold
+          next if free >= to_sell
+
+          on = item.inventory_date ? " on #{item.inventory_date}" : ''
+          "#{variant.descriptive_name}#{on}: #{to_sell} tickets can still be sold but only #{free} seats are free"
+        end
+      end
+    end
+  end
+end

data/app/overrides/spree/admin/products/_form/auto_assign_seats.html.erb.deface

@@ -0,0 +1,14 @@
+<!-- insert_after "[data-hook='admin_product_form_promotionable']" -->
+
+<div>
+  <%= f.field_container :auto_assign_seats do %>
+    <%= f.label :auto_assign_seats do %>
+      <%= f.check_box :auto_assign_seats %>
+      Auto-assign seats
+    <% end %>
+    <%= f.error_message_on :auto_assign_seats %>
+    <small class="form-text text-muted">
+      Customers don't pick seats; each paid order gets the best free seats together, following the layout's Seat order. Can only be switched on once every seat of this product is linked in Seat order.
+    </small>
+  <% end %>
+</div>

data/app/queries/spree_cm_commissioner/seats/free_runs_query.rb

@@ -0,0 +1,73 @@
+module SpreeCmCommissioner
+  module Seats
+    # A variant's free seats, grouped into runs of side-by-side seats for auto-assign.
+    #
+    # Walks the variant's linked seats in Block#seat_index order (see SeatLayouts::SaveSeatOrder), one
+    # layout at a time since each layout is numbered on its own:
+    # - a skipped number is the organizer's row break, so it starts the next stroke (0, 1, 2… in sell
+    #   order) and ends the run;
+    # - a taken seat ends the run too, so a run is always seats a party can sit in together.
+    #
+    #   seat_index: 1 2 3   5 6 7    (4 skipped: row break)
+    #   taken:          ✗
+    #   runs:       stroke 0 [1, 2], stroke 1 [5, 6, 7]
+    #
+    # Only active layouts count: an inactive/archived layout's seats are not on sale.
+    class FreeRunsQuery
+      Run = Struct.new(:seat_layout_id, :stroke, :start_index, :block_ids, keyword_init: true) do
+        delegate :size, to: :block_ids
+      end
+
+      def initialize(variant_id:, inventory_item_id:)
+        @variant_id = variant_id
+        @inventory_item_id = inventory_item_id
+      end
+
+      def call
+        seats = linked_seats.pluck(:id, :seat_layout_id, :seat_index)
+        taken = ReservedBlock.unavailable.where(inventory_item_id: @inventory_item_id, block_id: linked_seats.select(:id))
+                             .pluck(:block_id).to_set
+
+        seats.group_by { |_id, seat_layout_id, _index| seat_layout_id }.flat_map do |seat_layout_id, layout_seats|
+          runs_in(seat_layout_id, layout_seats, taken)
+        end
+      end
+
+      private
+
+      def linked_seats
+        Block.joins(:seat_layout)
+             .where(variant_id: @variant_id, cm_seat_layouts: { status: SeatLayout.statuses[:active] })
+             .where.not(seat_index: nil)
+             .order(:seat_layout_id, :seat_index)
+      end
+
+      def runs_in(seat_layout_id, seats, taken)
+        runs = []
+        stroke = 0
+        run = nil
+
+        seats.each_with_index do |(id, _seat_layout_id, index), i|
+          if i.positive? && index != seats[i - 1][2] + 1
+            stroke += 1
+            run = nil
+          end
+
+          if taken.include?(id)
+            run = nil
+            next
+          end
+
+          if run.nil?
+            run = Run.new(seat_layout_id: seat_layout_id, stroke: stroke, start_index: index, block_ids: [])
+            runs << run
+          end
+
+          run.block_ids << id
+        end
+
+        runs
+      end
+    end
+  end
+end

data/app/serializers/spree/v2/storefront/line_item_serializer_decorator.rb

@@ -11,7 +11,7 @@ module Spree
                           :high_demand, :jwt_token,
                           :direction, :trip_id, :boarding_trip_stop_id, :drop_off_trip_stop_id,
                           :service_fee_total, :display_service_fee_total,
-                          :parent_id, :relation_type, :bundle_amount, :display_bundle_amount
+                          :parent_id, :relation_type, :bundle_amount, :display_bundle_amount, :seat_assignment_status
 
           base.attribute :required_self_check_in_location, &:required_self_check_in_location?
           base.attribute :allowed_self_check_in, &:allowed_self_check_in?

data/app/serializers/spree/v2/storefront/product_serializer_decorator.rb

@@ -19,7 +19,7 @@ module Spree
                           :use_video_as_default, :allow_transfer, :allow_gift_transfer
 
           base.attributes :reveal_description, :discontinue_on, :public_metadata, :purchasable_on, :preview,
-                          :enable_inventory_hold
+                          :enable_inventory_hold, :auto_assign_seats
 
           # Expose only the `event_id` here instead of the full event object.
           # This lets the client fetch event details separately (usually already cached),