spree_cm_commissioner 2.13.7 → 2.14.0

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

@@ -31,8 +31,6 @@ module SpreeCmCommissioner
 
       validate :validate_trip_stops_for_scheduled_trips
 
-      validates :passenger_count, numericality: { only_integer: true, greater_than: 0 }, allow_nil: true
-
       # Groups LineItems by trip fields. Some fields can be null,
       # so use it with caution. Output:
       # {
@@ -62,8 +60,6 @@ module SpreeCmCommissioner
     def drop_off_trip_stop_id = private_metadata['drop_off_trip_stop_id']&.to_i
     def service_origin_id = private_metadata['service_origin_id']&.to_i
 
-    def passenger_count = public_metadata['passenger_count']&.to_i
-
     def pickup_map_place
       pickup_hash = public_metadata&.dig('pickup_map_place')
       return nil if pickup_hash.blank?
@@ -121,10 +117,6 @@ module SpreeCmCommissioner
       set_private_metadata_value('service_origin_id', value)
     end
 
-    def passenger_count=(value)
-      set_public_metadata_value('passenger_count', value)
-    end
-
     private
 
     def resolve_service_origin_id
@@ -153,14 +145,6 @@ module SpreeCmCommissioner
       end
     end
 
-    def set_public_metadata_value(key, value)
-      if value.nil?
-        public_metadata.delete(key)
-      else
-        public_metadata[key] = value.to_s
-      end
-    end
-
     def set_private_metadata_value(key, value)
       if value.nil?
         private_metadata.delete(key)

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

@@ -33,6 +33,7 @@ module SpreeCmCommissioner
       'month' => 'integer',
       'number-of-adults' => 'integer',
       'number-of-kids' => 'integer',
+      'number-of-guests' => 'integer',
       'kids-age-max' => 'integer',
       'allowed-extra-adults' => 'integer',
       'allowed-extra-kids' => 'integer',
@@ -49,6 +50,13 @@ module SpreeCmCommissioner
       'top-up-amount' => 'integer'
     }.freeze
 
+    # System option types for rate plan terms. RatePlanOptions reads them by these names.
+    RATE_PLAN_RESERVED_OPTIONS = {
+      'meal-plan' => 'string',
+      'refundable' => 'boolean',
+      'free-cancellation-days' => 'integer'
+    }.freeze
+
     included do
       include SpreeCmCommissioner::ParameterizeName
 
@@ -59,6 +67,10 @@ module SpreeCmCommissioner
 
       before_validation :set_reserved_options_attributes, if: :reserved_option?
 
+      # reserved_option? reads the saved name, so a new record never matches it; rate plan system types need
+      # their kind and attr_type from the start, since RatePlanOptions reads them by name.
+      before_validation :set_reserved_options_attributes, if: -> { new_record? && RATE_PLAN_RESERVED_OPTIONS.key?(name) }
+
       after_save :sort_date_time_option_values, if: -> { attr_type == 'date' || attr_type == 'time' }
       after_save :update_variants_metadata, if: :saved_change_to_name?
 
@@ -81,9 +93,10 @@ module SpreeCmCommissioner
     end
 
     def reserved_option?
-      return name_was.in?(RESERVED_OPTIONS.keys) if name_changed?
+      reserved_names = RESERVED_OPTIONS.keys + RATE_PLAN_RESERVED_OPTIONS.keys
+      return name_was.in?(reserved_names) if name_changed?
 
-      name.in?(RESERVED_OPTIONS.keys)
+      name.in?(reserved_names)
     end
 
     def ticket_type?
@@ -91,8 +104,13 @@ module SpreeCmCommissioner
     end
 
     def set_reserved_options_attributes
-      self.attr_type = RESERVED_OPTIONS[name]
-      self.kind = :variant
+      if RATE_PLAN_RESERVED_OPTIONS.key?(name)
+        self.attr_type = RATE_PLAN_RESERVED_OPTIONS[name]
+        self.kind = :rate_plan
+      else
+        self.attr_type = RESERVED_OPTIONS[name]
+        self.kind = :variant
+      end
     end
 
     def sort_date_time_option_values

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

@@ -0,0 +1,62 @@
+module SpreeCmCommissioner
+  # Rate plan terms are option values (source of truth) cached as {option_type_name => option_value_name} in
+  # the `options` column. Follows VariantOptionsConcern, which caches in public_metadata only because
+  # spree_variants is a core table; cm_rate_plans is ours, so it gets a column.
+  module RatePlanOptionsConcern
+    extend ActiveSupport::Concern
+
+    included do
+      # Terms beyond price, e.g. Meal plan: Breakfast, from option types of the `rate_plan` kind.
+      has_many :option_value_rate_plans, class_name: 'SpreeCmCommissioner::OptionValueRatePlan', inverse_of: :rate_plan, dependent: :destroy
+      has_many :option_values, through: :option_value_rate_plans, class_name: 'Spree::OptionValue'
+
+      validate :option_values_are_rate_plan_kind
+      validate :one_option_value_per_option_type
+      validate :free_cancellation_only_when_refundable
+
+      # Before validation, so validations can read the typed cache instead of re-deriving it from option_values.
+      before_validation :cache_options
+
+      delegate :meal_plan, :refundable?, :free_cancellation_days, to: :options
+    end
+
+    # Read as RatePlanOptions, stored as a hash, like Route#route_stops.
+    def options
+      RatePlanOptions.from_hash(read_attribute(:options))
+    end
+
+    def options=(value)
+      self[:options] = value.to_h
+    end
+
+    def cache_options
+      self.options = option_values.each_with_object({}) do |option_value, hash|
+        hash[option_value.option_type.name] = option_value.name
+      end
+    end
+
+    # Reloads option values first: callers like OptionValueRatePlan may hold an instance loaded before the change.
+    def cache_options!
+      option_values.reset
+      cache_options
+      save!
+    end
+
+    private
+
+    def option_values_are_rate_plan_kind
+      errors.add(:option_values, :invalid_kind) unless option_values.all? { |value| value.option_type&.rate_plan? }
+    end
+
+    # A rate plan can't be both "Room only" and "Breakfast".
+    def one_option_value_per_option_type
+      errors.add(:option_values, :duplicate_option_type) if option_values.map(&:option_type_id).uniq.size != option_values.size
+    end
+
+    def free_cancellation_only_when_refundable
+      return if refundable? || free_cancellation_days.nil?
+
+      errors.add(:option_values, :free_cancellation_not_refundable)
+    end
+  end
+end

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

@@ -2,9 +2,21 @@ module SpreeCmCommissioner
   module VariantOptionsConcern
     extend ActiveSupport::Concern
 
+    # VariantOptions#number_of_guests in SQL (explicit number-of-guests, else adults defaulting
+    # to 1 plus kids defaulting to 0), so search matches the capacity the variant reports.
+    GUEST_CAPACITY_SQL = <<~SQL.squish.freeze
+      COALESCE(
+        CAST(spree_variants.public_metadata->'cm_options'->>'number-of-guests' AS INTEGER),
+        COALESCE(CAST(spree_variants.public_metadata->'cm_options'->>'number-of-adults' AS INTEGER), #{VariantOptions::DEFAULT_NUMBER_OF_ADULTS}) +
+        COALESCE(CAST(spree_variants.public_metadata->'cm_options'->>'number-of-kids' AS INTEGER), 0)
+      )
+    SQL
+
     included do
       before_save :set_options_to_public_metadata
 
+      scope :with_guest_capacity, -> (number_of_guests) { where("#{GUEST_CAPACITY_SQL} >= ?", number_of_guests) }
+
       delegate :location,
                :start_date,
                :start_time,

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

@@ -0,0 +1,81 @@
+module SpreeCmCommissioner
+  # The base price lookups (price_in, default_price, price_for_date) override Spree's, so they stay in VariantDecorator.
+  module VariantRatePlannable
+    extend ActiveSupport::Concern
+
+    attr_writer :preloaded_stay_prices, :preloaded_rate_closings
+
+    included do
+      has_many :active_rate_plans, -> { active.order(:position) }, class_name: 'SpreeCmCommissioner::RatePlan', inverse_of: :variant
+      has_many :rate_plans, -> { order(:position) }, class_name: 'SpreeCmCommissioner::RatePlan', inverse_of: :variant, dependent: :destroy
+
+      # Variants with a rate open on every date, by the rule #rates lists them with: the base rate when there's no
+      # active rate plan, else any active one (a derived one also needs the base rate open, RateClosings). Rate-level
+      # only; bookable_on_every_date checks the room-nights themselves.
+      scope :with_open_rate_on_every_date, lambda { |dates|
+        closed = lambda do |rate_condition|
+          SpreeCmCommissioner::RateRestriction
+            .joins(:inventory_item)
+            .where(closed: true, cm_inventory_items: { inventory_date: dates })
+            .where('cm_inventory_items.variant_id = spree_variants.id')
+            .where(rate_condition)
+            .arel.exists
+        end
+
+        active_rate_plans = SpreeCmCommissioner::RatePlan.active.where('cm_rate_plans.variant_id = spree_variants.id')
+        base_open = active_rate_plans.arel.exists.not.and(closed.call('cm_rate_restrictions.rate_plan_id IS NULL').not)
+        own_or_followed = [
+          'cm_rate_restrictions.rate_plan_id = cm_rate_plans.id OR (cm_rate_plans.kind = ? AND cm_rate_restrictions.rate_plan_id IS NULL)',
+          SpreeCmCommissioner::RatePlan.kinds[:derived]
+        ]
+
+        rate_plan_open = active_rate_plans.where(closed.call(own_or_followed).not).arel.exists
+        where(base_open.or(rate_plan_open))
+      }
+    end
+
+    class_methods do
+      # Every variant gets the same batch: one per variant would be a price query per room. Each one only reads its
+      # own [variant_id, rate_plan_id] keys, so it never sees another room's prices. Expects active_rate_plans
+      # preloaded, or this adds a query per variant.
+      def preload_stay_prices(variants, dates:, currency:)
+        stay_prices = SpreeCmCommissioner::StayPrices.new(
+          variants: variants,
+          rate_plans: variants.flat_map(&:active_rate_plans),
+          dates: dates,
+          currency: currency
+        )
+
+        rate_closings = SpreeCmCommissioner::RateClosings.new(
+          variant_ids: variants.map(&:id),
+          dates: dates
+        )
+
+        variants.each do |variant|
+          variant.preloaded_stay_prices = stay_prices
+          variant.preloaded_rate_closings = rate_closings
+        end
+      end
+    end
+
+    # The default rate (the variant's own prices) only when there's no active rate plan. A hotel that also wants
+    # to sell at the plain price adds a 0% rate plan. Rates closed on any of the dates are left out.
+    def rates(dates:, currency:)
+      stay_prices = @preloaded_stay_prices if @preloaded_stay_prices&.matches?(dates: dates, currency: currency)
+      stay_prices ||= SpreeCmCommissioner::StayPrices.new(variants: [self], rate_plans: active_rate_plans, dates: dates, currency: currency)
+
+      rate_closings = @preloaded_rate_closings if @preloaded_rate_closings&.matches?(dates: dates)
+      rate_closings ||= SpreeCmCommissioner::RateClosings.new(variant_ids: [id], dates: dates)
+
+      (active_rate_plans.presence || [nil]).filter_map do |rate_plan|
+        next if rate_closings.closed?(id, rate_plan)
+
+        SpreeCmCommissioner::Rate.new(variant: self, rate_plan: rate_plan, dates: dates, currency: currency, stay_prices: stay_prices)
+      end
+    end
+
+    def stay_price(dates:, currency:)
+      SpreeCmCommissioner::StayPrices.new(variants: [self], rate_plans: [], dates: dates, currency: currency).for_variant(self)
+    end
+  end
+end

data/app/models/spree_cm_commissioner/address_decorator.rb

@@ -6,6 +6,8 @@ module SpreeCmCommissioner
       base.validates :address1, presence: true, if: :require_address1?
       base.validates :city, presence: true, if: :require_city?
       base.validates :country, presence: true, if: :require_country?
+      # Country is optional, so redefine Spree's country delegation to return nil instead of raising.
+      base.delegate :name, :iso3, :iso, :iso_name, to: :country, prefix: true, allow_nil: true
     end
 
     # override to return false instead of true

data/app/models/spree_cm_commissioner/configuration.rb

@@ -8,12 +8,6 @@ module SpreeCmCommissioner
     # preference :favorite_number, :integer
     # preference :supported_locales, :array, default: [:en]
     preference :enabled, :boolean, default: true
-    preference :displayed_product_taxon_ids, :array, default: []
-    preference :top_category_taxon_ids, :array, default: []
-    preference :trending_category_taxon_ids, :array, default: []
-    preference :featured_brand_taxon_ids, :array, default: []
-    preference :featured_vendor_ids, :array, default: []
-    preference :cleared_cache_at, :string
     preference :prepaid_topup_min_amount, :decimal, default: 1
     preference :prepaid_topup_max_amount, :decimal, default: 500
 

data/app/models/spree_cm_commissioner/exports/import_order_guests_csv.rb

@@ -19,7 +19,7 @@ module SpreeCmCommissioner
       # Lets Excel detect UTF-8 so Khmer names render correctly.
       UTF8_BOM = "\uFEFF".freeze
       ORDER_BATCH_SIZE = 200
-      HEADERS = ['Guest', 'Phone Number', 'Order ID', 'Order Status', 'Ticket', 'Order Ticket', 'Guest Ticket'].freeze
+      HEADERS = ['Guest', 'Phone Number', 'Order ID', 'Order Status', 'Ticket', 'QR Data', 'Order Ticket', 'Guest Ticket'].freeze
 
       store_public_metadata :guests_count, :integer, default: 0
       store_private_metadata :exported_by_id, :integer
@@ -85,6 +85,7 @@ module SpreeCmCommissioner
           order.number,
           order.state&.capitalize,
           line_item.name,
+          order.qr_data,
           app_url_helpers.order_page_url(order.qr_data, **app_url_options),
           guest_ticket_link(guest, line_item)
         ]

data/app/models/spree_cm_commissioner/exports/operator_guest_json_gzip.rb

@@ -3,7 +3,9 @@ module SpreeCmCommissioner
     class OperatorGuestJsonGzip < ::SpreeCmCommissioner::Export
       BATCH_INCLUDES = [
         :occupation, :user,
-        { check_ins: %i[check_in_by check_in_session], line_item: [:variant, { order: :bill_address }] }
+        { check_ins: %i[check_in_by check_in_session], line_item: [:variant, { order: :bill_address }],
+          guest_dynamic_fields: [:dynamic_field_option, { dynamic_field: :dynamic_field_options }]
+        }
       ].freeze
 
       RESOURCE_INCLUDES = [
@@ -14,7 +16,11 @@ module SpreeCmCommissioner
         'line_item',
         'line_item.order',
         'line_item.order.billing_address',
-        'line_item.variant'
+        'line_item.variant',
+        'guest_dynamic_fields',
+        'guest_dynamic_fields.dynamic_field_option',
+        'guest_dynamic_fields.dynamic_field',
+        'guest_dynamic_fields.dynamic_field.dynamic_field_options'
       ].freeze
 
       # Check-in group scope: one role, one export. `role` is the requesting operator's check-in group

data/app/models/spree_cm_commissioner/guest.rb

@@ -83,7 +83,7 @@ module SpreeCmCommissioner
     self.whitelisted_ransackable_attributes = %w[first_name last_name phone_number gender contact occupation_id card_type created_at check_in_status]
 
     scope :with_dynamic_fields_and_options, lambda {
-      includes(guest_dynamic_fields: { dynamic_field: :dynamic_field_options })
+      includes(guest_dynamic_fields: [:dynamic_field_option, { dynamic_field: :dynamic_field_options }])
     }
 
     def self.csv_importable_columns

data/app/models/spree_cm_commissioner/integration.rb

@@ -14,10 +14,25 @@ module SpreeCmCommissioner
     validates :incremental_sync_interval_seconds, presence: true, numericality: { only_integer: true, greater_than: 0, less_than_or_equal_to: 3600 }
     validates :full_sync_interval_hours, presence: true, numericality: { only_integer: true, greater_than: 0, less_than_or_equal_to: 168 }
 
+    # Listed from the folder rather than `descendants`, which misses subclasses Zeitwerk hasn't
+    # loaded yet in dev and test.
+    def self.types
+      Dir[SpreeCmCommissioner::Engine.root.join('app/models/spree_cm_commissioner/integrations/*.rb')]
+        .map { |path| "SpreeCmCommissioner::Integrations::#{File.basename(path, '.rb').camelize}" }
+        .sort
+    end
+
     def sync_manager
       raise NotImplementedError, 'Subclasses must implement the sync_manager method'
     end
 
+    # Whether the partner, not BookMe+, sets this variant's per-night stock, prices and closings.
+    # When true, stock resets and dashboard edits leave its inventory items alone, and new nights
+    # start closed until the partner opens them (InventoryItem). Off by default.
+    def inventory_external_wins?(_variant)
+      false
+    end
+
     def restock_external_inventory!(_order, _line_items)
       raise NotImplementedError, 'Subclasses must implement the restock_external_inventory! method'
     end

data/app/models/spree_cm_commissioner/integrations/switch_cm.rb

@@ -0,0 +1,96 @@
+# A hotel connected to switch.cm, which calls our Booking.com-compatible channel-manager API
+# (Spree::Api::SwitchCm) instead of us calling it: it pushes availability, prices and
+# restrictions, and pulls reservations. So there's nothing to pull, hold or unstock externally;
+# polling only runs our own checks (SyncManager).
+#
+# Every switch.cm row shares one Doorkeeper app; the hotels switch.cm may manage are the rows
+# pointing at it. `paused` is the setup state: switch.cm can read the hotel (room list,
+# reservation summary) while it keeps selling on its own counts. `active` with conflict strategy
+# `external_wins` hands the rooms' availability, prices and restrictions over to switch.cm.
+class SpreeCmCommissioner::Integrations::SwitchCm < SpreeCmCommissioner::Integration
+  READABLE_STATUSES = %i[active paused].freeze
+
+  belongs_to :oauth_application, class_name: 'Spree::OauthApplication', optional: false
+
+  # Reservations completed before this aren't in the reservation feeds: switch.cm imports them
+  # through the reservation summary while setting the hotel up.
+  store_public_metadata :connected_at, :datetime
+  alias stored_connected_at connected_at
+
+  before_create :set_connected_at
+  after_commit :sync_unpushed_nights, on: %i[create update]
+
+  # Polling runs the hotel's periodic checks (SyncManager), and the incremental one alerts on
+  # every run while reservations sit unpulled, so the column's 10-second default would flood
+  # Telegram. Full runs daily upkeep.
+  attribute :incremental_sync_interval_seconds, :integer, default: -> { SyncStrategies::IncrementalSyncStrategy::UNSEEN_AFTER.to_i }
+
+  scope :readable, -> { where(status: READABLE_STATUSES) }
+
+  # override
+  def sync_manager
+    SyncManager.new(integration: self)
+  end
+
+  # Only for rooms switch.cm can see (RoomCatalog): a hotel's other products, and rooms that need
+  # confirmation, keep BookMe+ counts since switch.cm never pushes them.
+  # override
+  def inventory_external_wins?(variant)
+    owns_inventory? && variant.accommodation? && !variant.need_confirmation?
+  end
+
+  def owns_inventory?
+    active? && external_wins?
+  end
+
+  # switch.cm pulls reservations, so a BookMe+ sale needs nothing from it at checkout, and the
+  # hotel's own cancellation rules decide whether a booking can be cancelled.
+  # override
+  def unstock_external_inventory!(_order, _line_items); end
+
+  # override
+  def restock_external_inventory!(_order, _line_items); end
+
+  # override
+  def sync_item_availability!(_options = {}); end
+
+  # override
+  def external_inventory_items(_order)
+    []
+  end
+
+  # override
+  def external_inventory_item_status(_order, _options)
+    {}
+  end
+
+  # A row saved without this class's callbacks (e.g. created as the base Integration) has no stamp;
+  # nil would hide every reservation from the feeds and from UnseenRoomNights, so it falls back to
+  # the row's creation time, which is what the stamp would have been.
+  def connected_at
+    stored_connected_at || created_at
+  end
+
+  # While switch.cm owns the rooms, nights it hasn't pushed stay closed, so the admin page shows
+  # this until the first full push lands.
+  def push_progress
+    Inventory::PushedNights.new(self).progress
+  end
+
+  private
+
+  # Checks the stored value, not #connected_at: Rails sets created_at before create callbacks run,
+  # so the fallback would already answer and the stamp would never be written.
+  def set_connected_at
+    self.connected_at = Time.current.iso8601 if stored_connected_at.nil?
+  end
+
+  # Taking over closes the rooms' unpushed nights; letting go (paused, disconnected, or another
+  # conflict strategy) reopens them, while pushed nights keep switch.cm's last numbers.
+  def sync_unpushed_nights
+    owned_before = status_before_last_save.to_s == 'active' && conflict_strategy_before_last_save.to_s == 'external_wins'
+    return if owned_before == owns_inventory?
+
+    Inventory::PushedNights.new(self).reconcile_unpushed!
+  end
+end

data/app/models/spree_cm_commissioner/inventory_item.rb

@@ -16,6 +16,11 @@ module SpreeCmCommissioner
 
     has_many :prices, class_name: 'Spree::Price', inverse_of: :inventory_item, dependent: :destroy
 
+    # The variant's own prices for this date. A rate plan stores its date price on the same
+    # inventory item, so `prices` can hold several rows per currency; reading or writing through `prices`
+    # would show or overwrite a rate plan's price as the variant's. Rows built here get `rate_plan_id: nil`.
+    has_many :variant_prices, -> { where(rate_plan_id: nil) }, class_name: 'Spree::Price', inverse_of: :inventory_item
+
     # Scoped to `unavailable` (not `reserved_or_on_hold`) so operator-locked seats are exposed
     # everywhere a sold seat is — including the storefront API, which is what lets locked seats render
     # as unavailable in the app with no client change.
@@ -27,6 +32,9 @@ module SpreeCmCommissioner
 
     has_many :lock_movements, class_name: 'SpreeCmCommissioner::InventoryLockMovement', inverse_of: :inventory_item
 
+    # Closings of single rates on this date; closing every rate is `closed`.
+    has_many :rate_restrictions, class_name: 'SpreeCmCommissioner::RateRestriction', inverse_of: :inventory_item, dependent: :delete_all
+
     # Validation
     validates :quantity_available, numericality: { greater_than_or_equal_to: 0 }
     validates :quantity_on_hold, numericality: { greater_than_or_equal_to: 0 }
@@ -34,13 +42,25 @@ module SpreeCmCommissioner
     validates :quantity_locked_on_hold, numericality: { greater_than_or_equal_to: 0 }
     validates :max_capacity, numericality: { greater_than_or_equal_to: 0 } # Originally inventory of each variant.
     validates :inventory_date, presence: true, if: :permanent_stock?
-    validates :variant_id, uniqueness: { scope: :inventory_date, message: -> (object, _data) { "The variant is taken on #{object.inventory_date}" } }
+    # Create only: most saves just touch stock quantities, and the key below can't change afterwards. Still needed
+    # for NULL inventory_date rows, which the unique index does not cover.
+    validates :variant_id, uniqueness: { scope: :inventory_date, message: -> (object, _data) { "The variant is taken on #{object.inventory_date}" } },
+                           on: :create
+    validate :variant_and_inventory_date_unchanged, on: :update
 
     # Scope
     scope :active, -> { where(inventory_date: nil).or(where('inventory_date >= ?', Time.zone.today)) }
 
+    # Same rule as CachedInventoryItem#sellable?, which booking checks: open for sale and not sold out.
+    scope :bookable_on, -> (dates) { where(inventory_date: dates, closed: false).where('quantity_available > 0') }
+
     before_save -> { self.product_type = variant.product_type }, if: -> { product_type.nil? }
 
+    # A night whose inventory a partner owns (Integration#inventory_external_wins?) starts closed: its
+    # count is only our seed from the physical room count, which the partner may already have sold
+    # elsewhere. The partner's first availability push opens it.
+    before_create -> { self.closed = true }, if: -> { permanent_stock? && variant&.inventory_external_wins? }
+
     after_commit :schedule_product_cache_invalidation
     after_commit :publish_live_stock_status_to_firestore
 
@@ -95,8 +115,10 @@ module SpreeCmCommissioner
       available_before.to_i + locked_before.to_i
     end
 
+    # nil above MAX_DISPLAY_STOCK: "3 left" helps a guest decide, "20 left" when 300 are free misleads. Apps read
+    # nil as plenty, not sold out.
     def public_quantity_available
-      [quantity_available, MAX_DISPLAY_STOCK].min
+      quantity_available if quantity_available <= MAX_DISPLAY_STOCK
     end
 
     # How many seats an operator has taken off sale for this date.
@@ -108,7 +130,7 @@ module SpreeCmCommissioner
     end
 
     def price_in(currency)
-      prices.detect { |price| price.currency == currency } || prices.build(currency: currency)
+      variant_prices.detect { |price| price.currency == currency } || variant_prices.build(currency: currency)
     end
 
     # This method is only used when admin update stock
@@ -194,5 +216,12 @@ module SpreeCmCommissioner
       expires_at = [inventory_date.end_of_day + 7.days, 1.day.from_now].max
       (expires_at - Time.zone.now).to_i
     end
+
+    private
+
+    def variant_and_inventory_date_unchanged
+      errors.add(:variant_id, :cannot_be_changed) if will_save_change_to_variant_id?
+      errors.add(:inventory_date, :cannot_be_changed) if will_save_change_to_inventory_date?
+    end
   end
 end

data/app/models/spree_cm_commissioner/line_item_decorator.rb

@@ -95,6 +95,7 @@ module SpreeCmCommissioner
       base.include SpreeCmCommissioner::ProductDelegation
       base.include SpreeCmCommissioner::LineItemOpenDatedTrippable
       base.include SpreeCmCommissioner::LineItemBundleable
+      base.include SpreeCmCommissioner::LineItemRatePlannable
       base.include SpreeCmCommissioner::KycBitwise
     end
 
@@ -118,21 +119,21 @@ module SpreeCmCommissioner
       self.product_type = variant.product_type
       self.from_date = opts.delete(:from_date)&.to_datetime
       self.to_date = opts.delete(:to_date)&.to_datetime
+      self.rate_plan_id = opts.delete(:rate_plan_id).presence || rate_plan_id
 
       base_price = variant.price_in(currency)
 
       self.price = if permanent_stock?
                      date_range.map do |date|
-                       selected_price = variant.price_for_date(date: date, currency: currency) || base_price
-                       (selected_price.amount || 0) + variant.price_modifier_amount_in(currency, opts.merge(date: date))
+                       (unit_price_amount(currency, base_price, date: date) || 0) + variant.price_modifier_amount_in(currency, opts.merge(date: date))
                      end.sum
                    else
-                     (base_price.amount || 0) + variant.price_modifier_amount_in(currency, opts)
+                     (unit_price_amount(currency, base_price) || 0) + variant.price_modifier_amount_in(currency, opts)
                    end
     end
 
     # override to calculate price per date for permanent stock
-    def update_price # rubocop:disable Metrics/PerceivedComplexity
+    def update_price
       # Skip price updates for ticket transfer orders to preserve custom transfer pricing
       return if order&.ticket_transfer?
       # prepaid_top_up line items carry a one-time custom_price set at creation (see
@@ -144,11 +145,10 @@ module SpreeCmCommissioner
       base_price = variant.price_in(order.currency)
       self.price = if permanent_stock?
                      date_range.map do |date|
-                       selected_price = variant.price_for_date(date: date, currency: order.currency) || base_price
-                       selected_price.amount || 0
+                       unit_price_amount(order.currency, base_price, date: date) || 0
                      end.sum
                    else
-                     base_price.amount || 0
+                     unit_price_amount(order.currency, base_price) || 0
                    end
     end
 

data/app/models/spree_cm_commissioner/maintenance_tasks/cache_invalidation.rb

@@ -3,13 +3,29 @@ module SpreeCmCommissioner
   module MaintenanceTasks
     class CacheInvalidation < MaintenanceTask
       def maintain
-        return if ENV['CACHE_AUTO_INVALIDATION_DISABLED'] == 'yes'
+        if ENV['CACHE_AUTO_INVALIDATION_DISABLED'] == 'yes'
+          log_invalidation('skipped: CACHE_AUTO_INVALIDATION_DISABLED')
+          return
+        end
+
+        result = SpreeCmCommissioner::ApiCaches::Invalidate.call(model: maintainable.class.name, id: maintainable.id)
 
-        if maintainable.is_a?(SpreeCmCommissioner::HomepageBackground) || maintainable.is_a?(Spree::Menu)
-          SpreeCmCommissioner::HomepageDataLoader.clear_cache
+        if result.success?
+          log_invalidation('sent', patterns: result.value[:api_patterns])
+        else
+          log_invalidation("failed: #{result.error}")
         end
+      end
+
+      private
 
-        SpreeCmCommissioner::ApiCaches::Invalidate.call(model: maintainable.class.name, id: maintainable.id)
+      # Each path costs money on CloudFront, so every outcome is logged and kept on the task for troubleshooting.
+      def log_invalidation(outcome, patterns: [])
+        log_run("Invalidation #{outcome} #{patterns.join(', ')}".strip)
+        CmAppLogger.log(
+          label: "#{self.class.name} #{outcome}",
+          data: { maintenance_task_id: id, maintainable_type: maintainable_type, maintainable_id: maintainable_id, patterns: patterns }
+        )
       end
     end
   end

data/app/models/spree_cm_commissioner/maintenance_tasks/event.rb

@@ -26,7 +26,7 @@ module SpreeCmCommissioner
 
       # Denormalises maintainable's price range onto EventMetadata#min_price/max_price/currency
       # so the event-details bar can show "from $X" without loading the ticket list. Triggered
-      # by PriceDecorator's after_commit hook via a pending task, and run unconditionally here.
+      # by PriceDecorator's after_commit hook via a pending task. Only saves when the range moved.
       def refresh_price_range
         currency = Spree::Store.default.default_currency
 
@@ -35,11 +35,12 @@ module SpreeCmCommissioner
                                  .where(variant_id: priced_variant_ids, currency: currency)
                                  .pick(Arel.sql('MIN(amount)'), Arel.sql('MAX(amount)'))
 
-        maintainable.update!(
+        maintainable.assign_attributes(
           min_price: min_amount&.to_s,
           max_price: max_amount&.to_s,
           currency: min_amount.present? ? currency : nil
         )
+        maintainable.save! if maintainable.changed?
       end
 
       def update_conversion_for(product_taxon)