Backend

backend/package.json

@@ -36,10 +36,10 @@
     "class-validator": "^0.14.0",
     "cloudinary": "^1.33.0",
     "mongoose": "^6.9.0",
+    "multer": "^1.4.5-lts.1",
     "passport": "^0.6.0",
     "passport-jwt": "^4.0.1",
     "passport-local": "^1.0.0",
-    "multer": "^1.4.5-lts.1",
     "reflect-metadata": "^0.1.13",
     "rxjs": "^7.2.0",
     "swagger-ui-express": "^4.6.0"
@@ -53,6 +53,7 @@
     "@types/jest": "29.2.4",
     "@types/multer": "^1.4.7",
     "@types/node": "18.11.18",
+    "@types/passport-jwt": "^3.0.8",
     "@types/passport-local": "^1.0.35",
     "@types/supertest": "^2.0.11",
     "@typescript-eslint/eslint-plugin": "^5.0.0",

backend/src/admin/admin.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { AdminController } from './controller/admin.controller';
+import { AdminSchema } from './schema/admin.schema';
+import { AdminService } from './service/admin.service';
+
+@Module({
+  imports:[
+    MongooseModule.forFeature([{name:"Admin",schema:AdminSchema}])],
+  controllers: [AdminController],
+  providers: [AdminService]
+})
+export class AdminModule {}

backend/src/admin/controller/admin.controller.ts

@@ -0,0 +1,45 @@
+import { Admin } from '../schema/admin.schema';
+import { AdminService } from '../service/admin.service';
+import {
+  Controller,
+  Post,
+  Body,
+  Get,
+  Delete,
+  Param,
+  Put,
+} from '@nestjs/common';
+import { CreateAdminDto } from '../dto/admin.dto';
+
+@Controller('admin')
+export class AdminController {
+  constructor(private readonly adminService: AdminService) {}
+
+  @Get()
+  findAll(): Promise<Admin[]> {
+    return this.adminService.findAll();
+  }
+
+  @Get(':id')
+  findOne(@Param() Param) {
+    return this.adminService.findOne(Param.id);
+  }
+
+  @Post()
+  create(@Body() createAdminDto: CreateAdminDto): Promise<Admin> {
+    return this.adminService.create(createAdminDto);
+  }
+
+  @Delete(':id')
+  delete(@Param() Param): Promise<Admin> {
+    return this.adminService.delete(Param.id);
+  }
+
+  @Put(':id')
+  update(
+    @Param('id') id,
+    @Body() updateAdmindto: CreateAdminDto,
+  ): Promise<Admin> {
+    return this.adminService.update(id, updateAdmindto);
+  }
+}

backend/src/admin/dto/admin.dto.ts

@@ -0,0 +1,36 @@
+import {
+  IsEmail,
+  IsNotEmpty,
+  IsString,
+  IsNumber,
+  IsBoolean,
+} from 'class-validator';
+export class CreateAdminDto {
+  @IsNotEmpty()
+  @IsString()
+  readonly firstname: string;
+
+  @IsNotEmpty()
+  @IsString()
+  readonly lastname: string;
+
+  @IsNotEmpty()
+  @IsString()
+  readonly username: string;
+
+  @IsNotEmpty()
+  @IsString()
+  readonly role: string;
+
+  @IsNotEmpty()
+  @IsString()
+  readonly password: string;
+
+  @IsNotEmpty()
+  @IsBoolean()
+  readonly status: boolean;
+
+  @IsNotEmpty()
+  @IsString()
+  readonly email: string;
+}

backend/src/admin/interface/admin.interface.ts

@@ -0,0 +1,10 @@
+export interface Admin {
+    id?:string;
+    firstname: string,
+    lastname: string,
+    username:string; 
+    password:string;  
+    email:string;
+    role:string;  
+    status: string;
+}

backend/src/admin/schema/admin.schema.ts

@@ -0,0 +1,20 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+
+@Schema({ timestamps: true})
+export class Admin {
+  @Prop({ required: true })
+  firstname: string;
+  @Prop({ required: true })
+  lastname: string;
+  @Prop({ required: true })
+  username: string;
+  @Prop({ required: true })
+  email: string;
+  @Prop({ required: true , default:false})
+  status: boolean;
+  @Prop({ required: true })
+  role: string;
+  @Prop({ required: true })
+  password: string;
+}
+export const AdminSchema = SchemaFactory.createForClass(Admin);

backend/src/admin/service/admin.service.ts

@@ -0,0 +1,55 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { Admin } from '../schema/admin.schema';
+
+@Injectable()
+export class AdminService {
+    constructor( @InjectModel("Admin") private adminModel : Model<Admin>){}
+    async findAll():Promise<Admin[]>{
+      try{
+
+        return await this.adminModel.find();
+      }
+      catch (err){
+        throw err;
+      }
+
+      }
+    async findOne(id:string):Promise<Admin>{
+        try{
+          return await this.adminModel.findOne({_id:id});
+        }
+        catch (err){
+          throw err
+      }
+      }
+
+    async create(admin:Admin):Promise<Admin>{
+        try{
+          const new_admin= new this.adminModel(admin);
+          return await new_admin.save();
+        }
+        catch (err){
+          throw err;
+      }
+      }
+    async delete(id:string):Promise<Admin>{
+        try{
+          return await this.adminModel.findByIdAndDelete({_id:id})
+        }
+        catch (err){
+          throw err;
+      }
+      }
+
+    async update(id:string, admin:Admin):Promise<Admin>{
+        try{
+          return await this.adminModel.findByIdAndUpdate(id,admin,{new:true})
+        }
+        catch (err){
+            throw err;
+      }
+      }
+
+}

backend/src/app.module.ts

@@ -1,17 +1,34 @@
 import { Module } from '@nestjs/common';
 import { AppController } from './app.controller';
 import { AppService } from './app.service';
-import { ReportsModule } from './reports/reports.module';
 import { MongooseModule } from '@nestjs/mongoose';
+import { AuthModule } from './auth/auth.module';
+import { UserModule } from './user/user.module';
+import { ReportsModule } from './reports/reports.module';
 import { RatingsModule } from './ratings/ratings.module';
+import { CoursesModule } from './courses/courses.module';
+import { InstructorsModule } from './instructors/instructors.module';
+import { AdminModule } from './admin/admin.module';
+import { DepartmentModule } from './department/department.module';
+import { CommentModule } from './comment/comment.module';
 
 @Module({
   imports: [
-    MongooseModule.forRoot('mongodb://localhost:27017', {
-      dbName: 'RateTheInstructor',
-    }),
+    MongooseModule.forRoot(
+      'mongodb+srv://amanuel:test1234@cluster0.8yo5agg.mongodb.net/?retryWrites=true&w=majority',
+      {
+        dbName: 'RateTheInstructor',
+      },
+    ),
     ReportsModule,
     RatingsModule,
+    AdminModule,
+    AuthModule,
+    UserModule,
+    CoursesModule,
+    InstructorsModule,
+    DepartmentModule,
+    CommentModule,
   ],
   controllers: [AppController],
   providers: [AppService],

backend/src/app.service.ts

@@ -1,6 +1,3 @@
 import { Injectable } from '@nestjs/common';
-
 @Injectable()
-export class AppService {
-
-}
+export class AppService {}

backend/src/auth/auth.module.ts

@@ -0,0 +1,19 @@
+import { Module } from '@nestjs/common';
+import { AuthController } from './controllers/auth/auth.controller';
+import { AuthService } from './services/auth/auth.service';
+import { JwtModule, JwtService } from '@nestjs/jwt';
+import { PassportModule } from '@nestjs/passport';
+import { JwtStrategy } from './strategies/jwt.strategy';
+
+@Module({
+  imports: [
+    JwtModule.register({
+      secret: 'SECRET',
+      signOptions: { expiresIn: '60s' },
+    }),
+    PassportModule,
+  ],
+  controllers: [AuthController],
+  providers: [AuthService, JwtStrategy],
+})
+export class AuthModule {}

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

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

backend/src/auth/controllers/auth/auth.controller.ts

@@ -0,0 +1,29 @@
+import { Controller, Post, Body, UseGuards, Get, Req } from '@nestjs/common';
+import { AuthGuard } from '@nestjs/passport';
+import { Request } from 'express';
+import { AuthService } from 'src/auth/services/auth/auth.service';
+import { CreateUserDto } from 'src/user/dto/user.dto';
+
+@Controller('auth')
+export class AuthController {
+  constructor(private authService: AuthService) {}
+
+  @Post('/login')
+  async login(@Body() loginData) {
+    return this.authService.login(loginData);
+  }
+  @Post('/signup')
+  async signup(@Body() authDto: CreateUserDto) {
+    return this.authService.signup(authDto);
+  }
+  @Post('/logout')
+  async logout() {
+    return this.authService.logout();
+  }
+
+  @UseGuards(AuthGuard('jwt'))
+  @Get('/protected')
+  async protected(@Req() req: Request) {
+    return req.user;
+  }
+}

backend/src/auth/guards/roles.guard.ts

@@ -0,0 +1,24 @@
+import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { SetMetadata } from '@nestjs/common';
+
+export const Roles = (...roles: string[]) => SetMetadata('roles', roles);
+
+@Injectable()
+export class RoleGuard implements CanActivate {
+  constructor(private readonly reflector: Reflector) {}
+
+  canActivate(context: ExecutionContext): boolean {
+    const roles = this.reflector.get<string[]>('roles', context.getHandler());
+    if (!roles) {
+      return true;
+    }
+    const request = context.switchToHttp().getRequest();
+    const user = request.user;
+    return this.matchRoles(roles, user.role);
+  }
+
+  private matchRoles(roles: string[], userRole: string) {
+    return roles.includes(userRole);
+  }
+}

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

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