Refatora Van para Vehicle

src/database/migrations/1655691282002-CreateVehiclesTable.ts

@@ -1,10 +1,10 @@
 import { MigrationInterface, QueryRunner, Table } from 'typeorm';
 
-export class CreateVansTable1655691282002 implements MigrationInterface {
+export class CreateVehiclesTable1655691282002 implements MigrationInterface {
   public async up(queryRunner: QueryRunner): Promise<void> {
     await queryRunner.createTable(
       new Table({
-        name: 'vans',
+        name: 'vehicles',
         columns: [
           {
             name: 'user_id',
@@ -73,6 +73,6 @@ export class CreateVansTable1655691282002 implements MigrationInterface {
   }
 
   public async down(queryRunner: QueryRunner): Promise<void> {
-    await queryRunner.dropTable('vans');
+    await queryRunner.dropTable('vehicles');
   }
 }

src/database/migrations/1655720873936-AddFKUserIdToVehiclesTable.ts

@@ -1,11 +1,11 @@
 import { MigrationInterface, QueryRunner, TableForeignKey } from 'typeorm';
 
-export class AddFKUserIdToVansTable1655720873936 implements MigrationInterface {
+export class AddFKUserIdToVehiclesTable1655720873936 implements MigrationInterface {
   public async up(queryRunner: QueryRunner): Promise<void> {
     await queryRunner.createForeignKey(
-      'vans',
+      'vehicles',
       new TableForeignKey({
-        name: 'UserIdVan', // nome da FK, serve para referenciar numa exclusão pelo QueryRunner se necessário
+        name: 'UserIdVehicle', // 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
@@ -17,8 +17,8 @@ export class AddFKUserIdToVansTable1655720873936 implements MigrationInterface {
 
   public async down(queryRunner: QueryRunner): Promise<void> {
     await queryRunner.dropForeignKey(
-      'vans',
+      'vehicles',
-      'UserIdVan',
+      'UserIdVehicle',
     );
   }
 }

src/database/migrations/1659404395471-CreateItineraries.ts

@@ -14,7 +14,7 @@ export class CreateItineraries1659404395471 implements MigrationInterface {
             generationStrategy: 'increment',
           },
           {
-            name: 'van_plate',
+            name: 'vehicle_plate',
             type: 'varchar',
           },
           {
@@ -64,10 +64,10 @@ export class CreateItineraries1659404395471 implements MigrationInterface {
     await queryRunner.createForeignKey(
       'itineraries',
       new TableForeignKey({
-        name: 'itineraries_van_plate_fk', // nome da FK, serve para referenciar numa exclusão pelo QueryRunner se necessário
+        name: 'itineraries_vehicle_plate_fk', // nome da FK, serve para referenciar numa exclusão pelo QueryRunner se necessário
-        columnNames: ['van_plate'], // coluna que vai virar FK
+        columnNames: ['vehicle_plate'], // coluna que vai virar FK
         referencedColumnNames: ['plate'], // coluna PK da primeira tabela
-        referencedTableName: 'vans', // nome da tabela que possui a PK
+        referencedTableName: 'vehicles', // nome da tabela que possui a PK
         onDelete: 'SET NULL',
         onUpdate: 'CASCADE',
       }),
@@ -77,7 +77,7 @@ export class CreateItineraries1659404395471 implements MigrationInterface {
       'itineraries',
       new TableIndex({
         name: 'itineraries_idx',
-        columnNames: ['van_plate', 'days_of_week', 'specific_day', 'estimated_departure_time'],
+        columnNames: ['vehicle_plate', 'days_of_week', 'specific_day', 'estimated_departure_time'],
         isUnique: true,
       })
     );
@@ -85,7 +85,7 @@ export class CreateItineraries1659404395471 implements MigrationInterface {
 
   public async down(queryRunner: QueryRunner): Promise<void> {
     await queryRunner.dropTable('itineraries');
-    await queryRunner.dropForeignKey('itineraries', 'itineraries_van_plate_fk');
+    await queryRunner.dropForeignKey('itineraries', 'itineraries_vehicle_plate_fk');
     await queryRunner.dropIndex('itineraries', 'itineraries_idx');
   }
 }

src/models/Itinerary.ts

@@ -6,30 +6,30 @@ import {
   UpdateDateColumn,
   OneToMany,
 } from 'typeorm';
-import Van from './Van';
+import Vehicle from './Vehicle';
 
 @Entity('itineraries')
-class User {
+class Itinerary {
   @PrimaryGeneratedColumn('increment')
   id_itinerary: number;
 
   @Column()
-  van_plate: string;
+  vehicle_plate: string;
 
   @Column()
   price: number;
 
   @Column()
-  days_of_week: number;
+  days_of_week: string;
 
   @Column()
-  specific_day: Date;
+  specific_day?: Date;
 
   @Column()
-  estimated_departure_time: Date;
+  estimated_departure_time: string;
 
   @Column()
-  estimated_arrival_time: Date;
+  estimated_arrival_time: string;
 
   @Column()
   available_seats: number;
@@ -37,11 +37,11 @@ class User {
   @Column()
   itinerary_nickname: string;
 
-  @CreateDateColumn()
+  // @CreateDateColumn()
-  created_at: Date;
+  // created_at: Date;
 
-  @UpdateDateColumn()
+  // @UpdateDateColumn()
-  updated_at: Date;
+  // updated_at: Date;
 }
 
-export default User;
+export default Itinerary;

src/models/User.ts

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

src/models/Vehicle.ts

@@ -12,8 +12,8 @@ import {
 } from 'typeorm';
 import User from './User';
 
-@Entity('vans')
+@Entity('vehicles')
-class Van {
+class Vehicle {
   @PrimaryColumn()
   plate: string;
 
@@ -31,20 +31,20 @@ class Van {
 
   @Column()
   locator_name: string;
-  
+
   @Column()
   locator_address: string;
-  
+
   @Column()
   locator_complement: string;
-  
+
   @Column()
   locator_city: string;
 
   @Column()
   locator_state: string;
 
-  @ManyToOne(() => User, user => user.van)
+  @ManyToOne(() => User, user => user.vehicle)
   @JoinColumn({ name: 'user_id' })
   user: User;
 
@@ -55,4 +55,4 @@ class Van {
   updated_at: Date;
 }
 
-export default Van;
+export default Vehicle;

src/routes/index.ts

@@ -5,15 +5,15 @@ import sessionsRouter from './sessions.routes';
 import itinerariesRouter from './itineraries.routes';
 import usersRouter from './users.routes';
 import carsRouter from './cars.routes';
-import vansRouter from './vans.routes';
+import vehiclesRouter from './vehicles.routes';
 
 const routes = Router();
 
 routes.use('/users', usersRouter);
 routes.use('/sessions', sessionsRouter);
 routes.use('/search', searchRoutes);
-routes.use('/transports', itinerariesRouter);
+routes.use('/itineraries', itinerariesRouter);
 routes.use('/cars', carsRouter);
-routes.use('/vans', vansRouter);
+routes.use('/vehicles', vehiclesRouter);
 
 export default routes;

src/routes/transports.routes.ts

@@ -1,98 +0,0 @@
-import { Router } from 'express';
-import { getRepository } from 'typeorm';
-import CalculateDistanceBetweenCoords from '../services/CalculateDistanceBetweenCoords';
-
-const transporteRouter = Router();
-
-transporteRouter.post('/', async (request, response) => {
-  const { coordinatesFrom, coordinatesTo } = request.body;
-  console.log(coordinatesFrom, coordinatesTo);
-  const data = [
-    {
-      motorista: 'João',
-      valor: 'R$ 150,00',
-      lugares: '2',
-      avaliacao: '4.5',
-      bairros_atendidos: [{lat:-22.873432, lgn:-47.142274}],
-      destinos: [{lat:-22.833645, lgn:-47.048905}],
-    },
-    {
-      motorista: 'Ricardo',
-      valor: 'R$ 180,00',
-      lugares: '5',
-      avaliacao: '4.0',
-      bairros_atendidos: [{lat:-22.873432, lgn:-47.142274}],
-      destinos: [{lat:-22.833645, lgn:-47.048905}],
-    },
-    {
-      motorista: 'Luiz',
-      valor: 'R$ 200,00',
-      lugares: '1',
-      avaliacao: '4.3',
-      bairros_atendidos: [{lat:-22.873432, lgn:-47.142274}],
-      destinos: [{lat:-22.833645, lgn:-47.048905}],
-    },
-    {
-      motorista: 'Marcos',
-      valor: 'R$ 199,00',
-      lugares: '6',
-      avaliacao: '4.9',
-      bairros_atendidos: [{lat:-22.873432, lgn:-47.142274}],
-      destinos: [{lat:-22.833645, lgn:-47.048905}],
-    },
-    {
-      motorista: 'Orandi',
-      valor: 'R$ 210,00',
-      lugares: '8',
-      avaliacao: '5.0',
-      bairros_atendidos: [{lat:-22.873432, lgn:-47.142274}],
-      destinos: [{lat:-22.833645, lgn:-47.048905}],
-    },
-    {
-      motorista: 'Pedro',
-      valor: 'R$ 189,00',
-      lugares: '4',
-      avaliacao: '4.1',
-      bairros_atendidos: [{lat:-22.873432, lgn:-47.142274}],
-      destinos: [{lat:-22.833645, lgn:-47.048905}],
-    },
-    {
-      motorista: 'Pericles',
-      valor: 'R$ 220,00',
-      lugares: '19',
-      avaliacao: '4.5',
-      bairros_atendidos: [{lat:-23.873432, lgn:-47.142274}],
-      destinos: [{lat:-22.833645, lgn:-47.048905}],
-    },
-  ];
-
-  let lat_from:number = +coordinatesFrom.lat;
-  let lng_from:number = +coordinatesFrom.lng;
-  let lat_to:number = +coordinatesTo.lat;
-  let lng_to:number = +coordinatesTo.lng;
-
-  let transportsFiltered = data.filter(x => {
-    var distance = 0;
-    var distance2 = 0;
-    for (const i of x.bairros_atendidos) {
-      let lat2:number = +i.lat;
-      let lng2:number = +i.lgn;
-      distance = CalculateDistanceBetweenCoords({lat1:lat_from, lng1:lng_from, lat2, lng2});
-      if (distance <= 10) break;
-    }
-    
-    for (const j of x.destinos) {
-      let lat2:number = +j.lat;
-      let lng2:number = +j.lgn;
-      distance2 = CalculateDistanceBetweenCoords({lat1:lat_to, lng1:lng_to, lat2, lng2});
-      if (distance2 <= 10) break;
-    }
-
-    return (distance <= 10 && distance2 <= 10);
-  });
-
-  console.log(transportsFiltered)
-  return response.json(transportsFiltered);
-});
-
-export default transporteRouter;

src/routes/users.routes.ts

@@ -12,7 +12,7 @@ import UpdateUserService from '../services/UpdateUserService';
 import UpdateUserAvatarService from '../services/UpdateUserAvatarService';
 import UpdateUserPasswordService from '../services/UpdateUserPasswordService';
 import AuthenticateUserService from '../services/AuthenticateUserService';
-import CheckIfUserHasVansService from '../services/CheckIfUserHasVansService';
+import CheckIfUserHasVehiclesService from '../services/CheckIfUserHasVehiclesService';
 
 const usersRouter = Router();
 
@@ -134,13 +134,13 @@ usersRouter.get(
   async (request, response) => {
     const { id_user } = request.params;
 
-    const checkIfUserHasVansService = new CheckIfUserHasVansService();
+    const checkIfUserHasVehiclesService = new CheckIfUserHasVehiclesService();
 
-    const userHasVans = await checkIfUserHasVansService.execute({
+    const userHasVehicles = await checkIfUserHasVehiclesService.execute({
       id_user,
     });
 
-    return response.json({ result: userHasVans });
+    return response.json({ result: userHasVehicles });
   },
 );
 

src/routes/vans.routes.ts

@@ -1,142 +0,0 @@
-import { Router } from 'express';
-import { getRepository } from 'typeorm';
-import Van from '../models/Van';
-
-import ensureAuthenticated from '../middlewares/ensureAuthenticated';
-
-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();
-
-vansRouter.get('/list', async (request, response) => {
-  const vansRepository = getRepository(Van);
-
-  const vans = await vansRepository.find();
-
-  return response.json({ data: vans });
-});
-
-vansRouter.get(
-  '/plate/:plate',
-  ensureAuthenticated,
-  async (request, response) => {
-    const { plate } = request.params;
-
-    const findVanService = new FindVanService();
-
-    const van = await findVanService.execute(plate);
-
-    return response.json({ data: van });
-  },
-);
-
-vansRouter.get(
-  '/user/:id_user',
-  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('/', ensureAuthenticated, async (request, response) => {
-  const {
-    plate,
-    brand,
-    model,
-    seats_number,
-    locator_name,
-    locator_address,
-    locator_complement,
-    locator_city,
-    locator_state,
-  } = request.body;
-
-  const createVanService = new CreateVanService();
-
-  console.log('aaaaaaaaaaaaaaa');
-  console.log(request.user);
-
-  const van = await createVanService.execute({
-    id_user: request.user.id_user,
-    plate,
-    brand,
-    model,
-    seats_number,
-    locator_name,
-    locator_address,
-    locator_complement,
-    locator_city,
-    locator_state,
-  });
-
-  return response.json({ message: 'Van criada com sucesso.', data: van });
-});
-
-vansRouter.patch(
-  '/edit/:plate',
-  ensureAuthenticated,
-  async (request, response) => {
-    const {
-      brand,
-      model,
-      seats_number,
-      locator_name,
-      locator_address,
-      locator_complement,
-      locator_city,
-      locator_state,
-    } = request.body;
-
-    const { plate } = request.params;
-
-    const updateVanService = new UpdateVanService();
-
-    await updateVanService.execute({
-      plate,
-      brand,
-      model,
-      seats_number,
-      locator_name,
-      locator_address,
-      locator_complement,
-      locator_city,
-      locator_state,
-    });
-
-    return response.json({
-      message: 'Informações da van atualizadas com sucesso.',
-    });
-  },
-);
-
-vansRouter.patch(
-  '/edit/plate/:plate',
-  ensureAuthenticated,
-  async (request, response) => {
-    const { newPlate } = request.body;
-
-    const { plate } = request.params;
-
-    const updateVanPlateService = new UpdateVanPlateService();
-
-    await updateVanPlateService.execute({
-      oldPlate: plate,
-      newPlate,
-    });
-
-    return response.json({
-      message: 'Placa da van atualizada com sucesso.',
-    });
-  },
-);
-
-export default vansRouter;

src/routes/vehicles.routes.ts

@@ -0,0 +1,139 @@
+import { Router } from 'express';
+import { getRepository } from 'typeorm';
+import Vehicle from '../models/Vehicle';
+
+import ensureAuthenticated from '../middlewares/ensureAuthenticated';
+
+import FindVehicleService from '../services/FindVehicleService';
+import CreateVehicleService from '../services/CreateVehicleService';
+import UpdateVehicleService from '../services/UpdateVehicleService';
+import UpdateVehiclePlateService from '../services/UpdateVehiclePlateService';
+import FindVehicleByUserIdService from '../services/FindVehiclesByUserIdService';
+
+const vehiclesRouter = Router();
+
+vehiclesRouter.get('/list', async (request, response) => {
+  const vehiclesRepository = getRepository(Vehicle);
+
+  const vehicles = await vehiclesRepository.find();
+
+  return response.json({ data: vehicles });
+});
+
+vehiclesRouter.get(
+  '/plate/:plate',
+  ensureAuthenticated,
+  async (request, response) => {
+    const { plate } = request.params;
+
+    const findVehicleService = new FindVehicleService();
+
+    const vehicle = await findVehicleService.execute(plate);
+
+    return response.json({ data: vehicle });
+  },
+);
+
+vehiclesRouter.get(
+  '/user/:id_user',
+  async (request, response) => {
+    const { id_user } = request.params;
+
+    const findVehicleByUserIdService = new FindVehicleByUserIdService();
+
+    const vehicles = await findVehicleByUserIdService.execute(id_user);
+
+    return response.json({ data: vehicles });
+  },
+);
+
+vehiclesRouter.post('/', ensureAuthenticated, async (request, response) => {
+  const {
+    plate,
+    brand,
+    model,
+    seats_number,
+    locator_name,
+    locator_address,
+    locator_complement,
+    locator_city,
+    locator_state,
+  } = request.body;
+
+  const createVehicleService = new CreateVehicleService();
+
+  const vehicle = await createVehicleService.execute({
+    id_user: request.user.id_user,
+    plate,
+    brand,
+    model,
+    seats_number,
+    locator_name,
+    locator_address,
+    locator_complement,
+    locator_city,
+    locator_state,
+  });
+
+  return response.json({ message: 'Veículo criado com sucesso.', data: vehicle });
+});
+
+vehiclesRouter.patch(
+  '/edit/:plate',
+  ensureAuthenticated,
+  async (request, response) => {
+    const {
+      brand,
+      model,
+      seats_number,
+      locator_name,
+      locator_address,
+      locator_complement,
+      locator_city,
+      locator_state,
+    } = request.body;
+
+    const { plate } = request.params;
+
+    const updateVehicleService = new UpdateVehicleService();
+
+    await updateVehicleService.execute({
+      plate,
+      brand,
+      model,
+      seats_number,
+      locator_name,
+      locator_address,
+      locator_complement,
+      locator_city,
+      locator_state,
+    });
+
+    return response.json({
+      message: 'Informações da vehicle atualizadas com sucesso.',
+    });
+  },
+);
+
+vehiclesRouter.patch(
+  '/edit/plate/:plate',
+  ensureAuthenticated,
+  async (request, response) => {
+    const { newPlate } = request.body;
+
+    const { plate } = request.params;
+
+    const updateVehiclePlateService = new UpdateVehiclePlateService();
+
+    await updateVehiclePlateService.execute({
+      oldPlate: plate,
+      newPlate,
+    });
+
+    return response.json({
+      message: 'Placa da vehicle atualizada com sucesso.',
+    });
+  },
+);
+
+export default vehiclesRouter;

src/services/CheckIfUserHasVehiclesService.ts

@@ -3,16 +3,16 @@ import { getRepository } from 'typeorm';
 import AppError from '../errors/AppError';
 
 import User from '../models/User';
-import Van from '../models/Van';
+import Vehicle from '../models/Vehicle';
 
 interface Request {
   id_user: string;
 }
 
-class CheckIfUserHasVansService {
+class CheckIfUserHasVehiclesService {
   public async execute({ id_user }: Request): Promise<Boolean> {
     const usersRepository = getRepository(User);
-    const vansRepository = getRepository(Van);
+    const vehiclesRepository = getRepository(Vehicle);
 
     const user = await usersRepository.findOne({
       where: { id_user },
@@ -22,12 +22,12 @@ class CheckIfUserHasVansService {
       throw new AppError('O usuário informado não foi encontrado.', 404);
     }
 
-    const vanExists = await vansRepository.findOne({
+    const vehicleExists = await vehiclesRepository.findOne({
       where: { user },
     });
 
-    return !!vanExists
+    return !!vehicleExists
   }
 }
 
-export default CheckIfUserHasVansService;
+export default CheckIfUserHasVehiclesService;

src/services/CreateVehicleService.ts

@@ -3,7 +3,7 @@ import { getRepository } from 'typeorm';
 import AppError from '../errors/AppError';
 import User from '../models/User';
 
-import Van from '../models/Van';
+import Vehicle from '../models/Vehicle';
 
 interface Request {
   id_user: string;
@@ -18,7 +18,7 @@ interface Request {
   locator_state: string;
 }
 
-class CreateVanService {
+class CreateVehicleService {
   public async execute({
     id_user,
     plate,
@@ -30,8 +30,8 @@ class CreateVanService {
     locator_complement,
     locator_city,
     locator_state,
-  }: Request): Promise<Van> {
+  }: Request): Promise<Vehicle> {
-    const vansRepository = getRepository(Van);
+    const vehiclesRepository = getRepository(Vehicle);
     const usersRepository = getRepository(User);
 
     const user = await usersRepository.findOne({
@@ -45,18 +45,18 @@ class CreateVanService {
       );
     }
 
-    const vanExists = await vansRepository.findOne({
+    const vehicleExists = await vehiclesRepository.findOne({
       where: { plate },
     });
 
-    if (vanExists) {
+    if (vehicleExists) {
       throw new AppError(
-        'Uma van com a placa informada já foi cadastrada.',
+        'Uma vehicle com a placa informada já foi cadastrada.',
         409,
       );
     }
 
-    const van = vansRepository.create({
+    const vehicle = vehiclesRepository.create({
       user,
       plate,
       brand,
@@ -70,10 +70,10 @@ class CreateVanService {
       locator_state,
     });
 
-    await vansRepository.save(van);
+    await vehiclesRepository.save(vehicle);
 
-    return van;
+    return vehicle;
   }
 }
 
-export default CreateVanService;
+export default CreateVehicleService;

src/services/FindVanLocatorService.ts

@@ -1,25 +0,0 @@
-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/FindVanService.ts

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

src/services/FindVansByUserIdService.ts

@@ -1,33 +0,0 @@
-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/FindVehicleLocatorService.ts

@@ -0,0 +1,25 @@
+import { getRepository } from 'typeorm';
+
+import AppError from '../errors/AppError';
+
+import Vehicle from '../models/Vehicle';
+import VehicleLocator from '../models/VehicleLocator';
+
+class FindVehicleLocatorService {
+  public async execute(id_vehicle: string): Promise<VehicleLocator> {
+    const vehiclesRepository = getRepository(Vehicle);
+    const vehiclesLocatorsRepository = getRepository(VehicleLocator);
+
+    const vehicle = await vehiclesRepository.findOne({
+      where: { id_vehicle }
+    });
+
+    if (!vehicle) {
+      throw new AppError('A Vehicle informada não existe.', 404);
+    };
+
+    return vehicle.locator;
+  }
+}
+
+export default FindVehicleLocatorService;

src/services/FindVehicleService.ts

@@ -0,0 +1,23 @@
+import { getRepository } from 'typeorm';
+
+import AppError from '../errors/AppError';
+
+import Vehicle from '../models/Vehicle';
+
+class FindVehicleService {
+  public async execute(plate: string): Promise<Vehicle> {
+    const vehiclesRepository = getRepository(Vehicle);
+
+    const vehicle = await vehiclesRepository.findOne({
+      where: { plate }
+    });
+
+    if (!vehicle) {
+      throw new AppError('A vehicle informada não existe.');
+    };
+
+    return vehicle;
+  }
+}
+
+export default FindVehicleService;

src/services/FindVehiclesByUserIdService.ts

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

src/services/UpdateVanPlateService.ts

@@ -1,32 +0,0 @@
-import { getRepository } from 'typeorm';
-
-import AppError from '../errors/AppError';
-
-import Van from '../models/Van';
-
-interface Request {
-  oldPlate: string;
-  newPlate: string;
-}
-
-class UpdateVanPlateService {
-  public async execute({ oldPlate, newPlate }: Request): Promise<Van> {
-    const vansRepository = getRepository(Van);
-
-    const van = await vansRepository.findOne({
-      where: { plate: oldPlate },
-    });
-
-    if (!van) {
-      throw new AppError('A van informada não existe.');
-    }
-
-    van.plate = newPlate
-
-    await vansRepository.save(van);
-
-    return van;
-  }
-}
-
-export default UpdateVanPlateService;

src/services/UpdateVanService.ts

@@ -1,56 +0,0 @@
-import { getRepository } from 'typeorm';
-
-import AppError from '../errors/AppError';
-
-import Van from '../models/Van';
-
-interface Request {
-  plate: string;
-  brand?: string;
-  model?: string;
-  seats_number?: string;
-  locator_name?: string;
-  locator_address?: string;
-  locator_complement?: string;
-  locator_city?: string;
-  locator_state?: string;
-}
-
-class UpdateVanService {
-  public async execute({
-    plate,
-    brand,
-    model,
-    seats_number,
-    locator_name,
-    locator_address,
-    locator_complement,
-    locator_city,
-    locator_state,
-  }: Request): Promise<Van> {
-    const vansRepository = getRepository(Van);
-
-    const van = await vansRepository.findOne({
-      where: { plate },
-    });
-
-    if (!van) {
-      throw new AppError('A van informada não existe.');
-    }
-
-    if (brand) van.brand = brand
-    if (model) van.model = model
-    if (seats_number) van.seats_number = seats_number
-    if (locator_name) van.locator_name = locator_name
-    if (locator_address) van.locator_address = locator_address
-    if (locator_complement) van.locator_complement = locator_complement
-    if (locator_city) van.locator_city = locator_city
-    if (locator_state) van.locator_state = locator_state
-
-    await vansRepository.save(van);
-
-    return van;
-  }
-}
-
-export default UpdateVanService;

src/services/UpdateVehiclePlateService.ts

@@ -0,0 +1,32 @@
+import { getRepository } from 'typeorm';
+
+import AppError from '../errors/AppError';
+
+import Vehicle from '../models/Vehicle';
+
+interface Request {
+  oldPlate: string;
+  newPlate: string;
+}
+
+class UpdateVehiclePlateService {
+  public async execute({ oldPlate, newPlate }: Request): Promise<Vehicle> {
+    const vehiclesRepository = getRepository(Vehicle);
+
+    const vehicle = await vehiclesRepository.findOne({
+      where: { plate: oldPlate },
+    });
+
+    if (!vehicle) {
+      throw new AppError('A vehicle informada não existe.');
+    }
+
+    vehicle.plate = newPlate
+
+    await vehiclesRepository.save(vehicle);
+
+    return vehicle;
+  }
+}
+
+export default UpdateVehiclePlateService;

src/services/UpdateVehicleService.ts

@@ -0,0 +1,56 @@
+import { getRepository } from 'typeorm';
+
+import AppError from '../errors/AppError';
+
+import Vehicle from '../models/Vehicle';
+
+interface Request {
+  plate: string;
+  brand?: string;
+  model?: string;
+  seats_number?: string;
+  locator_name?: string;
+  locator_address?: string;
+  locator_complement?: string;
+  locator_city?: string;
+  locator_state?: string;
+}
+
+class UpdateVehicleService {
+  public async execute({
+    plate,
+    brand,
+    model,
+    seats_number,
+    locator_name,
+    locator_address,
+    locator_complement,
+    locator_city,
+    locator_state,
+  }: Request): Promise<Vehicle> {
+    const vehiclesRepository = getRepository(Vehicle);
+
+    const vehicle = await vehiclesRepository.findOne({
+      where: { plate },
+    });
+
+    if (!vehicle) {
+      throw new AppError('A vehicle informada não existe.');
+    }
+
+    if (brand) vehicle.brand = brand
+    if (model) vehicle.model = model
+    if (seats_number) vehicle.seats_number = seats_number
+    if (locator_name) vehicle.locator_name = locator_name
+    if (locator_address) vehicle.locator_address = locator_address
+    if (locator_complement) vehicle.locator_complement = locator_complement
+    if (locator_city) vehicle.locator_city = locator_city
+    if (locator_state) vehicle.locator_state = locator_state
+
+    await vehiclesRepository.save(vehicle);
+
+    return vehicle;
+  }
+}
+
+export default UpdateVehicleService;