spree_cm_commissioner 2.8.6.pre.pre1 → 2.8.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a85bc5a3c971cde57bbe6e2549e83b5fed6e70b06cf07e46dc31eb04de53b6ca
-  data.tar.gz: 694d562a264083048a0111ff61ddf828892ff39660c596ecc292d150df182a1e
+  metadata.gz: 4f8d11251736536036263c451dde5cb82e34a6d54b12fe116866a338346d8097
+  data.tar.gz: f1cec56cfe9db369b4bf70a40c8545e09fd2b89a9d0fd1e2d0547cf4818a04eb
 SHA512:
-  metadata.gz: d126f5f0121b305ec904bea9370449323d8383f547373cf76440d42d18fba6c92eafa153023d61b76a679eb1239edbfe41c810c97d801b8e34db2c7f4fabf52e
-  data.tar.gz: 67f9eecfb1909d3b7b53c91029cd242ba8f279d0fc77fb63ceac338e451b8bb71efcfbe92d6a409573a9b0955f0af9ab7edb4e509b5d880fee57631004d5c02e
+  metadata.gz: b0d1ef1dca4921e6493b8455b31c31b9289444aa64b3d5378dc6d87c0676c081ee2c0148dfd3a46fb8572d30fb8fb86d6c53a24249768b3b9001fbb3f2f6a4fa
+  data.tar.gz: a3dfc479c74f38e3889e84ab72246fc01e31134a630563f4f3bf2b3713e3e13d2df1389a0bdf1aae4337e56d891cb6a6dc29e21570d28b84d9d75a5b1d1cd152

data/.env.example

@@ -22,6 +22,11 @@ WAITING_ROOM_MIN_SESSIONS_COUNT=5
 WAITING_ROOM_DISABLED=no
 WAITING_ROOM_POSITION_STAMP_LIMIT=1000
 WAITING_ROOM_FIRESTORE_BATCH_SIZE=500
+WAITING_ROOM_MIN_WAIT_TO_ENTER_SECONDS=600 # Waiting Room step floor (10 min)
+WAITING_ROOM_MIN_QUEUE_TO_ENTER_SECONDS=300 # Queue step floor (5 min)
+WAITING_ROOM_MAX_WAIT_TO_DISPLAY_SECONDS=3600 # above this the ETA is hidden (1 h)
+WAITING_ROOM_CALLER_INTERVAL_SECONDS=60 # how often the caller runs; match the waiting_guests_caller cron
+WAITING_ROOM_MAX_ETA_BATCH_SIZE=50 # cap on batch size assumed when estimating the ETA
 
 # Vattanac Bank
 VATTANAC_AES_SECRET_KEY= ""
@@ -68,3 +73,6 @@ HOLD_COOLDOWN_AFTER_EXPIRY_IN_MINUTES=2     # Cooldown period before a user can
 
 # See: app/models/spree_cm_commissioner/payment_decorator.rb
 PAYMENT_INCOMPLETE_NOTIFICATION_DELAY_IN_MINUTES=5  # Delay before notifying a customer that their order is still unpaid after payment is created
+
+# See: app/jobs/spree_cm_commissioner/telegram_alerts/order_integrity_check_job.rb
+ORDER_INTEGRITY_TELEGRAM_ALERT_ENABLED="no"  # Set to yes to enable the order integrity Telegram alert job (off by default to avoid flooding Telegram rate limits during traffic spikes)

data/.gitignore

@@ -34,9 +34,3 @@ vendor/bundle/
 # Cursor
 .cursor
 dump.rdb
-# Added by code-review-graph
-.code-review-graph/
-.cursorrules
-.claude
-CLAUDE.md
-AGENTS.md

data/Gemfile.lock

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

data/app/controllers/concerns/spree_cm_commissioner/content_cachable.rb

@@ -16,7 +16,6 @@ module SpreeCmCommissioner
       GuestCardClassesController
       SeatLayoutController
       CmsPagesController
-      AdvertisementsController
     ].freeze
 
     # Priority 2: Semi-Static (1 hour)
@@ -26,7 +25,6 @@ module SpreeCmCommissioner
       HomepageDataController
       PopularRoutesController
       RoutePlacesController
-      ShowsController
     ].freeze
 
     # Priority 3: Moderate Freshness (30 minutes)

data/app/controllers/spree/admin/homepage_section_controller.rb

@@ -51,10 +51,7 @@ module Spree
       def permitted_resource_params
         segment_value = helpers.calculate_segment_value(params[:spree_cm_commissioner_homepage_section])
 
-        params
-          .require(:spree_cm_commissioner_homepage_section)
-          .permit(:title, :description, :active, :tenant_id, :preview)
-          .merge(segment: segment_value)
+        params.require(:spree_cm_commissioner_homepage_section).permit(:title, :description, :active, :tenant_id).merge(segment: segment_value)
       end
 
       def load_tenants

data/app/controllers/spree/admin/import_new_orders_controller.rb

@@ -23,6 +23,31 @@ module Spree
           end
         end
       end
+
+      # POST: /admin/orders/import_new_orders/:id/cancel
+      def cancel
+        import = model_class.find(params[:id])
+        show_url = spree.admin_import_new_order_url(import.id)
+
+        unless import.cancellable?
+          flash[:error] = 'These orders cannot be canceled.' # rubocop:disable Rails/I18nLocaleTexts
+          redirect_to show_url and return
+        end
+
+        if params[:confirm_name].to_s.strip != import.name.to_s.strip
+          flash[:error] = 'Import name did not match. Cancellation aborted.' # rubocop:disable Rails/I18nLocaleTexts
+          redirect_to show_url and return
+        end
+
+        SpreeCmCommissioner::CancelImportOrderJob.perform_later(
+          import_order_id: import.id,
+          canceled_by_user_id: spree_current_user.id,
+          cancellation_reason: params[:cancellation_reason].to_s.strip.presence
+        )
+
+        flash[:success] = "Canceling orders from \"#{import.name}\". This runs in the background."
+        redirect_to show_url
+      end
     end
   end
 end

data/app/controllers/spree/admin/taxons_controller_decorator.rb

@@ -3,7 +3,6 @@ module Spree
     module TaxonsControllerDecorator
       def self.prepended(base)
         base.before_action :build_assets, only: %i[create update]
-        base.before_action :normalize_sti_taxon_params, only: %i[create update]
       end
 
       # override
@@ -56,24 +55,6 @@ module Spree
         @taxon.build_ad_banner(attachment: permitted_resource_params.delete(:ad_banner)) if permitted_resource_params[:ad_banner]
         @taxon.build_video_banner(attachment: permitted_resource_params.delete(:video_banner)) if permitted_resource_params[:video_banner]
       end
-
-      # Some admin forms submit STI records under their class key
-      # (e.g. :spree_cm_commissioner_show) while Spree update reads :taxon.
-      # Merge both into :taxon so all edited fields are persisted.
-      def normalize_sti_taxon_params
-        return unless @taxon
-
-        sti_key = @taxon.class.model_name.param_key.to_sym
-        sti_params = params[sti_key]
-        return unless sti_params.is_a?(::ActionController::Parameters)
-
-        base_params = params[:taxon]
-        base_hash = base_params.is_a?(::ActionController::Parameters) ? base_params.to_unsafe_h : {}
-        sti_hash = sti_params.to_unsafe_h
-        merged_params = ::ActionController::Parameters.new(base_hash.merge(sti_hash))
-
-        params[:taxon] = merged_params
-      end
     end
   end
 end

data/app/controllers/spree/api/v2/storefront/account/orders_controller_decorator.rb

@@ -44,6 +44,11 @@ module Spree
             def collection_finder
               SpreeCmCommissioner::Orders::FindByState
             end
+
+            # this allows fetching a single order regardless of its state.
+            def resource_finder
+              SpreeCmCommissioner::Orders::FindByAllState
+            end
           end
         end
       end

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

@@ -19,7 +19,6 @@ module Spree
             @collection ||= model_class.filter_by_segment(params[:homepage_id] || :general)
                                        .active
                                        .where(tenant_id: nil)
-                                       .where(preview: false)
                                        .order(position: :asc)
           end
         end

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

@@ -31,12 +31,12 @@ module Spree
 
           def collection
             if spree_current_user.present?
-              spree_current_user.orders.payment.not_archived
+              spree_current_user.orders.not_archived
             else
               order_tokens = Array(params[:order_tokens])
               return Spree::Order.none if order_tokens.empty?
 
-              Spree::Order.payment.not_archived.without_user.where(token: order_tokens)
+              Spree::Order.not_archived.without_user.where(token: order_tokens)
             end
           end
 

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

@@ -86,9 +86,10 @@ module Spree
           end
 
           def collection
-            SpreeCmCommissioner::TicketTransfer.includes(:order,
-                                                         from_guest: [:event, { line_item: :product }]
-                                                        ).where(from_user_id: spree_current_user.id)
+            SpreeCmCommissioner::TicketTransfer
+              .includes(:order, from_guest: [:event, { line_item: :product }])
+              .where(from_user_id: spree_current_user.id)
+              .order(id: :desc)
           end
 
           def resource_serializer

data/app/controllers/spree/api/v2/tenant/base_controller.rb

@@ -16,10 +16,6 @@ module Spree
             set_current_tenant(@tenant)
           end
 
-          def current_vendor
-            @current_vendor ||= @tenant.active_vendor
-          end
-
           def render_serialized_payload(status = 200)
             render json: yield, status: status, content_type: content_type
           end

data/app/controllers/spree/api/v2/tenant/homepage_sections_controller.rb

@@ -5,7 +5,6 @@ module Spree
         class HomepageSectionsController < BaseController
           def collection
             @collection ||= scope.filter_by_segment(params[:homepage_id] || :general)
-                                 .where(preview: false)
                                  .active
                                  .order(position: :asc)
           end

data/app/controllers/spree/api/v2/tenant/order_histories_controller.rb

@@ -38,12 +38,12 @@ module Spree
 
           def collection
             if spree_current_user.present?
-              spree_current_user.orders.payment.not_archived
+              spree_current_user.orders.not_archived
             else
               order_tokens = Array(params[:order_tokens])
               return Spree::Order.none if order_tokens.empty?
 
-              Spree::Order.payment.not_archived.without_user.where(token: order_tokens)
+              Spree::Order.not_archived.without_user.where(token: order_tokens)
             end
           end
 

data/app/controllers/spree/api/v2/tenant/products_controller.rb

@@ -21,7 +21,7 @@ module Spree
 
           def scope
             MultiTenant.with(@tenant) do
-              model_class.where(tenant_id: MultiTenant.current_tenant_id, preview: false)
+              model_class.where(tenant_id: MultiTenant.current_tenant_id)
             end
           end
 

data/app/controllers/spree/api/v2/tenant/taxons_controller.rb

@@ -31,7 +31,7 @@ module Spree
 
           def scope
             MultiTenant.with(@tenant) do
-              model_class.where(preview: false)
+              model_class
             end
           end
 

data/app/controllers/spree_cm_commissioner/admin/products_controller_decorator.rb

@@ -6,7 +6,6 @@ module SpreeCmCommissioner
         base.around_action :set_writing_role, only: %i[index]
         base.after_action :set_tenant_after_update, only: %i[update]
         base.before_action :merge_industry_taxons_into_taxons, only: [:update]
-        base.before_action :normalize_sti_product_params, only: %i[create update]
       end
 
       # Override
@@ -52,24 +51,6 @@ module SpreeCmCommissioner
 
       protected
 
-      # Some admin forms submit STI records under their class key while
-      # Spree update reads :product. Merge both into :product so all edited
-      # fields are persisted for STI product subclasses.
-      def normalize_sti_product_params
-        return unless @product
-
-        sti_key = @product.class.model_name.param_key.to_sym
-        sti_params = params[sti_key]
-        return unless sti_params.is_a?(::ActionController::Parameters)
-
-        base_params = params[:product]
-        base_hash = base_params.is_a?(::ActionController::Parameters) ? base_params.to_unsafe_h : {}
-        sti_hash = sti_params.to_unsafe_h
-        merged_params = ::ActionController::Parameters.new(base_hash.merge(sti_hash))
-
-        params[:product] = merged_params
-      end
-
       def merge_industry_taxons_into_taxons
         return if params[:product].blank?
 

data/app/finders/spree_cm_commissioner/events/find_matches.rb

@@ -7,7 +7,6 @@ module SpreeCmCommissioner
       def execute
         scope.joins(:integration_mappings).where(
           kind: :event,
-          preview: false,
           integration_mappings: { status: :active }
         ).distinct
       end

data/app/finders/spree_cm_commissioner/orders/find.rb

@@ -4,14 +4,30 @@
 module SpreeCmCommissioner
   module Orders
     class Find
+      CURRENT_CART_STATES = %w[cart address].freeze
+      CART_MAX_AGE_IN_MINUTES = ENV.fetch('CART_MAX_AGE_IN_MINUTES', '720').to_i # Default: 12 hours
+
       def execute(store:, user:, currency:, token: nil, state: nil)
+        state = Array(state).map(&:to_s)
+
         params = { store_id: store.id, currency: currency }
         params[:state] = state if state.present?
 
-        return find_by_token(params, token) if token.present?
-        return find_by_user(params, user) if user.present?
+        order = if token.present?
+                  find_by_token(params, token)
+                elsif user.present?
+                  find_by_user(params, user)
+                end
+
+        # Only enforce hold and age expiration when fetching current cart states ('cart' or 'address').
+        # For other states (like 'payment,complete'), we want to return the order even if it's old or expired
+        # because some pages on client still need some specific state of order to display.
+        if state.intersect?(CURRENT_CART_STATES)
+          return nil if hold_expired?(order)
+          return nil if cart_too_old?(order)
+        end
 
-        nil
+        order
       end
 
       def find_by_token(params, token)
@@ -24,6 +40,20 @@ module SpreeCmCommissioner
         scope.order(created_at: :desc).find_by(params)
       end
 
+      def hold_expired?(order)
+        return false if order.nil?
+
+        # Check if the order has a hold_expires_at column and if it has already passed
+        order.hold_expires_at.present? && order.hold_expires_at < Time.current
+      end
+
+      def cart_too_old?(order)
+        return false if order.nil?
+
+        # Treat the cart as active based on its last update time, not its creation time.
+        order.updated_at < CART_MAX_AGE_IN_MINUTES.minutes.ago
+      end
+
       private
 
       def scope

data/app/finders/spree_cm_commissioner/orders/find_by_all_state.rb

@@ -0,0 +1,11 @@
+module SpreeCmCommissioner
+  module Orders
+    class FindByAllState < Spree::Orders::FindComplete
+      private
+
+      def scope
+        user? ? user.orders.includes(scope_includes) : Spree::Order.includes(scope_includes)
+      end
+    end
+  end
+end

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

@@ -15,8 +15,6 @@ module SpreeCmCommissioner
           'badge badge-success text-uppercase'
         when :football
           'badge badge-dark text-uppercase'
-        when :show
-          'badge badge-danger text-uppercase'
         else
           'badge'
         end

data/app/interactors/spree_cm_commissioner/waiting_guests_caller.rb

@@ -3,8 +3,11 @@ require 'google/cloud/firestore'
 # TODO: alert when available_slots is negative.
 module SpreeCmCommissioner
   class WaitingGuestsCaller < BaseInteractor
-    MIN_WAIT_TO_ENTER_SECONDS = 120 # 2 min floor — Waiting Room step (full journey, more uncertainty)
-    MIN_QUEUE_TO_ENTER_SECONDS = 60 # 1 min floor — Queue step (position assigned, one caller cycle minimum)
+    # 10 min floor — Waiting Room step (full journey, most uncertainty)
+    MIN_WAIT_TO_ENTER_SECONDS = (ENV['WAITING_ROOM_MIN_WAIT_TO_ENTER_SECONDS'] || 600).to_i
+
+    # 5 min floor — Queue step (position assigned, sub-segment of the journey)
+    MIN_QUEUE_TO_ENTER_SECONDS = (ENV['WAITING_ROOM_MIN_QUEUE_TO_ENTER_SECONDS'] || 300).to_i
 
     # Firestore bounds a batch update by payload size (10 MiB); 500 ops/commit leaves us far under that.
     FIRESTORE_BATCH_SIZE = (ENV['WAITING_ROOM_FIRESTORE_BATCH_SIZE'] || 500).to_i
@@ -20,7 +23,8 @@ module SpreeCmCommissioner
         full: long_waiting_guests.size >= available_slots,
         available_slots: available_slots - long_waiting_guests.size,
         avg_wait_to_enter_seconds: compute_avg_wait_to_enter_seconds(long_waiting_guests),
-        avg_queue_to_enter_seconds: compute_avg_queue_to_enter_seconds(long_waiting_guests)
+        avg_queue_to_enter_seconds: compute_avg_queue_to_enter_seconds(long_waiting_guests),
+        slots_per_call: available_slots
       )
     end
 
@@ -96,10 +100,18 @@ module SpreeCmCommissioner
     end
 
     # merge: true so we preserve the published `waiting_guests_records_path` on the lobby doc.
-    def mark_as(full:, available_slots:, avg_wait_to_enter_seconds: nil, avg_queue_to_enter_seconds: nil)
+    def mark_as(
+      full:,
+      available_slots:,
+      avg_wait_to_enter_seconds: nil,
+      avg_queue_to_enter_seconds: nil,
+      slots_per_call: nil
+    )
       data = { full: full, available_slots: available_slots }
       data[:avg_wait_to_enter_seconds] = avg_wait_to_enter_seconds if avg_wait_to_enter_seconds
       data[:avg_queue_to_enter_seconds] = avg_queue_to_enter_seconds if avg_queue_to_enter_seconds
+      data[:slots_per_call] = slots_per_call if slots_per_call
+
       lobby_document.set(data, merge: true)
     end
 

data/app/jobs/concerns/spree_cm_commissioner/idempotent_job.rb

@@ -0,0 +1,12 @@
+module SpreeCmCommissioner
+  module IdempotentJob
+    def with_idempotency(key = nil, &block)
+      SpreeCmCommissioner::IdempotencyKey.run_once(key.presence || default_idempotency_key, &block)
+    end
+
+    # Namespaced so the key is self-describing in the DB (no `source` column needed).
+    def default_idempotency_key
+      "#{self.class.name}:#{job_id}"
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/cancel_import_order_job.rb

@@ -0,0 +1,11 @@
+module SpreeCmCommissioner
+  class CancelImportOrderJob < ApplicationUniqueJob
+    def perform(options = {})
+      SpreeCmCommissioner::Imports::Orders::Cancel.new(
+        import_order_id: options[:import_order_id],
+        canceled_by_user_id: options[:canceled_by_user_id],
+        cancellation_reason: options[:cancellation_reason]
+      ).call
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/idempotency_keys/prune_job.rb

@@ -0,0 +1,20 @@
+# Prunes old idempotency keys. Keys only matter within the retry window
+# (minutes–hours), so anything older than the cutoff is safe to delete.
+# The `created_at` index supports the delete.
+module SpreeCmCommissioner
+  module IdempotencyKeys
+    class PruneJob < SpreeCmCommissioner::ApplicationJob
+      DEFAULT_CUTOFF_DAYS = 3
+
+      queue_as :default
+
+      def perform(cutoff_days = DEFAULT_CUTOFF_DAYS)
+        days = [cutoff_days.to_i, 1].max
+
+        SpreeCmCommissioner::IdempotencyKey
+          .where(created_at: ...days.days.ago)
+          .delete_all
+      end
+    end
+  end
+end

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

@@ -1,12 +1,30 @@
 module SpreeCmCommissioner
   module InventoryItems
     class BulkAdjustQuantitiesJob < ApplicationUniqueJob
+      include SpreeCmCommissioner::IdempotentJob
+
+      def perform(options = {})
+        with_idempotency(idempotency_key_for(options)) do
+          bulk_adjust_quantities!(options)
+        end
+      end
+
+      private
+
+      # Dedup on the line items being synced, so a re-pushed payload for the same
+      # line items no-ops. An explicit key wins; with no line items we fall back to
+      # the per-enqueue job_id (returning nil lets with_idempotency apply that default).
+      def idempotency_key_for(options)
+        return options[:idempotency_key] if options[:idempotency_key].present?
+        return nil if options[:line_item_ids].blank?
+
+        "line_item:#{options[:line_item_ids].compact.uniq.sort.join(':')}"
+      end
+
       # :line_item_ids, :inventory_id_and_quantities, :caller_source
       #
-      # :line_item_ids is included for unique job key generation to prevent duplicate jobs,
-      # though it's not used in the perform method implementation.
       # :caller_source is a string like "ClassName#method" identifying who enqueued the job.
-      def perform(options = {})
+      def bulk_adjust_quantities!(options = {})
         SpreeCmCommissioner::InventoryItems::BulkAdjustQuantities.call!(
           inventory_id_and_quantities: options[:inventory_id_and_quantities],
           caller_source: options[:caller_source]

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

@@ -1,14 +1,45 @@
 module SpreeCmCommissioner
   module InventoryItems
     class BulkAdjustQuantitiesOnHoldJob < ApplicationUniqueJob
+      include SpreeCmCommissioner::IdempotentJob
+
       queue_as :default
 
+      def perform(options = {})
+        with_idempotency(idempotency_key_for(options)) do
+          bulk_adjust_quantities_on_hold(options)
+        end
+      end
+
+      private
+
+      # Dedup on the order + the exact adjustment set, so a re-pushed identical
+      # on-hold payload no-ops while a genuinely different one re-applies. An explicit
+      # key wins; with no order_id we fall back to the per-enqueue job_id (returning
+      # nil lets with_idempotency apply that default).
+      def idempotency_key_for(options)
+        return options[:idempotency_key] if options[:idempotency_key].present?
+        return nil if options[:order_id].blank?
+
+        "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".
+      # Delimiter hierarchy: ":" separates key fields, "," separates adjustments, "=" pairs id/qty.
+      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}" }
+          .join(',')
+      end
+
       # :order_id, :inventory_id_and_quantities, :caller_source
       #
-      # :order_id is included for unique job key generation to prevent duplicate jobs,
-      # though it's not used in the perform method implementation.
+      # :order_id is used for unique idempotency key generation to prevent duplicate
+      # processing, though it's not used in the adjustment itself.
       # :caller_source is a string like "ClassName#method" identifying who enqueued the job.
-      def perform(options = {})
+      def bulk_adjust_quantities_on_hold(options = {})
         raise ArgumentError, 'order_id is required' if options[:order_id].blank?
         raise ArgumentError, 'inventory_id_and_quantities is required' if options[:inventory_id_and_quantities].blank?
 

data/app/jobs/spree_cm_commissioner/telegram_alerts/order_integrity_check_job.rb

@@ -0,0 +1,17 @@
+module SpreeCmCommissioner
+  module TelegramAlerts
+    class OrderIntegrityCheckJob < ApplicationUniqueJob
+      queue_as :telegram_bot
+      # retry: 0 sends failed jobs straight to the dead queue, avoiding retry storms.
+      # Guarded since sidekiq_options requires the host app's Sidekiq integration.
+      sidekiq_options retry: 0 if respond_to?(:sidekiq_options)
+
+      def perform(order_id:)
+        order = Spree::Order.find_by(id: order_id)
+        return unless order
+
+        SpreeCmCommissioner::TelegramAlerts::OrderIntegrityChecksRunner.call(order: order)
+      end
+    end
+  end
+end

data/app/jobs/spree_cm_commissioner/waiting_guests_caller_job.rb

@@ -1,6 +1,11 @@
+# Scheduled as a cron job (see cm-market-server/config/schedule.yml):
 # waiting_guests_caller:
 #   cron: "*/1 * * * *" # Every minute
 #   class: "SpreeCmCommissioner::WaitingGuestsCallerJob"
+#
+# NOTE: the queue ETA assumes one batch is released per run, so this interval must match
+# SpreeCmCommissioner::WaitingRoom::StampQueuePositions::CALLER_INTERVAL_SECONDS
+# (env WAITING_ROOM_CALLER_INTERVAL_SECONDS). If you change the cron, update that too.
 module SpreeCmCommissioner
   class WaitingGuestsCallerJob < ApplicationUniqueJob
     queue_as :waiting_room

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

@@ -8,8 +8,7 @@ module SpreeCmCommissioner
       tour: 0b00100,
       accommodation: 0b01000,
       things_to_do: 0b10000,
-      football: 0b100000,
-      show: 0b1000000
+      football: 0b100000
     }.freeze
 
     BIT_SEGMENT.each do |segment, bit_value|

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

@@ -45,8 +45,7 @@ module SpreeCmCommissioner
       'color' => 'color',
       'ticket-type' => 'string',
       'seat-type' => 'string',
-      'intercity-taxi' => 'string',
-      'vote-package' => 'integer'
+      'intercity-taxi' => 'string'
     }.freeze
 
     included do

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

@@ -26,10 +26,9 @@ module SpreeCmCommissioner
 
       state_machine.after_transition to: :canceled, do: :precalculate_conversion
       state_machine.after_transition to: :canceled, do: :restock_inventory!
-      state_machine.after_transition to: :canceled, do: :de_allocate_resources
 
       state_machine.after_transition to: :complete, do: :increment_route_fulfilled_order_count
-      state_machine.after_transition to: :complete, do: :allocate_resources
+      state_machine.after_transition to: :complete, do: :run_order_complete_alerts
 
       scope :accepted, -> { where(request_state: 'accepted') }
 
@@ -324,19 +323,20 @@ module SpreeCmCommissioner
       TelegramNotificationSenderJob.perform_later(chat_id: chat_id, message: factory.message, parse_mode: factory.parse_mode)
     end
 
+    def run_order_complete_alerts
+      return unless ENV['ORDER_INTEGRITY_TELEGRAM_ALERT_ENABLED'] == 'yes'
+
+      # Allow async payment processors time to settle before checking for alerts
+      SpreeCmCommissioner::TelegramAlerts::OrderIntegrityCheckJob
+        .set(wait: 2.minutes)
+        .perform_later(order_id: id)
+    end
+
     def send_order_complete_telegram_alert_to_store
       title = '🎫 --- [NEW ORDER] ---'
       chat_id = store.preferred_telegram_order_alert_chat_id
       factory = OrderTelegramMessageFactory.new(title: title, order: self)
       TelegramNotificationSenderJob.perform_later(chat_id: chat_id, message: factory.message, parse_mode: factory.parse_mode)
     end
-
-    def allocate_resources
-      SpreeCmCommissioner::VotingCreditAllocationJob.perform_later(order_id: id)
-    end
-
-    def de_allocate_resources
-      SpreeCmCommissioner::VotingCreditDeAllocationJob.perform_later(order_id: id)
-    end
   end
 end