Include tracking of current players in the queue descriptor.

This should allow us to hit the max player limit and automatically remove the queue descriptor and start bringing in team arrays.

For now, let's just assume teams are randomized always with no captains.

Author: PhlexPlexico

src/routes/queue.ts

@@ -329,10 +329,20 @@ router.put('/:slug', Utils.ensureAuthenticated, async (req, res) => {
   const action: string = req.body[0].action ? req.body[0].action : 'join';
 
   try {
+    let currentQueueCount: number = await QueueService.getCurrentQueuePlayerCount(slug);
+    let maxQueueCount: number = await QueueService.getCurrentQueueMaxCount(slug);
     if (action === 'join') {
       await QueueService.addUserToQueue(slug, req.user?.steam_id!);
+      if (currentQueueCount == maxQueueCount) {
+        // TODO: Add in logic to create teams, or create a new queue with users' steam IDs and queue ID
+        // to get ready to shuffle teams.
+      }
     } else if (action === 'leave') {
       await QueueService.removeUserFromQueue(slug, req.user?.steam_id!, req.user?.steam_id!);
+      if (currentQueueCount == 0) {
+        // If no users are left in the queue, delete it.
+        await QueueService.deleteQueue(slug, req.user?.steam_id!, 'admin');
+      }
     } else {
       return res.status(400).json({ error: 'Invalid action. Must be "join" or "leave".' });
     }

src/services/queue.ts

@@ -9,7 +9,7 @@ const DEFAULT_TTL_SECONDS: number = config.get("server.queueTTL") == 0 ? 3600 :
 
 export class QueueService {
 
-  static async createQueue(ownerId?: string, maxPlayers: number = 10, isPrivate: boolean = false, ttlSeconds: number = DEFAULT_TTL_SECONDS): Promise<QueueDescriptor> {
+  static async createQueue(ownerId: string, maxPlayers: number = 10, isPrivate: boolean = false, ttlSeconds: number = DEFAULT_TTL_SECONDS): Promise<QueueDescriptor> {
     let slug: string;
     let key: string;
     let attempts: number = 0;
@@ -37,13 +37,16 @@ export class QueueService {
       expiresAt,
       ownerId,
       maxSize: maxPlayers,
-      isPrivate: isPrivate
+      isPrivate: isPrivate,
+      currentPlayers: 1
     };
 
     await redis.sAdd('queues', slug);
     await redis.expire(key, ttlSeconds);
     await redis.set(`queue-meta:${slug}`, JSON.stringify(descriptor), { EX: ttlSeconds });
 
+    await this.addUserToQueue(slug, ownerId);
+
     return descriptor;
   }
 
@@ -100,6 +103,7 @@ export class QueueService {
     };
 
     await redis.rPush(key, JSON.stringify(item));
+    meta.currentPlayers += 1;
   }
 
   static async removeUserFromQueue(
@@ -125,6 +129,7 @@ export class QueueService {
       const parsed = JSON.parse(item);
       if (parsed.steamId === steamId) {
         await redis.lRem(key, 1, item);
+        meta.currentPlayers -= 1;
         return true;
       }
     }
@@ -169,6 +174,16 @@ export class QueueService {
     throw new Error('You do not have permission to remove other users from this queue.');
   }
 
+  static async getCurrentQueuePlayerCount(slug: string): Promise<number> {
+    const meta = await getQueueMetaOrThrow(slug);
+    return meta.currentPlayers;
+  }
+
+  static async getCurrentQueueMaxCount(slug: string): Promise<number> {
+    const meta = await getQueueMetaOrThrow(slug);
+    return meta.maxSize;
+  }
+
 }
 
 async function getQueueMetaOrThrow(slug: string): Promise<QueueDescriptor> {

src/types/queues/QueueDescriptor.ts

@@ -3,6 +3,7 @@ export interface QueueDescriptor {
   createdAt: number;      // Timestamp (ms) when queue was created
   expiresAt: number;      // Timestamp (ms) when queue will expire
   ownerId?: string;       // Optional user ID of the queue creator
-  maxSize?: number;       // Optional max number of users allowed
+  maxSize: number;        // Max number of players allowed in the queue
   isPrivate?: boolean;    // Optional flag for visibility
+  currentPlayers: number; // Current number of players in the queue
 }