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

Merge pull request #4 from Hzin/VAN-45-create-view-search-itinerary

Browse Source 
Van 45 create view search itinerary
This commit is contained in:
CloudAlb
2022-09-09 20:55:10 -03:00
committed by GitHub
parent 7f95452fc9 405c5f8300
commit 79cefe3c34
46 changed files with 1372 additions and 681 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
src/constants/itineraryExample.ts Normal file
View File

@@ -0,0 +1,43 @@
import Destination from "../models/Destination";
import Itinerary from "../models/Itinerary";
import NeighborhoodServed from "../models/NeighborhoodServed";
const itineraryExample: Itinerary = {
id_itinerary: 1,
vehicle_plate: 'ABC1234',
price: 120.00,
days_of_week: '0111110',
specific_day: undefined,
estimated_departure_time: '17:40:00',
estimated_arrival_time: '19:00:00',
available_seats: 5,
itinerary_nickname: 'Van do Osva',
// created_at: new Date('2022-09-03T20:54:04'),
// updated_at: new Date('2022-09-03T20:54:05'),
};
const neighborhoodsServed: NeighborhoodServed[] = [
{
id_neighborhood: 1,
itinerary: itineraryExample,
name: 'Parque Jambeiro',
latitude: -22.962812284675504,
longitude: -47.0504998323243,
// created_at: new Date('2022-09-03T20:54:04'),
// updated_at: new Date('2022-09-03T20:54:05'),
}
];
const destinations: Destination[] = [
{
id_destination: 1,
itinerary: itineraryExample,
name: 'PUC Campinas 1',
latitude: -22.83427688865263,
longitude: -47.048043986779355,
// created_at: new Date('2022-09-03T20:54:04'),
// updated_at: new Date('2022-09-03T20:54:05'),
}
];
export default { itineraryExample, neighborhoodsServed, destinations };

3
src/constants/mapRadiusConfig.ts Normal file
View File

@@ -0,0 +1,3 @@
const maxRadius = 10
export default maxRadius

27
src/database/migrations/1617210132141-CreateUsers.ts
View File

@@ -17,12 +17,25 @@ export class CreateUsers1617210132141 implements MigrationInterface {
name: 'name',
type: 'varchar',
},
{
name: 'lastname',
type: 'varchar',
},
{
name: 'email',
type: 'varchar',
length: '255',
isUnique: true,
},
// {
// name: 'cpf',
// type: 'varchar',
// isUnique: true,
// },
// {
// name: 'cnpj',
// type: 'varchar',
// isUnique: true,
// },
{
name: 'phone_number',
type: 'varchar',
@@ -32,7 +45,7 @@ export class CreateUsers1617210132141 implements MigrationInterface {
},
{
name: 'birth_date',
type: 'date',
type: 'varchar',
},
{
name: 'password',
@@ -55,6 +68,16 @@ export class CreateUsers1617210132141 implements MigrationInterface {
scale: 2,
isNullable: true
},
{
name: 'document',
type: 'varchar',
isNullable: true
},
{
name: 'document_type',
type: 'varchar',
isNullable: true
},
{
name: 'created_at',
type: 'timestamp',

15
src/database/migrations/1653437653433-AlterUsersTableAddLastnameColumn.ts
View File

@@ -1,15 +0,0 @@
import {MigrationInterface, QueryRunner, TableColumn} from "typeorm";
export class AlterUsersTableAddLastnameColumn1653437653433 implements MigrationInterface {
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.addColumn('users', new TableColumn({
name: 'lastname',
type: 'varchar',
isNullable: true
}))
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropColumn('users', 'lastname')
}
}

28
src/database/migrations/1653768789073-CreateCarModelsTable.ts
View File

@@ -1,28 +0,0 @@
import { MigrationInterface, QueryRunner, Table } from 'typeorm';
export class CreateCarModelsTable1653768789073 implements MigrationInterface {
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.createTable(
new Table({
name: 'carModels',
columns: [
{
name: 'id_model',
type: 'uuid',
isPrimary: true,
generationStrategy: 'uuid',
default: 'uuid_generate_v4()',
},
{
name: 'name',
type: 'varchar',
}
],
}),
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropTable('carModels');
}
}

20
src/database/migrations/1653769103891-InsertDataIntoCarModelsTable.ts
View File

@@ -1,20 +0,0 @@
import { getConnection, MigrationInterface, QueryRunner } from "typeorm";
import carModels from '../../constants/carModels'
import CarModels from "../../models/CarModels";
export class InsertDataIntoCarModelsTable1653769103891 implements MigrationInterface {
public async up(queryRunner: QueryRunner): Promise<void> {
carModels.forEach(async (car) => {
const GBP = await queryRunner.manager.save(queryRunner.manager.create<CarModels>(CarModels, { name: car.name }))
}
)}
public async down(queryRunner: QueryRunner): Promise<void> {
await getConnection()
.createQueryBuilder()
.delete()
.from(CarModels)
.execute();
}
}

24
src/database/migrations/1654814986232-AddCpfAndCnpjFieldToUsers.ts
View File

@@ -1,24 +0,0 @@
import { MigrationInterface, QueryRunner, TableColumn } from 'typeorm';
export class AddCpfAndCnpjFieldToUsers1654814986232
implements MigrationInterface
{
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.addColumns('users', [
new TableColumn({
name: 'cpf',
type: 'varchar',
isNullable: true,
}),
new TableColumn({
name: 'cnpj',
type: 'varchar',
isNullable: true,
}),
]);
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropColumns('users', ['cnpj', 'cpf']);
}
}

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

@@ -1,11 +1,15 @@
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',
type: 'uuid',
},
{
name: 'plate',
type: 'varchar',
@@ -69,6 +73,6 @@ export class CreateVansTable1655691282002 implements MigrationInterface {
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropTable('vans');
await queryRunner.dropTable('vehicles');
}
}

24
src/database/migrations/1655711281662-RemoveCpfAndCnpjFieldsFromUsersTable.ts
View File

@@ -1,24 +0,0 @@
import { MigrationInterface, QueryRunner, TableColumn } from 'typeorm';
export class RemoveCpfAndCnpjFieldsFromUsersTable1655711281662
implements MigrationInterface
{
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropColumns('users', ['cnpj', 'cpf']);
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.addColumns('users', [
new TableColumn({
name: 'cpf',
type: 'varchar',
isNullable: true,
}),
new TableColumn({
name: 'cnpj',
type: 'varchar',
isNullable: true,
}),
]);
}
}

24
src/database/migrations/1655711315251-AddDocumentAndDocumentTypeFieldsToUsersTable.ts
View File

@@ -1,24 +0,0 @@
import { MigrationInterface, QueryRunner, TableColumn } from 'typeorm';
export class AddDocumentAndDocumentTypeFieldsToUsersTable1655711315251
implements MigrationInterface
{
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.addColumns('users', [
new TableColumn({
name: 'document',
type: 'varchar',
isNullable: true,
}),
new TableColumn({
name: 'document_type',
type: 'varchar',
isNullable: true,
}),
]);
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropColumns('users', ['document_type', 'document']);
}
}

20
src/database/migrations/1655720865095-AddUserIdFieldToVansTable.ts
View File

@@ -1,20 +0,0 @@
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');
}
}

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

119
src/database/migrations/1659404395471-CreateItineraries.ts Normal file
View File

@@ -0,0 +1,119 @@
import {
MigrationInterface,
QueryRunner,
Table,
TableForeignKey,
TableIndex,
} from 'typeorm';
export class CreateItineraries1659404395471 implements MigrationInterface {
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.createTable(
new Table({
name: 'itineraries',
columns: [
{
name: 'id_itinerary',
type: 'integer',
isPrimary: true,
isGenerated: true,
generationStrategy: 'increment',
},
{
name: 'vehicle_plate',
type: 'varchar',
},
{
name: 'price',
type: 'float',
},
{
name: 'days_of_week',
type: 'varchar',
isNullable: true,
},
{
name: 'specific_day',
type: 'date',
isNullable: true,
},
{
name: 'estimated_departure_time',
type: 'time',
},
{
name: 'estimated_arrival_time',
type: 'time',
},
{
name: 'available_seats',
type: 'integer',
},
{
name: 'itinerary_nickname',
type: 'varchar',
},
{
name: 'is_active',
type: 'boolean',
},
{
name: 'estimated_departure_address',
type: 'varchar',
},
{
name: 'departure_latitude',
type: 'numeric',
},
{
name: 'departure_longitude',
type: 'numeric',
},
{
name: 'created_at',
type: 'timestamp',
default: 'now()',
},
{
name: 'updated_at',
type: 'timestamp',
default: 'now()',
},
],
}),
);
await queryRunner.createForeignKey(
'itineraries',
new TableForeignKey({
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: 'vehicles', // nome da tabela que possui a PK
onDelete: 'SET NULL',
onUpdate: 'CASCADE',
}),
);
await queryRunner.createIndex(
'itineraries',
new TableIndex({
name: 'itineraries_idx',
columnNames: [
'vehicle_plate',
'days_of_week',
'specific_day',
'estimated_departure_time',
'is_active',
],
isUnique: true,
}),
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropTable('itineraries');
await queryRunner.dropForeignKey('itineraries', 'itineraries_vehicle_plate_fk');
await queryRunner.dropIndex('itineraries', 'itineraries_idx');
}
}

123
src/database/migrations/1659404395471-CreateItineraries.ts.orig Normal file
View File

@@ -0,0 +1,123 @@
import {
MigrationInterface,
QueryRunner,
Table,
TableForeignKey,
TableIndex,
} from 'typeorm';
export class CreateItineraries1659404395471 implements MigrationInterface {
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.createTable(
new Table({
name: 'itineraries',
columns: [
{
name: 'id_itinerary',
type: 'integer',
isPrimary: true,
isGenerated: true,
generationStrategy: 'increment',
},
{
name: 'vehicle_plate',
type: 'varchar',
},
{
name: 'price',
type: 'float',
},
{
name: 'days_of_week',
type: 'varchar',
isNullable: true,
},
{
name: 'specific_day',
type: 'date',
isNullable: true,
},
{
name: 'estimated_departure_time',
type: 'time',
},
{
name: 'estimated_arrival_time',
type: 'time',
},
{
name: 'available_seats',
type: 'integer',
},
{
name: 'itinerary_nickname',
type: 'varchar',
},
{
name: 'is_active',
type: 'boolean',
},
{
name: 'estimated_departure_address',
type: 'varchar',
},
{
name: 'departure_latitude',
type: 'numeric',
},
{
name: 'departure_longitude',
type: 'numeric',
},
{
name: 'created_at',
type: 'timestamp',
default: 'now()',
},
{
name: 'updated_at',
type: 'timestamp',
default: 'now()',
},
],
}),
);
await queryRunner.createForeignKey(
'itineraries',
new TableForeignKey({
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: 'vehicles', // nome da tabela que possui a PK
onDelete: 'SET NULL',
onUpdate: 'CASCADE',
}),
);
await queryRunner.createIndex(
'itineraries',
new TableIndex({
name: 'itineraries_idx',
<<<<<<< HEAD
columnNames: ['vehicle_plate', 'days_of_week', 'specific_day', 'estimated_departure_time'],
=======
columnNames: [
'van_plate',
'days_of_week',
'specific_day',
'estimated_departure_time',
'is_active',
],
>>>>>>> c1c8dc7a5ec1043bff7ae027e0b959e0cc561254
isUnique: true,
}),
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropTable('itineraries');
await queryRunner.dropForeignKey('itineraries', 'itineraries_vehicle_plate_fk');
await queryRunner.dropIndex('itineraries', 'itineraries_idx');
}
}

55
src/database/migrations/1660009211327-CreateNeighborhoodsServed.ts Normal file
View File

@@ -0,0 +1,55 @@
import { MigrationInterface, QueryRunner, Table, TableForeignKey } from 'typeorm';
export class CreateNeighborhoodsServed1660009211327
implements MigrationInterface
{
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.createTable(
new Table({
name: 'neighborhoods_served',
columns: [
{
name: 'id_neighborhood',
type: 'integer',
isPrimary: true,
isGenerated: true,
generationStrategy: 'increment',
},
{
name: 'itinerary_id',
type: 'integer',
},
{
name: 'name',
type: 'varchar',
},
{
name: 'latitude',
type: 'numeric',
},
{
name: 'longitude',
type: 'numeric',
}
],
}),
);
await queryRunner.createForeignKey(
'neighborhoods_served',
new TableForeignKey({
name: 'neighborhoods_served_itinerary_id_fk', // nome da FK, serve para referenciar numa exclusão pelo QueryRunner se necessário
columnNames: ['itinerary_id'], // coluna que vai virar FK
referencedColumnNames: ['id_itinerary'], // coluna PK da tabela referenciada
referencedTableName: 'itineraries', // nome da tabela que possui a PK
onDelete: 'SET NULL',
onUpdate: 'CASCADE',
}),
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropForeignKey('neighborhoods_served', 'neighborhoods_served_itinerary_id_fk');
await queryRunner.dropTable('neighborhoods_served');
}
}

53
src/database/migrations/1660009323138-CreateDestinations.ts Normal file
View File

@@ -0,0 +1,53 @@
import { MigrationInterface, QueryRunner, Table, TableForeignKey } from 'typeorm';
export class CreateDestinations1660009323138 implements MigrationInterface {
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.createTable(
new Table({
name: 'destinations',
columns: [
{
name: 'id_destination',
type: 'integer',
isPrimary: true,
isGenerated: true,
generationStrategy: 'increment',
},
{
name: 'itinerary_id',
type: 'integer',
},
{
name: 'name',
type: 'varchar',
},
{
name: 'latitude',
type: 'numeric',
},
{
name: 'longitude',
type: 'numeric',
},
],
}),
);
await queryRunner.createForeignKey(
'destinations',
new TableForeignKey({
name: 'destinations_itinerary_id_fk', // nome da FK, serve para referenciar numa exclusão pelo QueryRunner se necessário
columnNames: ['itinerary_id'], // coluna que vai virar FK
referencedColumnNames: ['id_itinerary'], // coluna PK da tabela referenciada
referencedTableName: 'itineraries', // nome da tabela que possui a PK
onDelete: 'SET NULL',
onUpdate: 'CASCADE',
}),
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropTable('destinations');
await queryRunner.dropForeignKey('destinations', 'destinations_itinerary_id_fk');
}
}

93
src/database/migrations/1660010452826-CreatePassengers.ts Normal file
View File

@@ -0,0 +1,93 @@
import {
MigrationInterface,
QueryRunner,
Table,
TableForeignKey,
TableIndex,
} from 'typeorm';
export class CreatePassengers1660010452826 implements MigrationInterface {
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.createTable(
new Table({
name: 'passengers',
columns: [
{
name: 'id_passenger',
type: 'integer',
isPrimary: true,
isGenerated: true,
generationStrategy: 'increment',
},
{
name: 'itinerary_id',
type: 'integer',
},
{
name: 'user_id',
type: 'uuid',
},
{
name: 'address',
type: 'varchar',
},
{
name: 'latitude_address',
type: 'numeric',
},
{
name: 'longitude_address',
type: 'numeric',
},
{
name: 'payment_status',
type: 'boolean',
},
],
}),
);
await queryRunner.createForeignKey(
'passengers',
new TableForeignKey({
name: 'passengers_itinerary_id_fk', // nome da FK, serve para referenciar numa exclusão pelo QueryRunner se necessário
columnNames: ['itinerary_id'], // coluna que vai virar FK
referencedColumnNames: ['id_itinerary'], // coluna PK da tabela referenciada
referencedTableName: 'itineraries', // nome da tabela que possui a PK
onDelete: 'SET NULL',
onUpdate: 'CASCADE',
}),
);
await queryRunner.createForeignKey(
'passengers',
new TableForeignKey({
name: 'passengers_user_id_fk', // 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 tabela referenciada
referencedTableName: 'users', // nome da tabela que possui a PK
onDelete: 'SET NULL',
onUpdate: 'CASCADE',
}),
);
await queryRunner.createIndex(
'passengers',
new TableIndex({
name: 'passengers_itinerary_user_idx',
columnNames: ['itinerary_id', 'user_id'],
isUnique: true,
}),
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropTable('passengers');
await queryRunner.dropForeignKey(
'passengers',
'passengers_itinerary_id_fk',
);
await queryRunner.dropForeignKey('passengers', 'passengers_user_id_fk');
await queryRunner.dropIndex('passengers', 'passengers_itinerary_user_idx');
}
}

76
src/database/migrations/1660010491828-CreateRouteHistoric.ts Normal file
View File

@@ -0,0 +1,76 @@
import { MigrationInterface, QueryRunner, Table, TableForeignKey, TableIndex } from 'typeorm';
export class CreateRouteHistoric1660010491828 implements MigrationInterface {
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.createTable(
new Table({
name: 'route_historic',
columns: [
{
name: 'id_historic',
type: 'integer',
isPrimary: true,
isGenerated: true,
generationStrategy: 'increment',
},
{
name: 'itinerary_id',
type: 'integer',
},
{
name: 'user_id',
type: 'uuid',
},
{
name: 'is_return',
type: 'boolean',
},
{
name: 'date',
type: 'date',
},
],
}),
);
await queryRunner.createForeignKey(
'route_historic',
new TableForeignKey({
name: 'route_historic_itinerary_id_fk', // nome da FK, serve para referenciar numa exclusão pelo QueryRunner se necessário
columnNames: ['itinerary_id'], // coluna que vai virar FK
referencedColumnNames: ['id_itinerary'], // coluna PK da tabela referenciada
referencedTableName: 'itineraries', // nome da tabela que possui a PK
onDelete: 'SET NULL',
onUpdate: 'CASCADE',
}),
);
await queryRunner.createForeignKey(
'route_historic',
new TableForeignKey({
name: 'route_historic_user_id_fk', // 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 tabela referenciada
referencedTableName: 'users', // nome da tabela que possui a PK
onDelete: 'SET NULL',
onUpdate: 'CASCADE',
}),
);
await queryRunner.createIndex(
'route_historic',
new TableIndex({
name: 'itinerary_historic_idx',
columnNames: ['itinerary_id', 'user_id', 'is_return', 'date'],
isUnique: true,
}),
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropTable('route_historic');
await queryRunner.dropForeignKey('route_historic', 'route_historic_itinerary_id_fk');
await queryRunner.dropForeignKey('route_historic', 'route_historic_user_id_fk');
await queryRunner.dropIndex('route_historic', 'itinerary_historic_idx');
}
}

28
src/database/migrations/1661199963221-AlterUsersTableEditBirthDateFieldTypeToString.ts
View File

@@ -1,28 +0,0 @@
import {MigrationInterface, QueryRunner, TableColumn} from "typeorm";
export class AlterUsersTableEditBirthDateFieldTypeToString1661199963221 implements MigrationInterface {
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropColumn('users', 'birth_date')
await queryRunner.addColumn('users', new TableColumn(
{
name: 'birth_date',
type: 'varchar',
isNullable: true
},
))
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropColumn('users', 'birth_date')
await queryRunner.addColumn('users', new TableColumn(
{
name: 'birth_date',
type: 'date',
isNullable: true
},
))
}
}

15
src/database/migrations/1661212542739-RenameCarModelsTableToCarBrands.ts
View File

@@ -1,15 +0,0 @@
import {MigrationInterface, QueryRunner} from "typeorm";
export class RenameCarModelsTableToCarBrands1661212542739 implements MigrationInterface {
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.renameTable('carModels', 'carBrands')
await queryRunner.renameColumn('carBrands', 'id_model', 'id_brand')
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.renameTable('carBrands', 'carModels')
await queryRunner.renameColumn('carBrands', 'id_brand', 'id_model')
}
}

28
src/database/migrations/1661745915711-DropCarBrandsTable.ts
View File

@@ -1,28 +0,0 @@
import {MigrationInterface, QueryRunner, Table} from "typeorm";
export class DropCarBrandsTable1661745915711 implements MigrationInterface {
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropTable('carBrands')
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.createTable(
new Table({
name: 'carModels',
columns: [
{
name: 'id_brand',
type: 'uuid',
isPrimary: true,
generationStrategy: 'uuid',
default: 'uuid_generate_v4()',
},
{
name: 'name',
type: 'varchar',
}
],
}),
);
}
}

107
src/database/migrations/1662081949950-CreatePassengersRequests.ts Normal file
View File

@@ -0,0 +1,107 @@
import {
MigrationInterface,
QueryRunner,
Table,
TableForeignKey,
TableIndex,
} from 'typeorm';
export class CreatePassengersRequests1662081949950
implements MigrationInterface
{
public async up(queryRunner: QueryRunner): Promise<void> {
await queryRunner.createTable(
new Table({
name: 'passengers_requests',
columns: [
{
name: 'id_request',
type: 'integer',
isPrimary: true,
isGenerated: true,
generationStrategy: 'increment',
},
{
name: 'itinerary_id',
type: 'integer',
},
{
name: 'user_id',
type: 'uuid',
},
{
name: 'status',
type: 'enum',
enum: ['pending', 'accepted', 'rejected'],
},
{
name: 'created_at',
type: 'timestamp',
default: 'now()',
},
{
name: 'address',
type: 'varchar',
},
{
name: 'latitude_address',
type: 'numeric',
},
{
name: 'longitude_address',
type: 'numeric',
},
],
}),
);
await queryRunner.createForeignKey(
'passengers_requests',
new TableForeignKey({
name: 'passengers_requests_itinerary_id_fk', // nome da FK, serve para referenciar numa exclusão pelo QueryRunner se necessário
columnNames: ['itinerary_id'], // coluna que vai virar FK
referencedColumnNames: ['id_itinerary'], // coluna PK da tabela referenciada
referencedTableName: 'itineraries', // nome da tabela que possui a PK
onDelete: 'SET NULL',
onUpdate: 'CASCADE',
}),
);
await queryRunner.createForeignKey(
'passengers_requests',
new TableForeignKey({
name: 'passengers_requests_user_id_fk', // 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 tabela referenciada
referencedTableName: 'users', // nome da tabela que possui a PK
onDelete: 'SET NULL',
onUpdate: 'CASCADE',
}),
);
await queryRunner.createIndex(
'passengers_requests',
new TableIndex({
name: 'passengers_requests_idx',
columnNames: ['itinerary_id', 'user_id', 'status', 'created_at'],
isUnique: true,
}),
);
}
public async down(queryRunner: QueryRunner): Promise<void> {
await queryRunner.dropTable('passengers_requests');
await queryRunner.dropForeignKey(
'passengers_requests',
'passengers_requests_itinerary_id_fk',
);
await queryRunner.dropForeignKey(
'passengers_requests',
'passengers_requests_user_id_fk',
);
await queryRunner.dropIndex(
'passengers_requests',
'passengers_requests_idx',
);
}
}

37
src/models/Destination.ts Normal file
View File

@@ -0,0 +1,37 @@
import {
Entity,
Column,
PrimaryGeneratedColumn,
CreateDateColumn,
UpdateDateColumn,
ManyToOne,
JoinColumn,
} from 'typeorm';
import Itinerary from './Itinerary';
@Entity('destinations')
class Destination {
@PrimaryGeneratedColumn('increment')
id_destination: number;
@ManyToOne(() => Itinerary, itinerary => itinerary.destinations)
@JoinColumn({ name: 'itinerary_id' })
itinerary: Itinerary;
@Column()
name: string;
@Column()
latitude: number;
@Column()
longitude: number;
// @CreateDateColumn()
// created_at: Date;
// @UpdateDateColumn()
// updated_at: Date;
}
export default Destination;

56
src/models/Itinerary.ts Normal file
View File

@@ -0,0 +1,56 @@
import {
Entity,
Column,
PrimaryGeneratedColumn,
CreateDateColumn,
UpdateDateColumn,
OneToMany,
JoinColumn,
} from 'typeorm';
import Destination from './Destination';
import NeighborhoodServed from './NeighborhoodServed';
import Vehicle from './Vehicle';
@Entity('itineraries')
class Itinerary {
@PrimaryGeneratedColumn('increment')
id_itinerary: number;
@Column()
vehicle_plate: string;
@Column()
price: number;
@Column()
days_of_week: string;
@Column()
specific_day?: Date;
@Column()
estimated_departure_time: string;
@Column()
estimated_arrival_time: string;
@Column()
available_seats: number;
@Column()
itinerary_nickname: string;
@OneToMany(() => NeighborhoodServed, neighborhoodServed => neighborhoodServed.itinerary, { eager: true, cascade: true, nullable: true })
neighborhoodsServed?: NeighborhoodServed[];
@OneToMany(() => Destination, destination => destination.itinerary, { eager: true, cascade: true, nullable: true })
destinations?: Destination[];
// @CreateDateColumn()
// created_at: Date;
// @UpdateDateColumn()
// updated_at: Date;
}
export default Itinerary;

37
src/models/NeighborhoodServed.ts Normal file
View File

@@ -0,0 +1,37 @@
import {
Entity,
Column,
PrimaryGeneratedColumn,
CreateDateColumn,
UpdateDateColumn,
ManyToOne,
JoinColumn,
} from 'typeorm';
import Itinerary from './Itinerary';
@Entity('neighborhoods_served')
class NeighborhoodServed {
@PrimaryGeneratedColumn('increment')
id_neighborhood: number;
@ManyToOne(() => Itinerary, itinerary => itinerary.neighborhoodsServed)
@JoinColumn({ name: 'itinerary_id' })
itinerary: Itinerary;
@Column()
name: string;
@Column()
latitude: number;
@Column()
longitude: number;
// @CreateDateColumn()
// created_at: Date;
// @UpdateDateColumn()
// updated_at: Date;
}
export default NeighborhoodServed;

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;

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

10
src/routes/index.ts
View File

@@ -1,19 +1,19 @@
import { Router } from 'express';
import searchRoutes from './search.routes';
import searchRoutes from './search.routes';
import sessionsRouter from './sessions.routes';
import transportesRouter from './transportes.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('/transportes', transportesRouter);
routes.use('/itineraries', itinerariesRouter);
routes.use('/cars', carsRouter);
routes.use('/vans', vansRouter);
routes.use('/vehicles', vehiclesRouter);
export default routes;

118
src/routes/itineraries.routes.ts Normal file
View File

@@ -0,0 +1,118 @@
import { Router } from 'express';
import { getRepository } from 'typeorm';
import Itinerary from '../models/Itinerary';
import CalculateDistanceBetweenCoords from '../services/CalculateDistanceBetweenCoords';
import CreateItineraryService from '../services/CreateItineraryService';
import testData from "../constants/itineraryExample"
import maxRadius from '../constants/mapRadiusConfig';
const itinerariesRouter = Router();
itinerariesRouter.get('/', async (request, response) => {
const itinerariesRepository = getRepository(Itinerary);
const itineraries = await itinerariesRepository.find();
return response.json({ data: itineraries });
})
itinerariesRouter.post('/', async (request, response) => {
const {
id_itinerary,
vehicle_plate,
price,
days_of_week,
specific_day,
estimated_departure_time,
estimated_arrival_time,
available_seats,
itinerary_nickname,
neighborhoodsServed,
destinations
} = request.body;
const createItineraryService = new CreateItineraryService();
const itinerary = await createItineraryService.execute({
id_itinerary,
vehicle_plate,
price,
days_of_week,
specific_day,
estimated_departure_time,
estimated_arrival_time,
available_seats,
itinerary_nickname,
neighborhoodsServed,
destinations
});
return response.json({ data: itinerary, message: 'Itinerário criado com sucesso!' });
});
itinerariesRouter.post('/examples', async (request, response) => {
const createItineraryService = new CreateItineraryService();
const itinerary = await createItineraryService.execute({
id_itinerary: testData.itineraryExample.id_itinerary,
vehicle_plate: testData.itineraryExample.vehicle_plate,
price: testData.itineraryExample.price,
days_of_week: testData.itineraryExample.days_of_week,
specific_day: testData.itineraryExample.specific_day,
estimated_departure_time: testData.itineraryExample.estimated_departure_time,
estimated_arrival_time: testData.itineraryExample.estimated_arrival_time,
available_seats: testData.itineraryExample.available_seats,
itinerary_nickname: testData.itineraryExample.itinerary_nickname,
neighborhoodsServed: testData.neighborhoodsServed,
destinations: testData.destinations,
});
return response.json({ data: itinerary, message: 'Itinerário criado com sucesso!' });
});
itinerariesRouter.post('/search/inradius', async (request, response) => {
const { coordinatesOrigin, coordinatesDestination } = request.body;
const itinerariesRepository = getRepository(Itinerary);
// console.log(coordinatesOrigin, coordinatesDestiny);
const lat_from: number = +coordinatesOrigin.lat;
const lng_from: number = +coordinatesOrigin.lng;
const lat_to: number = +coordinatesDestination.lat;
const lng_to: number = +coordinatesDestination.lng;
const itineraries = await itinerariesRepository.find();
let transportsFiltered = itineraries.filter(itinerary => {
if (!itinerary.neighborhoodsServed || !itinerary.destinations) return false
var distanceOrigins = 0;
var distanceDestinations = 0;
for (const neighborhoodServed of itinerary.neighborhoodsServed) {
let lat2: number = +neighborhoodServed.latitude;
let lng2: number = +neighborhoodServed.longitude;
distanceOrigins = CalculateDistanceBetweenCoords({ lat1: lat_from, lng1: lng_from, lat2, lng2 });
if (distanceOrigins <= maxRadius) break;
}
for (const destination of itinerary.destinations) {
let lat2: number = +destination.latitude;
let lng2: number = +destination.longitude;
distanceDestinations = CalculateDistanceBetweenCoords({ lat1: lat_to, lng1: lng_to, lat2, lng2 });
if (distanceDestinations <= maxRadius) break;
}
console.log('distanceOrigins: ' + distanceOrigins)
console.log('distanceDestinations: ' + distanceDestinations)
return (distanceOrigins <= maxRadius && distanceDestinations <= maxRadius);
});
return response.json({ data: transportsFiltered });
});
export default itinerariesRouter;

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

@@ -1,98 +0,0 @@
import { Router } from 'express';
import { getRepository } from 'typeorm';
import CalculateDistanceBetweenCoords from '../services/CalculateDistanceBetweenCoords';
const transportesRouter = Router();
transportesRouter.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 transportesRouter;

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;

71
src/services/CreateItineraryService.ts Normal file
View File

@@ -0,0 +1,71 @@
import { getRepository } from 'typeorm';
import AppError from '../errors/AppError';
import Itinerary from '../models/Itinerary';
import NeighborhoodServed from '../models/NeighborhoodServed';
import Destination from '../models/Destination';
interface Request {
id_itinerary: number,
vehicle_plate: string,
price: number,
days_of_week: string,
specific_day: Date | undefined,
estimated_departure_time: string,
estimated_arrival_time: string,
available_seats: number,
itinerary_nickname: string,
neighborhoodsServed: NeighborhoodServed[],
destinations: Destination[]
}
class CreateItineraryService {
public async execute({
id_itinerary,
vehicle_plate,
price,
days_of_week,
specific_day,
estimated_departure_time,
estimated_arrival_time,
available_seats,
itinerary_nickname,
neighborhoodsServed,
destinations,
}: Request): Promise<Itinerary> {
const itinerariesRepository = getRepository(Itinerary);
// TODO, verificar se o período já está ocupado para a placa da vehicle informada!
// const checkUserEmailExists = await usersRepository.findOne({
// where: { id_itinerary },
// });
// if (checkUserEmailExists) {
// throw new AppError('Email já cadastrado!', 200);
// }
const itinerary = itinerariesRepository.create({
id_itinerary,
vehicle_plate,
price,
days_of_week,
specific_day,
estimated_departure_time,
estimated_arrival_time,
available_seats,
itinerary_nickname
});
await itinerariesRepository.save(itinerary);
itinerary.neighborhoodsServed = neighborhoodsServed
itinerary.destinations = destinations
await itinerariesRepository.save(itinerary);
return itinerary;
}
}
export default CreateItineraryService;

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;