Semana21 aula64

semana21/testes-backend/.gitignore

@@ -0,0 +1,6 @@
+node_modules/
+build/
+.vscode/
+
+.env
+.rest

semana21/testes-backend/jest.config.js

@@ -0,0 +1,8 @@
+module.exports = {
+   roots: ["<rootDir>/tests"],
+   transform: {
+      "^.+\\.tsx?$": "ts-jest",
+   },
+   testRegex: "(/__tests__/.*|(\\.|/)(test|spec))\\.tsx?$",
+   moduleFileExtensions: ["ts", "tsx", "js", "jsx", "json", "node"],
+};

semana21/testes-backend/package.json

@@ -0,0 +1,34 @@
+{
+   "name": "testes-no-backend",
+   "version": "1.0.0",
+   "description": "",
+   "main": "index.js",
+   "scripts": {
+      "test": "clear && echo \"Running tests...\" && jest",
+      "start": "tsc && node --inspect ./build/src/index.js",
+      "dev": " ts-node-dev ./src/index.ts"
+   },
+   "author": "Labenu",
+   "license": "ISC",
+   "dependencies": {
+      "bcryptjs": "^2.4.3",
+      "dotenv": "^8.2.0",
+      "express": "^4.17.1",
+      "jsonwebtoken": "^8.5.1",
+      "knex": "^0.21.1",
+      "mysql": "^2.18.1",
+      "uuid": "^8.0.0"
+   },
+   "devDependencies": {
+      "@types/bcryptjs": "^2.4.2",
+      "@types/express": "^4.17.6",
+      "@types/jest": "^25.2.3",
+      "@types/jsonwebtoken": "^8.5.0",
+      "@types/knex": "^0.16.1",
+      "@types/uuid": "^7.0.3",
+      "jest": "^26.0.1",
+      "ts-jest": "^26.1.0",
+      "ts-node-dev": "^1.0.0-pre.44",
+      "typescript": "^3.9.2"
+   }
+}

semana21/testes-backend/src/business/GetUserByIdBusinness.ts

@@ -0,0 +1,24 @@
+import { GetUserIdData } from "../data/GetUserIdData"
+import { CustomError } from "../errors/CustomError"
+
+export class GetUserByIdBusiness{
+    constructor(
+        private getUserIdData: GetUserIdData
+    ){}
+   public getUserId = async(id: string) => {
+
+        //    const getData = new GetUserIdData();
+           const resultUser = await this.getUserIdData.getUserIdData(id)
+
+           console.log("resultbusiness", resultUser)
+
+           if(!resultUser){
+            throw new CustomError (404, "Not Found")
+           }
+
+           return resultUser
+
+    }
+}
+
+export default new GetUserByIdBusiness(new GetUserIdData())

semana21/testes-backend/src/business/UserBusiness.ts

@@ -0,0 +1,97 @@
+import { CustomError } from "../errors/CustomError";
+import { User, stringToUserRole } from "../model/User";
+import {UserDatabase} from "../data/UserDatabase";
+import {HashGenerator} from "../services/hashGenerator";
+import {IdGenerator} from "../services/idGenerator";
+import {TokenGenerator} from "../services/tokenGenerator";
+
+export class UserBusiness {
+
+   constructor(
+     private idGenerator: IdGenerator,
+     private hashGenerator: HashGenerator,
+     private tokenGenerator: TokenGenerator,
+     private userDatabase: UserDatabase
+   ){
+
+   }
+
+   public async signup(
+      name: string,
+      email: string,
+      password: string,
+      role: string
+   ) {
+      try {
+         if (!name || !email || !password || !role) {
+            throw new CustomError(422, "Missing input");
+         }
+
+         if (email.indexOf("@") === -1) {
+            throw new CustomError(422, "Invalid email");
+         }
+
+         if (password.length < 6) {
+            throw new CustomError(422, "Invalid password");
+         }
+
+         const id = this.idGenerator.generate();
+         const cypherPassword = await this.hashGenerator.hash(password);
+         await this.userDatabase.createUser(
+            new User(id, name, email, cypherPassword, stringToUserRole(role))
+         );
+
+         const accessToken = this.tokenGenerator.generate({
+            id,
+            role,
+         });
+         return { accessToken };
+      } catch (error) {
+         if (error.message.includes("key 'email'")) {
+            throw new CustomError(409, "Email already in use")
+         }
+
+         throw new CustomError(error.statusCode, error.message)
+      }
+
+   }
+
+   public async login(email: string, password: string) {
+
+      try {
+         if (!email || !password) {
+            throw new CustomError(422, "Missing input");
+         }
+
+         const user = await this.userDatabase.getUserByEmail(email);
+
+         if (!user) {
+            throw new CustomError(401, "Invalid credentials");
+         }
+
+         const isPasswordCorrect = await this.hashGenerator.compareHash(
+            password,
+            user.getPassword()
+         );
+
+         if (!isPasswordCorrect) {
+            throw new CustomError(401, "Invalid credentials");
+         }
+
+         const accessToken = this.tokenGenerator.generate({
+            id: user.getId(),
+            role: user.getRole(),
+         });
+
+         return { accessToken };
+      } catch (error) {
+         throw new CustomError(error.statusCode, error.message)
+      }
+   }
+}
+
+export default new UserBusiness
+                  (new IdGenerator(),
+                  new HashGenerator(), 
+                  new TokenGenerator(),
+                  new UserDatabase())

semana21/testes-backend/src/controller/GetUserByIdController.ts

@@ -0,0 +1,32 @@
+import { GetUserByIdBusiness } from './../business/GetUserByIdBusinness';
+import { Request, Response } from "express"
+import { UserDatabase } from "../data/UserDatabase";
+import { GetUserIdData } from '../data/GetUserIdData';
+
+export class GetUserByIdController{
+    getUserId = async(
+        req: Request,
+        res: Response
+    ) => {
+        try {
+
+            const {id} = req.params;
+
+            const getUserById = new GetUserByIdBusiness(new GetUserIdData())
+            const result = await getUserById.getUserId(id)
+
+            res.status(200).send({
+                id: result.id,
+                name: result.name,
+                email: result.email,
+                role: result.role
+            })
+
+        } catch (error) {
+            const { statusCode, message } = error
+            res.status(statusCode || 400).send({ message });
+        }
+    }
+}
+
+export default new GetUserByIdController()

semana21/testes-backend/src/controller/UserController.ts

@@ -0,0 +1,54 @@
+import { Request, Response } from "express";
+import { UserBusiness } from "../business/UserBusiness";
+import { IdGenerator } from "../services/idGenerator";
+import { HashGenerator } from "../services/hashGenerator";
+import { TokenGenerator } from "../services/tokenGenerator";
+import { UserDatabase } from "../data/UserDatabase";
+import { IdGeneratorMock } from "../../tests/mocks/idGeneratorMock";
+import { HashGeneratorMock } from "../../tests/mocks/HashGeneratorMock";
+import { TokenGeneratorMock } from "../../tests/mocks/TokenGeneratorMock";
+import { UserDatabaseMock } from "../../tests/mocks/UserDatabaseMock";
+
+export class UserController {
+
+   public async signup(req: Request, res: Response) {
+      try {
+         const { name, role, email, password } = req.body
+         const userBusiness =
+         new UserBusiness(
+            new IdGenerator(),
+            new HashGenerator(),
+            new TokenGenerator(),
+            new UserDatabase());
+
+         const result = await userBusiness.signup(
+            name,
+            email,
+            password,
+            role
+         );
+         res.status(200).send(result);
+      } catch (error) {
+         const { statusCode, message } = error
+         res.status(statusCode || 400).send({ message });
+      }
+   }
+
+   public async login(req: Request, res: Response) {
+      try {
+         const { email, password } = req.body;
+         const userBusiness = new UserBusiness(
+         new IdGenerator(),
+         new HashGenerator(),
+         new TokenGenerator(),
+         new UserDatabase());
+         const result = await userBusiness.login(email, password);
+         res.status(200).send(result);
+      } catch (error) {
+         const { statusCode, message } = error
+         res.status(statusCode || 400).send({ message });
+      }
+   }
+}
+
+export default new UserController()

semana21/testes-backend/src/data/BaseDataBase.ts

@@ -0,0 +1,23 @@
+import dotenv from "dotenv";
+import knex from "knex";
+
+dotenv.config();
+
+export default class BaseDataBase {
+
+   protected static connection: knex = knex({
+      client: "mysql",
+      connection: {
+         host: process.env.DB_HOST,
+         user: process.env.DB_USER,
+         password: process.env.DB_PASSWORD,
+         database: process.env.DB_SCHEMA,
+         port: 3306,
+         multipleStatements: true
+      },
+   });
+
+   public static async destroyConnection(): Promise<void> {
+      await BaseDataBase.connection.destroy();
+   }
+}

semana21/testes-backend/src/data/GetUserIdData.ts

@@ -0,0 +1,25 @@
+import { User } from '../model/User';
+import BaseDataBase from './BaseDataBase';
+
+export class GetUserIdData extends BaseDataBase{
+
+    getUserIdData = async (id: string) => {
+        // try {
+
+            const result = await BaseDataBase.connection.select("*").from("aula58_users").where({id})
+            // if(result.length < 1){
+            //     throw new Error("User Not found")
+            // }
+            console.log("result", result)
+            return result[0]
+
+
+
+        // } catch (error) {
+
+        //     throw new Error(error.sqlMessage || error.message)
+
+        // }
+
+    }
+}

semana21/testes-backend/src/data/UserDatabase.ts

@@ -0,0 +1,74 @@
+import BaseDataBase from "./BaseDataBase";
+import { User } from "../model/User";
+
+export class UserDatabase extends BaseDataBase {
+
+   protected tableName: string = "INSIRA AQUI O NOME DA SUA TABELA DE USUÁRIOS";
+
+   private toModel(dbModel?: any): User | undefined {
+      return (
+         dbModel &&
+         new User(
+            dbModel.id,
+            dbModel.name,
+            dbModel.email,
+            dbModel.password,
+            dbModel.role
+         )
+      );
+   }
+
+   public async createUser(user: User): Promise<void> {
+      try {
+         await BaseDataBase.connection.raw(`
+            INSERT INTO ${this.tableName} (id, name, email, password, role)
+            VALUES (
+            '${user.getId()}', 
+            '${user.getName()}', 
+            '${user.getEmail()}',
+            '${user.getPassword()}', 
+            '${user.getRole()}'
+            )`
+         );
+      } catch (error) {
+         throw new Error(error.sqlMessage || error.message)
+      }
+   }
+
+   public async getUserByEmail(email: string): Promise<User | undefined> {
+      try {
+         const result = await BaseDataBase.connection.raw(`
+            SELECT * from ${this.tableName} WHERE email = '${email}'
+         `);
+         return this.toModel(result[0][0]);
+      } catch (error) {
+         throw new Error(error.sqlMessage || error.message)
+      }
+   }
+
+   public async getUserById(id: string): Promise<User | undefined> {
+      try {
+         const result = await BaseDataBase.connection.raw(`
+            SELECT * from ${this.tableName} WHERE id = '${id}'
+         `);
+         return this.toModel(result[0][0]);
+      } catch (error) {
+         throw new Error(error.sqlMessage || error.message)
+      }
+   }
+
+   public async getAllUsers(): Promise<User[]> {
+      try {
+         const result = await BaseDataBase.connection.raw(`
+            SELECT * from ${this.tableName}
+         `);
+         return result[0].map((res: any) => {
+            return this.toModel(res);
+         });
+      } catch (error) {
+         throw new Error(error.sqlMessage || error.message)
+      }
+   }
+}
+
+export default new UserDatabase()