diff --git a/src/constants/itineraryExample.ts b/src/constants/itineraryExample.ts new file mode 100644 index 0000000..1ea47e1 --- /dev/null +++ b/src/constants/itineraryExample.ts @@ -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 }; diff --git a/src/constants/mapRadiusConfig.ts b/src/constants/mapRadiusConfig.ts new file mode 100644 index 0000000..3fb29c4 --- /dev/null +++ b/src/constants/mapRadiusConfig.ts @@ -0,0 +1,3 @@ +const maxRadius = 10 + +export default maxRadius diff --git a/src/database/migrations/1617210132141-CreateUsers.ts b/src/database/migrations/1617210132141-CreateUsers.ts index 64d8b16..f510a2e 100644 --- a/src/database/migrations/1617210132141-CreateUsers.ts +++ b/src/database/migrations/1617210132141-CreateUsers.ts @@ -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', diff --git a/src/database/migrations/1653437653433-AlterUsersTableAddLastnameColumn.ts b/src/database/migrations/1653437653433-AlterUsersTableAddLastnameColumn.ts deleted file mode 100644 index 699f3e0..0000000 --- a/src/database/migrations/1653437653433-AlterUsersTableAddLastnameColumn.ts +++ /dev/null @@ -1,15 +0,0 @@ -import {MigrationInterface, QueryRunner, TableColumn} from "typeorm"; - -export class AlterUsersTableAddLastnameColumn1653437653433 implements MigrationInterface { - public async up(queryRunner: QueryRunner): Promise { - await queryRunner.addColumn('users', new TableColumn({ - name: 'lastname', - type: 'varchar', - isNullable: true - })) - } - - public async down(queryRunner: QueryRunner): Promise { - await queryRunner.dropColumn('users', 'lastname') - } -} diff --git a/src/database/migrations/1653768789073-CreateCarModelsTable.ts b/src/database/migrations/1653768789073-CreateCarModelsTable.ts deleted file mode 100644 index 9ca8c67..0000000 --- a/src/database/migrations/1653768789073-CreateCarModelsTable.ts +++ /dev/null @@ -1,28 +0,0 @@ -import { MigrationInterface, QueryRunner, Table } from 'typeorm'; - -export class CreateCarModelsTable1653768789073 implements MigrationInterface { - public async up(queryRunner: QueryRunner): Promise { - 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 { - await queryRunner.dropTable('carModels'); - } -} diff --git a/src/database/migrations/1653769103891-InsertDataIntoCarModelsTable.ts b/src/database/migrations/1653769103891-InsertDataIntoCarModelsTable.ts deleted file mode 100644 index 1632443..0000000 --- a/src/database/migrations/1653769103891-InsertDataIntoCarModelsTable.ts +++ /dev/null @@ -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 { - carModels.forEach(async (car) => { - const GBP = await queryRunner.manager.save(queryRunner.manager.create(CarModels, { name: car.name })) - } - )} - - public async down(queryRunner: QueryRunner): Promise { - await getConnection() - .createQueryBuilder() - .delete() - .from(CarModels) - .execute(); - } -} diff --git a/src/database/migrations/1654814986232-AddCpfAndCnpjFieldToUsers.ts b/src/database/migrations/1654814986232-AddCpfAndCnpjFieldToUsers.ts deleted file mode 100644 index 7dbbb73..0000000 --- a/src/database/migrations/1654814986232-AddCpfAndCnpjFieldToUsers.ts +++ /dev/null @@ -1,24 +0,0 @@ -import { MigrationInterface, QueryRunner, TableColumn } from 'typeorm'; - -export class AddCpfAndCnpjFieldToUsers1654814986232 - implements MigrationInterface -{ - public async up(queryRunner: QueryRunner): Promise { - 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 { - await queryRunner.dropColumns('users', ['cnpj', 'cpf']); - } -} diff --git a/src/database/migrations/1655691282002-CreateVansTable.ts b/src/database/migrations/1655691282002-CreateVehiclesTable.ts similarity index 87% rename from src/database/migrations/1655691282002-CreateVansTable.ts rename to src/database/migrations/1655691282002-CreateVehiclesTable.ts index 0cd3e25..6810100 100644 --- a/src/database/migrations/1655691282002-CreateVansTable.ts +++ b/src/database/migrations/1655691282002-CreateVehiclesTable.ts @@ -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 { 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 { - await queryRunner.dropTable('vans'); + await queryRunner.dropTable('vehicles'); } } diff --git a/src/database/migrations/1655711281662-RemoveCpfAndCnpjFieldsFromUsersTable.ts b/src/database/migrations/1655711281662-RemoveCpfAndCnpjFieldsFromUsersTable.ts deleted file mode 100644 index 34495bf..0000000 --- a/src/database/migrations/1655711281662-RemoveCpfAndCnpjFieldsFromUsersTable.ts +++ /dev/null @@ -1,24 +0,0 @@ -import { MigrationInterface, QueryRunner, TableColumn } from 'typeorm'; - -export class RemoveCpfAndCnpjFieldsFromUsersTable1655711281662 - implements MigrationInterface -{ - public async up(queryRunner: QueryRunner): Promise { - await queryRunner.dropColumns('users', ['cnpj', 'cpf']); - } - - public async down(queryRunner: QueryRunner): Promise { - await queryRunner.addColumns('users', [ - new TableColumn({ - name: 'cpf', - type: 'varchar', - isNullable: true, - }), - new TableColumn({ - name: 'cnpj', - type: 'varchar', - isNullable: true, - }), - ]); - } -} diff --git a/src/database/migrations/1655711315251-AddDocumentAndDocumentTypeFieldsToUsersTable.ts b/src/database/migrations/1655711315251-AddDocumentAndDocumentTypeFieldsToUsersTable.ts deleted file mode 100644 index d8c0e0a..0000000 --- a/src/database/migrations/1655711315251-AddDocumentAndDocumentTypeFieldsToUsersTable.ts +++ /dev/null @@ -1,24 +0,0 @@ -import { MigrationInterface, QueryRunner, TableColumn } from 'typeorm'; - -export class AddDocumentAndDocumentTypeFieldsToUsersTable1655711315251 - implements MigrationInterface -{ - public async up(queryRunner: QueryRunner): Promise { - 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 { - await queryRunner.dropColumns('users', ['document_type', 'document']); - } -} diff --git a/src/database/migrations/1655720865095-AddUserIdFieldToVansTable.ts b/src/database/migrations/1655720865095-AddUserIdFieldToVansTable.ts deleted file mode 100644 index bfeed73..0000000 --- a/src/database/migrations/1655720865095-AddUserIdFieldToVansTable.ts +++ /dev/null @@ -1,20 +0,0 @@ -import { MigrationInterface, QueryRunner, TableColumn } from 'typeorm'; - -export class AddUserIdFieldToVansTable1655720865095 - implements MigrationInterface -{ - public async up(queryRunner: QueryRunner): Promise { - await queryRunner.addColumn( - 'vans', - new TableColumn({ - name: 'user_id', - type: 'uuid', - isNullable: true, - }), - ); - } - - public async down(queryRunner: QueryRunner): Promise { - await queryRunner.dropColumn('vans', 'user_id'); - } -} diff --git a/src/database/migrations/1655720873936-AddFKUserIdToVansTable.ts b/src/database/migrations/1655720873936-AddFKUserIdToVehiclesTable.ts similarity index 70% rename from src/database/migrations/1655720873936-AddFKUserIdToVansTable.ts rename to src/database/migrations/1655720873936-AddFKUserIdToVehiclesTable.ts index a5cef77..2a00fc6 100644 --- a/src/database/migrations/1655720873936-AddFKUserIdToVansTable.ts +++ b/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 { 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 { await queryRunner.dropForeignKey( - 'vans', - 'UserIdVan', + 'vehicles', + 'UserIdVehicle', ); } } diff --git a/src/database/migrations/1659404395471-CreateItineraries.ts b/src/database/migrations/1659404395471-CreateItineraries.ts new file mode 100644 index 0000000..9ed0348 --- /dev/null +++ b/src/database/migrations/1659404395471-CreateItineraries.ts @@ -0,0 +1,119 @@ +import { + MigrationInterface, + QueryRunner, + Table, + TableForeignKey, + TableIndex, +} from 'typeorm'; + +export class CreateItineraries1659404395471 implements MigrationInterface { + public async up(queryRunner: QueryRunner): Promise { + 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 { + await queryRunner.dropTable('itineraries'); + await queryRunner.dropForeignKey('itineraries', 'itineraries_vehicle_plate_fk'); + await queryRunner.dropIndex('itineraries', 'itineraries_idx'); + } +} diff --git a/src/database/migrations/1659404395471-CreateItineraries.ts.orig b/src/database/migrations/1659404395471-CreateItineraries.ts.orig new file mode 100644 index 0000000..0aefbe0 --- /dev/null +++ b/src/database/migrations/1659404395471-CreateItineraries.ts.orig @@ -0,0 +1,123 @@ +import { + MigrationInterface, + QueryRunner, + Table, + TableForeignKey, + TableIndex, +} from 'typeorm'; + +export class CreateItineraries1659404395471 implements MigrationInterface { + public async up(queryRunner: QueryRunner): Promise { + 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 { + await queryRunner.dropTable('itineraries'); + await queryRunner.dropForeignKey('itineraries', 'itineraries_vehicle_plate_fk'); + await queryRunner.dropIndex('itineraries', 'itineraries_idx'); + } +} diff --git a/src/database/migrations/1660009211327-CreateNeighborhoodsServed.ts b/src/database/migrations/1660009211327-CreateNeighborhoodsServed.ts new file mode 100644 index 0000000..a3fd119 --- /dev/null +++ b/src/database/migrations/1660009211327-CreateNeighborhoodsServed.ts @@ -0,0 +1,55 @@ +import { MigrationInterface, QueryRunner, Table, TableForeignKey } from 'typeorm'; + +export class CreateNeighborhoodsServed1660009211327 + implements MigrationInterface +{ + public async up(queryRunner: QueryRunner): Promise { + 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 { + await queryRunner.dropForeignKey('neighborhoods_served', 'neighborhoods_served_itinerary_id_fk'); + await queryRunner.dropTable('neighborhoods_served'); + } +} diff --git a/src/database/migrations/1660009323138-CreateDestinations.ts b/src/database/migrations/1660009323138-CreateDestinations.ts new file mode 100644 index 0000000..0c49875 --- /dev/null +++ b/src/database/migrations/1660009323138-CreateDestinations.ts @@ -0,0 +1,53 @@ +import { MigrationInterface, QueryRunner, Table, TableForeignKey } from 'typeorm'; + +export class CreateDestinations1660009323138 implements MigrationInterface { + public async up(queryRunner: QueryRunner): Promise { + 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 { + await queryRunner.dropTable('destinations'); + await queryRunner.dropForeignKey('destinations', 'destinations_itinerary_id_fk'); + } +} diff --git a/src/database/migrations/1660010452826-CreatePassengers.ts b/src/database/migrations/1660010452826-CreatePassengers.ts new file mode 100644 index 0000000..0549219 --- /dev/null +++ b/src/database/migrations/1660010452826-CreatePassengers.ts @@ -0,0 +1,93 @@ +import { + MigrationInterface, + QueryRunner, + Table, + TableForeignKey, + TableIndex, +} from 'typeorm'; + +export class CreatePassengers1660010452826 implements MigrationInterface { + public async up(queryRunner: QueryRunner): Promise { + 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 { + 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'); + } +} diff --git a/src/database/migrations/1660010491828-CreateRouteHistoric.ts b/src/database/migrations/1660010491828-CreateRouteHistoric.ts new file mode 100644 index 0000000..095e67a --- /dev/null +++ b/src/database/migrations/1660010491828-CreateRouteHistoric.ts @@ -0,0 +1,76 @@ +import { MigrationInterface, QueryRunner, Table, TableForeignKey, TableIndex } from 'typeorm'; + +export class CreateRouteHistoric1660010491828 implements MigrationInterface { + public async up(queryRunner: QueryRunner): Promise { + 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 { + 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'); + } +} diff --git a/src/database/migrations/1661199963221-AlterUsersTableEditBirthDateFieldTypeToString.ts b/src/database/migrations/1661199963221-AlterUsersTableEditBirthDateFieldTypeToString.ts deleted file mode 100644 index 4d21d2a..0000000 --- a/src/database/migrations/1661199963221-AlterUsersTableEditBirthDateFieldTypeToString.ts +++ /dev/null @@ -1,28 +0,0 @@ -import {MigrationInterface, QueryRunner, TableColumn} from "typeorm"; - -export class AlterUsersTableEditBirthDateFieldTypeToString1661199963221 implements MigrationInterface { - - public async up(queryRunner: QueryRunner): Promise { - 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 { - await queryRunner.dropColumn('users', 'birth_date') - - await queryRunner.addColumn('users', new TableColumn( - { - name: 'birth_date', - type: 'date', - isNullable: true - }, - )) - } -} diff --git a/src/database/migrations/1661212542739-RenameCarModelsTableToCarBrands.ts b/src/database/migrations/1661212542739-RenameCarModelsTableToCarBrands.ts deleted file mode 100644 index 31729a4..0000000 --- a/src/database/migrations/1661212542739-RenameCarModelsTableToCarBrands.ts +++ /dev/null @@ -1,15 +0,0 @@ -import {MigrationInterface, QueryRunner} from "typeorm"; - -export class RenameCarModelsTableToCarBrands1661212542739 implements MigrationInterface { - public async up(queryRunner: QueryRunner): Promise { - await queryRunner.renameTable('carModels', 'carBrands') - - await queryRunner.renameColumn('carBrands', 'id_model', 'id_brand') - } - - public async down(queryRunner: QueryRunner): Promise { - await queryRunner.renameTable('carBrands', 'carModels') - - await queryRunner.renameColumn('carBrands', 'id_brand', 'id_model') - } -} diff --git a/src/database/migrations/1661745915711-DropCarBrandsTable.ts b/src/database/migrations/1661745915711-DropCarBrandsTable.ts deleted file mode 100644 index 1ee89dd..0000000 --- a/src/database/migrations/1661745915711-DropCarBrandsTable.ts +++ /dev/null @@ -1,28 +0,0 @@ -import {MigrationInterface, QueryRunner, Table} from "typeorm"; - -export class DropCarBrandsTable1661745915711 implements MigrationInterface { - public async up(queryRunner: QueryRunner): Promise { - await queryRunner.dropTable('carBrands') - } - - public async down(queryRunner: QueryRunner): Promise { - 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', - } - ], - }), - ); - } -} diff --git a/src/database/migrations/1662081949950-CreatePassengersRequests.ts b/src/database/migrations/1662081949950-CreatePassengersRequests.ts new file mode 100644 index 0000000..a906f70 --- /dev/null +++ b/src/database/migrations/1662081949950-CreatePassengersRequests.ts @@ -0,0 +1,107 @@ +import { + MigrationInterface, + QueryRunner, + Table, + TableForeignKey, + TableIndex, +} from 'typeorm'; + +export class CreatePassengersRequests1662081949950 + implements MigrationInterface +{ + public async up(queryRunner: QueryRunner): Promise { + 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 { + 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', + ); + } +} diff --git a/src/models/Destination.ts b/src/models/Destination.ts new file mode 100644 index 0000000..8e9f5b3 --- /dev/null +++ b/src/models/Destination.ts @@ -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; diff --git a/src/models/Itinerary.ts b/src/models/Itinerary.ts new file mode 100644 index 0000000..ceda8f0 --- /dev/null +++ b/src/models/Itinerary.ts @@ -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; diff --git a/src/models/NeighborhoodServed.ts b/src/models/NeighborhoodServed.ts new file mode 100644 index 0000000..f7404b7 --- /dev/null +++ b/src/models/NeighborhoodServed.ts @@ -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; diff --git a/src/models/User.ts b/src/models/User.ts index a68f745..03e2acb 100644 --- a/src/models/User.ts +++ b/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) - van: Van[]; + @OneToMany(() => Vehicle, vehicle => vehicle.user) + vehicle: Vehicle[]; @CreateDateColumn() created_at: Date; diff --git a/src/models/Van.ts b/src/models/Vehicle.ts similarity index 86% rename from src/models/Van.ts rename to src/models/Vehicle.ts index e619cdb..85efd81 100644 --- a/src/models/Van.ts +++ b/src/models/Vehicle.ts @@ -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; diff --git a/src/routes/index.ts b/src/routes/index.ts index c5ed39c..ea9c4f6 100644 --- a/src/routes/index.ts +++ b/src/routes/index.ts @@ -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; diff --git a/src/routes/itineraries.routes.ts b/src/routes/itineraries.routes.ts new file mode 100644 index 0000000..e86f659 --- /dev/null +++ b/src/routes/itineraries.routes.ts @@ -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; diff --git a/src/routes/transportes.routes.ts b/src/routes/transportes.routes.ts deleted file mode 100644 index ef4c2a4..0000000 --- a/src/routes/transportes.routes.ts +++ /dev/null @@ -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; diff --git a/src/routes/users.routes.ts b/src/routes/users.routes.ts index 053eea5..980dac7 100644 --- a/src/routes/users.routes.ts +++ b/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 }); }, ); diff --git a/src/routes/vans.routes.ts b/src/routes/vans.routes.ts deleted file mode 100644 index f657fbf..0000000 --- a/src/routes/vans.routes.ts +++ /dev/null @@ -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; diff --git a/src/routes/vehicles.routes.ts b/src/routes/vehicles.routes.ts new file mode 100644 index 0000000..7d97ff7 --- /dev/null +++ b/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; diff --git a/src/services/CheckIfUserHasVansService.ts b/src/services/CheckIfUserHasVehiclesService.ts similarity index 65% rename from src/services/CheckIfUserHasVansService.ts rename to src/services/CheckIfUserHasVehiclesService.ts index bb89992..97b0481 100644 --- a/src/services/CheckIfUserHasVansService.ts +++ b/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 { 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; diff --git a/src/services/CreateItineraryService.ts b/src/services/CreateItineraryService.ts new file mode 100644 index 0000000..1b364f6 --- /dev/null +++ b/src/services/CreateItineraryService.ts @@ -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 { + 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; diff --git a/src/services/CreateVanService.ts b/src/services/CreateVehicleService.ts similarity index 71% rename from src/services/CreateVanService.ts rename to src/services/CreateVehicleService.ts index c34a5d0..6af55a3 100644 --- a/src/services/CreateVanService.ts +++ b/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 { - const vansRepository = getRepository(Van); + }: Request): Promise { + 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; diff --git a/src/services/FindVanLocatorService.ts b/src/services/FindVanLocatorService.ts deleted file mode 100644 index cead069..0000000 --- a/src/services/FindVanLocatorService.ts +++ /dev/null @@ -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 { - 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; diff --git a/src/services/FindVanService.ts b/src/services/FindVanService.ts deleted file mode 100644 index 64e454c..0000000 --- a/src/services/FindVanService.ts +++ /dev/null @@ -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 { - 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; diff --git a/src/services/FindVansByUserIdService.ts b/src/services/FindVansByUserIdService.ts deleted file mode 100644 index 9a3245c..0000000 --- a/src/services/FindVansByUserIdService.ts +++ /dev/null @@ -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 { - 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; diff --git a/src/services/FindVehicleLocatorService.ts b/src/services/FindVehicleLocatorService.ts new file mode 100644 index 0000000..80c4d47 --- /dev/null +++ b/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 { + 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; diff --git a/src/services/FindVehicleService.ts b/src/services/FindVehicleService.ts new file mode 100644 index 0000000..5914765 --- /dev/null +++ b/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 { + 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; diff --git a/src/services/FindVehiclesByUserIdService.ts b/src/services/FindVehiclesByUserIdService.ts new file mode 100644 index 0000000..b02ac43 --- /dev/null +++ b/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 { + 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; diff --git a/src/services/UpdateVanPlateService.ts b/src/services/UpdateVanPlateService.ts deleted file mode 100644 index f3dadc2..0000000 --- a/src/services/UpdateVanPlateService.ts +++ /dev/null @@ -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 { - 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; diff --git a/src/services/UpdateVanService.ts b/src/services/UpdateVanService.ts deleted file mode 100644 index e157e92..0000000 --- a/src/services/UpdateVanService.ts +++ /dev/null @@ -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 { - 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; diff --git a/src/services/UpdateVehiclePlateService.ts b/src/services/UpdateVehiclePlateService.ts new file mode 100644 index 0000000..e647956 --- /dev/null +++ b/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 { + 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; diff --git a/src/services/UpdateVehicleService.ts b/src/services/UpdateVehicleService.ts new file mode 100644 index 0000000..4a25599 --- /dev/null +++ b/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 { + 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;