Merge pull request #110 from CS3219-AY2425S1/jehou/questiondb

Leetcode question filtering

Author: jehousoh

backend/question/docs/question.plantuml

@@ -23,19 +23,21 @@ entity Pagination {
 interface IQuestionServiceAPI {
   + GET /
   + POST /create [createQuestion: EditQuestion]
-  + POST /all [pagination: Pagination]
+  + POST /all [pagination: Pagination, title: string, complexity: string[], category: string[]]
   + GET /{id}
   + POST /{id}/update [updateQuestion: EditQuestion]
   + POST /{id}/delete
+  + POST /pick-question [complexity: string[], category: string[]]
 }
 
 note right of IQuestionServiceAPI
   - GET /: Check service status
   - POST /create: Create a new question
-  - POST /all: Retrieve all questions with pagination
+  - POST /all: Retrieve all questions with pagination (Supports filtering by title, complexiy and category)
   - GET /{id}: Retrieve a specific question by ID
   - POST /{id}/update: Update a specific question by ID
   - POST /{id}/delete: Delete a specific question by ID
+  - POST /pick-question: Pick a random question given a list of complexities and categories
 end note
 
 class QuestionService {

backend/question/docs/question.yaml

@@ -66,10 +66,39 @@ paths:
                   type: integer
                   default: 1
                   description: Page number
+                  example: 1
                 page_size:
                   type: integer
                   default: 10
                   description: Number of questions per page
+                  example: 10
+                title:
+                  type: string
+                  default: ""
+                  description: Filter by title
+                  example: "Two Sum"
+                complexity:
+                  type: array
+                  items:
+                    type: string
+                  default: []
+                  description: Filter by complexities
+                  example: ["Easy", "Medium", "Hard"]
+                category:
+                  type: array
+                  items:
+                    type: string
+                  default: []
+                  description: Filter by categories
+                  example:
+                    [
+                      "Hash Table",
+                      "Array",
+                      "Linked List",
+                      "Dynamic Programming",
+                      "Math",
+                      "String",
+                    ]
       responses:
         "200":
           description: List of questions
@@ -155,6 +184,43 @@ paths:
           description: Question not found
         "500":
           description: Internal server error
+  /pick-question:
+    post:
+      summary: Pick a random question given a list of complexities and categories
+      requestBody:
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                complexity:
+                  type: array
+                  items:
+                    type: string
+                  default: []
+                  description: Filter by complexities
+                  example: ["Easy"]
+                category:
+                  type: array
+                  items:
+                    type: string
+                  default: []
+                  description: Filter by categories
+                  example: ["Hash Table"]
+
+      responses:
+        "200":
+          description: Question picked
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/Question"
+        "400":
+          description: Bad Request (validation error)
+        "404":
+          description: No Question found
+        "500":
+          description: Internal server error
 
 components:
   schemas:

backend/question/src/routes/questionRoutes.ts

@@ -4,6 +4,7 @@ import Question, { TQuestion } from "../models/Question";
 import {
   createQuestionValidators,
   idValidators,
+  pickQuestionValidators,
   updateQuestionValidators,
 } from "./validators";
 
@@ -60,24 +61,30 @@ router.post("/all", async (req: Request, res: Response) => {
   let pagination = parseInt(req.body.pagination as string, 10) || 1; // Default page is 1
   const page_size = parseInt(req.body.page_size as string, 10) || 10; // Default limit is 10
   const skip = (pagination - 1) * page_size; // Calculate how many documents to skip
+
+  const { title, complexity, category } = req.body;
+
+  const query: any = { deleted: false };
+  if (title && title !== "") query.title = { $regex: title, $options: "i" };
+  if (complexity && complexity.length > 0)
+    query.complexity = { $in: complexity };
+  if (category && category.length > 0) query.category = { $in: category };
+
   try {
-    const questions = await Question.find(
-      { deleted: false },
-      {
-        questionid: 1,
-        title: 1,
-        description: 1,
-        complexity: 1,
-        category: 1,
-      }
-    )
+    const questions = await Question.find(query, {
+      questionid: 1,
+      title: 1,
+      description: 1,
+      complexity: 1,
+      category: 1,
+    })
       .lean()
       .sort({ questionid: "ascending" })
       .skip(skip)
       .limit(page_size)
       .exec();
 
-    const total = await Question.countDocuments({ deleted: false }).exec();
+    const total = await Question.countDocuments(query).exec();
     const totalPages = Math.ceil(total / page_size);
     if (totalPages < pagination) pagination = 1;
 
@@ -123,6 +130,47 @@ router.get("/:id", [...idValidators], async (req: Request, res: Response) => {
   }
 });
 
+// Retrieve a random question by complexity and category
+router.post(
+  "/pick-question",
+  [...pickQuestionValidators],
+  async (req: Request, res: Response) => {
+    const errors = validationResult(req);
+    if (!errors.isEmpty()) {
+      return res.status(400).json({ errors: errors.array() });
+    }
+    const { complexity, category } = req.body;
+
+    const query: any = { deleted: false };
+    if (complexity) query.complexity = { $in: complexity };
+    if (category) query.category = { $in: category };
+
+    try {
+      const randomQuestion = await Question.aggregate([
+        { $match: query }, // Filter by complexity and category
+        { $sample: { size: 1 } }, // Randomly select one document
+        {
+          $project: {
+            questionid: 1,
+            title: 1,
+            description: 1,
+            complexity: 1,
+            category: 1,
+          },
+        },
+      ]);
+
+      if (!randomQuestion.length) {
+        return res.status(404).json({ message: "No questions found" });
+      }
+
+      return res.json(randomQuestion[0]);
+    } catch (error) {
+      return res.status(500).send("Internal server error");
+    }
+  }
+);
+
 // Update a specific question by id
 router.post(
   "/:id/update",
@@ -180,10 +228,6 @@ router.post(
       );
       return res.json(updatedQuestion);
     } catch (error) {
-      //to catch pre-middleware defined error
-      if (error instanceof Error) {
-        return res.status(404).json(error.message);
-      }
       return res.status(500).send("Internal server error");
     }
   }

backend/question/src/routes/validators.ts

@@ -10,16 +10,51 @@ export const createQuestionValidators = [
       throw new Error("Category must be a non-empty array");
     }
     //check if array contains only non-empty strings and trim whitespace
-    if (!category.every((element) => typeof element === "string" && element.length > 0 && element.trim().length > 0)) {
+    if (
+      !category.every(
+        (element) =>
+          typeof element === "string" &&
+          element.length > 0 &&
+          element.trim().length > 0
+      )
+    ) {
       throw new Error("Category must contain only non-empty strings");
     }
     return true;
-  }
-  ),
+  }),
 ];
 
 export const idValidators = [check("id").isInt({ min: 1 })];
 
+export const pickQuestionValidators = [
+  check("complexity").custom((complexity) => {
+    if (!Array.isArray(complexity) || complexity.length === 0) {
+      throw new Error("Complexity must be a non-empty array");
+    }
+    if (
+      !complexity.every(
+        (element) => typeof element === "string" && element.trim().length > 0
+      )
+    ) {
+      throw new Error("Complexity must contain only non-empty strings");
+    }
+    return true;
+  }),
+  check("category").custom((category) => {
+    if (!Array.isArray(category) || category.length === 0) {
+      throw new Error("Category must be a non-empty array");
+    }
+    if (
+      !category.every(
+        (element) => typeof element === "string" && element.trim().length > 0
+      )
+    ) {
+      throw new Error("Category must contain only non-empty strings");
+    }
+    return true;
+  }),
+];
+
 export const updateQuestionValidators = [
   check("id").isInt(),
   body().custom((body) => {
@@ -35,7 +70,14 @@ export const updateQuestionValidators = [
             throw new Error("Category must be a non-empty array");
           }
           //check if array contains only non-empty strings and trim whitespace
-          if (!field.every((element) => typeof element === "string" && element.length > 0 && element.trim().length > 0)) {
+          if (
+            !field.every(
+              (element) =>
+                typeof element === "string" &&
+                element.length > 0 &&
+                element.trim().length > 0
+            )
+          ) {
             throw new Error("Category must contain only non-empty strings");
           }
         } else {