Linkando van com usuário

src/database/migrations/1655720865095-AddUserIdFieldToVansTable.ts

@@ -0,0 +1,20 @@
+import { MigrationInterface, QueryRunner, TableColumn } from 'typeorm';
+
+export class AddUserIdFieldToVansTable1655720865095
+  implements MigrationInterface
+{
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.addColumn(
+      'vans',
+      new TableColumn({
+        name: 'user_id',
+        type: 'uuid',
+        isNullable: true,
+      }),
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.dropColumn('vans', 'user_id');
+  }
+}

src/database/migrations/1655720873936-AddFKUserIdToVansTable.ts

@@ -0,0 +1,24 @@
+import { MigrationInterface, QueryRunner, TableForeignKey } from 'typeorm';
+
+export class AddFKUserIdToVansTable1655720873936 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.createForeignKey(
+      'vans',
+      new TableForeignKey({
+        name: 'UserIdVan', // nome da FK, serve para referenciar numa exclusão pelo QueryRunner se necessário
+        columnNames: ['user_id'], // coluna que vai virar FK
+        referencedColumnNames: ['id_user'], // coluna PK da primeira tabela
+        referencedTableName: 'users', // nome da tabela que possui a PK
+        onDelete: 'SET NULL',
+        onUpdate: 'CASCADE',
+      }),
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.dropForeignKey(
+      'vans',
+      'UserIdVan',
+    );
+  }
+}

src/models/User.ts

@@ -4,7 +4,9 @@ import {
   PrimaryGeneratedColumn,
   CreateDateColumn,
   UpdateDateColumn,
+  OneToMany,
 } from 'typeorm';
+import Van from './Van';
 
 @Entity('users')
 class User {
@@ -44,6 +46,9 @@ class User {
   @Column()
   document: string;
 
+  @OneToMany(() => Van, van => van.user)
+  van: Van[];
+
   @CreateDateColumn()
   created_at: Date;
 

src/models/Van.ts

@@ -7,7 +7,10 @@ import {
   JoinColumn,
   OneToOne,
   PrimaryColumn,
+  OneToMany,
+  ManyToOne,
 } from 'typeorm';
+import User from './User';
 
 @Entity('vans')
 class Van {
@@ -41,6 +44,10 @@ class Van {
   @Column()
   locator_state: string;
 
+  @ManyToOne(() => User, user => user.van)
+  @JoinColumn({ name: 'user_id' })
+  user: User;
+
   @CreateDateColumn()
   created_at: Date;
 

src/routes/users.routes.ts

@@ -117,7 +117,7 @@ usersRouter.patch('/edit', ensureAuthenticated, async (request, response) => {
     document
   });
 
-  return response.json({ message: 'User info sucessfully updated.' });
+  return response.json({ message: 'Perfil atualizado com sucesso.' });
 });
 
 usersRouter.patch('/edit/avatar', ensureAuthenticated, async (request, response) => {

src/routes/vans.routes.ts

@@ -8,6 +8,7 @@ import FindVanService from '../services/FindVanService';
 import CreateVanService from '../services/CreateVanService';
 import UpdateVanService from '../services/UpdateVanService';
 import UpdateVanPlateService from '../services/UpdateVanPlateService';
+import FindVanByUserIdService from '../services/FindVansByUserIdService';
 
 const vansRouter = Router();
 
@@ -19,7 +20,7 @@ vansRouter.get('/list', async (request, response) => {
   return response.json({ data: vans });
 });
 
-vansRouter.get('/:plate', ensureAuthenticated, async (request, response) => {
+vansRouter.get('/plate/:plate', ensureAuthenticated, async (request, response) => {
   const { plate } = request.params;
 
   const findVanService = new FindVanService();
@@ -29,8 +30,19 @@ vansRouter.get('/:plate', ensureAuthenticated, async (request, response) => {
   return response.json({ data: van });
 });
 
+vansRouter.get('/user/:id_user', ensureAuthenticated, async (request, response) => {
+  const { id_user } = request.params;
+
+  const findVanByUserIdService = new FindVanByUserIdService();
+
+  const vans = await findVanByUserIdService.execute(id_user);
+
+  return response.json({ data: vans });
+});
+
 vansRouter.post('/', async (request, response) => {
   const {
+    id_user,
     plate,
     brand,
     model,
@@ -45,6 +57,7 @@ vansRouter.post('/', async (request, response) => {
   const createVanService = new CreateVanService();
 
   const van = await createVanService.execute({
+    id_user,
     plate,
     brand,
     model,

src/server.ts

@@ -20,8 +20,9 @@ createConnection();
 
 app.use((err: Error, request: Request, response: Response, _: NextFunction) => {
   if (err instanceof AppError) {
-    return response.status(err.statusCode).json({
+    return response.status(202).json({
       status: 'error',
+      httpCode: err.statusCode,
       message: err.message,
     });
   }

src/services/CreateVanService.ts

@@ -1,10 +1,12 @@
 import { getRepository } from 'typeorm';
 
 import AppError from '../errors/AppError';
+import User from '../models/User';
 
 import Van from '../models/Van';
 
 interface Request {
+  id_user: string;
   plate: string;
   brand: string;
   model: string;
@@ -18,6 +20,7 @@ interface Request {
 
 class CreateVanService {
   public async execute({
+    id_user,
     plate,
     brand,
     model,
@@ -29,6 +32,18 @@ class CreateVanService {
     locator_state,
   }: Request): Promise<Van> {
     const vansRepository = getRepository(Van);
+    const usersRepository = getRepository(User);
+
+    const user = await usersRepository.findOne({
+      where: { id_user },
+    });
+
+    if (!user) {
+      throw new AppError(
+        'O usuário informado não foi encontrado.',
+        404,
+      );
+    }
 
     const vanExists = await vansRepository.findOne({
       where: { plate },
@@ -42,6 +57,7 @@ class CreateVanService {
     }
 
     const van = vansRepository.create({
+      user,
       plate,
       brand,
       model,

src/services/FindVanService.ts

@@ -5,15 +5,15 @@ import AppError from '../errors/AppError';
 import Van from '../models/Van';
 
 class FindVanService {
-  public async execute(id_van: string): Promise<Van> {
+  public async execute(plate: string): Promise<Van> {
     const vansRepository = getRepository(Van);
 
     const van = await vansRepository.findOne({
-      where: { id_van }
+      where: { plate }
     });
 
     if (!van) {
-      throw new AppError('Van does not exist.');
+      throw new AppError('A van informada não existe.');
     };
 
     return van;

src/services/FindVansByUserIdService.ts

@@ -0,0 +1,33 @@
+import { getRepository } from 'typeorm';
+
+import AppError from '../errors/AppError';
+
+import User from '../models/User';
+import Van from '../models/Van';
+
+class FindVanByUserIdService {
+  public async execute(id_user: string): Promise<Van[]> {
+    const usersRepository = getRepository(User);
+    const vansRepository = getRepository(Van);
+
+    const user = await usersRepository.findOne({
+      where: { id_user }
+    });
+
+    if (!user) {
+      throw new AppError('O usuário informado não existe.', 404);
+    };
+
+    const van = await vansRepository.find({
+      where: { user }
+    });
+
+    if (!van) {
+      throw new AppError('Não há nenhuma van cadastrada para esse usuário.');
+    };
+
+    return van;
+  }
+}
+
+export default FindVanByUserIdService;

src/services/UpdateUserService.ts

@@ -23,18 +23,29 @@ class UpdateUserService {
     const socialRepository = getRepository(Social);
 
     const user = await usersRepository.findOne({
-      where: { id_user: id_user }
+      where: { id_user }
     });
 
     if (!user) {
-      throw new AppError('O usuário informado não existe.');
+      throw new AppError('O usuário informado não existe.', 404);
     };
 
     if (name) user.name = name
     if (lastname) user.lastname = lastname
     if (bio) user.bio = bio
     if (email) user.email = email
-    if (phone_number) user.phone_number = phone_number
+
+    if (phone_number) {
+      const phoneAlreadyExists = await usersRepository.findOne({
+        where: { phone_number }
+      });
+
+      if (phoneAlreadyExists) {
+        throw new AppError('O telefone informado já está em uso por outra conta!', 409);
+      }
+    }
+    
+    user.phone_number = phone_number
 
     if (document_type) user.document_type = document_type
     if (document) user.document = document