Add Room Fetching Based on Rest

Author: Nephelite

backend/api-gateway/nginx.conf

@@ -63,7 +63,7 @@ http {
             proxy_send_timeout 60s;
         }
 
-        # Proxy for /api/categories to service running on port 3002
+        # Proxy for /api/history to service running on port 3002
         location /api/history/ {
             proxy_pass http://host.docker.internal:3002/api/history/;
             proxy_set_header Host $host;

backend/matching-service/app.ts

@@ -25,17 +25,15 @@ const server = http.createServer(app);
 
 initSocket(server);
 
+app.use(cors({
+    origin: true,
+    credentials: true,
+}));
+
 app.use(express.json());
 
 app.use("/api/match", matchingRoutes);
 
-app.use(
-    cors({
-        origin: "*",
-        credentials: true,
-    })
-);
-
 app.use(errorHandler);
 
 server.listen(port, async () => {

backend/matching-service/controllers/roomController.ts

@@ -0,0 +1,26 @@
+import roomModel from "../models/RoomSchema";
+import { Request, Response, NextFunction } from "express";
+
+export async function getRoomDetails(
+    request: Request,
+    response: Response,
+    next: NextFunction
+) {
+    const { roomId } = request.params
+    try {
+        console.log(roomId)
+        const room = await roomModel.findOne({ roomId });
+        if (!room) {
+            throw new Error("Room not found");
+        }
+        response.status(200).json({
+            roomId, 
+            attemptStartedAt: room.createdAt.getTime(),
+            userIdOne: room.participants[0],
+            userIdTwo: room.participants[1],
+            questionId: room.questionId,
+        });
+    } catch (error) {
+        next(error);
+    }
+}

backend/matching-service/middlewares/auth.ts

@@ -0,0 +1,23 @@
+import { Request, Response, NextFunction } from 'express';
+import jwt from 'jsonwebtoken';
+
+export interface AuthenticatedRequest extends Request {
+  userId?: string;
+}
+
+export const authenticateToken = (req: AuthenticatedRequest, res: Response, next: NextFunction) => {
+  const authHeader = req.headers['authorization'];
+
+  if (!authHeader) return res.status(401).json({ error: 'Authorization header missing' });
+
+  const token = authHeader.split(' ')[1];
+
+  if (!token) return res.status(401).json({ error: 'Token missing' });
+
+  jwt.verify(token, process.env.JWT_ACCESS_TOKEN_SECRET as string, (err, decoded: any) => {
+    if (err) return res.status(403).json({ error: 'Invalid token' });
+
+    req.userId = decoded.id;
+    next();
+  });
+};

backend/matching-service/middlewares/basic-access-control.ts

@@ -0,0 +1,31 @@
+import jwt from "jsonwebtoken";
+export function verifyIsAdmin(req: any, res: any, next: any) {
+  if (req.isAdmin) {
+    next();
+  } else {
+    return res.status(403).json({ message: "Not authorized to access this resource" });
+  }
+}
+export function verifyAccessToken(req: any, res: any, next: any) {
+  const authHeader = req.headers.authorization || req.header.Authorization;
+  if (!authHeader) {
+    return res.status(401).json({ message: "Authentication failed" });
+  }
+
+  if (!authHeader?.startsWith("Bearer ")) {
+    return res.status(401).json({ message: "Unauthorized: no token" });
+  }
+  const token = authHeader.split(" ")[1];
+
+  const secret = process.env.JWT_ACCESS_TOKEN_SECRET;
+  if (!secret) {
+    return res.status(500).json({ message: "Internal server error" });
+  }
+  jwt.verify(token, secret, async (err: any, user: any) => {
+    if (err) {
+      return res.status(401).json({ message: `Unauthorized: ${err.message}` });
+    }
+    req.isAdmin = user.isAdmin;
+    next();
+  });
+}

backend/matching-service/models/RoomSchema.ts

@@ -1,6 +1,17 @@
-import mongoose from "mongoose";
+import mongoose, { Schema, Types } from "mongoose";
 
-const roomSchema = new mongoose.Schema({
+export interface Room extends mongoose.Document {
+    _id: Types.ObjectId;
+    participants: string[];
+    category: string;
+    difficulty: string;
+    roomId: string;
+    questionId: string;
+    createdAt: Date;
+}
+
+
+const roomSchema: Schema<Room> = new mongoose.Schema<Room>({
     participants: [{ userId: String }],
     category: { type: String, default: 'Any' },
     difficulty: { type: String, default: 'Any' },
@@ -9,6 +20,6 @@ const roomSchema = new mongoose.Schema({
     createdAt: { type: Date, default: Date.now }
 });
 
-const Room = mongoose.model('Room', roomSchema);
+const roomModel = mongoose.model<Room>('Room', roomSchema);
 
-export default Room;
+export default roomModel;

backend/matching-service/routes/matchingRoutes.ts

@@ -1,9 +1,13 @@
+import { getRoomDetails } from '../controllers/roomController';
 import { cancelMatch, startMatching } from '../controllers/matchingController';
 import express from 'express';
+import { verifyAccessToken } from '../middlewares/basic-access-control';
+import { authenticateToken } from 'middlewares/auth';
 
 const router = express.Router();
 
-router.post('/', startMatching);
-router.delete('/:socketId', cancelMatch)
+router.post('/', authenticateToken, startMatching);
+router.delete('/:socketId', authenticateToken, cancelMatch)
+router.get('/room/:roomId', authenticateToken, getRoomDetails)
 
 export default router;

frontend/src/data/repositories/HistoryRemoteDataSource.ts

@@ -18,7 +18,6 @@ export class HistoryRemoteDataSource extends BaseApi {
     }
 
     async deleteSelectedHistories(selectedHistoryIds: string[]): Promise<void> {
-        console.log("Delete")
         selectedHistoryIds.forEach(async (id) => {
             console.log(id);
             await this.protectedDelete<void>(`/user/${id}`);

frontend/src/data/repositories/RoomRemoteDataSource.ts

@@ -0,0 +1,16 @@
+import { BaseApi } from "../../infrastructure/Api/BaseApi";
+import { Room } from "../../domain/entities/Room";
+
+const API_URL = "/api/match";
+
+export class RoomRemoteDataSource extends BaseApi {
+    constructor() {
+        super(API_URL);
+    }
+
+    async getRoomDetails(roomId: string): Promise<Room> {
+        return await this.protectedGet<Room>(`/room/${roomId}`);
+    }
+}
+
+export const roomRemoteDataSource = new RoomRemoteDataSource();

frontend/src/data/repositories/RoomRepositoryImpl.ts

@@ -0,0 +1,13 @@
+import { roomRemoteDataSource } from './RoomRemoteDataSource';
+import { Room } from '../../domain/entities/Room';
+import { IRoomRepository } from 'domain/repositories/IRoomRepository';
+
+export class RoomRepositoryImpl implements IRoomRepository {
+    private dataSource = roomRemoteDataSource;
+
+    async getRoomDetails(roomId: string): Promise<Room> {
+        return this.dataSource.getRoomDetails(roomId);
+    }
+}
+
+export const roomRepository = new RoomRepositoryImpl();