mergear a staging

harvester-app/src/backend/casosUso/dispositivos/habilitarDispositivo.js

@@ -0,0 +1,33 @@
+// RF48 Administrador habilita dispositivo - Nuevo requerimiento para habilitar dispositivos deshabilitados
+
+const { habilitarDispositivo: habilitarDispositivoAPI } = require('../../domain/usuariosAPI/usuariosAPI');
+
+/**
+ * Habilita un dispositivo específico que ha sido previamente deshabilitado.
+ *
+ * Esta función valida que se proporcione un ID de dispositivo y, si es válido, 
+ * realiza una solicitud asíncrona a la API para habilitar el dispositivo correspondiente.
+ * Retorna un objeto con el resultado de la operación.
+ *
+ * @async
+ * @function habilitarDispositivo
+ * @param {string} idDispositivo - ID del dispositivo que se va a habilitar.
+ * @returns {Promise<{ok: boolean, mensaje: string}>} Resultado de la operación de habilitación.
+ */
+async function habilitarDispositivo(idDispositivo) {
+    if (!idDispositivo) {
+        return { ok: false, mensaje: 'ID de dispositivo no proporcionado' };
+    }
+
+    try {
+        const respuesta = await habilitarDispositivoAPI(idDispositivo);
+        return respuesta;
+
+    } catch {
+        return { ok: false, mensaje: 'Error al habilitar el dispositivo' };
+    }
+}
+
+module.exports = {
+    habilitarDispositivo,
+};

harvester-app/src/backend/casosUso/dispositivos/obtenerDispositivos.js

@@ -0,0 +1,28 @@
+// RF47 Administrador consulta dispositivos - Nuevo requerimiento para listar todos los dispositivos
+
+const { obtenerDispositivos: obtenerDispositivosAPI } = require('../../domain/usuariosAPI/usuariosAPI');
+
+/**
+ * Obtiene la lista completa de dispositivos con información de sus propietarios.
+ *
+ * Esta función realiza una solicitud asíncrona a la API para obtener todos los dispositivos
+ * registrados en el sistema, incluyendo información sobre sus propietarios y estado.
+ * Retorna un objeto con el resultado de la operación.
+ *
+ * @async
+ * @function obtenerDispositivos
+ * @returns {Promise<{ok: boolean, dispositivos?: Array, mensaje?: string}>} Resultado de la operación con la lista de dispositivos.
+ */
+async function obtenerDispositivos() {
+    try {
+        const respuesta = await obtenerDispositivosAPI();
+        return respuesta;
+
+    } catch {
+        return { ok: false, mensaje: 'Error al obtener la lista de dispositivos' };
+    }
+}
+
+module.exports = {
+    obtenerDispositivos,
+};

harvester-app/src/backend/casosUso/excel/cargarExcel.js

@@ -136,7 +136,7 @@ async function leerExcel(archivo) {
                         if (verificacionExcel.hayPeligro) {
                             reject({
                                 exito: false,
-                                mensaje: `El archivo subido contiene el siguiente caracter inválido: ${verificacionExcel.lugarDetectado} Caracter: ${verificacionExcel.caracterDetectado}`
+                                mensaje: `El archivo subido contiene el siguiente problema: ${verificacionExcel.caracterDetectado}. ${verificacionExcel.lugarDetectado}`
                             });
                         }
                         // Almacenamos los datos usando el nombre de la hoja como clave
@@ -193,6 +193,7 @@ function verificarExcel(hojaJSON) {
     }
 
     const patron = /[<>&"'`#]/g 
+    const longitudMaxima = 100;
     let contadorFilas = 0;
     let contadorCeldas = 0;
 
@@ -208,16 +209,24 @@ function verificarExcel(hojaJSON) {
                 if (match) {
                     return {
                         hayPeligro: true,
-                        caracterDetectado: match[0],
+                        caracterDetectado: `Caracter inválido: ${match[0]}`,
                         lugarDetectado: `Fila: ${contadorFilas} Celda: ${contadorCeldas}`
                     }
                 }
 
                 // 2. Verificar si comienza con = + -
-                if (celda.startsWith('=') || celda.startsWith('+') || celda.startsWith('-')) {
+                if (esInicioPeligroso(celda)) {
                     return {
                         hayPeligro: true,
-                        caracterDetectado: celda[0],
+                        caracterDetectado: `Caracter inválido: ${celda[0]}`,
+                        lugarDetectado: `Fila: ${contadorFilas}, Celda: ${contadorCeldas}`
+                    }
+                }
+
+                if (celda.length > longitudMaxima) {
+                    return {
+                        hayPeligro: true,
+                        caracterDetectado: `Longitud mayor a ${longitudMaxima} caracteres`,
                         lugarDetectado: `Fila: ${contadorFilas}, Celda: ${contadorCeldas}`
                     }
                 }
@@ -229,6 +238,28 @@ function verificarExcel(hojaJSON) {
 }
 
 
+
+/**
+ * Verifica si una celda contiene un inicio potencialmente peligroso
+ * Permite '+' o '-' si parece un número telefónico
+ * @param {string} texto - Texto de la celda a verificar
+ * @returns {boolean} - Verdadero si la celda comienza con un carácter peligroso
+ */
+function esInicioPeligroso(texto) {
+    const patronInicioPeligroso = /^[=+-]/;
+    const patronNumeroTelefono = /^[+-]?\d[\d\s\-()]*$/;
+
+    if (patronInicioPeligroso.test(texto)) {
+        // Permitir si es numero telefónico
+        if (patronNumeroTelefono.test(texto)) {
+            return false;
+        }
+        return true;
+    }
+
+    return false;
+}
+
 module.exports = {
     leerExcel,
 }

harvester-app/src/backend/casosUso/formulas/aplicarFormula.js

@@ -162,5 +162,8 @@ function indiceALetraColumna(indice) {
 }
 
 module.exports = {
-    aplicarFormula
+    aplicarFormula,
+    encontrarColumnaVacia,
+    traducirFormulaEstructurada,
+    indiceALetraColumna,
 };

harvester-app/src/backend/casosUso/formulas/filtrarDatos.js

@@ -0,0 +1,152 @@
+const { HyperFormula } = require('hyperformula');
+const { encontrarColumnaVacia } = require('./aplicarFormula.js')
+
+const opciones = {
+    licenseKey: 'gpl-v3',
+};
+
+/**
+ * Aplica una fórmula estructurada a una hoja de Excel almacenada en localStorage.
+ * @param {string} nombreFormula - Nombre de la fórmula a aplicar.
+ * @param {string} formulaEstructurada - Fórmula estructurada a aplicar.
+ * @param {string|null} tractorSeleccionado - Nombre de la hoja donde se aplicará la fórmula (opcional).
+ * @returns {Object} Resultado de la aplicación de la fórmula.
+ */
+
+function filtrarDatos(filtro, datosExcel, tractorSeleccionado){
+    if(filtro.length==0){
+        return { resultados: datosExcel };
+    }
+
+  // Lógica para filtrar los datos según el filtro
+
+    const hojas = datosExcel.hojas;
+
+    // Si no se especifica hoja, usar la primera disponible
+    let datos = [];
+    let tractorUsado = '';
+
+    if (tractorSeleccionado && hojas[tractorSeleccionado]) {
+        datos = hojas[tractorSeleccionado];
+        tractorUsado = tractorSeleccionado;
+    } else {
+        // Tomar la primera hoja disponible
+        tractorUsado = Object.keys(hojas)[0];
+        datos = hojas[tractorUsado];
+    }
+
+    // Verificar que datos sea un array
+    if (!Array.isArray(datos)) {
+        throw new Error('Formato de datos inválido: se esperaba un array');
+    }
+
+    if (datos.length === 0) {
+        throw new Error('No hay datos disponibles en la hoja seleccionada');
+    }
+
+    // Obtener encabezados
+    const encabezados = datos[0];
+
+    // Encontrar la primera columna vacía usando método seguro
+    const indiceColumnaVacio = encontrarColumnaVacia(datos);
+
+
+
+    const hyperFormulaInstance = HyperFormula.buildFromArray(datos, opciones);
+    const sheetId = hyperFormulaInstance.getSheetId('Sheet1');
+
+    const columnaCondicion = nombreColumnaAIndice(filtro[0].Datos, encabezados);
+    if(columnaCondicion.error) {
+        return { error: true, columnaNoEncontrada: columnaCondicion.columnaNoEncontrada };
+    }
+
+    const filas = datos.length;
+
+    const condicionFiltro = extraerCondicionFiltro(filtro[0].Datos);
+
+    for(let columna = indiceColumnaVacio; columna < indiceColumnaVacio*2+1; columna+=1) {
+        hyperFormulaInstance.setCellContents({ row: 0, col: columna, sheet: sheetId }, encabezados[columna-indiceColumnaVacio]);
+        const columnaLetra = numeroAColumnaExcel(columna-indiceColumnaVacio+1);
+        hyperFormulaInstance.setCellContents({ row: 1, col: columna, sheet: 0 }, `=FILTER(${columnaLetra}2:${columnaLetra}${filas}, ${columnaCondicion}2: ${columnaCondicion}${filas}${condicionFiltro})`);
+    }
+
+    const resultadosFiltrados = [];
+    for(let fila = 0; fila < filas; fila+=1) {
+        const resultadoColumna = [];
+        for(let columna = indiceColumnaVacio; columna < indiceColumnaVacio*2+1; columna+=1) {
+            const valorCelda = hyperFormulaInstance.getCellValue({ row: fila, col: columna, sheet: sheetId });
+            if (valorCelda != null && valorCelda != undefined) {
+                resultadoColumna.push(valorCelda);
+            }
+        }
+        if (resultadoColumna.length > 0) {
+            resultadosFiltrados.push(resultadoColumna);
+        }
+    }
+
+    const resultados = {
+        hojas: {
+            [tractorSeleccionado]: resultadosFiltrados
+        }
+    };
+
+
+    return {
+        resultados,
+    };
+
+}
+
+
+function numeroAColumnaExcel(num) {
+  let columna = '';
+  while (num > 0) {
+    const residuo = (num - 1) % 26;
+    columna = String.fromCharCode(65 + residuo) + columna;
+    num = Math.floor((num - 1) / 26);
+  }
+  return columna;
+}
+
+
+
+/**
+ * @function traducirFormulaEstructurada
+ * @param {string} formula - Fórmula estructurada a traducir.
+ * @param {Array} encabezados - Encabezados de la hoja de Excel.
+ * @param {number} filaActiva - Fila activa para la traducción.
+ * @returns {string} Fórmula traducida a formato clásico de Excel.
+ */
+
+function nombreColumnaAIndice(filtro, encabezados) {
+    // Buscar el primer match de [@NombreColumna]
+    const match = filtro.match(/\[@([^\]]+)\]/);
+    if (!match) {
+        return { error: true, columnasNoEncontradas: ['No se encontró ninguna columna en el filtro'] };
+    }
+    const nombreColumna = match[1];
+    const columna = encabezados.indexOf(nombreColumna);
+    if (columna === -1) {
+        return { error: true, columnaNoEncontrada: [nombreColumna] };
+    }
+    return numeroAColumnaExcel(columna + 1); // +1 porque A=1, B=2, etc.
+}
+
+
+/**
+ * Extrae la condición de una fórmula tipo =FILTER([@Columna]condición)
+ * @param {string} filtro - Fórmula tipo =FILTER([@Columna]condición)
+ * @returns {string|null} La condición (por ejemplo, '>1' o '="Muy rápido"'), o null si no se encuentra.
+ */
+function extraerCondicionFiltro(filtro) {
+    // Busca la referencia estructurada y lo que sigue después de ella, hasta el paréntesis de cierre
+    const match = filtro.match(/\[@[^\]]+\]([^)]+)/);
+    if (!match) return null;
+    return match[1].trim();
+}
+
+
+
+module.exports = {
+  filtrarDatos,
+} 

harvester-app/src/backend/casosUso/sesion/iniciarSesion.js

@@ -1,4 +1,4 @@
-// RF2 Usuario registrado inicia sesión - https://codeandco-wiki.netlify.app/docs/proyectos/tractores/documentacion/requisitos/RF2
+// RF2 Usuario registrado inicia sesión - https://codeandco-wiki.netlify.app/docs/next/proyectos/tractores/documentacion/requisitos/RF2
 
 const validador = require('validator');
 const { iniciarSesion: iniciarSesionAPI } = require('../../domain/sesionAPI/sesionAPI');
@@ -10,7 +10,13 @@ const { iniciarSesion: iniciarSesionAPI } = require('../../domain/sesionAPI/sesi
  * @returns {boolean} `true` si el correo es válido, de lo contrario `false`.
  */
 function validarCorreo(correo) {
-  const regex = /^[a-z0-9!#$%&'*+=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+  // Rechaza si hay espacios en cualquier parte
+  if (/\s/.test(correo)) { 
+    return false;
+  }
+
+  // Validar formato de correo electrónico
+  const regex = /^(?!.*\s)[a-z0-9!#$%&'*+=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
   return regex.test(correo);
 }
 
@@ -42,7 +48,11 @@ function sanitizarEntrada(correo, contrasenia) {
  */
 async function iniciarSesion(correo, contrasenia) {
   if (!validarCorreo(correo)) {
-    return { ok: false, mensaje: 'Correo inválido' };
+    return { ok: false, mensaje: 'Correo o contraseña incorrectos' };
+  }
+
+  if (!contrasenia || contrasenia.trim() === '') {
+    return { ok: false, mensaje: 'La contraseña no puede estar vacía' };
   }
 
   // Sanitizar la entrada del correo y la contraseña

harvester-app/src/backend/casosUso/usuarios/crearUsuario.js

@@ -52,7 +52,7 @@ function validarCorreo(correo) {
  */
 async function crearUsuario({ nombre, correo, contrasenia, idRolFK }) {
     if (!nombre || !correo || !contrasenia || !idRolFK) {
-        return { ok: false, mensaje: 'Todos los campos son obligatorios' };
+        return { ok: false, mensaje: `Todos los campos son obligatorios` };
     }
 
     if (!validarCorreo(correo)) {
@@ -79,9 +79,8 @@ async function crearUsuario({ nombre, correo, contrasenia, idRolFK }) {
             return { ok: false, mensaje: respuesta.mensaje || 'Error al crear el usuario' };
         }
         return { ok: true, mensaje: respuesta.mensaje, id: respuesta.id };
-    // eslint-disable-next-line no-unused-vars
-    } catch (error) {
-        return { ok: false, mensaje: 'Error al crear el usuario'};
+    } catch {
+        return { ok: false, mensaje: 'Error al crear el usuario' };
     }
 }
 

harvester-app/src/backend/domain/sesionAPI/sesionAPI.js

@@ -1,5 +1,6 @@
-// RF2 Usuario registrado inicia sesión - https://codeandco-wiki.netlify.app/docs/proyectos/tractores/documentacion/requisitos/RF2
-// RF3 Usuario cierra sesión - https://codeandco-wiki.netlify.app/docs/proyectos/tractores/documentacion/requisitos/RF3
+// RF2 Usuario registrado inicia sesión - https://codeandco-wiki.netlify.app/docs/next/proyectos/tractores/documentacion/requisitos/RF2
+// RF5 Usuario cierra sesión - https://codeandco-wiki.netlify.app/docs/next/proyectos/tractores/documentacion/requisitos/RF5
+
 const { URL_BASE } = require(`${rutaBase}src/framework/utils/scripts/constantes.js`);	
 
 /**