Atualizando rotas das vans com lógica do locador

src/database/migrations/1655691282002-CreateVansTable.ts

@@ -29,6 +29,11 @@ export class CreateVansTable1655691282002 implements MigrationInterface {
             name: 'seats_number',
             type: 'numeric',
           },
+          {
+            name: 'document',
+            type: 'varchar',
+            isNullable: true
+          },
           {
             name: 'created_at',
             type: 'timestamp',

src/database/migrations/1655692498005-CreateVanDocumentsTable.ts

@@ -9,11 +9,9 @@ export class CreateVanDocumentsTable1655692498005
         name: 'vanDocuments',
         columns: [
           {
-            name: 'id_vanDocuments',
-            type: 'uuid',
+            name: 'document_van',
+            type: 'varchar',
             isPrimary: true,
-            generationStrategy: 'uuid',
-            default: 'uuid_generate_v4()',
           },
           {
             name: 'vanLocator_id',

src/database/migrations/1655696991836-AddFKVanDocumentToVanDocumentsTable.ts

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

src/models/Van.ts

@@ -7,6 +7,7 @@ import {
   JoinColumn,
   OneToOne,
 } from 'typeorm';
+import VanDocuments from './VanDocuments';
 import VanLocator from './VanLocator';
 
 @Entity('vans')
@@ -27,8 +28,8 @@ class Van {
   seats_number: number;
 
   @OneToOne(() => VanLocator, { eager: true })
-  @JoinColumn({ name: 'vanLocator_id' })
-  vanLocator: VanLocator;
+  @JoinColumn({ name: 'document' })
+  locator: VanLocator;
 
   @CreateDateColumn()
   created_at: Date;

src/models/VanDocuments.ts

@@ -0,0 +1,34 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  JoinColumn,
+  OneToOne,
+  PrimaryColumn,
+} from 'typeorm';
+import VanLocator from './VanLocator';
+
+@Entity('vanDocuments')
+class VanDocuments {
+  @PrimaryColumn()
+  @OneToOne(() => VanDocuments, { eager: true })
+  @JoinColumn({ name: 'document' })
+  vanDocuments: VanDocuments;
+
+  @OneToOne(() => VanLocator, { eager: true })
+  @JoinColumn({ name: 'vanLocator_id' })
+  vanLocator: VanLocator;
+
+  @Column()
+  document_status: string;
+
+  @CreateDateColumn()
+  created_at: Date;
+
+  @UpdateDateColumn()
+  updated_at: Date;
+}
+
+export default VanDocuments;

src/routes/vans.routes.ts

@@ -7,6 +7,10 @@ import ensureAuthenticated from '../middlewares/ensureAuthenticated';
 import FindVanService from '../services/FindVanService';
 import CreateVanService from '../services/CreateVanService';
 import UpdateVanService from '../services/UpdateVanService';
+import VanLocator from '../models/VanLocator';
+import FindVanLocatorService from '../services/FindVanLocatorService';
+import CreateVanLocatorService from '../services/CreateVanLocatorService';
+import UpdateVanLocatorService from '../services/UpdateVanLocatorService';
 
 const vansRouter = Router();
 
@@ -60,7 +64,79 @@ vansRouter.patch(
       seats_number,
     });
 
-    return response.json({ message: 'Informações da van atualizadas com sucesso.' });
+    return response.json({
+      message: 'Informações da van atualizadas com sucesso.',
+    });
+  },
+);
+
+// locadores de van
+vansRouter.get('/locator/list', async (request, response) => {
+  const vanLocatorsRepository = getRepository(VanLocator);
+
+  const vansLocators = await vanLocatorsRepository.find();
+
+  return response.json({ data: vansLocators });
+});
+
+vansRouter.get(
+  '/locator/:id',
+  ensureAuthenticated,
+  async (request, response) => {
+    const { id } = request.params;
+
+    const findVanLocator = new FindVanLocatorService();
+
+    const vanLocator = await findVanLocator.execute(id);
+
+    return response.json({ data: vanLocator });
+  },
+);
+
+vansRouter.post('/locator/:id_van', async (request, response) => {
+  const { name, address, complement, city, state } = request.body;
+
+  const { id_van } = request.params;
+
+  const createVanLocator = new CreateVanLocatorService();
+
+  const vanLocator = await createVanLocator.execute({
+    id_van,
+    name,
+    address,
+    complement,
+    city,
+    state,
+  });
+
+  return response.json({
+    message: 'Locador da van configurado com sucesso.',
+    data: vanLocator,
+  });
+});
+
+vansRouter.patch(
+  '/locator/edit/:id_van',
+  ensureAuthenticated,
+  async (request, response) => {
+    const { name, address, complement, city, state } = request.body;
+
+    const { id_van } = request.params;
+
+    const updateVanLocatorService = new UpdateVanLocatorService();
+
+    await updateVanLocatorService.execute({
+      id_van,
+      name,
+      address,
+      complement,
+      city,
+      state,
+    });
+
+    return response.json({
+      message: 'Informações da van atualizadas com sucesso.',
+    });
   },
 );
 

src/services/CreateVanLocatorService.ts

@@ -0,0 +1,64 @@
+import { getRepository } from 'typeorm';
+import { v4 } from 'uuid';
+import { hash } from 'bcryptjs';
+
+import AppError from '../errors/AppError';
+
+import Van from '../models/Van';
+import VanLocator from '../models/VanLocator';
+
+interface Request {
+  id_van: string;
+  name: string;
+  address: string;
+  complement: string;
+  city: string;
+  state: string;
+}
+
+class CreateVanLocatorService {
+  public async execute({
+    id_van,
+    name,
+    address,
+    complement,
+    city,
+    state,
+  }: Request): Promise<VanLocator> {
+    const vansRepository = getRepository(Van);
+    const vansLocatorsRepository = getRepository(VanLocator);
+
+    const van = await vansRepository.findOne({
+      where: { id_van },
+    });
+
+    if (!van) {
+      throw new AppError('A van informada não existe.', 404);
+    }
+
+    if (van.locator) {
+      throw new AppError(
+        'A van informada já possui um locador cadastrado.',
+        400,
+      );
+    }
+
+    const vanLocator = vansLocatorsRepository.create({
+      name,
+      address,
+      complement,
+      city,
+      state,
+    });
+
+    await vansLocatorsRepository.save(vanLocator);
+
+    // linka o locador para o registro da van
+    van.locator = vanLocator
+    await vansRepository.save(van);
+
+    return vanLocator;
+  }
+}
+
+export default CreateVanLocatorService;

src/services/FindVanLocatorService.ts

@@ -0,0 +1,25 @@
+import { getRepository } from 'typeorm';
+
+import AppError from '../errors/AppError';
+
+import Van from '../models/Van';
+import VanLocator from '../models/VanLocator';
+
+class FindVanLocatorService {
+  public async execute(id_van: string): Promise<VanLocator> {
+    const vansRepository = getRepository(Van);
+    const vansLocatorsRepository = getRepository(VanLocator);
+
+    const van = await vansRepository.findOne({
+      where: { id_van }
+    });
+
+    if (!van) {
+      throw new AppError('A Van informada não existe.', 404);
+    };
+
+    return van.locator;
+  }
+}
+
+export default FindVanLocatorService;

src/services/UpdateVanLocatorService.ts

@@ -0,0 +1,56 @@
+import { getRepository } from 'typeorm';
+
+import AppError from '../errors/AppError';
+
+import Van from '../models/Van';
+import VanLocator from '../models/VanLocator';
+
+interface Request {
+  id_van: string;
+  name: string;
+  address: string;
+  complement: string;
+  city: string;
+  state: string;
+}
+
+class UpdateVanLocatorService {
+  public async execute({
+    id_van,
+    name,
+    address,
+    complement,
+    city,
+    state,
+  }: Request): Promise<VanLocator> {
+    const vansRepository = getRepository(Van);
+    const vansLocatorsRepository = getRepository(VanLocator);
+
+    const van = await vansRepository.findOne({
+      where: { id_van },
+    });
+
+    if (!van) {
+      throw new AppError('A van informada não existe.', 404);
+    }
+
+    if (!van.locator) {
+      throw new AppError(
+        'A van informada não possui um locador cadastrado.',
+        404,
+      );
+    }
+
+    if (name) van.locator.name = name
+    if (address) van.locator.address = address
+    if (complement) van.locator.complement = complement
+    if (city) van.locator.city = city
+    if (state) van.locator.state = state
+
+    await vansRepository.save(van);
+
+    return van.locator;
+  }
+}
+
+export default UpdateVanLocatorService;