Feature/users

config.js

@@ -1,5 +1,7 @@
 exports.port = process.argv[2] || process.env.PORT || 8080;
-exports.dbUrl = process.env.MONGO_URL || process.env.DB_URL || 'mongodb://127.0.0.1:27017/test';
+exports.dbUrl = process.env.MONGO_URL || process.env.DB_URL || 'mongodb://127.0.0.1:27017/BurgerQueenApi';
 exports.secret = process.env.JWT_SECRET || 'esta-es-la-api-burger-queen';
 exports.adminEmail = process.env.ADMIN_EMAIL || 'admin@localhost';
 exports.adminPassword = process.env.ADMIN_PASSWORD || 'changeme';
+
+// Variables de entorno las que están en mayúsculas-Investigar

connect.js

@@ -1,10 +1,34 @@
+const { MongoClient } = require('mongodb');
 const config = require('./config');
+const { default: mongoose } = require('mongoose');
+
+const client = new MongoClient(config.dbUrl);
 
 // eslint-disable-next-line no-unused-vars
 const { dbUrl } = config;
 
 async function connect() {
   // TODO: Conexión a la Base de Datos
+  try {
+    await mongoose.connect(dbUrl, {
+      useNewUrlParser: true,
+      useUnifiedTopology: true,
+    });
+    console.log('-Connected to database');
+    return mongoose.connection;
+  } catch (error) {
+    console.error('-Cannot connect to database', error);
+    throw error;
+  }
+}
+
+async function disconnect() {
+  try {
+    await mongoose.disconnect();
+    console.log('-Disconnected from database');
+  } catch (error) {
+    console.error('-Error disconnecting from the database', error);
+  }
 }
 
 module.exports = { connect };

controller/productscontroller.js

@@ -0,0 +1,6 @@
+const { Product } = require('../models/productsModels')
+
+module.exports = { getProducts: async(req, res, next) => {
+ const products = await Product.find()
+    res.json(products)
+}}

controller/users.js

@@ -1,5 +1,10 @@
+const { User } = require('../models/usersModels');
+
 module.exports = {
-  getUsers: (req, resp, next) => {
+  getUsers: async (req, resp, next) => {
     // TODO: Implementa la función necesaria para traer la colección `users`
-  },
+    const users = await User.find();
+    return resp.json(users); 
+   },
 };
+

e2e/globalConfig.json

@@ -0,0 +1 @@
+{"mongoUri":"mongodb://127.0.0.1:54568/","mongoDBName":"jest"}

e2e/globalSetup.js

@@ -21,6 +21,7 @@ const __e2e = {
   testUserCredentials: {
     email: 'test@test.test',
     password: '123456',
+    role: 'waiter'
   },
   testUserToken: null,
   childProcessPid: null,
@@ -30,8 +31,9 @@ const __e2e = {
   // testObjects: [],
 };
 
-const fetch = (url, opts = {}) => import('node-fetch')
-  .then(({ default: fetch }) => fetch(`${baseUrl}${url}`, {
+const fetch = (url, opts = {}) =>  {
+  console.log(`${baseUrl}${url}`);
+  return global.fetch(`${baseUrl}${url}`, {
     ...opts,
     headers: {
       'content-type': 'application/json',
@@ -42,8 +44,8 @@ const fetch = (url, opts = {}) => import('node-fetch')
         ? { body: JSON.stringify(opts.body) }
         : {}
     ),
-  }));
-
+  });
+}
 const fetchWithAuth = (token) => (url, opts = {}) => fetch(url, {
   ...opts,
   headers: {
@@ -146,6 +148,7 @@ module.exports = () => new Promise((resolve, reject) => {
       .then(resolve)
       .catch((err) => {
         console.log('there was an error');
+        console.error(err);
         kill(child.pid, 'SIGKILL', () => reject(err));
       })
     }).catch((error)=> console.log(error));

e2e/users.spec.js

@@ -155,6 +155,7 @@ describe('POST /users', () => {
       body: {
         email: 'test1@test.test',
         password: '12345',
+        //role: 'admin',
         roles: { admin: false },
       },
     })

middleware/auth.js

@@ -1,44 +1,56 @@
 const jwt = require('jsonwebtoken');
 
-module.exports = (secret) => (req, resp, next) => {
-  const { authorization } = req.headers;
-
+module.exports = (secret) => (req, res, next) => {
+  const { authorization } = req.headers;  
+  
   if (!authorization) {
     return next();
-  }
+  }  
 
-  const [type, token] = authorization.split(' ');
+  const [type, token] = authorization.split(' ');  
 
   if (type.toLowerCase() !== 'bearer') {
     return next();
-  }
+  }  
 
-  jwt.verify(token, secret, (err, decodedToken) => {
+  jwt.verify(token, secret, async (err, decodedToken) => {
     if (err) {
       return next(403);
     }
 
-    // TODO: Verificar identidad del usuario usando `decodeToken.uid`
+    // Extrae el rol directamente del token JWT si está presente
+    const userRole = decodedToken.role || 'usuario_predeterminado'; 
+
+    // TODO: Verificar identidad del usuario usando `decodedToken.uid`
+    req.decodedTokenUser = decodedToken.userId; // Guarda el token decodificado en el objeto de solicitud
+    req.userRole = userRole;
+    console.log("userId", req.decodedTokenUser);
+    console.log("userRole", req.userRole);
+    next(); // Continua con el siguiente middleware  
   });
 };
 
-module.exports.isAuthenticated = (req) => (
-  // TODO: decidir por la informacion del request si la usuaria esta autenticada
-  false
-);
+module.exports.isAuthenticated = (req) => {
+  req.isAuthenticated = req.decodedTokenUser !== null;
+  console.log("request", req.decodedTokenUser);
+  console.log("se está evaluando que esté autenticado", req.isAuthenticated);
+  console.log("Lo que retorna isAuthenticated", !!req.isAuthenticated);
+  return !!req.isAuthenticated;
+};
 
-module.exports.isAdmin = (req) => (
-  // TODO: decidir por la informacion del request si la usuaria es admin
-  false
-);
+module.exports.isAdmin = (req) => {
+  // TODO: decidir por la información del request si la usuaria es admin
+  console.log("userRole", req.userRole);
+  return req.userRole === 'admin';
+};
 
-module.exports.requireAuth = (req, resp, next) => (
+module.exports.requireAuth = (req, res, next) => (
   (!module.exports.isAuthenticated(req))
     ? next(401)
     : next()
 );
 
-module.exports.requireAdmin = (req, resp, next) => (
+module.exports.requireAdmin = (req, res, next) => (
   // eslint-disable-next-line no-nested-ternary
   (!module.exports.isAuthenticated(req))
     ? next(401)

models/ordersModels.js

@@ -0,0 +1,67 @@
+const mongoose = require('mongoose');
+
+const { Schema, model } = mongoose;
+
+const orderSchema = new Schema({
+  id: {
+    type: Number,
+    required: true,
+    unique: true,
+  },
+  userId: {
+    type: Number,
+    required: true,
+  },
+  client: {
+    type: String,
+    required: true,
+  },
+  products: [
+    {
+      qty: {
+        type: Number,
+        required: true,
+      },
+      product: {
+        id: {
+          type: Number,
+          required: true,
+        },
+        name: {
+          type: String,
+          required: true,
+        },
+        price: {
+          type: Number,
+          required: true,
+        },
+        image: {
+          type: String,
+          required: true,
+        },
+        type: {
+          type: String,
+          enum: ['Desayuno', 'Almuerzo'],
+          required: true,
+        },
+        dateEntry: {
+          type: String,
+          required: true,
+        },
+      },
+    },
+  ],
+  status: {
+    type: String,
+    enum: ['pending', 'preparation', 'ready', 'delivered'],
+    default: 'pending',
+  },
+  dateEntry: {
+    type: String,
+    required: true,
+  },
+});
+
+const Order = model('Order', orderSchema);
+
+module.exports = Order;

models/productsModels.js

@@ -0,0 +1,34 @@
+const mongoose = require('mongoose');
+
+const { Schema, model } = mongoose;
+
+const productsSchema = new Schema({
+  id: {
+    type: Number,
+    required: true,
+    unique: true,
+  },
+  name: {
+    type: String,
+    required: true,
+  },
+  price: {
+    type: Number,
+    required: true,
+  },
+  image: {
+    type: String,
+    required: true,
+  },
+  type: {
+    type: String,
+    enum: ['Desayuno', 'Almuerzo'],
+    required: true,
+  },
+  dateEntry: {
+    type: String,
+    required: true,
+  },
+});
+
+exports.Product = mongoose.model("products", productsSchema);

models/usersModels.js

@@ -0,0 +1,19 @@
+const mongoose = require('mongoose');
+
+const userSchema = new mongoose.Schema({
+  email: {
+    type: String,
+    required: true,
+  },
+  password: {
+    type: String,
+    required: true,
+  },
+  role: {
+      type: String,
+      enum: ['admin', 'chef', 'waiter'],
+      required: true,
+    },
+  });
+
+exports.User = mongoose.model('users', userSchema);