get match items draft

anunayajoshi · anunayajoshi · commit 4c8a20b44989 · 2024-10-18T17:10:20.000+08:00
diff --git a/backend/matching/.env.local b/backend/matching/.env.local
@@ -5,6 +5,11 @@ EXPRESS_PORT=9004
 MATCHING_DB_HOSTNAME="localhost"
 MATCHING_DB_PORT=6379
 
+USER_SERVER_ENDPOINT="http://localhost:9003"
+QUESTION_SERVER_ENDPOINT="http://localhost:9002"
+COLLAB_SERVER_ENDPOINT="http://localhost:9004"
+
+
 # MATCHING_DB_USERNAME="peerprep-match-express"
 # MATCHING_DB_PASSWORD="G7jBgyz9wGAFQ5La"
 # REDIS_ARGS="--requirepass G7jBgyz9wGAFQ5La --user ${MATCHING_DB_USERNAME} on >G7jBgyz9wGAFQ5La ~* allcommands --user default off nopass nocommands"
diff --git a/backend/matching/src/services/get-match-items.ts b/backend/matching/src/services/get-match-items.ts
@@ -1,7 +1,140 @@
-export const getMatchItems = () => {
-  // TODO: Get Match Items
-  return {
-    roomId: '',
-    questionId: '',
-  };
+import { IMatchType } from "@/types";
+import axios from 'axios';
+
+interface IGetRandomQuestionPayload {
+  attemptedQuestions: number[];
+  difficulty?: string;
+  topic?: string;
+}
+
+interface IQuestion {
+  id: number;
+  title: string;
+  description: string;
+  difficulty: string;
+  topic: string[];
+}
+
+interface IServiceResponse<T> {
+  success: boolean;
+  data?: T;
+  error?: { message: string };
+}
+
+interface IMatchItemsResponse {
+  roomId: string;
+  questionId: number;
+  question: IQuestion;
+}
+
+export const getMatchItems = async (
+  searchIdentifier: IMatchType,
+  topic?: string,
+  difficulty?: string,
+  userId1?: string,
+  userId2?: string
+): Promise<IServiceResponse<IMatchItemsResponse>> => {
+  const userEndpoint = `${process.env.USER_SERVER_ENDPOINT}`;
+  const questionEndpoint = `${process.env.QUESTION_SERVER_ENDPOINT}`;
+  const collabServerEndpoint = `${process.env.COLLAB_SERVER_ENDPOINT}`;
+
+  try {
+    if (!userId1 || !userId2) {
+      throw new Error('Both user IDs are required');
+    }
+
+    // Fetch attempted questions for both users
+    const [attemptedQuestions1, attemptedQuestions2] = await Promise.all([
+      fetchAttemptedQuestions(userEndpoint, userId1),
+      fetchAttemptedQuestions(userEndpoint, userId2)
+    ]);
+
+    // Combine attempted questions from both users
+    const allAttemptedQuestions = [...new Set([...attemptedQuestions1, ...attemptedQuestions2])];
+
+    // Prepare payload for the /random endpoint
+    const payload: IGetRandomQuestionPayload = {
+      attemptedQuestions: allAttemptedQuestions,
+    };
+
+    if (searchIdentifier === 'difficulty' && difficulty) {
+      payload.difficulty = difficulty;
+    } else if (searchIdentifier === 'topic' && topic) {
+      payload.topic = topic;
+    } else if (searchIdentifier === 'exact match' && topic && difficulty) {
+      payload.topic = topic;
+      payload.difficulty = difficulty;
+    }
+
+    // Query the question endpoint using the /random endpoint
+    const questionResponse = await axios.post<IServiceResponse<{ question: IQuestion }>>(
+      `${questionEndpoint}/random`,
+      payload
+    );
+
+    if (!questionResponse.data.success || !questionResponse.data.data?.question) {
+      throw new Error(questionResponse.data.error?.message || 'Failed to get a random question');
+    }
+
+    const questionId = questionResponse.data.data.question.id;
+
+    // Update attempted questions for both users
+    await Promise.all([
+      updateAttemptedQuestions(userEndpoint, userId1, questionId),
+      updateAttemptedQuestions(userEndpoint, userId2, questionId)
+    ]);
+
+    // Query the collab server for the room ID
+    const roomResponse = await axios.get<IServiceResponse<{ roomId: string }>>(
+      `${collabServerEndpoint}/rooms`,
+      {
+        params: {
+          userId1,
+          userId2,
+          questionId: questionId.toString(),
+        }
+      }
+    );
+
+    if (!roomResponse.data.success || !roomResponse.data.data?.roomId) {
+      throw new Error(roomResponse.data.error?.message || 'Failed to create room');
+    }
+
+    return {
+      success: true,
+      data: {
+        roomId: roomResponse.data.data.roomId,
+        questionId: questionId,
+        question: questionResponse.data.data.question,
+      }
+    };
+  } catch (error) {
+    console.error('Error in getMatchItems:', error);
+    return {
+      success: false,
+      error: {
+        message: error instanceof Error ? error.message : 'An unknown error occurred',
+      }
+    };
+  }
 };
+
+async function fetchAttemptedQuestions(userEndpoint: string, userId: string): Promise<number[]> {
+  const response = await axios.get<IServiceResponse<{ attemptedQuestions: number[] }>>(
+    `${userEndpoint}/user/${userId}/attempted-questions`
+  );
+  if (!response.data.success || !response.data.data?.attemptedQuestions) {
+    throw new Error(`Failed to fetch attempted questions for user ${userId}`);
+  }
+  return response.data.data.attemptedQuestions;
+}
+
+async function updateAttemptedQuestions(userEndpoint: string, userId: string, questionId: number): Promise<void> {
+  const response = await axios.post<IServiceResponse<{ message: string }>>(
+    `${userEndpoint}/user/${userId}/attempted-question`,
+    { questionId }
+  );
+  if (!response.data.success) {
+    throw new Error(`Failed to update attempted questions for user ${userId}`);
+  }
+}
diff --git a/backend/matching/src/types/index.ts b/backend/matching/src/types/index.ts
@@ -28,3 +28,5 @@ export type IStreamMessage = {
   };
   value?: Awaited<ReturnType<(typeof client)['ft']['search']>>['documents'][number]['value'];
 };
+
+export type IMatchType = 'difficulty' | 'topic' | 'exact match' | undefined
diff --git a/backend/matching/src/workers/matcher.ts b/backend/matching/src/workers/matcher.ts
@@ -3,6 +3,7 @@ import { POOL_INDEX, STREAM_GROUP, STREAM_NAME, STREAM_WORKER } from '@/lib/db/c
 import { decodePoolTicket, getPoolKey, getStreamId } from '@/lib/utils';
 import { getMatchItems } from '@/services';
 import { MATCH_SVC_EVENT } from '@/ws';
+import { IMatchType } from '@/types';
 
 import { connectClient, sendNotif } from './common';
 
@@ -41,7 +42,9 @@ async function processMatch(
   redisClient: typeof client,
   { requestorUserId, requestorStreamId, requestorSocketPort }: RequestorParams,
   matches: Awaited<ReturnType<(typeof client)['ft']['search']>>,
-  searchIdentifier?: string
+  searchIdentifier?: IMatchType,
+  topic?: string,
+  difficulty?: string
 ) {
   if (matches.total > 0) {
     for (const matched of matches.documents) {
@@ -61,6 +64,7 @@ async function processMatch(
       const matchedStreamId = getStreamId(timestamp);
 
       logger.info(`Found match: ${JSON.stringify(matched)}`);
+      
 
       await Promise.all([
         // Remove other from pool
@@ -70,7 +74,7 @@ async function processMatch(
       ]);
 
       // Notify both sockets
-      const { ...matchItems } = getMatchItems();
+      const { ...matchItems } = getMatchItems(searchIdentifier, topic, difficulty, requestorUserId, matchedUserId);
       sendNotif([requestorSocketPort, matchedSocketPort], MATCH_SVC_EVENT.SUCCESS, matchItems);
       sendNotif([requestorSocketPort, matchedSocketPort], MATCH_SVC_EVENT.DISCONNECT);
 
@@ -142,7 +146,9 @@ async function match() {
         redisClient,
         requestorParams,
         exactMatches,
-        'exact match'
+        'exact match',
+        topic,
+        difficulty
       );
 
       if (exactMatchFound || !topic || !difficulty) {
@@ -160,7 +166,9 @@ async function match() {
         redisClient,
         requestorParams,
         topicMatches,
-        'topic'
+        'topic',
+        topic,
+        difficulty
       );
 
       if (topicMatchFound) {
@@ -177,7 +185,9 @@ async function match() {
         redisClient,
         requestorParams,
         difficultyMatches,
-        'difficulty'
+        'difficulty',
+        topic,
+        difficulty
       );
 
       if (!hasDifficultyMatch) {
diff --git a/backend/question/src/services/get/types.ts b/backend/question/src/services/get/types.ts
@@ -51,6 +51,7 @@ export type IGetRandomQuestionPayload = {
 
 export type IGetRandomQuestionResponse = IServiceResponse<{
   question: {
+    id: number; // question's unique identifier or number
     title: string; // name or title of the question
     description: string; // question description
     difficulty: string; // difficulty level (e.g., 'easy', 'medium', 'hard')
diff --git a/backend/user/src/controllers/questions/index.ts b/backend/user/src/controllers/questions/index.ts
@@ -0,0 +1,38 @@
+import { StatusCodes } from 'http-status-codes';
+import type { IRouteHandler } from '@/types';
+import { getAttemptedQuestionsService, addAttemptedQuestionService } from '@/services/questions';
+
+export const addAttemptedQuestion: IRouteHandler = async (req, res) => {
+  const userId = req.params.userId; // Assuming the userId is passed as a route parameter
+  const { questionId } = req.body; // Assuming the questionId is passed in the request body
+
+  if (!userId || !questionId) {
+    return res.status(StatusCodes.BAD_REQUEST).json('User ID and Question ID are required');
+  }
+
+  const { code, data, error } = await addAttemptedQuestionService(userId, questionId);
+
+  if (error || code !== StatusCodes.OK || !data) {
+    const sanitizedErr = error?.message ?? 'An error occurred.';
+    return res.status(code).json(sanitizedErr);
+  }
+
+  return res.status(StatusCodes.OK).json(data);
+};
+
+export const getAttemptedQuestions: IRouteHandler = async (req, res) => {
+  const userId = req.params.userId; // Assuming the userId is passed as a route parameter
+
+  if (!userId) {
+    return res.status(StatusCodes.BAD_REQUEST).json('User ID is required');
+  }
+
+  const { code, data, error } = await getAttemptedQuestionsService(userId);
+
+  if (error || code !== StatusCodes.OK || !data) {
+    const sanitizedErr = error?.message ?? 'An error occurred.';
+    return res.status(code).json(sanitizedErr);
+  }
+
+  return res.status(StatusCodes.OK).json(data);
+};
diff --git a/backend/user/src/routes/auth.ts b/backend/user/src/routes/auth.ts
@@ -2,6 +2,7 @@ import express from 'express';
 
 import { checkEmailValid, checkUsernameValid, login, logout, register } from '@/controllers/auth';
 import { limiter } from '@/lib/ratelimit';
+import { getAttemptedQuestions, addAttemptedQuestion } from '@/controllers/questions';
 
 const router = express.Router();
 
@@ -10,6 +11,9 @@ router.post('/logout', logout);
 router.post('/register', register);
 router.post('/username-valid', checkUsernameValid);
 router.post('/email-valid', checkEmailValid);
+
+router.post('/attempted-questions', getAttemptedQuestions)
+router.post('/attempt-question', addAttemptedQuestion)
 router.use(limiter);
 
 export default router;
diff --git a/backend/user/src/services/questions/index.ts b/backend/user/src/services/questions/index.ts
