spree_cm_commissioner 2.10.2.pre.pre1 → 2.12.0.pre.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5552124388d0792051115573a9cc5e51044c8edcf7f8e89c6f03b43d2ebd0ab
-  data.tar.gz: '0694645f790079a03ebad09626ca155e7495c37ea8b45f83064a3c31b2aa6f75'
+  metadata.gz: 1bcaa0a7cc8d39b507cd072bfd4576b28f72c83f2344b11ef2097306aa8454dd
+  data.tar.gz: bf8156fe0e0f2a41febcacc07188e8b0bbd9b2cd79c3ccad5a8d1394fa307db7
 SHA512:
-  metadata.gz: 06b79003d8dee84088c17d6cd6f90b7d2b7d5eeca20b4045ca1775b467b3455b66898e72e47d33e9655a6b8b7c1b36dcef355b8b4ff5258daa066d87e8cdfb02
-  data.tar.gz: 386411dbfdd18ce5d25ade6d55e045b1bcaea788d3b8cb49437723789ab8e1e5e7e1b77e4cbece9ee962427f8b0c5c603c1cd1cdc091400ca8cf6e860dfd39a4
+  metadata.gz: 19b750a2f5c27cabbc5c507a0e50424a26e295aefa94369787ff490376475f63e56993950e87a9a1b2c3be624f6ec29f2192a51a7e019bfed05e3ee4dcb54018
+  data.tar.gz: 4acf6f94be21c3960010398b9a431b950b2e3e7bffed455096ea0dc2ed05fca769bd53884b6ed26be86cc11db2a8c220c73711be800bccebf7fc005854454f11

data/Gemfile.lock

@@ -34,7 +34,7 @@ GIT
 PATH
   remote: .
   specs:
-    spree_cm_commissioner (2.10.2.pre.pre1)
+    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/concerns/spree_cm_commissioner/content_cachable.rb

@@ -14,7 +14,7 @@ module SpreeCmCommissioner
       CountriesController
       ProvincesController
       GuestCardClassesController
-      SeatLayoutController
+      SeatLayoutsController
       CmsPagesController
       AdvertisementsController
     ].freeze

data/app/controllers/spree/admin/system/waiting_room_sessions_controller.rb

@@ -0,0 +1,27 @@
+module Spree
+  module Admin
+    module System
+      class WaitingRoomSessionsController < Spree::Admin::BaseController
+        def index
+          @filter = params[:filter] if params[:filter] == 'load_test'
+
+          sessions = SpreeCmCommissioner::WaitingRoomSession.active
+          sessions = sessions.load_test if @filter == 'load_test'
+
+          @waiting_room_sessions = sessions.order(created_at: :desc).page(params[:page]).per(50)
+        end
+
+        # Kills only the sessions the admin checked (Gmail-style select + delete), instead of the
+        # room's whole active set. Firebase's active_sessions/full reflect this only on the next
+        # WaitingGuestsCaller run (they're a once-a-minute mirror, not live).
+        def kill
+          ids = Array(params[:ids])
+          count = SpreeCmCommissioner::WaitingRoomSession.kill_by_ids!(ids)
+          flash[:success] = "Killed #{count} waiting-room session(s)."
+
+          redirect_back fallback_location: admin_system_waiting_room_sessions_path
+        end
+      end
+    end
+  end
+end

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

@@ -14,8 +14,6 @@ module Spree
       end
 
       def update_telegram_chat
-        @vendor.update(preferred_telegram_alert_channels: submitted_alert_channels_mask)
-
         context = ::SpreeCmCommissioner::TelegramChatsFinder.call(
           telegram_chat_name: params['vendor']['preferred_telegram_chat_name'],
           telegram_chat_type: params['vendor']['preferred_telegram_chat_type']
@@ -36,19 +34,6 @@ module Spree
         redirect_to collection_url(@vendor)
       end
 
-      # OR the bits, never sum them. Sum is not idempotent: if the same bit arrives twice
-      # (duplicated checkbox, double-submit, hand-crafted post) 1 + 1 = 2, which silently means
-      # google_form instead of spree. ["0","1","1","16"].sum => 18 => [google_form, offline_sell];
-      # the same input OR'd => 17 => [spree, offline_sell].
-      #
-      # Masking against the known bits also drops junk from a crafted post (999 => 7).
-      def submitted_alert_channels_mask
-        known = SpreeCmCommissioner::OrderChannelBitwise::CHANNEL_ALERT_BITS.values.reduce(:|)
-
-        Array(params.dig(:vendor, :telegram_alert_channels))
-          .reduce(0) { |acc, value| acc | value.to_i } & known
-      end
-
       # @overrided
       def model_class
         Spree::User

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

@@ -11,12 +11,12 @@ module Spree
           # Params:
           # - line_items: Array of { variant_id:, quantity:, options: {}, public_metadata: {}, private_metadata: {} } (required)
           def create
-            result = SpreeCmCommissioner::DraftOrder::Create.call(
+            result = SpreeCmCommissioner::DraftOrders::Create.call(
               line_items: draft_order_line_items,
               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/controllers/spree/api/v2/tenant/draft_orders_controller.rb

@@ -8,7 +8,7 @@ module Spree
           # Params:
           # - line_items: Array of { variant_id:, quantity:, options: {}, public_metadata: {}, private_metadata: {} } (required)
           def create
-            result = SpreeCmCommissioner::DraftOrder::Create.call(
+            result = SpreeCmCommissioner::DraftOrders::Create.call(
               line_items: draft_order_line_items,
               user: spree_current_user,
               store: current_store,

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

@@ -13,7 +13,7 @@ module Spree
           def collection
             @collection ||= @voting_session
                             .voting_contestants
-                            .includes(:voting_session, { show_contestant: :assigned_show_person },
+                            .includes(:voting_session, :eliminated_voting_session, { show_contestant: :assigned_show_person },
                                       :show_contestant_images, :show_contestant_videos,
                                       :advanced_to, :advanced_from
                             ).order(:vote_number)

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

@@ -20,7 +20,7 @@ module Spree
 
           def scope
             scope = spree_current_user.voting_credit_transactions
-                                      .includes(:vote_credit, :originator)
+                                      .includes(:vote_credit, :originator, contestant: :voting_session)
                                       .order(created_at: :desc)
 
             scope = scope.by_action(params[:actions].split(',')) if params[:actions].present?

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

@@ -56,21 +56,31 @@ module SpreeCmCommissioner
         option_value.name
       end
 
-      # Builds the load-test fixture for this variant so it can be used by the k6 booking flow.
+      # Builds the load-test fixture for this variant so it can be used by a k6 booking flow.
       # Shown on a page (with a check for whether the variant can be booked) for the tester to
       # copy into the load_testing config. A product with a tenant_id belongs to a tenant
       # (SaaS-hosted) store rather than the platform — the two k6 workflows keep separate fixture
       # folders (load_testing/config/fixture/platform/booking_ticket_flow/ vs
       # load_testing/config/fixture/tenant/cash_on_booking_ticket_flow/ — the tenant flow is named
       # cash_on_* since it has an ABA sibling; the platform flow doesn't).
+      #
+      # Whether this variant needs seat_selection_booking_flow isn't picked here — it's read off
+      # the generated fixture's metadata[:select_seat] (see GenerateBookingTicketData), which
+      # derives it the same way add-to-cart itself does.
       def fixture
         @fixture_workflow = @variant.product.tenant_id.present? ? 'tenant' : 'platform'
-        @fixture_flow = @fixture_workflow == 'tenant' ? 'cash_on_booking_ticket_flow' : 'booking_ticket_flow'
+        @fixture_env = Rails.env.development? ? 'local' : Rails.env.to_s # the load_testing config calls it "local", not "development"
+
         result = SpreeCmCommissioner::LoadTest::GenerateBookingTicketData.call(variant: @variant)
         @fixture = result.value[:data]
         @fixture_issues = result.value[:issues]
-        # The load_testing config calls it "local", not "development".
-        @fixture_env = Rails.env.development? ? 'local' : Rails.env.to_s
+        @fixture_flow = @fixture[:metadata][:select_seat] ? 'seat_selection_booking_flow' : fixture_flow_for(@fixture_workflow)
+      end
+
+      private
+
+      def fixture_flow_for(workflow)
+        workflow == 'tenant' ? 'cash_on_booking_ticket_flow' : 'booking_ticket_flow'
       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/jobs/spree_cm_commissioner/voting_session_auto_open_job.rb

@@ -0,0 +1,14 @@
+module SpreeCmCommissioner
+  # Enqueued by VotingSessions::ScheduleVoteWindowJobs with wait_until: vote_open_at.
+  # See VotingSessions::AutoOpen for the actual open/publish logic.
+  class VotingSessionAutoOpenJob < ApplicationJob
+    queue_as :default
+
+    def perform(voting_session_id)
+      voting_session = SpreeCmCommissioner::VotingSession.find_by(id: voting_session_id)
+      return if voting_session.nil?
+
+      SpreeCmCommissioner::VotingSessions::AutoOpen.call(voting_session: voting_session)
+    end
+  end
+end

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

@@ -41,6 +41,21 @@ module SpreeCmCommissioner
       store_public_metadata :preload_seat_layout_ids, :array, default: []
       store_public_metadata :preload_active_seat_layout_ids, :array, default: []
 
+      # Use to indicate if a seat layout is the guide layout for this event. 1 guide layout per event.
+      store_public_metadata :preload_guide_seat_layout_id, :integer
+      store_public_metadata :preload_active_guide_seat_layout_id, :integer
+
+      # Denormalised price range across the event's variants, so the client can show it (e.g. "from $X")
+      # without loading every variant. Kept in sync by PriceDecorator's after_commit hook
+      store_public_metadata :min_price, :string
+      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'
+
       before_validation :validate_at_least_one_check_in_flow_presence
     end
 
@@ -51,6 +66,18 @@ module SpreeCmCommissioner
       flows
     end
 
+    def display_min_price
+      return nil if min_price.blank?
+
+      Spree::Money.new(min_price, currency: currency).to_s
+    end
+
+    def display_max_price
+      return nil if max_price.blank?
+
+      Spree::Money.new(max_price, currency: currency).to_s
+    end
+
     private
 
     def validate_at_least_one_check_in_flow_presence

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

@@ -1,7 +1,7 @@
 # Make sure to put this concern below other concern or methods that generating additional order info like guests, seat number, etc.
 # This will ensure that when each notification is sent with neccessary data.
 module SpreeCmCommissioner
-  module OrderStateMachine # rubocop:disable Metrics/ModuleLength
+  module OrderStateMachine
     extend ActiveSupport::Concern
 
     included do # rubocop:disable Metrics/BlockLength
@@ -271,30 +271,15 @@ module SpreeCmCommissioner
       return unless telegram_alert_enabled?
 
       vendor_list.each do |vendor|
-        # `next`, not `return`: the mask is per-vendor, so one opted-out vendor on a
-        # multi-vendor order must not suppress the others.
-        next unless vendor.alerts_telegram_for_channel?(channel_key)
-
+        title = '🎫 --- [NEW ORDER FROM BOOKME+] ---'
         chat_id = vendor.preferred_telegram_chat_id
-        next if chat_id.blank?
-
-        factory = OrderTelegramMessageFactory.new(title: vendor_alert_title(vendor), order: self, vendor: vendor)
-        TelegramNotificationSenderJob.perform_later(chat_id: chat_id, message: factory.message, parse_mode: factory.parse_mode)
+        if chat_id.present?
+          factory = OrderTelegramMessageFactory.new(title: title, order: self, vendor: vendor)
+          TelegramNotificationSenderJob.perform_later(chat_id: chat_id, message: factory.message, parse_mode: factory.parse_mode)
+        end
       end
     end
 
-    # White-label vendors announce their own brand; platform vendors stay BookMe+.
-    #
-    # vendor.name is operator-supplied data interpolated into an HTML parse_mode message
-    # (TelegramMessageFactory#header wraps the title in <b>), so it MUST be escaped —
-    # Telegram rejects unescaped &, < and > with "400 can't parse entities", and
-    # TelegramNotificationSender swallows that error, so the alert would vanish silently.
-    def vendor_alert_title(vendor)
-      return '🎫 --- [NEW ORDER FROM BOOKME+] ---' unless vendor.tenant_present?
-
-      "🎫 --- [NEW ORDER FROM #{CGI.escapeHTML(vendor.name.to_s)}] ---"
-    end
-
     def notify_order_complete_app_notification_to_user
       return if products.all?(&:vote_package?) # disable app push notification for vote package orders
 

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

@@ -12,6 +12,14 @@ module SpreeCmCommissioner
       max_quantity_per_ip
     ].freeze
 
+    # Caps that aggregate across orders. The order cap is bounded by each of these:
+    # whichever is smaller is what the buyer actually gets.
+    AGGREGATE_LIMIT_KEYS = %i[
+      max_quantity_per_account
+      max_quantity_per_device
+      max_quantity_per_ip
+    ].freeze
+
     POSITIVE_INTEGER = { only_integer: true, greater_than: 0, message: :must_be_positive_integer }.freeze
 
     included do
@@ -27,6 +35,7 @@ module SpreeCmCommissioner
 
       validate :validate_max_quantity_per_account
       validate :validate_max_quantity_per_device
+      validate :validate_order_cap_within_aggregate_caps
 
       before_validation :normalize_purchase_limits
     end
@@ -50,6 +59,19 @@ module SpreeCmCommissioner
       errors.add(:base, I18n.t('purchase_limit.account_cap_requires_named_booking'))
     end
 
+    # An order cap above an aggregate cap is unreachable - the aggregate check counts the same
+    # cart quantity plus past orders, so it rejects first. Only the tightest cap is named:
+    # fixing it clears the rest. A blank cap reads back as 0, hence the positive? filter.
+    def validate_order_cap_within_aggregate_caps
+      order_cap = max_quantity_per_order.to_i
+      key = AGGREGATE_LIMIT_KEYS.select { |k| public_send(k).to_i.positive? && public_send(k).to_i < order_cap }
+                                .min_by { |k| public_send(k).to_i }
+      return if key.nil?
+
+      cap_name = I18n.t("purchase_limit.cap_names.#{key.to_s.delete_prefix('max_quantity_per_')}")
+      errors.add(:max_quantity_per_order, I18n.t('purchase_limit.order_cap_exceeds_scope_cap', cap_name: cap_name))
+    end
+
     def validate_max_quantity_per_device
       return unless max_quantity_per_device.to_i.positive? && !purchasable_on_app?
 

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

@@ -5,11 +5,11 @@ module SpreeCmCommissioner
     included do
       has_one :ticket_transfer, class_name: 'SpreeCmCommissioner::TicketTransfer'
 
-      scope :not_ticket_transfer, -> { where.not(channel: SpreeCmCommissioner::OrderChannelBitwise::TICKET_TRANSFER_CHANNEL) }
+      scope :not_ticket_transfer, -> { where.not(channel: SpreeCmCommissioner::OrderDecorator::TICKET_TRANSFER_CHANNEL) }
     end
 
     def ticket_transfer?
-      channel == SpreeCmCommissioner::OrderChannelBitwise::TICKET_TRANSFER_CHANNEL
+      channel == SpreeCmCommissioner::OrderDecorator::TICKET_TRANSFER_CHANNEL
     end
 
     # Completes an accepted ticket transfer for this order. Called from

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

@@ -8,25 +8,6 @@ module SpreeCmCommissioner
       preference :telegram_chat_id, :string
       preference :telegram_chat_name, :string
       preference :telegram_chat_type, :string
-      preference :telegram_alert_channels, :integer, default: 1
-    end
-
-    # Should this vendor's Telegram group be alerted for an order on this channel?
-    # An unmapped channel alerts — a stray message is a better failure than silence.
-    def alerts_telegram_for_channel?(channel_key)
-      bit = SpreeCmCommissioner::OrderChannelBitwise::CHANNEL_ALERT_BITS[channel_key]
-      return true if bit.nil?
-
-      telegram_alert_channels_mask.anybits?(bit)
-    end
-
-    # Spree's getter is `preferences.fetch(name) { default }`, which falls back only when the
-    # key is ABSENT. A key present with a nil value returns nil, and nil.to_i == 0 would mute
-    # EVERY channel silently. Fall back to the default instead; a deliberate 0 survives
-    # because 0 is truthy in Ruby.
-    def telegram_alert_channels_mask
-      (preferred_telegram_alert_channels ||
-        SpreeCmCommissioner::OrderChannelBitwise::DEFAULT_TELEGRAM_ALERT_CHANNELS).to_i
     end
   end
 end