spree_cm_commissioner 2.8.15.pre.pre2 → 2.8.15.pre.pre3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 93c5573306fbc0f28002f0bd03260743213101bdf498bd31f6f1399562a9aa76
-  data.tar.gz: 47649ceb71b08fa483ff5f045bd1bd05d9d5246ed0346d2cd6cc5ebe78b0526a
+  metadata.gz: 3ac1f1c30c374b8f4ad3dd06b486bbe1e25cbfa1f1c26bbd7a3d53895aaefaa2
+  data.tar.gz: affc12ef47495c5c51530c1fae89c771380b3759825932ea263ec5474abbb289
 SHA512:
-  metadata.gz: 6942ddfbb5af4869b8ae506652edcbe8100f16c9430e51224b4f58d2f4fe68f783587a16bc10a89d5a397d8ae294c8534e59ffbfa6e63546dfd5fe0ea5b98033
-  data.tar.gz: e214d676b68d2ad73c8efb0a160f6fca2f86d0c33b32259adf1a7fc7a965d8ba6c2d74b2a8fa884f9b0d45ccc47aec7858c7c897646252d8439046616e70a3ae
+  metadata.gz: f14fbec2aadcfdf2ecb3e463fe26321d581f40ade6010ace88f1e2eb4dc9f8c3f80d329f8d3a8664133dd223376f17feca17a7413c3f9d515bc1c1f8eaa884d4
+  data.tar.gz: 53239fc959124a3cc3d6fe74804bbee08b576161b3914f45dab14b1e9be03c84000cfe716ce012c1c86f7903a3aa72d5127bc2979ff5f3a5a67c8a8a1a643407

data/.env.example

@@ -20,13 +20,6 @@ WAITING_ROOM_SESSION_SIGNATURE="e6b2********************26e3"
 WAITING_ROOM_SESSION_EXPIRE_DURATION_IN_SECOND=
 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= ""
@@ -70,9 +63,3 @@ PAYMENT_LOCK_MIN_DURATION_IN_MINUTES=5      # Minimum remaining hold time requir
 MAX_ACTIVE_HOLDS_PER_USER=3                 # Max concurrent active holds allowed per user across all orders
 MAX_HOLDS_PER_IP_PER_HOUR=5                 # Max hold attempts per IP address within a rolling 1-hour window (abuse prevention)
 HOLD_COOLDOWN_AFTER_EXPIRY_IN_MINUTES=2     # Cooldown period before a user can re-acquire a hold after one expired on them
-
-# 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/.github/workflows/test_and_build_gem.yml

@@ -163,9 +163,8 @@ jobs:
       - name: Security
         env:
           DATABASE_URL: postgres://myuser:mypassword@localhost:5432/test_db
-
-        # Using --no-threads to bypass a known Ruby 3.2.0 GC segmentation fault in CI.
         run: |
+          # Using --no-threads to bypass a known Ruby 3.2.0 GC segmentation fault in CI.
           bundle exec brakeman --no-threads --no-exit-on-warn
 
   test:

data/Gemfile.lock

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

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

@@ -23,31 +23,6 @@ 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/inventory_holds_controller.rb

@@ -9,7 +9,6 @@ module Spree
         q['s'] ||= 'created_at desc'
         q['created_at_gt'] = parse_time_or_nil(q['created_at_gt'], :beginning_of_day) if q['created_at_gt'].present?
         q['created_at_lt'] = parse_time_or_nil(q['created_at_lt'], :end_of_day) if q['created_at_lt'].present?
-        normalize_enum_filters!(q)
 
         @search = scope.ransack(q)
         result_scope = @search.result(distinct: true)
@@ -19,11 +18,7 @@ module Spree
                  .page(params[:page])
                  .per(params[:per_page] || Spree::Backend::Config[:admin_orders_per_page])
 
-        # Status tab counts must reflect every other filter but NOT the status filter, so
-        # each tab shows how many holds it would return (otherwise selecting one status
-        # zeroes out all the other tabs).
-        @status_counts = scope.ransack(q.except('status_eq')).result(distinct: true)
-                              .reorder(nil).group(:status).count
+        @status_counts = result_scope.reorder(nil).group(:status).count
       end
 
       def release
@@ -49,23 +44,8 @@ module Spree
 
       private
 
-      # `status` and `release_reason` are integer-backed enums. Ransack casts a string
-      # value for an integer column with String#to_i, so "payment_locked" becomes 0
-      # (== :pending) and every label silently filters to the wrong status. Translate
-      # enum labels to their stored integer before searching.
-      def normalize_enum_filters!(query)
-        {
-          'status_eq' => SpreeCmCommissioner::InventoryHold.statuses,
-          'release_reason_eq' => SpreeCmCommissioner::InventoryHold.release_reasons
-        }.each do |key, mapping|
-          value = query[key]
-          query[key] = mapping[value.to_s] if value.present? && mapping.key?(value.to_s)
-        end
-      end
-
       def back_params
         raw_params = params[:back_params].presence || params
-        raw_params = raw_params.to_unsafe_h if raw_params.respond_to?(:to_unsafe_h)
         ActionController::Parameters.new(raw_params).permit(:page, :per_page, q: {})
       end
 

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

@@ -4,10 +4,7 @@ module Spree
       class WaitingRoomController < Spree::Admin::BaseController
         def show
           @fetcher = SpreeCmCommissioner::WaitingRoomSystemMetadataFetcher.new
-          @lobby_fetcher = SpreeCmCommissioner::WaitingRoomLobbyMetadataFetcher.new
-
           @fetcher.load_document_data
-          @lobby_fetcher.load_document_data
 
           @active_sesions_count = SpreeCmCommissioner::WaitingRoomSession.active.count
         end
@@ -32,18 +29,6 @@ module Spree
 
           redirect_back fallback_location: admin_system_waiting_room_path
         end
-
-        def publish_lobby_path
-          result = SpreeCmCommissioner::WaitingRoom::PublishLobbyPath.call
-
-          if result.success?
-            flash[:success] = "Published waiting guests records path: #{result.value[:records_path]}"
-          else
-            flash[:error] = result.error.to_s
-          end
-
-          redirect_back fallback_location: admin_system_waiting_room_path
-        end
       end
     end
   end

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

@@ -28,10 +28,6 @@ module Spree
         remove_asset(@taxon.home_banner)
       end
 
-      def remove_ad_banner
-        remove_asset(@taxon.ad_banner)
-      end
-
       def remove_video_banner
         remove_asset(@taxon.video_banner)
       end
@@ -53,7 +49,6 @@ module Spree
         @taxon.build_app_banner(attachment: permitted_resource_params.delete(:app_banner)) if permitted_resource_params[:app_banner]
         @taxon.build_web_banner(attachment: permitted_resource_params.delete(:web_banner)) if permitted_resource_params[:web_banner]
         @taxon.build_home_banner(attachment: permitted_resource_params.delete(:home_banner)) if permitted_resource_params[:home_banner]
-        @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
 

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

@@ -44,11 +44,6 @@ 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/guests_controller.rb

@@ -31,15 +31,13 @@ module Spree
           def create
             spree_authorize! :update, spree_current_order, order_token
 
-            result = SpreeCmCommissioner::Cart::CreateGuest.call(
-              line_item: parent,
-              options: guest_params
-            )
+            resource = scope.new(guest_params)
 
-            if result.success?
-              render_serialized_payload(201) { serialize_resource(result.value) }
+            if resource.save
+              resource.save_and_move_to_next_stage
+              render_serialized_payload(201) { serialize_resource(resource) }
             else
-              render_error_payload(result.value.errors, 422)
+              render_error_payload(resource.errors, 422)
             end
           end
 

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

@@ -30,25 +30,13 @@ module Spree
           private
 
           def collection
-            # WARNING: Do NOT remove .order(id: :desc).
-            # Mobile relies on this ordering for paginated order_histories.
-            # Removing it will cause mobile to paginate by oldest records first (last 10 oldest),
-            # breaking the "most recent orders" display on the order history screen.
-            # It related to user cancel or complete order flow, which relies on the most recent orders being returned first.
             if spree_current_user.present?
-              spree_current_user.orders
-                                .not_archived
-                                .incomplete
-                                .order(id: :desc)
+              spree_current_user.orders.payment.not_archived
             else
               order_tokens = Array(params[:order_tokens])
               return Spree::Order.none if order_tokens.empty?
 
-              Spree::Order.not_archived
-                          .incomplete
-                          .without_user
-                          .where(token: order_tokens)
-                          .order(id: :desc)
+              Spree::Order.payment.not_archived.without_user.where(token: order_tokens)
             end
           end
 

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

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

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

@@ -37,25 +37,13 @@ module Spree
           end
 
           def collection
-            # WARNING: Do NOT remove .order(id: :desc).
-            # Mobile relies on this ordering for paginated order_histories.
-            # Removing it will cause mobile to paginate by oldest records first (last 10 oldest),
-            # breaking the "most recent orders" display on the order history screen.
-            # It related to user cancel or complete order flow, which relies on the most recent orders being returned first.
             if spree_current_user.present?
-              spree_current_user.orders
-                                .not_archived
-                                .incomplete
-                                .order(id: :desc)
+              spree_current_user.orders.payment.not_archived
             else
               order_tokens = Array(params[:order_tokens])
               return Spree::Order.none if order_tokens.empty?
 
-              Spree::Order.not_archived
-                          .incomplete
-                          .without_user
-                          .where(token: order_tokens)
-                          .order(id: :desc)
+              Spree::Order.payment.not_archived.without_user.where(token: order_tokens)
             end
           end
 

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

@@ -0,0 +1,81 @@
+module Spree
+  module Api
+    module V2
+      module Tenant
+        class VotePackagesController < BaseController
+          before_action :require_spree_current_user, only: :claim_status
+          before_action :require_votable_params, only: :index
+
+          # Overrided
+          def index
+            render_serialized_payload { serialize_collection(sorted_collection) }
+          end
+
+          def claim_status
+            product = current_season.vote_packages.find(params[:id])
+
+            result = SpreeCmCommissioner::VotingCredits::ClaimableScopeResolver.new(
+              product: product,
+              voting_session_id: params[:voting_session_id]
+            ).call
+
+            return render_error_payload(result.error, 422) if result.failure?
+
+            scope = result.value
+
+            claimed = SpreeCmCommissioner::Claim.free_claimed?(
+              user_id: spree_current_user.id,
+              product_id: product.id,
+              claimable_id: scope[:claimable_id],
+              claimable_type: scope[:claimable_type]
+            )
+
+            render_serialized_payload { { claimed: claimed }.merge(scope) }
+          end
+
+          private
+
+          # Overrided
+          def collection
+            current_vendor.vote_packages
+                          .where(status: :active, event_id: current_season.id)
+                          .by_votable(params[:votable_type], params[:votable_id])
+          end
+
+          # Overrided
+          def sorted_collection
+            packages = current_season.allow_free_vote? ? collection.to_a : collection.reject(&:free?)
+            packages.sort_by { |p| [p.free? ? 0 : 1, p.vote_credits.to_i] }
+          end
+
+          # Overrided
+          def serialize_collection(collection)
+            collection_serializer.new(
+              collection,
+              include: resource_includes
+            ).serializable_hash
+          end
+
+          # Overrided
+          def collection_serializer
+            Spree::V2::Tenant::VotePackageSerializer
+          end
+
+          def current_season
+            @current_season ||= current_vendor.shows
+                                              .where.not(parent_id: nil)
+                                              .find_by!(slug: params[:show_id])
+          end
+
+          # We need to require votable_type and votable_id params because we are filtering VotePackages by ShowEpisode.
+          # VotePackage Metadata(votable_type and votable_id) are important when allocating voting credits to users.
+          def require_votable_params
+            return if params[:votable_type].present? && params[:votable_id].present?
+
+            render_error_payload('votable_type and votable_id are required', 422)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,30 +4,14 @@
 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?
 
-        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
+        return find_by_token(params, token) if token.present?
+        return find_by_user(params, user) if user.present?
 
-        order
+        nil
       end
 
       def find_by_token(params, token)
@@ -40,20 +24,6 @@ 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/interactors/spree_cm_commissioner/waiting_guests_caller.rb

@@ -3,97 +3,41 @@ require 'google/cloud/firestore'
 # TODO: alert when available_slots is negative.
 module SpreeCmCommissioner
   class WaitingGuestsCaller < BaseInteractor
-    # 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
-
     def call
-      started_at = Time.zone.now
       available_slots = fetch_available_slots
+      return unless available_slots.positive?
 
-      # Always run through to mark_as — even with no slots — so the lobby keeps a fresh heartbeat
-      # (logs.waiting_guests_caller_job) during peak/full periods instead of going stale
-      # and looking like a dead cron.
-      long_waiting_guests = available_slots.positive? ? fetch_long_waiting_guests(available_slots) : []
-      calling_all(long_waiting_guests) if long_waiting_guests.any?
+      long_waiting_guests = fetch_long_waiting_guests(available_slots)
+      calling_all(long_waiting_guests)
 
-      mark_as(
-        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),
-        recent_slots_per_call: available_slots.positive? ? available_slots : nil,
-        active_sessions: @active_sessions,
-        max_sessions: @max_sessions,
-        logs: call_logs(started_at: started_at, called_count: long_waiting_guests.size)
-      )
+      mark_as(full: long_waiting_guests.size >= available_slots, available_slots: available_slots - long_waiting_guests.size)
     end
 
     def fetch_available_slots
-      @max_sessions = fetch_max_sessions
-      @active_sessions = SpreeCmCommissioner::WaitingRoomSession.active.count
-      [@max_sessions - @active_sessions, 0].max
+      max_sessions = fetch_max_sessions
+      active_sessions = SpreeCmCommissioner::WaitingRoomSession.active.count
+      max_sessions - active_sessions
     end
 
-    # This query requires an index; create it in Firebase beforehand.
-    # Client must create waiting_guests documents with :queued_at and :allow_to_enter_room_at set to nil to allow filter + order queries.
-    #
-    # Yesterday's guests are always older than today's, so fill from yesterday first, then use any
-    # leftover slots for today. This way no one queued before the midnight rollover gets skipped.
-    #   e.g. 5 slots, 2 waiting in yesterday -> take both, then take 3 from today.
+    # This query required index. create them in Firebase beforehand.
+    # Client side must create waiting_guests document with :queued_at & :allow_to_enter_room_at to null to allow fillter & order.
     def fetch_long_waiting_guests(available_slots)
-      previous_guests = eligible_guests_in(previous_records_path, available_slots)
-
-      # Pre-flip window: the lobby pointer still points at yesterday, so both paths resolve to the
-      # same partition — return now to avoid querying (and double-counting) it twice.
-      return previous_guests if records_path == previous_records_path
-
-      remaining_slots = available_slots - previous_guests.size
-      return previous_guests if remaining_slots <= 0
-
-      previous_guests + eligible_guests_in(records_path, remaining_slots)
-    end
-
-    def eligible_guests_in(records_path, limit)
-      firestore.col(records_path)
+      firestore.col('waiting_guests')
+               .doc(current_date)
+               .col('records')
                .where('allow_to_enter_room_at', '==', nil)
                .order('queued_at')
-               .limit(limit)
+               .limit(available_slots)
                .get.to_a
     end
 
-    # Published path is authoritative; fall back to the server's own date if not yet published.
-    def records_path
-      lobby_data&.dig(:waiting_guests_records_path).presence || default_records_path(current_date)
-    end
-
-    # Drain target is derived from the server date, never the (possibly stale) lobby pointer.
-    def previous_records_path
-      default_records_path(previous_date)
-    end
-
-    def default_records_path(date)
-      "waiting_guests/#{date}/records"
-    end
-
     # For alert waiting guests to enter room, we just update :allow_to_enter_room_at.
     # App will listen to firebase & start refresh session token to enter room.
-    #
-    # Commit in Firestore batches (chunks of FIRESTORE_BATCH_SIZE) instead of one update per guest,
-    # so e.g. 1000 guests = 2 commits, not 1000 round-trips. update merges, so we only send the
-    # changed field and leave the rest of each doc intact.
     def calling_all(waiting_guests)
-      allow_at = Time.zone.now
-
-      waiting_guests.each_slice(FIRESTORE_BATCH_SIZE) do |slice|
-        firestore.batch do |b|
-          slice.each { |document| b.update(document.ref, { allow_to_enter_room_at: allow_at }) }
-        end
+      waiting_guests.each do |document|
+        data = document.data.dup
+        data[:allow_to_enter_room_at] = Time.zone.now
+        document.ref.update(data)
       end
     end
 
@@ -101,79 +45,9 @@ module SpreeCmCommissioner
       Time.zone.now.strftime('%Y-%m-%d')
     end
 
-    def previous_date
-      1.day.ago.strftime('%Y-%m-%d')
-    end
-
-    # merge: true so we preserve the published `waiting_guests_records_path` on the lobby doc.
-    # App-facing fields plus live capacity state (full / available_slots / active_sessions /
-    # max_sessions / ETAs) stay top-level; this run's observability snapshot is namespaced under
-    # `logs.waiting_guests_caller_job` (see #call_logs). merge: true deep-merges nested maps, so
-    # each job owns its own key under `logs` without clobbering the others.
-    def mark_as( # rubocop:disable Metrics/ParameterLists
-      full:,
-      available_slots:,
-      avg_wait_to_enter_seconds: nil,
-      avg_queue_to_enter_seconds: nil,
-      recent_slots_per_call: nil,
-      active_sessions: nil,
-      max_sessions: nil,
-      logs: 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[:recent_slots_per_call] = recent_slots_per_call if recent_slots_per_call
-      data[:active_sessions] = active_sessions unless active_sessions.nil?
-      data[:max_sessions] = max_sessions unless max_sessions.nil?
-      data[:logs] = { waiting_guests_caller_job: logs } if logs
-
-      lobby_document.set(data, merge: true)
-    end
-
-    # Point-in-time snapshot (overwritten each run, never cumulative) of this caller run: last-run
-    # timing (heartbeat) and how many guests were called. Capacity state (active/max sessions,
-    # available_slots) lives top-level, not here.
-    def call_logs(started_at:, called_count:)
-      finished_at = Time.zone.now
-      {
-        called_count: called_count,
-        last_started_at: started_at,
-        last_finished_at: finished_at,
-        last_duration_ms: ((finished_at - started_at) * 1000).round
-      }
-    end
-
-    # Average total wait (queued_at → allow_to_enter_room_at) for just-called guests.
-    # Used for the Waiting Room step ETA: how long until I get in from when I joined.
-    def compute_avg_wait_to_enter_seconds(guests)
-      return nil if guests.empty?
-
-      now = Time.zone.now
-      total = guests.sum { |doc| (now - doc.data[:queued_at].to_time).to_f }
-      [(total / guests.size).round, MIN_WAIT_TO_ENTER_SECONDS].max
-    end
-
-    # Average queue wait (position_set_at → allow_to_enter_room_at) for just-called guests.
-    # Used for the Queue step ETA: how long after getting a position until I actually enter.
-    # Returns nil when none of the called guests had position_set_at (first run, or no prior stamp).
-    def compute_avg_queue_to_enter_seconds(guests)
-      return nil if guests.empty?
-
-      now = Time.zone.now
-      positioned = guests.select { |doc| doc.data[:position_set_at] }
-      return nil if positioned.empty?
-
-      total = positioned.sum { |doc| (now - doc.data[:position_set_at].to_time).to_f }
-      [(total / positioned.size).round, MIN_QUEUE_TO_ENTER_SECONDS].max
-    end
-
-    def lobby_data
-      @lobby_data ||= lobby_document.get.data
-    end
-
-    def lobby_document
-      @lobby_document ||= firestore.col('waiting_rooms').doc('lobby')
+    # When open app, app request to check whether room is full or not via Firebase instead of server to minimize server requests.
+    def mark_as(full:, available_slots:)
+      firestore.col('waiting_rooms').doc('lobby').set({ full: full, available_slots: available_slots })
     end
 
     def fetch_max_sessions

data/app/interactors/spree_cm_commissioner/waiting_room_latest_system_metadata_puller.rb

@@ -10,14 +10,12 @@ module SpreeCmCommissioner
         secret_access_key: ENV.fetch('AWS_SECRET_ACCESS_KEY')
       )
 
-      response = ecs_client.describe_services(
+      tasks_response = ecs_client.list_tasks(
         cluster: ENV.fetch('AWS_CLUSTER_NAME'),
-        services: [ENV.fetch('AWS_CLUSTER_SERVICE_NAME')]
+        launch_type: 'FARGATE'
       )
 
-      running_count = response.services.first.running_count
-
-      SpreeCmCommissioner::WaitingRoomSystemMetadataSetter.new.set(server_running_count: running_count)
+      SpreeCmCommissioner::WaitingRoomSystemMetadataSetter.new.set(server_running_count: [tasks_response.task_arns.size, 1].max)
     end
   end
 end