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

Van 45 create view search itinerary

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

src/constants/mapRadiusConfig.ts

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

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',

src/database/migrations/1653437653433-AlterUsersTableAddLastnameColumn.ts

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

src/database/migrations/1653768789073-CreateCarModelsTable.ts

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

src/database/migrations/1653769103891-InsertDataIntoCarModelsTable.ts

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

src/database/migrations/1654814986232-AddCpfAndCnpjFieldToUsers.ts

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

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

src/database/migrations/1655711281662-RemoveCpfAndCnpjFieldsFromUsersTable.ts

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

src/database/migrations/1655711315251-AddDocumentAndDocumentTypeFieldsToUsersTable.ts

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

src/database/migrations/1655720865095-AddUserIdFieldToVansTable.ts

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

src/database/migrations/1655720873936-AddFKUserIdToVehiclesTable.ts

@@ -1,11 +1,11 @@
 import { MigrationInterface, QueryRunner, TableForeignKey } from 'typeorm';
 
-export class AddFKUserIdToVansTable1655720873936 implements MigrationInterface {
+export class AddFKUserIdToVehiclesTable1655720873936 implements MigrationInterface {
   public async up(queryRunner: QueryRunner): Promise<void> {
     await queryRunner.createForeignKey(
-      'vans',
+      'vehicles',
       new TableForeignKey({
-        name: 'UserIdVan', // nome da FK, serve para referenciar numa exclusão pelo QueryRunner se necessário
+        name: 'UserIdVehicle', // nome da FK, serve para referenciar numa exclusão pelo QueryRunner se necessário
         columnNames: ['user_id'], // coluna que vai virar FK
         referencedColumnNames: ['id_user'], // coluna PK da primeira tabela
         referencedTableName: 'users', // nome da tabela que possui a PK
@@ -17,8 +17,8 @@ export class AddFKUserIdToVansTable1655720873936 implements MigrationInterface {
 
   public async down(queryRunner: QueryRunner): Promise<void> {
     await queryRunner.dropForeignKey(
-      'vans',
+      'vehicles',
-      'UserIdVan',
+      'UserIdVehicle',
     );
   }
 }

src/database/migrations/1659404395471-CreateItineraries.ts

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

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

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

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

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

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

src/database/migrations/1661199963221-AlterUsersTableEditBirthDateFieldTypeToString.ts

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

src/database/migrations/1661212542739-RenameCarModelsTableToCarBrands.ts

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

src/database/migrations/1661745915711-DropCarBrandsTable.ts

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

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

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;

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;

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;

src/models/User.ts

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

src/models/Vehicle.ts

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

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;

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;

src/routes/transportes.routes.ts

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

src/routes/users.routes.ts

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

src/routes/vans.routes.ts

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

src/routes/vehicles.routes.ts

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

src/services/CheckIfUserHasVehiclesService.ts

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

src/services/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<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;

src/services/CreateVehicleService.ts

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

src/services/FindVanLocatorService.ts

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

src/services/FindVanService.ts

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

src/services/FindVansByUserIdService.ts

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

src/services/FindVehicleLocatorService.ts

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

src/services/FindVehicleService.ts

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

src/services/FindVehiclesByUserIdService.ts

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

src/services/UpdateVanPlateService.ts

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

src/services/UpdateVanService.ts

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

src/services/UpdateVehiclePlateService.ts

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

src/services/UpdateVehicleService.ts

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