Adicionando autenticação de usuário

Author: avdLuna

Diff for: .env.example

@@ -0,0 +1,4 @@
+# Authentication
+
+JWT_SECRET=
+JWT_EXPIRATION_DAYS=7

Diff for: app/config/enviroment.js

@@ -0,0 +1,26 @@
+require('dotenv').config();
+
+const environment = {
+    development: {
+        JWT: {
+            secret: process.env.JWT_SECRET,
+            expiration_days: process.env.JWT_EXPIRATION_DAYS
+        }
+    },
+
+    staging: {
+        JWT: {
+            secret: process.env.JWT_SECRET,
+            expiration_days: process.env.JWT_EXPIRATION_DAYS
+        }
+    },
+
+    production: {
+        JWT: {
+            secret: process.env.JWT_SECRET,
+            expiration_days: process.env.JWT_EXPIRATION_DAYS
+        }
+    }
+}
+
+module.exports = environment[process.env.NODE_ENV || 'development'];

Diff for: app/controllers/auth.controller.js

@@ -9,9 +9,10 @@ const login = async (req, res) => {
         log.info('Iniciando login', { email });
 
         const result = await service.login(email, password);
-        if (!result)
+        if (!result){
             return http.notFound(res, 'E-mail ou senha inválido(a)');
-
+        }
+        
         log.info('Login finalizado', { email });
 
         const { user, token } = result;

Diff for: app/controllers/user.controller.js

@@ -8,6 +8,7 @@ const create = async (req,res) => {
 
         const data = req.body;
         const email = data.email;
+        const password = data.password;
         /* Dá erro aqui, investigar
         const user = await UserService.findByEmail(email)
                     .then(userData => {
@@ -16,10 +17,12 @@ const create = async (req,res) => {
                         }
                     })
 */
+
         const createdUser = await UserService.create(data)
                             .then(userData => {
                                 return http.ok(res,userData);
                             });
+        
         return createdUser;
 
     } catch (error) {
@@ -34,14 +37,13 @@ const get = async (req,res) => {
 
         const id = req.params.id;
 
-        const user = await UserService.get(id)
-                            .then(userData => {
-                                if(!userData){
-                                    return http.notFound(res, "Nenhum usuário encontrado");
-                                }
-                                return http.ok(res,userData);
-                            });
-        return user;
+        const user = await UserService.get(id);
+
+        if(!user){
+            return http.notFound(res, "Usuário não encontrado");
+        }
+
+        return http.ok(res, user);
     } catch(error){
         log.error("Erro obter usuário", req.originalUrl, error);
         http.internalServerError(res);
@@ -52,11 +54,9 @@ const getAll = async (req,res) => {
     try {
         log.info("Iniciando obtenção de todos os usuários");
 
-        const user = await UserService.getAll()
-                            .then(userData => {
-                                return http.ok(res,userData);
-                            });
-        return user;
+        const user = await UserService.getAll();
+
+        return http.ok(res, user);
     } catch(error){
         log.error("Erro obter usuários", req.originalUrl, error);
         http.internalServerError(res);

Diff for: app/models/user.model.js

@@ -1,28 +1,38 @@
 const bcrypt = require('bcryptjs');
+const config = require('../config/enviroment');
 const jwt = require('jsonwebtoken');
+const mongoose = require('mongoose');
+const { Schema } = require('mongoose');
 const { getDateTime } = require('../services/util.service');
+const SALT_WORK_FACTOR = 10;
 
-module.exports = mongoose => {
-    const User = mongoose.model(
-      "user",
-      mongoose.Schema(
-        {
-          name: String,
-          email: String,
-          password: String
-        },
-        { timestamps: true }
-      )
-    );
-  
-    User.prototype.checkPassword = function (password) {
-      return bcrypt.compare(password, this.passwordHash);
-    }
+const UserSchema = new Schema({
+      name: String,
+      email: String,
+      password: String
+});
+    
+    
+UserSchema.pre('save', async function save(next) {
+  if (!this.isModified('password')) return next();
+  try {
+    const salt = await bcrypt.genSalt(SALT_WORK_FACTOR);
+    this.password = await bcrypt.hash(this.password, salt);
+    return next();
+  } catch (err) {
+    return next(err);
+  }
+});
 
-    User.prototype.generateAuthToken = function () {
-      const { secret, expiration_days } = config.JWT;
-      return jwt.sign({ id: this.id }, secret, { expiresIn: `${expiration_days}d` });
-    }
+UserSchema.methods.validatePassword = async function validatePassword(data) {
+  return await bcrypt.compareSync(data, this.password);
+};
 
-    return User;
-  };
+UserSchema.methods.generateAuthToken = function () {
+  const { secret, expiration_days } = config.JWT;
+  return jwt.sign({ id: this.id }, secret, { expiresIn: `${expiration_days}d` });
+}
+
+const model = mongoose.model('User', UserSchema);
+
+module.exports = model;

Diff for: app/services/auth.service.js

@@ -1,24 +1,32 @@
-const { User } = require('../models');
+const UserService = require('../services/user.service');
+const User = require("../models/user.model");
 
-async function login(email, password) {
+async function login(mail, password) {
     try {
-        const user = await User.find({},{ email });
-        if (!user)
+        let token = null;
+        const user = await User.findOne({ email: mail });
+        
+        if (!user){
             return null;
+        }
 
-        const validPassword = await user.checkPassword(password);
-        if (!validPassword)
+       const validPassword = await user.validatePassword(password);
+        console.log(validPassword);
+        if (!validPassword){
             return null;
+        }
 
-        const {id, name, email} = user;
+        token = user.generateAuthToken();
+
+        const {_id, name, email} = user;
 
         return {
             user: {
-                id, 
+                _id, 
                 name, 
                 email,
             },
-            token: user.generateAuthToken()
+            token: token
         };
     } catch (error) {
         throw error;

Diff for: app/services/user.service.js

@@ -1,5 +1,5 @@
 const db = require("../models");
-const User = db.user;
+const User = require("../models/user.model");
 
 async function create(data){
     try {    
@@ -32,7 +32,7 @@ async function get(id){
         const user = await User.findById(id);
 
         if(!user){
-            return null
+            return null;
         }
 
         return user

Diff for: package-lock.json

@@ -21,6 +21,7 @@
     "bcryptjs": "^2.4.3",
     "body-parser": "^1.19.0",
     "cors": "^2.8.5",
+    "dotenv": "^8.2.0",
     "express": "^4.17.1",
     "express-validator": "^6.6.1",
     "jsonwebtoken": "^8.5.1",

Diff for: package.json

@@ -1,20 +1,19 @@
 const express = require("express");
 const router = express.Router();
 
-//const authMiddleware = require('./app/middlewares/auth');
-
-//const auth = require('./app/routes/auth.route');
+const authMiddleware = require('./app/middlewares/auth');
 
+const auth = require('./app/routes/auth.route');
 const user = require('./app/routes/user.route');
 
 router.get('/', (req, res) => {
     return res.send('Bubbles API');
 });
 
 router.use('/user', user);
-
+router.use('/auth', auth);
 // Private routes
-//router.use(authMiddleware);
+router.use(authMiddleware);