Update list of user and change roles to role in roles guard

backend/src/modules/authentication/authorization/roles.guard.ts

@@ -17,6 +17,6 @@ export class RolesGuard implements CanActivate {
       return true;
     }
     const { user } = context.switchToHttp().getRequest();
-    return requiredRoles.some((role) => user.roles.includes(role));
+    return requiredRoles.some((role) => user.role.includes(role));
   }
 }

backend/src/modules/user/dto/update-users.dto.ts

@@ -0,0 +1,24 @@
+import { IsEmail, IsMobilePhone, IsOptional, IsString } from "class-validator";
+
+export class UpdateUsersDto {
+
+  @IsString()
+  id: string;
+
+  @IsString()
+  @IsOptional()
+  full_name?: string;
+
+  @IsEmail()
+  @IsOptional()
+  email?: string;
+
+  @IsMobilePhone('vi-VN')
+  @IsOptional()
+  phone_number: string
+
+  @IsString()
+  @IsOptional()
+  password?: string;
+}
+

backend/src/modules/user/user.controller.ts

@@ -1,9 +1,10 @@
-import { Body, Controller, Get, Param, Post, Query, Request } from '@nestjs/common';
+import { Body, Controller, Get, Post, Put, Query, Request } from '@nestjs/common';
 import { UserService } from './user.service.js';
 import { UserEntity } from 'src/entities/user.entity.js';
 import { Roles } from '../authentication/authorization/roles.decorator.js';
 import { Role } from '../../common/enums/role.enum.js';
 import { Paginate, PaginateQuery } from 'nestjs-paginate';
+import { UpdateUsersDto } from './dto/update-users.dto.js';
 
 @Controller('users')
 export class UsersController {
@@ -31,6 +32,14 @@ export class UsersController {
       return this.usersService.updateUserById(userId, updateUserDto);
   }
 
+  @Put('updateList')
+  @Roles(Role.ADMIN)
+  async updateUsers(
+    @Body() updateUsersDto: UpdateUsersDto[],
+  ) {
+    return this.usersService.updateUsers(updateUsersDto);
+  }
+
   @Get('getAll')
   @Roles(Role.ADMIN, Role.AREA_MANAGER, Role.BRANCH_MANAGER)
   async findAllUser(@Paginate() query: PaginateQuery) {

backend/src/modules/user/user.service.ts

@@ -1,22 +1,13 @@
-import {
-  Body,
-  forwardRef,
-  Inject,
-  Injectable,
-  NotFoundException,
-} from '@nestjs/common';
+import { Body, forwardRef, HttpStatus, Inject, Injectable, NotFoundException } from '@nestjs/common';
 import { UserEntity } from '../../entities/user.entity.js';
 import { SignUpDto } from '../authentication/dto/sign-up.dto.js';
 import { UpdateUserDto } from './dto/update-user-dto.js';
 import { ValidateService } from '../../validate/validate.service.js';
 import * as bcrypt from 'bcrypt';
 import { JwtService } from '@nestjs/jwt';
-import {
-  FilterOperator,
-  paginate,
-  PaginateConfig,
-  PaginateQuery,
-} from 'nestjs-paginate';
+import { FilterOperator, paginate, PaginateConfig, PaginateQuery } from 'nestjs-paginate';
+import { UpdateUsersDto } from './dto/update-users.dto.js';
+import { In } from 'typeorm';
 
 export type User = any;
 
@@ -27,37 +18,32 @@ export class UserService {
     private jwtService: JwtService,
   ) {}
 
-  async create(signUpDto: SignUpDto): Promise<UserEntity | undefined> {
+  async create(signUpDto: SignUpDto): Promise<UserEntity | undefined>{
     return UserEntity.create({
       full_name: signUpDto.full_name,
       phone_number: signUpDto.phone_number,
       email: signUpDto.email,
-      hash_password: signUpDto.password,
-    });
+      hash_password: signUpDto.password
+    })
   }
 
-  async save(userEntity: UserEntity): Promise<UserEntity | undefined> {
+  async save(userEntity: UserEntity): Promise<UserEntity | undefined>{
     return UserEntity.save(userEntity);
   }
 
-  async findOneByField(
-    field: string,
-    value: any,
-  ): Promise<UserEntity | undefined> {
-    return UserEntity.findOne({
-      where: { [field]: value },
+  async findOneByField(field: string, value: any): Promise<UserEntity | undefined> {
+    return UserEntity.findOne({ 
+      where: { [field]: value }
     });
   }
 
-  async updateUserById(userId: string, updateUserDto: UpdateUserDto) {
+  async updateUserById(userId: string, updateUserDto: UpdateUserDto){
+
     await this.validateService.checkExistField('email', updateUserDto.email);
-    await this.validateService.checkExistField(
-      'phone_number',
-      updateUserDto.phone_number,
-    );
+    await this.validateService.checkExistField('phone_number', updateUserDto.phone_number);
 
     const user = await UserEntity.findOne({
-      where: { id: userId },
+      where: { id: userId }
     });
     if (!user) {
       throw new NotFoundException(`User with ID ${userId} not found`);
@@ -66,17 +52,14 @@ export class UserService {
     Object.assign(user, updateUserDto);
     if (updateUserDto.hash_password) {
       const saltRounds = 10;
-      user.hash_password = await bcrypt.hash(
-        updateUserDto.hash_password,
-        saltRounds,
-      ); // Mã hóa mật khẩu
+      user.hash_password = await bcrypt.hash(updateUserDto.hash_password, saltRounds); // Mã hóa mật khẩu
     }
     await UserEntity.save(user);
 
-    const payload = { sub: user.id, username: user.full_name, role: user.role };
-    const token = await this.jwtService.signAsync(payload);
+    const payload = { sub: user.id, username: user.full_name, roles: user.role };
+    const token = await this.jwtService.signAsync(payload)
     return {
-      access_token: token,
+      access_token: token
     };
   }
 
@@ -93,17 +76,15 @@ export class UserService {
           FilterOperator.GT,
           FilterOperator.GTE,
         ],
-        item_type: [FilterOperator.EQ],
+        item_type: [FilterOperator.EQ]
       },
     };
     return paginate(query, UserEntity.createQueryBuilder(), paginateConfig);
   }
 
   async findAllByName(fullName: string, query: PaginateQuery) {
-    const queryBuilder = UserEntity.createQueryBuilder('users').where(
-      'users.full_name = :fullName',
-      { fullName },
-    );
+    const queryBuilder = UserEntity.createQueryBuilder('users')
+      .where('users.full_name = :fullName', { fullName });
     const paginateConfig: PaginateConfig<UserEntity> = {
       sortableColumns: ['id', 'full_name', 'phone_number', 'email'],
       nullSort: 'last',
@@ -116,17 +97,15 @@ export class UserService {
           FilterOperator.GT,
           FilterOperator.GTE,
         ],
-        item_type: [FilterOperator.EQ],
+        item_type: [FilterOperator.EQ]
       },
     };
     return paginate(query, queryBuilder, paginateConfig);
   }
 
   async findAllByRole(role: string, query: PaginateQuery) {
-    const queryBuilder = UserEntity.createQueryBuilder('users').where(
-      'users.role = :role',
-      { role },
-    );
+    const queryBuilder = UserEntity.createQueryBuilder('users')
+      .where('users.role = :role', { role });
     const paginateConfig: PaginateConfig<UserEntity> = {
       sortableColumns: ['id', 'full_name', 'phone_number', 'email'],
       nullSort: 'last',
@@ -139,9 +118,46 @@ export class UserService {
           FilterOperator.GT,
           FilterOperator.GTE,
         ],
-        item_type: [FilterOperator.EQ],
+        item_type: [FilterOperator.EQ]
       },
     };
     return paginate(query, queryBuilder, paginateConfig);
   }
+
+  async updateUsers(updateUsersDto: UpdateUsersDto[]) {
+    try {
+      //Lấy ra id trong updateUsersDto
+      const userIds = updateUsersDto.map(user => user.id).filter(id => id !== undefined);
+
+      //Lấy ra các user tồn tại trong db
+      const existingUsers = await UserEntity.find({
+        where: { id: In(userIds) },
+      });
+
+      // Bước 2: Kết hợp dữ liệu từ yêu cầu với dữ liệu hiện có
+      const mergedData = updateUsersDto.map(userData => {
+        const existingUser = existingUsers.find(user => user.id === userData.id);
+    
+        if (existingUser) {
+          // Kết hợp: giữ nguyên giá trị hiện có cho các trường không có trong userData
+          return { ...existingUser, ...userData };
+        } else {
+          // Đối với user mới (không có trong DB), sử dụng dữ liệu từ request
+          return userData;
+        }
+      });
+
+      console.log(updateUsersDto)
+      UserEntity.upsert(mergedData, ['id'])
+      return {
+        statusCode: HttpStatus.OK,
+        message: "Thành công"
+      }
+    } catch (error) {
+      return {
+        statusCode: HttpStatus.OK,
+        message: "Thất bại"
+      }
+    }
+  }
 }