update user info, create validate service

backend/src/modules/authentication/authentication.module.ts

@@ -7,6 +7,7 @@ import { AuthenticationGuard } from './authentication.guard.js';
 import { APP_GUARD } from '@nestjs/core';
 import { ConfigModule, ConfigService } from '@nestjs/config';
 import { RolesGuard } from './authorization/roles.guard.js';
+import { ValidateService } from '../../validate/validate.service.js';
 @Module({
   imports: [
     UserModule,
@@ -28,7 +29,8 @@ import { RolesGuard } from './authorization/roles.guard.js';
     {
       provide: APP_GUARD,
       useClass: RolesGuard,
-    }
+    },
+    ValidateService
   ],
   controllers: [AuthenticationController],
   exports: [AuthenticationService],

backend/src/modules/authentication/authentication.service.ts

@@ -4,11 +4,13 @@ import * as bcrypt from 'bcrypt';
 import { JwtService } from '@nestjs/jwt';
 import { SignUpDto } from './dto/sign-up.dto.js';
 import { UserEntity } from '../../entities/user.entity.js';
+import { ValidateService } from '../../validate/validate.service.js';
 @Injectable()
 export class AuthenticationService {
   constructor(
     private usersService: UserService,
     private jwtService: JwtService,
+    private validatService: ValidateService
   ) {}
 
   async signIn(
@@ -20,10 +22,12 @@ export class AuthenticationService {
       user = await this.usersService.findOneByField('email', username);
     else
       user = await this.usersService.findOneByField('phone_number', username);
-    if (!user || (await !bcrypt.compare(pass, user.hash_password))) {
+    const compare = await bcrypt.compare(pass, user.hash_password)
+    console.log(compare);
+    if (( !user || !compare )) {
       throw new UnauthorizedException();
     }
-    const payload = { sub: user.id, username: user.id, roles: user.role.role_name};
+    const payload = { sub: user.id, username: user.full_name, roles: user.role.role_name};
     return {
       access_token: await this.jwtService.signAsync(payload),
     };
@@ -39,8 +43,8 @@ export class AuthenticationService {
       password 
     } = signUpDto
 
-    await this.checkExistField('email', email);
-    await this.checkExistField('phone_number', phone_number)
+    await this.validatService.checkExistField('email', email);
+    await this.validatService.checkExistField('phone_number', phone_number)
     const hash_password = await bcrypt.hash(password, 10)
 
     const user = await this.usersService.create({

backend/src/modules/authentication/rbac-policy.ts

@@ -1,9 +0,0 @@
-import { RolesBuilder } from 'nest-access-control';
-import { Role } from './enums';
-
-export const RBAC_POLICY: RolesBuilder = new RolesBuilder();
-
-// prettier-ignore
-RBAC_POLICY
-  .grant(Role.ADMIN)
-    .read()

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

@@ -0,0 +1,31 @@
+import { IsEmail, IsMobilePhone, IsOptional, IsString } from "class-validator";
+import { Column } from "typeorm";
+
+export class UpdateUserDto{
+
+  @IsOptional()
+  avatar: string;
+
+  @IsOptional()
+  full_name: string;
+
+  @IsOptional()
+  @IsMobilePhone('vi-VN')
+  phone_number: string;
+
+  @IsOptional()
+  address: string;
+
+  @IsOptional()
+  @IsEmail()
+  email: string;
+
+  @IsOptional()
+  role_id: string;
+  
+  @IsOptional()
+  hash_password: string;
+
+  @IsOptional()
+  is_valid: boolean;
+}

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

@@ -1,6 +1,7 @@
-import { Controller, Get, Param } from '@nestjs/common';
+import { Body, Controller, Get, Param, Post, Request } from '@nestjs/common';
 import { UserService } from './user.service.js';
 import { UserEntity } from 'src/entities/user.entity.js';
+import { UpdateUserDto } from './dto/update-user-dto.js';
 
 @Controller('users')
 export class UsersController {
@@ -12,4 +13,11 @@ export class UsersController {
   ): Promise<UserEntity | undefined> {
     return this.usersService.findOne(username);
   }
+
+  @Post('updateUser')
+  async updateUser(@Request() req){
+      const userId = req.user.sub;
+      const updateUserDto = req.body;
+      return this.usersService.updateUserById(userId, updateUserDto);
+  }
 }

backend/src/modules/user/user.module.ts

@@ -1,8 +1,23 @@
 import { Module } from '@nestjs/common';
 import { UserService } from './user.service.js';
+import { ValidateService } from '../../validate/validate.service.js';
+import { UsersController } from './user.controller.js';
+import { JwtModule } from '@nestjs/jwt';
+import { ConfigModule, ConfigService } from '@nestjs/config';
 
 @Module({
-  providers: [UserService],
+  imports: [
+    JwtModule.registerAsync({
+      imports: [ConfigModule], // Nhập ConfigModule để sử dụng ConfigService
+      useFactory: async (configService: ConfigService) => ({
+        secret: configService.get<string>('JWT_KEY'), // Lấy giá trị từ biến môi trường
+        signOptions: { expiresIn: '7d' }, // Thời gian hết hạn token
+      }),
+      inject: [ConfigService], // Inject ConfigService vào factory
+    }),
+  ],
+  controllers: [UsersController],
+  providers: [UserService, ValidateService],
   exports: [UserService],
 })
 export class UserModule {}

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

@@ -1,12 +1,19 @@
-import { Injectable } from '@nestjs/common';
+import { Body, forwardRef, 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';
 
 export type User = any;
 
 @Injectable()
 export class UserService {
-  constructor() {}
+  constructor(
+    private validateService: ValidateService,
+    private jwtService: JwtService,
+  ) {}
 
   async findOne(username: string): Promise<UserEntity | undefined> {
     return UserEntity.findOne({ where: { full_name: username } });
@@ -31,4 +38,31 @@ export class UserService {
       relations: ['role'] 
     });
   }
+
+  async updateUserById(userId: string, updateUserDto: UpdateUserDto){
+
+    await this.validateService.checkExistField('email', updateUserDto.email);
+    await this.validateService.checkExistField('phone_number', updateUserDto.phone_number);
+
+    const user = await UserEntity.findOne({
+      where: { id: userId },
+      relations: ['role']
+    });
+    if (!user) {
+      throw new NotFoundException(`User with ID ${userId} not found`);
+    }
+
+    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
+    }
+    await UserEntity.save(user);
+
+    const payload = { sub: user.id, username: user.full_name, roles: user.role.role_name };
+    const token = await this.jwtService.signAsync(payload)
+    return {
+      access_token: token
+    };
+  }
 }

backend/src/validate/validate.service.spec.ts

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

backend/src/validate/validate.service.ts

@@ -0,0 +1,25 @@
+// validation.service.ts
+import { Injectable, ConflictException } from '@nestjs/common';
+import { UserEntity } from '../entities/user.entity.js';
+
+@Injectable()
+export class ValidateService {
+  constructor() {}
+
+  // Kiểm tra xem giá trị của một trường có tồn tại không
+  async checkExistField(fieldName: string, fieldValue: any): Promise<void> {
+    if (fieldValue === null || fieldValue === undefined) {
+      return; // Nếu giá trị null hoặc undefined, không cần kiểm tra
+    }
+
+    // Tìm trong database theo tên và giá trị của trường
+    const existingUser = await UserEntity.findOne({ 
+        where: { [fieldName]: fieldValue }, 
+        relations: ['role'] 
+    });
+
+    if (existingUser) {
+      throw new ConflictException(`${fieldName} is already taken`);
+    }
+  }
+}