spree_cm_commissioner 2.8.3.pre.pre12 → 2.8.3.pre.pre14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc7986faabd73e3ae1e70e3a80e14f59119301779f847a112d585d15bf52406f
-  data.tar.gz: 97c8e0f4d601a7ddb553e786bc23f0f8b9a70a1eae307d7cf79da8e05d70d5c9
+  metadata.gz: e14575f7ac52d9cfa8c454de179107ec31f080a9b8bdc2ff1bfdebeeb5a42f46
+  data.tar.gz: fde706a204a681e6c94931be9dfc915ed5090f3abd81d2481120d598b1e168dd
 SHA512:
-  metadata.gz: a1bec82d194a2943c597dc804c2a3f69c7a3f09da8c9734d82e76c1af7c102748175307e1a530a7107a0011bf5d1556cefc1c2d9fd7929e1e52ea2979912ed2c
-  data.tar.gz: 992f9e6d0c5b58e06d726ed5967121d85530bf654410a475ce7b694f7e559dc42d6bc0e021136e550b000517b6d9a505e45db16bede3bc2ecc0b70c308c267ec
+  metadata.gz: c69e06e635df7a5259a6fbcab7d1fba55b93eac89ed5c12592e0070baf1bfbaa3ad442754604fd7cffe435d069c340a0f6b427abf39049d5fa5855b5a68fc64f
+  data.tar.gz: 33bf29761d4ee458f559c067c5872db8e381c0f9de7805ce02efaa76bde07229e97a5c20f42ba81a77eb585820dc4360eadbcd035cb4be740364ff1d2d947440

data/Gemfile.lock

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

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

@@ -4,7 +4,10 @@ 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
@@ -29,6 +32,18 @@ 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/api/v2/tenant/free_vote_claim_controller.rb

@@ -0,0 +1,58 @@
+module Spree
+  module Api
+    module V2
+      module Tenant
+        class FreeVoteClaimController < BaseController
+          before_action :require_spree_current_user
+
+          def show
+            load_effective_config_onto_show
+
+            render_serialized_payload { serialize_resource(current_show) }
+          end
+
+          def create
+            result = SpreeCmCommissioner::VotingCredits::ClaimFreeVotes.new(
+              show: current_show,
+              user: spree_current_user,
+              tenant_id: MultiTenant.current_tenant_id,
+              votable_id: voting_session.id
+            ).call
+
+            if result.failure?
+              render_error_payload(result.error.to_s)
+            elsif result.value.nil?
+              head :no_content
+            else
+              render_serialized_payload { Spree::V2::Tenant::VotingCreditSerializer.new(result.value).serializable_hash }
+            end
+          end
+
+          private
+
+          def resource_serializer
+            Spree::V2::Tenant::FreeVoteClaimSerializer
+          end
+
+          def load_effective_config_onto_show
+            config = voting_session.effective_voting_config(show_config: current_show.effective_voting_config)
+
+            current_show.claimed = !spree_current_user.free_vote_claimable?(show: current_show, votable_id: voting_session.id)
+            current_show.effective_free_vote_limit = config['free_vote_limit']
+            current_show.effective_free_vote_limit_type = config['free_vote_limit_type']
+          rescue ArgumentError
+            current_show.claimed = false
+          end
+
+          def voting_session
+            @voting_session ||= current_vendor.voting_sessions.find(params[:voting_session_id])
+          end
+
+          def current_show
+            @current_show ||= voting_session.show
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Spree
+  module Api
+    module V2
+      module Tenant
+        class VotePackagesController < BaseController
+          def index
+            render_serialized_payload { serialize_collection(scope) }
+          end
+
+          private
+
+          def scope
+            current_vendor.vote_packages.where(status: :active, event_id: current_season.id)
+          end
+
+          def current_season
+            @current_season ||= current_vendor.shows
+                                              .where.not(parent_id: nil)
+                                              .find_by!(slug: params[:show_id])
+          end
+
+          def serialize_collection(collection)
+            collection_serializer.new(collection, include: resource_includes).serializable_hash
+          end
+
+          def collection_serializer
+            Spree::V2::Tenant::VotePackageSerializer
+          end
+        end
+      end
+    end
+  end
+end

data/app/interactors/spree_cm_commissioner/waiting_guests_caller.rb

@@ -19,18 +19,47 @@ module SpreeCmCommissioner
       max_sessions - active_sessions
     end
 
-    # 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.
+    # 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.
     def fetch_long_waiting_guests(available_slots)
-      firestore.col('waiting_guests')
-               .doc(current_date)
-               .col('records')
+      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)
                .where('allow_to_enter_room_at', '==', nil)
                .order('queued_at')
-               .limit(available_slots)
+               .limit(limit)
                .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.
     def calling_all(waiting_guests)
@@ -45,9 +74,22 @@ module SpreeCmCommissioner
       Time.zone.now.strftime('%Y-%m-%d')
     end
 
+    def previous_date
+      1.day.ago.strftime('%Y-%m-%d')
+    end
+
     # When open app, app request to check whether room is full or not via Firebase instead of server to minimize server requests.
+    # merge: true so we preserve the published `waiting_guests_records_path` on the lobby doc.
     def mark_as(full:, available_slots:)
-      firestore.col('waiting_rooms').doc('lobby').set({ full: full, available_slots: available_slots })
+      lobby_document.set({ full: full, available_slots: available_slots }, merge: true)
+    end
+
+    def lobby_data
+      @lobby_data ||= lobby_document.get.data
+    end
+
+    def lobby_document
+      @lobby_document ||= firestore.col('waiting_rooms').doc('lobby')
     end
 
     def fetch_max_sessions

data/app/jobs/spree_cm_commissioner/waiting_room/publish_lobby_path_job.rb

@@ -0,0 +1,17 @@
+# waiting_room_lobby_path_publisher:
+#   cron: "0 0 * * * Asia/Phnom_Penh" # Once per day at local midnight (date rollover)
+#   class: "SpreeCmCommissioner::WaitingRoom::PublishLobbyPathJob"
+module SpreeCmCommissioner
+  module WaitingRoom
+    class PublishLobbyPathJob < ApplicationJob
+      queue_as :waiting_room
+
+      def perform
+        return if ENV['WAITING_ROOM_DISABLED'] == 'yes'
+
+        # call! so a publish failure raises (Sidekiq retries/alerts) instead of being silently swallowed.
+        SpreeCmCommissioner::WaitingRoom::PublishLobbyPath.call!
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/show.rb

@@ -2,14 +2,17 @@ module SpreeCmCommissioner
   class Show < Spree::Taxon
     include SpreeCmCommissioner::StoreMetadata
 
-    has_many :voting_credits, class_name: 'SpreeCmCommissioner::VotingCredit', as: :votable, dependent: :destroy
     belongs_to :show, class_name: 'SpreeCmCommissioner::Show', foreign_key: :parent_id, optional: true
+
+    has_many :voting_credits, class_name: 'SpreeCmCommissioner::VotingCredit', as: :votable, dependent: :destroy
     has_many :seasons, class_name: 'SpreeCmCommissioner::Show', foreign_key: :parent_id, inverse_of: :parent
     has_many :show_contestants, class_name: 'SpreeCmCommissioner::ShowContestant', inverse_of: :show, dependent: :destroy
     has_many :show_people_assignments, class_name: 'SpreeCmCommissioner::ShowPersonAssignment', dependent: :destroy
     has_many :show_people, through: :show_people_assignments, source: :show_person
     has_many :episodes, class_name: 'SpreeCmCommissioner::ShowEpisode', foreign_key: :event_id
+    has_many :vote_packages, -> { where(product_type: :vote_package) }, class_name: 'SpreeCmCommissioner::ShowEpisode', foreign_key: :event_id
     has_many :voting_sessions, through: :episodes, class_name: 'SpreeCmCommissioner::VotingSession'
+
     has_one :current_episode, -> { current_or_next_upcoming }, class_name: 'SpreeCmCommissioner::ShowEpisode', foreign_key: :event_id
     has_one :current_voting_session, through: :current_episode
 
@@ -24,6 +27,8 @@ module SpreeCmCommissioner
     SHOW_TYPES = %w[show tournament boxing].freeze
 
     # Define standard voting configuration keys
+    attr_accessor :claimed, :effective_free_vote_limit, :effective_free_vote_limit_type
+
     store_accessor :voting_config,
                    :free_vote_limit,
                    :free_vote_limit_type,
@@ -64,12 +69,13 @@ module SpreeCmCommissioner
       "SpreeCmCommissioner::#{type}"
     end
 
-    def free_vote_idempotency_key(user_id:, votable_id: nil)
-      case free_vote_limit_type
+    def free_vote_idempotency_key(user_id:, votable_id: nil, limit_type: nil)
+      effective_limit_type = limit_type || free_vote_limit_type
+      case effective_limit_type
       when 'per_episode'        then "free_claim::episode::#{votable_id}::user::#{user_id}"
       when 'per_voting_session' then "free_claim::voting_session::#{votable_id}::user::#{user_id}"
       when 'per_show'           then "free_claim::show::#{id}::user::#{user_id}"
-      else raise ArgumentError, "Invalid free_vote_limit_type: #{free_vote_limit_type}"
+      else raise ArgumentError, "Invalid free_vote_limit_type: #{effective_limit_type}"
       end
     end
 

data/app/models/spree_cm_commissioner/user_decorator.rb

@@ -196,6 +196,18 @@ module SpreeCmCommissioner
       notification
     end
 
+    def free_vote_claimable?(show:, votable_id: nil)
+      voting_session = votable_id.present? ? SpreeCmCommissioner::VotingSession.find_by(id: votable_id, show: show) : nil
+      effective_config = voting_session&.effective_voting_config || show.effective_voting_config
+      limit_type = effective_config['free_vote_limit_type']
+
+      return false unless limit_type
+
+      resolved_votable_id = limit_type == 'per_episode' ? voting_session&.episode_id : votable_id
+      idempotency_key = show.free_vote_idempotency_key(user_id: id, votable_id: resolved_votable_id, limit_type: limit_type)
+      !voting_credit_transactions.exists?(idempotency_key: idempotency_key)
+    end
+
     def push_notificable?
       return false if device_tokens_count.blank?
 

data/app/models/spree_cm_commissioner/vendor_decorator.rb

@@ -118,6 +118,7 @@ module SpreeCmCommissioner
                                           }, class_name: 'Spree::Taxonomy', dependent: :destroy
 
       base.has_many :merchandise_products, -> { where(product_type: :ecommerce, event_id: nil) }, class_name: 'Spree::Product'
+      base.has_many :vote_packages, -> { where(product_type: :vote_package) }, class_name: 'SpreeCmCommissioner::ShowEpisode', foreign_key: :vendor_id
 
       # Create maintaining task to purge vendor related caches
       base.after_save { SpreeCmCommissioner::MaintenanceTasks::CacheInvalidation.pending.create_or_find_by(maintainable: self) }

data/app/models/spree_cm_commissioner/voting_session.rb

@@ -103,12 +103,12 @@ module SpreeCmCommissioner
       end
     end
 
-    def effective_voting_config
+    def effective_voting_config(show_config: nil)
       return {} unless show
 
-      config = parse_json_config(voting_config)
-      show_config = show.effective_voting_config
-      config.reverse_merge(show_config || {})
+      show_config ||= show.effective_voting_config
+      session_config = parse_json_config(voting_config).compact
+      show_config.merge(session_config)
     end
 
     def effective_fraud_config

data/app/serializers/spree/v2/tenant/free_vote_claim_serializer.rb

@@ -0,0 +1,9 @@
+module Spree
+  module V2
+    module Tenant
+      class FreeVoteClaimSerializer < BaseSerializer
+        attributes :claimed, :effective_free_vote_limit, :effective_free_vote_limit_type
+      end
+    end
+  end
+end

data/app/serializers/spree/v2/tenant/vote_package_serializer.rb

@@ -2,7 +2,10 @@ module Spree
   module V2
     module Tenant
       class VotePackageSerializer < BaseSerializer
-        attributes :name, :price, :compare_at_price, :available_on, :discontinue_on, :status, :vote_credits
+        attributes :name, :price, :compare_at_price, :currency, :display_price,
+                   :available_on, :discontinue_on, :status, :vote_credits
+
+        has_many :variants, serializer: Spree::V2::Tenant::VariantSerializer
       end
     end
   end

data/app/services/spree_cm_commissioner/voting_credits/claim_free_votes.rb

@@ -1,82 +1,57 @@
-# Mobile can check that where ClaimFreeVotes Screen should Appear based on the show's voting_config.
-# free_vote_limit and voting_config.free_vote_limit_type, then call this service to claim free votes.
-#
-# Grants free votes to a user based on the show's free_vote_limit_type:
-#   - per_show          : once per show          (no extra params needed)
-#   - per_episode       : once per episode        (pass votable_type: 'SpreeCmCommissioner::ShowEpisode', votable_id: episode.id)
-#   - per_voting_session: once per voting session (pass votable_type: 'SpreeCmCommissioner::VotingSession', votable_id: voting_session.id)
+# Grants free votes based on the effective config (voting session overrides show):
+#   - per_show          : once per show          (votable_id optional)
+#   - per_episode       : once per episode        (votable_id: voting_session.id)
+#   - per_voting_session: once per voting session (votable_id: voting_session.id)
 #
+# votable_id is always a VotingSession ID. The episode is derived from it when needed.
+# The credit wallet target is determined by the show's voting_credit_scope.
 # Idempotent: a unique idempotency_key on the transaction prevents double-claiming.
-#
-# Usage:
-#   Show with per_show limit:
-#   SpreeCmCommissioner::VotingCredits::ClaimFreeVotes.new(
-#     show: show,
-#     user: user,
-#     tenant_id: 1
-#   ).call
-#
-#   Show with per_episode limit:
-#   SpreeCmCommissioner::VotingCredits::ClaimFreeVotes.new(
-#     show: show,
-#     user: user,
-#     tenant_id: 1,
-#     votable_type: 'SpreeCmCommissioner::ShowEpisode',
-#     votable_id: episode.id
-#   ).call
-#
-#   Show with per_voting_session limit:
-#   SpreeCmCommissioner::VotingCredits::ClaimFreeVotes.new(
-#     show: show,
-#     user: user,
-#     tenant_id: 1,
-#     votable_type: 'SpreeCmCommissioner::VotingSession',
-#     votable_id: voting_session.id
-#   ).call
 module SpreeCmCommissioner
   module VotingCredits
     class ClaimFreeVotes
       prepend ::Spree::ServiceModule::Base
 
-      attr_reader :show, :user, :tenant_id, :votable_type, :votable_id
+      attr_reader :show, :user, :tenant_id, :votable_id
 
-      def initialize(show:, user:, tenant_id:, votable_type: nil, votable_id: nil)
+      def initialize(show:, user:, tenant_id:, votable_id: nil)
         @show = show
         @user = user
         @tenant_id = tenant_id
-        @votable_type = votable_type
         @votable_id = votable_id
       end
 
-      # Returns the VotingCredit after granting free votes,
-      # or returns msg if free votes cannot be granted (e.g. limit reached).
-      def call # rubocop:disable Metrics/AbcSize
-        return success(nil) unless show.free_vote_limit_type
+      def call
+        return success(nil) unless effective_limit_type
 
-        idempotency_key = show.free_vote_idempotency_key(user_id: user.id, votable_id: votable_id)
+        return failure(nil, 'votable_id is required for per_episode/per_voting_session') if requires_votable_id? && votable_id.blank?
 
-        # idempotency_key is uniquely indexed — faster than scoping through user.voting_transactions association.
-        if SpreeCmCommissioner::VotingCreditTransaction.exists?(idempotency_key: idempotency_key)
-          return failure(nil, 'Free votes have already been claimed')
-        end
+        key_votable_id = effective_limit_type == 'per_episode' ? resolved_voting_session.episode_id : votable_id
+        idempotency_key = show.free_vote_idempotency_key(user_id: user.id, votable_id: key_votable_id, limit_type: effective_limit_type)
 
-        amount = show.free_vote_limit.to_i
+        return failure(nil, 'Free votes have already been claimed') if already_claimed?(idempotency_key)
+
+        amount = effective_limit.to_i
 
         return failure(nil, "Free votes are not available for #{show.voting_credit_scope}") if amount <= 0
 
-        case show.free_vote_limit_type
-        when 'per_episode', 'per_voting_session'
-          if votable_type.blank? || votable_id.blank?
-            return failure(nil, 'votable_type and votable_id are required for per_episode/per_voting_session')
-          end
-        end
+        credit = grant_votes(amount: amount, idempotency_key: idempotency_key)
 
+        success(credit)
+      rescue ActiveRecord::RecordNotUnique
+        failure(nil, 'Free votes have already been claimed')
+      rescue StandardError => e
+        failure(nil, e.message)
+      end
+
+      private
+
+      def grant_votes(amount:, idempotency_key:)
         credit = nil
 
         ActiveRecord::Base.transaction do
           credit = user.voting_credits.active.find_or_create_by!(
             tenant_id: tenant_id,
-            votable: votable
+            votable: credit_votable
           ) { |c| c.category = :promo }
 
           credit.with_lock do
@@ -90,30 +65,52 @@ module SpreeCmCommissioner
             amount: amount,
             originator: show,
             free_claim_votable_id: votable_id,
+            idempotency_key: idempotency_key,
             user_total_amount: credit.available_votes,
             memo: "Free claim: #{amount} votes | credit_scope: #{show.voting_credit_scope} | key: #{idempotency_key}"
           )
         end
 
-        success(credit)
-      rescue ActiveRecord::RecordNotUnique
-        # Two concurrent requests can both pass the existence check before either commits.
-        # The one that loses the unique-index race lands here — treat it as already claimed.
-        failure(nil, 'Free votes have already been claimed')
-      rescue StandardError => e
-        failure(nil, e.message)
+        credit
       end
 
-      # Always find votable by the show's credit_votable_type, to ensure consistency with where the credits are allocated.
-      # Resolves through the show association to prevent claiming against unrelated votable_ids.
-      def votable
+      def credit_votable
         case show.credit_votable_type
-        when 'SpreeCmCommissioner::Show'          then show
-        when 'SpreeCmCommissioner::ShowEpisode'   then show.episodes.find(votable_id)
-        when 'SpreeCmCommissioner::VotingSession' then show.voting_sessions.find(votable_id)
+        when 'SpreeCmCommissioner::Show'        then show
+        when 'SpreeCmCommissioner::ShowEpisode' then SpreeCmCommissioner::ShowEpisode.find(resolved_voting_session.episode_id)
+        when 'SpreeCmCommissioner::VotingSession' then resolved_voting_session
         else raise ActiveRecord::RecordNotFound, "Unknown credit_votable_type: #{show.credit_votable_type}"
         end
       end
+
+      def resolved_voting_session
+        @resolved_voting_session ||= SpreeCmCommissioner::VotingSession.find_by!(id: votable_id, show: show)
+      end
+
+      def effective_voting_config
+        @effective_voting_config ||=
+          if votable_id.present?
+            resolved_voting_session.effective_voting_config(show_config: show.effective_voting_config)
+          else
+            show.effective_voting_config
+          end
+      end
+
+      def effective_limit_type
+        effective_voting_config['free_vote_limit_type']
+      end
+
+      def effective_limit
+        effective_voting_config['free_vote_limit']
+      end
+
+      def requires_votable_id?
+        effective_limit_type.in?(%w[per_episode per_voting_session])
+      end
+
+      def already_claimed?(idempotency_key)
+        SpreeCmCommissioner::VotingCreditTransaction.exists?(idempotency_key: idempotency_key)
+      end
     end
   end
 end

data/app/services/spree_cm_commissioner/waiting_room/publish_lobby_path.rb

@@ -0,0 +1,48 @@
+require 'google/cloud/firestore'
+
+module SpreeCmCommissioner
+  module WaitingRoom
+    # Publishes the server-owned waiting-guests records path to the lobby document, so mobile
+    # and the waiting-room caller share one source of truth for the date partition instead of
+    # each building it from their own (possibly skewed) clock/timezone.
+    #
+    # CRON note: ecause we use Time.zone.now to determine the path, it's important that the CRON job runs at the same
+    # timezone as well — otherwise the cron could fire before/after Time.zone.now rolls to the new date.
+    # Example: cron: "0 0 * * * Asia/Phnom_Penh"
+    #
+    # Caching note: No caching needed since the service is expected to be called once per day
+    # so a single daily merge write is negligible.
+    class PublishLobbyPath
+      prepend ::Spree::ServiceModule::Base
+      extend SpreeCmCommissioner::ServiceModuleThrowable
+
+      def call
+        # merge: true so we never clobber the lobby's `full` / `available_slots` fields.
+        lobby_document.set({ waiting_guests_records_path: records_path }, merge: true)
+
+        success(records_path: records_path)
+      rescue StandardError => e
+        failure(nil, e.message)
+      end
+
+      private
+
+      # Server date is authoritative.
+      def records_path
+        @records_path ||= "waiting_guests/#{Time.zone.now.strftime('%Y-%m-%d')}/records"
+      end
+
+      def lobby_document
+        @lobby_document ||= firestore.col('waiting_rooms').doc('lobby')
+      end
+
+      def firestore
+        @firestore ||= Google::Cloud::Firestore.new(project_id: service_account[:project_id], credentials: service_account)
+      end
+
+      def service_account
+        @service_account ||= Rails.application.credentials.cloud_firestore_service_account
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/waiting_room_lobby_metadata_fetcher.rb

@@ -0,0 +1,47 @@
+require 'google/cloud/firestore'
+
+module SpreeCmCommissioner
+  # Reads the lobby document (waiting_rooms/lobby) — the read-side counterpart to
+  # WaitingRoom::PublishLobbyPath. Kept separate from WaitingRoomSystemMetadataFetcher,
+  # which owns the unrelated metadata/system document.
+  class WaitingRoomLobbyMetadataFetcher
+    attr_reader :document_data
+
+    def initialize(firestore: nil)
+      @firestore = firestore if firestore.present?
+    end
+
+    def load_document_data
+      @document_data = document.get.data || {}
+    end
+
+    # firebase metadata
+
+    # server-owned date partition — see WaitingRoom::PublishLobbyPath.
+    def waiting_guests_records_path
+      document_data[:waiting_guests_records_path]
+    end
+
+    # written by WaitingGuestsCaller#mark_as.
+    def full
+      document_data[:full]
+    end
+
+    # written by WaitingGuestsCaller#mark_as.
+    def available_slots
+      document_data[:available_slots]
+    end
+
+    def document
+      @document ||= firestore.col('waiting_rooms').doc('lobby')
+    end
+
+    def firestore
+      @firestore ||= Google::Cloud::Firestore.new(project_id: service_account[:project_id], credentials: service_account)
+    end
+
+    def service_account
+      @service_account ||= Rails.application.credentials.cloud_firestore_service_account
+    end
+  end
+end

data/app/views/spree/admin/system/waiting_room/show.html.erb

@@ -4,6 +4,7 @@
   <%= button_link_to Spree.t(:force_pull), force_pull_admin_system_waiting_room_path, method: :post, class: "btn btn-outline-primary" %>
 <% end %>
 
+<h6 class="mb-2 text-muted">System</h6>
 <div class="bg-white border rounded table-responsive">
   <table class="table" data-hook>
     <thead class="text-muted">
@@ -71,3 +72,55 @@
     </tbody>
   </table>
 </div>
+
+<h6 class="mt-4 mb-2 text-muted">Lobby</h6>
+<div class="bg-white border rounded table-responsive">
+  <table class="table" data-hook>
+    <thead class="text-muted">
+      <tr data-hook="admin_system_lobby_headers">
+        <th><%= Spree.t(:field_name) %></th>
+        <th><%= Spree.t(:current_value) %></th>
+        <th></th>
+      </tr>
+    </thead>
+    <tbody>
+      <% lobby_items = [
+        {
+          field_name: :waiting_guests_records_path,
+          value: @lobby_fetcher.waiting_guests_records_path.presence || "Not published yet",
+          reset_path: publish_lobby_path_admin_system_waiting_room_path
+        },
+        {
+          field_name: :full,
+          value: @lobby_fetcher.full ? "Yes" : "No",
+        },
+        {
+          field_name: :available_slots,
+          value: @lobby_fetcher.available_slots,
+        },
+      ] %>
+
+      <% lobby_items.each do |item| %>
+        <tr data-hook="admin_system_lobby_rows">
+          <td>
+            <%= item[:field_name].to_s.humanize %>
+            <span class="badge text-lowercase"><%= item[:field_name] %></span>
+          </td>
+          <td>
+            <%= item[:value] %>
+          </td>
+          <td>
+            <% if item[:reset_path].present? %>
+              <%= link_to_with_icon('arrow-counterclockwise.svg', "Publish path now", item[:reset_path],
+                    method: :post,
+                    remote: false,
+                    class: 'icon_link btn btn-sm outline text-dark m-0 p-0',
+                    data: { confirm: "Publish today's records path to the lobby now?" }, no_text: true
+                  ) %>
+            <% end %>
+          </td>
+        </tr>
+      <% end %>
+    </tbody>
+  </table>
+</div>

data/config/routes.rb

@@ -14,6 +14,7 @@ Spree::Core::Engine.add_routes do
       resource :waiting_room, controller: :waiting_room, only: [:show] do
         collection do
           post :force_pull
+          post :publish_lobby_path
           post :modify_multiplier
           post :modify_max_thread_count
         end
@@ -604,10 +605,11 @@ Spree::Core::Engine.add_routes do
           end
           resources :contestants, controller: :show_contestants, only: %i[show]
           resources :elimination_sessions, controller: :show_elimination_sessions, only: %i[index]
-          resources :free_vote_claims, only: :create
+          resources :vote_packages, only: :index
         end
 
         resources :voting_sessions, only: [] do
+          resource :free_vote_claim, controller: :free_vote_claim, only: %i[show create]
           resources :voting_contestants, only: :index
           resources :voting_credits, only: :index
           resources :votes, only: %i[create index]

data/lib/spree_cm_commissioner/version.rb

@@ -1,5 +1,5 @@
 module SpreeCmCommissioner
-  VERSION = '2.8.3.pre.pre12'.freeze
+  VERSION = '2.8.3.pre.pre14'.freeze
 
   module_function
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spree_cm_commissioner
 version: !ruby/object:Gem::Version
-  version: 2.8.3.pre.pre12
+  version: 2.8.3.pre.pre14
 platform: ruby
 authors:
 - You
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-17 00:00:00.000000000 Z
+date: 2026-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: spree
@@ -1052,7 +1052,7 @@ files:
 - app/controllers/spree/api/v2/tenant/customer_notifications_controller.rb
 - app/controllers/spree/api/v2/tenant/dynamic_field_options_controller.rb
 - app/controllers/spree/api/v2/tenant/episodes_controller.rb
-- app/controllers/spree/api/v2/tenant/free_vote_claims_controller.rb
+- app/controllers/spree/api/v2/tenant/free_vote_claim_controller.rb
 - app/controllers/spree/api/v2/tenant/guests_controller.rb
 - app/controllers/spree/api/v2/tenant/homepage_sections_controller.rb
 - app/controllers/spree/api/v2/tenant/id_cards_controller.rb
@@ -1091,6 +1091,7 @@ files:
 - app/controllers/spree/api/v2/tenant/user_device_tokens_controller.rb
 - app/controllers/spree/api/v2/tenant/user_registration_with_pin_codes_controller.rb
 - app/controllers/spree/api/v2/tenant/vendors_controller.rb
+- app/controllers/spree/api/v2/tenant/vote_packages_controller.rb
 - app/controllers/spree/api/v2/tenant/votes_controller.rb
 - app/controllers/spree/api/v2/tenant/voting_contestants_controller.rb
 - app/controllers/spree/api/v2/tenant/voting_credit_transactions_controller.rb
@@ -1416,6 +1417,7 @@ files:
 - app/jobs/spree_cm_commissioner/voting_credit_allocation_job.rb
 - app/jobs/spree_cm_commissioner/voting_credit_de_allocation_job.rb
 - app/jobs/spree_cm_commissioner/waiting_guests_caller_job.rb
+- app/jobs/spree_cm_commissioner/waiting_room/publish_lobby_path_job.rb
 - app/jobs/spree_cm_commissioner/waiting_room_latest_system_metadata_puller_job.rb
 - app/jobs/spree_cm_commissioner/waiting_room_session_firebase_logger_job.rb
 - app/jobs/spree_cm_commissioner/webhook_subscriber_orders_sender_job.rb
@@ -1987,6 +1989,7 @@ files:
 - app/serializers/spree/v2/tenant/digital_link_serializer.rb
 - app/serializers/spree/v2/tenant/dynamic_field_option_serializer.rb
 - app/serializers/spree/v2/tenant/dynamic_field_serializer.rb
+- app/serializers/spree/v2/tenant/free_vote_claim_serializer.rb
 - app/serializers/spree/v2/tenant/guest_card_class_serializer.rb
 - app/serializers/spree/v2/tenant/guest_dynamic_field_serializer.rb
 - app/serializers/spree/v2/tenant/guest_serializer.rb
@@ -2341,6 +2344,8 @@ files:
 - app/services/spree_cm_commissioner/voting_leaderboards/calculate_score.rb
 - app/services/spree_cm_commissioner/voting_leaderboards/combined_result.rb
 - app/services/spree_cm_commissioner/voting_sessions/finalize.rb
+- app/services/spree_cm_commissioner/waiting_room/publish_lobby_path.rb
+- app/services/spree_cm_commissioner/waiting_room_lobby_metadata_fetcher.rb
 - app/services/spree_cm_commissioner/waiting_room_system_metadata_fetcher.rb
 - app/services/spree_cm_commissioner/waiting_room_system_metadata_setter.rb
 - app/services/spree_cm_commissioner/webhooks/subscribers/handle_request_decorator.rb

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

@@ -1,37 +0,0 @@
-module Spree
-  module Api
-    module V2
-      module Tenant
-        class FreeVoteClaimsController < BaseController
-          before_action :require_spree_current_user
-
-          def create
-            show = current_vendor.shows.find(params[:show_id])
-
-            result = SpreeCmCommissioner::VotingCredits::ClaimFreeVotes.new(
-              show: show,
-              user: spree_current_user,
-              tenant_id: MultiTenant.current_tenant_id,
-              votable_type: params[:votable_type],
-              votable_id: params[:votable_id]
-            ).call
-
-            if result.failure?
-              render_error_payload(result.error.to_s)
-            elsif result.value.nil?
-              head :no_content
-            else
-              render_serialized_payload { serialize_resource(result.value) }
-            end
-          end
-
-          private
-
-          def resource_serializer
-            Spree::V2::Tenant::VotingCreditSerializer
-          end
-        end
-      end
-    end
-  end
-end