spree_cm_commissioner 2.13.7 → 2.14.0

data/app/finders/spree_cm_commissioner/accommodations/find_variant.rb

@@ -12,20 +12,14 @@ module SpreeCmCommissioner
 
       def execute
         Spree::Variant
-          .joins(:inventory_items)
           .where(vendor_id: vendor_id)
-          .where(inventory_items: { inventory_date: stay_dates })
-          .where('CAST(spree_variants.public_metadata->\'cm_options\'->>\'number-of-adults\' AS INTEGER) +
-                  CAST(spree_variants.public_metadata->\'cm_options\'->>\'number-of-kids\' AS INTEGER) >= ?', number_of_guests
-          )
-          .where('inventory_items.quantity_available > 0')
-          .distinct
+          .bookable_on_every_date(dates)
+          .with_guest_capacity(number_of_guests)
+          .with_open_rate_on_every_date(dates)
       end
 
-      private
-
-      def stay_dates
-        from_date..to_date
+      def dates
+        @dates ||= SpreeCmCommissioner::BookingDates.nights(check_in: from_date, check_out: to_date)
       end
     end
   end

data/app/finders/spree_cm_commissioner/rates_availabilities/find_bookings.rb

@@ -0,0 +1,116 @@
+module SpreeCmCommissioner
+  module RatesAvailabilities
+    # The line items behind cells of the Rates & Availability grid. A stock cell covers every line item of its
+    # variant, a rate plan's price cell only that plan's, and the variant's own price cell those sold without one.
+    # A date matches every stay or booking it falls in, by the same rule InventoryItems::Reset counts with, so
+    # Confirmed adds up to what the stock cell has sold. Base on a dated product means bookings not over yet.
+    class FindBookings
+      FILTERS = %w[confirmed unpaid in_checkout canceled carts all].freeze
+
+      # `cells` are the grid's: { type:, variant_id:, rate_plan_id:, date: } with date '' for Base.
+      def initialize(product:, cells:, filter: 'confirmed', query: nil)
+        @product = product
+        @cells = cells
+        @filter = FILTERS.include?(filter) ? filter : 'confirmed'
+        @query = query.to_s.strip
+      end
+
+      attr_reader :filter
+
+      def execute
+        by_filter(searched, filter)
+          .includes({ rate_plan: { option_values: :option_type } }, variant: { option_values: :option_type }, order: %i[bill_address user])
+          .order(:from_date, :id)
+      end
+
+      # Line items per filter, for the quick filter chips. The search applies; the chosen filter doesn't. One pass,
+      # a COUNT FILTER per chip, each taking its condition from by_filter so the chips and their lists agree.
+      def counts
+        columns = FILTERS.map do |name|
+          where_clause = by_filter(Spree::LineItem.unscoped, name).where_clause
+          where_clause.empty? ? Arel.star.count : Arel.star.count.filter(where_clause.ast)
+        end
+        FILTERS.zip(searched.pick(*columns) || Array.new(FILTERS.size, 0)).to_h
+      end
+
+      # Which of these line items' orders are carts holding stock, for their In checkout badge.
+      def held_order_ids_among(line_items)
+        held_order_ids.where(order_id: line_items.map(&:order_id)).pluck(:order_id).to_set
+      end
+
+      private
+
+      def by_filter(scope, name)
+        case name
+        when 'confirmed' then scope.merge(Spree::LineItem.affecting_inventory)
+        when 'unpaid' then scope.merge(Spree::LineItem.affecting_inventory).where.not(spree_orders: { payment_state: 'paid' })
+        when 'in_checkout' then scope.where(order_id: held_order_ids)
+        when 'canceled' then scope.where.not(spree_orders: { canceled_at: nil })
+        # Unfinished orders that hold nothing, apart from the bookings so they can be cleaned up.
+        when 'carts' then scope.where(spree_orders: { completed_at: nil }).where.not(order_id: held_order_ids)
+        else scope
+        end
+      end
+
+      def held_order_ids
+        SpreeCmCommissioner::InventoryHold.active_or_payment_locked.select(:order_id)
+      end
+
+      def searched
+        return cells_scope if @query.blank?
+
+        term = "%#{Spree::LineItem.sanitize_sql_like(@query)}%"
+        cells_scope.left_joins(order: :bill_address).where(
+          'spree_orders.number ILIKE :term OR spree_orders.email ILIKE :term OR spree_orders.phone_number ILIKE :term ' \
+          "OR spree_addresses.phone ILIKE :term OR CONCAT_WS(' ', spree_addresses.firstname, spree_addresses.lastname) ILIKE :term",
+          term: term
+        )
+      end
+
+      # One scope per variant and row over its dates, OR'd together. Archived orders are carts gone stale
+      # (Orders::DailyArchiveInactiveOrders), already hidden from their guests, so they're left out here too.
+      def cells_scope
+        scopes = groups.map { |(variant_id, row), dates| group_scope(variant_id, row, dates) }
+        return Spree::LineItem.none if scopes.empty?
+
+        scopes.reduce(:or).joins(:order).where(spree_orders: { archived_at: nil })
+      end
+
+      # { [variant_id, row] => dates }, where row is :all for stock, nil for the variant's own prices, else a rate
+      # plan id, and a date is nil for Base. Cells of other products' variants are dropped.
+      def groups
+        @cells.select { |cell| variant_ids.include?(cell[:variant_id].to_i) }
+              .group_by { |cell| [cell[:variant_id].to_i, cell[:type] == 'stock' ? :all : cell[:rate_plan_id].presence&.to_i] }
+              .transform_values { |cells| cells.map { |cell| cell[:date].presence && Date.parse(cell[:date]) }.uniq }
+      end
+
+      def group_scope(variant_id, row, dates)
+        scope = Spree::LineItem.where(variant_id: variant_id)
+        scope = scope.where(rate_plan_id: row) unless row == :all
+        condition = dates.include?(nil) ? base_condition : dates_condition(dates.sort)
+        condition ? scope.where(*condition) : scope
+      end
+
+      # Base on a dated product is the bookings not over yet; on any other, every booking.
+      def base_condition
+        ['spree_line_items.to_date >= ?', Time.zone.today] if @product.permanent_stock?
+      end
+
+      # The range check is a cheap first cut before EXISTS, and lets a (variant_id, to_date) index skip old stays if
+      # a variant's history ever grows large enough to need one. EXISTS then keeps only stays covering one of the
+      # dates, not those that merely span a gap between two.
+      def dates_condition(dates)
+        [
+          'spree_line_items.to_date >= ? AND spree_line_items.from_date <= ? ' \
+          'AND EXISTS (SELECT 1 FROM unnest(ARRAY[?]::date[]) AS night(day) ' \
+          'WHERE night.day BETWEEN spree_line_items.from_date AND spree_line_items.to_date)',
+          dates.first, dates.last, dates.map(&:iso8601)
+        ]
+      end
+
+      def variant_ids
+        @variant_ids ||= Spree::Variant.where(product_id: @product.id).ids
+      end
+    end
+  end
+end

data/app/helpers/spree_cm_commissioner/admin/inventory_items_helper.rb

@@ -0,0 +1,36 @@
+module SpreeCmCommissioner
+  module Admin
+    # Inventory item counts as the stock managements page and the Rates & Availability stock details show them.
+    module InventoryItemsHelper
+      # The cloud icon after a count: whether Redis has the same value. A popover on stock managements; fetched
+      # HTML has nothing to initialize popovers, so the grid's script copies the message into a title.
+      def inventory_item_sync_icon(value, cached_value)
+        synced = value == cached_value
+        message = if synced
+                    t('inventory_item_stats.synced', value: cached_value)
+                  else
+                    t('inventory_item_stats.out_of_sync', cached: cached_value, value: value)
+                  end
+        icon = svg_icon(
+          name: synced ? 'cloud-check.svg' : 'cloud-slash.svg', width: '14', height: '14', classes: synced ? 'text-success' : 'text-danger'
+        )
+
+        content_tag(:span, icon, type: 'button', data: { toggle: 'popover', trigger: 'hover', placement: 'right', content: message })
+      end
+
+      # Recounts in place through the grid's bulk_update, unlike stock managements' bulk_reset link, which reloads.
+      def inventory_item_recount_button(inventory_item)
+        label = t('rates_availabilities.bulk.reset_stock')
+        data = {
+          ra_recount: true, variant_id: inventory_item.variant_id, date: inventory_item.inventory_date&.iso8601.to_s,
+          ra_confirm: t('rates_availabilities.bulk.reset_stock_confirm')
+        }
+
+        content_tag(
+          :button, svg_icon(name: 'arrow-counterclockwise.svg', width: '14', height: '14'),
+          type: 'button', class: 'icon_link btn btn-sm outline text-dark m-0 p-0 border-0', title: label, aria: { label: label }, data: data
+        )
+      end
+    end
+  end
+end

data/app/helpers/spree_cm_commissioner/admin/rates_availabilities_helper.rb

@@ -0,0 +1,247 @@
+module SpreeCmCommissioner
+  module Admin
+    # Cells of the Rates & Availability grid. Helpers, not partials: a page renders up to tens of thousands of cells.
+    module RatesAvailabilitiesHelper
+      # A dated product's Base column has no inventory item, only the capacity new dates start from.
+      def rates_availability_stock_cell(grid, variant, date)
+        item = grid.inventory_item(variant, date)
+        data = rates_availability_cell_data('stock', variant, nil, date)
+        return content_tag(:td, grid.base_stock(variant), class: 'ra-cell ra-base', data: data) if item.nil? && date.nil?
+        unless item
+          return content_tag(:td, '—', class: rates_availability_cell_class(date, 'text-muted'), title: t('rates_availabilities.not_generated'))
+        end
+
+        synced = grid.synced?(item)
+        content_tag(
+          :td, rates_availability_stock_content(item),
+          class: rates_availability_cell_class(
+            date, ('ra-closed' if item.closed), ('ra-sold-out' if !item.closed && item.quantity_available.zero?), ('ra-out-of-sync' unless synced)
+          ),
+          title: rates_availability_stock_title(item, synced),
+          data: data
+        )
+      end
+
+      def rates_availability_stock_content(item)
+        quantity = "#{item.quantity_available}/#{item.max_capacity}"
+        meter = rates_availability_stock_meter(item)
+        return safe_join([quantity, meter].compact) unless item.closed
+
+        label = content_tag(:span, t('rates_availabilities.closed_label'), class: 'ra-closed-label')
+        safe_join([label, content_tag(:small, quantity), meter].compact)
+      end
+
+      # The gap between max and available is what's sold plus what's locked for a private sale (holds are counted
+      # apart, and setting stock moves both numbers), so sold leaves the lock out to tell the two apart.
+      def rates_availability_stock_sold(item)
+        [item.max_capacity - item.quantity_available - item.quantity_locked, 0].max
+      end
+
+      # A bar under the quantity filling with what's sold, then what's locked; none until something is.
+      def rates_availability_stock_meter(item)
+        sold = rates_availability_stock_sold(item)
+        locked = item.quantity_locked
+        return if item.max_capacity <= 0 || (sold + locked).zero?
+
+        segments = { 'ra-meter-sold' => sold, 'ra-meter-locked' => locked }.filter_map do |css, quantity|
+          content_tag(:span, nil, class: css, style: "width: #{(quantity * 100.0 / item.max_capacity).round(1)}%") if quantity.positive?
+        end
+        content_tag(:span, safe_join(segments), class: 'ra-meter')
+      end
+
+      def rates_availability_stock_title(item, synced)
+        [
+          t(
+            'rates_availabilities.stock_tooltip',
+            available: item.quantity_available, max: item.max_capacity, sold: rates_availability_stock_sold(item),
+            on_hold: item.quantity_on_hold, locked: item.quantity_locked
+          ),
+          (t('rates_availabilities.closed') if item.closed),
+          (t('rates_availabilities.out_of_sync') unless synced)
+        ].compact.join(' · ')
+      end
+
+      # `index` is the column: 0 is Base, then one per date. A derived rate plan has no Base price of its own
+      # (it's calculated), so only its date cells can be selected, to override the calculated price. A closed date
+      # (the variant's, for every rate) keeps its prices editable. A rate closed by its own closing
+      # (RatesAvailabilityGrid#rate_closing) is ra-rate-closed, so it can be reopened from its cell; one closed only
+      # by its date or by following the base rate is ra-closed-day alone, and its title says where it reopens.
+      def rates_availability_price_cell(grid, row, index, date)
+        closed = date && grid.inventory_item(row.variant, date)&.closed
+        rate_closing = grid.rate_closing(row, date)
+        state = rates_availability_price_state(row, date)
+        data = rates_availability_cell_data('price', row.variant, row.rate_plan, date) unless row.rate_plan&.kind_derived? && date.nil?
+
+        content_tag(
+          :td, rates_availability_price_content(row.amounts[index], row.compare_at_amounts[index], grid.currency),
+          class: rates_availability_cell_class(
+            date, ("ra-#{state.to_s.dasherize}" if state), ('ra-closed-day' if closed || rate_closing), ('ra-rate-closed' if rate_closing == :closed)
+          ),
+          title: rates_availability_price_title(grid, row, state, closed, rate_closing), data: data
+        )
+      end
+
+      def rates_availability_price_title(grid, row, state, closed, rate_closing)
+        [
+          state == :derived ? rates_availability_rate_plan_hint(row.rate_plan) : (t("rates_availabilities.#{state}") if state),
+          (t('rates_availabilities.date_closed') if closed),
+          (rates_availability_rate_closing_title(grid, row, rate_closing) if rate_closing)
+        ].compact.join(' · ').presence
+      end
+
+      # The base price isn't sold while the variant has active rate plans, so closing it means closing the ones
+      # calculated from it, which its title says.
+      def rates_availability_rate_closing_title(grid, row, rate_closing)
+        derived = row.rate_plan.nil? && grid.rate_plans(row.variant).any? { |rate_plan| rate_plan.active? && rate_plan.kind_derived? }
+        return t('rates_availabilities.base_rate_closed') if derived
+
+        t("rates_availabilities.rate_#{rate_closing}")
+      end
+
+      # The price, with what guests see crossed out above it.
+      def rates_availability_price_content(amount, compare_at, currency)
+        return '—' if amount.nil?
+
+        crossed_out = content_tag(:s, Spree::Money.new(compare_at, currency: currency).to_s, class: 'ra-compare-at') if compare_at
+        safe_join([crossed_out, Spree::Money.new(amount, currency: currency).to_s].compact)
+      end
+
+      # The strings rates_availability.js shows, as it's a plain asset with no access to I18n.
+      def rates_availability_script_translations
+        {
+          selected: t('rates_availabilities.bulk.selected'),
+          saving: t('rates_availabilities.bulk.saving'),
+          done: t('rates_availabilities.bulk.done'),
+          failed: t('rates_availabilities.modal.failed')
+        }
+      end
+
+      # What a selectable cell sends to bulk_update.
+      def rates_availability_cell_data(type, variant, rate_plan, date)
+        { cell: type, variant_id: variant.id, rate_plan_id: rate_plan&.id, date: date&.iso8601.to_s }
+      end
+
+      # :date_price for a date with its own price, else :derived for a calculated one, else :uses_base on a date.
+      def rates_availability_price_state(row, date)
+        return :date_price if date && row.stay_price.date_price?(date)
+        return :derived if row.rate_plan&.kind_derived?
+
+        :uses_base if date
+      end
+
+      # The variant's own prices are only sold while it has no active rate plan, so the label says which.
+      def rates_availability_price_label(grid, row)
+        return row.rate_plan.display_name if row.rate_plan
+
+        key = grid.rate_plans(row.variant).any?(&:active?) ? 'base_price' : 'default_rate'
+        content_tag(:span, t("rates_availabilities.#{key}"), title: t("rates_availabilities.#{key}_hint"))
+      end
+
+      def rates_availability_rate_plan_hint(rate_plan)
+        if rate_plan.kind_independent?
+          t('rates_availabilities.independent')
+        elsif rate_plan.adjustment_percent?
+          t('rates_availabilities.derived_percent', value: format('%+g', rate_plan.adjustment_value))
+        else
+          t('rates_availabilities.derived_amount', value: format('%+g', rate_plan.adjustment_value), currency: rate_plan.currency)
+        end
+      end
+
+      def rates_availability_cell_class(date, *extra)
+        [
+          'ra-cell',
+          ('ra-base' if date.nil?),
+          ('ra-weekend' if date&.on_weekend?),
+          ('ra-today' if date == Time.zone.today),
+          ('ra-past' if date && date < Time.zone.today),
+          *extra
+        ].compact.join(' ')
+      end
+
+      def rates_availability_variant_name(variant)
+        variant.is_master? ? variant.product.name : variant.options_text
+      end
+
+      # "Deluxe · Fri 10 Oct 2026", or "3 variants · 9 Oct – 12 Oct 2026 · 4 dates" for a wider selection.
+      def rates_availability_selection_subtitle(product, cells)
+        variant_ids = cells.map { |cell| cell[:variant_id].to_i }.uniq
+        dates = cells.filter_map { |cell| cell[:date].presence && Date.parse(cell[:date]) }.uniq.sort
+        variant = product.variants_including_master.includes(option_values: :option_type).find_by(id: variant_ids.first) if variant_ids.one?
+
+        parts = [variant ? rates_availability_variant_name(variant) : t('rates_availabilities.selection.variants', count: variant_ids.size)]
+        parts << t('rates_availabilities.selection.base') if dates.empty? && product.permanent_stock?
+        parts.concat(rates_availability_selection_dates(dates))
+        parts.join(' · ')
+      end
+
+      def rates_availability_selection_dates(dates)
+        return [] if dates.empty?
+        return [l(dates.first, format: '%a %-d %b %Y')] if dates.one?
+
+        ["#{l(dates.first, format: '%-d %b')} – #{l(dates.last, format: '%-d %b %Y')}", t('rates_availabilities.selection.dates', count: dates.size)]
+      end
+
+      # The guest's name (else email), and the order's phone (else the billing one).
+      def rates_availability_booking_guest(order)
+        phone = order.phone_number.presence || order.bill_address&.phone.presence
+        [order.name.presence || order.email, phone].compact.join(' · ')
+      end
+
+      # When a placed order was placed, else when the cart was started, so a stale cart is told from a live one.
+      def rates_availability_booking_time(order)
+        key, time = order.completed_at ? ['placed', order.completed_at] : ['created', order.created_at]
+        t("rates_availabilities.bookings.#{key}", time: l(time, format: '%-d %b %Y, %H:%M'))
+      end
+
+      # The state that explains the line's effect on stock, then what's unusual about it.
+      def rates_availability_booking_badges(line_item, held_order_ids)
+        order = line_item.order
+        badges = [rates_availability_booking_state(order, held_order_ids)]
+        badges << [order.payment_state.humanize, order.paid? ? 'success' : 'warning'] if order.payment_state.present? && order.canceled_at.nil?
+        badges << [t('rates_availabilities.bookings.ticket_transfer'), 'info'] if order.ticket_transfer?
+        badges << [t('rates_availabilities.bookings.private_sale'), 'dark'] if line_item.locked_stock?
+        safe_join(badges.map { |label, style| content_tag(:span, label, class: "badge badge-#{style}") }, ' ')
+      end
+
+      def rates_availability_booking_state(order, held_order_ids)
+        state, style =
+          if order.canceled_at
+            %w[canceled secondary]
+          elsif order.completed_at
+            %w[complete success]
+          elsif held_order_ids.include?(order.id)
+            %w[in_checkout warning]
+          else
+            %w[cart light]
+          end
+        [t("rates_availabilities.bookings.states.#{state}"), style]
+      end
+
+      # A hotel's last night is `to_date`, so checkout is the day after.
+      def rates_availability_booking_dates(line_item)
+        return if line_item.from_date.blank?
+
+        from = line_item.from_date.to_date
+        case line_item.product_type.to_s
+        when 'accommodation'
+          nights = line_item.date_range.size
+          checkout = line_item.to_date.to_date + 1
+          "#{l(from, format: '%-d %b')} → #{l(checkout, format: '%-d %b')} · #{t('rates_availabilities.bookings.nights', count: nights)}"
+        when 'service'
+          days = line_item.date_range.size
+          "#{l(from, format: '%-d %b')} – #{l(line_item.to_date.to_date, format: '%-d %b')} · #{t('rates_availabilities.bookings.days', count: days)}"
+        else
+          l(line_item.from_date, format: '%a %-d %b %H:%M')
+        end
+      end
+
+      # The variant only when the selection spans several, the rate plan when the line has one.
+      def rates_availability_booking_rate(line_item, with_variant:)
+        parts = []
+        parts << rates_availability_variant_name(line_item.variant) if with_variant
+        parts << line_item.rate_plan.display_name if line_item.rate_plan
+        parts.join(' · ').presence
+      end
+    end
+  end
+end

data/app/interactors/spree_cm_commissioner/intercity_taxi_order_creator.rb

@@ -46,7 +46,6 @@ module SpreeCmCommissioner
           :pickup_lng,
           :drop_off_lat,
           :drop_off_lng,
-          :passenger_count,
           :pickup_oob_confirmed,
           :drop_off_oob_confirmed,
           :distance_km,

data/app/jobs/spree_cm_commissioner/option_type_variants_public_metadata_updater_job.rb

@@ -7,6 +7,7 @@ module SpreeCmCommissioner
       return if option_type.blank?
 
       option_type.variants.find_each(&:set_options_to_public_metadata!)
+      option_type.rate_plans.find_each(&:cache_options!)
     end
   end
 end

data/app/jobs/spree_cm_commissioner/option_value_variants_public_metadata_updater_job.rb

@@ -7,6 +7,7 @@ module SpreeCmCommissioner
       return if option_value.blank?
 
       option_value.variants.find_each(&:set_options_to_public_metadata!)
+      option_value.rate_plans.find_each(&:cache_options!)
     end
   end
 end

data/app/jobs/spree_cm_commissioner/product_variants_public_metadata_updater_job.rb

@@ -0,0 +1,12 @@
+module SpreeCmCommissioner
+  class ProductVariantsPublicMetadataUpdaterJob < ApplicationUniqueJob
+    def perform(options = {})
+      product = ::Spree::Product.find_by(id: options[:product_id])
+
+      # job can be queued with invalid id or record is created but rolled back or deleted.
+      return if product.blank?
+
+      product.variants_including_master.find_each(&:set_options_to_public_metadata!)
+    end
+  end
+end

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

@@ -36,6 +36,10 @@ module SpreeCmCommissioner
       guest_id_card
     ].freeze
 
+    # Pre-checked for a room type that has no KYC configured yet — the fields most hotels collect
+    # at check-in, so organizers who don't know what to pick get a sensible starting point.
+    ROOM_TYPE_COMMON_FIELDS = %i[guest_name guest_phone_number guest_id_card].freeze
+
     # Maps each KYC bit field to the actual Guest attribute(s) it stores.
     KYC_FIELD_ATTRIBUTES = {
       guest_name: %i[first_name last_name],

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

@@ -22,18 +22,9 @@ module SpreeCmCommissioner
     end
 
     def date_range
-      return [] unless date_present?
       return [] unless permanent_stock?
 
-      # For transit products (e.g., bus, train), only return the departure day,
-      # as the booking represents a single trip rather than a duration.
-      return [from_date.to_date] if transit?
-
-      # For products with a stay or usage period (e.g., hotel, car rental, activities),
-      # return the full date range from start to end, inclusive.
-      return (from_date.to_date..to_date.to_date).to_a if service? || accommodation?
-
-      []
+      SpreeCmCommissioner::BookingDates.for_product_type(product_type, from_date: from_date, to_date: to_date)
     end
 
     def checkin_date

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

@@ -1,9 +1,11 @@
 # Number of guests are depend on the variant, but user is allowed to input custom number of guests
-# which will be stored in public_metadata.
+# which will be stored in public_metadata. 'number_of_guests' is a headcount with no adult/kid
+# split (e.g. intercity taxi passengers) and wins over the adults/kids pair.
 #
 # metadata {
 #   'number_of_adults': 2,
 #   'number_of_kids': 1,
+#   'number_of_guests': 3,
 # }
 module SpreeCmCommissioner
   module LineItemGuestsConcern
@@ -12,11 +14,26 @@ module SpreeCmCommissioner
     included do
       validate :validate_total_adults, if: -> { valid_integer_metadata?('number_of_adults') }
       validate :validate_total_kids, if: -> { valid_integer_metadata?('number_of_kids') }
+      validate :validate_number_of_guests, if: -> { public_metadata.key?('number_of_guests') }
     end
 
     def number_of_adults = metadata_guest_count('number_of_adults') || (variant.number_of_adults * quantity)
     def number_of_kids = metadata_guest_count('number_of_kids') || (variant.number_of_kids * quantity)
-    def number_of_guests = number_of_adults + number_of_kids
+
+    # Without an adults/kids override, scale the variant's own headcount so a variant's
+    # number-of-guests option is honoured; for variants without it this equals adults + kids.
+    def number_of_guests
+      metadata_guest_count('number_of_guests') ||
+        (adults_or_kids_metadata? ? number_of_adults + number_of_kids : variant.number_of_guests * quantity)
+    end
+
+    def number_of_guests=(value)
+      if value.nil?
+        public_metadata.delete('number_of_guests')
+      else
+        public_metadata['number_of_guests'] = value.to_s
+      end
+    end
 
     def allowed_extra_adults = variant.allowed_extra_adults * quantity
     def allowed_extra_kids = variant.allowed_extra_kids * quantity
@@ -28,7 +45,9 @@ module SpreeCmCommissioner
 
     # True when the guest count is set via the public_metadata override (accommodation/transit),
     # i.e. decoupled from quantity rather than derived from variant.number_of_guests * quantity.
-    def custom_guest_count? = public_metadata['number_of_adults'].to_i.positive? || public_metadata['number_of_kids'].to_i.positive?
+    def custom_guest_count?
+      %w[number_of_guests number_of_adults number_of_kids].any? { |key| public_metadata[key].to_i.positive? }
+    end
 
     def generate_remaining_guests
       return if remaining_total_guests.zero?
@@ -86,6 +105,10 @@ module SpreeCmCommissioner
       value.present? && value.to_s.match?(/\A-?\d+\z/)
     end
 
+    def adults_or_kids_metadata?
+      valid_integer_metadata?('number_of_adults') || valid_integer_metadata?('number_of_kids')
+    end
+
     # public_metadata override for a guest count, only when it's a non-negative integer;
     # nil otherwise so callers fall back to the variant default. Keeps number_of_guests >= 0
     # (a negative would make custom_guest_count? false and spin the bump loop in Guests::Create).
@@ -103,5 +126,12 @@ module SpreeCmCommissioner
     def validate_total_kids
       errors.add(:quantity, 'exceed_total_kids') if public_metadata['number_of_kids'].to_i > allowed_total_kids
     end
+
+    # Not capped against the variant: e.g. intercity taxi capacity comes from the vehicle's seats.
+    def validate_number_of_guests
+      return if valid_integer_metadata?('number_of_guests') && public_metadata['number_of_guests'].to_i.positive?
+
+      errors.add(:number_of_guests, :greater_than, count: 0)
+    end
   end
 end

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

@@ -0,0 +1,55 @@
+module SpreeCmCommissioner
+  # The rate plan a line item is sold on. Without one, the line item sells at the variant's own price.
+  module LineItemRatePlannable
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :rate_plan, class_name: 'SpreeCmCommissioner::RatePlan', optional: true, inverse_of: :line_items
+
+      validate :ensure_rate_plan_sellable, if: -> { rate_plan.present? && rate_or_dates_changed? }
+      validate :ensure_rate_open, if: :rate_or_dates_changed?
+    end
+
+    private
+
+    # Rechecked when the dates move too: the new nights are priced from the same rate plan, and one without a
+    # price would sell for nothing. Unchanged bookings aren't, so archiving a rate plan doesn't break them.
+    def rate_or_dates_changed?
+      new_record? || rate_plan_id_changed? || from_date_changed? || to_date_changed?
+    end
+
+    # One unit's price on `date`, or for products without dates when `date` is nil.
+    def unit_price_amount(currency, base_price, date: nil)
+      return rate_plan.price_for_date(date: date, currency: currency) if rate_plan.present?
+
+      price = variant.price_for_date(date: date, currency: currency) if date.present?
+      (price || base_price).amount
+    end
+
+    # A client could otherwise send a cheaper rate plan from another variant, or one the vendor stopped
+    # selling. A date without a price (an independent rate plan missing one, or a fixed amount adjustment
+    # in another currency) would sell for nothing.
+    def ensure_rate_plan_sellable
+      if rate_plan.variant_id != variant_id || !rate_plan.active?
+        errors.add(:rate_plan, :invalid)
+      elsif rate_plan_price_missing?
+        errors.add(:rate_plan, :price_missing)
+      end
+    end
+
+    # A channel manager or the admin can close one rate on a date (RateRestriction) while the room stays open for
+    # the others, so the room's own availability check doesn't catch it. Without a rate plan, it's the base rate.
+    def ensure_rate_open
+      dates = date_range
+      return if dates.empty?
+
+      closed = SpreeCmCommissioner::RateClosings.new(variant_ids: [variant_id], dates: dates).closed?(variant_id, rate_plan)
+      errors.add(:base, :rate_closed) if closed
+    end
+
+    # Products without dates have one price to check, the rate plan's base price.
+    def rate_plan_price_missing?
+      rate_plan.price_for_dates(dates: date_range.presence || [nil], currency: currency).nil?
+    end
+  end
+end