spree_cm_commissioner 2.14.2 → 2.14.4

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/order/guests/update.rb

@@ -21,32 +21,10 @@ module SpreeCmCommissioner
           editable_attrs = guest.kyc_fields.flat_map { |field| SpreeCmCommissioner::KycBitwise::KYC_FIELD_ATTRIBUTES[field] || [] }
 
           filtered = attrs.slice(*editable_attrs)
-          filtered[:guest_dynamic_fields_attributes] = build_dynamic_field_attributes(guest, attrs[:dynamic_fields])
+          filtered[:guest_dynamic_fields_attributes] =
+            SpreeCmCommissioner::Guests::BuildDynamicFieldAttributes.call(guest: guest, dynamic_fields: attrs[:dynamic_fields])
           filtered
         end
-
-        # Builds the guest_dynamic_fields_attributes array SpreeCmCommissioner::Guests::Update
-        # expects, restricted to dynamic fields actually enabled for this guest's product (one
-        # `pluck`/load, not a query per submitted field). Option-based fields (checkbox/
-        # radio/selection) submit one or more selected option ids and become one
-        # GuestDynamicField row per selected option; Guests::Update's own auto-cleanup
-        # destroys any existing rows for options that were deselected.
-        def build_dynamic_field_attributes(guest, dynamic_fields)
-          return [] if dynamic_fields.blank?
-
-          enabled_fields = guest.line_item.product.dynamic_fields.index_by(&:id)
-
-          dynamic_fields.flat_map do |dynamic_field_id, value|
-            dynamic_field = enabled_fields[dynamic_field_id.to_s.to_i]
-            next [] unless dynamic_field
-
-            if dynamic_field.requires_dynamic_field_options?
-              Array(value).compact_blank.map { |option_id| { dynamic_field_id: dynamic_field.id, dynamic_field_option_id: option_id } }
-            else
-              [{ dynamic_field_id: dynamic_field.id, value: value }]
-            end
-          end
-        end
       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/guests/_dynamic_fields.html.erb

@@ -0,0 +1,67 @@
+<% answers_by_field_id = @guest_dynamic_fields.group_by(&:dynamic_field_id) %>
+<% i18n_scope = 'views.admin.guests.dynamic_fields' %>
+
+<div class="row">
+  <div class="col-12">
+    <div class="card mb-3">
+      <div class="card-header">
+        <h5 class="card-title mb-0 h6"><%= I18n.t('title', scope: i18n_scope) %></h5>
+      </div>
+
+      <div class="card-body">
+        <% @dynamic_fields.group_by(&:data_fill_stage).each do |stage, dynamic_fields| %>
+          <h6 class="text-muted"><%= I18n.t(stage, scope: "#{i18n_scope}.stages") %></h6>
+
+          <% dynamic_fields.each do |dynamic_field| %>
+            <% answers = answers_by_field_id[dynamic_field.id] || [] %>
+            <% answer = answers.first %>
+            <% input_name = "#{f.object_name}[dynamic_fields][#{dynamic_field.id}]" %>
+            <% input_id = "dynamic_field_#{dynamic_field.id}" %>
+            <% selected_option_ids = answers.map(&:dynamic_field_option_id) %>
+
+            <div class="form-group">
+              <%= label_tag input_id, dynamic_field.label %>
+
+              <% case dynamic_field.data_type.to_sym %>
+              <% when :text %>
+                <%= text_field_tag input_name, answer&.value, id: input_id, class: 'form-control' %>
+              <% when :textarea %>
+                <%= text_area_tag input_name, answer&.value, id: input_id, rows: 3, class: 'form-control' %>
+              <% when :number %>
+                <%= number_field_tag input_name, answer&.value, id: input_id, min: 0, class: 'form-control' %>
+              <% when :boolean %>
+                <%= select_tag input_name,
+                               options_for_select([[I18n.t('yes', scope: i18n_scope), 'true'], [I18n.t('no', scope: i18n_scope), 'false']], answer&.value),
+                               include_blank: true, id: input_id, class: 'form-control' %>
+              <% when :radio %>
+                <% dynamic_field.dynamic_field_options.each do |option| %>
+                  <div class="radio">
+                    <label>
+                      <%= radio_button_tag input_name, option.id, selected_option_ids.include?(option.id) %>
+                      <%= option.value %>
+                    </label>
+                  </div>
+                <% end %>
+              <% when :selection, :checkbox %>
+                <% if dynamic_field.checkbox? || dynamic_field.multiple_select %>
+                  <% dynamic_field.dynamic_field_options.each do |option| %>
+                    <div class="checkbox">
+                      <label>
+                        <%= check_box_tag "#{input_name}[]", option.id, selected_option_ids.include?(option.id), id: nil %>
+                        <%= option.value %>
+                      </label>
+                    </div>
+                  <% end %>
+                <% else %>
+                  <%= select_tag input_name,
+                                 options_from_collection_for_select(dynamic_field.dynamic_field_options, :id, :value, selected_option_ids.first),
+                                 include_blank: true, id: input_id, class: 'form-control' %>
+                <% end %>
+              <% end %>
+            </div>
+          <% end %>
+        <% end %>
+      </div>
+    </div>
+  </div>
+</div>

data/app/views/spree/admin/guests/_form.html.erb

@@ -149,3 +149,5 @@
     </div>
   </div>
 </div>
+
+<%= render partial: 'spree/admin/guests/dynamic_fields', locals: { f: f } if @dynamic_fields.present? %>

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

@@ -3,7 +3,7 @@
 <% end %>
 
 <% content_for :page_actions do %>
-  <%= button_link_to Spree.t(:clear_cache), admin_invalidate_api_caches_path(model: SpreeCmCommissioner::HomepageBackground.name), method: :post, class: "btn btn-outline-primary" %>
+  <%= render 'spree/admin/shared/api_cache_button', model: SpreeCmCommissioner::HomepageBackground.name %>
   <%= button_link_to Spree.t(:new_homepage_background), new_admin_homepage_feed_homepage_background_path, { class: "btn-success", icon: 'add.svg', id: 'admin_new_homepage_background' } %>
 <% end %>
 

data/app/views/spree/admin/homepage_section/edit.html.erb

@@ -4,7 +4,6 @@
       <%= link_to plural_resource_name(SpreeCmCommissioner::HomepageSection), spree.admin_homepage_feed_homepage_section_index_url %> /
       <%= Spree.t(:edit_section_relatable) %>
     </div>
-    <%= button_link_to Spree.t(:clear_cache), admin_invalidate_api_caches_path(model: SpreeCmCommissioner::HomepageSection.name, id: @object.id), method: :post, class: "btn btn-outline-primary" %>
   </div>
 <% end %>
 

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

@@ -18,7 +18,7 @@
 <% end %>
 
 <% content_for :page_actions do %>
-  <%= button_link_to Spree.t(:clear_cache), admin_invalidate_api_caches_path(model: SpreeCmCommissioner::HomepageSection.name), method: :post, class: "btn btn-outline-primary" %>
+  <%= render 'spree/admin/shared/api_cache_button', model: SpreeCmCommissioner::HomepageSection.name, tenant_id: selected_tenant&.id %>
   <%= button_link_to Spree.t(:new_homepage_section), new_admin_homepage_feed_homepage_section_path(tenant_id: params[:tenant_id]), { class: "btn-success", icon: 'add.svg', id: 'admin_new_homepage_section' } %>
 <% 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 %>