user-roles

Back-end/modulo2/user-roles/.gitignore

@@ -0,0 +1,7 @@
+node_modules
+build
+
+.env
+
+.vscode
+requests.rest

Back-end/modulo2/user-roles/package.json

@@ -0,0 +1,33 @@
+{
+    "name": "to-do-list",
+    "version": "1.0.0",
+    "main": "index.js",
+    "scripts": {
+        "start": "tsc && node --inspect ./build/index.js",
+        "dev": "tsnd --transpile-only --ignore-watch node_modules ./src/index.ts",
+        "test": "ts-node-dev ./src/services/authenticator.ts"
+    },
+    "author": "Labenu",
+    "license": "ISC",
+    "dependencies": {
+        "@types/bcryptjs": "^2.4.2",
+        "@types/jsonwebtoken": "^8.5.8",
+        "@types/uuid": "^8.3.4",
+        "bcryptjs": "^2.4.3",
+        "cors": "^2.8.5",
+        "dotenv": "^8.2.0",
+        "express": "^4.17.1",
+        "jsonwebtoken": "^8.5.1",
+        "knex": "^0.21.5",
+        "mysql": "^2.18.1",
+        "uuid": "^8.3.2"
+    },
+    "devDependencies": {
+        "@types/cors": "^2.8.8",
+        "@types/express": "^4.17.8",
+        "@types/knex": "^0.16.1",
+        "@types/node": "^14.11.2",
+        "ts-node-dev": "^1.0.0-pre.63",
+        "typescript": "4.6.4"
+    }
+}

Back-end/modulo2/user-roles/src/business/UserBusiness.ts

@@ -0,0 +1,105 @@
+import { UserDatabase } from "../data/UserDatabase";
+import { CustomError, InvalidEmail, InvalidName, InvalidPassword, UnathorizedUser, UserNotFound } from "../error/customError";
+import { AuthenticationData } from "../model/types";
+import {
+  UserInputDTO,
+  user,
+  EditUserInputDTO,
+  EditUserInput,
+  LoginUserInputDTO,
+} from "../model/user";
+import Authenticator from "../services/Authenticator";
+import HashManager from "../services/HashManager";
+import IdGenerator from "../services/IdGenerator";
+
+export class UserBusiness {
+  private userDB: UserDatabase
+  constructor(){
+    this.userDB = new UserDatabase()
+  }
+  public createUser = async (input :UserInputDTO) => {
+    let {name , nickname, email, password, role} = input 
+
+    if (!name || !nickname || !email || !password || !role) {
+      throw new CustomError(422, "Ausência de parâmetro") 
+    }
+
+    if (role !== "NORMAL" && role !== "ADMIN"){
+      role = "NORMAL"
+    }
+
+    const id = IdGenerator.generateId()
+    const hash = await HashManager.generateHash(password)
+
+    const user :user = {
+      id, 
+      email, 
+      password: hash, 
+      name, 
+      nickname, 
+      role
+    }
+
+    await this.userDB.insertUser(user)
+    const token = Authenticator.generateToken({id, role})
+
+    return token
+  }
+
+  public login = async (input:LoginUserInputDTO) => {
+    let {email, password} = input 
+
+    if(!email || !password) {
+      throw new CustomError(400, "Ausência de parâmetros")
+    }
+
+    const user = await this.userDB.findUserByEmail(email)
+    const hashCompare = await HashManager.compareHash(
+      password, 
+      user.password
+    )
+
+    if(!hashCompare){ 
+      throw new InvalidPassword()
+    }
+
+    const payload :AuthenticationData = {
+      id: user.id, 
+      role: user.role
+    }
+
+    const token = Authenticator.generateToken(payload)
+
+    return token
+  }
+
+  public editUser = async (input:EditUserInputDTO, token: string) => {
+    let {name , nickname, id} = input 
+
+    if (!name || !nickname || !token) {
+      throw new CustomError(422, "Ausência de parâmetro") 
+    }
+
+    const userExist = await this.userDB.getUserById(id)
+    if(!userExist){
+      throw new UserNotFound()
+    }
+
+    const tokenData = Authenticator.getTokenData(token)
+    console.log(tokenData)
+
+    if(tokenData.role !== "ADMIN") {
+      throw new UnathorizedUser()
+    }
+
+    const editedUser :EditUserInput = {
+      name, 
+      nickname, 
+      id
+    }
+
+    await this.userDB.editUser(editedUser)
+  }
+
+
+}

Back-end/modulo2/user-roles/src/controller/UserController.ts

@@ -0,0 +1,71 @@
+import { Request, Response } from "express";
+import { UserBusiness } from "../business/UserBusiness";
+import { EditUserInputDTO, LoginUserInputDTO, UserInputDTO } from "../model/user";
+
+export class UserController {
+  private userBusiness: UserBusiness
+  constructor(){
+    this.userBusiness = new UserBusiness()
+  }
+
+      public signup = async (req: Request, res: Response) => {
+        try {
+          const input :UserInputDTO = {
+            email: req.body.email, 
+            password: req.body.password, 
+            name: req.body.name, 
+            nickname: req.body.nickname, 
+            role: req.body.role
+          }
+
+          const token = await this.userBusiness.createUser(input)
+
+          res.status(201).send({ message: "Usuário criado!", token });
+        } catch (error: any) {
+          res.status(400).send(error.message);
+        }
+      };   
+
+      public login = async (req: Request, res: Response) => {
+        try {
+          const input :LoginUserInputDTO = {
+            email: req.body.email,
+            password: req.body.password
+          }
+
+          const token = await this.userBusiness.login(input)
+
+          res.status(200).send({message: "Login efetuado com sucesso!", token})
+
+        } catch (error: any) {
+          res.status(400).send(error.message);
+
+        }
+      }
+
+      public editUser = async (req: Request, res: Response) => {
+        try {
+          const token = req.headers.authorization as string
+          const input :EditUserInputDTO = {
+            name: req.body.name, 
+            nickname: req.body.nickname,
+            id: req.params.id
+          }
+
+          await this.userBusiness.editUser(input, token)
+
+          res.status(200).send({message: "Usuário Alterado com sucesso" })
+
+        } catch (error: any) {
+          res.status(400).send(error.message);
+        }
+      }
+
+
+
+
+
+
+
+
+}

Back-end/modulo2/user-roles/src/controller/app.ts

@@ -0,0 +1,13 @@
+import express from 'express'
+import cors from 'cors'
+
+const app = express()
+
+app.use(express.json())
+app.use(cors())
+
+app.listen(3003, ()=>{
+    console.log('Servidor rodando na porta 3003')
+})
+
+export default app

Back-end/modulo2/user-roles/src/controller/userRouter.ts

@@ -0,0 +1,12 @@
+import express from "express";
+
+import { UserController } from "../controller/UserController";
+
+export const userRouter = express.Router()
+
+const userController = new UserController()
+
+userRouter.post('/signup', userController.signup)
+userRouter.post('/login', userController.login)
+userRouter.put('/edit/:id', userController.editUser)
+

Back-end/modulo2/user-roles/src/data/BaseDatabase.ts

@@ -0,0 +1,21 @@
+import knex from 'knex'
+import dotenv from 'dotenv'
+
+dotenv.config()
+
+export class BaseDatabase {
+
+   protected static connection = 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
+      }
+   })
+
+}
+

Back-end/modulo2/user-roles/src/data/UserDatabase.ts

@@ -0,0 +1,57 @@
+import { CustomError } from "../error/customError";
+import { EditUserInput, user } from "../model/user";
+import { BaseDatabase } from "./BaseDatabase";
+
+export class UserDatabase extends BaseDatabase {
+  public insertUser = async (user: user) => {
+    try {
+      await UserDatabase.connection
+        .insert({
+          id: user.id,
+          name: user.name,
+          nickname: user.nickname,
+          email: user.email,
+          password: user.password,
+          role: user.role
+        })
+        .into("Auth_users");
+    } catch (error: any) {
+      throw new CustomError(400, error.sqlMessage);
+    }
+  };
+
+  public editUser = async (user: EditUserInput) => {
+    try {
+      await UserDatabase.connection
+        .update({ name: user.name, nickname: user.nickname })
+        .where({ id: user.id })
+        .into("Auth_users");
+    } catch (error: any) {
+      throw new CustomError(400, error.sqlMessage);
+    }
+  };
+
+  public findUserByEmail = async (email: string) => {
+    try {
+      const result = await UserDatabase.connection("Auth_users")
+        .select()
+        .where({email});
+      return result[0];
+    } catch (error: any) {
+      throw new CustomError(400, error.sqlMessage);
+    }
+  };
+
+  public getUserById = async (id: string) => {
+    try {
+      const result = await UserDatabase.connection("Auth_users")
+        .select()
+        .where({id});
+      return result[0];
+    } catch (error: any) {
+      throw new CustomError(400, error.sqlMessage);
+    }
+  };
+
+
+}

Back-end/modulo2/user-roles/src/error/customError.ts

@@ -0,0 +1,35 @@
+export class CustomError extends Error {
+    constructor(statusCode: number, message: string){
+        super(message)
+    }
+}
+
+export class InvalidName extends CustomError{ 
+    constructor(){
+        super(400, "Nome inválido")
+    }
+}
+
+export class InvalidEmail extends CustomError{ 
+    constructor(){
+        super(400, "Email inválido")
+    }
+}
+
+export class InvalidPassword extends CustomError{ 
+    constructor(){
+        super(400, "Senha inválida")
+    }
+}
+
+export class UserNotFound extends CustomError{ 
+    constructor(){
+        super(404, "Usuário não encontrado")
+    }
+}
+
+export class UnathorizedUser extends CustomError{ 
+    constructor(){
+        super(401, "Usuário não autorizado")
+    }
+}

Back-end/modulo2/user-roles/src/index.ts

@@ -0,0 +1,5 @@
+import app from "./controller/app"
+import { userRouter } from "./controller/userRouter"
+
+
+app.use('/user/', userRouter)

Back-end/modulo2/user-roles/src/model/types.ts

@@ -0,0 +1,9 @@
+export type AuthenticationData = {
+    id: string, 
+    role: string
+}
+
+enum USER_ROLES {
+    ADMIN = "ADMIN", 
+    NORMAL = "NORMAL"
+}