[Backend] Create Course Module

backend/src/app.module.ts

@@ -1,11 +1,13 @@
 import { Module } from '@nestjs/common';
 import { AppController } from './app.controller';
 import { AppService } from './app.service';
+import { CoursesModule } from './courses/courses.module';
 import { ReportsModule } from './reports/reports.module';
 import { MongooseModule } from '@nestjs/mongoose';
 
 @Module({
   imports: [
+    CoursesModule,
     MongooseModule.forRoot('mongodb://localhost:27017', {
       dbName: 'RateTheInstructor',
     }),

backend/src/courses/controllers/courses/courses.controller.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { CoursesController } from './courses.controller';
+
+describe('CoursesController', () => {
+  let controller: CoursesController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [CoursesController],
+    }).compile();
+
+    controller = module.get<CoursesController>(CoursesController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

backend/src/courses/controllers/courses/courses.controller.ts

@@ -0,0 +1,35 @@
+import { Controller, Get, Post, Delete } from '@nestjs/common';
+import { Body, Param, Patch } from '@nestjs/common/decorators';
+import { CreateCourseDto } from 'src/courses/dtos/create-courseDto.dto';
+import { UpdateCourseDto } from 'src/courses/dtos/update-courseDto';
+
+import { CoursesService } from 'src/courses/services/courses/courses.service';
+
+@Controller('courses')
+export class CoursesController {
+  constructor(private readonly courseService: CoursesService) {}
+  @Get()
+  getCourses() {
+    return this.courseService.getCourses();
+  }
+
+  @Post()
+  createCourse(@Body() courseDto: CreateCourseDto) {
+    return this.courseService.createCourse(courseDto);
+  }
+  @Patch(':id')
+  updateCourse(
+    @Param('id') id: string,
+    @Body() updateCourseDto: UpdateCourseDto,
+  ) {
+    return this.courseService.updateCourse(id, updateCourseDto);
+  }
+  @Delete(':id')
+  deleteCourse(@Param('id') id: string) {
+    return this.courseService.deleteCourse(id);
+  }
+  @Get(':id')
+  getUserById(@Param('id') id: string) {
+    return this.courseService.getUserById(id);
+  }
+}

backend/src/courses/courses.module.ts

@@ -0,0 +1,14 @@
+import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { CoursesController } from './controllers/courses/courses.controller';
+import { Course, CourseSchema } from './schemas/course.schema';
+import { CoursesService } from './services/courses/courses.service';
+
+@Module({
+  imports: [
+    MongooseModule.forFeature([{ name: Course.name, schema: CourseSchema }]),
+  ],
+  controllers: [CoursesController],
+  providers: [CoursesService],
+})
+export class CoursesModule {}

backend/src/courses/dtos/create-courseDto.dto.ts

@@ -0,0 +1,4 @@
+export class CreateCourseDto {
+  name: string;
+  code: string;
+}

backend/src/courses/dtos/update-courseDto.ts

@@ -0,0 +1,7 @@
+import { CreateCourseDto } from './create-courseDto.dto';
+import { OmitType } from '@nestjs/swagger';
+
+export class UpdateCourseDto extends OmitType(CreateCourseDto, [
+  'name',
+  'code',
+] as const) {}

backend/src/courses/interfaces/course.interface.ts

@@ -0,0 +1,6 @@
+import { Document } from 'mongoose';
+
+export interface ICourse extends Document {
+  name: string;
+  code: string;
+}

backend/src/courses/schemas/course.schema.ts

@@ -0,0 +1,11 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+
+@Schema({ timestamps: true })
+export class Course {
+  @Prop({ required: true })
+  name: string;
+  @Prop({ required: true })
+  code: string;
+}
+
+export const CourseSchema = SchemaFactory.createForClass(Course);

backend/src/courses/services/courses/courses.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { CoursesService } from './courses.service';
+
+describe('CoursesService', () => {
+  let service: CoursesService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [CoursesService],
+    }).compile();
+
+    service = module.get<CoursesService>(CoursesService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

backend/src/courses/services/courses/courses.service.ts

@@ -0,0 +1,85 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { BadRequestException } from '@nestjs/common/exceptions';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { CreateCourseDto } from 'src/courses/dtos/create-courseDto.dto';
+import { UpdateCourseDto } from 'src/courses/dtos/update-courseDto';
+import { ICourse } from 'src/courses/interfaces/course.interface';
+import { Course } from 'src/courses/schemas/course.schema';
+
+@Injectable()
+export class CoursesService {
+  constructor(@InjectModel(Course.name) private courseModel: Model<ICourse>) {}
+
+  async getCourses(): Promise<ICourse[]> {
+    let courses: ICourse[];
+    try {
+      courses = await this.courseModel.find();
+    } catch (err) {
+      throw err;
+    }
+    if (!courses) {
+      throw new NotFoundException('Courses Not Found');
+    }
+    return courses;
+  }
+  async createCourse(courseDto: CreateCourseDto): Promise<ICourse> {
+    const course = new this.courseModel(courseDto);
+    let savedCourse: ICourse;
+    try {
+      savedCourse = await course.save();
+    } catch (err) {
+      throw err;
+    }
+
+    if (!savedCourse) {
+      throw new BadRequestException("Course can't be created");
+    }
+    return savedCourse;
+  }
+
+  async updateCourse(
+    id: string,
+    updateCourseDto: UpdateCourseDto,
+  ): Promise<ICourse> {
+    let updatedcourse: ICourse;
+    try {
+      updatedcourse = await this.courseModel.findByIdAndUpdate(
+        { id },
+        { updateCourseDto },
+        { new: true },
+      );
+    } catch (err) {
+      throw err;
+    }
+    if (!updatedcourse) {
+      throw new NotFoundException('course not found');
+    }
+    return updatedcourse;
+  }
+  async deleteCourse(id: string): Promise<ICourse> {
+    let deletedCourse: ICourse;
+    try {
+      deletedCourse = await this.courseModel.findByIdAndDelete(id);
+    } catch (err) {
+      throw err;
+    }
+    if (!deletedCourse) {
+      throw new NotFoundException('Course Not Found');
+    }
+    return deletedCourse;
+  }
+  async getUserById(id: string): Promise<ICourse> {
+    let course: ICourse;
+    try {
+      course = await this.courseModel.findById(id);
+    } catch (err) {
+      console.log(err);
+      throw err.reason;
+    }
+    if (!course) {
+      throw new NotFoundException('Course Not Found');
+    }
+    return course;
+  }
+}

backend/src/main.ts

@@ -1,3 +1,4 @@
+import { ValidationPipe } from '@nestjs/common';
 import { NestFactory } from '@nestjs/core';
 import { AppModule } from './app.module';
 import { ValidationPipe } from '@nestjs/common';