Register 70%, ajustes realizables

src/auth/auth.controller.ts

@@ -3,18 +3,25 @@ import { AuthService } from './auth.service';
 import { CreateAuthDto } from './dto/create-auth.dto';
 import { AuthGuard } from './guard/auth.guard';
 import { Request } from '@nestjs/common';
+import { CreateUserDto } from './dto/create-user.dto';
 @Controller('auth')
 export class AuthController {
   constructor(private readonly authService: AuthService) {}
 
   @Post('login')
-  create(@Body() createAuthDto: CreateAuthDto) {
+  createJWT(@Body() createAuthDto: CreateAuthDto) {
     console.log('createAuthDto', createAuthDto);
-    return this.authService.create(createAuthDto);
+    return this.authService.createJWT(createAuthDto);
   }
+
+  @Post('register')
+  createUser(@Body() createUserDto: CreateUserDto) {
+    return this.authService.createUser(createUserDto);
+  }
+
   @UseGuards(AuthGuard)
   @Get('profile')
   getProfile(@Request() req) {
     return req.user;
   }
-}
+}

src/auth/auth.service.ts

@@ -1,9 +1,12 @@
-import { Injectable, UnauthorizedException } from '@nestjs/common';
+
+import { Injectable, UnauthorizedException, ConflictException } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
 import { CreateAuthDto } from './dto/create-auth.dto';
 import { User } from 'src/model/user.entity';
 import { JwtService } from '@nestjs/jwt';
+import { CreateUserDto } from './dto/create-user.dto';
+import * as bcrypt from 'bcrypt';
 
 @Injectable()
 export class AuthService {
@@ -13,16 +16,23 @@ export class AuthService {
     private readonly jwtService: JwtService,
   ) {}
 
-  async create(createAuthDto: CreateAuthDto): Promise<{ access_token: string }> {
+  async comparePassword(plainPassword, hashedPassword) {
+    const match = await bcrypt.compare(plainPassword, hashedPassword);
+    return match;
+  }
+
+  async createJWT(createAuthDto: CreateAuthDto): Promise<{ access_token: string }> {
     const existingUser = await this.userRepository.findOne({
       where: {
         dni: createAuthDto.dni,
-        password: createAuthDto.password,
       },
     });
-    if (!existingUser) {
-      throw new UnauthorizedException('No existe el usuario.');
+    const existingPassword = await bcrypt.compare(createAuthDto.password, existingUser.password);
+
+    if (!existingUser || !existingPassword) {
+      throw new UnauthorizedException('No existe el usuario o la contraseña es incorrecta.');
     }
+
     const payload = {
       dni: existingUser.dni,
       name: existingUser.name,
@@ -35,4 +45,45 @@ export class AuthService {
       access_token: this.jwtService.sign(payload),
     };
   }
-}
+
+  async createUser(createUserDto: CreateUserDto) {
+    const existingUser1 = await this.userRepository.findOne({
+      where: {
+        dni: createUserDto.dni,
+      },
+    });
+    const existingUser2 = await this.userRepository.findOne({
+      where: {
+        email: createUserDto.email,
+      },
+    });
+    if (existingUser1) {
+      throw new ConflictException('El DNI ya está registrado.');
+    }
+    if (existingUser2) {
+      throw new ConflictException('El Email ya está registrado.');
+    }
+    const hashedPassword = await bcrypt.hash(createUserDto.password, 10);
+
+    await this.userRepository.insert({
+      dni: createUserDto.dni,
+      password: hashedPassword,
+      name: createUserDto.name,
+      lastname: createUserDto.lastname,
+      email: createUserDto.email,
+      image_url: createUserDto.image_url,
+      created_at: Date(),
+      updated_at: Date(),
+    });
+
+    const payload = {
+      dni: createUserDto.dni,
+      name: createUserDto.name,
+      lastname: createUserDto.lastname,
+      email: createUserDto.email,
+      image_url: createUserDto.image_url,
+    };
+    const access_token = this.jwtService.sign(payload);
+    return { access_token };
+  }
+}

src/auth/dto/create-user.dto.ts

@@ -0,0 +1,34 @@
+import { IsString, IsNotEmpty, IsEmail, IsUrl, IsOptional, Matches } from 'class-validator';
+
+export class CreateUserDto {
+  @IsString()
+  @IsNotEmpty({ message: 'El DNI no puede estar vacío' })
+  @Matches(/^\d{8}$/, { message: 'El DNI debe tener exactamente 8 dígitos' })
+  dni: string;
+
+  @IsString()
+  @IsNotEmpty({ message: 'El nombre no puede estar vacío' })
+  name: string;
+
+  @IsString()
+  @IsNotEmpty({ message: 'El apellido no puede estar vacío' })
+  lastname: string;
+
+  @IsEmail({}, { message: 'Debe ser un correo electrónico válido' })
+  @IsNotEmpty({ message: 'El correo electrónico no puede estar vacío' })
+  email: string;
+
+  @IsString()
+  @IsNotEmpty({ message: 'La contraseña no puede estar vacía' })
+  password: string;
+
+  @IsUrl({}, { message: 'Debe ser una URL válida' })
+  @IsOptional()
+  image_url?: string;
+
+  @IsOptional()
+  created_at?: Date = new Date();
+
+  @IsOptional()
+  updated_at?: Date = new Date();
+}