Merge pull request #89 from CS3219-AY2425S1/room-fetching-rest

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/.env.example

@@ -18,6 +18,8 @@ RELAXATION_INTERVAL=3000
 MATCH_TIMEOUT=30000
 CLEANUP_INTERVAL=75000
 
+JWT_ACCESS_TOKEN_SECRET=<your-jwt-accecss-token>
+
 # Copy root .env
 # If using mongoDB containerization, set to true. Else set to false (i.e local testing)
 DB_REQUIRE_AUTH=true

backend/matching-service/app.ts

@@ -27,14 +27,12 @@ initSocket(server);
 
 app.use(express.json());
 
-app.use("/api/match", matchingRoutes);
+app.use(cors({
+    origin: true,
+    credentials: true,
+}));
 
-app.use(
-    cors({
-        origin: "*",
-        credentials: true,
-    })
-);
+app.use("/api/match", matchingRoutes);
 
 app.use(errorHandler);
 

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,24 @@
+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) => {
+    console.log(err);
+    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,12 @@
+import { getRoomDetails } from '../controllers/roomController';
 import { cancelMatch, startMatching } from '../controllers/matchingController';
 import express from 'express';
+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;
+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();