Feature/cadastro validacao

Issue number:

#26

Descrição:

Uma lista das mudanças relacionadas a esse MR

• Fazer a criptografia da senha do cadastro;
• Validações da criação do usuário;
• Teste unitários;
• Service de criptografia;

Checklist:

• Não deixou string literais no código
• Utilizou as variáveis padronizadas do design system (cor, títulos/fontes, imagens e etc)
• Não deixou nenhum código comentado

Foto da pipeline com status verde

src/api/user/user.controller.spec.ts

-import { NotFoundException } from '@nestjs/common';
+import { BadRequestException, NotFoundException } from '@nestjs/common';
 import { getModelToken } from '@nestjs/mongoose';
 import { Test, TestingModule } from '@nestjs/testing';
 import { Address } from '../../database/schemas/address.schema';
 import { User, UserEntity } from '../../database/schemas/user.schema';
+import { EncryptorService } from '../../security/encryptor.service';
 import { UserController } from './user.controller';
 import { UserCreateDto } from './user.dto';
 import { UserService } from './user.service';
@@ -29,11 +30,16 @@ const userDataMock: UserEntity = {
 
 const findByIdMock = jest.fn();
 const createMock = jest.fn();
+const findOneMock = jest.fn();
+const encryptorMock = {
+  encrypt: jest.fn().mockReturnValue('senha encriptada'),
+};
 
 const userModelMock = {
   find: () => ({ exec: () => [userDataMock] }),
   findById: findByIdMock,
   create: createMock,
+  findOne: findOneMock,
 };
 
 describe('UserController', () => {
@@ -48,6 +54,10 @@ describe('UserController', () => {
           provide: getModelToken(User.name),
           useValue: userModelMock,
         },
+        {
+          provide: EncryptorService,
+          useValue: encryptorMock,
+        },
       ],
     }).compile();
 
@@ -90,13 +100,32 @@ describe('UserController', () => {
         telefone: userDataMock.telefone,
         numeroINSS: userDataMock.numeroINSS,
       };
-
+      const hash = 'senha encriptada';
       await userController.create(dto);
       const createModel = { ...userDataMock };
       createModel.endereco = { cep: dto.cep } as Address;
+      createModel.password = hash;
       delete createModel._id;
-
       expect(createMock).toHaveBeenCalledWith(createModel);
     });
+
+    it('quando alguma informação já existir não deve criar usuário"', async () => {
+      const dto: UserCreateDto = {
+        cep: userDataMock.endereco.cep,
+        contatoEmergencia: userDataMock.contatoEmergencia,
+        cpf: userDataMock.cpf,
+        email: userDataMock.email,
+        password: userDataMock.password,
+        nome: userDataMock.nome,
+        telefone: userDataMock.telefone,
+        numeroINSS: userDataMock.numeroINSS,
+      };
+
+      findOneMock.mockReturnValue(userDataMock);
+
+      expect(userController.create(dto)).rejects.toThrowError(
+        BadRequestException,
+      );
+    });
   });
 });

src/api/user/user.module.ts

@@ -2,6 +2,7 @@ import { Module } from '@nestjs/common';
 import { MongooseModule } from '@nestjs/mongoose';
 import { DatabaseModule } from '../../database/database.module';
 import { User, UserSchema } from '../../database/schemas/user.schema';
+import { SecurityModule } from '../../security/security.module';
 import { UserController } from './user.controller';
 import { UserService } from './user.service';
 
@@ -9,6 +10,7 @@ import { UserService } from './user.service';
   imports: [
     DatabaseModule,
     MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
+    SecurityModule,
   ],
   controllers: [UserController],
   providers: [UserService],

src/api/user/user.service.ts

-import { Injectable, Logger } from '@nestjs/common';
+import { BadRequestException, Injectable, Logger } from '@nestjs/common';
 import { InjectModel } from '@nestjs/mongoose';
 import { Model } from 'mongoose';
 import { Address } from '../../database/schemas/address.schema';
 import { User, UserDocument } from '../../database/schemas/user.schema';
+import { EncryptorService } from '../../security/encryptor.service';
 import { UserCreateDto } from './user.dto';
 
+
 @Injectable()
 export class UserService {
   private readonly logger = new Logger(UserService.name);
@@ -12,11 +14,24 @@ export class UserService {
   constructor(
     @InjectModel(User.name)
     private readonly userModel: Model<UserDocument>,
+    private readonly encryptor: EncryptorService,
   ) {}
 
   async create(dto: UserCreateDto): Promise<UserDocument> {
-    const model = this.dtoToModel(dto);
-    return this.userModel.create(model);
+    const user = await this.findByEmailOrCpfOrTelefone(
+      dto.email,
+      dto.cpf,
+      dto.telefone,
+    );
+    if (!user) {
+      const model = this.dtoToModel({
+        ...dto,
+        password: await this.encryptor.encrypt(dto.password),
+      });
+      return this.userModel.create(model);
+    } else {
+      throw new BadRequestException('Usuário já existe');
+    }
   }
 
   async findById(id: string): Promise<UserDocument> {
@@ -29,6 +44,16 @@ export class UserService {
     }
   }
 
+  async findByEmailOrCpfOrTelefone(
+    email?: string,
+    cpf?: string,
+    telefone?: string,
+  ): Promise<UserDocument> {
+    return await this.userModel.findOne({
+      $or: [{ email: email }, { cpf: cpf }, { telefone: telefone }],
+    });
+  }
+
   async findByEmailAndPassword(
     email: string,
     password: string,

src/security/encryptor.service.ts

+import { Injectable } from '@nestjs/common';
+import * as bcrypt from 'bcrypt';
+
+@Injectable()
+export class EncryptorService {
+  async encrypt(password: string): Promise<string> {
+    return await bcrypt.hash(password, 10);
+  }
+}

src/security/security.module.ts

+import { Module } from '@nestjs/common';
+import { EncryptorService } from './encryptor.service';
+
+@Module({
+  imports: [],
+  controllers: [],
+  providers: [EncryptorService],
+  exports: [EncryptorService],
+})
+export class SecurityModule {}