Implement User/Course CRUD

src/controllers/course.controller.ts

@@ -0,0 +1,75 @@
+import { Request, Response } from 'express';
+import asyncHandler from 'express-async-handler';
+import { getAllCourses, 
+  getCourseById, 
+  createCourse, 
+  deleteCourse, 
+  updateCourse, 
+} from '../services/course.service';
+
+export const courseList = 
+    asyncHandler(async (req: Request, res: Response) => {
+      const courses = await getAllCourses();
+      res.status(200).json(courses);
+    });
+
+export const courseDetails = 
+    asyncHandler(async (req: Request, res: Response) => {
+      const courseId = parseInt(req.params.id);
+      const course = await getCourseById(courseId);
+
+      if (course) {
+        res.status(200).json(course);
+      } else {
+        res.status(404).json({ message: 'Course not found' });
+      }
+    });
+
+export const createCourseGet = 
+    asyncHandler(async (req: Request, res: Response) => {
+      res.status(200).json({ message: 'Provide course data to create a course' });
+    });
+
+export const createCoursePost = 
+    asyncHandler(async (req: Request, res: Response) => {
+      const courseData = req.body; 
+      const newCourse = await createCourse(courseData);
+      res.status(201).json(newCourse);
+    });
+
+export const deleteCourseGet = 
+    asyncHandler(async (req: Request, res: Response) => {
+      res.status(200).json({ message: 'Confirm course deletion' });
+    });
+
+export const deleteCoursePost = 
+    asyncHandler(async (req: Request, res: Response) => {
+      const courseId = parseInt(req.params.id);
+      const course = await getCourseById(courseId);
+
+      if (course) {
+        await deleteCourse(course);
+        res.status(200).json({ message: 'Course deleted' });
+      } else {
+        res.status(404).json({ message: 'Course not found' });
+      }
+    });
+
+export const updateCourseGet = 
+    asyncHandler(async (req: Request, res: Response) => {
+      res.status(200).json({ message: 'Provide updated course data' });
+    });
+
+export const updateCoursePost = 
+    asyncHandler(async (req: Request, res: Response) => {
+      const courseId = parseInt(req.params.id);
+      const course = await getCourseById(courseId);
+
+      if (course) {
+        const updatedData = req.body;
+        const updatedCourse = await updateCourse(course, updatedData);
+        res.status(200).json(updatedCourse);
+      } else {
+        res.status(404).json({ message: 'Course not found' });
+      }
+    });

src/controllers/user.controller.ts

@@ -0,0 +1,85 @@
+import { getAllUsers, 
+    getUserById, 
+    createUser, 
+    updateUser, 
+    deleteUser 
+} from '../services/user.service';
+import { Request, Response } from 'express';
+import asyncHandler from 'express-async-handler';
+
+export const userList = 
+    asyncHandler(async (req: Request, res: Response) => {
+        const users = await getAllUsers();
+        res.status(200).json(users); 
+});
+
+export const userDetails = 
+    asyncHandler(async (req: Request, res: Response) => {
+        const userId = parseInt(req.params.id); 
+        const user = await getUserById(userId);
+
+        if (user) {
+            res.status(200).json(user); 
+        } else {
+            res.status(404).json({ message: 'User not found' }); 
+        }
+});
+
+export const userCreateGet = 
+    asyncHandler(async (req: Request, res: Response) => {
+        res.status(200).json({ message: 'Display user creation form' }); 
+});
+
+export const userCreatePost = 
+    asyncHandler(async (req: Request, res: Response) => {
+        const newUserData = req.body; 
+        const newUser = await createUser(newUserData);
+        res.status(201).json(newUser); 
+});
+
+export const userDeleteGet = 
+    asyncHandler(async (req: Request, res: Response) => {
+        const userId = parseInt(req.params.id); 
+        const user = await getUserById(userId);
+
+        if (user) {
+            res.status(200).json({ message: 'Confirm deletion of user', user }); 
+        } else {
+            res.status(404).json({ message: 'User not found' }); 
+        }
+});
+
+export const userDeletePost = 
+    asyncHandler(async (req: Request, res: Response) => {
+        const userId = parseInt(req.params.id); 
+        await deleteUser(userId); 
+        res.status(204).send(); 
+});
+
+export const userUpdateGet = 
+    asyncHandler(async (req: Request, res: Response) => {
+        const userId = parseInt(req.params.id); 
+        const user = await getUserById(userId);
+
+        if (user) {
+            res.status(200).json(user); 
+        } else {
+            res.status(404).json({ message: 'User not found' }); 
+        }
+});
+
+export const userUpdatePost = 
+    asyncHandler(async (req: Request, res: Response) => {
+        const userToUpdate = await getUserById(parseInt(req.params.id));
+        const updatedUserData = req.body; 
+        if (!userToUpdate) {
+            throw new Error('User not found');
+        }
+        const updatedUser = await updateUser(userToUpdate, updatedUserData);
+
+        if (updatedUser) {
+            res.status(200).json(updatedUser); 
+        } else {
+            res.status(404).json({ message: 'User not found' }); 
+        }
+});

src/route/course.routes.ts

@@ -0,0 +1,22 @@
+import { Router } from 'express';
+import * as courseController from '../controllers/course.controller';
+
+const router: Router = Router();
+
+router.get('/', courseController.courseList);
+
+router.get('/create', courseController.createCourseGet);
+
+router.get('/:id', courseController.courseDetails);
+
+router.post('/create', courseController.createCoursePost);
+
+router.get('/:id/delete', courseController.deleteCourseGet);
+
+router.post('/:id/delete', courseController.deleteCoursePost);
+
+router.get('/:id/update', courseController.updateCourseGet);
+
+router.post('/:id/update', courseController.updateCoursePost);
+
+export default router;

src/route/index.ts

@@ -0,0 +1,13 @@
+import { Router } from 'express'
+import userRoutes from './user.routes'
+import courseRoutes from './course.routes'
+
+// **** Variables **** //
+const router = Router();
+
+/* GET home page. */
+router.use('/users', userRoutes)
+router.use('/courses', courseRoutes)
+
+// **** Export default **** //
+export default router;

src/route/user.routes.ts

@@ -0,0 +1,22 @@
+import { Router } from 'express';
+import * as userController from '../controllers/user.controller';
+
+const router: Router = Router();
+
+router.get('/', userController.userList);
+
+router.get('/create', userController.userCreateGet);
+
+router.get('/:id', userController.userDetails);
+
+router.post('/create', userController.userCreatePost);
+
+router.get('/:id/delete', userController.userDeleteGet);
+
+router.post('/:id/delete', userController.userDeletePost);
+
+router.get('/:id/update', userController.userUpdateGet);
+
+router.post('/:id/update', userController.userUpdatePost);
+
+export default router;

src/services/course.service.ts

@@ -0,0 +1,30 @@
+import { AppDataSource } from '../repos/db';
+import { Course } from '../entity/Course';
+
+const courseRepository = AppDataSource.getRepository(Course);
+
+export const getAllCourses = async () => {
+  return await courseRepository.find({
+    order: { name: 'ASC' },
+  });
+};
+
+export const getCourseById = async (id: number) => {
+  return await courseRepository.findOne({
+    where: { id: id },
+  });
+};
+
+export const createCourse = async (courseData: Partial<Course>) => {
+  const newCourse = courseRepository.create(courseData);
+  return await courseRepository.save(newCourse);
+};
+
+export const deleteCourse = async (course: Course) => {
+  return await courseRepository.remove(course);
+};
+
+export const updateCourse = async (course: Course, updatedData: Partial<Course>) => {
+  Object.assign(course, updatedData);
+  return await courseRepository.save(course);
+};

src/services/user.service.ts

@@ -0,0 +1,29 @@
+import { AppDataSource } from '../repos/db';
+import { User } from '../entity/User';
+
+const userRepository = AppDataSource.getRepository(User);
+
+export const getAllUsers = async () => {
+  return await userRepository.find({
+    order: { name: 'ASC'},
+  });
+};
+
+export const getUserById = async (id: number) => {
+  return await userRepository.findOne({
+    where: { id: id },
+  });
+};
+
+export const createUser = async (userData: Partial<User>) => {
+  return await userRepository.save(new User(userData));
+};
+
+export const updateUser = async (userToUpdate: User, userData: Partial<User>) => {
+  Object.assign(userToUpdate, userData);
+  return await userRepository.save(userToUpdate);
+};
+
+export const deleteUser = async (id: number) => {
+  return await userRepository.delete(id);
+};