Merge pull request #73 from CS3219-AY2425S1/n2-user-question-history

N2 user question history

Author: Nephelite

backend/api-gateway/nginx.conf

@@ -63,6 +63,19 @@ http {
             proxy_send_timeout 60s;
         }
 
+        # Proxy for /api/categories to service running on port 3002
+        location /api/history/ {
+            proxy_pass http://host.docker.internal:3002/api/history/;
+            proxy_set_header Host $host;
+            proxy_set_header X-Real-IP $remote_addr;
+            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+            proxy_set_header X-Forwarded-Proto $scheme;
+
+            proxy_connect_timeout 60s;
+            proxy_read_timeout 60s;
+            proxy_send_timeout 60s;
+        }
+
         # Proxy for /api/match to service running on port 3003
         location /api/match/ {
             proxy_pass http://host.docker.internal:3003/api/match/;

backend/matching-service/controllers/matchingController.ts

@@ -306,6 +306,7 @@ async function handleMatchEvent(
                 message: `You have been matched with User ID: ${user2.userId}`,
                 category: user1.category || user2.category || "Any",
                 difficulty: user1.difficulty || user2.difficulty || "Any",
+                attemptStartedAt: Date.now(),
                 matchId: matchId,
                 roomId: roomId,
                 matchUserId: user2.userId,
@@ -316,6 +317,7 @@ async function handleMatchEvent(
                 message: `You have been matched with User ID: ${user1.userId}`,
                 category: user2.category || user1.category || "Any",
                 difficulty: user2.difficulty || user1.difficulty || "Any",
+                attemptStartedAt: Date.now(),
                 matchId: matchId,
                 roomId: roomId,
                 matchUserId: user1.userId,

backend/question-service/.env.example

@@ -7,6 +7,8 @@ PORT=3002
 # Initialize data from questions.json
 POPULATE_DB=true
 
+JWT_ACCESS_TOKEN_SECRET=<your-jwt-accecss-token>
+
 # Kafka configuration
 KAFKA_HOST=localhost
 KAFKA_PORT=9092
@@ -15,8 +17,6 @@ KAFKA_PORT=9092
 # If using mongoDB containerization, set to true. Else set to false (i.e local testing)
 DB_REQUIRE_AUTH=true
 
-JWT_ACCESS_TOKEN_SECRET=<your-jwt-accecss-token>
-
 # mongoDB auth variables
 MONGO_USER=user
 MONGO_PASSWORD=password

backend/question-service/app.ts

@@ -7,6 +7,7 @@ import categoriesRoutes from './routes/categoriesRoutes';
 import { connectToDatabase } from './utils/database';
 import { errorHandler } from './middlewares/errorHandler';
 import { populateQuestions } from './utils/populateQuestions';
+import historyRoutes from './routes/historyRoutes';
 import { setUpKafkaSubscribers } from './utils/kafkaClient';
 
 dotenv.config({ path: path.resolve(__dirname, './.env') });
@@ -25,6 +26,7 @@ app.use(cors({
 
 app.use('/api/questions', questionsRoutes);
 app.use('/api/categories', categoriesRoutes);
+app.use('/api/history', historyRoutes)
 
 app.use(errorHandler);
 

backend/question-service/controllers/historyController.ts

@@ -0,0 +1,156 @@
+import { Response } from 'express';
+import jwt, { JwtPayload } from 'jsonwebtoken';
+import historyEntryModel from '../models/HistoryEntry';
+import { AuthenticatedRequest } from 'middlewares/auth';
+
+const getErrorMessage = (error: unknown): string => {
+  if (error instanceof Error) return error.message;
+  return 'An unexpected error occurred';
+};
+
+const extractUserIdFromToken = (req: AuthenticatedRequest): string | null => {
+    const userId = req.userId;
+    if (!userId) {
+      console.error('userId missing - Token is likely invalid');
+      return null;
+    }
+    return userId
+  };
+
+export const getUserHistoryEntries = async (req: AuthenticatedRequest, res: Response) => {
+  try {
+    const userId = extractUserIdFromToken(req);
+
+    if (!userId) {
+      return res.status(401).json({ error: 'Invalid or missing token' });
+    }
+
+    const historyEntries = await historyEntryModel.find({ userId })
+    .populate({
+      path: 'question',
+      populate: {
+        path: 'categories',
+        model: 'category',
+      },
+    });
+    const historyViewModels = historyEntries.map((entry) => {
+      return {
+        id: entry._id,
+        key: entry._id,
+        attemptStartedAt: entry.attemptStartedAt.getTime(),
+        attemptCompletedAt: entry.attemptCompletedAt.getTime(),
+        title: entry.question.title,
+        difficulty: entry.question.difficulty,
+        topics: entry.question.categories.map((cat: any) => cat.name),
+        attemptCode: entry.attemptCode,
+    }});
+    res.status(200).json(historyViewModels);
+  } catch (error) {
+    res.status(500).json({ error: getErrorMessage(error) });
+  }
+};
+
+export const createOrUpdateUserHistoryEntry = async (req: AuthenticatedRequest, res: Response) => {
+  try {
+    const userId = extractUserIdFromToken(req);
+
+    if (!userId) {
+      return res.status(401).json({ error: 'Invalid or missing token' });
+    }
+
+    const { questionId, roomId, attemptStartedAt, attemptCompletedAt, collaboratorId, attemptCode } = req.body;
+
+    if (!roomId) {
+      return res.status(400).json({ error: 'roomId is required' });
+    }
+
+    const existingEntry = await historyEntryModel.findOne({ userId, roomId });
+
+    if (existingEntry) {
+      existingEntry.question = questionId;
+      existingEntry.attemptStartedAt = attemptStartedAt;
+      existingEntry.attemptCompletedAt = attemptCompletedAt;
+      existingEntry.collaboratorId = collaboratorId;
+      existingEntry.attemptCode = attemptCode;
+
+      const updatedEntry = await existingEntry.save();
+
+      return res.status(200).json(updatedEntry);
+    } else {
+      const newHistoryEntry = new historyEntryModel({
+        userId,
+        question: questionId,
+        roomId,
+        attemptStartedAt,
+        attemptCompletedAt,
+        collaboratorId,
+        attemptCode,
+      });
+
+      const savedEntry = await newHistoryEntry.save();
+
+      return res.status(201).json(savedEntry);
+    }
+  } catch (error) {
+    return res.status(500).json({ error: getErrorMessage(error) });
+  }
+};
+
+export const deleteUserHistoryEntry = async (req: AuthenticatedRequest, res: Response) => {
+  try {
+    const userId = extractUserIdFromToken(req);
+
+    if (!userId) {
+      return res.status(401).json({ error: 'Invalid or missing token' });
+    }
+
+    const { id } = req.params;
+
+    const deletedEntry = await historyEntryModel.findOneAndDelete({ _id: id, userId });
+
+    if (!deletedEntry) {
+      return res.status(404).json({ message: 'History entry not found' });
+    }
+
+    res.status(200).json({ message: 'History entry deleted successfully' });
+  } catch (error) {
+    res.status(500).json({ error: getErrorMessage(error) });
+  }
+};
+
+export const deleteUserHistoryEntries = async (req: AuthenticatedRequest, res: Response) => {
+  try {
+    const userId = extractUserIdFromToken(req);
+
+    if (!userId) {
+      return res.status(401).json({ error: 'Invalid or missing token' });
+    }
+
+    const { ids } = req.body;
+    if (!Array.isArray(ids)) {
+      return res.status(400).json({ message: '"ids" must be an array of history entry IDs.' });
+    }
+
+    const result = await historyEntryModel.deleteMany({ _id: { $in: ids }, userId });
+    res.status(200).json({ message: `${result.deletedCount} history entries deleted.` });
+  } catch (error) {
+    res.status(500).json({ error: getErrorMessage(error) });
+  }
+};
+
+export const deleteAllUserHistoryEntries = async (req: AuthenticatedRequest, res: Response) => {
+  try {
+    const userId = extractUserIdFromToken(req);
+
+    if (!userId) {
+      return res.status(401).json({ error: 'Invalid or missing token' });
+    }
+
+    const result = await historyEntryModel.deleteMany({ userId });
+    res.status(200).json({
+      message: `${result.deletedCount} history entries deleted for user ${userId}.`,
+    });
+  } catch (error) {
+    res.status(500).json({ error: getErrorMessage(error) });
+  }
+};

backend/question-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/question-service/models/HistoryEntry.ts

@@ -0,0 +1,26 @@
+import mongoose, { Schema, Types } from 'mongoose';
+import { Question } from './Question';
+
+export interface HistoryEntry extends mongoose.Document {
+  _id: Types.ObjectId;
+  userId: string;
+  question: Question;
+  roomId: string; // Note: This should not be used to retrieve the room from matching service! This is only here to serve as a uniqueness check for updating attempt information!
+  attemptStartedAt: Date;
+  attemptCompletedAt: Date;
+  collaboratorId: string;
+  attemptCode: string;
+}
+
+const historyEntrySchema: Schema = new Schema<HistoryEntry>({
+  userId: { type: String, required: true },
+  question: { type: Schema.Types.ObjectId, ref: 'question', required: true },
+  roomId: { type: String, required: true, unique: false },
+  attemptStartedAt: { type: Date, required: true, default: Date.now() },
+  attemptCompletedAt: { type: Date, required: true, default: Date.now() },
+  collaboratorId: { type: String, required: true },
+  attemptCode: { type: String, required: true },
+});
+
+const historyEntryModel = mongoose.model<HistoryEntry>('historyEntry', historyEntrySchema);
+export default historyEntryModel;

backend/question-service/routes/historyRoutes.ts

@@ -0,0 +1,19 @@
+import express from 'express';
+import {
+  getUserHistoryEntries,
+  createOrUpdateUserHistoryEntry,
+  deleteUserHistoryEntry,
+  deleteUserHistoryEntries,
+  deleteAllUserHistoryEntries,
+} from '../controllers/historyController';
+import { authenticateToken } from '../middlewares/auth';
+
+const router = express.Router();
+
+router.get("/", authenticateToken, getUserHistoryEntries);
+router.post("/", authenticateToken, createOrUpdateUserHistoryEntry);
+router.delete("/user/:id", authenticateToken, deleteUserHistoryEntry);
+router.delete("/user", authenticateToken, deleteUserHistoryEntries);
+router.delete("/all", authenticateToken, deleteAllUserHistoryEntries);
+
+export default router;

frontend/src/data/repositories/HistoryRemoteDataSource.ts

@@ -0,0 +1,33 @@
+
+import { HistoryEntry } from "domain/entities/HistoryEntry";
+import { BaseApi } from "../../infrastructure/Api/BaseApi";
+
+const API_URL = "/api/history";
+
+export class HistoryRemoteDataSource extends BaseApi {
+    constructor() {
+        super(API_URL);
+    }
+
+    async getAllUserHistories(): Promise<HistoryEntry[]> {
+        return await this.protectedGet<HistoryEntry[]>("/");
+    }
+
+    async createOrUpdateUserHistory(questionId: string, roomId: string, attemptStartedAt: string, attemptCompletedAt: string, collaboratorId: string, attemptCode: string): Promise<void> {
+        return await this.protectedPost<void>("/", { questionId, roomId, attemptStartedAt, attemptCompletedAt, collaboratorId, attemptCode });
+    }
+
+    async deleteSelectedHistories(selectedHistoryIds: string[]): Promise<void> {
+        console.log("Delete")
+        selectedHistoryIds.forEach(async (id) => {
+            console.log(id);
+            await this.protectedDelete<void>(`/user/${id}`);
+        });
+    }
+
+    async deleteAllUserHistories(): Promise<void> {
+        await this.protectedDelete<void>("/all");
+    }
+}
+
+export const historyRemoteDataSource = new HistoryRemoteDataSource();

frontend/src/data/repositories/HistoryRepositoryImpl.ts

@@ -0,0 +1,24 @@
+import { HistoryEntry } from "domain/entities/HistoryEntry";
+import { historyRemoteDataSource } from "./HistoryRemoteDataSource";
+
+export class HistoryRepositoryImpl {
+    private dataSource = historyRemoteDataSource;
+
+    async getAllUserHistories(): Promise<HistoryEntry[]> {
+        return this.dataSource.getAllUserHistories();
+    }
+
+    async createOrUpdateUserHistory(questionId: string, roomId: string, attemptStartedAt: string, attemptCompletedAt: string, collaboratorId: string, attemptCode: string): Promise<void> {
+        this.dataSource.createOrUpdateUserHistory(questionId, roomId, attemptStartedAt, attemptCompletedAt, collaboratorId, attemptCode)
+    }
+
+    async deleteSelectedUserHistories(selectedHistoryIds: string[]): Promise<void> {
+        this.dataSource.deleteSelectedHistories(selectedHistoryIds);
+    }
+
+    async deleteAllUserHistories(): Promise<void> {
+        this.dataSource.deleteAllUserHistories();
+    }
+}
+
+export const historyRepository = new HistoryRepositoryImpl();