spree_cm_commissioner 2.15.1 → 2.15.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7cd929df06e0243dc4cf2b0b4ffc57d3346ced9f9d0cb5bdd3142d6adc153a88
-  data.tar.gz: 29a71dceac61e9e6497137c525ff9e76ace8ca1a179f0dc6eab157fd83a30a4d
+  metadata.gz: a5538af5130244a626ceca3f818410469c93ea7975f5cbc51b212b7536361b8e
+  data.tar.gz: 4e272e66836c76b1296aad6a65488cd17e3ef9517a4a8112594047875de4a185
 SHA512:
-  metadata.gz: 2bd7890db6844d7057a5e89f8e2cd0285e387772aaccba0ba2806aee4b7f78de3cea566402fb5a97279613bae6be342bbef2b55e2d185c82d8d85fec59401520
-  data.tar.gz: 682f9b46dae492ff3f0bdb9f558dccc3185ec4b9a6a0770e4fca4146ecd496e90577b97c049a9a171f7ab6ac76486fc14d4cdefe6bf7098ec96de9b8c09c170b
+  metadata.gz: 80bc600859e7bdf199590d0a5e7982b9b03bbef4ddc9b19e03fbbbe6be76ceca11817687b1d358db20be3b9b7665154d9a05db59412e690448982cf70f543e4d
+  data.tar.gz: 646dea4a475811f6452137087b603d3bb36b6832bd6550339713b84a82f7ee0c71054b81632aebd4ddd041eef14ceca479402e679b0ab49fbf40d87f0e69ec15

data/Gemfile.lock

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

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/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/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/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),

data/app/serializers/spree/v2/tenant/line_item_serializer.rb

@@ -12,7 +12,7 @@ module Spree
                    :completion_steps, :available_social_contact_platforms, :allow_anonymous_booking,
                    :discontinue_on, :high_demand, :jwt_token, :pre_tax_amount, :display_pre_tax_amount, :public_metadata,
                    :direction, :trip_id, :boarding_trip_stop_id, :drop_off_trip_stop_id, :remark,
-                   :service_fee_total, :display_service_fee_total
+                   :service_fee_total, :display_service_fee_total, :seat_assignment_status
 
         attribute :required_self_check_in_location, &:required_self_check_in_location?
         attribute :allowed_self_check_in, &:allowed_self_check_in?

data/app/services/spree_cm_commissioner/order_holds/release.rb

@@ -41,7 +41,9 @@ module SpreeCmCommissioner
       end
 
       def cancel_seat_blocks!(order)
-        return unless order.should_manage_blocks?
+        # auto_assign_seats?: Seats::AutoAssignJob may have seated the guests after this order
+        # instance was loaded, leaving its preload_block_ids stale and empty.
+        return unless order.should_manage_blocks? || order.auto_assign_seats?
 
         result = SpreeCmCommissioner::ReservedBlocks::Cancel.call!(
           order_id: order.id,

data/app/services/spree_cm_commissioner/seat_layouts/save_seat_order.rb

@@ -0,0 +1,111 @@
+module SpreeCmCommissioner
+  module SeatLayouts
+    # Persists an organizer's seat order from the "Seat order" page.
+    #
+    # Strokes arrive as ordered arrays of block ids. Each stroke is one row of side-by-side seats of a
+    # single ticket type (variant), and a variant's stroke order is its sell order — the order between
+    # strokes of different variants means nothing, since auto-assign only ever ranks one variant's
+    # seats. A seat with no variant can never be sold, so it has no place in the order.
+    #
+    # Each variant's strokes are flattened into its own Block#seat_index sequence: consecutive inside
+    # a stroke, one number skipped between strokes, so a single integer answers both "are these two
+    # seats together?" (differ by exactly 1) and "which sells first?" (lower). Numbering per variant
+    # keeps one type's edits from renumbering another's. The Seat order page rebuilds the strokes by
+    # grouping by variant and splitting at the skipped numbers, so it must agree with `indexes_for`.
+    #
+    # Replaces the whole layout's order on every save. Assignments live on ReservedBlock and
+    # Guest#block_id, never on seat_index, so re-saving mid-sale moves no sold seat — it only
+    # changes how future auto-assign picks are ranked.
+    #
+    #   success(linked_count)
+    #   | failure(nil, :duplicate_seat | :unknown_seat | :not_a_seat | :no_ticket_type | :mixed_ticket_types)
+    class SaveSeatOrder
+      prepend ::Spree::ServiceModule::Base
+
+      def call(seat_layout:, strokes:)
+        strokes = normalize(strokes)
+        ids = strokes.flatten
+        blocks = ids.include?(nil) ? [] : seat_layout.blocks.where(id: ids).to_a
+        variant_ids = blocks.to_h { |block| [block.id, block.variant_id] }
+
+        reason = refusal(strokes, ids, blocks, variant_ids)
+        return failure(nil, reason) if reason
+
+        indexes = indexes_for(strokes, variant_ids)
+
+        # Clear first, then write: the unique (variant_id, seat_layout_id, seat_index) index is
+        # checked row by row, so rewriting in place would collide with numbers not yet moved.
+        ActiveRecord::Base.transaction do
+          seat_layout.blocks.where.not(seat_index: nil).update_all(seat_index: nil, updated_at: Time.current) # rubocop:disable Rails/SkipsModelValidations
+          write_indexes!(indexes) if indexes.any?
+        end
+
+        success(indexes.size)
+      end
+
+      private
+
+      # Each ticket type keeps its own counter, so the same number can appear once per type: VIP 1 and
+      # Regular 1 are two different first seats. `variant_ids` is { block_id => variant_id }.
+      #
+      #   strokes: [[R1, R2], [V1, V2], [R3, R4]]   (R = Regular seats, V = VIP seats)
+      #
+      #   Regular: R1 → 1, R2 → 2, (3 skipped: row break), R3 → 4, R4 → 5
+      #   VIP:     V1 → 1, V2 → 2
+      def indexes_for(strokes, variant_ids)
+        next_index = Hash.new(1)
+
+        strokes.each_with_object({}) do |stroke, indexes|
+          variant_id = variant_ids[stroke.first]
+
+          stroke.each do |id|
+            indexes[id] = next_index[variant_id]
+            next_index[variant_id] += 1
+          end
+
+          # The row split: skip one number, so this row's last seat and the next row's first are 2 apart.
+          next_index[variant_id] += 1
+        end
+      end
+
+      def refusal(strokes, ids, blocks, variant_ids)
+        return :unknown_seat if ids.include?(nil)
+        return :duplicate_seat if ids.uniq.size != ids.size
+        return :unknown_seat if blocks.size != ids.size
+        return :not_a_seat unless blocks.all?(&:seatable?)
+        return :no_ticket_type if blocks.any? { |block| block.variant_id.nil? }
+
+        :mixed_ticket_types if mixed_ticket_types?(strokes, variant_ids)
+      end
+
+      # Two seats of different ticket types are never sold as a pair, and each type is numbered on its
+      # own, so a row spanning both has no single sequence to live in.
+      def mixed_ticket_types?(strokes, variant_ids)
+        strokes.any? { |stroke| stroke.map { |id| variant_ids[id] }.uniq.size > 1 }
+      end
+
+      # Turns the param ids into integers and drops empty rows. A non-numeric id becomes nil, which
+      # `refusal` reports as :unknown_seat, instead of raising here.
+      #
+      #   [["12", "13"], [], ["14", "x"]] → [[12, 13], [14, nil]]
+      #   nil                             → []   (clears the whole order)
+      def normalize(strokes)
+        Array(strokes).map { |stroke| Array(stroke).map { |id| Integer(id, exception: false) } }.reject(&:empty?)
+      end
+
+      # One statement instead of one UPDATE per seat: a stadium layout is thousands of seats, and
+      # Block's callbacks/validations (layout sync, variant-unassign guard) are irrelevant to this
+      # one integer column.
+      def write_indexes!(indexes)
+        values = indexes.map { |id, index| "(#{Integer(id)}, #{Integer(index)})" }.join(', ')
+
+        ActiveRecord::Base.connection.execute(<<~SQL.squish)
+          UPDATE cm_blocks
+          SET seat_index = v.seat_index, updated_at = NOW()
+          FROM (VALUES #{values}) AS v(id, seat_index)
+          WHERE cm_blocks.id = v.id
+        SQL
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/seats/auto_assign.rb

@@ -0,0 +1,135 @@
+module SpreeCmCommissioner
+  module Seats
+    # Seats the unseated guests of a paid order's auto-assign line items. Runs from Seats::AutoAssignJob
+    # once completion has committed: payment and stock are already final, so a slow or failed
+    # assignment never holds up or rolls back the completion — the job just retries.
+    #
+    # One assignment per inventory item at a time (a transaction-scoped advisory lock). Jobs are
+    # enqueued in completion order, so serializing them keeps "first to pay gets the better seats",
+    # and the free runs read under the lock cannot go stale because of another assignment.
+    #
+    # Steps: advisory lock → Seats::FreeRunsQuery (free seats as side-by-side runs) →
+    # Seats::PickSeats (which seats this party gets, plain Ruby) → reserve_seats!.
+    #
+    # A seat for every paid ticket is guaranteed by the Redis count hold taken at checkout (plus
+    # Seats::AutoAssignValidator). Sitting together is best effort: near sell-out a party can be
+    # split, which is recorded on the line item (seat_assignment_status) for the organizer to fix.
+    #
+    #   success([{ line_item_id:, status: :together | :split | :unseated, block_ids: [...] }, ...])
+    class AutoAssign
+      prepend ::Spree::ServiceModule::Base
+
+      # Seats::LockBlocks does not take the advisory lock, so an operator can still take a seat between
+      # the free runs read and reserve_seats!. Raised so the whole assignment rolls back and the job
+      # retries against fresh runs — rare enough not to retry in place.
+      SeatTakenError = Class.new(StandardError)
+
+      # A stuck assignment must not queue every later job for the same event behind it forever.
+      # Postgres applies lock_timeout to advisory locks too; the job retries on the timeout.
+      LOCK_TIMEOUT = '30s'.freeze
+
+      UNSEATED = { status: :unseated, block_ids: [] }.freeze
+
+      def call(order:)
+        inventory_item_ids = order.line_items.select(&:auto_assign_seats?).filter_map { |li| li.inventory_items.first&.id }.uniq
+        return success([]) if inventory_item_ids.empty?
+
+        outcomes = ActiveRecord::Base.transaction do
+          lock_inventory_items!(inventory_item_ids)
+
+          # Taken after the advisory lock so the order row is not held while queueing. The job is
+          # enqueued inside the completion transaction, which still holds this row: lock! waits for
+          # it to commit, then reloads — a rolled-back completion or a committed cancel gets no
+          # seats, and a cancel still in flight waits here, then finds the rows written below.
+          order.lock!
+
+          unless order.completed? && !order.canceled?
+            # A party canceled before the job ran is no longer waiting for a seat.
+            order.line_items.seat_assignment_pending.update_all(seat_assignment_status: nil) # rubocop:disable Rails/SkipsModelValidations
+            next []
+          end
+
+          order.line_items.select(&:auto_assign_seats?).filter_map { |line_item| assign_line_item!(order, line_item) }
+        end
+
+        report(order, outcomes) if outcomes.any?
+        success(outcomes)
+      end
+
+      private
+
+      # Sorted so two orders spanning the same items always lock them in the same order.
+      def lock_inventory_items!(inventory_item_ids)
+        connection = ActiveRecord::Base.connection
+        connection.execute("SET LOCAL lock_timeout = '#{LOCK_TIMEOUT}'")
+
+        inventory_item_ids.sort.each do |id|
+          connection.execute("SELECT pg_advisory_xact_lock(#{Zlib.crc32("spree_cm_commissioner:seat_auto_assign:#{id}")})")
+        end
+      end
+
+      def assign_line_item!(order, line_item)
+        guests = line_item.guests.where(block_id: nil).order(:id).to_a
+        return nil if guests.empty?
+
+        inventory_item = line_item.inventory_items.first
+        return record!(line_item, UNSEATED) if inventory_item.nil?
+
+        runs = FreeRunsQuery.new(variant_id: line_item.variant_id, inventory_item_id: inventory_item.id).call
+        pick = PickSeats.call(runs: runs, count: guests.size)
+        return record!(line_item, UNSEATED) if pick.nil?
+
+        reserve_seats!(order, guests, pick.block_ids, inventory_item)
+        record!(line_item, { status: pick.together? ? :together : :split, block_ids: pick.block_ids })
+      end
+
+      def reserve_seats!(order, guests, block_ids, inventory_item)
+        guests.zip(block_ids).each do |guest, block_id|
+          # Row-locked for LockBlocks, which locks the inventory item rather than the block. A seat
+          # with no row yet is covered by the unique index instead: a concurrent insert raises
+          # RecordNotUnique, which retries the job like SeatTakenError.
+          key = { block_id: block_id, inventory_item_id: inventory_item.id }
+          reserved_block = SpreeCmCommissioner::ReservedBlock.lock.find_by(key) || SpreeCmCommissioner::ReservedBlock.new(key)
+          raise SeatTakenError, "block #{block_id}" if taken?(reserved_block)
+
+          # Same attributes ReservedBlocks::Reserve writes. Gender is what neighbour rules evaluated by
+          # the next assignment read.
+          reserved_block.update!(
+            status: :reserved,
+            guest: guest,
+            gender: guest.gender || guest.saved_guest&.gender,
+            expired_at: nil,
+            payment_locked_at: nil,
+            inventory_date: inventory_item.inventory_date,
+            updated_by: order.user
+          )
+
+          # Guest#assign_seat_number_with_block copies the block label into seat_number, and
+          # Guest#preload_order_block_ids refreshes order.preload_block_ids so a later cancel releases it.
+          guest.update!(block_id: block_id)
+        end
+      end
+
+      def taken?(reserved_block)
+        reserved_block.reserved? || reserved_block.locked? || reserved_block.active_on_hold?
+      end
+
+      # update_columns: LineItem validations (purchase limits) must not block a paid order's seats.
+      def record!(line_item, outcome)
+        line_item.update_columns(seat_assignment_status: outcome[:status]) # rubocop:disable Rails/SkipsModelValidations
+
+        outcome.merge(line_item_id: line_item.id)
+      end
+
+      def report(order, outcomes)
+        data = { order_id: order.id, order_number: order.number, outcomes: outcomes }
+
+        if outcomes.all? { |outcome| outcome[:status] == :together }
+          CmAppLogger.log(label: self.class.name, data: data)
+        else
+          CmAppLogger.error(label: "#{self.class.name} party not seated together", data: data)
+        end
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/seats/block_date_iteration.rb

@@ -28,7 +28,10 @@ module SpreeCmCommissioner
       # Yields [block, date, inventory_item] for every pair that resolves to an inventory item, and
       # records a :no_inventory skip for those that do not — a service calendar can legitimately exclude
       # dates, so a missing item is normal input rather than an error.
+      # No dates means the undated item every event ticket has (inventory_date: nil) — there is no
+      # departure to choose, so the dashboard sends none.
       def each_block_date(blocks, dates, skipped)
+        dates = Array(dates).presence || [nil]
         index = inventory_index(blocks, dates)
 
         # Warm every Redis key once for the whole grid instead of once per seat-date.
@@ -39,9 +42,9 @@ module SpreeCmCommissioner
         # fewer round-trips, which matters as soon as Redis is a network hop rather than localhost.
         SpreeCmCommissioner::RedisStock::CachedInventoryItemsBuilder.new(index.values).call if index.any?
 
-        Array(dates).each do |date|
+        dates.each do |date|
           blocks.each do |block|
-            item = index[[block.variant_id, date.to_date]]
+            item = index[[block.variant_id, date&.to_date]]
 
             if item.nil?
               skipped << skip(date, block, :no_inventory)

data/app/services/spree_cm_commissioner/seats/pick_seats.rb

@@ -0,0 +1,79 @@
+module SpreeCmCommissioner
+  module Seats
+    # Chooses which free seats a party of `count` gets, from Seats::FreeRunsQuery runs.
+    #
+    # Rules, in order:
+    # 1. Together — the run in the earliest stroke that fits, then the best fit inside that stroke:
+    #    exact fit, then leaving ≥ 2 behind, and only then leaving exactly 1 (an orphan only a solo
+    #    buyer can ever use). Stroke ranks above fit so an earlier payer is never pushed back a row
+    #    just to pack better. Seats come from the start of the run, keeping the rest contiguous.
+    # 2. Split — anchor on the biggest run, fill from the nearest strokes of the same layout first.
+    #    Organizers drag rows in order, so the nearest stroke is usually the row behind or in front.
+    # nil — fewer than `count` free seats in total (stock/seat drift).
+    #
+    # Deliberately plain Ruby over duck-typed runs (seat_layout_id, stroke, start_index, block_ids,
+    # size): no database, so it is unit-tested with Structs and can be replayed offline against a
+    # venue to measure how often parties split.
+    class PickSeats
+      Pick = Struct.new(:block_ids, :pieces, keyword_init: true) do
+        def together? = pieces == 1
+      end
+
+      def self.call(runs:, count:)
+        new(runs, count).call
+      end
+
+      def initialize(runs, count)
+        @runs = runs
+        @count = count
+      end
+
+      def call
+        return nil if @count <= 0 || @runs.sum(&:size) < @count
+
+        together || split
+      end
+
+      private
+
+      def together
+        run = @runs.select { |r| r.size >= @count }
+                   .min_by { |r| [r.seat_layout_id, r.stroke, fit_penalty(r), r.start_index] }
+        return nil if run.nil?
+
+        Pick.new(block_ids: run.block_ids.first(@count), pieces: 1)
+      end
+
+      def fit_penalty(run)
+        case run.size - @count
+        when 0 then 0
+        when 1 then 2
+        else 1
+        end
+      end
+
+      def split
+        anchor = @runs.max_by { |r| [r.size, -r.stroke, -r.start_index] }
+        nearest = (@runs - [anchor]).sort_by do |r|
+          [
+            r.seat_layout_id == anchor.seat_layout_id ? 0 : 1,
+            (r.stroke - anchor.stroke).abs,
+            (r.start_index - anchor.start_index).abs
+          ]
+        end
+
+        ids = []
+        pieces = 0
+
+        [anchor, *nearest].each do |run|
+          break if ids.size == @count
+
+          ids.concat(run.block_ids.first(@count - ids.size))
+          pieces += 1
+        end
+
+        Pick.new(block_ids: ids, pieces: pieces)
+      end
+    end
+  end
+end

data/db/migrate/20261106000001_add_seat_index_to_cm_blocks.rb

@@ -0,0 +1,16 @@
+class AddSeatIndexToCmBlocks < ActiveRecord::Migration[7.0]
+  def change
+    add_column :cm_blocks, :seat_index, :integer, if_not_exists: true
+
+    # One seat order per ticket type on a layout: each variant's seats are numbered on their own, so
+    # editing one type's rows never renumbers another's. Unique so SeatLayouts::SaveSeatOrder can make
+    # a corrupt order (two seats claiming the same place) impossible rather than merely unlikely; in
+    # this column order because auto-assign looks up free seats the same way: by ticket type (variant_id),
+    # per layout (seat_layout_id), in seat order (seat_index).
+    add_index :cm_blocks, %i[variant_id seat_layout_id seat_index],
+              unique: true,
+              where: 'seat_index IS NOT NULL',
+              name: 'index_cm_blocks_on_variant_layout_and_seat_index',
+              if_not_exists: true
+  end
+end

data/db/migrate/20261110000001_add_seat_assignment_status_to_spree_line_items.rb

@@ -0,0 +1,11 @@
+class AddSeatAssignmentStatusToSpreeLineItems < ActiveRecord::Migration[7.0]
+  def change
+    add_column :spree_line_items, :seat_assignment_status, :integer, if_not_exists: true
+
+    # Only auto-assign line items ever get a value, so a partial index stays tiny while serving the
+    # lookups that need it: pending parties for a bulk run or sweeper, split parties for the organizer.
+    add_index :spree_line_items, :seat_assignment_status,
+              where: 'seat_assignment_status IS NOT NULL',
+              if_not_exists: true
+  end
+end

data/lib/spree_cm_commissioner/version.rb

@@ -1,5 +1,5 @@
 module SpreeCmCommissioner
-  VERSION = '2.15.1'.freeze
+  VERSION = '2.15.2'.freeze
 
   module_function
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spree_cm_commissioner
 version: !ruby/object:Gem::Version
-  version: 2.15.1
+  version: 2.15.2
 platform: ruby
 authors:
 - You
@@ -1435,6 +1435,7 @@ files:
 - app/jobs/spree_cm_commissioner/route_metrics/increase_order_count_job.rb
 - app/jobs/spree_cm_commissioner/route_metrics/increase_trip_count_job.rb
 - app/jobs/spree_cm_commissioner/route_prices/update_price_range_job.rb
+- app/jobs/spree_cm_commissioner/seats/auto_assign_job.rb
 - app/jobs/spree_cm_commissioner/seats/bulk_release_on_hold_blocks_job.rb
 - app/jobs/spree_cm_commissioner/seats/release_expired_blocks_job.rb
 - app/jobs/spree_cm_commissioner/show_contestants/import_job.rb
@@ -1506,6 +1507,7 @@ files:
 - app/models/concerns/spree_cm_commissioner/order_prepaid_payment.rb
 - app/models/concerns/spree_cm_commissioner/order_qr_codeable.rb
 - app/models/concerns/spree_cm_commissioner/order_scopes.rb
+- app/models/concerns/spree_cm_commissioner/order_seat_auto_assignable.rb
 - app/models/concerns/spree_cm_commissioner/order_state_machine.rb
 - app/models/concerns/spree_cm_commissioner/parameterize_name.rb
 - app/models/concerns/spree_cm_commissioner/participation_type_bitwise.rb
@@ -1513,6 +1515,7 @@ files:
 - app/models/concerns/spree_cm_commissioner/phone_number_sanitizer.rb
 - app/models/concerns/spree_cm_commissioner/product_delegation.rb
 - app/models/concerns/spree_cm_commissioner/product_relation_type.rb
+- app/models/concerns/spree_cm_commissioner/product_seat_auto_assignable.rb
 - app/models/concerns/spree_cm_commissioner/product_type.rb
 - app/models/concerns/spree_cm_commissioner/promotion/rules/oauth_application_scoped.rb
 - app/models/concerns/spree_cm_commissioner/purchase_limitable.rb
@@ -1766,6 +1769,7 @@ files:
 - app/models/spree_cm_commissioner/saved_guest.rb
 - app/models/spree_cm_commissioner/seat_layout.rb
 - app/models/spree_cm_commissioner/seat_section.rb
+- app/models/spree_cm_commissioner/seats/auto_assign_validator.rb
 - app/models/spree_cm_commissioner/service_calendar.rb
 - app/models/spree_cm_commissioner/service_fee_rule.rb
 - app/models/spree_cm_commissioner/show.rb
@@ -1920,6 +1924,7 @@ files:
 - app/overrides/spree/admin/products/_form/allow_gift_transfer.html.erb.deface
 - app/overrides/spree/admin/products/_form/allow_self_check_in.html.erb.deface
 - app/overrides/spree/admin/products/_form/allow_transfer.html.erb.deface
+- app/overrides/spree/admin/products/_form/auto_assign_seats.html.erb.deface
 - app/overrides/spree/admin/products/_form/available_on.html.erb.deface
 - app/overrides/spree/admin/products/_form/discontinue_on.html.erb.deface
 - app/overrides/spree/admin/products/_form/enable_confirmation_email.html.erb.deface
@@ -2078,6 +2083,7 @@ files:
 - app/queries/spree_cm_commissioner/pie_chart_event_aggregator_queries.rb
 - app/queries/spree_cm_commissioner/recipient_searcher_query.rb
 - app/queries/spree_cm_commissioner/reservation_query.rb
+- app/queries/spree_cm_commissioner/seats/free_runs_query.rb
 - app/queries/spree_cm_commissioner/session_product_monitor_query.rb
 - app/queries/spree_cm_commissioner/single_leg_trips_query.rb
 - app/queries/spree_cm_commissioner/store_credit_overview_query.rb
@@ -2668,12 +2674,15 @@ files:
 - app/services/spree_cm_commissioner/rsa_service.rb
 - app/services/spree_cm_commissioner/seat_layouts/grid.rb
 - app/services/spree_cm_commissioner/seat_layouts/sanitize_svg.rb
+- app/services/spree_cm_commissioner/seat_layouts/save_seat_order.rb
 - app/services/spree_cm_commissioner/seat_layouts/update.rb
 - app/services/spree_cm_commissioner/seats/apply_locks.rb
+- app/services/spree_cm_commissioner/seats/auto_assign.rb
 - app/services/spree_cm_commissioner/seats/block_date_iteration.rb
 - app/services/spree_cm_commissioner/seats/bulk_release_on_hold_blocks.rb
 - app/services/spree_cm_commissioner/seats/lock_blocks.rb
 - app/services/spree_cm_commissioner/seats/lock_state.rb
+- app/services/spree_cm_commissioner/seats/pick_seats.rb
 - app/services/spree_cm_commissioner/seats/release_expired_blocks.rb
 - app/services/spree_cm_commissioner/seats/unlock_blocks.rb
 - app/services/spree_cm_commissioner/seeds/roles_decorator.rb
@@ -3799,6 +3808,8 @@ files:
 - db/migrate/20261105000002_add_index_to_spree_orders_waiting_room_session_id.rb
 - db/migrate/20261105000003_add_queue_fields_to_cm_waiting_room_sessions.rb
 - db/migrate/20261105000004_add_oauth_application_id_to_spree_orders.rb
+- db/migrate/20261106000001_add_seat_index_to_cm_blocks.rb
+- db/migrate/20261110000001_add_seat_assignment_status_to_spree_line_items.rb
 - db/migrate/20261110000001_create_cm_oauth_application_promotion_rules.rb
 - docker-compose.yml
 - docs/api/scoped-access-token-endpoints.md