spree_cm_commissioner 2.11.0 → 2.12.0.pre.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58bbc65915f1f69096fabf6a1778dd9d810ebdbf8e788c2b1597e3b2173f2204
-  data.tar.gz: c32858179db78672e07bc34c5f7395b59b228d5585e35647c3d5486cf0c0ea9c
+  metadata.gz: 1bcaa0a7cc8d39b507cd072bfd4576b28f72c83f2344b11ef2097306aa8454dd
+  data.tar.gz: bf8156fe0e0f2a41febcacc07188e8b0bbd9b2cd79c3ccad5a8d1394fa307db7
 SHA512:
-  metadata.gz: 6493ccc10ddcb0dfae06115f11168207bdee8f8d687367108ba59e41885e10a989f8adcb17a220019039ef3a5c224ab3fe4356c6f1e90ae9130e4a607347e015
-  data.tar.gz: 363d64fd5b2aa2f809163134dd050b85d46d529fe35a34994381c3bc7861acd4f57afab353fdd2772081e019a5f49eb78f4d9141ee9d7a44e06991b07170d764
+  metadata.gz: 19b750a2f5c27cabbc5c507a0e50424a26e295aefa94369787ff490376475f63e56993950e87a9a1b2c3be624f6ec29f2192a51a7e019bfed05e3ee4dcb54018
+  data.tar.gz: 4acf6f94be21c3960010398b9a431b950b2e3e7bffed455096ea0dc2ed05fca769bd53884b6ed26be86cc11db2a8c220c73711be800bccebf7fc005854454f11

data/Gemfile.lock

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

data/app/controllers/spree/api/v2/operator/check_ins_controller.rb

@@ -10,10 +10,14 @@ module Spree
           CACHE_EXPIRES_IN = 1.minute
 
           def collection
-            @collection ||= SpreeCmCommissioner::CheckIn
-                            .where(checkinable_type: 'Spree::Taxon', checkinable_id: params[:taxon_id])
-                            .page(params[:page])
-                            .per(params[:per_page])
+            @collection ||= if restricted?
+                              SpreeCmCommissioner::CheckIn.none
+                            else
+                              SpreeCmCommissioner::CheckIn
+                                .where(checkinable_type: 'Spree::Taxon', checkinable_id: params[:taxon_id])
+                                .page(params[:page])
+                                .per(params[:per_page])
+                            end
           end
 
           # override
@@ -41,6 +45,20 @@ module Spree
 
           private
 
+          # Non-organizers may only see check-in history for an event they're assigned
+          # to, and only while it's ongoing — once it ends, it becomes organizer-owned
+          # history (admins assign themselves the organizer role explicitly if they
+          # need access). A missing/nonexistent taxon_id is restricted the same way.
+          def restricted?
+            return false if spree_current_user.organizer?
+
+            taxon = Spree::Taxon.find_by(id: params[:taxon_id])
+            return true if taxon.nil?
+            return true unless spree_current_user.events.exists?(id: taxon.id)
+
+            taxon.ended?
+          end
+
           def model_class
             SpreeCmCommissioner::CheckIn
           end

data/app/controllers/spree/api/v2/operator/dashboard_crew_events_controller.rb

@@ -7,7 +7,7 @@ module Spree
 
           def collection
             SpreeCmCommissioner::DashboardCrewEventQuery.new(
-              user_id: spree_current_user.id,
+              user: spree_current_user,
               section: params[:section] || 'incoming'
             ).events
           end

data/app/controllers/spree/api/v2/operator/event_charts_controller.rb

@@ -7,23 +7,31 @@ module Spree
           ADDITIONAL_FIELDS = %i[participation entry_type].freeze
 
           def index
-            kyc_fields = fetch_filtered_kyc_fields
-            types = ADDITIONAL_FIELDS + kyc_fields
-
-            resources = types.map do |type|
-              # Create unique ID by using chart_type as the identifier
-              SpreeCmCommissioner::EventChart.new(
-                id: type.to_s,
-                chart_type: type,
-                product_charts: nil
-              )
-            end
+            resources = if restricted?
+                          []
+                        else
+                          kyc_fields = fetch_filtered_kyc_fields
+                          types = ADDITIONAL_FIELDS + kyc_fields
+
+                          types.map do |type|
+                            # Create unique ID by using chart_type as the identifier
+                            SpreeCmCommissioner::EventChart.new(
+                              id: type.to_s,
+                              chart_type: type,
+                              product_charts: nil
+                            )
+                          end
+                        end
 
             render json: SpreeCmCommissioner::V2::Operator::PieChartEventAggregatorSerializer.new(resources).serializable_hash
           end
 
           def resource
-            @resource = event_chart_aggregator_queries.call
+            @resource = if restricted?
+                          SpreeCmCommissioner::EventChart.new(id: params[:id], chart_type: params[:id] || 'participation', product_charts: [])
+                        else
+                          event_chart_aggregator_queries.call
+                        end
           end
 
           def resource_serializer
@@ -32,6 +40,20 @@ module Spree
 
           private
 
+          # Non-organizers may only see chart data for an event they're assigned to,
+          # and only while it's ongoing — once it ends, it becomes organizer-owned
+          # history (admins assign themselves the organizer role explicitly if they
+          # need access). A missing/nonexistent taxon_id is restricted the same way.
+          def restricted?
+            return false if spree_current_user&.organizer?
+
+            taxon = Spree::Taxon.find_by(id: params[:taxon_id])
+            return true if taxon.nil?
+            return true unless spree_current_user&.events&.exists?(id: taxon.id)
+
+            taxon.ended?
+          end
+
           def event_chart_aggregator_queries
             SpreeCmCommissioner::EventChartQueries.new(
               taxon_id: params[:taxon_id],

data/app/controllers/spree/api/v2/resource_controller_decorator.rb

@@ -18,6 +18,13 @@ module Spree
           request.headers['X-Cm-App-Name']
         end
 
+        # Set by DefaultInterceptor (cm-market-app/packages/core) on every request, across every
+        # app (customer, operator, terminal) that shares it — the single source for device_id,
+        # replacing the old per-endpoint params[:device_id] (never actually sent by any client).
+        def device_id
+          request.headers['X-Cm-Device-Id']
+        end
+
         def required_schema_validation!
           return true if required_schema.nil?
 

data/app/controllers/spree/api/v2/storefront/draft_orders_controller.rb

@@ -16,7 +16,7 @@ module Spree
               user: spree_current_user,
               store: current_store,
               currency: current_currency,
-              options: { device_id: params[:device_id], last_ip_address: request.remote_ip }
+              options: { device_id: device_id, last_ip_address: request.remote_ip }
             )
 
             if result.success?

data/app/controllers/spree/api/v2/storefront/queue_draft_orders_controller.rb

@@ -0,0 +1,55 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        class QueueDraftOrdersController < ::Spree::Api::V2::ResourceController
+          # Creating the order (once the job runs) acquires the inventory hold, so honor the
+          # load-test bypass here too, same as DraftOrdersController.
+          include SpreeCmCommissioner::LoadTestBypassable
+
+          # Accepts a draft order request without building it: writes a queued Firestore status
+          # document and schedules the real build (SpreeCmCommissioner::DraftOrders::Create) on a
+          # background job. The app watches the returned document for the eventual outcome
+          # instead of waiting on this request.
+          #
+          # Endpoint: POST /api/v2/storefront/queue_draft_orders
+          # Params: same as POST /api/v2/storefront/draft_orders — line_items: Array of
+          #   { variant_id:, quantity:, options: {}, public_metadata: {}, private_metadata: {} } (required)
+          def create
+            result = SpreeCmCommissioner::QueueDraftOrders::Enqueue.call(
+              create_type: 'generic',
+              creation_params: {
+                line_items: draft_order_line_items,
+                user: spree_current_user,
+                store: current_store,
+                currency: current_currency,
+                options: { device_id: device_id, last_ip_address: request.remote_ip }
+              },
+              locale: I18n.locale.to_s
+            )
+
+            if result.success?
+              render_serialized_payload { result.value }
+            else
+              render_error_payload(result.error)
+            end
+          end
+
+          private
+
+          # .to_h.deep_symbolize_keys converts every level (including line_items and their nested
+          # options/metadata) from ActionController::Parameters into plain Ruby Hashes with symbol
+          # keys — required because this crosses an ActiveJob serialization boundary
+          # (QueueDraftOrders::ProcessJob), unlike DraftOrdersController's version of this method,
+          # which hands Parameters straight to DraftOrders::Create within the same request.
+          def draft_order_line_items
+            params.permit(line_items: [:variant_id, :quantity, { options: {}, public_metadata: {}, private_metadata: {} }])
+                  .to_h
+                  .deep_symbolize_keys
+                  .fetch(:line_items, [])
+          end
+        end
+      end
+    end
+  end
+end

data/app/interactors/spree_cm_commissioner/payment_incomplete_notification_sender.rb

@@ -8,12 +8,23 @@ module SpreeCmCommissioner
       SpreeCmCommissioner::OrderGeneralNotification.with(
         notificable: order,
         title: title,
-        message: message(order)
+        message: message(order),
+        payload: payload(order)
       ).deliver_later(order.user)
     end
 
     private
 
+    # Overrides notification_type so the app can route this tap to the payment screen instead of
+    # the booking details every other OrderGeneralNotification lands on. The screen loads the cart
+    # by token, not by number, so the token has to ride along or the tap has nothing to open.
+    def payload(order)
+      {
+        notification_type: 'payment_incomplete_notification',
+        order_token: order.token
+      }
+    end
+
     def title
       I18n.t('notifications.spree_cm_commissioner.payment_incomplete_notification.title')
     end

data/app/jobs/spree_cm_commissioner/inventory_items/bulk_adjust_quantities_on_hold_job.rb

@@ -24,13 +24,17 @@ module SpreeCmCommissioner
         "order:#{options[:order_id]}:hold:#{adjustments_fingerprint(options[:inventory_id_and_quantities])}"
       end
 
-      # Readable, order-independent fingerprint of the adjustment payload, e.g. "1=2,2=-1".
+      # Readable, order-independent fingerprint of the adjustment payload, e.g. "1=2,2=-1:locked".
       # Delimiter hierarchy: ":" separates key fields, "," separates adjustments, "=" pairs id/qty.
+      #
+      # The pool is part of the identity: a mixed order can carry a public and a locked adjustment
+      # with the same inventory_id and quantity, and without this they fingerprint identically — so
+      # one of the two would be dropped as a duplicate and its counter never mirrored.
       def adjustments_fingerprint(adjustments)
         Array(adjustments)
-          .map { |adj| adj.with_indifferent_access.values_at(:inventory_id, :quantity) }
-          .sort_by { |inventory_id, quantity| [inventory_id.to_s, quantity.to_s] }
-          .map { |inventory_id, quantity| "#{inventory_id}=#{quantity}" }
+          .map { |adj| adj.with_indifferent_access.values_at(:inventory_id, :quantity, :locked) }
+          .sort_by { |inventory_id, quantity, locked| [inventory_id.to_s, quantity.to_s, locked.to_s] }
+          .map { |inventory_id, quantity, locked| locked ? "#{inventory_id}=#{quantity}:locked" : "#{inventory_id}=#{quantity}" }
           .join(',')
       end
 

data/app/jobs/spree_cm_commissioner/queue_draft_orders/process_job.rb

@@ -0,0 +1,23 @@
+module SpreeCmCommissioner
+  module QueueDraftOrders
+    # Thin trigger for QueueDraftOrders::Process — owns only the locale wrapping (so any
+    # user-facing message the create call surfaces renders in the request's original locale, not
+    # the job worker's default), not the order-creation/Firestore-publishing logic itself.
+    class ProcessJob < SpreeCmCommissioner::ApplicationJob
+      # Own queue (not the inherited :default) — before this feature, order creation happened
+      # synchronously in the request cycle, i.e. at effectively top priority. Sharing :default's
+      # weight-3 slot with unrelated background work would let a :default backlog slow down
+      # checkout, the opposite of what a flash-sale/high-demand feature should do. See
+      # bookmebus/cm-market-server's config/sidekiq.yml for the matching queue weight.
+      queue_as :queue_draft_orders
+
+      def perform(document_path, create_type, creation_params, locale = nil)
+        I18n.with_locale(locale.presence || I18n.default_locale) do
+          SpreeCmCommissioner::QueueDraftOrders::Process.call(
+            document_path: document_path, create_type: create_type, creation_params: creation_params
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -51,6 +51,8 @@ module SpreeCmCommissioner
       store_public_metadata :max_price, :string
       store_public_metadata :currency, :string
 
+      store_public_metadata :organizer_rule, :text
+
       store_public_metadata :spotify_embed_url, :string
       store_public_metadata :spotify_embed_skeleton_color, :string, default: '#900033'
 

data/app/models/spree_cm_commissioner/inventory_item.rb

@@ -22,6 +22,8 @@ module SpreeCmCommissioner
     # Validation
     validates :quantity_available, numericality: { greater_than_or_equal_to: 0 }
     validates :quantity_on_hold, numericality: { greater_than_or_equal_to: 0 }
+    validates :quantity_locked, numericality: { greater_than_or_equal_to: 0 }
+    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}" } }
@@ -40,15 +42,27 @@ module SpreeCmCommissioner
     # This is temporary until we have a more robust cache invalidation strategy in place.
     def schedule_product_cache_invalidation
       return unless ecommerce?
-      return unless saved_change_to_quantity_available?
+      return unless saved_change_to_quantity_available? || saved_change_to_quantity_locked?
 
-      # Only fires on in_stock status transition (0 ↔ N); non-zero to non-zero changes are skipped.
-      old_val, new_val = saved_change_to_quantity_available
-      return if old_val.to_i.positive? && new_val.to_i.positive?
+      # Only fires on an in_stock status transition (0 ↔ N); non-zero to non-zero changes are skipped.
+      #
+      # Measured across BOTH pools, because Variant#in_stock? counts both. Watching quantity_available
+      # alone would miss an agent buying out the locked pool while public stock was already 0 — the
+      # column never moves, so no task is scheduled and the card keeps advertising stock that is gone.
+      return if total_quantity_before_last_save.positive? == (quantity_available + quantity_locked).positive?
 
       SpreeCmCommissioner::MaintenanceTasks::CacheInvalidation.pending.create_or_find_by(maintainable: variant.product)
     end
 
+    # Both pools as they stood before this save. saved_change_to_* is nil for a column that did not
+    # change, so an unchanged pool falls back to its current value rather than to zero.
+    def total_quantity_before_last_save
+      available_before = saved_change_to_quantity_available&.first || quantity_available
+      locked_before = saved_change_to_quantity_locked&.first || quantity_locked
+
+      available_before.to_i + locked_before.to_i
+    end
+
     def public_quantity_available
       [quantity_available, MAX_DISPLAY_STOCK].min
     end
@@ -87,19 +101,21 @@ module SpreeCmCommissioner
       end
     end
 
-    def redis_key
-      "inventory:#{id}"
+    # Stock and hold keys. `locked: true` addresses the withheld pool — see LineItem#locked_stock?,
+    # which is what every caller on the checkout path passes.
+    def redis_key(locked: false)
+      locked ? "inventory:locked:#{id}" : "inventory:#{id}"
     end
 
-    def redis_hold_key
-      "inventory:on_hold:#{id}"
+    def redis_hold_key(locked: false)
+      locked ? "inventory:locked_on_hold:#{id}" : "inventory:on_hold:#{id}"
     end
 
     def quantity_in_redis
       SpreeCmCommissioner.inventory_redis_pool.with { |redis| redis.get(redis_key).to_i }
     end
 
-    def adjust_quantity_in_redis(quantity)
+    def adjust_quantity_in_redis(quantity, locked: false)
       SpreeCmCommissioner.inventory_redis_pool.with do |redis|
         # Always update Redis cache, even if it doesn't exist yet.
         # This prevents admin adjustments from being lost when cache is later initialized.
@@ -116,7 +132,7 @@ module SpreeCmCommissioner
           return new_value
         LUA
 
-        redis.eval(script, keys: [redis_key], argv: [quantity, redis_expired_in])
+        redis.eval(script, keys: [redis_key(locked: locked)], argv: [quantity, redis_expired_in])
       end
     end
 

data/app/models/spree_cm_commissioner/line_item_decorator.rb

@@ -16,6 +16,7 @@ module SpreeCmCommissioner
       }, through: :variant
 
       base.has_many :taxons, class_name: 'Spree::Taxon', through: :product
+
       base.has_many :guests, class_name: 'SpreeCmCommissioner::Guest', dependent: :destroy
       base.has_many :guests_with_blocks, -> { where.not(block_id: nil) }, class_name: 'SpreeCmCommissioner::Guest'
       base.has_many :reserved_blocks, through: :guests, class_name: 'SpreeCmCommissioner::ReservedBlock'
@@ -43,6 +44,12 @@ module SpreeCmCommissioner
 
       base.store_public_metadata :completion_steps, :array
 
+      # Set by DraftOrders::Create from the verified PrivateSale, never from params — the client
+      # cannot ask for locked stock, the server decides which lines the token covers. Persisted
+      # with the line item, so the same value answers AvailabilityValidator on this save and
+      # Restock on a cancellation months later.
+      base.store_private_metadata :locked_stock, :boolean, default: false
+
       base.accepts_nested_attributes_for :guests, allow_destroy: true
 
       def base.json_api_columns
@@ -265,7 +272,7 @@ module SpreeCmCommissioner
     def sufficient_stock?
       return true if order&.ticket_transfer?
 
-      SpreeCmCommissioner::Stock::LineItemAvailabilityChecker.new(self).can_supply?(quantity)
+      SpreeCmCommissioner::Stock::LineItemAvailabilityChecker.new(self).checker.can_supply?(quantity)
     end
 
     def month

data/app/models/spree_cm_commissioner/redis_stock/cached_inventory_items_builder.rb

@@ -8,32 +8,51 @@ module SpreeCmCommissioner
       end
 
       # output: [ CachedInventoryItem(...), CachedInventoryItem(...) ]
+      #
+      # Reads BOTH pools in one MGET. Reporting only the pool a caller asked for would mean taking a
+      # pool argument here and threading it through every service that warms or reads stock; four
+      # numbers in the row we already fetch costs one MGET either way.
       def call
-        stock_keys = inventory_items.map(&:redis_key)
-        hold_keys = inventory_items.map(&:redis_hold_key)
-        all_keys = stock_keys + hold_keys
-        return [] unless all_keys.any?
+        return [] if inventory_items.empty?
 
-        all_counts = SpreeCmCommissioner.inventory_redis_pool.with { |redis| redis.mget(*all_keys) }
-        stock_counts = all_counts.first(inventory_items.length)
-        hold_counts = all_counts.last(inventory_items.length)
+        keys = pool_keys
+        counts = SpreeCmCommissioner.inventory_redis_pool.with { |redis| redis.mget(*keys.flatten) }
+        counts_by_pool = counts.each_slice(inventory_items.length).to_a
 
-        inventory_items.map.with_index do |inventory_item, i|
-          ::SpreeCmCommissioner::CachedInventoryItem.new(
-            inventory_key: stock_keys[i],
-            inventory_hold_key: hold_keys[i],
-            active: inventory_item.active?,
-            quantity_available: cache_inventory(stock_keys[i], inventory_item, inventory_item.quantity_available, stock_counts[i]),
-            quantity_on_hold: cache_inventory(hold_keys[i], inventory_item, inventory_item.quantity_on_hold, hold_counts[i]),
-            max_capacity: inventory_item.max_capacity,
-            inventory_item_id: inventory_item.id,
-            variant_id: inventory_item.variant_id
-          )
-        end
+        inventory_items.map.with_index { |item, i| build_cached_item(item, i, keys, counts_by_pool) }
       end
 
       private
 
+      # [public_stock, public_hold, locked_stock, locked_hold] — one row of keys per pool, each in the
+      # same item order, so a slice of the MGET result lines up with the item at the same index.
+      def pool_keys
+        [
+          inventory_items.map(&:redis_key),
+          inventory_items.map(&:redis_hold_key),
+          inventory_items.map { |item| item.redis_key(locked: true) },
+          inventory_items.map { |item| item.redis_hold_key(locked: true) }
+        ]
+      end
+
+      def build_cached_item(item, index, keys, counts_by_pool)
+        stock_keys, hold_keys, locked_keys, locked_hold_keys = keys
+        stock, hold, locked, locked_hold = counts_by_pool
+
+        ::SpreeCmCommissioner::CachedInventoryItem.new(
+          inventory_key: stock_keys[index],
+          inventory_hold_key: hold_keys[index],
+          active: item.active?,
+          quantity_available: cache_inventory(stock_keys[index], item, item.quantity_available, stock[index]),
+          quantity_on_hold: cache_inventory(hold_keys[index], item, item.quantity_on_hold, hold[index]),
+          quantity_locked: cache_inventory(locked_keys[index], item, item.quantity_locked, locked[index]),
+          quantity_locked_on_hold: cache_inventory(locked_hold_keys[index], item, item.quantity_locked_on_hold, locked_hold[index]),
+          max_capacity: item.max_capacity,
+          inventory_item_id: item.id,
+          variant_id: item.variant_id
+        )
+      end
+
       def cache_inventory(key, inventory_item, db_value, count_in_redis)
         return count_in_redis.to_i if count_in_redis.present?
         return db_value unless inventory_item.active?

data/app/models/spree_cm_commissioner/stock/availability_checker.rb

@@ -3,27 +3,35 @@ module SpreeCmCommissioner
     class AvailabilityChecker
       attr_reader :variant, :options, :error_message
 
+      # options[:locked] checks the operator's withheld allotment instead of public stock — set for a
+      # line item whose LineItem#locked_stock? is true.
       def initialize(variant, options = {})
         @variant = variant
         @options = options
         @error_message = nil
       end
 
-      def can_supply?(quantity = 1)
+      # Can `quantity` be supplied? By default from THIS line's pool — which is what add-to-cart gates
+      # on, so it must never quietly include stock the caller cannot buy.
+      #
+      # include_locked: true adds the locked pool to the total instead, for callers asking "is this
+      # worth showing at all" rather than "may this order have it". See Variant#in_stock?.
+      def can_supply?(quantity = 1, include_locked: false)
         return false unless variant.available?
         return true unless variant.should_track_inventory?
         return true if variant.backorderable?
         return true if variant.need_confirmation?
+        return false if cached_inventory_items.empty?
 
-        variant_available?(quantity)
+        cached_inventory_items.all? { |item| item.active? && quantity_in_pool(item, include_locked: include_locked) >= quantity }
       end
 
-      def variant_available?(quantity = 1)
-        return false if cached_inventory_items.empty?
+      # The cache row carries both pools, so choosing between them is a read, not another Redis trip.
+      def quantity_in_pool(item, include_locked: false)
+        return item.quantity_available + item.quantity_locked if include_locked
+        return item.quantity_locked if options[:locked]
 
-        cached_inventory_items.all? do |cached_inventory_item|
-          cached_inventory_item.active? && cached_inventory_item.quantity_available >= quantity
-        end
+        item.quantity_available
       end
 
       def cached_inventory_items

data/app/models/spree_cm_commissioner/stock/availability_validator_decorator.rb

@@ -2,14 +2,66 @@ module SpreeCmCommissioner
   module Stock
     module AvailabilityValidatorDecorator
       # override
-      def item_available?(line_item, quantity)
+      # Complexity cops: core's own `validate` already trips these under similarly strict config.
+      def validate(line_item) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        unit_count = line_item.inventory_units.reject(&:pending?).sum(&:quantity)
+        return if unit_count >= line_item.quantity
+
+        quantity = line_item.quantity - unit_count
+        return if quantity.zero?
+
         # Ticket-transfer orders move existing inventory between guests rather than
-        # purchasing new stock, so they must not be gated by the live stock check.
-        return true if line_item.order&.ticket_transfer?
+        # purchasing new stock, so they must not be gated by the live stock check — and
+        # skipping it here means we never even build a checker for them.
+        return if line_item.order&.ticket_transfer?
+
+        checker = SpreeCmCommissioner::Stock::LineItemAvailabilityChecker.new(line_item).checker
+        return if checker.can_supply?(quantity)
+
+        if line_item.variant.available?
+          if line_item.locked_stock?
+            # own allotment exhausted — ordinary sold out, never "reserved"
+            add_sold_out_error(line_item)
+          else
+            # public line: own pool already failed — check both pools together
+            if checker.can_supply?(quantity, include_locked: true) # rubocop:disable Style/IfInsideElse -- elsif would collapse the locked/public split
+              add_reserved_error(line_item)
+            else
+              add_sold_out_error(line_item)
+            end
+          end
+        else
+          add_inactive_product_error(line_item)
+        end
+      end
+
+      private
+
+      # Formatting below carries core's own style for this error (display_name construction,
+      # multi-line errors.add) verbatim — reformatting to satisfy the cops would fight that.
+      # rubocop:disable Rails/Present, Layout/MultilineMethodCallBraceLayout
+      def add_sold_out_error(line_item)
+        variant = line_item.variant
+        display_name = variant.name.to_s
+        display_name += " (#{variant.options_text})" unless variant.options_text.blank?
+
+        line_item.errors.add(:quantity,
+                             :selected_quantity_not_available,
+                             message: Spree.t(:selected_quantity_not_available, item: display_name.inspect))
+      end
+
+      def add_reserved_error(line_item)
+        line_item.errors.add(:quantity,
+                             :stock_reserved,
+                             message: I18n.t('spree_cm_commissioner.stock.reserved'))
+      end
 
-        SpreeCmCommissioner::Stock::LineItemAvailabilityChecker.new(line_item)
-                                                               .can_supply?(quantity)
+      def add_inactive_product_error(line_item)
+        line_item.errors.add(:base,
+                             :only_active_products_can_be_added_to_cart,
+                             message: Spree.t(:only_active_products_can_be_added_to_cart))
       end
+      # rubocop:enable Rails/Present, Layout/MultilineMethodCallBraceLayout
     end
   end
 end

data/app/models/spree_cm_commissioner/stock/line_item_availability_checker.rb

@@ -7,15 +7,18 @@ module SpreeCmCommissioner
         @line_item = line_item
       end
 
-      def can_supply?(quantity)
-        ::SpreeCmCommissioner::Stock::AvailabilityChecker.new(line_item.variant, options)
-                                                         .can_supply?(quantity)
+      def checker
+        @checker ||= ::SpreeCmCommissioner::Stock::AvailabilityChecker.new(line_item.variant, options)
       end
 
       def options
         {
           from_date: line_item.date_range.first,
-          to_date: line_item.date_range.last
+          to_date: line_item.date_range.last,
+          # A locked-stock line is measured against the operator's allotment, not public stock. Without
+          # this it would read sold out whenever public stock ran out — which is precisely when the
+          # allotment is supposed to still be sellable.
+          locked: line_item.locked_stock?
         }
       end
     end

data/app/models/spree_cm_commissioner/stock/order_availability_checker.rb

@@ -40,7 +40,13 @@ module SpreeCmCommissioner
         return true if line_item.variant.backorderable?
         return true if line_item.variant.need_confirmation?
 
-        cached_inventory_items.all? { |item| item.active? && item.quantity_available >= line_item.quantity }
+        # Each line is measured against ITS OWN pool. The cache row carries both, so this needs no
+        # extra query — before it did, and a locked-stock line was silently checked against public
+        # stock, i.e. read sold out exactly when its allotment was still sellable.
+        cached_inventory_items.all? do |item|
+          quantity = line_item.locked_stock? ? item.quantity_locked : item.quantity_available
+          item.active? && quantity >= line_item.quantity
+        end
       end
     end
   end

data/app/models/spree_cm_commissioner/taxon_decorator.rb

@@ -162,6 +162,10 @@ module SpreeCmCommissioner
       "https://#{Spree::Store.default.url}/t/#{permalink}"
     end
 
+    def ended?
+      to_date.present? && to_date <= Time.current
+    end
+
     def send_transaction_email_to_organizers
       return unless kind == 'event' && level == 1