Merge pull request #32 from CS3219-AY2425S1/anun/crud

SeeuSim · web-flow · commit 7431eab47ebb · 2024-09-30T02:11:01.000+08:00
diff --git a/backend/question/src/controller/question-controller.ts b/backend/question/src/controller/question-controller.ts
@@ -7,19 +7,31 @@ import {
   getRandomQuestionService,
   searchQuestionsByTitleService,
 } from '@/services/get/index';
+import type {
+  ICreateQuestionPayload,
+  IDeleteQuestionPayload,
+  IUpdateQuestionPayload,
+} from '@/services/post/types';
+
+import {
+  createQuestionService,
+  deleteQuestionService,
+  updateQuestionService,
+} from '@/services/post';
 import type {
   IGetQuestionsPayload,
   IGetQuestionPayload,
   IGetRandomQuestionPayload,
 } from '@/services/get/types';
 
 export const getQuestions = async (req: Request, res: Response): Promise<Response> => {
+  const { questionName, difficulty, topic, pageNum, recordsPerPage } = req.query;
   const payload: IGetQuestionsPayload = {
-    questionName: req.query.questionName as string,
-    difficulty: req.query.difficulty as string,
-    topic: req.query.topic as string[],
-    pageNum: parseInt(req.query.pageNum as string) || 0,
-    recordsPerPage: parseInt(req.query.recordsPerPage as string) || 20,
+    questionName: questionName as string,
+    difficulty: difficulty as string,
+    topic: topic as string[],
+    pageNum: parseInt(pageNum as string) || 0,
+    recordsPerPage: parseInt(recordsPerPage as string) || 20,
   };
 
   try {
@@ -67,6 +79,8 @@ export const getRandomQuestion = async (req: Request, res: Response): Promise<Re
     const result = await getRandomQuestionService(payload);
     return res.status(result.code).json(result);
   } catch (error) {
+    console.log('error', error);
+
     return res
       .status(StatusCodes.INTERNAL_SERVER_ERROR)
       .json({ success: false, message: 'An error occurred', error });
@@ -93,3 +107,71 @@ export const searchQuestionsByTitle = async (req: Request, res: Response): Promi
       .json({ success: false, message: 'An error occurred', error });
   }
 };
+
+export const createQuestion = async (req: Request, res: Response): Promise<Response> => {
+  const { title, description, difficulty, topics } = req.body;
+
+  if (!title || !description || !difficulty) {
+    return res.status(StatusCodes.UNPROCESSABLE_ENTITY).json('Malformed');
+  }
+
+  const payload: ICreateQuestionPayload = {
+    title,
+    description,
+    difficulty,
+    topics,
+  };
+
+  try {
+    const result = await createQuestionService(payload);
+    if (!result.data || result.code >= 400) {
+      return res.status(result.code).json({
+        message: result.message ?? 'An error occurred',
+      });
+    }
+    return res.status(result.code).json(result.data);
+  } catch (error) {
+    return res
+      .status(StatusCodes.INTERNAL_SERVER_ERROR)
+      .json({ success: false, message: 'An error occurred', error });
+  }
+};
+
+export const updateQuestion = async (req: Request, res: Response): Promise<Response> => {
+  const { title, description, difficulty, topics } = req.body;
+  if (!title && !description && !difficulty && (!topics || !Array.isArray(topics))) {
+    return res.status(StatusCodes.UNPROCESSABLE_ENTITY).json('Malformed');
+  }
+
+  const payload: IUpdateQuestionPayload = {
+    id: parseInt(req.params.questionId),
+    title,
+    description,
+    difficulty,
+    topics,
+  };
+
+  try {
+    const result = await updateQuestionService(payload);
+    return res.status(result.code).json(result);
+  } catch (error) {
+    return res
+      .status(StatusCodes.INTERNAL_SERVER_ERROR)
+      .json({ success: false, message: 'An error occurred', error });
+  }
+};
+
+export const deleteQuestion = async (req: Request, res: Response): Promise<Response> => {
+  const payload: IDeleteQuestionPayload = {
+    id: parseInt(req.params.questionId),
+  };
+
+  try {
+    const result = await deleteQuestionService(payload);
+    return res.status(result.code).json(result.success ? 'Ok' : result.message);
+  } catch (error) {
+    return res
+      .status(StatusCodes.INTERNAL_SERVER_ERROR)
+      .json({ success: false, message: 'An error occurred', error });
+  }
+};
diff --git a/backend/question/src/routes/question.ts b/backend/question/src/routes/question.ts
@@ -5,6 +5,9 @@ import {
   getQuestions,
   getQuestionDetails,
   getRandomQuestion,
+  createQuestion,
+  updateQuestion,
+  deleteQuestion,
 } from '@/controller/question-controller';
 
 const router = Router();
@@ -17,4 +20,8 @@ router.get('/:questionId', getQuestionDetails);
 
 router.post('/random', getRandomQuestion);
 
+router.post('/create', createQuestion);
+router.put('/:questionId', updateQuestion);
+router.delete('/:questionId', deleteQuestion);
+
 export default router;
diff --git a/backend/question/src/services/get/index.ts b/backend/question/src/services/get/index.ts
@@ -1,4 +1,4 @@
-import { and, arrayOverlaps, eq, ilike, notInArray, sql } from 'drizzle-orm';
+import { and, arrayOverlaps, eq, ilike, inArray, not, sql } from 'drizzle-orm';
 
 import { db } from '@/lib/db/index';
 import { questions } from '@/lib/db/schema';
@@ -92,31 +92,45 @@ export const getQuestionDetailsService = async (
 export const getRandomQuestionService = async (
   payload: IGetRandomQuestionPayload
 ): Promise<IGetRandomQuestionResponse> => {
-  const { attemptedQuestions, difficulty, topic } = payload;
+  const { difficulty, topic, attemptedQuestions } = payload;
   const whereClause = [];
 
+  console.log('Starting query construction');
+
   if (difficulty) {
+    console.log(`Adding difficulty filter: ${difficulty}`);
     whereClause.push(eq(questions.difficulty, difficulty));
   }
 
-  if (topic && topic.length > 0) {
-    whereClause.push(arrayOverlaps(questions.topic, topic));
+  const topicArray = (Array.isArray(topic) ? topic : [topic]).filter(
+    (t): t is string => t !== undefined
+  );
+  if (topicArray.length > 0) {
+    whereClause.push(arrayOverlaps(questions.topic, topicArray));
   }
 
   if (attemptedQuestions && attemptedQuestions.length > 0) {
-    whereClause.push(notInArray(questions.id, attemptedQuestions));
+    console.log(`Excluding attempted questions: ${attemptedQuestions.join(', ')}`);
+    whereClause.push(not(inArray(questions.id, attemptedQuestions)));
   }
 
-  // randomize the order of questions
-  const query = db
-    .select()
-    .from(questions)
-    .where(and(...whereClause))
-    .orderBy(sql`RANDOM()`)
-    .limit(1);
+  console.log(`Where clause conditions: ${whereClause.length}`);
+
+  let query = db.select().from(questions);
+
+  if (whereClause.length > 0) {
+    query = query.where(and(...whereClause)) as typeof query;
+  }
+
+  query = (query as any).orderBy(sql`RANDOM()`).limit(1);
+
+  console.log('Executing query');
+  console.log(query.toSQL()); // This will log the SQL query
 
   const result = await query;
 
+  console.log(`Query result: ${JSON.stringify(result)}`);
+
   if (result.length === 0) {
     return {
       code: StatusCodes.NOT_FOUND,
@@ -126,7 +140,6 @@ export const getRandomQuestionService = async (
       },
     };
   }
-
   return {
     code: StatusCodes.OK,
     data: { question: result[0] },
diff --git a/backend/question/src/services/post/index.ts b/backend/question/src/services/post/index.ts
@@ -0,0 +1,65 @@
+import { db } from '../../lib/db/index';
+import { eq } from 'drizzle-orm';
+import { questions } from '../../lib/db/schema';
+import { ICreateQuestionPayload, IUpdateQuestionPayload, IDeleteQuestionPayload } from './types';
+
+export const createQuestionService = async (payload: ICreateQuestionPayload) => {
+  try {
+    const [newQuestion] = await db
+      .insert(questions)
+      .values({
+        title: payload.title,
+        description: payload.description,
+        difficulty: payload.difficulty,
+        topic: payload.topics.map(String),
+      })
+      .returning();
+
+    return { success: true, code: 201, data: newQuestion };
+  } catch (error) {
+    console.error('Error creating question:', error);
+    return { success: false, code: 500, message: 'Failed to create question' };
+  }
+};
+
+export const updateQuestionService = async (payload: IUpdateQuestionPayload) => {
+  try {
+    const [updatedQuestion] = await db
+      .update(questions)
+      .set({
+        title: payload.title,
+        description: payload.description,
+        difficulty: payload.difficulty,
+        topic: payload.topics.map(String),
+      })
+      .where(eq(questions.id, Number(payload.id)))
+      .returning();
+
+    if (!updatedQuestion) {
+      return { success: false, code: 404, message: 'Question not found' };
+    }
+
+    return { success: true, code: 200, data: updatedQuestion };
+  } catch (error) {
+    console.error('Error updating question:', error);
+    return { success: false, code: 500, message: 'Failed to update question' };
+  }
+};
+
+export const deleteQuestionService = async (payload: IDeleteQuestionPayload) => {
+  try {
+    const [deletedQuestion] = await db
+      .delete(questions)
+      .where(eq(questions.id, payload.id))
+      .returning();
+
+    if (!deletedQuestion) {
+      return { success: false, code: 404, message: 'Question not found' };
+    }
+
+    return { success: true, code: 200, message: 'Question deleted successfully' };
+  } catch (error) {
+    console.error('Error deleting question:', error);
+    return { success: false, code: 500, message: 'Failed to delete question' };
+  }
+};
diff --git a/backend/question/src/services/post/types.ts b/backend/question/src/services/post/types.ts
@@ -0,0 +1,14 @@
+export interface ICreateQuestionPayload {
+  title: string;
+  description: string;
+  difficulty: string;
+  topics: string[];
+}
+
+export interface IUpdateQuestionPayload extends ICreateQuestionPayload {
+  id: number;
+}
+
+export interface IDeleteQuestionPayload {
+  id: number;
+}
