Merge branch 'master' into feature/buscar-transporte

src/constants/carModels.ts

@@ -0,0 +1,142 @@
+const carModels = [
+  {
+    name: 'Aston Martin',
+  },
+  {
+    name: 'Audi',
+  },
+  {
+    name: 'Bentley',
+  },
+  {
+    name: 'BMW',
+  },
+  {
+    name: 'BMW Motorrad',
+  },
+  {
+    name: 'BYD',
+  },
+  {
+    name: 'Caoa Chery',
+  },
+  {
+    name: 'Chevrolet',
+  },
+  {
+    name: 'Chrysler',
+  },
+  {
+    name: 'Citroën',
+  },
+  {
+    name: 'Dodge',
+  },
+  {
+    name: 'Ferrari',
+  },
+  {
+    name: 'Fiat',
+  },
+  {
+    name: 'Ford',
+  },
+  {
+    name: 'Honda',
+  },
+  {
+    name: 'Husqvarna',
+  },
+  {
+    name: 'Hyundai',
+  },
+  {
+    name: 'JAC',
+  },
+  {
+    name: 'Jaguar',
+  },
+  {
+    name: 'Jeep',
+  },
+  {
+    name: 'Kia',
+  },
+  {
+    name: 'Lamborghini',
+  },
+  {
+    name: 'Land Rover',
+  },
+  {
+    name: 'Lexus',
+  },
+  {
+    name: 'Lifan',
+  },
+  {
+    name: 'Maserati',
+  },
+  {
+    name: 'McLaren',
+  },
+  {
+    name: 'Mercedes-Benz',
+  },
+  {
+    name: 'Mini',
+  },
+  {
+    name: 'Mitsubishi',
+  },
+  {
+    name: 'Nissan',
+  },
+  {
+    name: 'Peugeot',
+  },
+  {
+    name: 'Porsche',
+  },
+  {
+    name: 'Ram',
+  },
+  {
+    name: 'Renault',
+  },
+  {
+    name: 'Rolls Royce',
+  },
+  {
+    name: 'Royal Enfield',
+  },
+  {
+    name: 'Smart',
+  },
+  {
+    name: 'Subaru',
+  },
+  {
+    name: 'Suzuki',
+  },
+  {
+    name: 'Toyota',
+  },
+  {
+    name: 'Triumph',
+  },
+  {
+    name: 'Troller',
+  },
+  {
+    name: 'Volkswagen',
+  },
+  {
+    name: 'Volvo',
+  },
+  {
+    name: 'Yamaha',
+  },
+];
+
+export default carModels;

src/database/migrations/1653437653433-AlterUsersTableAddLastnameColumn.ts

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,20 @@
+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/models/CarModels.ts

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

src/models/User.ts

@@ -14,6 +14,9 @@ class User {
   @Column()
   name: string;
 
+  @Column()
+  lastname: string;
+
   @Column()
   email: string;
   

src/routes/cars.routes.ts

@@ -0,0 +1,17 @@
+import { Router } from 'express';
+
+import ensureAuthenticated from '../middlewares/ensureAuthenticated';
+
+import GetCarModelsService from '../services/GetCarModelsService';
+
+const carsRouter = Router();
+
+carsRouter.get('/list', ensureAuthenticated, async (request, response) => {
+  const getCarModelsService = new GetCarModelsService();
+
+  const carModels = await getCarModelsService.execute();
+
+  return response.json({ data: carModels });
+});
+
+export default carsRouter;

src/routes/index.ts

@@ -4,6 +4,7 @@ import searchRoutes from './search.routes';
 import sessionsRouter from './sessions.routes';
 import transportesRouter from './transportes.routes';
 import usersRouter from './users.routes';
+import carsRouter from './cars.routes';
 
 const routes = Router();
 
@@ -11,5 +12,6 @@ routes.use('/users', usersRouter);
 routes.use('/sessions', sessionsRouter);
 routes.use('/search', searchRoutes);
 routes.use('/transportes', transportesRouter);
+routes.use('/cars', carsRouter);
 
 export default routes;

src/routes/sessions.routes.ts

@@ -1,9 +1,19 @@
 import { Router } from 'express';
+import { sign, verify } from 'jsonwebtoken';
+
+import authConfig from '../config/auth';
+import AppError from '../errors/AppError';
 
 import AuthenticateUserService from '../services/AuthenticateUserService';
 
 const sessionsRouter = Router();
 
+interface TokenPayload {
+  iat: number;
+  exp: number;
+  sub: string;
+}
+
 // login pode ser: email ou username
 sessionsRouter.post('/', async (request, response) => {
   const { login, password } = request.body;
@@ -15,7 +25,24 @@ sessionsRouter.post('/', async (request, response) => {
     password,
   });
 
-  return response.json({ message: 'User logged in sucessfully', token: token });
+  return response.json({ message: 'Usuário autenticado com sucesso!', token: token });
 });
 
+sessionsRouter.post('/refresh', async(request, response) => {
+  const { token } = request.body;
+
+  let sub = null;
+  let decoded = null;
+
+  try {
+    decoded = verify(token, authConfig.jwt.secret);
+  } catch (error) {
+    throw new AppError('Token de autenticação inválido.', 401);
+  }
+
+  sub = decoded as TokenPayload;
+
+  return response.json({ "status": "success", "userId": sub.sub });
+})
+
 export default sessionsRouter;

src/routes/users.routes.ts

@@ -50,27 +50,38 @@ usersRouter.get('/:id', ensureAuthenticated, async (request, response) => {
 
   const user = await findUser.execute(id);
 
+  // converting ISO 8601 date to normal date
+  let birth_date = new Date(user.birth_date)
+
+  let year = birth_date.getFullYear()
+  let month = birth_date.getMonth()+1
+  let date = birth_date.getDate()
+
+  const finalDate = `${date}/${month}/${year}`
+
   const userWithoutPassword = {
     id_user: user.id_user,
     name: user.name,
+    lastname: user.lastname,
     email: user.email,
-    birth_date: user.birth_date,
+    birth_date: finalDate,
     avatar_image: user.avatar_image,
     bio: user.bio,
-    created_at: user.created_at,
+    // created_at: user.created_at,
-    updated_at: user.updated_at,
+    // updated_at: user.updated_at,
   };
 
   return response.json({ data: userWithoutPassword });
 });
 
 usersRouter.post('/', async (request, response) => {
-  const { name, email, birth_date, password } = request.body;
+  const { name, lastname, email, birth_date, password } = request.body;
 
   const createUser = new CreateUserService();
 
   const user = await createUser.execute({
     name,
+    lastname,
     email,
     birth_date,
     password,
@@ -87,13 +98,14 @@ usersRouter.post('/', async (request, response) => {
 });
 
 usersRouter.patch('/edit', ensureAuthenticated, async (request, response) => {
-  const { name, username, bio, email, birth_date } = request.body;
+  const { name, lastname, username, bio, email, birth_date } = request.body;
 
   const updateUserService = new UpdateUserService();
 
   await updateUserService.execute({
     id_user: request.user.id_user,
     name,
+    lastname,
     username,
     bio,
     email,

src/server.ts

@@ -34,6 +34,8 @@ app.use((err: Error, request: Request, response: Response, _: NextFunction) => {
   });
 });
 
-app.listen(3333, () => {
+const port = 10002
-  console.log('🚀 Server started on port 3333!');
+
+app.listen(port, () => {
+  console.log(`🚀 Server started on port ${port}!`);
 });

src/services/AuthenticateUserService.ts

@@ -17,6 +17,8 @@ interface Response {
   id_user: string;
 }
 
+const failedLoginMessage = { message: 'Combinação incorreta de login e senha.', statusCode: 200 }
+
 class AuthenticateUserService {
   public async execute({ login, password }: Request): Promise<Response> {
     const usersRepository = getRepository(User);
@@ -28,7 +30,7 @@ class AuthenticateUserService {
     // TODO, ajeitar todos os HTTP status code
     // Por que tem que deixar 200 para funcionar?
     if (!user) {
-      throw new AppError('Incorrect login/password combination.', 200);
+      throw new AppError(failedLoginMessage.message, failedLoginMessage.statusCode);
     }
 
     // user.password -> senha criptografada
@@ -37,7 +39,7 @@ class AuthenticateUserService {
     const passwordMatched = await compare(password, user.password);
 
     if (!passwordMatched) {
-      throw new AppError('Incorrect login/password combination.', 200);
+      throw new AppError(failedLoginMessage.message, failedLoginMessage.statusCode);
     }
 
     // usuário autenticado

src/services/CreateUserService.ts

@@ -9,13 +9,14 @@ import Social from '../models/Social';
 
 interface Request {
   name: string;
+  lastname: string;
   email: string;
   birth_date: string;
   password: string;
 }
 
 class CreateUserService {
-  public async execute({ name, email, birth_date, password }: Request): Promise<User> {
+  public async execute({ name, lastname, email, birth_date, password }: Request): Promise<User> {
     const usersRepository = getRepository(User);
     const socialsRepository = getRepository(Social);
 
@@ -33,8 +34,9 @@ class CreateUserService {
     // TODO, arrumar o formato das datas e padronizar com a equipe
 
     const user = usersRepository.create({
-      id_user: v4(), name, email, birth_date, password: hashedPassword, avatar_image: "", bio: ""
+      id_user: v4(), name, lastname, email, birth_date, password: hashedPassword, avatar_image: "", bio: ""
     });
+
     await usersRepository.save(user);
 
     // já criar registro na tabela Socials para evitar inconsistências

src/services/FindUserService.ts

@@ -8,12 +8,12 @@ class CreateUserService {
   public async execute(id: string): Promise<User> {
     const usersRepository = getRepository(User);
 
-    const user = await usersRepository.findOne({
+    let user = await usersRepository.findOne({
       where: { id_user: id },
     });
 
     if (!user) {
-      throw new AppError('User does not exist.');
+      throw new AppError('Usuário não existe.');
     }
 
     return user;

src/services/GetCarModelsService.ts

@@ -0,0 +1,22 @@
+import { getRepository } from 'typeorm';
+
+import AppError from '../errors/AppError';
+
+import CarModels from '../models/CarModels';
+
+class GetCarModelsService {
+  public async execute(): Promise<CarModels[]> {
+    const carModelsRepository = getRepository(CarModels);
+
+    const carModels = await carModelsRepository.find();
+
+    if (!carModels) {
+      // carModels, fazer no front um tratamento para isso
+      throw new AppError('Não há modelos de carro cadastrados.');
+    };
+
+    return carModels;
+  }
+}
+
+export default GetCarModelsService;

src/services/UpdateUserService.ts

@@ -8,6 +8,7 @@ import Social from '../models/Social';
 interface Request {
   id_user: string;
   name: string;
+  lastname: string;
   username: string;
   bio: string;
   email: string;
@@ -15,7 +16,7 @@ interface Request {
 }
 
 class UpdateUserService {
-  public async execute({ id_user, name, username, bio, email, birth_date }: Request): Promise<User> {
+  public async execute({ id_user, name, lastname, username, bio, email, birth_date }: Request): Promise<User> {
     const usersRepository = getRepository(User);
     const socialRepository = getRepository(Social);
 
@@ -27,9 +28,12 @@ class UpdateUserService {
       throw new AppError('User does not exist.');
     };
 
-    user.name = name;
+    user.name = name
-    user.bio = bio;
+    user.lastname = lastname
-    user.birth_date = new Date(birth_date); // TODO, funciona?
+    user.bio = bio
+    user.email = email
+    
+    // user.birth_date = new Date(birth_date); // TODO, funciona?
 
     await usersRepository.save(user);