Implement accept and decline match

Author: evanyan13

backend/gateway-service/package-lock.json

@@ -34,7 +34,8 @@
     "ioredis": "^5.4.1",
     "passport-jwt": "^4.0.1",
     "reflect-metadata": "^0.1.13",
-    "rxjs": "^7.8.1"
+    "rxjs": "^7.8.1",
+    "uuid": "^10.0.0"
   },
   "devDependencies": {
     "@nestjs/cli": "^10.0.0",
@@ -44,6 +45,7 @@
     "@types/jest": "^29.5.2",
     "@types/node": "^20.3.1",
     "@types/supertest": "^2.0.12",
+    "@types/uuid": "^10.0.0",
     "@typescript-eslint/eslint-plugin": "^6.0.0",
     "@typescript-eslint/parser": "^6.0.0",
     "eslint": "^8.42.0",

backend/gateway-service/package.json

@@ -1,2 +1,4 @@
 export { UserMatchOptionsDto } from './user-match-options.dto';
 export { MatchRequestDto } from './match-request.dto';
+export { MatchAcceptDto } from './match-accept.dto';
+export { MatchDeclineDto } from './match-decline.dto';

backend/gateway-service/src/modules/match/dto/index.ts

@@ -0,0 +1,11 @@
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class MatchAcceptDto {
+  @IsString()
+  @IsNotEmpty()
+  userId: string;
+
+  @IsString()
+  @IsNotEmpty()
+  matchId: string;
+}

backend/gateway-service/src/modules/match/dto/match-accept.dto.ts

@@ -0,0 +1,11 @@
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class MatchDeclineDto {
+  @IsString()
+  @IsNotEmpty()
+  userId: string;
+
+  @IsString()
+  @IsNotEmpty()
+  matchId: string;
+}

backend/gateway-service/src/modules/match/dto/match-decline.dto.ts

@@ -11,17 +11,25 @@ import { ClientProxy } from '@nestjs/microservices';
 import { Inject } from '@nestjs/common';
 import { firstValueFrom } from 'rxjs';
 import { RedisService } from './redis.service';
-import { MatchRequestDto } from './dto';
+import { v4 as uuidv4 } from 'uuid';
+import { MatchAcceptDto, MatchDeclineDto, MatchRequestDto } from './dto';
 import {
   MATCH_FOUND,
   MATCH_CANCELLED,
   MATCH_CONFIRMED,
   MATCH_TIMEOUT,
   MATCH_REQUESTED,
+  MATCH_ACCEPTED,
   MATCH_ERROR,
   EXCEPTION,
+  MATCH_DECLINED,
 } from './match.event';
-import { CANCEL_MATCH, FIND_MATCH } from './match.message';
+import {
+  ACCEPT_MATCH,
+  CANCEL_MATCH,
+  DECLINE_MATCH,
+  FIND_MATCH,
+} from './match.message';
 
 @WebSocketGateway({
   namespace: '/match',
@@ -35,6 +43,8 @@ import { CANCEL_MATCH, FIND_MATCH } from './match.message';
 export class MatchGateway implements OnGatewayInit {
   @WebSocketServer() server: Server;
   private userSockets: Map<string, string> = new Map();
+  private matchConfirmations: Map<string, Set<string>> = new Map();
+  private matchParticipants: Map<string, Set<string>> = new Map();
 
   constructor(
     @Inject('MATCHING_SERVICE') private matchingClient: ClientProxy,
@@ -63,7 +73,7 @@ export class MatchGateway implements OnGatewayInit {
       !payload.selectedTopic ||
       !payload.selectedDifficulty
     ) {
-      client.emit(EXCEPTION, 'Invalid match request payload.');
+      client.emit(MATCH_ERROR, 'Invalid match request payload.');
       return;
     }
 
@@ -81,7 +91,7 @@ export class MatchGateway implements OnGatewayInit {
           message: result.message,
         });
       } else {
-        client.emit(EXCEPTION, result.message);
+        client.emit(MATCH_ERROR, result.message);
       }
     } catch (error) {
       client.emit(EXCEPTION, `Error requesting match: ${error.message}`);
@@ -95,10 +105,7 @@ export class MatchGateway implements OnGatewayInit {
     @MessageBody() payload: { userId: string },
   ) {
     if (!payload.userId) {
-      client.emit(
-        EXCEPTION,
-        'Invalid userId. Please check your payload and try again.',
-      );
+      client.emit(MATCH_ERROR, 'Invalid userId in payload.');
       return;
     }
 
@@ -116,7 +123,7 @@ export class MatchGateway implements OnGatewayInit {
           message: result.message,
         });
       } else {
-        client.emit(EXCEPTION, result.message);
+        client.emit(MATCH_ERROR, result.message);
       }
     } catch (error) {
       console.log(error);
@@ -125,23 +132,141 @@ export class MatchGateway implements OnGatewayInit {
     }
   }
 
-  // Notify both matched users via WebSocket
+  @SubscribeMessage(ACCEPT_MATCH)
+  async handleAcceptMatch(
+    @ConnectedSocket() client: Socket,
+    @MessageBody() payload: MatchAcceptDto,
+  ) {
+    const { userId, matchId } = payload;
+
+    if (!userId || !matchId) {
+      client.emit(MATCH_ERROR, 'Invalid payload.');
+      return;
+    }
+
+    if (!this.validateUserId(client, userId)) {
+      return;
+    }
+
+    // Validate if the matchId exists and check if the user is a valid participant
+    const participants = this.matchParticipants.get(matchId);
+    if (!participants || !participants.has(userId)) {
+      client.emit(MATCH_ERROR, 'You are not a participant of this match.');
+      return;
+    }
+
+    // Check if the user has already accepted the match
+    const confirmations = this.matchConfirmations.get(matchId) || new Set();
+    if (confirmations.has(userId)) {
+      client.emit(MATCH_ERROR, 'You have already accepted this match.');
+      return;
+    }
+
+    // Add user's confirmation for the match
+    confirmations.add(userId);
+    this.matchConfirmations.set(matchId, confirmations);
+
+    // Check if both participants have confirmed the match
+    if (confirmations.size === 2) {
+      this.notifyUsersMatchConfirmed(matchId, [...confirmations]);
+    } else {
+      client.emit(MATCH_ACCEPTED, {
+        message: 'Waiting for the other user to accept the match.',
+      });
+    }
+  }
+
+  @SubscribeMessage(DECLINE_MATCH)
+  async handleDeclineMatch(
+    @ConnectedSocket() client: Socket,
+    @MessageBody() payload: MatchDeclineDto,
+  ) {
+    const { userId, matchId } = payload;
+
+    if (!userId || !matchId) {
+      client.emit(MATCH_ERROR, 'Invalid payload.');
+      return;
+    }
+
+    if (!this.validateUserId(client, userId)) {
+      return;
+    }
+
+    // Validate if the matchId exists and check if the user is a valid participant
+    const participants = this.matchParticipants.get(matchId);
+    if (!participants || !participants.has(userId)) {
+      client.emit(MATCH_ERROR, 'You are not a participant of this match.');
+      return;
+    }
+
+    // Notify the other user that the match has been declined
+    this.notifyOtherUserMatchDeclined(matchId, userId);
+
+    // Remove match-related data
+    this.matchParticipants.delete(matchId);
+    this.matchConfirmations.delete(matchId);
+    client.emit(MATCH_DECLINED, { message: 'You have declined the match.' });
+  }
+
+  // Notify both users when they are matched
   notifyUsersWithMatch(matchedUsers: string[]) {
     const [user1, user2] = matchedUsers;
     const user1SocketId = this.getUserSocketId(user1);
     const user2SocketId = this.getUserSocketId(user2);
+
     if (user1SocketId && user2SocketId) {
+      const matchId = this.generateMatchId();
       this.server.to(user1SocketId).emit(MATCH_FOUND, {
-        message: `You have been matched with user ${user2}`,
-        matchedUserId: user2,
+        message: `You have found a match`,
+        matchUserId: user2,
+        matchId,
       });
       this.server.to(user2SocketId).emit(MATCH_FOUND, {
-        message: `You have been matched with user ${user1}`,
-        matchedUserId: user1,
+        message: `You have found a match`,
+        matchUserId: user1,
+        matchId,
       });
+
+      // Store participants for this matchId
+      this.matchParticipants.set(matchId, new Set([user1, user2]));
     }
   }
 
+  // Notify both users when they both accept the match
+  notifyUsersMatchConfirmed(matchId: string, users: string[]) {
+    const sessionId = this.generateSessionId();
+    users.forEach((user) => {
+      const socketId = this.getUserSocketId(user);
+      if (socketId) {
+        this.server.to(socketId).emit(MATCH_CONFIRMED, {
+          message: `Match confirmed! New session created.`,
+          sessionId,
+        });
+      }
+    });
+
+    // Clean up match participants and confirmations
+    this.matchConfirmations.delete(matchId);
+    this.matchParticipants.delete(matchId);
+  }
+
+  private notifyOtherUserMatchDeclined(
+    matchId: string,
+    decliningUserId: string,
+  ) {
+    const participants = this.matchParticipants.get(matchId);
+    participants?.forEach((participantId) => {
+      if (participantId !== decliningUserId) {
+        const socketId = this.getUserSocketId(participantId);
+        if (socketId) {
+          this.server.to(socketId).emit(MATCH_DECLINED, {
+            message: 'The other user has declined the match.',
+          });
+        }
+      }
+    });
+  }
+
   notifyUsersWithTimeout(timedOutUsers: string[]) {
     timedOutUsers.forEach((user) => {
       const socketId = this.getUserSocketId(user);
@@ -213,19 +338,17 @@ export class MatchGateway implements OnGatewayInit {
       );
 
       if (result.success) {
-        console.log(`Match canceled successfully for user ${userId}`);
+        console.log(`Match auto cancelled user ${userId} at disconnect`);
       } else {
-        console.warn(
-          `Match cancellation failed for user ${userId}: ${result.message}`,
-        );
+        console.log(`No match cancelled: ${result.message}`);
       }
 
       this.userSockets.delete(userId);
       console.log(`User ${userId} disconnected and removed from userSockets.`);
     } catch (error) {
       client.emit(
         EXCEPTION,
-        `Error canceling match for user ${userId}: ${error.message}`,
+        `Error disconnecting user ${userId}: ${error.message}`,
       );
     }
   }
@@ -234,8 +357,17 @@ export class MatchGateway implements OnGatewayInit {
     return this.userSockets.get(userId);
   }
 
+  private generateMatchId(): string {
+    return uuidv4();
+  }
+
+  // TODO - to be replaced with colab method in the future
+  private generateSessionId(): string {
+    return uuidv4();
+  }
+
   private emitExceptionAndDisconnect(client: Socket, message: string) {
-    client.emit(EXCEPTION, `Error connecting to /match socket: ${message}`);
+    client.emit(EXCEPTION, `Error: ${message}`);
     client.disconnect();
   }
 

backend/gateway-service/src/modules/match/match.controller.ts

@@ -1,7 +1,9 @@
-export const MATCH_FOUND = 'matchFound'; // Emitted when a match is found
-export const MATCH_REQUESTED = 'matchRequested'; // Emitted when a user requests a match
-export const MATCH_CANCELLED = 'matchCancelled'; // Emitted when a match is cancelled
-export const MATCH_CONFIRMED = 'matchConfirmed'; // Emitted when a match is confirmed
+export const MATCH_FOUND = 'matchFound';
+export const MATCH_REQUESTED = 'matchRequested';
+export const MATCH_CANCELLED = 'matchCancelled';
+export const MATCH_ACCEPTED = 'matchAccepted';
+export const MATCH_DECLINED = 'matchDeclined';
+export const MATCH_CONFIRMED = 'matchConfirmed';
 export const MATCH_TIMEOUT = 'matchTimeout'; // Emitted after 5 minutes of inactivity
-export const MATCH_ERROR = 'matchError'; // Emitted when an error occurs
-export const EXCEPTION = 'exception'; // Emitted when an exception occurs
+export const MATCH_ERROR = 'matchError';
+export const EXCEPTION = 'exception';

backend/gateway-service/src/modules/match/match.event.ts

@@ -1,2 +1,4 @@
 export const FIND_MATCH = 'findMatch';
 export const CANCEL_MATCH = 'cancelMatch';
+export const ACCEPT_MATCH = 'acceptMatch';
+export const DECLINE_MATCH = 'declineMatch';