spree_cm_commissioner 2.9.3.pre.pre1 → 2.9.4

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

@@ -88,7 +88,7 @@ module SpreeCmCommissioner
 
     # public_metadata override for a guest count, only when it's a non-negative integer;
     # nil otherwise so callers fall back to the variant default. Keeps number_of_guests >= 0
-    # (a negative would make custom_guest_count? false and spin the bump loop in Cart::CreateGuest).
+    # (a negative would make custom_guest_count? false and spin the bump loop in Guests::Create).
     def metadata_guest_count(key)
       return nil unless valid_integer_metadata?(key)
 

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

@@ -1,10 +1,12 @@
 # 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
+      after_commit :clear_has_incomplete_guest_info_cache, on: %i[create update]
+
       state_machine.before_transition to: :address, do: :hold_order_holds
 
       state_machine.before_transition to: :complete, do: :request, if: :need_confirmation?
@@ -19,7 +21,7 @@ module SpreeCmCommissioner
 
       state_machine.around_transition to: :complete, do: :unstock_inventory!
 
-      state_machine.after_transition to: :complete, do: :mark_user_as_has_incomplete_guest_info, if: :has_incomplete_guest_info?
+      state_machine.after_transition to: :complete, do: :send_dynamic_field_notification_to_guests
       state_machine.after_transition to: :complete, do: :send_transaction_email_to_user, if: :user_has_email?
 
       state_machine.before_transition to: :resumed, do: :clear_cancellation_details
@@ -118,29 +120,6 @@ module SpreeCmCommissioner
       end
     end
 
-    def mark_user_as_has_incomplete_guest_info
-      user&.public_metadata&.[]=('has_incomplete_guest_info', true)
-      user&.save!
-
-      line_items.each do |line_item|
-        line_item.guests.each do |guest|
-          guest.user ||= user
-          guest.save!(validate: false) if guest.changed?
-          guest.save_and_move_to_next_stage
-          # send notification only for guests that still have incomplete dynamic fields
-          SpreeCmCommissioner::GuestDynamicFieldNotificationSender.call(guest: guest) if guest_incomplete?(guest)
-        end
-      end
-    end
-
-    def has_incomplete_guest_info? # rubocop:disable Naming/PredicateName
-      line_items.any? do |line_item|
-        line_item.guests.any? do |guest|
-          guest_incomplete?(guest)
-        end
-      end
-    end
-
     # allow authorized user to accept all requested line items
     def accepted_by(user)
       transaction do
@@ -152,12 +131,6 @@ module SpreeCmCommissioner
       end
     end
 
-    def guest_incomplete?(guest)
-      (guest.pre_registration_fields? && !guest.pre_registration_completed?) ||
-        (guest.post_registration_fields? && !guest.post_registration_completed?) ||
-        (guest.during_check_in_fields? && !guest.check_in_completed?)
-    end
-
     def unstock_inventory!
       ActiveRecord::Base.transaction do
         yield if block_given? # Equal to block.call
@@ -285,6 +258,15 @@ module SpreeCmCommissioner
       @telegram_alert_enabled = line_items.any?(&:enable_telegram_alert?)
     end
 
+    def send_dynamic_field_notification_to_guests
+      incomplete_guests = line_items.flat_map(&:guests).select(&:incomplete?)
+      return if incomplete_guests.empty?
+
+      incomplete_guests.each do |guest|
+        SpreeCmCommissioner::Guests::SendDynamicFieldNotification.call(guest: guest)
+      end
+    end
+
     def send_order_complete_telegram_alert_to_vendors
       return unless telegram_alert_enabled?
 

data/app/models/spree_cm_commissioner/current.rb

@@ -1,8 +1,11 @@
 module SpreeCmCommissioner
   class Current < ActiveSupport::CurrentAttributes
-    # Set to true for the duration of a load-test request so that rate-limiting
-    # services deeper in the call chain (e.g. InventoryHolds::ValidateLimits) can
-    # skip their checks without needing the request object threaded through them.
+    # True during a load-test request, letting deep services (e.g.
+    # InventoryHolds::ValidateLimits) skip anti-abuse checks without threading
+    # the request through them.
+    #
+    # Thread-safe: CurrentAttributes keeps values per thread/fiber and Rails
+    # resets them each request, so concurrent requests never share this value.
     attribute :load_test_bypass
   end
 end

data/app/models/spree_cm_commissioner/dynamic_field.rb

@@ -18,6 +18,8 @@ module SpreeCmCommissioner
     validates :configurations, presence: true, allow_blank: false
     validate :validate_data_fill_stage_phase
 
+    after_commit :enqueue_data_fill_stage_maintenance_for_products, on: %i[update], if: :saved_change_to_data_fill_stage?
+
     scope :with_dynamic_field_options, -> { includes(dynamic_field_options: :dynamic_field) }
 
     def requires_dynamic_field_options?
@@ -45,6 +47,16 @@ module SpreeCmCommissioner
 
     private
 
+    # Reassigning which phase this field belongs to affects every product that has it enabled,
+    # not just one — same recompute/notify need as ProductDynamicField create.
+    def enqueue_data_fill_stage_maintenance_for_products
+      product_dynamic_fields.distinct.pluck(:product_id).each do |product_id|
+        SpreeCmCommissioner::MaintenanceTasks::GuestDataFillStage
+          .pending
+          .find_or_create_by(maintainable_type: 'Spree::Product', maintainable_id: product_id)
+      end
+    end
+
     def validate_data_fill_stage_phase
       return if data_fill_stage.blank?
 

data/app/models/spree_cm_commissioner/guest.rb

@@ -4,6 +4,7 @@ module SpreeCmCommissioner
     include SpreeCmCommissioner::KycBitwise
     include SpreeCmCommissioner::PhoneNumberSanitizer
     include SpreeCmCommissioner::Integrations::IntegrationMappable
+    include SpreeCmCommissioner::GuestDataFillStageConcern
 
     delegate :kyc, to: :line_item, allow_nil: true
     delegate :allowed_upload_later?, to: :line_item, allow_nil: true
@@ -68,7 +69,6 @@ module SpreeCmCommissioner
     after_update :preload_order_block_ids, if: :saved_change_to_block_id?
     before_destroy :cancel_reserved_block!, if: -> { reserved_block.present? }
     after_destroy :preload_order_block_ids
-    after_commit :update_user_incomplete_guest_info_status, if: :should_update_incomplete_guest_info?
 
     validates :bib_index, uniqueness: true, allow_nil: true
 
@@ -368,154 +368,11 @@ module SpreeCmCommissioner
       )
     end
 
-    def all_required_dynamic_fields_completed?(stage)
-      missing_dynamic_fields_for_stage(stage).blank?
-    end
-
-    state_machine :data_fill_stage_phase, initial: 'pre_registration' do
-      state 'pre_registration', value: 'pre_registration'
-      state 'post_registration', value: 'post_registration'
-      state 'during_check_in', value: 'during_check_in'
-      state 'completed', value: 'completed'
-
-      event :complete_pre_registration do
-        transition 'pre_registration' => 'post_registration',
-                   if: -> (guest) { guest.pre_registration_completed? && guest.post_registration_fields? }
-        transition 'pre_registration' => 'during_check_in',
-                   if: -> (guest) { guest.pre_registration_completed? && !guest.post_registration_fields? && guest.during_check_in_fields? }
-        transition 'pre_registration' => 'completed',
-                   if: -> (guest) { guest.pre_registration_completed? && !guest.post_registration_fields? && !guest.during_check_in_fields? }
-      end
-
-      event :complete_post_registration do
-        transition 'post_registration' => 'during_check_in',
-                   if: -> (guest) { guest.post_registration_completed? && guest.during_check_in_fields? }
-        transition 'post_registration' => 'completed',
-                   if: -> (guest) { guest.post_registration_completed? && !guest.during_check_in_fields? }
-      end
-
-      event :complete_check_in do
-        transition 'during_check_in' => 'completed',
-                   if: -> (guest) { guest.check_in_completed? }
-      end
-    end
-
-    def save_and_move_to_next_stage(_transition = nil)
-      # Trigger state machine transitions based on completion status
-      case data_fill_stage_phase
-      when 'pre_registration'
-        complete_pre_registration! if pre_registration_completed?
-      when 'post_registration'
-        complete_post_registration! if post_registration_completed?
-      when 'during_check_in'
-        complete_check_in! if check_in_completed?
-      end
-    end
-
-    def completed_phases
-      phases = []
-      phases << 'pre_registration' if pre_registration_completed?
-      phases << 'post_registration' if post_registration_completed?
-      phases << 'during_check_in' if check_in_completed?
-      phases
-    end
-
-    def pre_registration_completed?
-      return false unless line_item&.order&.completed?
-      return true unless line_item&.product&.dynamic_fields&.pre_registration&.any?
-
-      required_fields = line_item.product.dynamic_fields.pre_registration.pluck(:id)
-      filled_fields = guest_dynamic_fields.where(dynamic_field_id: required_fields).pluck(:dynamic_field_id)
-      (required_fields - filled_fields).empty?
-    end
-
-    def post_registration_completed?
-      return false unless line_item&.order&.completed?
-      return true unless line_item&.product&.dynamic_fields&.post_registration&.any?
-
-      required_fields = line_item.product.dynamic_fields.post_registration.pluck(:id)
-      filled_fields = guest_dynamic_fields.where(dynamic_field_id: required_fields).pluck(:dynamic_field_id)
-      (required_fields - filled_fields).empty?
-    end
-
-    def check_in_completed?
-      return false unless line_item&.order&.completed?
-      return true unless line_item&.product&.dynamic_fields&.during_check_in&.any?
-
-      required_fields = line_item.product.dynamic_fields.during_check_in.pluck(:id)
-      filled_fields = guest_dynamic_fields.where(dynamic_field_id: required_fields).pluck(:dynamic_field_id)
-      (required_fields - filled_fields).empty?
-    end
-
-    def pre_registration_fields?
-      line_item&.product&.dynamic_fields&.pre_registration&.any?
-    end
-
-    def post_registration_fields?
-      line_item&.product&.dynamic_fields&.post_registration&.any?
-    end
-
-    def during_check_in_fields?
-      line_item&.product&.dynamic_fields&.during_check_in&.any?
-    end
-
-    def product_dynamic_fields
-      @product_dynamic_fields ||= line_item.product.dynamic_fields
-    end
-
-    def missing_dynamic_fields_for_stage(stage)
-      return [] if line_item.blank? || line_item.product.blank?
-
-      # Cache product dynamic fields to avoid multiple queries
-      @product_dynamic_fields ||= line_item.product.dynamic_fields
-      required_fields = @product_dynamic_fields.where(data_fill_stage: stage)
-      filled_ids = guest_dynamic_fields&.pluck(:dynamic_field_id) || []
-
-      required_fields.reject { |field| filled_ids.include?(field.id) }
-    end
-
     def reject_guest_dynamic_field?(attributes)
       # Reject if dynamic_field_id is blank or if _destroy is true
       attributes[:dynamic_field_id].blank? || ActiveModel::Type::Boolean.new.cast(attributes[:_destroy])
     end
 
-    def update_user_incomplete_guest_info_status
-      return unless user
-      return unless line_item&.order&.completed?
-
-      user.reload
-
-      has_incomplete = user.orders.complete.any? do |order|
-        order_has_incomplete_guests?(order)
-      end
-
-      current_status = user.public_metadata['has_incomplete_guest_info'] || false
-
-      return unless current_status != has_incomplete
-
-      user.public_metadata['has_incomplete_guest_info'] = has_incomplete
-      user.save!
-    end
-
-    def order_has_incomplete_guests?(order)
-      order.line_items.any? do |line_item|
-        line_item.guests.any? do |guest|
-          guest_incomplete?(guest)
-        end
-      end
-    end
-
-    def guest_incomplete?(guest)
-      (guest.pre_registration_fields? && !guest.pre_registration_completed?) ||
-        (guest.post_registration_fields? && !guest.post_registration_completed?) ||
-        (guest.during_check_in_fields? && !guest.check_in_completed?)
-    end
-
-    def should_update_incomplete_guest_info?
-      saved_change_to_data_fill_stage_phase? ||
-        (guest_dynamic_fields.any? && (guest_dynamic_fields.any?(&:saved_changes?) || guest_dynamic_fields.any?(&:destroyed?)))
-    end
-
     # Ticket Transfer validations
     def allows_transfer?
       line_item&.product&.allow_transfer?

data/app/models/spree_cm_commissioner/guest_dynamic_field.rb

@@ -4,26 +4,49 @@ module SpreeCmCommissioner
     belongs_to :dynamic_field, class_name: 'SpreeCmCommissioner::DynamicField', optional: false
     belongs_to :dynamic_field_option, class_name: 'SpreeCmCommissioner::DynamicFieldOption', optional: true
 
+    before_validation :assign_dynamic_field_option, if: :requires_dynamic_field_options?
+
+    validates :value, presence: true
+
     validate :validate_value_format, if: -> { value.present? && dynamic_field.present? }
-    validate :validate_option_reference, if: -> { dynamic_field_option.present? }
-    validate :validate_phase_sequence
-    validate :check_required_fields_based_on_phase
-    validate :reject_empty_string_for_text_fields
+    validate :validate_phase_sequence, if: -> { dynamic_field.present? && guest.present? }
+    validate :dynamic_field_unchanged, on: :update
 
-    after_commit :sync_guest_data_fill_stage_phase
+    # Fires once per changed field in a batch (e.g. Guests::Update saving N rows in one transaction).
+    # Each call recomputes the same already-correct value since all N changes are committed by the time
+    # any after_commit runs, so only the first call's write is real. Accepted: the alternative is either manual
+    # call sites (the exact bug this design replaced) or a fragile transaction-scoped dedup guard.
+    after_commit { guest&.refresh_data_fill_stage }
 
-    scope :with_dynamic_field_and_options, lambda {
-      includes(:dynamic_field, :dynamic_field_option)
-    }
+    scope :with_dynamic_field_and_options, -> { includes(:dynamic_field, :dynamic_field_option) }
 
     self.whitelisted_ransackable_associations = %w[guest]
     self.whitelisted_ransackable_attributes = %w[value]
 
+    def requires_dynamic_field_options?
+      return false if dynamic_field.blank?
+
+      dynamic_field.requires_dynamic_field_options?
+    end
+
     private
 
-    def validate_value_format
-      return if dynamic_field.blank?
+    # If no option is set yet, look it up from `value` -- by option id first, then by
+    # option value (unifies the two shapes callers submit a chosen option in: `value: "3"`
+    # vs `value: "red"`). Then overwrite `value` with the option's canonical value, so it
+    # stays a uniform human-readable string for consumers that read it generically
+    # regardless of field type (chatrace payloads, CSV export) instead of a raw option id.
+    def assign_dynamic_field_option
+      if dynamic_field_option.blank?
+        self.dynamic_field_option =
+          dynamic_field.dynamic_field_options.find_by(id: value) ||
+          dynamic_field.dynamic_field_options.find_by(value: value)
+      end
 
+      self.value = dynamic_field_option.value if dynamic_field_option.present?
+    end
+
+    def validate_value_format # rubocop:disable Metrics/CyclomaticComplexity
       case dynamic_field.data_type.to_s
       when 'text', 'textarea'
         errors.add(:value, "can't be blank") if value.is_a?(String) && value.strip == ''
@@ -32,74 +55,23 @@ module SpreeCmCommissioner
       when 'boolean'
         errors.add(:value, 'must be true or false') unless %w[true false].include?(value.to_s.downcase)
       when 'checkbox', 'radio', 'selection'
-        validate_option_value
-      end
-    end
-
-    def validate_option_value
-      if dynamic_field_option.present?
-        self.value ||= dynamic_field_option.value
-      else
-        valid_options = dynamic_field.dynamic_field_options.pluck(:id).map(&:to_s)
-        errors.add(:value, 'is not a valid option') unless valid_options.include?(value)
+        valid_option = dynamic_field_option.present? && dynamic_field_option.dynamic_field_id == dynamic_field_id
+        errors.add(:value, 'is not a valid option') unless valid_option
       end
     end
 
-    def validate_option_reference
-      return if dynamic_field.blank? || dynamic_field_option.blank?
-      return if dynamic_field_option.dynamic_field_id == dynamic_field_id
-
-      # Only validate if both dynamic_field and dynamic_field_option are persisted
-      # This prevents validation errors during creation when associations might not be fully loaded
-      return if dynamic_field.new_record? || dynamic_field_option.new_record?
-
-      errors.add(:dynamic_field_option, 'must belong to the same dynamic field')
-    end
-
+    # Blocks answering a later-stage field (e.g. post_registration) until every earlier stage
+    # (e.g. pre_registration) is complete for this guest.
     def validate_phase_sequence
-      return if dynamic_field.blank? || guest.blank?
+      stages = GuestDataFillStageConcern::STAGES
+      prior_stages = stages.first(stages.index(dynamic_field.data_fill_stage))
 
-      case dynamic_field.data_fill_stage.to_sym
-      when :post_registration
-        errors.add(:base, 'Must complete pre_registration fields first') unless guest.pre_registration_completed?
-      when :during_check_in
-        unless guest.post_registration_completed? || !guest.post_registration_fields?
-          errors.add(:base, 'Must complete post_registration fields first')
-        end
-      end
-    end
-
-    def field_required_in_current_phase?
-      return false if dynamic_field.blank? || guest.blank?
-
-      case dynamic_field.data_fill_stage.to_sym
-      when :pre_registration, :post_registration
-        guest.line_item.order.completed? && guest.check_ins.empty?
-      when :during_check_in
-        guest.check_ins.exists?
-      else
-        false
-      end
+      incomplete = prior_stages.find { |stage| !guest.stage_completed?(stage) }
+      errors.add(:base, "Must complete #{incomplete} fields first") if incomplete
     end
 
-    def check_required_fields_based_on_phase
-      return if dynamic_field.blank? || value.present?
-      return unless field_required_in_current_phase?
-
-      errors.add(:value, I18n.t("guest_dynamic_field.errors.#{dynamic_field.data_fill_stage}_required"))
-    end
-
-    def sync_guest_data_fill_stage_phase
-      guest&.save_and_move_to_next_stage
-      guest&.update_user_incomplete_guest_info_status
-    end
-
-    def reject_empty_string_for_text_fields
-      return if dynamic_field.blank?
-      return unless %w[text textarea].include?(dynamic_field.data_type.to_s)
-      return unless value.is_a?(String)
-
-      errors.add(:value, "can't be blank") if value.strip == ''
+    def dynamic_field_unchanged
+      errors.add(:dynamic_field_id, 'cannot be changed') if dynamic_field_id_changed?
     end
   end
 end

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

@@ -0,0 +1,21 @@
+module SpreeCmCommissioner
+  module MaintenanceTasks
+    class GuestDataFillStage < MaintenanceTask
+      BATCH_SIZE = ENV.fetch('MAINTENANCE_TASKS_GUEST_DATA_FILL_STAGE_BATCH_SIZE', '300').to_i
+
+      def maintain
+        product = maintainable
+
+        SpreeCmCommissioner::Guest
+          .joins(line_item: %i[variant order])
+          .where(spree_variants: { product_id: product.id })
+          .merge(Spree::Order.complete)
+          .order(:id)
+          .pluck(:id)
+          .each_slice(BATCH_SIZE) do |guest_ids|
+            SpreeCmCommissioner::MaintenanceTasks::GuestDataFillStageBatchJob.perform_later(guest_ids: guest_ids, notify: true)
+          end
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/order_decorator.rb

@@ -259,6 +259,32 @@ module SpreeCmCommissioner
       guests.exists?(state: %i[locked transferred])
     end
 
+    def has_incomplete_guest_info? # rubocop:disable Naming/PredicateName
+      # expires_in is a safety net, not the primary invalidation path — clear_has_incomplete_guest_info_cache
+      # is still called explicitly wherever the underlying guest data can change. This just bounds
+      # how long a missed invalidation could leave a stale value in place.
+      #
+      # Reads the persisted data_fill_stage column via a join instead of Guest#incomplete? (which
+      # recomputes live per guest). post_registration is the only stage that matters here: a
+      # completed order already forces pre_registration complete (guest_data_fill_stage_concern.rb),
+      # and during_check_in is check-in crew's concern, not something this banner surfaces —
+      # matches find_orders_with_incomplete_guest_info in orders_controller_decorator.rb.
+      Rails.cache.fetch(incomplete_guest_info_cache_key, expires_in: 1.hour) do
+        guests.post_registration.exists?
+      end
+    end
+
+    # Clears this order's own cache plus the purchaser's cross-order aggregate cache —
+    # anything that can change the former can also change the latter.
+    def clear_has_incomplete_guest_info_cache
+      Rails.cache.delete(incomplete_guest_info_cache_key)
+      user&.clear_has_incomplete_guest_info_cache
+    end
+
+    def incomplete_guest_info_cache_key
+      "order/#{id}/has_incomplete_guest_info"
+    end
+
     def generate_svg_qr
       qrcode = RQRCode::QRCode.new(qr_data)
       qrcode.as_svg(

data/app/models/spree_cm_commissioner/product_decorator.rb

@@ -183,28 +183,6 @@ module SpreeCmCommissioner
       end
     end
 
-    def dynamic_fields_by_collection_phase
-      {
-        pre_registration: dynamic_fields.pre_registration.includes(:dynamic_field_options).order(:position),
-        post_registration: dynamic_fields.post_registration.includes(:dynamic_field_options).order(:position),
-        during_check_in: dynamic_fields.during_check_in.includes(:dynamic_field_options).order(:position)
-      }
-    end
-
-    def required_dynamic_fields_completed?(guest, phase)
-      required_fields = dynamic_fields.where(data_fill_stage: phase)
-      return true if required_fields.empty?
-
-      filled_ids = guest.guest_dynamic_fields.where(dynamic_field_id: required_fields.select(:id)).pluck(:dynamic_field_id)
-      (required_fields.pluck(:id) - filled_ids).empty?
-    end
-
-    def required_fields_for_guest(guest)
-      dynamic_fields_by_collection_phase.transform_values do |fields|
-        fields.select { |field| guest.guest_dynamic_fields.where(dynamic_field: field).empty? }
-      end
-    end
-
     private
 
     def set_tenant

data/app/models/spree_cm_commissioner/product_dynamic_field.rb

@@ -4,5 +4,22 @@ module SpreeCmCommissioner
     belongs_to :dynamic_field, class_name: 'SpreeCmCommissioner::DynamicField', optional: false
 
     validates :dynamic_field_id, uniqueness: { scope: :product_id }
+
+    after_commit :enqueue_data_fill_stage_maintenance, on: %i[create]
+
+    private
+
+    # Only newly-added fields need active recompute: adding a field can make an
+    # already-complete guest newly incomplete, which needs a persisted-column fix and a
+    # catch-up notification. Removing a field can only shrink the required set, which
+    # stage_completed? already reflects correctly the instant it's checked live (no
+    # GuestDynamicField answers get destroyed by unlinking a field from a product) — no guest
+    # is ever made worse off, and nothing needs notifying, so it's not worth an async trigger.
+    # The persisted data_fill_stage column self-heals on that guest's next natural write.
+    def enqueue_data_fill_stage_maintenance
+      SpreeCmCommissioner::MaintenanceTasks::GuestDataFillStage
+        .pending
+        .find_or_create_by(maintainable_type: 'Spree::Product', maintainable_id: product_id)
+    end
   end
 end

data/app/models/spree_cm_commissioner/request_guard.rb

@@ -0,0 +1,19 @@
+module SpreeCmCommissioner
+  # Runs a protected block only for normal requests, so callers don't touch
+  # Current.load_test_bypass directly. Exempt requests (e.g. trusted load tests)
+  # skip the block and get nil back.
+  #
+  #   include SpreeCmCommissioner::RequestGuard
+  #
+  #   with_request_guard { validate_ip_rate_limit!(order) }
+  module RequestGuard
+    module_function
+
+    # Runs the block unless the request is exempt; returns its value, or nil.
+    def with_request_guard
+      return nil if SpreeCmCommissioner::Current.load_test_bypass
+
+      yield
+    end
+  end
+end

data/app/models/spree_cm_commissioner/user_decorator.rb

@@ -52,7 +52,6 @@ module SpreeCmCommissioner
       base.scope :by_non_tenant, -> { where(tenant_id: nil) }
       base.scope :vendor_users, -> (vendor_id) { joins(:role_users => :role).where(spree_roles: { vendor_id: vendor_id }).distinct }
 
-      base.store :public_metadata, accessors: [:has_incomplete_guest_info], coder: JSON
       base.store :private_metadata, accessors: %i[otp_secret otp_required_for_login consumed_timestep], coder: JSON
 
       base.store_public_metadata :primary_service_type, :string
@@ -66,6 +65,15 @@ module SpreeCmCommissioner
       # the id_token param. Nothing token-related is stored on the account itself.
       base.store_private_metadata :load_test_account, :boolean, default: false
 
+      # SQL counterpart of `load_test_account?`, so the flag can be filtered in the DB instead of
+      # loading rows into Ruby to call the predicate. private_metadata is stored double-encoded (a
+      # JSON string scalar, not a native jsonb object — see store_metadata), so unwrap the outer
+      # string with `#>> '{}'` before keying into it. Keeps the storage detail in one place next to
+      # the declaration above rather than duplicating the raw SQL in every caller.
+      base.scope :load_test_accounts, lambda {
+        where("(private_metadata #>> '{}')::jsonb ->> 'load_test_account' = 'true'")
+      }
+
       # Validations
       base.validates :primary_service_type,
                      inclusion: { in: SpreeCmCommissioner::ServiceType::SERVICE_TYPES.map(&:to_s) },
@@ -223,6 +231,23 @@ module SpreeCmCommissioner
         super(request)
       end
     end
+
+    def has_incomplete_guest_info? # rubocop:disable Naming/PredicateName
+      # expires_in is a safety net, not the primary invalidation path — see the matching comment
+      # on Order#has_incomplete_guest_info?. Joins straight to guests.post_registration instead of
+      # calling Order#has_incomplete_guest_info? per order (which would be N+1 query calls).
+      Rails.cache.fetch(incomplete_guest_info_cache_key, expires_in: 1.hour) do
+        orders.complete.joins(:guests).merge(SpreeCmCommissioner::Guest.post_registration).exists?
+      end
+    end
+
+    def clear_has_incomplete_guest_info_cache
+      Rails.cache.delete(incomplete_guest_info_cache_key)
+    end
+
+    def incomplete_guest_info_cache_key
+      "user/#{id}/has_incomplete_guest_info"
+    end
   end
 end
 

data/app/queries/spree_cm_commissioner/event_chart_queries.rb

@@ -59,7 +59,7 @@ module SpreeCmCommissioner
                WHEN cm_check_ins.id IS NOT NULL THEN 'show'
                ELSE 'no_show'
              END AS name,
-             COUNT(*) AS total"
+             COUNT(DISTINCT cm_guests.id) AS total"
                             )
                      .group('spree_products.id, CASE WHEN cm_check_ins.id IS NOT NULL THEN \'show\' ELSE \'no_show\' END')
                      .group_by(&:product_id)
@@ -98,7 +98,7 @@ module SpreeCmCommissioner
              WHEN cm_check_ins.entry_type = 0 THEN 'normal'
              WHEN cm_check_ins.entry_type = 1 THEN 'VIP'
            END AS name,
-           COUNT(cm_check_ins.id) AS total"
+           COUNT(DISTINCT cm_guests.id) AS total"
              )
              .group('spree_products.id, cm_check_ins.entry_type')
              .group_by(&:product_id)

data/app/queries/spree_cm_commissioner/pie_chart_event_aggregator_queries.rb

@@ -58,7 +58,7 @@ module SpreeCmCommissioner
                    WHEN cm_check_ins.id IS NOT NULL THEN 'show'
                    ELSE 'no_show'
                  END AS name,
-                 COUNT(*) AS total"
+                 COUNT(DISTINCT cm_guests.id) AS total"
                )
         .group('spree_products.id, CASE WHEN cm_check_ins.id IS NOT NULL THEN \'show\' ELSE \'no_show\' END')
         .group_by(&:product_id)
@@ -110,7 +110,7 @@ module SpreeCmCommissioner
                   CASE  WHEN cm_check_ins.entry_type = 0 THEN 'normal'
                         WHEN cm_check_ins.entry_type = 1 THEN 'VIP'
                         ELSE NULL END AS name,
-                  COUNT(cm_check_ins.id) AS total"
+                  COUNT(DISTINCT cm_guests.id) AS total"
                )
         .where.not(cm_check_ins: { id: nil })
         .group('spree_products.id, cm_check_ins.entry_type')