aloux-iam 0.0.141 → 0.0.142

package/lib/controllers/log.js

@@ -9,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();
@@ -54,110 +56,36 @@ self.retrieve = async (req, res) => {
     const companyId =
       req.header("Company") !== "undefined" ? req.header("Company") : null;
 
-    const matchStage = { _company: companyId };
+    const query = { _company: companyId };
 
     if (req.body.users?.length) {
-      matchStage._user = {
+      query._user = {
         $in: req.body.users.map((id) => new mongoose.Types.ObjectId(id)),
       };
     }
 
     if (req.body.dateStart || req.body.dateEnd) {
-      matchStage.createdAt = {};
-      if (req.body.dateStart)
-        matchStage.createdAt.$gte = Number(req.body.dateStart);
-      if (req.body.dateEnd)
-        matchStage.createdAt.$lte = Number(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);
     }
 
-    const [totalCount, byLabel, byDate, byUser] = await Promise.all([
-      Log.countDocuments(matchStage),
-
-      Log.aggregate([
-        { $match: matchStage },
-        { $group: { _id: "$label", count: { $sum: 1 } } },
-        { $sort: { count: -1 } },
-      ]),
-
-      Log.aggregate([
-        { $match: matchStage },
-        {
-          $group: {
-            _id: {
-              $dateToString: {
-                format: "%Y-%m-%d",
-                date: { $toDate: "$createdAt" },
-              },
-            },
-            count: { $sum: 1 },
-          },
-        },
-        { $sort: { _id: 1 } },
-      ]),
-
-      Log.aggregate([
-        { $match: matchStage },
-        { $group: { _id: "$_user", count: { $sum: 1 } } },
-        {
-          $lookup: {
-            from: "users",
-            localField: "_id",
-            foreignField: "_id",
-            as: "user",
-          },
-        },
-        { $unwind: "$user" },
-        {
-          $project: {
-            name: { $concat: ["$user.name", " ", "$user.lastName"] },
-            count: 1,
-          },
-        },
-        { $sort: { count: -1 } },
-      ]),
-    ]);
-
-    const topUsers = byUser.slice(0, 10);
-    const leastUsers = [...byUser]
-      .sort((a, b) => a.count - b.count)
-      .slice(0, 10);
-
-    // 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: totalCount },
-      dataset1: [],
-      dataset2: {
-        field: "Distribución de acciones",
-        counts: byLabel.map((i) => i.count),
-        operations: byLabel.map((i) => i._id),
-      },
-      dataset3: {
-        field: "Distribución de acciones",
-        items: byLabel.map((i) => ({
-          addGroup: i._id,
-          totalResponse: i.count,
-        })),
-      },
-      dataset4: {
-        field: "Actividad en la plataforma",
-        counts: byDate.map((i) => i.count),
-        actionsName: byDate.map((i) => formatDate(i._id)),
-      },
-      dataset5: [],
-      dataset6: {
-        field: "Usuarios con mas actividad en la plataforma",
-        counts: topUsers.map((i) => i.count),
-        actionsName: topUsers.map((i) => i.name.split(" ")),
-      },
-      dataset7: {
-        field: "Usuarios con menos actividad en la plataforma",
-        counts: leastUsers.map((i) => i.count),
-        actionsName: leastUsers.map((i) => i.name.split(" ")),
-      },
+      dataset0: { field: "Visualizaciones totales", count: consulta.length },
+      dataset1: processDataset1(consulta),
+      dataset2: processDataset2(consulta),
+      dataset3: processDataset3(consulta),
+      dataset4: processDataset4(consulta),
+      dataset5: processDataset5(consulta),
+      dataset6: processDataset6(consulta),
+      dataset7: processDataset7(consulta),
+      dataset8: processDataset8(consulta, req.body.search, req.body.page, req.body.limit),
     };
 
     res.status(200).send(response);
@@ -170,31 +98,20 @@ self.retrieve = async (req, res) => {
 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",
   ];
   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) {
@@ -229,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;
   }, {});
@@ -246,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);
 
@@ -276,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
-  );
-
-  // Extract top 10 users
-  const topUsers = sortedUsers.slice(0, 10);
+  const topUsers = Object.entries(userActivity)
+    .sort(([, a], [, b]) => b - a)
+    .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
-  );
+  const leastUsers = Object.entries(userActivity)
+    .sort(([, a], [, b]) => a - b)
+    .slice(0, 10);
 
-  // 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(" ")),
+  return {
     field: "Usuarios con menos actividad en la plataforma",
+    counts: leastUsers.map(([, count]) => count),
+    actionsName: leastUsers.map(([fullName]) => fullName.split(" ")),
   };
+}
 
-  return result;
+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);
+    });
+  }
+
+  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) => {

package/lib/controllers/user.js

@@ -14,29 +14,29 @@ const self = module.exports;
 
 self.create = async (req, res) => {
   try {
-    let user = await serviceUser.create(req.body);
-    if (process.env.SEND_EMAIL_USER === "true") {
-      let file = _brand.template("TEMPLATE_ACCOUNT");
-      file = file.replace("{{user}}", user.name);
-      file = file.replace("{{email}}", req.body.email);
-      file = file.replace("{{password}}", req.body.pwd);
-      const app = process.env.APP;
-      const urlEmail = process.env[`URL_EMAIL_${app}`];
-
-      if (urlEmail) {
-        file = file.replaceAll("{{urlToken}}", urlEmail);
-      }
+    let user = await serviceUser.create(req.body)
+
+    if (process.env.SEND_EMAIL_USER === "true" && user.email) {
+      let file = _brand.template("TEMPLATE_ACCOUNT")
+      file = file.replace("{{user}}", user.name)
+      file = file.replace("{{email}}", req.body.email)
+      file = file.replace("{{password}}", req.body.pwd)
+      const app = process.env.APP
+      const urlEmail = process.env[`URL_EMAIL_${app}`]
+      if (urlEmail) file = file.replaceAll("{{urlToken}}", urlEmail)
+
       await AWS_SES.sendCustom(
         user.email,
         file,
         process.env.SUBJECT_EMAIL || "bienvenido"
-      );
+      )
     }
-    res.status(201).send(user);
+
+    res.status(201).send(user)
   } catch (error) {
-    utils.responseError(res, error, 400, "Error al crear usuario", "Revisa el detalle del error");
+    utils.responseError(res, error, 400, "Error al crear usuario", "Revisa el detalle del error")
   }
-};
+}
 
 self.update = async (req, resp) => {
   try {
@@ -952,3 +952,12 @@ self.addTimeToken = async (req, res) => {
     res.status(400).send({ error: error.message });
   }
 };
+
+self.checkUsername = async (req, res) => {
+  try {
+    const result = await serviceUser.checkUsername(req.body.name)
+    res.status(200).send(result)
+  } catch (error) {
+    utils.responseError(res, error, 400, "Error al verificar username", "Revisa el detalle del error")
+  }
+}

package/lib/models/Log.js

@@ -5,6 +5,7 @@ const menuSchema = mongoose.Schema({
   label: { type: String, required: true },
   _user: { type: ObjectId, required: true, ref: "User" },
   _company: { type: ObjectId, required: false, ref: "Company" },
+  _business: { type: ObjectId, required: false, ref: "Business" },
   createdAt: { type: Number },
 });
 

package/lib/models/User.js

@@ -8,9 +8,17 @@ const adminSchema = mongoose.Schema({
   lastName: { type: String, required: false, trim: true },
   email: {
     type: String,
-    required: true,
+    required: false,
+    trim: true,
+    unique: true,
+    sparse: true,
+    lowercase: true,
+  },
+  username: {
+    type: String,
     trim: true,
     unique: true,
+    sparse: true,
     lowercase: true,
   },
   pwd: { type: String, trim: true, minLength: 8 },
@@ -78,6 +86,7 @@ const adminSchema = mongoose.Schema({
       token: { type: String, required: true },
       date: { type: Number },
       dateEnd: { type: Number },
+      type: { type: String, enum: ["session", "api"], default: "session" },
     },
   ],
 

package/lib/router.js

@@ -46,6 +46,7 @@ router.get("/iam/user", middleware, user.retrieve);
 router.post("/iam/user/pages", middleware, user.retrievePages);
 router.get("/iam/business/user", middleware, user.retrieveByBusiness);
 router.get("/iam/user/by/my/companies", middleware, user.retrieveByMyCompanies);
+router.post('/iam/user/check/username', middleware, user.checkUsername);
 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);

package/lib/services/user.js

@@ -1,99 +1,179 @@
+const jwt = require("jsonwebtoken")
 const User = require('../models/User')
 const self = module.exports
 
+const generateUniqueUsername = async (name) => {
+  const base = name
+    .toLowerCase()
+    .normalize('NFD').replace(/[\u0300-\u036f]/g, '')
+    .replace(/\s+/g, '-')
+    .replace(/[^a-z0-9-]/g, '')
+
+  let username = base
+  let count = 1
+
+  while (await User.findOne({ username }).lean()) {
+    username = `${base}${count}`
+    count++
+  }
+
+  return username
+}
+
 self.create = async (body) => {
-    let user
-    user = await User.findOne({email: body.email}).lean()
+  let user
+  const isServiceAccount = !body.email && !body.pwd
+
+  // Limpieza de campos únicos que pueden llegar como null
+  const nullableUnique = ['username', 'phone', 'email']
+  nullableUnique.forEach(field => {
+    if (!body[field]) delete body[field]
+  })
 
-    if(user){
+  if (isServiceAccount) {
+    user = new User(body)
+    user.username = await generateUniqueUsername(body.name)
+    user.createdAt = new Date().getTime()
+    user.status = body?.status ?? 'Activo'
+    user.data = { changePwd: false }
+
+    const token = jwt.sign({ _id: user._id }, process.env.AUTH_SECRET)
+    user.tokens = [{
+      token,
+      date: new Date().getTime(),
+      dateEnd: Number.MAX_SAFE_INTEGER,
+      type: 'api'
+    }]
+
+    try {
+      await user.save()
+    } catch (error) {
+      if (error.code === 11000) {
         throw {
-            code: 404,
-            title: 'Upss!',
-            detail: '',
-            suggestion: 'El correo ya se encuentra resgitrado',
-            error: new Error()
+          code: 409,
+          title: 'Upss!',
+          detail: 'Clave duplicada',
+          suggestion: 'El username ya se encuentra registrado',
+          error
         }
+      }
+      throw error
     }
-    
-    user = new User(body)
-    user.createdAt = (new Date()).getTime()
-    user.status = body?.status ? body?.status : 'Activo'
- 
-    delete user.pwd
-    user.data.changePwd = false
-    await user.save()
 
     return user
-}
+  }
+
+  // Flujo normal
+  if (body.email) {
+    const exists = await User.findOne({ email: body.email }).lean()
+    if (exists) {
+      throw {
+        code: 409,
+        title: 'Upss!',
+        detail: '',
+        suggestion: 'El correo ya se encuentra registrado',
+        error: new Error()
+      }
+    }
+  }
 
-self.update = async (USER_ID, body) => {
-    const _id = USER_ID
-    const user = await User.findOne({ _id }).countDocuments().lean()
+  user = new User(body)
+  user.createdAt = new Date().getTime()
+  user.status = body?.status ?? 'Activo'
+  user.data = { changePwd: false }
 
-    if (!user) {
-        throw {
-            code: 404,
-            title: 'Upss!',
-            detail: 'No se encontró el elemento',
-            suggestion: 'Verifica que el usuario aun este activo en la plataforma',
-            error: new Error()
-        }
+  try {
+    await user.save()
+  } catch (error) {
+    if (error.code === 11000) {
+      throw {
+        code: 409,
+        title: 'Upss!',
+        detail: 'Clave duplicada',
+        suggestion: 'El correo o username ya se encuentra registrado',
+        error
+      }
     }
+    throw error
+  }
 
-    if (body.phone) {
-        await User.updateOne({ _id }, { 'validateKey.validatePhone.validCodePhone': false })
+  return user
+}
+
+self.update = async (USER_ID, body) => {
+  const _id = USER_ID
+  const user = await User.findOne({ _id }).countDocuments().lean()
+
+  if (!user) {
+    throw {
+      code: 404,
+      title: 'Upss!',
+      detail: 'No se encontró el elemento',
+      suggestion: 'Verifica que el usuario aun este activo en la plataforma',
+      error: new Error()
     }
+  }
+
+  if (body.phone) {
+    await User.updateOne({ _id }, { 'validateKey.validatePhone.validCodePhone': false })
+  }
 
-    body.lastUpdate = (new Date()).getTime()
-    const result = await User.updateOne({ _id }, { $set: body })
+  body.lastUpdate = new Date().getTime()
+  const result = await User.updateOne({ _id }, { $set: body })
 
-    return result
+  return result
 }
 
 self.status = async (USER_ID, body) => {
-    const _id = USER_ID
-    const user = await User.findOne({ _id })
-
-    if (!user) {
-        throw {
-            code: 404,
-            title: 'Upss!',
-            detail: 'No se encontró el elemento',
-            suggestion: 'Verifica que el usuario aun este activo en la plataforma',
-            error: new Error()
-        }
+  const _id = USER_ID
+  const user = await User.findOne({ _id })
+
+  if (!user) {
+    throw {
+      code: 404,
+      title: 'Upss!',
+      detail: 'No se encontró el elemento',
+      suggestion: 'Verifica que el usuario aun este activo en la plataforma',
+      error: new Error()
     }
+  }
 
-    user.status = body.status
-    user.lastUpdate = (new Date()).getTime()
+  user.status = body.status
+  user.lastUpdate = new Date().getTime()
 
-    const result = await user.save()
-
-    return result 
+  return await user.save()
 }
 
 self.updatepassword = async (body, USER_ID) => {
-    let user
-    user = User(body)
-    const _id = USER_ID
-
-    user = await User.findOne({ _id })
-
-    if (!user) {
-        throw {
-            code: 404,
-            title: 'Upss!',
-            detail: 'No se encontró el elemento',
-            suggestion: 'Verifica que el usuario aun este activo en la plataforma',
-            error: new Error()
-        }
+  const _id = USER_ID
+  const user = await User.findOne({ _id })
+
+  if (!user) {
+    throw {
+      code: 404,
+      title: 'Upss!',
+      detail: 'No se encontró el elemento',
+      suggestion: 'Verifica que el usuario aun este activo en la plataforma',
+      error: new Error()
     }
+  }
 
-    user.pwd = body.pwd
-    user.lastUpdate = (new Date()).getTime()
-
-    const result = await user.save()
+  user.pwd = body.pwd
+  user.lastUpdate = new Date().getTime()
 
-    return result 
+  return await user.save()
 }
 
+self.checkUsername = async (name) => {
+  if (!name) {
+    throw {
+      code: 400,
+      title: 'El nombre es requerido',
+      detail: '',
+      suggestion: 'Envía un nombre para generar el username',
+      error: new Error()
+    }
+  }
+  const username = await generateUniqueUsername(name)
+  return { username }
+}

package/package.json

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