CRUD: Review - Comment - Component

package.json

@@ -35,8 +35,7 @@
     "morgan": "^1.10.0",
     "mysql": "^2.18.1",
     "mysql2": "^3.11.3",
-    "reflect-metadata": "^0.2.2",
-    "typeorm": "^0.3.20"
+    "reflect-metadata": "^0.2.2"
   },
   "devDependencies": {
     "@eslint/js": "^9.12.0",
@@ -62,6 +61,7 @@
     "supertest": "^7.0.0",
     "ts-node": "^10.9.2",
     "tsconfig-paths": "^4.2.0",
+    "typeorm": "^0.3.20",
     "typescript": "^5.6.2",
     "typescript-eslint": "^8.8.0"
   }

src/controller/comment.ts

@@ -0,0 +1,68 @@
+import { Request, Response } from 'express';
+import { CommentService } from '../service/comment';
+
+export class CommentController {
+  private commentService: CommentService;
+
+  constructor() {
+    this.commentService = new CommentService();
+  }
+
+  async getAllComments(req: Request, res: Response): Promise<void> {
+    try {
+      const comments = await this.commentService.getAllComments();
+      res.json(comments);
+    } catch (error) {
+      res.status(500).json({ message: 'Lỗi khi lấy danh sách bình luận', error });
+    }
+  }
+
+  async getCommentById(req: Request, res: Response): Promise<void> {
+    try {
+      const id = Number(req.params.id);
+      const comment = await this.commentService.getCommentById(id);
+      if (comment) {
+        res.json(comment);
+      } else {
+        res.status(404).json({ message: 'Không tìm thấy bình luận' });
+      }
+    } catch (error) {
+      res.status(500).json({ message: 'Lỗi khi lấy bình luận', error });
+    }
+  }
+
+  async createComment(req: Request, res: Response): Promise<void> {
+    try {
+      const commentData = req.body;
+      const newComment = await this.commentService.createComment(commentData);
+      res.status(201).json(newComment);
+    } catch (error) {
+      res.status(500).json({ message: 'Lỗi khi tạo bình luận', error });
+    }
+  }
+
+  async updateComment(req: Request, res: Response): Promise<void> {
+    try {
+      const id = Number(req.params.id);
+      const commentData = req.body;
+      const updatedComment = await this.commentService.updateComment(id, commentData);
+      if (updatedComment) {
+        res.json(updatedComment);
+      } else {
+        res.status(404).json({ message: 'Không tìm thấy bình luận để cập nhật' });
+      }
+    } catch (error) {
+      res.status(500).json({ message: 'Lỗi khi cập nhật bình luận', error });
+    }
+  }
+
+  async deleteComment(req: Request, res: Response): Promise<void> {
+    try {
+      const id = Number(req.params.id);
+      await this.commentService.deleteComment(id);
+      res.status(204).send();
+    } catch (error) {
+      res.status(500).json({ message: 'Lỗi khi xóa bình luận', error });
+    }
+  }
+}

src/controller/component.ts

@@ -0,0 +1,68 @@
+import { Request, Response } from 'express';
+import { ComponentService } from '../service/component';
+
+export class ComponentController {
+  private componentService: ComponentService;
+
+  constructor() {
+    this.componentService = new ComponentService();
+  }
+
+  async getAllComponents(req: Request, res: Response): Promise<void> {
+    try {
+      const components = await this.componentService.getAllComponents();
+      res.json(components);
+    } catch (error) {
+      res.status(500).json({ message: 'Lỗi khi lấy danh sách thành phần', error });
+    }
+  }
+
+  async getComponentById(req: Request, res: Response): Promise<void> {
+    try {
+      const id = Number(req.params.id);
+      const component = await this.componentService.getComponentById(id);
+      if (component) {
+        res.json(component);
+      } else {
+        res.status(404).json({ message: 'Không tìm thấy thành phần' });
+      }
+    } catch (error) {
+      res.status(500).json({ message: 'Lỗi khi lấy thành phần', error });
+    }
+  }
+
+  async createComponent(req: Request, res: Response): Promise<void> {
+    try {
+      const componentData = req.body;
+      const newComponent = await this.componentService.createComponent(componentData);
+      res.status(201).json(newComponent);
+    } catch (error) {
+      res.status(500).json({ message: 'Lỗi khi tạo thành phần', error });
+    }
+  }
+
+  async updateComponent(req: Request, res: Response): Promise<void> {
+    try {
+      const id = Number(req.params.id);
+      const componentData = req.body;
+      const updatedComponent = await this.componentService.updateComponent(id, componentData);
+      if (updatedComponent) {
+        res.json(updatedComponent);
+      } else {
+        res.status(404).json({ message: 'Không tìm thấy thành phần để cập nhật' });
+      }
+    } catch (error) {
+      res.status(500).json({ message: 'Lỗi khi cập nhật thành phần', error });
+    }
+  }
+
+  async deleteComponent(req: Request, res: Response): Promise<void> {
+    try {
+      const id = Number(req.params.id);
+      await this.componentService.deleteComponent(id);
+      res.status(204).send();
+    } catch (error) {
+      res.status(500).json({ message: 'Lỗi khi xóa thành phần', error });
+    }
+  }
+}

src/controller/review.ts

@@ -0,0 +1,68 @@
+import { Request, Response } from 'express';
+import { ReviewService } from '../service/review';
+
+export class ReviewController {
+  private reviewService: ReviewService;
+
+  constructor() {
+    this.reviewService = new ReviewService();
+  }
+
+  async getAllReviews(req: Request, res: Response): Promise<void> {
+    try {
+      const reviews = await this.reviewService.getAllReviews();
+      res.json(reviews);
+    } catch (error) {
+      res.status(500).json({ message: 'Lỗi khi lấy danh sách đánh giá', error });
+    }
+  }
+
+  async getReviewById(req: Request, res: Response): Promise<void> {
+    try {
+      const id = Number(req.params.id);
+      const review = await this.reviewService.getReviewById(id);
+      if (review) {
+        res.json(review);
+      } else {
+        res.status(404).json({ message: 'Không tìm thấy đánh giá' });
+      }
+    } catch (error) {
+      res.status(500).json({ message: 'Lỗi khi lấy đánh giá', error });
+    }
+  }
+
+  async createReview(req: Request, res: Response): Promise<void> {
+    try {
+      const reviewData = req.body;
+      const newReview = await this.reviewService.createReview(reviewData);
+      res.status(201).json(newReview);
+    } catch (error) {
+      res.status(500).json({ message: 'Lỗi khi tạo đánh giá', error });
+    }
+  }
+
+  async updateReview(req: Request, res: Response): Promise<void> {
+    try {
+      const id = Number(req.params.id);
+      const reviewData = req.body;
+      const updatedReview = await this.reviewService.updateReview(id, reviewData);
+      if (updatedReview) {
+        res.json(updatedReview);
+      } else {
+        res.status(404).json({ message: 'Không tìm thấy đánh giá để cập nhật' });
+      }
+    } catch (error) {
+      res.status(500).json({ message: 'Lỗi khi cập nhật đánh giá', error });
+    }
+  }
+
+  async deleteReview(req: Request, res: Response): Promise<void> {
+    try {
+      const id = Number(req.params.id);
+      await this.reviewService.deleteReview(id);
+      res.status(204).send();
+    } catch (error) {
+      res.status(500).json({ message: 'Lỗi khi xóa đánh giá', error });
+    }
+  }
+}

src/index.ts

@@ -1,10 +1,23 @@
 import 'reflect-metadata';
-import { AppDataSource } from './repos/db';
+import { AppDataSource } from './repos/db';  
+import express from 'express';
+import routes from './route/index';
+
+const app = express();
+
+app.use(express.json());
 
 AppDataSource.initialize()
   .then(() => {
     console.log('Data Source has been initialized!');
+
+    const host = 'localhost';
+    const port = 3000;
+
+    app.listen(port, host, () => {
+      console.log(`Server is running at http://${host}:${port}`);
+    });
+
+    app.use('/', routes);
   })
-  .catch((error: unknown) => {
-    console.log('Error during Data Source initialization:', error);
-  });
+  .catch((error) => console.log('Error during Data Source initialization:', error));

src/route/comment.ts

@@ -0,0 +1,13 @@
+import { Router } from 'express';
+import { CommentController } from '../controller/comment';
+
+const router = Router();
+const commentController = new CommentController();
+
+router.get('/', (req, res) => commentController.getAllComments(req, res));
+router.get('/:id', (req, res) => commentController.getCommentById(req, res));
+router.post('/', (req, res) => commentController.createComment(req, res));
+router.put('/:id', (req, res) => commentController.updateComment(req, res));
+router.delete('/:id', (req, res) => commentController.deleteComment(req, res));
+
+export default router;

src/route/component.ts

@@ -0,0 +1,13 @@
+import { Router } from 'express';
+import { ComponentController } from '../controller/component';
+
+const router = Router();
+const componentController = new ComponentController();
+
+router.get('/', (req, res) => componentController.getAllComponents(req, res));
+router.get('/:id', (req, res) => componentController.getComponentById(req, res));
+router.post('/', (req, res) => componentController.createComponent(req, res));
+router.put('/:id', (req, res) => componentController.updateComponent(req, res));
+router.delete('/:id', (req, res) => componentController.deleteComponent(req, res));
+
+export default router;

src/route/index.ts

@@ -0,0 +1,12 @@
+import { Router } from 'express';
+import commentRoutes from './comment';
+import componentRoutes from './component';
+import reviewRoutes from './review';
+
+const router = Router();
+
+router.use('/comments', commentRoutes);      
+router.use('/components', componentRoutes); 
+router.use('/reviews', reviewRoutes);       
+
+export default router;

src/route/review.ts

@@ -0,0 +1,13 @@
+import { Router } from 'express';
+import { ReviewController } from '../controller/review';
+
+const router = Router();
+const reviewController = new ReviewController();
+
+router.get('/', (req, res) => reviewController.getAllReviews(req, res));
+router.get('/:id', (req, res) => reviewController.getReviewById(req, res));
+router.post('/', (req, res) => reviewController.createReview(req, res));
+router.put('/:id', (req, res) => reviewController.updateReview(req, res));
+router.delete('/:id', (req, res) => reviewController.deleteReview(req, res));
+
+export default router;

src/service/comment.ts

@@ -0,0 +1,38 @@
+import { Repository } from 'typeorm';
+import { Comment } from '../entity/Comment';
+import { AppDataSource } from '../repos/db';
+
+export class CommentService {
+  private commentRepository: Repository<Comment>;
+
+  constructor() {
+    this.commentRepository = AppDataSource.getRepository(Comment);
+  }
+
+  async getAllComments(): Promise<Comment[]> {
+    return this.commentRepository.find({
+      relations: ['review'],
+    });
+  }
+
+  async getCommentById(id: number): Promise<Comment | null> {
+    return this.commentRepository.findOne({
+      where: { id },
+      relations: ['review'],
+    });
+  }
+
+  async createComment(commentData: Partial<Comment>): Promise<Comment> {
+    const comment = this.commentRepository.create(commentData);
+    return this.commentRepository.save(comment);
+  }
+
+  async updateComment(id: number, commentData: Partial<Comment>): Promise<Comment | null> {
+    await this.commentRepository.update(id, commentData);
+    return this.getCommentById(id);
+  }
+
+  async deleteComment(id: number): Promise<void> {
+    await this.commentRepository.delete(id);
+  }
+}

src/service/component.ts

@@ -0,0 +1,38 @@
+import { Repository } from 'typeorm';
+import { Component } from '../entity/Component';
+import { AppDataSource } from '../repos/db';
+
+export class ComponentService {
+  private componentRepository: Repository<Component>;
+
+  constructor() {
+    this.componentRepository = AppDataSource.getRepository(Component);
+  }
+
+  async getAllComponents(): Promise<Component[]> {
+    return this.componentRepository.find({
+      relations: ['lesson'],
+    });
+  }
+
+  async getComponentById(id: number): Promise<Component | null> {
+    return this.componentRepository.findOne({
+      where: { id },
+      relations: ['lesson'],
+    });
+  }
+
+  async createComponent(componentData: Partial<Component>): Promise<Component> {
+    const component = this.componentRepository.create(componentData);
+    return this.componentRepository.save(component);
+  }
+
+  async updateComponent(id: number, componentData: Partial<Component>): Promise<Component | null> {
+    await this.componentRepository.update(id, componentData);
+    return this.getComponentById(id);
+  }
+
+  async deleteComponent(id: number): Promise<void> {
+    await this.componentRepository.delete(id);
+  }
+}