aloux-iam 0.0.116 → 0.0.117

package/lib/controllers/label.js

@@ -0,0 +1,82 @@
+const Label = require("../models/Label");
+const self = module.exports;
+
+self.create = async (req, res) => {
+  try {
+    const label = new Label(req.body);
+    label.createdAt = new Date().getTime();
+    label.status = "Activo";
+    await label.save();
+    res.status(201).send(label);
+  } catch (error) {
+    res.status(400).send({ error: error.message });
+  }
+};
+
+self.update = async (req, resp) => {
+  try {
+    await new Label(req.body).validate();
+    const _id = req.params.LABEL_ID;
+    const count = await Label.findOne({ _id }).countDocuments();
+    if (!count) throw new Error("Upss! No se encontró el registro");
+    req.body.lastUpdate = new Date().getTime();
+    const result = await Label.updateOne({ _id }, req.body);
+    resp.status(200).send(req.body);
+  } catch (error) {
+    resp.status(400).send({ error: error.message });
+  }
+};
+self.status = async (req, resp) => {
+  try {
+    const _id = req.params.LABEL_ID;
+    const user = await Label.findOne({ _id });
+    if (!user) throw new Error("Upss! No se encontró el Elemento");
+    user.status = req.body.status;
+    user.lastUpdate = new Date().getTime();
+    const result = await user.save();
+    resp.status(200).send(result);
+  } catch (error) {
+    resp.status(400).send({ error: error.message });
+  }
+};
+self.retrieve = async (req, res) => {
+  try {
+    const consulta = await Label.find({}).sort({ index: 1 });
+    if (!consulta) res.status(404).send();
+    res.status(200).send(consulta);
+  } catch (error) {
+    res.status(400).send(error);
+  }
+};
+
+self.get = async (req, res) => {
+  try {
+    const _id = req.params.LABEL_ID;
+    const label = await Label.findOne({ _id });
+    if (!label) res.status(404).send();
+    res.status(200).send(label);
+  } catch (error) {
+    res.status(400).send(error);
+  }
+};
+
+self.delete = async (req, res) => {
+  try {
+    const _id = req.params.LABEL_ID;
+    const response = await Label.deleteOne({ _id });
+    if (!response.deletedCount)
+      res.status(404).send({ error: "El registro no existe" });
+    else res.status(200).send({});
+  } catch (error) {
+    res.status(400).send({ error: error.message });
+  }
+};
+
+self.count = async (req, res) => {
+  try {
+    let result = await Label.find({}).countDocuments();
+    res.status(200).send({ count: result });
+  } catch (error) {
+    res.status(400).send({ error: error.message });
+  }
+};

package/lib/controllers/log.js

@@ -0,0 +1,268 @@
+const Log = require("../models/Log");
+const Label = require("../models/Label");
+const self = module.exports;
+
+self.create = async (req, res) => {
+  try {
+    const log = new Log(req.body);
+    log.createdAt = new Date().getTime();
+    log._user = req.user._id;
+    const label = await Label.findOne(
+      { label: req.body.label },
+      { _id: 1 }
+    ).lean();
+    if (label) {
+      log._label = label._id;
+      await log.save();
+    }
+
+    res.status(201).send(log);
+  } catch (error) {
+    res.status(400).send({ error: error.message });
+  }
+};
+
+self.update = async (req, resp) => {
+  try {
+    await new Log(req.body).validate();
+    const _id = req.params.LOG_ID;
+    const count = await Log.findOne({ _id }).countDocuments();
+    if (!count) throw new Error("Upss! No se encontró el registro");
+    req.body.lastUpdate = new Date().getTime();
+    const result = await Log.updateOne({ _id }, req.body);
+    resp.status(200).send(req.body);
+  } catch (error) {
+    resp.status(400).send({ error: error.message });
+  }
+};
+self.status = async (req, resp) => {
+  try {
+    const _id = req.params.LOG_ID;
+    const user = await Log.findOne({ _id });
+    if (!user) throw new Error("Upss! No se encontró el Elemento");
+    user.status = req.body.status;
+    user.lastUpdate = new Date().getTime();
+    const result = await user.save();
+    resp.status(200).send(result);
+  } catch (error) {
+    resp.status(400).send({ error: error.message });
+  }
+};
+self.retrieve = async (req, res) => {
+  try {
+    let query = {};
+
+    if (req.body.users.length) {
+      query = {
+        _user: { $in: req.body.users },
+      };
+    }
+
+    const consulta = await Log.find(query)
+      .populate([
+        { path: "_label" },
+        { path: "_user", select: { name: 1, lastName: 1 } },
+      ])
+      .sort({ createdAt: 1 })
+      .lean();
+
+    const response = {
+      dataset0: { field: "Total de operaciones", count: consulta.length },
+      dataset1: consulta,
+      dataset2: processDataset2(consulta),
+      dataset3: processDataset3(consulta),
+      dataset4: processDataset4(consulta),
+      dataset5: processDataset5(consulta),
+      dataset6: processDataset6(consulta),
+      dataset7: processDataset7(consulta),
+    };
+
+    res.status(200).send(response);
+  } catch (error) {
+    console.error(error);
+    res.status(400).send(error);
+  }
+};
+
+function formatDate(date) {
+  const day = String(date.getDate()).padStart(2, "0");
+  const monthNames = [
+    "Ene",
+    "Feb",
+    "Mar",
+    "Abr",
+    "May",
+    "Jun",
+    "Jul",
+    "Ago",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dic",
+  ];
+  const month = monthNames[date.getMonth()];
+  const year = date.getFullYear();
+  return `${day} ${month} ${year}`;
+}
+
+function processDataset2(consulta) {
+  const labelCounts = consulta.reduce((acc, item) => {
+    const label = item._label.label;
+    acc[label] = (acc[label] || 0) + 1;
+    return acc;
+  }, {});
+
+  return {
+    field: "Distribución de acciones",
+    counts: Object.values(labelCounts),
+    operations: Object.keys(labelCounts),
+  };
+}
+
+function processDataset3(consulta) {
+  const labelCounts = consulta.reduce((acc, item) => {
+    const label = item._label.label;
+    acc[label] = (acc[label] || 0) + 1;
+    return acc;
+  }, {});
+
+  return {
+    field: "Distribución de acciones",
+    items: Object.keys(labelCounts).map((label) => ({
+      addGroup: label,
+      totalResponse: labelCounts[label],
+    })),
+  };
+}
+
+function processDataset4(consulta) {
+  const dateCounts = consulta.reduce((acc, item) => {
+    const date = formatDate(new Date(item.createdAt));
+    acc[date] = (acc[date] || 0) + 1;
+    return acc;
+  }, {});
+
+  return {
+    field: "Actividad en la plataforma",
+    counts: Object.values(dateCounts),
+    actionsName: Object.keys(dateCounts),
+  };
+}
+
+function processDataset5(consulta) {
+  const labelCountsByDate = {};
+  const categories = new Set();
+
+  consulta.forEach((item) => {
+    const date = formatDate(new Date(item.createdAt));
+    const label = item._label.label;
+    categories.add(date);
+
+    if (!labelCountsByDate[date]) {
+      labelCountsByDate[date] = {};
+    }
+    labelCountsByDate[date][label] = (labelCountsByDate[date][label] || 0) + 1;
+  });
+
+  const uniqueLabels = new Set(
+    Object.values(labelCountsByDate).flatMap(Object.keys)
+  );
+  const series = Array.from(uniqueLabels).map((label) => ({
+    name: label,
+    data: Array.from(categories).map(
+      (date) => labelCountsByDate[date]?.[label] || 0
+    ),
+  }));
+
+  return {
+    field: "Actividad en la plataforma por operación",
+    categories: Array.from(categories),
+    series: series,
+  };
+}
+
+function processDataset6(data) {
+  const userActivity = {};
+
+  // Count activity per user. Assuming data contains _user with name and lastName
+  data.forEach((item) => {
+    const fullName = `${item._user.name} ${item._user.lastName}`;
+    userActivity[fullName] = (userActivity[fullName] || 0) + 1;
+  });
+
+  // Sort users by activity count in descending order
+  const sortedUsers = Object.entries(userActivity).sort(
+    ([, countA], [, countB]) => countB - countA
+  );
+
+  // Extract top 10 users
+  const topUsers = sortedUsers.slice(0, 10);
+
+  // Build the result object
+  const result = {
+    counts: topUsers.map(([, count]) => count),
+    actionsName: topUsers.map(([fullName]) => fullName.split(" ")),
+    field: "Usuarios con mas actividad en la plataforma",
+  };
+
+  return result;
+}
+
+function processDataset7(data) {
+  const userActivity = {};
+
+  // Count activity per user. Assuming data contains _user with name and lastName
+  data.forEach((item) => {
+    const fullName = `${item._user.name} ${item._user.lastName}`;
+    userActivity[fullName] = (userActivity[fullName] || 0) + 1;
+  });
+
+  // Sort users by activity count in ascending order
+  const sortedUsers = Object.entries(userActivity).sort(
+    ([, countA], [, countB]) => countA - countB
+  );
+
+  // Extract top 10 least active users
+  const leastActiveUsers = sortedUsers.slice(0, 10);
+
+  // Build the result object
+  const result = {
+    counts: leastActiveUsers.map(([, count]) => count),
+    actionsName: leastActiveUsers.map(([fullName]) => fullName.split(" ")),
+    field: "Usuarios con menos actividad en la plataforma",
+  };
+
+  return result;
+}
+
+self.get = async (req, res) => {
+  try {
+    const _id = req.params.LOG_ID;
+    const log = await Log.findOne({ _id });
+    if (!log) res.status(404).send();
+    res.status(200).send(log);
+  } catch (error) {
+    res.status(400).send(error);
+  }
+};
+
+self.delete = async (req, res) => {
+  try {
+    const _id = req.params.LOG_ID;
+    const response = await Log.deleteOne({ _id });
+    if (!response.deletedCount)
+      res.status(404).send({ error: "El registro no existe" });
+    else res.status(200).send({});
+  } catch (error) {
+    res.status(400).send({ error: error.message });
+  }
+};
+
+self.count = async (req, res) => {
+  try {
+    let result = await Log.find({}).countDocuments();
+    res.status(200).send({ count: result });
+  } catch (error) {
+    res.status(400).send({ error: error.message });
+  }
+};

package/lib/controllers/user.js

@@ -8,6 +8,7 @@ const serviceUser = require("../services/user");
 const utils = require("../config/utils");
 const mongoose = require("mongoose");
 const AWS_SES = require("../services/ses");
+const Business = require("../models/Business");
 const self = module.exports;
 
 self.create = async (req, res) => {
@@ -20,10 +21,14 @@ self.create = async (req, res) => {
       file = file.replace("{{user}}", user.name);
       file = file.replace("{{email}}", req.body.email);
       file = file.replace("{{password}}", req.body.pwd);
-      if(process.env.URL_EMAIL){
+      if (process.env.URL_EMAIL) {
         file = file.replace("{{urlToken}}", process.env.URL_EMAIL);
       }
-      await AWS_SES.sendCustom(user.email, file, process.env.SUBJECT_EMAIL || "bienvenido");
+      await AWS_SES.sendCustom(
+        user.email,
+        file,
+        process.env.SUBJECT_EMAIL || "bienvenido"
+      );
     }
 
     res.status(201).send(user);
@@ -140,6 +145,33 @@ self.retrieve = async (req, res) => {
   }
 };
 
+self.retrieveByBusiness = async (req, res) => {
+  try {
+    const businessId = req.header("Business") || null;
+    const business = await Business.findOne({ id: businessId }).lean();
+
+    if (!business) {
+      throw {
+        code: 401,
+        title: "El negocio no existe",
+        detail: "",
+        suggestion: "No se encontro el negocio",
+        error: new Error(),
+      };
+    }
+
+    let result = await User.find({ _business: business._id })
+      .select("-pwd -tokens")
+      .populate({ path: "_functions", select: { name: 1 } })
+      .sort({ createdAt: -1 })
+      .lean();
+
+    res.status(200).send(result);
+  } catch (error) {
+    res.status(400).send({ error: error.message });
+  }
+};
+
 self.delete = async (req, res) => {
   try {
     const _id = req.params.USER_ID;

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/router.js

@@ -7,6 +7,9 @@ const user = require("./controllers/user");
 const menu = require("./controllers/menu");
 const permission = require("./controllers/permission");
 const functions = require("./controllers/functions");
+const label = require("./controllers/label");
+const log = require("./controllers/log");
+
 const history = require("./controllers/history.js");
 
 // User / user self (no auth)
@@ -33,6 +36,7 @@ router.post("/iam/auth/validate/mail", middleware, auth.validatEmailChange);
 // IAM / User
 router.post("/iam/user", middleware, user.create);
 router.get("/iam/user", middleware, user.retrieve);
+router.get("/iam/business/user", middleware, user.retrieveByBusiness);
 router.get("/iam/user/:USER_ID", middleware, user.get);
 router.patch("/iam/user/:USER_ID", middleware, user.update);
 router.put("/iam/user/:USER_ID/status", middleware, user.status);
@@ -79,4 +83,22 @@ router.get("/iam/history/:HISTORY_ID", middleware, history.detail);
 // Utilities
 router.patch("/iam/add/time/:TOKEN", user.addTimeToken);
 
+// IAM / Label
+router.post("/iam/label", middleware, label.create);
+router.patch("/iam/label/:LABEL_ID", middleware, label.update);
+router.put("/iam/label/:LABEL_ID/status", middleware, label.status);
+router.get("/iam/label", middleware, label.retrieve);
+router.get("/iam/label/:LABEL_ID", middleware, label.get);
+router.delete("/iam/label/:LABEL_ID", middleware, label.delete);
+router.get("/iam/label/count/all", middleware, label.count);
+
+// IAM / Log
+router.post("/iam/log", middleware, log.create);
+router.patch("/iam/log/:LOG_ID", middleware, log.update);
+router.put("/iam/log/:LOG_ID/status", middleware, log.status);
+router.post("/iam/log/retrieve", middleware, log.retrieve);
+router.get("/iam/log/:LOG_ID", middleware, log.get);
+router.delete("/iam/log/:LOG_ID", middleware, log.delete);
+router.get("/iam/log/count/all", middleware, log.count);
+
 module.exports = router;

package/lib/services/auth.js

@@ -574,15 +574,17 @@ self.resetPassword = async (req, res) => {
   var body = JSON.parse(JSON.stringify(req.body));
   let usuario = await User.findOne({ email: correo });
 
-  if (!usuario || !usuario?.data?.changePwd) {
-    //evaluar si se queda
-    throw {
-      code: 409,
-      title: "Usuario no encontrado.",
-      detail: "",
-      suggestion: "Verifica que el usuario exista",
-      error: new Error(),
-    };
+  if (process.env.CHANGE_PWD === "true") {
+    if (!usuario || !usuario?.data?.changePwd) {
+      //evaluar si se queda
+      throw {
+        code: 409,
+        title: "Usuario no encontrado.",
+        detail: "",
+        suggestion: "Verifica que el usuario exista",
+        error: new Error(),
+      };
+    }
   }
 
   const newTime = new Date().getTime();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aloux-iam",
-  "version": "0.0.116",
+  "version": "0.0.117",
   "description": "Aloux IAM for APIs ",
   "main": "index.js",
   "scripts": {