fpavon-ee-shared 1.0.0

package/dist/infrastructure/middlewares/middleware.auth.js

@@ -0,0 +1,372 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.obtenerUnidadPadre = exports.unidadesJoinFuncion = exports.getChildrenUnitIds = exports.getGerencia = exports.getChildrenLabelNumbers = exports.descifrarToken = exports.cifrado = exports.extraerNivel = exports.validarToken = void 0;
+const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
+const connection_sql_1 = require("../bd/connection.sql"); // Asegúrate de ajustar la ruta a tu configuración de base de datos
+const axios_1 = __importDefault(require("axios"));
+const validarToken = (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const bearerHeader = req.header('Authorization') || "";
+        if (bearerHeader !== "") {
+            const bearer = bearerHeader.split(" ");
+            let token = bearer[1];
+            // Limpio el token de comillas por las dudas
+            token = token.replace(/['"]+/g, '');
+            let data = jsonwebtoken_1.default.verify(token, (process.env.SECRET || ''));
+            const { afiliado, idNavegador } = data;
+            // Verificar si el usuario está deslogueado
+            const queryVerificar = `SELECT logueado, idNavegador FROM Usuarios WHERE afiliado = '${data.afiliado}'`;
+            const result = yield (0, connection_sql_1.getConnection)(queryVerificar);
+            if (result.recordset.length === 0) {
+                res.status(401).json({ status: false, mensaje: "Usuario no encontrado" });
+                return;
+            }
+            const usuario = result.recordset[0];
+            if (usuario.logueado === 0) {
+                res.status(401).json({ status: false, mensaje: "Usuario deslogueado por inactividad" });
+                return; // Terminar ejecución pero sin retornar res
+            }
+            //ACTIVAR LO SIGUIENTE PARA DESLOGUEO POR MISMO USUARIO EN DISTINTOS DISPOSITIVOS
+            // if (!usuario.idNavegador || usuario.idNavegador !== idNavegador) {
+            //   res.status(401).json({ status: false, mensaje: "Sesión inválida. Posible login desde otro dispositivo." });
+            //   return;
+            // }
+            req.body.token = token;
+            req.body.nombreGerencia = data.nombreGerencia;
+            req.body.uid = data.afiliado;
+            req.body.nivel = data.grupoAD;
+            req.body.nombreCompleto = data.apellido + ", " + data.nombre;
+            req.body.cargo = data.cargo;
+            req.body.unidad = data.unidad;
+            req.body.unidadSuperior = data.unidadSuperior;
+            req.body.gerencia = data.gerencia;
+            req.body.nombreUnidad = data.nombreUnidad;
+            req.body.documento = data.documento;
+            req.body.usuario = {
+                uid: data.afiliado,
+                nivel: data.grupoAD,
+                nombreCompleto: data.apellido + ", " + data.nombre,
+                cargo: data.cargo,
+                unidad: data.unidad,
+                unidadSuperior: data.unidadSuperior,
+                gerencia: data.gerencia,
+                nombreUnidad: data.nombreUnidad,
+                nombreGerencia: data.nombreGerencia,
+                roles: data.roles,
+                grupos: data.grupos,
+                documento: data.documento,
+                mail: data.mail
+            };
+            // Esto bloque está porque la gente de PAI no agregó la gerencia donde corresponde
+            if (data.gerencia != 0) {
+                req.body.gerencia = data.gerencia;
+            }
+            else {
+                req.body.gerencia = data.unidad;
+            }
+            // Esto bloque está porque la gente de PAI no agregó la gerencia donde corresponde
+            // Actualizar lastActivity
+            const queryActualizar = `UPDATE Usuarios SET lastActivity = CURRENT_TIMESTAMP WHERE afiliado = '${data.afiliado}'`;
+            yield (0, connection_sql_1.getConnection)(queryActualizar);
+            next();
+        }
+        else {
+            res.status(401).json({ status: false, mensaje: "no se encontró el token en la cabecera" });
+            return; // Terminar ejecución pero sin retornar res
+        }
+    }
+    catch (error) {
+        res.status(401).json({ status: false, mensaje: "token inválido" });
+        return; // Terminar ejecución pero sin retornar res
+    }
+});
+exports.validarToken = validarToken;
+const extraerNivel = (data) => {
+    let nivel = 0;
+    data.forEach(element => {
+        if (element.indexOf(1) > 0)
+            nivel = 1;
+        else if (element.indexOf(2) > 0)
+            nivel = 2;
+        else if (element.indexOf(3) > 0)
+            nivel = 3;
+    });
+    return nivel;
+};
+exports.extraerNivel = extraerNivel;
+//Para generar token que se usará en el front end
+const cifrado = (usuario) => {
+    return new Promise((resolve, reject) => {
+        let secreto = process.env.SECRET;
+        jsonwebtoken_1.default.sign(usuario, secreto, { expiresIn: '12h' }, (err, token) => {
+            return err ? reject("no se pudo generar el JWT") : resolve(token);
+        });
+    });
+};
+exports.cifrado = cifrado;
+const descifrarToken = (token) => {
+    token = token.replace(/['"]+/g, '');
+    try {
+        let data = jsonwebtoken_1.default.verify(token, (process.env.SECRET || ''));
+        return data;
+    }
+    catch (error) {
+        return 'ERROR';
+    }
+};
+exports.descifrarToken = descifrarToken;
+// NOTA: Asume que la función getGerencia y las dependencias (axios, etc.) están definidas e importadas.
+// Si estás usando TypeScript, considera definir la interfaz 'Unidad' para 'gerencia' para un mejor tipado.
+const getChildrenLabelNumbers = (searchNumber) => __awaiter(void 0, void 0, void 0, function* () {
+    let gerencia;
+    const searchUnitId = searchNumber;
+    try {
+        // 1. Obtener la gerencia COMPLETA (nodo raíz 1187 en el ejemplo)
+        const rawData = yield getGerencia(searchNumber);
+        gerencia = (typeof rawData === 'string') ? JSON.parse(rawData) : rawData;
+    }
+    catch (error) {
+        console.error("Error al obtener la gerencia:", error);
+        // En caso de fallo, devolvemos solo la unidad buscada
+        return [searchNumber];
+    }
+    // --- Funciones Auxiliares ---
+    /**
+     * Función recursiva para encontrar el nodo específico (e.g., 1238) dentro de la jerarquía.
+     * @param nodo El nodo actual en la búsqueda.
+     * @returns El nodo encontrado o null.
+     */
+    function findTargetNode(nodo) {
+        // 1. Si el nodo actual es el nodo buscado, lo retornamos.
+        if (nodo.C_ID_UNIDAD === searchUnitId) {
+            return nodo;
+        }
+        // 2. Si tiene hijas, buscamos recursivamente en ellas.
+        if (nodo.Hijas && Array.isArray(nodo.Hijas)) {
+            for (const hija of nodo.Hijas) {
+                const found = findTargetNode(hija);
+                if (found) {
+                    return found; // Retornar inmediatamente si se encuentra
+                }
+            }
+        }
+        // 3. No encontrado en este subárbol.
+        return null;
+    }
+    /**
+     * Función recursiva para extraer los IDs A PARTIR de un nodo.
+     * Esta es tu función original, ajustada.
+     * @param nodo El objeto de la unidad actual.
+     * @param unitsArray El array donde se almacenan los IDs.
+     */
+    function extractUnitsFromNode(nodo, unitsArray) {
+        if (nodo.C_ID_UNIDAD) {
+            unitsArray.push(nodo.C_ID_UNIDAD);
+        }
+        if (nodo.Hijas && Array.isArray(nodo.Hijas)) {
+            for (const hija of nodo.Hijas) {
+                extractUnitsFromNode(hija, unitsArray);
+            }
+        }
+    }
+    // --- Lógica Principal de Extracción ---
+    // 1. Encontrar el nodo raíz deseado (e.g., el objeto de la unidad 1238)
+    const targetNode = findTargetNode(gerencia);
+    if (!targetNode) {
+        // Si por alguna razón la unidad de búsqueda no está en la jerarquía retornada
+        console.warn(`Unidad ${searchUnitId} no encontrada en la jerarquía de la gerencia.`);
+        return [searchUnitId];
+    }
+    // 2. Extraer TODAS las unidades (incluyendo la 1238) A PARTIR del nodo encontrado.
+    const unidades = [];
+    extractUnitsFromNode(targetNode, unidades);
+    // 3. Devolver el array final sin duplicados.
+    return [...new Set(unidades)];
+});
+exports.getChildrenLabelNumbers = getChildrenLabelNumbers;
+// Caché en memoria para unidades
+const unidadesCache = {};
+const CACHE_TTL = 1000 * 60 * 60; // 1 hora en milisegundos
+/**
+ * Obtiene la estructura jerárquica de una unidad
+ */
+/**
+ * Obtiene la estructura jerárquica de una unidad
+ */
+function getGerencia(unidad) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log("UNIDAD: ", unidad);
+        try {
+            // URL del endpoint de la API de unidades
+            const url = 'http://10.5.12.245:9095/api/Unidades/GetGerencia';
+            // Configuración explícita para la petición GET
+            const options = {
+                method: 'get', // Asegurar que esté en minúsculas y sea 'get'
+                url: `${url}?idUnidad=${unidad}`,
+                headers: {
+                    'Api_Key': 'a8778df88c4c7d781bbef56220e16417',
+                    'Accept': 'application/json'
+                },
+                timeout: 10000, // Reducimos a 10 segundos
+                transformRequest: [(data) => data], // Evitar transformación automática
+                proxy: false // Desactivar proxy si está causando problemas
+            };
+            console.log("Enviando petición GET a:", options.url);
+            // Realizar la petición a la API usando axios explícitamente como GET
+            const response = yield axios_1.default.get(`${url}?idUnidad=${unidad}`, {
+                headers: options.headers,
+                timeout: options.timeout,
+                proxy: false
+            });
+            if (response.status === 200) {
+                // console.log("Respuesta exitosa de GetGerencia", response.data);
+                return response.data;
+            }
+            else {
+                console.error("Error en getGerencia: Respuesta no exitosa", response.status);
+                // Si hay error, devolver un objeto con la unidad original
+                return { C_ID_UNIDAD: unidad, Hijas: [] };
+            }
+        }
+        catch (error) {
+            console.error("Error en getGerencia:", error);
+            // Si hay error, devolver un objeto con la unidad original
+            return { C_ID_UNIDAD: unidad, Hijas: [] };
+        }
+    });
+}
+exports.getGerencia = getGerencia;
+/**
+ * Obtiene los IDs de todas las unidades subordinadas
+ */
+function getChildrenUnitIds(searchUnitId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!searchUnitId) {
+            return [];
+        }
+        // Verificar caché
+        const cacheKey = `unidades_${searchUnitId}`;
+        if (unidadesCache[cacheKey] && unidadesCache[cacheKey].timestamp > Date.now() - CACHE_TTL) {
+            return [...unidadesCache[cacheKey].unidades];
+        }
+        try {
+            // Para manejar el timeout, seguimos necesitando Promise.race
+            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout obteniendo unidades")), 30000));
+            // Función para obtener las unidades
+            function getUnidades() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        // Obtener la gerencia
+                        const gerencia = yield getGerencia(searchUnitId);
+                        // Array para almacenar todos los IDs de unidades
+                        const unidades = [searchUnitId];
+                        // Función recursiva para extraer IDs de la estructura jerárquica
+                        function extraerUnidades(nodo) {
+                            if (nodo.C_ID_UNIDAD && nodo.C_ID_UNIDAD !== searchUnitId) {
+                                unidades.push(nodo.C_ID_UNIDAD);
+                            }
+                            // Procesar unidades hijas recursivamente
+                            if (nodo.Hijas && Array.isArray(nodo.Hijas)) {
+                                for (const hija of nodo.Hijas) {
+                                    extraerUnidades(hija);
+                                }
+                            }
+                        }
+                        // Procesar la estructura jerárquica
+                        extraerUnidades(gerencia);
+                        // Eliminar duplicados
+                        return [...new Set(unidades)];
+                    }
+                    catch (error) {
+                        console.warn(`Error procesando gerencia para ${searchUnitId}:`, error);
+                        return [searchUnitId];
+                    }
+                });
+            }
+            // Seguimos necesitando Promise.race para el timeout
+            let unidades;
+            try {
+                unidades = yield Promise.race([getUnidades(), timeoutPromise]);
+            }
+            catch (error) {
+                console.warn(`Error o timeout obteniendo unidades para ${searchUnitId}:`, error);
+                unidades = [searchUnitId];
+            }
+            // Guardar en caché
+            unidadesCache[cacheKey] = {
+                timestamp: Date.now(),
+                unidades: unidades
+            };
+            return unidades;
+        }
+        catch (error) {
+            console.warn(`Error en getChildrenUnitIds para ${searchUnitId}:`, error);
+            return [searchUnitId];
+        }
+    });
+}
+exports.getChildrenUnitIds = getChildrenUnitIds;
+const unidadesJoinFuncion = (unidad) => __awaiter(void 0, void 0, void 0, function* () {
+    let unidades = [];
+    try {
+        yield (0, connection_sql_1.getConnection)(`select * from CodigosDeUbicacion where hijos like '%${unidad}%'`).then(resp => {
+            let hijos = JSON.parse(resp.recordset[0].hijos);
+            for (let i of hijos) {
+                let label = i.label.split('-')[1];
+                unidades.push(label.trim());
+                if (i.children) {
+                    for (let o of i.children) {
+                        let label = o.label.split('-')[1];
+                        unidades.push(label.trim());
+                        if (o.children) {
+                            for (let u of o.children) {
+                                let label = u.label.split('-')[1];
+                                unidades.push(label.trim());
+                            }
+                        }
+                    }
+                }
+            }
+        });
+    }
+    catch (error) {
+        console.error("Error unidadesJoinFuncion", error);
+    }
+    return unidades;
+});
+exports.unidadesJoinFuncion = unidadesJoinFuncion;
+const obtenerUnidadPadre = (unidadABuscar) => __awaiter(void 0, void 0, void 0, function* () {
+    function findParent(organigrama, codigoUnidad, parent) {
+        for (const unidad of organigrama) {
+            const codigo = unidad.label.split(' - ').pop(); // Extrae el código de la unidad
+            if (codigo === codigoUnidad) {
+                return parent ? parent.label.split(' - ').pop() : null;
+            }
+            // Si tiene hijos, los recorremos recursivamente
+            if (unidad.children.length > 0) {
+                const result = findParent(unidad.children, codigoUnidad, unidad);
+                if (result) {
+                    return result;
+                }
+            }
+        }
+        return null;
+    }
+    const queryResp = yield (0, connection_sql_1.getConnection)(`select * from CodigosDeUbicacion where hijos like '%${unidadABuscar}%'`);
+    const organigrama = JSON.parse(queryResp.recordset[0].hijos);
+    console.log(organigrama);
+    return findParent(organigrama, unidadABuscar);
+});
+exports.obtenerUnidadPadre = obtenerUnidadPadre;

package/dist/infrastructure/middlewares/middleware.deslogueo.js

@@ -0,0 +1 @@
+"use strict";

package/dist/infrastructure/middlewares/middleware.validarCampos.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validarCampos = void 0;
+const express_validator_1 = require("express-validator");
+const validarCampos = (req, res, next) => {
+    let errores = (0, express_validator_1.validationResult)(req);
+    if (!errores.isEmpty()) {
+        return res.status(400).json({
+            status: "error en los parametros",
+            mensaje: errores.mapped()
+        });
+    }
+    next();
+};
+exports.validarCampos = validarCampos;

package/dist/infrastructure/middlewares/middleware.validarRol.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validarRol = void 0;
+function validarRol(rolRequerido) {
+    if (typeof rolRequerido != 'string')
+        throw new Error("Debe enviar un rol requerido");
+    return function (req, res, next) {
+        try {
+            if (!req.body.usuario.roles.includes(rolRequerido)) {
+                return res.status(401).json({ "error": "No tiene permisos para usar esta funcionalidad" });
+            }
+            next();
+        }
+        catch (error) {
+            return res.status(500).json({ "error": `${error}` });
+        }
+    };
+}
+exports.validarRol = validarRol;

package/dist/infrastructure/middlewares/validarNivel.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validarGerencia = exports.validarNivel = void 0;
+function validarNivel(nivelRequerido) {
+    return function (req, res, next) {
+        // Aquí podrías validar el nivel de usuario
+        try {
+            if (req.body.nivelNumero < nivelRequerido) {
+                // Si el usuario no tiene el nivel de acceso necesario, devuelve un error
+                return res.status(401).json({ "error": "No tiene permisos para usar esta funcionalidad" });
+            }
+            // Si el usuario tiene el nivel de acceso necesario, llama al siguiente middleware o al controlador final
+            next();
+        }
+        catch (error) {
+            return res.status(500).json({ "error": `${error}` });
+        }
+    };
+}
+exports.validarNivel = validarNivel;
+function validarGerencia(gerenciaRequerido) {
+    return function (req, res, next) {
+        // Aquí podrías validar gerencia de usuario
+        try {
+            if (req.body.usuario.nombreGerencia != gerenciaRequerido) {
+                // Si el usuario no tiene el nivel de acceso necesario, devuelve un error
+                return res.status(401).json({ "error": "No tiene permisos para usar esta funcionalidad" });
+            }
+            // Si el usuario tiene el nivel de acceso necesario, llama al siguiente middleware o al controlador final
+            next();
+        }
+        catch (error) {
+            return res.status(500).json({ "error": `${error}` });
+        }
+    };
+}
+exports.validarGerencia = validarGerencia;

package/dist/infrastructure/server/httpsServer.class.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpsServidor = void 0;
+const cors_1 = __importDefault(require("cors"));
+const express_1 = __importDefault(require("express"));
+const morgan_body_1 = __importDefault(require("morgan-body"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const https_1 = __importDefault(require("https"));
+require('dotenv').config({ path: './.env' });
+const swagger_1 = __importDefault(require("../docs/swagger"));
+class HttpsServidor {
+    constructor() {
+        this.expressApp = (0, express_1.default)();
+        this.port = process.env.PORT;
+        this.httpsServer = this.createHttpsServer();
+        this.useCors();
+        this.useJson();
+        this.srvio = this.start();
+    }
+    useLogger() {
+        const log = fs_1.default.createWriteStream(path_1.default.join(__dirname, "logs", "express.log"), { flags: "a" });
+        (0, morgan_body_1.default)(this.expressApp, {
+            // .. other settings
+            noColors: true,
+            stream: log,
+        });
+    }
+    useRoutes(router) {
+        this.expressApp.use("/", router);
+    }
+    useCors() {
+        this.expressApp.use(express_1.default.urlencoded({ extended: true }));
+        this.expressApp.use((0, cors_1.default)());
+    }
+    useJson() {
+        this.expressApp.use(express_1.default.json());
+    }
+    start() {
+        if (process.env.NODE_ENV !== 'test') {
+            return this.httpsServer.listen(this.port, () => {
+                (0, swagger_1.default)(this.expressApp, this.port);
+                console.log("Servidor levantado en :", this.port);
+            });
+        }
+    }
+    createHttpsServer() {
+        const privateKeyBase64 = process.env.SSL_PRIVATE_KEY_BASE64;
+        const certificateBase64 = process.env.SSL_CERTIFICATE_BASE64;
+        const privateKey = Buffer.from(privateKeyBase64, 'base64').toString('utf8');
+        const certificate = Buffer.from(certificateBase64, 'base64').toString('utf8');
+        const credentials = { key: privateKey, cert: certificate };
+        return https_1.default.createServer(credentials, this.expressApp);
+    }
+}
+exports.HttpsServidor = HttpsServidor;

package/dist/infrastructure/server/server.class.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Servidor = void 0;
+const cors_1 = __importDefault(require("cors"));
+const express_1 = __importDefault(require("express"));
+const morgan_body_1 = __importDefault(require("morgan-body"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const http_1 = __importDefault(require("http"));
+require('dotenv').config({ path: './.env' });
+const swagger_1 = __importDefault(require("../docs/swagger"));
+class Servidor {
+    constructor() {
+        this.expressApp = (0, express_1.default)();
+        this.port = process.env.PORT;
+        this.httpServer = new http_1.default.Server(this.expressApp);
+        this.useCors();
+        this.useJson();
+        this.srvio = this.start();
+    }
+    useLogger() {
+        const log = fs_1.default.createWriteStream(path_1.default.join(__dirname, "logs", "express.log"), { flags: "a" });
+        (0, morgan_body_1.default)(this.expressApp, {
+            // .. other settings
+            noColors: true,
+            stream: log,
+        });
+    }
+    useRoutes(router) {
+        this.expressApp.use("/", router);
+    }
+    useCors() {
+        this.expressApp.use(express_1.default.urlencoded({ extended: true }));
+        // this.expressApp.use(cors({origin:true, credentials:true}));
+        this.expressApp.use((0, cors_1.default)());
+    }
+    useJson() {
+        this.expressApp.use(express_1.default.json());
+    }
+    start() {
+        let srv;
+        if (process.env.NODE_ENV !== 'test') {
+            return srv = this.httpServer.listen(this.port, () => {
+                (0, swagger_1.default)(this.expressApp, this.port);
+                console.log("Servidor levantado en :", this.port);
+            });
+        }
+        return srv;
+    }
+}
+exports.Servidor = Servidor;

package/dist/infrastructure/socket/socketIO.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketClient = void 0;
+const socket_io_client_1 = __importDefault(require("socket.io-client"));
+class SocketClient {
+    constructor(url) {
+        this.url = url;
+        this.socket = (0, socket_io_client_1.default)(this.url);
+        this.setupListeners();
+    }
+    setupListeners() {
+        this.socket.on('connect', () => {
+            console.log('Conectado al servidor');
+        });
+        this.socket.on('disconnect', () => {
+            console.log('Desconectado del servidor');
+        });
+    }
+}
+exports.SocketClient = SocketClient;