cloud/tcc-vamos-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refatora Van para Vehicle

Browse Source
This commit is contained in:
Matheus Albino Brunhara
2022-09-03 19:39:07 -03:00
parent 7ce2e602cc
commit 0ff59fcfea
23 changed files with 368 additions and 469 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/database/migrations/1655691282002-CreateVansTable.ts → src/database/migrations/1655691282002-CreateVehiclesTable.ts
View File

@@ -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');
}
}

10
src/database/migrations/1655720873936-AddFKUserIdToVansTable.ts → src/database/migrations/1655720873936-AddFKUserIdToVehiclesTable.ts
View File

@@ -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',
'UserIdVan',
'vehicles',
'UserIdVehicle',
);
}
}

12
src/database/migrations/1659404395471-CreateItineraries.ts
View File

@@ -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
columnNames: ['van_plate'], // coluna que vai virar FK
name: 'itineraries_vehicle_plate_fk', // nome da FK, serve para referenciar numa exclusão pelo QueryRunner se necessário
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');
}
}

24
src/models/Itinerary.ts
View File

@@ -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()
created_at: Date;
// @CreateDateColumn()
// created_at: Date;
@UpdateDateColumn()
updated_at: Date;
// @UpdateDateColumn()
// updated_at: Date;
}
export default User;
export default Itinerary;

6
src/models/User.ts
View File

@@ -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)
van: Van[];
@OneToMany(() => Vehicle, vehicle => vehicle.user)
vehicle: Vehicle[];
@CreateDateColumn()
created_at: Date;

8
src/models/Van.ts → src/models/Vehicle.ts
View File

@@ -12,8 +12,8 @@ import {
} from 'typeorm';
import User from './User';
@Entity('vans')
class Van {
@Entity('vehicles')
class Vehicle {
@PrimaryColumn()
plate: string;
@@ -44,7 +44,7 @@ class Van {
@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;

6
src/routes/index.ts
View File

@@ -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;

98
src/routes/transports.routes.ts
View File

@@ -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;

8
src/routes/users.routes.ts
View File

@@ -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 });
},
);

142
src/routes/vans.routes.ts
View File

@@ -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;

139
src/routes/vehicles.routes.ts Normal file
View File

@@ -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;

12
src/services/CheckIfUserHasVansService.ts → src/services/CheckIfUserHasVehiclesService.ts
View File

@@ -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;

22
src/services/CreateVanService.ts → src/services/CreateVehicleService.ts
View File

@@ -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> {
const vansRepository = getRepository(Van);
}: Request): Promise<Vehicle> {
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;

25
src/services/FindVanLocatorService.ts
View File

@@ -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;

23
src/services/FindVanService.ts
View File

@@ -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;

33
src/services/FindVansByUserIdService.ts
View File

@@ -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;

25
src/services/FindVehicleLocatorService.ts Normal file
View File

@@ -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;

23
src/services/FindVehicleService.ts Normal file
View File

@@ -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;

33
src/services/FindVehiclesByUserIdService.ts Normal file
View File

@@ -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;

32
src/services/UpdateVanPlateService.ts
View File

@@ -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;

56
src/services/UpdateVanService.ts
View File

@@ -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;

32
src/services/UpdateVehiclePlateService.ts Normal file
View File

@@ -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;

56
src/services/UpdateVehicleService.ts Normal file
View File

@@ -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;