spree_cm_commissioner 2.14.1 → 2.14.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d7734080da716bf13a816acbd174d75272acdbbf4fd5a257d5e6c535eb7cece
-  data.tar.gz: 310a647df40f1c0d6f0cab1a3f676d7f558e07d0a45108addd7a1d552ebd4083
+  metadata.gz: c169ca8f3c24e2294f37a17142112c820953fbd3b109c7e53c3a39ccf19e88e4
+  data.tar.gz: ec8aee4c537d0f1f47b705eb4e248a0b148b124979e743adfd02d1b510b4a9f9
 SHA512:
-  metadata.gz: efb1b8f98edd7bb4a815086717aad5722a2e22ca6dd7c9472df0aa18ce1259cbd26674c45a3b0e8a064ff69e194f6b650bfded02528d7ef6078c74e62aad0fee
-  data.tar.gz: e578ec7e879cfade2a629c9a452283689942890aae8ad5b82b81bb67dba4f3155aaba401f76d77ae603435614e90a610293f2e1c9fde942627dab76bec5f6241
+  metadata.gz: 4cb10cc3987eff0d89409c4275cafa26263a9ed349deacb81c816c3fca496927973a640eb1fe875a4e724eebdc43ecc3cec6f5e8626b7f9653e422704bad6553
+  data.tar.gz: 1f68fa692abff8ab900ac03cc864b5509270c863b62606b8f2ddca4b98c7f05358b61c82663af1f580ab7a5510f690fc3827d2f07c1cc60c574e6146add476be

data/Gemfile.lock

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

data/app/factory/spree_cm_commissioner/order_telegram_message_factory.rb

@@ -3,17 +3,18 @@
 # Order Number:
 # <code>R621016753</code>
 #
-# [ x1 ]
+# 🎪 Event: Temple Run 2023
+# 🏪 Vendor: Temple Run with Sai
+#
 # <b>5km Running Ticket</b>
+# Quantity: 1
 # <i>👉 Distance: 5km, T-shirt: M</i>
 # <i>🗓️ Nov 15, 2023</i>
-# <i>🏪 Temple Run with Sai</i>
 #
-# [ x2 ]
 # <b>5km Running Ticket</b>
+# Quantity: 2
 # <i>👉 Distance: 5km, T-shirt: S</i>
 # <i>🗓️ Nov 15, 2023 -> Nov 17, 2023</i>
-# <i>🏪 Temple Run with Sai</i>
 #
 # <b>🙍 Customer Info</b>
 # Name: Vaneath Awesome
@@ -43,10 +44,31 @@ module SpreeCmCommissioner
     def body
       text = []
       text << "Order Number:\n#{inline_code(order.number)}\n"
+      summary = summary_content
+      text << "#{summary}\n" if summary.present?
       text << selected_line_items.map { |item| line_item_content(item) }.compact.join("\n\n")
       text.compact.join("\n")
     end
 
+    # Stated once for the whole order rather than per ticket: an order is almost always one
+    # event and one vendor, so a per-ticket line would just repeat the same name.
+    def summary_content
+      line_items = selected_line_items.to_a
+      ActiveRecord::Associations::Preloader.new(records: line_items, associations: %i[event vendor]).call
+
+      [
+        names_line('🎪 Event', line_items.map(&:event)),
+        names_line('🏪 Vendor', line_items.map(&:vendor))
+      ].compact.join("\n").presence
+    end
+
+    def names_line(label, records)
+      names = records.compact.map(&:name).compact_blank.uniq
+      return nil if names.empty?
+
+      "#{label}: #{names.map { |name| ERB::Util.html_escape(name) }.join(', ')}"
+    end
+
     def line_item_content(line_item)
       return transit_line_item_content(line_item) if line_item.transit?
 
@@ -56,7 +78,6 @@ module SpreeCmCommissioner
       text << "Quantity: #{line_item.quantity}"
       text << italic("👉 #{line_item.options_text}") if line_item.options_text.present?
       text << italic(pretty_date_for(line_item)) if pretty_date_for(line_item).present?
-      text << italic("🏪 #{line_item.vendor.name}") if line_item.vendor&.name.present? && vendor.blank?
       text << seat_labels_text(line_item) if seat_labels_text(line_item).present?
 
       text.compact.join("\n")

data/app/jobs/spree_cm_commissioner/audit_events/cleanup_expired_job.rb

@@ -0,0 +1,18 @@
+module SpreeCmCommissioner
+  module AuditEvents
+    class CleanupExpiredJob < SpreeCmCommissioner::ApplicationJob
+      # Gap before continuing a backlog, so the Sidekiq thread is free for other jobs in between.
+      CONTINUE_DELAY = 10.seconds
+
+      queue_as :maintenance
+
+      # Not an ApplicationUniqueJob: `unique :until_executed` would drop the continuation below as a duplicate of the
+      # running job. Overlapping with the daily cron is harmless because deleting is idempotent.
+      def perform
+        result = SpreeCmCommissioner::AuditEvents::CleanupExpired.new.call
+
+        self.class.set(wait: CONTINUE_DELAY).perform_later if result.value[:more_remaining]
+      end
+    end
+  end
+end

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

@@ -2,7 +2,7 @@ module SpreeCmCommissioner
   module VendorPreference
     extend ActiveSupport::Concern
 
-    TELEGRAM_CHAT_TYPE = %i[channel group].freeze
+    TELEGRAM_CHAT_TYPE = %i[channel group supergroup].freeze
 
     included do
       preference :telegram_chat_id, :string

data/app/models/spree_cm_commissioner/audit_event.rb

@@ -1,5 +1,8 @@
 module SpreeCmCommissioner
   class AuditEvent < Base
+    # How long AuditLogger keeps an event when the caller gives no retention_days.
+    DEFAULT_RETENTION_DAYS = 90
+
     belongs_to :auditable, polymorphic: true, optional: true
     belongs_to :user, class_name: 'Spree::User', optional: true
 
@@ -7,5 +10,7 @@ module SpreeCmCommissioner
 
     scope :success, -> { where(success: true) }
     scope :failed,  -> { where(success: false) }
+
+    scope :expired, -> (now = Time.current) { where(retention_until: ...now.to_date) }
   end
 end

data/app/services/spree_cm_commissioner/audit_events/cleanup_expired.rb

@@ -0,0 +1,58 @@
+module SpreeCmCommissioner
+  module AuditEvents
+    class CleanupExpired
+      prepend ::Spree::ServiceModule::Base
+
+      BATCH_SIZE = 1_000
+      TIME_BUDGET = 30.seconds
+
+      # Deletes expired audit events chunk by chunk until none are left or the time budget is spent, so a large backlog
+      # never pins a Sidekiq thread past its shutdown window. CleanupExpiredJob schedules the next run while
+      # `more_remaining` is true.
+      #
+      # Safe to delete without callbacks: nothing references cm_audit_events (checked in cm-market-server/db/schema.rb).
+      # Errors are not rescued on purpose: a failed drain must surface to Sidekiq (retry + alert), not end quietly.
+      def call(batch_size: BATCH_SIZE, time_budget: TIME_BUDGET)
+        started_at = monotonic_now
+        deleted_count = 0
+        batches = 0
+        more_remaining = false
+
+        loop do
+          deleted = delete_expired_chunk(batch_size)
+          deleted_count += deleted
+          batches += 1 if deleted.positive?
+
+          break if deleted < batch_size
+
+          if monotonic_now - started_at >= time_budget.to_f
+            more_remaining = true
+            break
+          end
+        end
+
+        elapsed_ms = ((monotonic_now - started_at) * 1000).round
+        log_completion(deleted_count: deleted_count, batches: batches, elapsed_ms: elapsed_ms, more_remaining: more_remaining)
+
+        success(deleted_count: deleted_count, batches: batches, more_remaining: more_remaining)
+      end
+
+      private
+
+      # One `DELETE ... WHERE id IN (SELECT id ... LIMIT n)`: no rows are loaded into Ruby.
+      def delete_expired_chunk(batch_size)
+        SpreeCmCommissioner::AuditEvent
+          .where(id: SpreeCmCommissioner::AuditEvent.expired.limit(batch_size).select(:id))
+          .delete_all
+      end
+
+      def monotonic_now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def log_completion(**data)
+        CmAppLogger.log(label: 'SpreeCmCommissioner::AuditEvents::CleanupExpired completed', data: data)
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/audit_logger.rb

@@ -30,7 +30,7 @@ module SpreeCmCommissioner
         attempt: 0,
         retention_days: nil
       )
-        retention_until = (retention_days || 90).days.from_now.to_date
+        retention_until = (retention_days || SpreeCmCommissioner::AuditEvent::DEFAULT_RETENTION_DAYS).days.from_now.to_date
 
         SpreeCmCommissioner::AuditEventJob.perform_later(
           event_type: event_type,

data/app/services/spree_cm_commissioner/integrations/book_me_bus_v1/polling/sync_seat_layout.rb

@@ -116,34 +116,31 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
 
       # vehicle_type is a shared BookMeBus category (many different physical buses/trips can
       # report the same vehicle_type_id), but the seat map we just fetched is specific to one
-      # trip's stop segment. Re-writing this shared template on every poll means whichever trip
-      # synced last silently overwrites (and, via cleanup_stale_blocks!, deletes seats from) the
-      # template every other trip of that vehicle_type duplicates from on creation. Only seed it
-      # once; each trip's own duplicated SeatLayout is what stays continuously in sync afterward
-      # (see duplicate_to_trip_if_needed!/sync_trip_seat_layout!).
+      # trip's stop segment. Adding or deleting seats on this shared template on every poll would let
+      # whichever trip synced last rewrite the template every other trip duplicates from, so its seats
+      # are only created once. Its geometry (sections, padding, spacing) is re-applied every time though,
+      # so templates synced before the builder standard heal on their next sync.
       if seat_layout.persisted?
+        apply_builder_layout!(seat_layout, external_seat_layout, create_missing: false)
         backfill_vehicle_type_seats!(vehicle_type, seat_layout)
         return seat_layout
       end
 
-      # Calculate dimensions based on layout
-      dimensions = calculate_layout_dimensions(external_seat_layout)
+      builder_layout = external_seat_layout.builder_layout
 
-      # Update seat layout attributes
       @sync_result.track(:seat_layout, seat_layout) do |tracker|
         seat_layout.assign_attributes(
           name: build_seat_layout_name(vehicle_type, external_seat_layout),
           status: :active,
-          width: dimensions[:width],
-          height: dimensions[:height],
+          width: builder_layout[:width],
+          height: builder_layout[:height],
           total_seats: external_seat_layout.seats.count,
           layoutable: vehicle_type
         )
         tracker.save_if_changed!(seat_layout)
       end
 
-      # Sync blocks (seats) for this layout - no variant for templates
-      sync_blocks!(seat_layout: seat_layout, external_seat_layout: external_seat_layout, variant: nil)
+      apply_builder_layout!(seat_layout, external_seat_layout, create_missing: true)
 
       backfill_vehicle_type_seats!(vehicle_type, seat_layout)
 
@@ -219,6 +216,8 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
 
       return if trip_seat_layout.blank?
 
+      apply_builder_layout!(trip_seat_layout, external_seat_layout, create_missing: false)
+
       # Assign variants to sellable blocks
       trip_seat_layout.blocks.each do |block|
         next unless block.sellable?
@@ -245,134 +244,52 @@ module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
       "#{vehicle_type.name} Layout (#{seat_count} seats)"
     end
 
-    # Calculate layout dimensions based on external seat layout
+    # Lays the seats out exactly as the BookMe+ seat layout builder would (Resources::SeatLayout#builder_layout): one
+    # section per BookMeBus layer, named with the layer key (UnstockInventory sends it back as the reservation layer),
+    # seats matched by label so block ids, variants and reserved blocks survive. Idempotent: positions are a pure
+    # function of BookMeBus's grid, so a re-sync writes nothing once a layout matches.
     #
-    # @param external_seat_layout [Resources::SeatLayout]
-    # @return [Hash] Hash with :width and :height keys
-    def calculate_layout_dimensions(external_seat_layout)
-      block_width = 50
-      block_height = 50
-      gap = 10
-      padding = 200
-      layer_gap = 100
-
-      rows = external_seat_layout.row_count
-      columns = external_seat_layout.column_count
-      layer_count = external_seat_layout.primary_layout.keys.count
-
-      # Layers (e.g. lower/upper deck) sit side by side, not stacked - see
-      # Resources::SeatLayout#to_internal_blocks_attributes for the matching block placement.
-      width = (layer_count * columns * (block_width + gap)) + ((layer_count - 1) * layer_gap) + padding
-      height = (rows * (block_height + gap)) + padding
-
-      { width: width, height: height }
-    end
-
-    # Sync blocks for a seat layout
-    #
-    # This method creates or updates Block records from the external seat layout.
-    # It handles multi-layer layouts (e.g., double-decker buses) and assigns
-    # coordinates based on row/column positions.
-    #
-    # @param seat_layout [SpreeCmCommissioner::SeatLayout] The internal seat layout
-    # @param external_seat_layout [Resources::SeatLayout] External seat layout data
-    # @param variant [Spree::Variant] Optional variant to assign to blocks
-    def sync_blocks!(seat_layout:, external_seat_layout:, variant: nil)
-      # Get block attributes from external layout
-      blocks_attrs = external_seat_layout.to_internal_blocks_attributes(seat_layout)
-
-      # Track existing blocks by label for updates
-      existing_blocks = seat_layout.blocks.index_by(&:label)
-      seat_sections_by_layer = build_seat_sections_by_layer(seat_layout, blocks_attrs)
-
-      blocks_attrs.each do |block_attrs|
-        label = block_attrs[:label]
-        block = existing_blocks[label] || seat_layout.blocks.build
-        section = seat_sections_by_layer[block_attrs.dig(:metadata, :layer)]
-
-        @sync_result.track(:block, block) do |tracker|
-          # Only assign variant to sellable blocks (seat, sleeping_seat, standing)
-          block_variant = SpreeCmCommissioner::Block.sellable?(block_attrs[:block_type]) ? variant : nil
-
-          block.assign_attributes(
-            label: block_attrs[:label],
-            block_type: block_attrs[:block_type],
-            width: block_attrs[:width],
-            height: block_attrs[:height],
-            # cm-block renders position:absolute inside its parent cm-seat-section (also
-            # position:absolute), so a sectioned block's x/y must be relative to the section's
-            # own origin - not the canvas-absolute value every block starts with - or the section's
-            # offset gets applied twice and seats render far outside their section.
-            x: block_attrs[:x] - (section&.x || 0),
-            y: block_attrs[:y] - (section&.y || 0),
-            rotation: block_attrs[:rotation],
-            seat_layout: seat_layout,
-            seat_section: section,
-            variant: block_variant
-          )
-
-          tracker.save_if_changed!(block)
+    # create_missing: true builds a new template's seats; false only re-positions seats that already exist (a shared
+    # template or a trip copy must not gain or lose seats from one trip's segment).
+    def apply_builder_layout!(seat_layout, external_seat_layout, create_missing:)
+      builder_layout = external_seat_layout.builder_layout
+      blocks_by_label = seat_layout.blocks.index_by(&:label)
+
+      builder_layout[:sections].each do |section_attrs|
+        section = sync_seat_section!(seat_layout, section_attrs)
+
+        section_attrs[:blocks].each do |block_attrs|
+          block = blocks_by_label[block_attrs[:label]] || (seat_layout.blocks.build if create_missing)
+          next if block.nil?
+
+          @sync_result.track(:block, block) do |tracker|
+            block.assign_attributes(
+              block_attrs.slice(:label, :block_type, :width, :height, :x, :y, :rotation).merge(seat_layout: seat_layout, seat_section: section)
+            )
+            tracker.save_if_changed!(block)
+          end
         end
       end
 
-      # Remove blocks that no longer exist in the external layout
-      cleanup_stale_blocks!(seat_layout: seat_layout, synced_labels: blocks_attrs.pluck(:label))
-    end
+      remove_empty_stale_sections!(seat_layout, builder_layout[:sections].pluck(:name))
 
-    # A single-layer bus (the overwhelming common case - "BUS" only) keeps its blocks
-    # top-level (no seat_section), matching prior behavior exactly. Only a genuinely
-    # multi-layer layout (double-decker: "BUS" + "UPPER_DECK") gets one SeatSection per
-    # layer, so `block.seat_section&.name` reports the real deck instead of always
-    # falling back to the 'BUS' default UnstockInventory uses when it's nil. A single layer's real name is
-    # kept in the template mapping's `layers` payload instead - UnstockInventory#single_layer_name reads it.
-    #
-    # @return [Hash{String => SpreeCmCommissioner::SeatSection}] section per layer name
-    def build_seat_sections_by_layer(seat_layout, blocks_attrs)
-      attrs_by_layer = blocks_attrs.group_by { |attrs| attrs.dig(:metadata, :layer) }
-      return {} if attrs_by_layer.size <= 1
-
-      attrs_by_layer.each_with_object({}) do |(layer_name, attrs_for_layer), sections|
-        next if layer_name.blank?
-
-        sections[layer_name] = find_or_build_seat_section!(seat_layout, layer_name, attrs_for_layer)
+      @sync_result.track(:seat_layout, seat_layout) do |tracker|
+        seat_layout.assign_attributes(width: builder_layout[:width], height: builder_layout[:height])
+        tracker.save_if_changed!(seat_layout)
       end
     end
 
-    # Section geometry is a bounding box around its layer's blocks so it renders sanely,
-    # not just a placeholder - SeatSection requires positive width/height.
-    def find_or_build_seat_section!(seat_layout, layer_name, attrs_for_layer)
-      section = seat_layout.seat_sections.find_or_initialize_by(name: layer_name)
-
-      min_x = attrs_for_layer.pluck(:x).min
-      min_y = attrs_for_layer.pluck(:y).min
-      max_x = attrs_for_layer.map { |a| a[:x] + a[:width] }.max
-      max_y = attrs_for_layer.map { |a| a[:y] + a[:height] }.max
-
-      section.assign_attributes(x: min_x, y: min_y, width: max_x - min_x, height: max_y - min_y, rotation: 0)
+    def sync_seat_section!(seat_layout, section_attrs)
+      section = seat_layout.seat_sections.find_or_initialize_by(name: section_attrs[:name])
+      section.assign_attributes(section_attrs.slice(:x, :y, :width, :height).merge(rotation: 0))
       section.save! if section.new_record? || section.changed?
       section
     end
 
-    # Remove blocks that are no longer in the external layout
-    #
-    # @param seat_layout [SpreeCmCommissioner::SeatLayout] The seat layout
-    # @param synced_labels [Array<String>] Labels of blocks that were synced
-    def cleanup_stale_blocks!(seat_layout:, synced_labels:)
-      synced_labels_set = synced_labels.to_set
-
-      seat_layout.blocks.each do |block|
-        next if synced_labels_set.include?(block.label)
-
-        # Only delete blocks that don't have active reservations
-        if block.respond_to?(:all_reserved_blocks) && block.all_reserved_blocks.reserved_or_on_hold.exists?
-          Rails.logger.warn("[SyncSeatLayout] Skipping deletion of block #{block.label} - has active reservations")
-          next
-        end
-
-        @sync_result.track(:block, block) do |_tracker|
-          block.destroy!
-          @sync_result.increment_metric(:block, :deleted)
-        end
+    # A layer BookMeBus no longer reports. Kept while it still holds seats, so nothing with a reservation disappears.
+    def remove_empty_stale_sections!(seat_layout, layer_names)
+      seat_layout.seat_sections.where.not(name: layer_names).find_each do |section|
+        section.destroy! if section.blocks.empty?
       end
     end
 

data/app/services/spree_cm_commissioner/integrations/book_me_bus_v1/resources/seat_layout.rb

@@ -36,22 +36,6 @@ module SpreeCmCommissioner
       #   Row 1: [5] [6] [aisle] [7] [8]
       #
       class SeatLayout
-        # Layout rendering constants
-        BLOCK_WIDTH = 50
-        BLOCK_HEIGHT = 50
-        BLOCK_GAP = 10
-        # Gap between layers (e.g. lower/upper deck) placed side by side - see
-        # #to_internal_blocks_attributes. Matches SyncSeatLayout#calculate_layout_dimensions's
-        # own `layer_gap`, kept as a literal there too for the same reason noted on
-        # LAYER_TOP_MARGIN below.
-        LAYER_GAP = 100
-        DEFAULT_CANVAS_WIDTH = 400
-        DEFAULT_CANVAS_HEIGHT = 400
-        # Matches SyncSeatLayout#calculate_layout_dimensions's own `padding` - kept as a literal
-        # there too since that method already owns the canvas height/width calculation and this is
-        # the one place outside it that also needs the same top-margin value.
-        LAYER_TOP_MARGIN = 100
-
         attr_reader :id, :from_stop_id, :to_stop_id, :on_date, :duration,
                     :min_number_of_seats_remaining, :number_of_seats_remaining,
                     :layouts, :stop_times, :trip
@@ -183,39 +167,6 @@ module SpreeCmCommissioner
           seats.group_by(&:seat_type)
         end
 
-        # Get the number of rows in the layout
-        #
-        # @return [Integer] Number of rows in the primary layout
-        #
-        # Example:
-        #   # Layout with 12 rows:
-        #   # Row 0:  [1] [2] [aisle] [3] [4]
-        #   # Row 1:  [5] [6] [aisle] [7] [8]
-        #   # ...
-        #   # Row 11: [45] [46] [aisle] [47] [48]
-        #
-        #   seat_layout.row_count  # => 12
-        #
-        def row_count
-          primary_layout.values.first&.size || 0
-        end
-
-        # Get the number of columns in the layout (including aisles)
-        #
-        # @return [Integer] Number of columns in the first row
-        #
-        # Example:
-        #   # Layout: [seat, seat, aisle, seat, seat]
-        #   seat_layout.column_count  # => 5
-        #
-        #   # Layout: [seat, seat, aisle, seat]
-        #   seat_layout.column_count  # => 4
-        #
-        def column_count
-          first_row = primary_layout.values.first&.first
-          first_row&.size || 0
-        end
-
         # Get count of available seats (status = 0)
         #
         # @return [Integer] Number of seats with status 0 (available)
@@ -231,84 +182,32 @@ module SpreeCmCommissioner
           seats.count(&:available?)
         end
 
-        # Convert BookMeBus seat layout to BookMe+ Block attributes
-        #
-        # Transforms the 2D seat layout into an array of block hashes ready for
-        # creating SpreeCmCommissioner::Block records. Each seat becomes a block
-        # with calculated x,y coordinates based on its row/column position.
-        #
-        # Coordinate Calculation:
-        #   x = column_index * (block_width + gap)
-        #   y = row_index * (block_height + gap)
-        #
-        # @param seat_layout [SpreeCmCommissioner::SeatLayout] The internal seat layout model
-        # @return [Array<Hash>] Array of block attribute hashes
-        #
-        # Example:
-        #   internal_layout = SpreeCmCommissioner::SeatLayout.create!(
-        #     name: "VIP Bus Layout",
-        #     layoutable: vehicle_type
-        #   )
-        #
-        #   blocks_attrs = external_seat_layout.to_internal_blocks_attributes(internal_layout)
-        #   # => [
-        #   #   {
-        #   #     label: "1",
-        #   #     block_type: :seat,
-        #   #     width: 50, height: 50,
-        #   #     x: 0, y: 0,  # Row 0, Column 0
-        #   #     rotation: 0,
-        #   #     seat_layout: internal_layout
-        #   #   },
-        #   #   {
-        #   #     label: "2",
-        #   #     block_type: :seat,
-        #   #     width: 50, height: 50,
-        #   #     x: 60, y: 0,  # Row 0, Column 1 (50 + 10 gap)
-        #   #     rotation: 0,
-        #   #     seat_layout: internal_layout
-        #   #   },
-        #   #   # Column 2 (aisle) is skipped
-        #   #   {
-        #   #     label: "3",
-        #   #     block_type: :seat,
-        #   #     width: 50, height: 50,
-        #   #     x: 180, y: 0,  # Row 0, Column 3
-        #   #     rotation: 0,
-        #   #     seat_layout: internal_layout
-        #   #   }
-        #   # ]
-        #
-        #   # Create blocks
-        #   blocks_attrs.each { |attrs| SpreeCmCommissioner::Block.create!(attrs) }
-        #
-        # Visual Layout:
-        #   (0,0)     (60,0)    (180,0)   (240,0)
-        #     [1]       [2]    [aisle]     [3]       [4]
-        #
-        #   (0,60)    (60,60)  (180,60)  (240,60)
-        #     [5]       [6]    [aisle]     [7]       [8]
-        #
-        def to_internal_blocks_attributes(seat_layout)
-          blocks = []
-          offsets = calculate_centering_offsets(seat_layout)
-          # Assumes every layer shares the first layer's column count, same as
-          # #calculate_centering_offsets and SyncSeatLayout#calculate_layout_dimensions.
-          layer_width = column_count * (BLOCK_WIDTH + BLOCK_GAP)
-          current_layer_x_offset = 0
+        # The layout as the BookMe+ seat layout builder would draw it (see SeatLayouts::Grid), so synced layouts look
+        # like hand-built ones: one section per layer, in BookMeBus's order, named with its layer key (UnstockInventory
+        # sends that name back as the reservation `layer`). Each layer is measured on its own. In a layer with sleepers
+        # every BookMeBus row takes two grid rows, so a sleeper is 40x90 like the builder's "Sleeping seat".
+        #
+        # @return [Hash] { width:, height:, sections: [{ name:, x:, y:, width:, height:, blocks: [...] }] }, block x/y
+        #   relative to their section
+        def builder_layout
+          @builder_layout ||= build_builder_layout
+        end
 
-          primary_layout.each do |layer_name, rows|
-            process_layer_rows(rows, layer_name, blocks, offsets, current_layer_x_offset, seat_layout)
+        private
 
-            # Place the next layer to the right, so double-decker buses show their decks
-            # side by side instead of one on top of the other.
-            current_layer_x_offset += layer_width + LAYER_GAP
+        def build_builder_layout
+          layers = primary_layout.map { |layer_name, rows| [layer_name, Array(rows)] }
+          sizes = layers.map do |_, rows|
+            grid.section_size(rows: rows.size * rows_per_seat_row(rows), columns: rows.map { |row| Array(row).size }.max.to_i)
           end
+          origins = grid.section_origins(sizes)
 
-          blocks
-        end
+          sections = layers.each_with_index.map do |(layer_name, rows), index|
+            { name: layer_name, **origins[index], **sizes[index], blocks: section_blocks(layer_name, rows) }
+          end
 
-        private
+          { **grid.canvas_size(sections), sections: sections }
+        end
 
         def extract_seats_from_layout(layout)
           seats = []
@@ -332,45 +231,34 @@ module SpreeCmCommissioner
           seats
         end
 
-        # x centers the *whole* row of side-by-side layers within the canvas width (canvas_width
-        # already accounts for every layer's width plus the gaps between them - see
-        # SyncSeatLayout#calculate_layout_dimensions). For a single-layer bus this simplifies to
-        # exactly the old single-layer centering, so that overwhelmingly common case is
-        # unaffected. y is just a small constant top margin - layers don't stack vertically, so
-        # there's no per-layer vertical slot to account for.
-        def calculate_centering_offsets(seat_layout)
-          layer_count = primary_layout.keys.count
-          layer_width = column_count * (BLOCK_WIDTH + BLOCK_GAP)
-          total_width = (layer_count * layer_width) + ((layer_count - 1) * LAYER_GAP)
-          canvas_width = seat_layout.width || DEFAULT_CANVAS_WIDTH
+        def grid
+          SpreeCmCommissioner::SeatLayouts::Grid
+        end
 
-          {
-            x: ((canvas_width - total_width) / 2.0).round,
-            y: LAYER_TOP_MARGIN
-          }
+        def rows_per_seat_row(rows)
+          rows.flatten.compact.any? { |seat_data| Seat.new(seat_data).block_type == :sleeping_seat } ? 2 : 1
         end
 
-        def process_layer_rows(rows, layer_name, blocks, offsets, layer_x_offset, seat_layout) # rubocop:disable Metrics/ParameterLists
-          rows.each_with_index do |row, row_idx|
-            row.each_with_index do |seat_data, col_idx|
-              next if seat_data.nil? # Skip aisles
+        def section_blocks(layer_name, rows)
+          row_unit = rows_per_seat_row(rows)
+
+          rows.each_with_index.flat_map do |row, row_idx|
+            Array(row).each_with_index.filter_map do |seat_data, col_idx|
+              next if seat_data.nil? # aisle or gap
 
               seat = Seat.new(seat_data)
-              blocks << build_block_attributes(seat, layer_name, row_idx, col_idx, offsets, layer_x_offset, seat_layout)
+              rect = grid.block_rect(row: row_idx * row_unit, column: col_idx, row_span: seat.block_type == :sleeping_seat ? 2 : 1)
+              build_block_attributes(seat, layer_name, rect)
             end
           end
         end
 
-        def build_block_attributes(seat, layer_name, row_idx, col_idx, offsets, layer_x_offset, seat_layout) # rubocop:disable Metrics/ParameterLists
+        def build_block_attributes(seat, layer_name, rect)
           {
             label: seat.label,
             block_type: seat.block_type,
-            width: BLOCK_WIDTH,
-            height: BLOCK_HEIGHT,
-            x: (col_idx * (BLOCK_WIDTH + BLOCK_GAP)) + layer_x_offset + offsets[:x],
-            y: (row_idx * (BLOCK_HEIGHT + BLOCK_GAP)) + offsets[:y],
             rotation: 0,
-            seat_layout: seat_layout,
+            **rect,
             metadata: {
               layer: layer_name,
               seat_type: seat.seat_type,

data/app/services/spree_cm_commissioner/inventory_items/reset.rb

@@ -4,31 +4,35 @@ module SpreeCmCommissioner
       prepend ::Spree::ServiceModule::Base
       extend SpreeCmCommissioner::ServiceModuleThrowable
 
-      def call(inventory_item:)
-        max_capacity = variant_total_inventory(inventory_item)
-        total_purchases = variant_total_purchases(inventory_item)
-        # Everything an operator has taken off public sale, by either mechanism: one ReservedBlock per
-        # seat for seat-selection products, and quantity_locked for everything else. Both must be
-        # subtracted or a reset hands withheld units straight back to the public.
-        #
-        # locked_count is self-healing because the rows ARE the record of what was deducted.
-        # quantity_locked is not — it is a counter with no rows behind it, so a reset preserves it
-        # rather than recomputing it. It is deliberately left out of the update below.
-        total_locked = inventory_item.locked_count + inventory_item.quantity_locked
-        quantity_available = [max_capacity - total_purchases - total_locked, 0].max
-        quantity_on_hold, quantity_locked_on_hold = variant_total_on_hold(inventory_item)
-
-        updated = inventory_item.update(
-          max_capacity: max_capacity,
-          quantity_available: quantity_available,
-          quantity_on_hold: quantity_on_hold,
-          quantity_locked_on_hold: quantity_locked_on_hold
-        )
-        return failure(nil, :failed_to_update_inventory_item) unless updated
+      # Fails with this as its value when the item's Redis counts moved while it was being recounted, so a bulk
+      # recount can tell "selling right now, try again" apart from a real failure.
+      BUSY = :busy
 
-        reset_redis_inventory(inventory_item)
+      # Recounts under the item's row lock, so a concurrent adjust_quantity! or BulkAdjustQuantities* write
+      # can't land between the read and the update and be overwritten.
+      #
+      # The row lock doesn't stop holds: InventoryHolds::Acquire increments Redis inside a transaction that
+      # commits later, and booking is enforced from Redis. A recount that overwrote Redis from the committed
+      # holds it read would hand an in-flight hold's units back to public sale. So Redis is snapshotted before
+      # the counts are read and written only if no key moved since (see #write_redis); otherwise the DB update
+      # is rolled back and this fails with BUSY. What's left is a hold whose Redis increment lands before the
+      # snapshot and whose commit lands after the counts are read: one hold's commit latency, not the recount's.
+      def call(inventory_item:)
+        outcome = nil
+
+        # requires_new, as in MoveToLocked: a Rollback in a bare nested transaction is swallowed, which would
+        # keep the DB counts of a recount whose Redis write was refused.
+        inventory_item.transaction(requires_new: true) do
+          inventory_item.lock!
+          outcome = recount_and_write_redis(inventory_item)
+          raise ActiveRecord::Rollback unless outcome == :reset
+        end
 
-        success(nil)
+        case outcome
+        when :reset then success(nil)
+        when BUSY then failure(BUSY, I18n.t('inventory_item.reset.busy'))
+        else failure(nil, outcome)
+        end
       end
 
       def variant_total_inventory(inventory_item)
@@ -60,12 +64,12 @@ module SpreeCmCommissioner
       # A locked-stock line holds against the locked counter, so counting it here would inflate the
       # public one and under-report public availability: exactly the drift this service exists to
       # correct.
+      #
+      # Active holds as a subquery rather than plucked ids: a bulk recount runs this per item, and every
+      # active hold in the system would otherwise be loaded each time.
       def variant_total_on_hold(inventory_item)
-        active_hold_order_ids = SpreeCmCommissioner::InventoryHold.active_or_payment_locked.pluck(:order_id)
-        return [0, 0] if active_hold_order_ids.empty?
-
         scope = Spree::LineItem
-                .where(order_id: active_hold_order_ids)
+                .where(order_id: SpreeCmCommissioner::InventoryHold.active_or_payment_locked.select(:order_id))
                 .joins(variant: :inventory_items)
                 .where(cm_inventory_items: { id: inventory_item.id })
 
@@ -85,18 +89,82 @@ module SpreeCmCommissioner
 
       private
 
+      # Runs inside the locked transaction. The snapshot comes first: one taken after the counts are read would
+      # already include a hold those counts missed, and the write would pass.
+      def recount_and_write_redis(inventory_item)
+        snapshot = redis_values(inventory_item)
+        return :failed_to_update_inventory_item unless recount(inventory_item)
+        return BUSY unless write_redis(inventory_item, snapshot)
+
+        :reset
+      end
+
+      def recount(inventory_item)
+        max_capacity = variant_total_inventory(inventory_item)
+        total_purchases = variant_total_purchases(inventory_item)
+        # Everything an operator has taken off public sale, by either mechanism: one ReservedBlock per
+        # seat for seat-selection products, and quantity_locked for everything else. Both must be
+        # subtracted or a reset hands withheld units straight back to the public.
+        #
+        # locked_count is self-healing because the rows ARE the record of what was deducted.
+        # quantity_locked is not — it is a counter with no rows behind it, so a reset preserves it
+        # rather than recomputing it. It is deliberately left out of the update below.
+        total_locked = inventory_item.locked_count + inventory_item.quantity_locked
+        quantity_available = [max_capacity - total_purchases - total_locked, 0].max
+        quantity_on_hold, quantity_locked_on_hold = variant_total_on_hold(inventory_item)
+
+        inventory_item.update(
+          max_capacity: max_capacity,
+          quantity_available: quantity_available,
+          quantity_on_hold: quantity_on_hold,
+          quantity_locked_on_hold: quantity_locked_on_hold
+        )
+      end
+
+      # Both pools, in the order #write_redis takes them.
+      def redis_keys(inventory_item)
+        [
+          inventory_item.redis_key, inventory_item.redis_hold_key,
+          inventory_item.redis_key(locked: true), inventory_item.redis_hold_key(locked: true)
+        ]
+      end
+
+      # '' for a missing key, which is what the script compares a missing key as.
+      def redis_values(inventory_item)
+        SpreeCmCommissioner.inventory_redis_pool.with { |redis| redis.mget(*redis_keys(inventory_item)) }.map(&:to_s)
+      end
+
       # Reseeds BOTH pools. Leaving the locked keys stale would let an agent's allotment drift away
       # from the row that a reset just corrected — and since availability is read from Redis, the
       # stale value is the one that would be enforced.
-      def reset_redis_inventory(inventory_item)
-        ttl = inventory_item.redis_expired_in
-
-        SpreeCmCommissioner.inventory_redis_pool.with do |redis|
-          redis.setex(inventory_item.redis_key, ttl, inventory_item.quantity_available)
-          redis.setex(inventory_item.redis_hold_key, ttl, inventory_item.quantity_on_hold)
-          redis.setex(inventory_item.redis_key(locked: true), ttl, inventory_item.quantity_locked)
-          redis.setex(inventory_item.redis_hold_key(locked: true), ttl, inventory_item.quantity_locked_on_hold)
+      #
+      # Atomically, and only while every key still holds its snapshot: a hold, release or sale since then has
+      # moved one, and the counts just read may not include it.
+      def write_redis(inventory_item, snapshot)
+        values = [
+          inventory_item.quantity_available, inventory_item.quantity_on_hold,
+          inventory_item.quantity_locked, inventory_item.quantity_locked_on_hold
+        ]
+
+        result = SpreeCmCommissioner.inventory_redis_pool.with do |redis|
+          redis.eval(compare_and_set_script, keys: redis_keys(inventory_item), argv: [*snapshot, *values, inventory_item.redis_expired_in])
         end
+
+        result == 1
+      end
+
+      def compare_and_set_script
+        <<~LUA
+          -- ARGV = [snapshot_1..snapshot_n, value_1..value_n, ttl]
+          local n = #KEYS
+          for i = 1, n do
+            if (redis.call('GET', KEYS[i]) or '') ~= ARGV[i] then return 0 end
+          end
+          for i = 1, n do
+            redis.call('SET', KEYS[i], ARGV[n + i], 'EX', tonumber(ARGV[2 * n + 1]))
+          end
+          return 1
+        LUA
       end
     end
   end

data/app/services/spree_cm_commissioner/rates_availabilities/bulk_update.rb

@@ -22,6 +22,9 @@ module SpreeCmCommissioner
 
       ACTIONS = %w[set_price use_base_price set_stock reset_stock close reopen].freeze
 
+      # Each recount takes its date's row lock and runs a few queries, one date after another in the request.
+      MAX_RECOUNT = 200
+
       def call(product:, store:, cells:, action:, values: {}, user: nil) # rubocop:disable Metrics/ParameterLists
         @product = product
         @store = store
@@ -46,7 +49,7 @@ module SpreeCmCommissioner
         end
 
         updated = send(action)
-        success(updated: updated, skipped: cells.size - updated)
+        success({ updated: updated, skipped: cells.size - updated, busy: @busy }.compact)
       rescue ActiveRecord::RecordInvalid, ArgumentError => e
         failure(nil, e.message)
       end
@@ -115,17 +118,20 @@ module SpreeCmCommissioner
       end
 
       # Rebuilds each date's available and on-hold counts from stock items and orders (InventoryItems::Reset), for
-      # when they've drifted. Base resets the undated item a product without dates sells from.
+      # when they've drifted, and undoes stock set on the date (Use Base stock). Base resets the undated item a
+      # product without dates sells from.
+      #
+      # A date being booked while it's recounted is left as it was and counted in `busy`, so the rest still apply.
       def reset_stock
         items = stock_cells.filter_map { |cell| cell[:inventory_item] || undated_inventory_item(cell[:variant]) }
-        errors = items.filter_map do |item|
-          result = InventoryItems::Reset.call(inventory_item: item)
-          result.error.to_s unless result.success?
-        end
+        raise ArgumentError, I18n.t('rates_availabilities.bulk.recount_limit', max: MAX_RECOUNT) if items.size > MAX_RECOUNT
 
-        raise ArgumentError, errors.uniq.to_sentence if errors.any?
+        results = items.map { |item| InventoryItems::Reset.call(inventory_item: item) }
+        busy, failed = results.reject(&:success?).partition { |result| result.value == InventoryItems::Reset::BUSY }
+        raise ArgumentError, failed.map { |result| result.error.to_s }.uniq.to_sentence if failed.any?
 
-        items.size
+        @busy = busy.size if busy.any?
+        items.size - busy.size
       end
 
       def undated_inventory_item(variant)

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

@@ -0,0 +1,56 @@
+module SpreeCmCommissioner
+  module SeatLayouts
+    # The geometry the BookMe+ seat layout builder ("Add Section") produces, so a generated layout looks exactly like a
+    # hand-built one. Keep in step with cm-market-server: SeatLayoutable#block_types (block_size/spacing) and the builder
+    # JS in vendor/javascript/lit_components: cm_seat_section_grid_builder_modal/services/{assign_block,get_section_size}.js,
+    # cm_seat_layout_builder/services/get_new_section_position.js and models/seat_layout.js#calculateElementBounds.
+    module Grid
+      BLOCK_SIZE = 40
+      SPACING = 10
+
+      module_function
+
+      # A block at grid (row, column) inside its section; x/y are relative to the section's origin.
+      def block_rect(row:, column:, row_span: 1, column_span: 1)
+        {
+          x: (column * BLOCK_SIZE) + ((column + 1) * SPACING),
+          y: (row * BLOCK_SIZE) + ((row + 1) * SPACING),
+          width: span_size(column_span),
+          height: span_size(row_span)
+        }
+      end
+
+      def section_size(rows:, columns:)
+        {
+          width: (columns * (BLOCK_SIZE + SPACING)) + SPACING,
+          height: (rows * (BLOCK_SIZE + SPACING)) + SPACING
+        }
+      end
+
+      # Sections sit side by side, left to right, SPACING apart and SPACING from the canvas edge.
+      def section_origins(sizes)
+        x = SPACING
+
+        sizes.map do |size|
+          origin = { x: x, y: SPACING }
+          x += size[:width] + SPACING
+          origin
+        end
+      end
+
+      # The canvas wraps its sections with the same margin on every side (their smallest x/y).
+      def canvas_size(rects)
+        return { width: 0, height: 0 } if rects.empty?
+
+        {
+          width: rects.map { |rect| rect[:x] + rect[:width] }.max + rects.pluck(:x).min,
+          height: rects.map { |rect| rect[:y] + rect[:height] }.max + rects.pluck(:y).min
+        }
+      end
+
+      def span_size(span)
+        (BLOCK_SIZE * span) + (SPACING * (span - 1))
+      end
+    end
+  end
+end

data/app/views/spree/admin/inventory_items/_details.html.erb

@@ -54,3 +54,19 @@
     <%= render 'spree/admin/rates_availabilities/list_pages', records: inventory_items %>
   <% end %>
 </div>
+
+<%# Every row, across pages. Over BulkUpdate's cap it's turned off rather than refused after the confirm. %>
+<% if inventory_items.any? %>
+  <% max_recount = SpreeCmCommissioner::RatesAvailabilities::BulkUpdate::MAX_RECOUNT %>
+  <% too_many = inventory_items.total_count > max_recount %>
+  <div class="modal-footer">
+    <small class="mr-auto text-muted" data-ra-recount-all-hint>
+      <%= svg_icon name: 'info-circle.svg', width: '13', height: '13' %> <%= t('rates_availabilities.stock_details.recount_all_hint') %>
+      <% if too_many %><br><%= t('rates_availabilities.stock_details.recount_all_limit', max: max_recount) %><% end %>
+    </small>
+    <button type="button" class="btn btn-outline-secondary text-nowrap" data-ra-recount-all <%= 'disabled' if too_many %>
+            data-ra-confirm="<%= t('rates_availabilities.stock_details.recount_all_confirm', count: inventory_items.total_count) %>">
+      <%= svg_icon name: 'arrow-counterclockwise.svg', width: '14', height: '14' %> <%= t('rates_availabilities.stock_details.recount_all') %>
+    </button>
+  </div>
+<% end %>

data/app/views/spree/admin/rates_availabilities/_script.html.erb

@@ -6,6 +6,8 @@
       selected: t('rates_availabilities.bulk.selected'),
       saving: t('rates_availabilities.bulk.saving'),
       done: t('rates_availabilities.bulk.done'),
+      busy: t('rates_availabilities.bulk.busy'),
+      useBaseStockConfirm: t('rates_availabilities.bulk.use_base_stock_confirm'),
       failed: t('rates_availabilities.modal.failed')
     }.to_json) %>;
 
@@ -228,7 +230,8 @@
       // close each rate on its own, and they'd stay closed after the date is reopened from its stock cell alone. A
       // price cell closed only by its date or the base rate (ra-closed-day alone) is in neither: it has no closing
       // of its own to reopen, and closing it would add one that shows only once those reopen.
-      // `datePrices` have their own price for the date, which Use Base price clears.
+      // `datePrices` have their own price for the date, which Use Base price clears. `dateStock` is what Use Base
+      // stock recounts: Base stock has nothing to fall back to.
       groups() {
         const cells = this.cells();
         const ofType = (type) => cells.filter((cell) => cell.dataset.cell === type);
@@ -247,7 +250,8 @@
           prices: prices,
           open: dated.filter((cell) => !isClosed(cell) && closesOnItsOwn(cell)),
           closed: dated.filter(isClosed),
-          datePrices: prices.filter((cell) => cell.classList.contains('ra-date-price'))
+          datePrices: prices.filter((cell) => cell.classList.contains('ra-date-price')),
+          dateStock: stock.filter((cell) => cell.dataset.date)
         };
       }
 
@@ -341,8 +345,9 @@
         this.load();
       }
 
-      // A newer request wins, as answers can arrive out of order while the search is typed.
-      load() {
+      // A newer request wins, as answers can arrive out of order while the search is typed. `notice` ({ text, level })
+      // goes above the reloaded list: the bulk bar, where a save reports, is under the modal.
+      load(notice = null) {
         const content = this.sharedModal.content;
         const seq = ++this.seq;
         const current = () => seq === this.seq && this.isShown;
@@ -359,6 +364,14 @@
           content.innerHTML = html;
           // Sync icons are popovers on stock managements, which nothing initializes in fetched HTML.
           content.querySelectorAll('[data-toggle="popover"]').forEach((el) => { el.title = el.dataset.content; });
+          const body = content.querySelector('.modal-body');
+          if (notice && body) {
+            const alert = document.createElement('div');
+            alert.className = 'alert alert-' + notice.level + ' py-2 small';
+            alert.setAttribute('role', 'status');
+            alert.textContent = notice.text;
+            body.prepend(alert);
+          }
           const search = content.querySelector('[data-ra-list-search]');
           if (searching && search) {
             search.focus();
@@ -424,6 +437,8 @@
         content.querySelector('[data-ra-bulk-count]').textContent = '· ' + groups[config.group].length;
         const useBase = content.querySelector('[data-ra-use-base]');
         if (useBase) useBase.hidden = !groups.datePrices.length;
+        const useBaseStock = content.querySelector('[data-ra-use-base-stock]');
+        if (useBaseStock) useBaseStock.hidden = !groups.dateStock.length;
         setTimeout(() => { const input = content.querySelector('input'); if (input) input.focus(); }, 300);
       }
 
@@ -438,11 +453,35 @@
         this.update('use_base_price', {}, this.cellSelection.groups().datePrices.map(cellData));
       }
 
+      // Recounting a date undoes the stock set on it, so this is Set stock's way back to Base, as Use Base price is
+      // for prices.
+      useBaseStock() {
+        const cells = this.cellSelection.groups().dateStock;
+        if (!window.confirm(T.useBaseStockConfirm.replace('%{count}', cells.length))) return;
+        this.sharedModal.hide();
+        this.update('reset_stock', {}, cells.map(cellData));
+      }
+
       recount(button) {
         if (!window.confirm(button.dataset.raConfirm)) return;
         this.update('reset_stock', {}, [{ type: 'stock', variant_id: button.dataset.variantId, rate_plan_id: null, date: button.dataset.date }]);
       }
 
+      // Every row of the open stock details: one stock cell per variant and date it was opened for, as its price
+      // cells list the same rows but reset_stock only takes stock cells.
+      recountAll(button) {
+        if (!window.confirm(button.dataset.raConfirm)) return;
+        const rows = new Map(this.cellListModal.request.cells.map((cell) => [cell.variant_id + '|' + cell.date, cell]));
+        const cells = [...rows.values()].map((cell) => ({ type: 'stock', variant_id: cell.variant_id, rate_plan_id: null, date: cell.date }));
+        this.update('reset_stock', {}, cells);
+      }
+
+      // In the bar, and above an open list modal, which covers the bar.
+      report(text, level) {
+        this.message(text, level === 'danger');
+        if (this.cellListModal.isShown) this.cellListModal.load({ text: text, level: level });
+      }
+
       // `cells` defaults to the selection. Reloads the grid, and an open list modal, as their counts change.
       update(action, values, cells = this.cellSelection.groups().all.map(cellData)) {
         this.bar.classList.add('ra-busy');
@@ -454,11 +493,12 @@
         }).then((response) => response.json().then((body) => {
           if (!response.ok) throw new Error(body.error);
           return this.monthTables.reload().then(() => {
-            if (this.cellListModal.isShown) this.cellListModal.load();
-            this.message(T.done.replace('%{updated}', body.updated).replace('%{skipped}', body.skipped));
+            const done = T.done.replace('%{updated}', body.updated).replace('%{skipped}', body.skipped);
+            if (body.busy) this.report(done + '. ' + T.busy.replace('%{count}', body.busy), 'warning');
+            else this.report(done, 'success');
           });
         })).catch((error) => {
-          this.message(error.message, true);
+          this.report(error.message, 'danger');
         }).finally(() => {
           this.bar.classList.remove('ra-busy');
         });
@@ -593,10 +633,12 @@
           ['[data-ra-select-date]', (el, event) => this.cellSelection.selectDate(el, event.shiftKey)],
           ['[data-ra-bulk]', (el) => this.bulkEditBar.start(el.dataset.raBulk)],
           ['[data-ra-use-base]', () => this.bulkEditBar.useBasePrice()],
+          ['[data-ra-use-base-stock]', () => this.bulkEditBar.useBaseStock()],
           ['[data-ra-list]', (el) => this.cellListModal.open(this.monthTables.root.dataset[el.dataset.raList + 'Url'])],
           ['[data-ra-list-filter]', (el) => this.cellListModal.setFilter(el.dataset.raListFilter)],
           ['[data-ra-list-page]', (el) => this.cellListModal.setPage(el)],
           ['[data-ra-recount]', (el) => this.bulkEditBar.recount(el)],
+          ['[data-ra-recount-all]', (el) => this.bulkEditBar.recountAll(el)],
           ['[data-ra-modal-url]', (el) => this.ratePlanForms.open(el.dataset.raModalUrl)],
           ['[data-ra-move]', (el) => this.ratePlanForms.moveItem(el)],
           ['[data-ra-delete-url]', (el) => this.ratePlanForms.destroy(el)]

data/app/views/spree/admin/rates_availabilities/index.html.erb

@@ -102,6 +102,10 @@
       <small class="text-muted"><%= t('rates_availabilities.bulk.stock_hint') %></small>
     </div>
     <div class="modal-footer">
+      <%# Only while dated stock is selected (BulkEditBar#openForm); recounts those dates, undoing the stock set on them. %>
+      <button type="button" class="mr-auto btn btn-outline-secondary" data-ra-use-base-stock hidden title="<%= t('rates_availabilities.bulk.use_base_stock_hint') %>">
+        <%= t('rates_availabilities.bulk.use_base_stock') %>
+      </button>
       <button type="button" class="btn btn-outline-secondary" data-ra-dismiss><%= t('rates_availabilities.rate_plan_form.cancel') %></button>
       <button type="submit" class="btn btn-primary"><%= t('rates_availabilities.rate_plan_form.save') %></button>
     </div>

data/config/locales/en.yml

@@ -1220,6 +1220,10 @@ en:
     convert:
       hold_expired: "Your reservation expired before payment completed. Please try booking again."
 
+  inventory_item:
+    reset:
+      busy: "Stock changed while it was being recounted, as someone is booking it. Try again in a moment."
+
   # Displayed as-is on stock-status badges pushed to Firestore (see
   # SpreeCmCommissioner::Products::PublishStockStatusToFirestore) — not read via I18n at request
   # time, so every locale we publish for must have an entry here.
@@ -1636,7 +1640,12 @@ en:
       close: "Close sale"
       reopen: "Reopen sale"
       reset_stock: "Recount stock"
-      reset_stock_confirm: "Recount stock? Available and on-hold are recalculated from base stock and orders."
+      reset_stock_confirm: "Recount stock? Available and on-hold are recalculated from Base stock and orders, which undoes stock set on the date."
+      recount_limit: "Recount up to %{max} dates at a time"
+      busy: "%{count} were being booked and were left as they were; try them again in a moment."
+      use_base_stock: "Use Base stock"
+      use_base_stock_hint: "Recount the selected dates from Base stock and orders, undoing the stock set on them"
+      use_base_stock_confirm: "Recount %{count} selected dates from Base stock and orders? Stock set on them is undone."
       deselect: "Deselect all"
       selected: "%{count} selected"
       saving: "Saving…"
@@ -1720,6 +1729,10 @@ en:
       title: "Stock details"
       date: "Date"
       none: "No inventory for the selected dates."
+      recount_all: "Recount all"
+      recount_all_hint: "Recalculates from Base stock and orders: fixes drifted counts and undoes stock set on these dates."
+      recount_all_confirm: "Recount all %{count} rows? Available and on-hold are recalculated from Base stock and orders, which undoes stock set on those dates."
+      recount_all_limit: "Select up to %{max} rows to recount them all at once"
     bookings:
       title: "Bookings"
       open: "Bookings"

data/config/locales/km.yml

@@ -740,6 +740,10 @@ km:
     convert:
       hold_expired: "ការកក់របស់អ្នកបានផុតកំណត់មុនពេលទូទាត់ប្រាក់បានបញ្ចប់។ សូមព្យាយាមកក់ម្តងទៀត។"
 
+  inventory_item:
+    reset:
+      busy: "ស្តុកបានផ្លាស់ប្តូរពេលកំពុងរាប់ឡើងវិញ ព្រោះមានអ្នកកំពុងកក់។ សូមព្យាយាមម្តងទៀតបន្តិចទៀត។"
+
   stock_status:
     pending_hold: "តម្រូវការខ្ពស់"
     sold_out: "លក់អស់"
@@ -1176,7 +1180,12 @@ km:
       close: "បិទការលក់"
       reopen: "បើកការលក់ឡើងវិញ"
       reset_stock: "រាប់ស្តុកឡើងវិញ"
-      reset_stock_confirm: "រាប់ស្តុកឡើងវិញ? ចំនួននៅសល់ និងកំពុងរក្សាទុកនឹងត្រូវគណនាឡើងវិញពីស្តុកមូលដ្ឋាន និងការកម្ម៉ង់។"
+      reset_stock_confirm: "រាប់ស្តុកឡើងវិញ? ចំនួននៅសល់ និងកំពុងរក្សាទុកនឹងត្រូវគណនាឡើងវិញពីស្តុកមូលដ្ឋាន និងការកម្ម៉ង់ ដែលលុបស្តុកដែលបានកំណត់លើថ្ងៃនោះ។"
+      recount_limit: "អាចរាប់ស្តុកឡើងវិញបានយ៉ាងច្រើន %{max} ថ្ងៃក្នុងមួយលើក"
+      busy: "%{count} កំពុងត្រូវបានកក់ ហើយមិនត្រូវបានប្តូរទេ។ សូមព្យាយាមម្តងទៀតបន្តិចទៀត។"
+      use_base_stock: "ប្រើស្តុកមូលដ្ឋាន"
+      use_base_stock_hint: "រាប់ស្តុកថ្ងៃដែលបានជ្រើសឡើងវិញពីស្តុកមូលដ្ឋាន និងការកម្ម៉ង់ ដោយលុបស្តុកដែលបានកំណត់លើថ្ងៃទាំងនោះ"
+      use_base_stock_confirm: "រាប់ស្តុក %{count} ថ្ងៃដែលបានជ្រើសឡើងវិញពីស្តុកមូលដ្ឋាន និងការកម្ម៉ង់? ស្តុកដែលបានកំណត់លើថ្ងៃទាំងនោះនឹងត្រូវលុប។"
       deselect: "ដកការជ្រើសទាំងអស់"
       selected: "បានជ្រើស %{count}"
       saving: "កំពុងរក្សាទុក…"
@@ -1260,6 +1269,10 @@ km:
       title: "ព័ត៌មានលម្អិតស្តុក"
       date: "ថ្ងៃ"
       none: "គ្មានស្តុកសម្រាប់ថ្ងៃដែលបានជ្រើសទេ។"
+      recount_all: "រាប់ទាំងអស់ឡើងវិញ"
+      recount_all_hint: "គណនាឡើងវិញពីស្តុកមូលដ្ឋាន និងការកម្ម៉ង់៖ កែចំនួនដែលខុស និងលុបស្តុកដែលបានកំណត់លើថ្ងៃទាំងនេះ។"
+      recount_all_confirm: "រាប់ស្តុកទាំង %{count} ជួរឡើងវិញ? ចំនួននៅសល់ និងកំពុងរក្សាទុកនឹងត្រូវគណនាឡើងវិញពីស្តុកមូលដ្ឋាន និងការកម្ម៉ង់ ដែលលុបស្តុកដែលបានកំណត់លើថ្ងៃទាំងនោះ។"
+      recount_all_limit: "ជ្រើសមិនលើស %{max} ជួរ ដើម្បីរាប់ទាំងអស់ឡើងវិញក្នុងមួយលើក"
     bookings:
       title: "ការកក់"
       open: "ការកក់"

data/lib/spree_cm_commissioner/version.rb

@@ -1,5 +1,5 @@
 module SpreeCmCommissioner
-  VERSION = '2.14.1'.freeze
+  VERSION = '2.14.3'.freeze
 
   module_function
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spree_cm_commissioner
 version: !ruby/object:Gem::Version
-  version: 2.14.1
+  version: 2.14.3
 platform: ruby
 authors:
 - You
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-22 00:00:00.000000000 Z
+date: 2026-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: spree
@@ -1370,6 +1370,7 @@ files:
 - app/jobs/spree_cm_commissioner/application_unique_job.rb
 - app/jobs/spree_cm_commissioner/async_operation_job.rb
 - app/jobs/spree_cm_commissioner/audit_event_job.rb
+- app/jobs/spree_cm_commissioner/audit_events/cleanup_expired_job.rb
 - app/jobs/spree_cm_commissioner/cancel_import_order_job.rb
 - app/jobs/spree_cm_commissioner/chatrace_order_creator_job.rb
 - app/jobs/spree_cm_commissioner/completion_steps/regenerate_for_line_items_job.rb
@@ -2315,6 +2316,7 @@ files:
 - app/services/spree_cm_commissioner/agency_users/destroy.rb
 - app/services/spree_cm_commissioner/api_caches/invalidate.rb
 - app/services/spree_cm_commissioner/assign_product_to_section/update.rb
+- app/services/spree_cm_commissioner/audit_events/cleanup_expired.rb
 - app/services/spree_cm_commissioner/audit_logger.rb
 - app/services/spree_cm_commissioner/calculate_distance.rb
 - app/services/spree_cm_commissioner/cart/add_guest.rb
@@ -2638,6 +2640,7 @@ files:
 - app/services/spree_cm_commissioner/routes/create.rb
 - app/services/spree_cm_commissioner/routes/update.rb
 - 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/update.rb
 - app/services/spree_cm_commissioner/seats/apply_locks.rb