nsc-events_3_39_update-user-dto-refactor

src/user/controllers/user/user.controller.ts

@@ -6,28 +6,19 @@ import {
   Get,
   Param,
   Patch,
-  Post,
-  Req,
   UseGuards,
 } from '@nestjs/common';
 import { UserService } from '../../services/user/user.service';
-import { Role } from '../../schemas/user.model';
-import { CreateUserDto } from '../../dto/create-user.dto';
+import { UserDocument } from '../../schemas/user.model';
 import { AuthGuard } from '@nestjs/passport';
+import { UpdateUserDto } from '../../dto/update-user.dto';
 
 // ================== User admin routes ======================== \\
 @Controller('users')
 @UseGuards(AuthGuard('jwt'))
 export class UserController {
   constructor(private readonly userService: UserService) {}
 
-  // ----------------- Add User ------------------------------- \\
-  @Post('new')
-  async adminAddUser(@Body() createUserDto: CreateUserDto, @Req() req: any) {
-    const generatedId = await this.userService.newUser(createUserDto);
-    return { id: generatedId };
-  }
-
   // ----------------- Get Users ----------------------------- \\
   @Get('')
   async getAllUsers() {
@@ -48,18 +39,13 @@ export class UserController {
 
   // ----------------- Update User --------------------------- \\
   @Patch('update/:id')
-  async updateUser(
-    @Param('id') id: string,
-    @Body('name') name: string,
-    @Body('email') email: string,
-    @Body('role') role: Role,
-  ) {
-    await this.userService.updateUser(id, name, email, role);
+  async updateUser(@Param('id') id: string, @Body() userDto: UpdateUserDto) {
+    return await this.userService.updateUser(id, userDto as UserDocument);
   }
 
   // ----------------- Delete User --------------------------- //
   @Delete('remove/:id')
-  async adminDeleteUser(@Param('id') id: string, @Req() req: any) {
+  async adminDeleteUser(@Param('id') id: string) {
     await this.userService.removeUser(id);
   }
 

src/user/dto/update-user.dto.ts

@@ -0,0 +1,20 @@
+import { IsEmpty, IsEnum, IsOptional, IsString } from 'class-validator';
+import { Role } from '../schemas/user.model';
+
+export class UpdateUserDto {
+  @IsOptional()
+  @IsString()
+  readonly name: string;
+
+  @IsOptional()
+  @IsEmpty({ message: 'Cannot update email here' })
+  readonly email: string;
+
+  @IsOptional()
+  @IsEmpty({ message: 'Cannot update password here' })
+  readonly password: string;
+
+  @IsOptional()
+  @IsEnum(Role)
+  readonly role: Role;
+}

src/user/services/user/user.service.ts

@@ -1,45 +1,20 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import {
   BadRequestException,
-  ForbiddenException,
   HttpException,
   HttpStatus,
   Injectable,
-  NotFoundException,
-  UnauthorizedException,
 } from '@nestjs/common';
-import * as bcrypt from 'bcryptjs';
 import { Model } from 'mongoose';
-import { Role, UserDocument } from '../../schemas/user.model';
+import { UserDocument } from '../../schemas/user.model';
 import { InjectModel } from '@nestjs/mongoose';
-import { CreateUserDto } from 'src/user/dto/create-user.dto';
-import { log } from 'console';
 
 @Injectable()
 export class UserService {
   constructor(@InjectModel('User') private userModel: Model<UserDocument>) {
     // User defined in user.module.ts
   }
 
-  // ----------------- Add user ----------------- \\
-  async newUser(createUserDto: CreateUserDto): Promise<string> {
-    const { name, email, password, role } = createUserDto;
-    const hashedPassword = await bcrypt.hash(password, 10);
-    const newUser = new this.userModel({
-      name,
-      email,
-      password: hashedPassword,
-      role,
-    });
-    try {
-      const result = await newUser.save();
-      return result._id;
-    } catch (error) {
-      log(error);
-      return error;
-    }
-  }
-
   // ----------------- Get all users ----------------- \\
   async getAllUsers(): Promise<any> {
     //fix: Use serialization to mask password, so we don't have to transform the data
@@ -84,30 +59,38 @@ export class UserService {
     if (!user) {
       throw new HttpException('User not found!', 404);
     }
-
-    return user;
+    return {
+      id: user.id,
+      name: user.name,
+      email: user.email,
+      role: user.role,
+    } as UserDocument;
   }
 
   // ----------------- Update user ----------------- \\
-  async updateUser(id: string, name: string, email: string, role: Role) {
-    const updatedUser = await this.userModel.findById(id).exec();
-    if (!updatedUser) {
-      throw new NotFoundException('User not found');
-    }
-
-    if (name) {
-      updatedUser.name = name;
+  async updateUser(id: string, user: UserDocument) {
+    // we may want to check if id is a valid id, if you remove/add a character, it returns a 500 error
+    if (user === null) {
+      throw new BadRequestException(`Updated User not supplied`);
     }
-    if (email) {
-      updatedUser.email = email;
-    }
-    if (role) {
-      updatedUser.role = role;
+    const updatedUser = await this.userModel
+      .findByIdAndUpdate(id, user, {
+        new: true,
+        runValidators: true,
+      })
+      .exec();
+    if (!updatedUser) {
+      throw new HttpException(
+        `User with id ${id} not found`,
+        HttpStatus.NOT_FOUND,
+      );
     }
-
-    const updated = await updatedUser.save();
-    console.log(updated);
-    return updated;
+    return {
+      id: updatedUser.id,
+      name: updatedUser.name,
+      email: updatedUser.email,
+      role: updatedUser.role,
+    } as UserDocument;
   }
 
   // ----------------- Delete user ----------------- \\