aloux-iam 0.0.140 → 0.0.142

package/lib/config/utils.js

@@ -1,22 +1,79 @@
-const self = module.exports
+const fs = require("fs");
+const self = module.exports;
 
 self.responseError = async (res, error) => {
-    let obj = error
-    if (!error.code) {
-        obj = {
-            code: 400,
-            title: 'Error',
-            detail: error.message,
-            suggestion: 'Revisar el detalle'
-        }
-    }
-    res.status(obj.code).send(obj)
-}
+  let obj = error;
+  if (!error.code) {
+    obj = {
+      code: 400,
+      title: "Error",
+      detail: error.message,
+      suggestion: "Revisar el detalle",
+    };
+  }
+  res.status(obj.code).send(obj);
+};
 
 self.generatePaginationResponse = async (count, page, itemsPerPage, items) => {
-    const totalPages = Math.ceil(count / itemsPerPage)
-    const currentPage = Math.max(1, Math.min(Number(page), totalPages))
-    const finalCurrentPage = totalPages === 0 ? 1 : currentPage
-    const remainingPages = Math.max(0, totalPages - finalCurrentPage)
-    return { currentPage: finalCurrentPage, totalPages, perPage: Number(itemsPerPage), count, remainingPages, items }
-}
+  const totalPages = Math.ceil(count / itemsPerPage);
+  const currentPage = Math.max(1, Math.min(Number(page), totalPages));
+  const finalCurrentPage = totalPages === 0 ? 1 : currentPage;
+  const remainingPages = Math.max(0, totalPages - finalCurrentPage);
+  return { currentPage: finalCurrentPage, totalPages, perPage: Number(itemsPerPage), count, remainingPages, items };
+};
+
+self.brand = {
+  _cfg: null,
+
+  init(config) {
+    this._cfg = config;
+  },
+
+  _get(key) {
+    if (this._cfg) return this._cfg[key];
+    const APP = process.env.APP;
+    if (APP) return process.env[`${key}_${APP}`] || process.env[key];
+    return process.env[key];
+  },
+
+  name() {
+    return this._get("PROJECT_NAME");
+  },
+
+  template(key) {
+    const path = this._get(key);
+    if (!path) {
+      throw {
+        code: 500,
+        title: "Error de configuración",
+        detail: `Template no encontrado: ${key}`,
+        suggestion: "Verifica que la variable de entorno esté definida",
+        error: new Error(),
+      };
+    }
+    try {
+      let file = fs.readFileSync(path, "utf8");
+      file = file.replace(/\+\+\+brandName\+\+\+/g, this.name() || "");
+      file = file.replace(/\+\+\+brandColor\+\+\+/g, this._get("BRAND_COLOR") || "");
+      file = file.replace(/\+\+\+brandLogo\+\+\+/g, this._get("BRAND_LOGO") || "");
+      return file;
+    } catch (e) {
+      throw {
+        code: 500,
+        title: "Error al leer template",
+        detail: `No se pudo leer el archivo: ${path}`,
+        suggestion: "Verifica que el path del template sea correcto",
+        error: e,
+      };
+    }
+  },
+};
+
+// Gkey
+self.resolveGkey = (business) => {
+  const businessGkey = business.gkey || null;
+  const hasOwnKey    = businessGkey?.status === true;
+
+  if (hasOwnKey) return { gkey: businessGkey, source: "business" };
+  return { gkey: null, source: null };
+};

package/lib/controllers/business.js

@@ -1,7 +1,9 @@
 const Business = require("../models/Business");
+const Company = require("../models/Company");
 const utils = require("../config/utils");
 const AlouxAWS = require("./operationsAWS");
 const errorController = require("../config/utils");
+const { resolveGkey } = require("../config/utils");
 
 const self = module.exports;
 
@@ -11,16 +13,26 @@ self.create = async (req, res) => {
     req.body.lastUpdate = req.body.createdAt;
     req.body.status = "Activo";
 
+    let inheritedGkey = null;
+    if (req.body.data?.useCompanyKey && req.body._company) {
+      const company = await Company.findOne({ _id: req.body._company }).lean();
+      const companyGkey = company?.data?.gkey;
+      if (companyGkey?.status) inheritedGkey = companyGkey;
+    }
+
     if (req.body.environment && req.body.environment.length > 1) {
       for (let i in req.body.environment) {
         const business = new Business(req.body);
         business.environment = req.body.environment[i];
+        if (inheritedGkey) business.gkey = inheritedGkey;
         await business.save();
       }
     } else {
       const business = new Business(req.body);
+      if (inheritedGkey) business.gkey = inheritedGkey;
       await business.save();
     }
+
     await res.status(201).send({});
   } catch (error) {
     await errorController.responseError(res, error);
@@ -250,3 +262,56 @@ self.identity = async (req, res) => {
     await errorController.responseError(res, error);
   }
 };
+
+self.setUseCompanyKey = async (req, res) => {
+  try {
+    const business = await Business.findOne({ _id: req.params.BUSINESS_ID }).lean();
+    if (!business) throw { code: 404, title: "No encontrado", detail: "No existe el negocio" };
+
+    await Business.updateOne(
+      { _id: req.params.BUSINESS_ID },
+      {
+        $unset: { gkey: "" },
+        $set: {
+          "data.useCompanyKey": false,
+          lastUpdate: new Date().getTime(),
+        },
+      }
+    );
+
+    res.status(202).send({ ok: true });
+  } catch (error) {
+    await errorController.responseError(res, error);
+  }
+};
+
+self.inheritKey = async (req, res) => {
+  try {
+    const business = await Business.findOne({ _id: req.params.BUSINESS_ID })
+      .populate("_company")
+      .lean();
+    if (!business) throw { code: 404, title: "No encontrado", detail: "No existe el negocio" };
+
+    const companyGkey = business._company?.data?.gkey;
+    if (!companyGkey?.status) throw {
+      code: 400,
+      title: "Sin llave",
+      detail: "La organización no tiene una llave de Google Cloud configurada",
+    };
+
+    await Business.updateOne(
+      { _id: req.params.BUSINESS_ID },
+      {
+        $set: {
+          gkey: companyGkey,
+          "data.useCompanyKey": true,
+          lastUpdate: new Date().getTime(),
+        },
+      }
+    );
+
+    res.status(202).send({ ok: true });
+  } catch (error) {
+    await errorController.responseError(res, error);
+  }
+};

package/lib/controllers/company.js

@@ -153,3 +153,38 @@ self.identity = async (req, res) => {
     await errorController.responseError(res, error);
   }
 };
+
+self.updateGkey = async (req, res) => {
+  try {
+    const company = await Company.findOne({ _id: req.params.COMPANY_ID });
+    if (!company) throw { code: 404, title: "No encontrado", detail: "No existe la organización" };
+
+    company.data = { ...(company.data || {}), gkey: req.body.gkey };
+    company.lastUpdate = new Date().getTime();
+    company.markModified("data");
+    await company.save();
+
+    res.status(202).send({ ok: true });
+  } catch (error) {
+    await errorController.responseError(res, error);
+  }
+};
+
+self.deleteGkey = async (req, res) => {
+  try {
+    const company = await Company.findOne({ _id: req.params.COMPANY_ID });
+    if (!company) throw { code: 404, title: "No encontrado", detail: "No existe la organización" };
+
+    const newData = { ...(company.data || {}) };
+    delete newData.gkey;
+
+    company.data = newData;
+    company.lastUpdate = new Date().getTime();
+    company.markModified("data");
+    await company.save();
+
+    res.status(200).send({ ok: true });
+  } catch (error) {
+    await errorController.responseError(res, error);
+  }
+};

package/lib/controllers/generatePassword.js

@@ -0,0 +1,13 @@
+const passwordService = require("../services/generatePassword");
+
+const self = module.exports;
+
+self.generate = (req, res) => {
+  try {
+    const length = Number(req.query.length) || 12;
+    const password = passwordService.generatePassword(length);
+    return res.json({ password });
+  } catch (error) {
+    return res.status(500).json({ message: "Error al generar la contraseña", error });
+  }
+};

package/lib/controllers/log.js

@@ -1,5 +1,6 @@
 const Log = require("../models/Log");
 const Label = require("../models/Label");
+const mongoose = require("mongoose");
 const self = module.exports;
 
 self.create = async (req, res) => {
@@ -8,9 +9,11 @@ self.create = async (req, res) => {
       req.header("Company") !== "undefined" ? req.header("Company") : null;
 
     const log = new Log(req.body);
+    const businessId = req.header("business") !== "undefined" ? req.header("business") : null;
     log.createdAt = new Date().getTime();
     log._user = req.user._id;
     log._company = companyId;
+    log._business = businessId;
 
     log.label = req.body.label;
     await log.save();
@@ -33,6 +36,7 @@ self.update = async (req, resp) => {
     resp.status(400).send({ error: error.message });
   }
 };
+
 self.status = async (req, resp) => {
   try {
     const _id = req.params.LOG_ID;
@@ -46,43 +50,44 @@ self.status = async (req, resp) => {
     resp.status(400).send({ error: error.message });
   }
 };
+
 self.retrieve = async (req, res) => {
   try {
     const companyId =
       req.header("Company") !== "undefined" ? req.header("Company") : null;
-    let query = { _company: companyId };
 
-    if (req.body.users.length) {
-      query = {
-        _user: { $in: req.body.users },
+    const query = { _company: companyId };
+
+    if (req.body.users?.length) {
+      query._user = {
+        $in: req.body.users.map((id) => new mongoose.Types.ObjectId(id)),
       };
     }
 
-    console.log(new Date())
-    const consulta = await Log.find(query)
-      .populate([{ path: "_user", select: { name: 1, lastName: 1 } }])
-      .sort({ createdAt: 1 })
-      .lean();
-    console.log(new Date())
+    if (req.body.dateStart || req.body.dateEnd) {
+      query.createdAt = {};
+      if (req.body.dateStart) query.createdAt.$gte = Number(req.body.dateStart);
+      if (req.body.dateEnd) query.createdAt.$lte = Number(req.body.dateEnd);
+    }
 
-    // for (let i in consulta) {
-    //   consulta[i].label = consulta[i]._label.label;
-    //   await consulta[i].save();
-    // }
+    if (req.body.business?.length) {
+      query._business = { $in: req.body.business };
+    }
+
+    const consulta = await Log.find(query).populate("_user", "name lastName email");
 
     const response = {
       dataset0: { field: "Visualizaciones totales", count: consulta.length },
-      dataset1: [],
+      dataset1: processDataset1(consulta),
       dataset2: processDataset2(consulta),
       dataset3: processDataset3(consulta),
       dataset4: processDataset4(consulta),
-      dataset5: [],
+      dataset5: processDataset5(consulta),
       dataset6: processDataset6(consulta),
       dataset7: processDataset7(consulta),
+      dataset8: processDataset8(consulta, req.body.search, req.body.page, req.body.limit),
     };
 
-    console.log(new Date())
-
     res.status(200).send(response);
   } catch (error) {
     console.error(error);
@@ -90,35 +95,23 @@ self.retrieve = async (req, res) => {
   }
 };
 
-function formatDate(date) {
-  const day = String(date.getDate()).padStart(2, "0");
+function formatDate(isoDate) {
+  const [year, month, day] = isoDate.split("-");
   const monthNames = [
-    "Ene",
-    "Feb",
-    "Mar",
-    "Abr",
-    "May",
-    "Jun",
-    "Jul",
-    "Ago",
-    "Sep",
-    "Oct",
-    "Nov",
-    "Dic",
+    "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}`;
+  return `${day} ${monthNames[parseInt(month) - 1]} ${year}`;
 }
+
 function processDataset1(consulta) {
-  return consulta.map((item) => {
-    return {
-      _id: item._id,
-      labelDescription: item.label,
-      userName: item._user.name + " " + item._user.lastName,
-      createdAt: item.createdAt,
-    };
-  });
+  return consulta.map((item) => ({
+    _id: item._id,
+    labelDescription: item.label,
+    userName: item._user.name + " " + item._user.lastName,
+    userEmail: item._user.email,
+    createdAt: item.createdAt,
+  }));
 }
 
 function processDataset2(consulta) {
@@ -153,7 +146,8 @@ function processDataset3(consulta) {
 
 function processDataset4(consulta) {
   const dateCounts = consulta.reduce((acc, item) => {
-    const date = formatDate(new Date(item.createdAt));
+    const isoDate = new Date(item.createdAt).toISOString().split("T")[0];
+    const date = formatDate(isoDate);
     acc[date] = (acc[date] || 0) + 1;
     return acc;
   }, {});
@@ -170,7 +164,8 @@ function processDataset5(consulta) {
   const categories = new Set();
 
   consulta.forEach((item) => {
-    const date = formatDate(new Date(item.createdAt));
+    const isoDate = new Date(item.createdAt).toISOString().split("T")[0];
+    const date = formatDate(isoDate);
     const label = item.label;
     categories.add(date);
 
@@ -200,55 +195,80 @@ function processDataset5(consulta) {
 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
-  );
+  const topUsers = Object.entries(userActivity)
+    .sort(([, a], [, b]) => b - a)
+    .slice(0, 10);
 
-  // Extract top 10 users
-  const topUsers = sortedUsers.slice(0, 10);
-
-  // Build the result object
-  const result = {
+  return {
+    field: "Usuarios con mas actividad en la plataforma",
     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);
+  const leastUsers = Object.entries(userActivity)
+    .sort(([, a], [, b]) => a - b)
+    .slice(0, 10);
 
-  // Build the result object
-  const result = {
-    counts: leastActiveUsers.map(([, count]) => count),
-    actionsName: leastActiveUsers.map(([fullName]) => fullName.split(" ")),
+  return {
     field: "Usuarios con menos actividad en la plataforma",
+    counts: leastUsers.map(([, count]) => count),
+    actionsName: leastUsers.map(([fullName]) => fullName.split(" ")),
   };
+}
+
+function processDataset8(data, search = "", page = 1, limit = 10) {
+  const userActivity = {};
+
+  data.forEach((item) => {
+    const fullName = `${item._user.name} ${item._user.lastName}`;
+    if (!userActivity[fullName]) {
+      userActivity[fullName] = {
+        name: item._user.name,
+        lastName: item._user.lastName,
+        email: item._user.email,
+        count: 0,
+      };
+    }
+    userActivity[fullName].count++;
+  });
+
+  let users = Object.values(userActivity).sort((a, b) => b.count - a.count);
+
+  if (search) {
+    const s = search.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+    users = users.filter((u) => {
+      const full = `${u.name} ${u.lastName} ${u.email}`.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+      return full.includes(s);
+    });
+  }
 
-  return result;
+  const total = users.length;
+  const totalPages = Math.ceil(total / limit);
+  const start = (page - 1) * limit;
+  const items = users.slice(start, start + limit);
+
+  return {
+    field: "Actividad de usuarios",
+    total,
+    page,
+    limit,
+    totalPages,
+    items,
+  };
 }
 
 self.get = async (req, res) => {
@@ -281,4 +301,4 @@ self.count = async (req, res) => {
   } catch (error) {
     res.status(400).send({ error: error.message });
   }
-};
+};

package/lib/controllers/totp.js

@@ -0,0 +1,46 @@
+const Totp = require("../services/totp");
+const utils = require("../config/utils");
+
+const self = module.exports;
+
+self.setup = async (req, res) => {
+  try {
+    const tempToken = req.query.tempToken || req.body?.tempToken;
+    const response = await Totp.setup(tempToken);
+    res.status(200).send(response);
+  } catch (error) {
+    await utils.responseError(res, error);
+  }
+};
+
+self.activate = async (req, res) => {
+  try {
+    const tempToken = req.headers["x-temp-token"] || req.body?.tempToken;
+    const response = await Totp.activate(tempToken, req.body.token);
+    res.status(200).send(response);
+  } catch (error) {
+    await utils.responseError(res, error);
+  }
+};
+
+self.checkLogin = async (req, res) => {
+  try {
+    const { token, tempToken } = req.body;
+    if (!token || !tempToken)
+      return res.status(400).send({ message: "Faltan parámetros" });
+
+    const response = await Totp.checkLogin(token, tempToken, res);
+    res.status(200).send(response);
+  } catch (error) {
+    await utils.responseError(res, error);
+  }
+};
+
+self.adminToggle = async (req, res) => {
+  try {
+    const response = await Totp.adminToggle(req.params.USER_ID, req.body.enabled);
+    res.status(200).send(response);
+  } catch (error) {
+    await utils.responseError(res, error);
+  }
+};