aloux-iam 0.0.114 → 0.0.115

package/lib/middleware.js

@@ -1,146 +1,146 @@
-const jwt = require("jsonwebtoken");
-const User = require("./models/User");
-const Permission = require("./models/Permission");
-const historyController = require("./controllers/history");
-
-const getAccess = (user, resource) => {
-  for (let i in user._functions) {
-    for (let j in user._functions[i]._permissions) {
-      if (user._functions[i]._permissions[j].status === "Activo") {
-        const permissionBack =
-          user._functions[i]._permissions[j].method +
-          " " +
-          user._functions[i]._permissions[j].endpoint;
-        if (permissionBack === resource.method + " " + resource.endpoint) {
-          return true;
-        }
-      }
-    }
-  }
-  return false;
-};
-
-const auth = async (req, res, next) => {
-  try {
-    let newHistory;
-    if (process.env.HISTORY === "true") {
-      const endpoints = process.env.HISTORY_ENDPOINTS.split(",");
-      const urlToCheck = req.route.path;
-      if (endpoints.includes(urlToCheck)) {
-        newHistory = await historyController.create(req);
-        req.history = newHistory._id.toString();
-      }
-    }
-
-    let token =
-      req.header("Authorization") || (req.cookies && req.cookies.token);
-
-    if (!token) {
-      throw {
-        code: 401,
-        title: "Error de autenticación",
-        detail: "Endpoint requiere token",
-        suggestion: "Vuelve a iniciar sesion",
-        error: new Error(),
-      };
-    }
-
-    token = token.replace("Bearer ", "");
-
-    const data = jwt.verify(token, process.env.AUTH_SECRET);
-    const user = await User.findOne(
-      { _id: data._id, "tokens.token": token, status: "Activo" },
-      { tokens: 0, pwd: 0 }
-    )
-      .populate({ path: "_functions", populate: [{ path: "_permissions" }] })
-      .lean();
-
-    if (!user) {
-      throw {
-        code: 401,
-        title: "Error de autenticación",
-        detail: "No se encontró el usuario",
-        suggestion: "Vuelve a iniciar sesion",
-        error: new Error(),
-      };
-    }
-
-    //Time session
-    if (process.env.SESSION_INTERRUPTOR === "true") {
-      const userTokens = await User.findOne(
-        { _id: user._id, status: "Activo" },
-        { tokens: 1 }
-      ).lean();
-      const tokenObject = userTokens.tokens.find((t) => t.token === token);
-      if (tokenObject.dateEnd <= Date.now()) {
-        await User.updateOne(
-          { _id: userTokens._id },
-          {
-            $pull: {
-              tokens: { token: tokenObject.token }, // Condición para eliminar el token específico
-            },
-          }
-        );
-        throw {
-          code: 401,
-          title: "La sesión expiró",
-          detail: "Has llegado al tiempo límite de tu sesión",
-          suggestion: "Se eliminó la sesión vencida",
-          error: new Error(),
-        };
-      }
-    }
-
-    const resource = await Permission.findOne({
-      method: req.originalMethod,
-      endpoint: req.route.path,
-    }).lean();
-    if (!resource) {
-      throw {
-        code: 403,
-        title: "Error de recurso",
-        detail:
-          "No se encontro  dado de alta el privilegio del endpoint: [" +
-          req.route.path +
-          "]",
-        suggestion: "Contacta con el administrador",
-        error: new Error(),
-      };
-    }
-
-    if (resource.auth && !resource.default) {
-      const access = getAccess(user, resource);
-      if (!access) {
-        throw {
-          code: 403,
-          title: "Error de permisos",
-          detail:
-            "No cuentas con permisos para el recurso [" +
-            resource.api +
-            "] que: " +
-            (resource ? resource.description : "Recurso indefinido"),
-          suggestion: "Contacta con el administrador",
-          error: new Error(),
-        };
-      }
-    }
-
-    req.user = user;
-    req.token = token;
-    req.permission = resource ? resource.description : "Recurso indefinido";
-    next();
-  } catch (error) {
-    let obj = error;
-    if (!error.code) {
-      obj = {
-        code: 401,
-        title: "Error de autenticación",
-        detail: error.message,
-        suggestion: "Vuelve a iniciar sesion",
-      };
-    }
-    res.status(obj.code).send(obj);
-  }
-};
-
-module.exports = auth;
+const jwt = require("jsonwebtoken");
+const User = require("./models/User");
+const Permission = require("./models/Permission");
+const historyController = require("./controllers/history");
+
+const getAccess = (user, resource) => {
+  for (let i in user._functions) {
+    for (let j in user._functions[i]._permissions) {
+      if (user._functions[i]._permissions[j].status === "Activo") {
+        const permissionBack =
+          user._functions[i]._permissions[j].method +
+          " " +
+          user._functions[i]._permissions[j].endpoint;
+        if (permissionBack === resource.method + " " + resource.endpoint) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+};
+
+const auth = async (req, res, next) => {
+  try {
+    let newHistory;
+    if (process.env.HISTORY === "true") {
+      const endpoints = process.env.HISTORY_ENDPOINTS.split(",");
+      const urlToCheck = req.route.path;
+      if (endpoints.includes(urlToCheck)) {
+        newHistory = await historyController.create(req);
+        req.history = newHistory._id.toString();
+      }
+    }
+
+    let token =
+      req.header("Authorization") || (req.cookies && req.cookies.token);
+
+    if (!token) {
+      throw {
+        code: 401,
+        title: "Error de autenticación",
+        detail: "Endpoint requiere token",
+        suggestion: "Vuelve a iniciar sesion",
+        error: new Error(),
+      };
+    }
+
+    token = token.replace("Bearer ", "");
+
+    const data = jwt.verify(token, process.env.AUTH_SECRET);
+    const user = await User.findOne(
+      { _id: data._id, "tokens.token": token, status: "Activo" },
+      { tokens: 0, pwd: 0 }
+    )
+      .populate({ path: "_functions", populate: [{ path: "_permissions" }] })
+      .lean();
+
+    if (!user) {
+      throw {
+        code: 401,
+        title: "Error de autenticación",
+        detail: "No se encontró el usuario",
+        suggestion: "Vuelve a iniciar sesion",
+        error: new Error(),
+      };
+    }
+
+    //Time session
+    if (process.env.SESSION_INTERRUPTOR === "true") {
+      const userTokens = await User.findOne(
+        { _id: user._id, status: "Activo" },
+        { tokens: 1 }
+      ).lean();
+      const tokenObject = userTokens.tokens.find((t) => t.token === token);
+      if (tokenObject.dateEnd <= Date.now()) {
+        await User.updateOne(
+          { _id: userTokens._id },
+          {
+            $pull: {
+              tokens: { token: tokenObject.token }, // Condición para eliminar el token específico
+            },
+          }
+        );
+        throw {
+          code: 401,
+          title: "La sesión expiró",
+          detail: "Has llegado al tiempo límite de tu sesión",
+          suggestion: "Se eliminó la sesión vencida",
+          error: new Error(),
+        };
+      }
+    }
+
+    const resource = await Permission.findOne({
+      method: req.originalMethod,
+      endpoint: req.route.path,
+    }).lean();
+    if (!resource) {
+      throw {
+        code: 403,
+        title: "Error de recurso",
+        detail:
+          "No se encontro  dado de alta el privilegio del endpoint: [" +
+          req.route.path +
+          "]",
+        suggestion: "Contacta con el administrador",
+        error: new Error(),
+      };
+    }
+
+    if (resource.auth && !resource.default) {
+      const access = getAccess(user, resource);
+      if (!access) {
+        throw {
+          code: 403,
+          title: "Error de permisos",
+          detail:
+            "No cuentas con permisos para el recurso [" +
+            resource.api +
+            "] que: " +
+            (resource ? resource.description : "Recurso indefinido"),
+          suggestion: "Contacta con el administrador",
+          error: new Error(),
+        };
+      }
+    }
+
+    req.user = user;
+    req.token = token;
+    req.permission = resource ? resource.description : "Recurso indefinido";
+    next();
+  } catch (error) {
+    let obj = error;
+    if (!error.code) {
+      obj = {
+        code: 401,
+        title: "Error de autenticación",
+        detail: error.message,
+        suggestion: "Vuelve a iniciar sesion",
+      };
+    }
+    res.status(obj.code).send(obj);
+  }
+};
+
+module.exports = auth;

package/lib/models/Business.js

@@ -1,14 +1,14 @@
-const mongoose = require("mongoose");
-
-const businessSchema = mongoose.Schema({
-  name: { type: String, required: true, trim: true, maxLength: 200 },
-  imgUrl: { type: String, required: false, trim: true, maxLength: 500 },
-  data: { type: Object, required: false },
-
-  status: { type: String, required: true, enum: ["Activo", "Inactivo"] },
-  createdAt: { type: Number },
-  lastUpdate: { type: Number },
-});
-
-const Business = mongoose.model("Business", businessSchema);
-module.exports = Business;
+const mongoose = require("mongoose");
+
+const businessSchema = mongoose.Schema({
+  name: { type: String, required: true, trim: true, maxLength: 200 },
+  imgUrl: { type: String, required: false, trim: true, maxLength: 500 },
+  data: { type: Object, required: false },
+
+  status: { type: String, required: true, enum: ["Activo", "Inactivo"] },
+  createdAt: { type: Number },
+  lastUpdate: { type: Number },
+});
+
+const Business = mongoose.model("Business", businessSchema);
+module.exports = Business;

package/lib/models/Functions.js

@@ -1,14 +1,14 @@
-const mongoose = require('mongoose')
-
-const functionsSchema = mongoose.Schema({
-    name:           { type: String, required: true, trim: true, unique: true },
-    description:    { type: String, trim: true },
-    _permissions:   [ { type: mongoose.Schema.Types.ObjectId, required: true, ref: 'Permission' } ],
-    _menus:         [ { type: mongoose.Schema.Types.ObjectId, required: true, ref: 'Menu' } ],
-    status:         { type: String, required: true, enum: ['Activo','Inactivo'] },
-    createdAt:      { type: Number },
-    lastUpdate:     { type: Number }
-})
-
-const Functions = mongoose.model("Functions", functionsSchema)
+const mongoose = require('mongoose')
+
+const functionsSchema = mongoose.Schema({
+    name:           { type: String, required: true, trim: true, unique: true },
+    description:    { type: String, trim: true },
+    _permissions:   [ { type: mongoose.Schema.Types.ObjectId, required: true, ref: 'Permission' } ],
+    _menus:         [ { type: mongoose.Schema.Types.ObjectId, required: true, ref: 'Menu' } ],
+    status:         { type: String, required: true, enum: ['Activo','Inactivo'] },
+    createdAt:      { type: Number },
+    lastUpdate:     { type: Number }
+})
+
+const Functions = mongoose.model("Functions", functionsSchema)
 module.exports = Functions

package/lib/models/History.js

@@ -1,15 +1,15 @@
-const mongoose = require("mongoose");
-const ObjectId = mongoose.Schema.Types.ObjectId;
-
-const historySchema = mongoose.Schema({
-  method: { type: String, default: false },
-  path: { type: String },
-  permission: { type: String },
-  payload: { type: Object, default: {} }, // Guarda cualquier estructura JSON
-  response: { type: Object, default: {} }, // Guarda cualquier estructura JSON
-  _createdBy: { type: ObjectId, required: false, ref: "User" },
-  createdAt: { type: Number, required: true },
-});
-
-const History = mongoose.model("History", historySchema);
-module.exports = History;
+const mongoose = require("mongoose");
+const ObjectId = mongoose.Schema.Types.ObjectId;
+
+const historySchema = mongoose.Schema({
+  method: { type: String, default: false },
+  path: { type: String },
+  permission: { type: String },
+  payload: { type: Object, default: {} }, // Guarda cualquier estructura JSON
+  response: { type: Object, default: {} }, // Guarda cualquier estructura JSON
+  _createdBy: { type: ObjectId, required: false, ref: "User" },
+  createdAt: { type: Number, required: true },
+});
+
+const History = mongoose.model("History", historySchema);
+module.exports = History;

package/lib/models/Label.js

@@ -0,0 +1,13 @@
+const mongoose = require("mongoose");
+
+const menuSchema = mongoose.Schema({
+  label: { type: String, required: true, trim: true },
+  description: { type: String, required: false, trim: true },
+
+  status: { type: String, required: true, enum: ["Activo", "Inactivo"] },
+  createdAt: { type: Number },
+  lastUpdate: { type: Number },
+});
+
+const Menu = mongoose.model("Label", menuSchema);
+module.exports = Menu;

package/lib/models/Log.js

@@ -0,0 +1,11 @@
+const mongoose = require("mongoose");
+const ObjectId = mongoose.Schema.Types.ObjectId;
+
+const menuSchema = mongoose.Schema({
+  _label: { type: ObjectId, required: true, ref: "Label" },
+  _user: { type: ObjectId, required: true, ref: "User" },
+  createdAt: { type: Number },
+});
+
+const Menu = mongoose.model("Log", menuSchema);
+module.exports = Menu;

package/lib/models/Menu.js

@@ -1,17 +1,17 @@
-const mongoose = require("mongoose");
-
-const menuSchema = mongoose.Schema({
-  label: { type: String, required: true, trim: true },
-  description: { type: String, required: false, trim: true },
-  path: { type: String, required: true, trim: true },
-  icon: { type: String, required: false, trim: true },
-  index: { type: Number },
-  _menu: { type: mongoose.Schema.Types.ObjectId, ref: "Menu" },
-
-  status: { type: String, required: true, enum: ["Activo", "Inactivo"] },
-  createdAt: { type: Number },
-  lastUpdate: { type: Number },
-});
-
-const Menu = mongoose.model("Menu", menuSchema);
-module.exports = Menu;
+const mongoose = require("mongoose");
+
+const menuSchema = mongoose.Schema({
+  label: { type: String, required: true, trim: true },
+  description: { type: String, required: false, trim: true },
+  path: { type: String, required: true, trim: true },
+  icon: { type: String, required: false, trim: true },
+  index: { type: Number },
+  _menu: { type: mongoose.Schema.Types.ObjectId, ref: "Menu" },
+
+  status: { type: String, required: true, enum: ["Activo", "Inactivo"] },
+  createdAt: { type: Number },
+  lastUpdate: { type: Number },
+});
+
+const Menu = mongoose.model("Menu", menuSchema);
+module.exports = Menu;

package/lib/models/Permission.js

@@ -1,16 +1,16 @@
-const mongoose = require("mongoose");
-
-const permissionSchema = mongoose.Schema({
-  description: { type: String, required: true, trim: true },
-  method: { type: String, required: true, unique: true },
-  api: { type: String, required: true },
-  endpoint: { type: String, required: true },
-  auth: { type: Number, required: true, default: 1 },
-  default: { type: Boolean },
-  status: { type: String, required: true, enum: ["Activo", "Inactivo"] },
-  createdAt: { type: Number },
-  lastUpdate: { type: Number },
-});
-
-const Permission = mongoose.model("Permission", permissionSchema);
-module.exports = Permission;
+const mongoose = require("mongoose");
+
+const permissionSchema = mongoose.Schema({
+  description: { type: String, required: true, trim: true },
+  method: { type: String, required: true, unique: true },
+  api: { type: String, required: true },
+  endpoint: { type: String, required: true },
+  auth: { type: Number, required: true, default: 1 },
+  default: { type: Boolean },
+  status: { type: String, required: true, enum: ["Activo", "Inactivo"] },
+  createdAt: { type: Number },
+  lastUpdate: { type: Number },
+});
+
+const Permission = mongoose.model("Permission", permissionSchema);
+module.exports = Permission;