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

Van 45 create view search itinerary

.gitignore

@@ -1 +1,161 @@
-node_modules
+# Created by https://www.toptal.com/developers/gitignore/api/yarn,node
+# Edit at https://www.toptal.com/developers/gitignore?templates=yarn,node
+
+### Node ###
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+.pnpm-debug.log*
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# Snowpack dependency directory (https://snowpack.dev/)
+web_modules/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional stylelint cache
+.stylelintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variable files
+.env
+.env.development.local
+.env.test.local
+.env.production.local
+.env.local
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+.parcel-cache
+
+# Next.js build output
+.next
+out
+
+# Nuxt.js build / generate output
+.nuxt
+dist
+
+# Gatsby files
+.cache/
+# Comment in the public line in if your project uses Gatsby and not Next.js
+# https://nextjs.org/blog/next-9-1#public-directory-support
+# public
+
+# vuepress build output
+.vuepress/dist
+
+# vuepress v2.x temp and cache directory
+.temp
+
+# Docusaurus cache and generated files
+.docusaurus
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# TernJS port file
+.tern-port
+
+# Stores VSCode versions used for testing VSCode extensions
+.vscode-test
+
+# yarn v2
+.yarn/cache
+.yarn/unplugged
+.yarn/build-state.yml
+.yarn/install-state.gz
+.pnp.*
+
+### Node Patch ###
+# Serverless Webpack directories
+.webpack/
+
+# Optional stylelint cache
+
+# SvelteKit build / generate output
+.svelte-kit
+
+### yarn ###
+# https://yarnpkg.com/getting-started/qa#which-files-should-be-gitignored
+
+.yarn/*
+!.yarn/releases
+!.yarn/patches
+!.yarn/plugins
+!.yarn/sdks
+!.yarn/versions
+
+# if you are NOT using Zero-installs, then:
+# comment the following lines
+!.yarn/cache
+
+# and uncomment the following lines
+# .pnp.*
+
+# End of https://www.toptal.com/developers/gitignore/api/yarn,node

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

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

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

@@ -49,7 +49,7 @@ export class CreateNeighborhoodsServed1660009211327
   }
 
   public async down(queryRunner: QueryRunner): Promise<void> {
-    await queryRunner.dropTable('neighborhoods_served');
     await queryRunner.dropForeignKey('neighborhoods_served', 'neighborhoods_served_itinerary_id_fk');
+    await queryRunner.dropTable('neighborhoods_served');
   }
 }

src/models/CarBrands.ts

@@ -0,0 +1,12 @@
+import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';
+
+@Entity('carBrands')
+class CarBrands {
+  @PrimaryGeneratedColumn('uuid')
+  id_brand: string;
+
+  @Column()
+  name: string;
+}
+
+export default CarBrands;

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 {
@@ -21,12 +21,12 @@ class User {
 
   @Column()
   email: string;
-  
+
   @Column()
   phone_number: string;
 
   @Column()
-  birth_date: Date;
+  birth_date: string;
 
   @Column()
   password: string;
@@ -36,7 +36,7 @@ class User {
 
   @Column()
   bio: string;
-  
+
   @Column()
   star_rating: number;
 
@@ -46,8 +46,8 @@ class User {
   @Column()
   document: string;
 
-  @OneToMany(() => Van, van => van.user)
+  @OneToMany(() => Vehicle, vehicle => vehicle.user)
-  van: Van[];
+  vehicle: Vehicle[];
 
   @CreateDateColumn()
   created_at: Date;

src/models/Vehicle.ts

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

src/routes/cars.routes.ts

@@ -1,4 +1,7 @@
 import { Router } from 'express';
+import axios from 'axios'
+
+import AppError from '../errors/AppError';
 
 import ensureAuthenticated from '../middlewares/ensureAuthenticated';
 
@@ -6,12 +9,63 @@ import GetCarModelsService from '../services/GetCarModelsService';
 
 const carsRouter = Router();
 
-carsRouter.get('/list', ensureAuthenticated, async (request, response) => {
+type Brand = {
-  const getCarModelsService = new GetCarModelsService();
+  codigo: string;
+  nome: string;
+};
 
-  const carModels = await getCarModelsService.execute();
+type GetBrandsResponse = {
+  data: Brand[];
+};
 
-  return response.json({ data: carModels });
+type Model = {
+  modelos: {
+    codigo: string;
+    nome: string;
+  }
+};
+
+type GetModelsResponse = {
+  modelos: Model[];
+};
+
+carsRouter.get('/brands/list', async (request, response) => {
+  // const getCarModelsService = new GetCarModelsService();
+  // const carModels = await getCarModelsService.execute();
+
+  const { data, status } = await axios.get<GetBrandsResponse>(
+    'https://parallelum.com.br/fipe/api/v1/carros/marcas',
+    {
+      headers: {
+        Accept: 'application/json',
+      },
+    },
+  );
+
+  if (status !== 200) {
+    throw new AppError('Não foi possível recuperar a lista de marcas de veículos.', 200);
+  }
+
+  return response.json({ data: data });
+});
+
+carsRouter.get('/models/list/:id', async (request, response) => {
+  const { id } = request.params;
+
+  const { data, status } = await axios.get<GetModelsResponse>(
+    `https://parallelum.com.br/fipe/api/v1/carros/marcas/${id}/modelos`,
+    {
+      headers: {
+        Accept: 'application/json',
+      },
+    },
+  );
+
+  if (status !== 200) {
+    throw new AppError('Não foi possível recuperar a lista de modelos do veículo informado.', 200);
+  }
+
+  return response.json({ data: data.modelos });
 });
 
 export default carsRouter;

src/routes/index.ts

@@ -2,18 +2,18 @@ import { Router } from 'express';
 
 import searchRoutes from './search.routes';
 import sessionsRouter from './sessions.routes';
-import transportsRouter from './transports.routes';
+import itinerariesRouter from './itineraries.routes';
 import usersRouter from './users.routes';
 import carsRouter from './cars.routes';
-import vansRouter from './vans.routes';
+import vehiclesRouter from './vehicles.routes';
 
 const routes = Router();
 
 routes.use('/users', usersRouter);
 routes.use('/sessions', sessionsRouter);
 routes.use('/search', searchRoutes);
-routes.use('/transports', transportsRouter);
+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/transports.routes.ts

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

src/routes/users.routes.ts

@@ -12,7 +12,7 @@ import UpdateUserService from '../services/UpdateUserService';
 import UpdateUserAvatarService from '../services/UpdateUserAvatarService';
 import UpdateUserPasswordService from '../services/UpdateUserPasswordService';
 import AuthenticateUserService from '../services/AuthenticateUserService';
-import CheckIfUserHasVansService from '../services/CheckIfUserHasVansService';
+import CheckIfUserHasVehiclesService from '../services/CheckIfUserHasVehiclesService';
 
 const usersRouter = Router();
 
@@ -49,14 +49,14 @@ usersRouter.get('/:id', ensureAuthenticated, async (request, response) => {
 
   const user = await findUserService.execute(id);
 
-  // converting ISO 8601 date to normal date
+  // // converting ISO 8601 date to normal date
-  let birth_date = new Date(user.birth_date);
+  // let birth_date = new Date(user.birth_date);
 
-  let year = birth_date.getFullYear();
+  // let year = birth_date.getFullYear();
-  let month = birth_date.getMonth() + 1;
+  // let month = birth_date.getMonth() + 1;
-  let date = birth_date.getDate();
+  // let date = birth_date.getDate();
 
-  const finalDate = `${date}/${month}/${year}`;
+  // const newBirthDate = `${date}/${month}/${year}`;
 
   const userWithoutPassword = {
     id_user: user.id_user,
@@ -64,7 +64,7 @@ usersRouter.get('/:id', ensureAuthenticated, async (request, response) => {
     lastname: user.lastname,
     email: user.email,
     phone_number: user.phone_number,
-    birth_date: finalDate,
+    birth_date: user.birth_date,
     avatar_image: user.avatar_image,
     bio: user.bio,
     document_type: user.document_type,
@@ -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/CreateUserService.ts

@@ -18,7 +18,7 @@ interface Request {
 class CreateUserService {
   public async execute({ name, lastname, email, birth_date, password }: Request): Promise<User> {
     const usersRepository = getRepository(User);
-    const socialInformationRepository = getRepository(Social);
+    // const socialInformationRepository = getRepository(Social);
 
     const checkUserEmailExists = await usersRepository.findOne({
       where: { email },

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/UpdateUserService.ts

@@ -34,6 +34,7 @@ class UpdateUserService {
     if (lastname) user.lastname = lastname
     if (bio) user.bio = bio
     if (email) user.email = email
+    if (birth_date) user.birth_date = birth_date
 
     if (phone_number) {
       const phoneAlreadyExists = await usersRepository.findOne({
@@ -44,13 +45,11 @@ class UpdateUserService {
         throw new AppError('O telefone informado já está em uso por outra conta!', 409);
       }
     }
-    
+
     user.phone_number = phone_number
 
     if (document_type) user.document_type = document_type
     if (document) user.document = document
-    
-    // user.birth_date = new Date(birth_date); // TODO, funciona?
 
     await usersRepository.save(user);
 

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;