Dev

src/apis/v1/documents/controller.ts

@@ -49,3 +49,9 @@ export const getDocumentsBySubjectId = async (req: RequestWithUser, res: Respons
   const result = await service.getDocumentsBySubjectId(input.id);
   res.send(fmt.formatResponse(result, Date.now() - req.startTime, 'OK'));
 };
+
+export const getDocumentsByOwner = async (req: RequestWithUser, res: Response) => {
+  const author: ObjectId = req?.user?._id;
+  const result = await service.getDocumentsByOwner(author);
+  res.send(fmt.formatResponse(result, Date.now() - req.startTime, 'OK'));
+};

src/apis/v1/documents/index.ts

@@ -11,6 +11,8 @@ const router = Router();
 
 router.get('/', authMiddleware, asyncRouteHandler(controller.getDocuments));
 
+router.get('/owner', authMiddleware, asyncRouteHandler(controller.getDocumentsByOwner));
+
 router.post(
   '/',
   authMiddleware,
@@ -46,4 +48,5 @@ router.get(
   validationMiddleware(ParamsDocumentDto, APP_CONSTANTS.params),
   asyncRouteHandler(controller.getDocumentsBySubjectId)
 );
+
 export default router;

src/apis/v1/documents/service.ts

@@ -15,6 +15,7 @@ import { SubjectModel } from 'models';
 import URLParams from 'utils/rest/urlparams';
 import { DEFAULT_PAGING } from 'utils/constants';
 import { hideUserInfoIfRequired } from 'utils';
+import DocumentType from 'models/types/Document';
 
 export const getDocuments = async (urlParams: URLParams) => {
   try {
@@ -152,11 +153,13 @@ export const getDocumentsByAdmin = async (filter: DocumentFilter, urlParams: URL
 
     logger.info(`Get all documents successfully`);
 
-    const resultAll = await Promise.all([count, results]);
+    const resolveAll = await Promise.all([count, results]);
     return {
-      result: resultAll[1],
+      result: resolveAll[1].map((document: DocumentType) => {
+        return { ...document.toObject(), author: hideUserInfoIfRequired(document?.author) };
+      }),
       meta: {
-        total: resultAll[0],
+        total: resolveAll[0],
         currentPage,
         pageSize,
       },
@@ -190,6 +193,23 @@ export const getDocumentsBySubjectId = async (subjectId: string) => {
   }
 };
 
+export const getDocumentsByOwner = async (authorId: ObjectId) => {
+  try {
+    const results = await DocumentModel.find({ author: authorId })
+      .populate('author', '-is_blocked -roles -created_at -updated_at -__v')
+      .populate('subject', '-is_deleted -created_at -updated_at -__v');
+
+    return {
+      documents: results.map((document) => {
+        return { ...document.toObject(), author: hideUserInfoIfRequired(document?.author) };
+      }),
+    };
+  } catch (error) {
+    logger.error(`Error while get documents by Owner: ${error}`);
+    throw new HttpException(400, ErrorCodes.BAD_REQUEST.MESSAGE, ErrorCodes.BAD_REQUEST.CODE);
+  }
+};
+
 export const updateDocumentByAdmin = async (input: UpdateDocumentByAdminDto, documentId: string) => {
   try {
     const document = await DocumentModel.findByIdAndUpdate(

src/apis/v1/exam/controller.ts

@@ -26,7 +26,6 @@ export const getExamsBySubjectId = async (req: RequestWithUser, res: Response) =
   const urlParams: URLParams = req.searchParams;
   const input: ParamsExamDto = req.params;
   const { result, meta } = await service.getExamsBySubjectId(input.id, urlParams);
-
   res.send(fmt.formatResponse(result, Date.now() - req.startTime, 'OK', meta.total, meta.currentPage, meta.pageSize));
 };
 
@@ -60,3 +59,10 @@ export const getDraftExam = async (req: RequestWithUser, res: Response) => {
 
   res.send(fmt.formatResponse(result, Date.now() - req.startTime, 'OK'));
 };
+
+export const getExamsByOwner = async (req: RequestWithUser, res: Response) => {
+  const author = req?.user?._id;
+  const result = await service.getExamsByOwner(String(author));
+
+  res.send(fmt.formatResponse(result, Date.now() - req.startTime, 'OK'));
+};

src/apis/v1/exam/index.ts

@@ -12,6 +12,8 @@ router.get('/', authMiddleware, asyncRouteHandler(controller.getExams));
 
 router.get('/draft-exam', authMiddleware, asyncRouteHandler(controller.getDraftExam));
 
+router.get('/owner', authMiddleware, asyncRouteHandler(controller.getExamsByOwner));
+
 router.get(
   '/:id',
   authMiddleware,

src/apis/v1/exam/service.ts

@@ -2,7 +2,7 @@
 import { ObjectId } from 'mongodb';
 import { ObjectId as ObjectIdType, PipelineStage } from 'mongoose';
 import { ErrorCodes, HttpException } from 'exceptions';
-import { ExamModel } from 'models';
+import { ExamModel, SubjectModel } from 'models';
 import { DEFAULT_PAGING } from 'utils/constants';
 import { logger } from 'utils/logger';
 import URLParams from 'utils/rest/urlparams';
@@ -70,7 +70,6 @@ export const getExams = async (urlParams: URLParams) => {
         $limit: Number(pageSize),
       },
     ]);
-
     const resolveAll = await Promise.all([count, data]);
     return {
       result: resolveAll[1].map((exam: Exam) => {
@@ -131,6 +130,7 @@ export const getExamById = async (id: string) => {
           _id: 1,
           title: 1,
           description: 1,
+          is_approved: 1,
           author: {
             _id: '$author._id',
             fullname: '$author.fullname',
@@ -181,7 +181,7 @@ export const getExamsBySubjectId = async (subjectId: string, urlParams: URLParam
     const count = ExamModel.countDocuments({ subject: subjectId });
     const data = ExamModel.aggregate([
       {
-        $match: { subject: _id },
+        $match: { subject: _id, is_approved: true },
       },
       {
         $lookup: {
@@ -233,13 +233,17 @@ export const getExamsBySubjectId = async (subjectId: string, urlParams: URLParam
         $limit: Number(pageSize),
       },
     ]);
-
-    const resolveAll = await Promise.all([count, data]);
+    const subject = SubjectModel.findOne({ _id: subjectId });
+    const resolveAll = await Promise.all([count, data, subject]);
 
     return {
-      result: resolveAll[1].map((exam: Exam) => {
-        return { ...exam, author: hideUserInfoIfRequired(exam?.author) };
-      }),
+      result: {
+        exams: resolveAll[1].map((exam: Exam) => {
+          return { ...exam, author: hideUserInfoIfRequired(exam?.author) };
+        }),
+        subject: resolveAll[2],
+      },
+
       meta: {
         total: resolveAll[0],
         pageSize,
@@ -251,7 +255,69 @@ export const getExamsBySubjectId = async (subjectId: string, urlParams: URLParam
     throw new HttpException(400, ErrorCodes.BAD_REQUEST.MESSAGE, ErrorCodes.BAD_REQUEST.CODE);
   }
 };
-
+export const getExamsByOwner = async (authorId: string) => {
+  try {
+    const _id = new ObjectId(authorId);
+    const count = ExamModel.countDocuments({ author: authorId });
+    const data = ExamModel.aggregate([
+      {
+        $match: { author: _id },
+      },
+      {
+        $lookup: {
+          from: 'question',
+          localField: '_id',
+          foreignField: 'exam_id',
+          as: 'questions',
+        },
+      },
+      {
+        $lookup: {
+          from: 'user',
+          localField: 'author',
+          foreignField: '_id',
+          as: 'author',
+        },
+      },
+      {
+        $lookup: {
+          from: 'subject',
+          localField: 'subject',
+          foreignField: '_id',
+          as: 'subject',
+        },
+      },
+      {
+        $unwind: '$subject',
+      },
+      {
+        $unwind: '$author',
+      },
+      {
+        $project: {
+          'author.is_blocked': 0,
+          'author.roles': 0,
+          'author.created_at': 0,
+          'author.updated_at': 0,
+          'author.__v': 0,
+          'questions.author': 0,
+        },
+      },
+      {
+        $sort: { created_at: -1 },
+      },
+    ]);
+    const resolveAll = await Promise.all([count, data]);
+    return {
+      exams: resolveAll[1].map((exam: Exam) => {
+        return { ...exam, author: hideUserInfoIfRequired(exam?.author) };
+      }),
+    };
+  } catch (error) {
+    logger.error(`Error while get exam by Owner: ${error}`);
+    throw new HttpException(400, ErrorCodes.BAD_REQUEST.MESSAGE, ErrorCodes.BAD_REQUEST.CODE);
+  }
+};
 export const createExam = async (input: ExamDto, author: ObjectIdType) => {
   try {
     const exam = {

src/apis/v1/questions/controller.ts

@@ -37,3 +37,10 @@ export const deleteQuestion = async (req: RequestWithUser, res: Response) => {
   const result = await service.deleteQuestion(params.id);
   res.send(fmt.formatResponse(result, Date.now() - req.startTime, 'OK'));
 };
+
+export const getQuestionsByExamId = async (req: RequestWithUser, res: Response) => {
+  const params: ParamsQuestionDto = req.params;
+
+  const result = await service.getQuestionsByExamId(params.id);
+  res.send(fmt.formatResponse(result, Date.now() - req.startTime, 'OK'));
+};

src/apis/v1/questions/index.ts

@@ -10,6 +10,12 @@ import { QuestionDto, UpdateQuestionDto, ParamsQuestionDto } from './dto/Questio
 const router = Router();
 
 router.get('/', authMiddleware, asyncRouteHandler(controller.getQuestions));
+router.get(
+  '/exam/:id',
+  authMiddleware,
+  validationMiddleware(ParamsQuestionDto, APP_CONSTANTS.params),
+  asyncRouteHandler(controller.getQuestionsByExamId)
+);
 
 router.post(
   '/',

src/apis/v1/questions/service.ts

@@ -4,8 +4,10 @@ import QuestionModel from 'models/schema/Question';
 import { DEFAULT_PAGING } from 'utils/constants';
 import { logger } from 'utils/logger';
 import URLParams from 'utils/rest/urlparams';
+import { hideUserInfoIfRequired } from 'utils';
 
 import { QuestionDto, UpdateQuestionDto } from './dto/QuestionDto';
+import { ExamModel } from 'models';
 
 export const createQuestion = async function (input: QuestionDto, author: ObjectId) {
   try {
@@ -96,3 +98,25 @@ export const deleteQuestion = async function (id: string) {
     throw new HttpException(400, ErrorCodes.BAD_REQUEST.MESSAGE, ErrorCodes.BAD_REQUEST.CODE);
   }
 };
+
+export const getQuestionsByExamId = async function (examId: string) {
+  try {
+    const data = await QuestionModel.find({ exam_id: examId });
+
+    const exam = ExamModel.findOne({ _id: examId })
+      .populate('subject', '-is_deleted -created_at -updated_at -__v')
+      .populate('author', '-is_blocked -roles -created_at -updated_at -__v');
+    const resultAll = await Promise.all([data, exam]);
+
+    return {
+      questions: resultAll[0],
+      exam: {
+        ...resultAll[1].toObject(),
+        author: hideUserInfoIfRequired(resultAll[1].author),
+      },
+    };
+  } catch (error) {
+    logger.error(`Error while get questions by examId: ${error}`);
+    throw new HttpException(400, ErrorCodes.BAD_REQUEST.MESSAGE, ErrorCodes.BAD_REQUEST.CODE);
+  }
+};

src/models/schema/Document.ts

@@ -1,11 +1,11 @@
 import { model, Model, Schema } from 'mongoose';
 
 import { MODELS } from 'utils/constants/models';
-import Documents from 'models/types/Document';
+import DocumentType from 'models/types/Document';
 import { Content } from 'utils/types';
 import { softDeletePlugin } from 'models/SoftDeleteModel';
 
-const DocumentSchema = new Schema<Documents>(
+const DocumentSchema = new Schema<DocumentType>(
   {
     author: { type: Schema.Types.ObjectId, ref: MODELS.user, required: true },
     title: { type: String, required: true },
@@ -26,5 +26,5 @@ DocumentSchema.plugin(softDeletePlugin);
 
 DocumentSchema.index({ title: 1, description: 1 });
 
-const DocumentModel: Model<Document> = model<Document>(MODELS.document, DocumentSchema, MODELS.document);
+const DocumentModel: Model<DocumentType> = model<DocumentType>(MODELS.document, DocumentSchema, MODELS.document);
 export default DocumentModel;

src/models/types/Document.ts

@@ -4,7 +4,7 @@ import { Content } from 'utils/types';
 import Subject from './Subject';
 import User from './User';
 
-export default interface Documents extends Document {
+export default interface DocumentType extends Document {
   author: User;
   title: string;
   description: string;

src/utils/index.ts

@@ -6,7 +6,7 @@ export const hideUserInfoIfRequired = (user: User) => {
   }
 
   return {
-    _id: user._id,
+    _id: user?._id,
     nickname: user?.nickname,
   };
 };