fpavon-ee-shared 1.0.0

package/dist/expediente-electronico/infrastructure/routes/expediente-electronico.route.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = require("express");
+const dependency_injection_1 = __importDefault(require("../../../dependency-injection/dependency-injection"));
+const middleware_auth_1 = require("../../../infrastructure/middlewares/middleware.auth");
+const route = (0, express_1.Router)();
+const agregarModulo = (req, res, next) => {
+    try {
+        const perfil = req.body.usuario.roles;
+        if (perfil.length == 0) {
+            res.status(401).json({ "error": "No tiene el perfil requerido." });
+            return;
+        }
+        perfil.forEach(rol => {
+            req.body.usuario.grupos.push(rol.grupo);
+        });
+        next();
+    }
+    catch (error) {
+        res.status(500).json({ "error": `${error}` });
+        return;
+    }
+};
+const expedienteElectronicoController = dependency_injection_1.default.get('EE.ExpedienteElectronico.infrastructure.ExpedienteElectronicoController');
+/**
+ * Routes
+ */
+route.use('/expediente-electronico', middleware_auth_1.validarToken);
+route.use('/expediente-electronico', agregarModulo);
+route.get('/expediente-electronico', middleware_auth_1.validarToken, expedienteElectronicoController.getExpCtrl);
+route.get('/expediente-electronico-sin-paginacion', middleware_auth_1.validarToken, expedienteElectronicoController.getExpSinPaginacionCtrl);
+route.get('/expediente-electronico/pendientes', expedienteElectronicoController.getExpPendientesCtrl);
+route.get('/expediente-electronico/pendientesSinPaginado', expedienteElectronicoController.getExpPendientesSinPaginadoCtrl);
+route.get('/expediente-electronico/rechazados', expedienteElectronicoController.getExpRechazadosCtrl);
+route.get('/expediente-electronico/aprobados', expedienteElectronicoController.getExpAprobadosCtrl);
+route.get('/expediente-electronico/cantidad', expedienteElectronicoController.getExpCantidadCtrl);
+route.get('/expediente-electronico/cantidadPendientes', expedienteElectronicoController.getExpCantidadPendientesCtrl);
+route.get('/expediente-electronico/cantidadAprobados', expedienteElectronicoController.getExpCantidadAprobadosCtrl);
+route.get('/expediente-electronico/cantidadRechazados', expedienteElectronicoController.getExpACantidadRechazadosCtrl);
+route.get('/unidades', expedienteElectronicoController.getAllUnidades);
+route.get('/unidades/:unidad', expedienteElectronicoController.getUnidadesByUnidad);
+route.patch('/expediente-electronico/firmarDocumento', expedienteElectronicoController.firmarDocumento);
+exports.default = route;

package/dist/infrastructure/bd/connection.sql.js

@@ -0,0 +1,64 @@
+"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.getConnectionForTransaction = exports.executeQuery = exports.getConnection = void 0;
+const mssql_1 = __importDefault(require("mssql"));
+const conexion = {
+    user: process.env.DBUSER,
+    password: process.env.DBPASSWORD,
+    server: process.env.DBSERVER || "",
+    database: process.env.DBNAME,
+    options: {
+        encrypt: true,
+        trustServerCertificate: true
+    }
+};
+function getConnection(query) {
+    return executeQuery(query);
+}
+exports.getConnection = getConnection;
+function executeQuery(query, params) {
+    return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const pool = yield mssql_1.default.connect(conexion);
+            const request = pool.request();
+            // Agrega parámetros si se proporcionan
+            if (params) {
+                Object.entries(params).forEach(([key, value]) => {
+                    request.input(key, value);
+                });
+            }
+            const result = yield request.query(query);
+            resolve(result);
+        }
+        catch (error) {
+            console.error("error BD: ", error);
+            reject(error);
+        }
+    }));
+}
+exports.executeQuery = executeQuery;
+function getConnectionForTransaction() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const pool = yield mssql_1.default.connect(conexion);
+            return pool;
+        }
+        catch (error) {
+            console.error("Error al conectar a la base de datos:", error);
+            throw new Error("No se pudo conectar a la base de datos");
+        }
+    });
+}
+exports.getConnectionForTransaction = getConnectionForTransaction;

package/dist/infrastructure/bd/pagination.sql.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPagination = void 0;
+const getPagination = (page = 1, limit = 10) => {
+    if (limit > 25) {
+        limit = 10;
+    }
+    if (page < 1) {
+        page = 1;
+    }
+    const offset = (page - 1) * limit; // Es el número de paginas.
+    const limitClause = `FETCH NEXT ${limit} ROWS ONLY`; // Es la cantidad de registros por página.
+    return { offset, limitClause };
+};
+exports.getPagination = getPagination;

package/dist/infrastructure/docs/swagger.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const swagger_jsdoc_1 = __importDefault(require("swagger-jsdoc"));
+const swagger_ui_express_1 = __importDefault(require("swagger-ui-express"));
+const swaggerDefinition = {
+    openapi: '3.0.0',
+    info: {
+        title: 'Expedientes Electronicos API',
+        version: '1.0.0',
+    },
+    servers: [
+        {
+            url: `${process.env.URL_SERVE}`
+        },
+    ],
+    components: {
+        securitySchemes: {
+            Authentication: {
+                type: "http",
+                scheme: "bearer",
+            },
+        },
+        schemas: {}
+    }
+};
+const swaggerOptions = {
+    swaggerDefinition,
+    apis: ['./src/*/infrastructure/routes/*.ts'],
+};
+// export default swaggerJSDoc(swaggerOptions);
+const swaggerDocs = (app, port) => {
+    app.use('/api/docs', swagger_ui_express_1.default.serve, swagger_ui_express_1.default.setup((0, swagger_jsdoc_1.default)(swaggerOptions)));
+};
+exports.default = swaggerDocs;

package/dist/infrastructure/fileServer/fileServer.basic-ftp.js

@@ -0,0 +1,220 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FtpConnection = void 0;
+// const ftp = require('basic-ftp');
+const ftp = __importStar(require("basic-ftp"));
+const stream_buffers_1 = require("stream-buffers");
+const node_stream_1 = require("node:stream");
+class FtpConnection {
+    constructor() {
+        this.client = new ftp.Client(60000);
+    }
+    connect(host, user, password, secure) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.client.access({
+                    host: host,
+                    user: user,
+                    password: password,
+                    secure,
+                    secureOptions: { rejectUnauthorized: false } // ⚠️ Desactiva validación del certificado
+                });
+                console.log('Conexión FTP establecida.');
+                // console.log(await this.client.list())
+            }
+            catch (err) {
+                console.error('Error al conectar al servidor FTP:', err);
+                throw err;
+            }
+        });
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.client.close();
+                console.log('Conexión FTP cerrada.');
+            }
+            catch (err) {
+                console.error('Error al cerrar la conexión FTP:', err);
+            }
+        });
+    }
+    uploadBuffer(buffer, remotePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const upload = yield this.client.uploadFrom(buffer, remotePath);
+                console.log('Archivo cargado con éxito en', remotePath);
+                return upload;
+            }
+            catch (err) {
+                console.error('Error al cargar el archivo:', err);
+                throw err;
+            }
+        });
+    }
+    uploadFromStream(stream, remotePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                console.log(`[FTP] 🚀 Iniciando upload de stream a: ${remotePath}`);
+                // Stream con logging de progreso
+                let totalBytes = 0;
+                let chunkCount = 0;
+                const progressStream = new node_stream_1.PassThrough();
+                // Interceptar datos para logging
+                stream.on('data', (chunk) => {
+                    totalBytes += chunk.length;
+                    chunkCount++;
+                    // Log cada 200 chunks para no saturar
+                    if (chunkCount % 200 === 0) {
+                        const mb = Math.round(totalBytes / 1024 / 1024 * 100) / 100;
+                        console.log(`[FTP] 📊 Progreso: ${chunkCount} chunks, ${mb} MB`);
+                    }
+                    progressStream.write(chunk);
+                });
+                stream.on('end', () => {
+                    const mb = Math.round(totalBytes / 1024 / 1024 * 100) / 100;
+                    console.log(`[FTP] 📁 Stream terminado: ${chunkCount} chunks totales, ${mb} MB`);
+                    progressStream.end();
+                });
+                stream.on('error', (error) => {
+                    console.error('[FTP] ❌ Error en stream de entrada:', error);
+                    progressStream.destroy(error);
+                });
+                // Upload real usando basic-ftp
+                yield this.client.uploadFrom(progressStream, remotePath);
+                const mb = Math.round(totalBytes / 1024 / 1024 * 100) / 100;
+                console.log(`[FTP] ✅ Upload completado: ${remotePath} (${mb} MB)`);
+            }
+            catch (err) {
+                console.error(`[FTP] ❌ Error en upload:`, err);
+                throw err;
+            }
+        });
+    }
+    downloadToBuffer(remotePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const writableBuffer = new stream_buffers_1.WritableStreamBuffer();
+                yield this.client.downloadTo(writableBuffer, remotePath);
+                const buffer = writableBuffer.getContents();
+                return buffer;
+            }
+            catch (err) {
+                console.error('Error al descargar el archivo:', err);
+                throw err;
+            }
+        });
+    }
+    downloadToStream(remotePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                console.log(`[FTP] Iniciando descarga de stream: ${remotePath}`);
+                const passThrough = new node_stream_1.PassThrough({
+                    highWaterMark: 64 * 1024 // Buffer de 64KB
+                });
+                // NO usar await aquí - retornar el stream inmediatamente
+                const downloadPromise = this.client.downloadTo(passThrough, remotePath);
+                // Manejar la finalización de forma asíncrona
+                downloadPromise
+                    .then(() => {
+                    console.log(`[FTP] Descarga completada: ${remotePath}`);
+                    // NO llamar passThrough.end() aquí - basic-ftp lo hace automáticamente
+                })
+                    .catch((error) => {
+                    console.error(`[FTP] Error en descarga: ${remotePath}`, error);
+                    passThrough.destroy(error);
+                });
+                // Debugging
+                passThrough.on('data', (chunk) => {
+                    console.log(`[FTP STREAM] Chunk recibido: ${chunk.length} bytes`);
+                });
+                passThrough.on('end', () => {
+                    console.log(`[FTP STREAM] Stream terminado: ${remotePath}`);
+                });
+                passThrough.on('error', (error) => {
+                    console.error(`[FTP STREAM] Error:`, error);
+                });
+                return passThrough;
+            }
+            catch (err) {
+                console.error('Error al crear stream:', err);
+                throw err;
+            }
+        });
+    }
+    deleteByUuid(uuid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.client.remove(uuid);
+                return true;
+            }
+            catch (err) {
+                console.error('Error al borrar el archivo:', err);
+                throw err;
+            }
+        });
+    }
+    list(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.client.useDefaultSettings();
+            return yield this.client.list(path);
+        });
+    }
+    deleteAllFilesOnFtpServer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Obtener una lista de archivos en el directorio actual
+                const fileList = yield this.client.list();
+                // Eliminar cada archivo en la lista
+                for (const file of fileList) {
+                    // console.log(file.type);
+                    if (file.type === 1) {
+                        console.log(`Eliminando archivo: ${file.name}`);
+                        yield this.client.remove(file.name);
+                    }
+                }
+                console.log('Todos los archivos han sido eliminados correctamente.');
+            }
+            catch (error) {
+                console.error('Error al eliminar archivos:', error);
+            }
+            finally {
+                // Cerrar la conexión
+                yield this.client.close();
+            }
+        });
+    }
+}
+exports.FtpConnection = FtpConnection;

package/dist/infrastructure/fileServer/fileServer.connection.js

@@ -0,0 +1,94 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FtpConnection = void 0;
+const fs = __importStar(require("fs"));
+class FtpConnection {
+    constructor() {
+        let Client = require('ftp');
+        this.client = new Client();
+        this.client.on('error', (err) => {
+            console.error('Error en la conexión FTP:', err);
+        });
+    }
+    connect(host, user, password) {
+        return new Promise((resolve, reject) => {
+            this.client.on('ready', () => {
+                console.log('Conexión FTP exitosa');
+                this.client.list((err, list) => {
+                    if (err)
+                        throw err;
+                    // console.log(list);
+                    this.client.end();
+                });
+                resolve();
+            });
+            this.client.connect({
+                host: host,
+                user: user,
+                password: password
+            });
+        });
+    }
+    uploadFile(localPath, remotePath) {
+        return new Promise((resolve, reject) => {
+            this.client.put(localPath, remotePath, (err) => {
+                if (err) {
+                    console.error('Error al subir el archivo:', err);
+                    reject(err);
+                }
+                else {
+                    console.log('Archivo subido exitosamente');
+                    resolve();
+                }
+            });
+        });
+    }
+    downloadFile(remotePath, localPath) {
+        console.log('Descargando..');
+        return new Promise((resolve, reject) => {
+            this.client.get(remotePath, function (err, stream) {
+                if (err) {
+                    console.error('Error al descargar el archivo:');
+                    reject(err);
+                    return;
+                }
+                stream.once('close', () => {
+                    console.log('Archivo descargado exitosamente');
+                    stream.pipe(fs.createWriteStream(localPath));
+                    resolve();
+                });
+                stream.once('end', () => {
+                    console.log('La conexión se cerró sin errores.');
+                    resolve();
+                });
+            });
+        });
+    }
+    disconnect() {
+        this.client.end();
+    }
+}
+exports.FtpConnection = FtpConnection;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validarApiKeyInternet = void 0;
+const API_KEY_SECRET = process.env.APIKEY;
+const validarApiKeyInternet = (req, res, next) => {
+    const apiKey = req.headers['x-api-key'];
+    if (!apiKey) {
+        return res.status(401).json({ error: 'Acceso no autorizado. Falta la clave API.' });
+    }
+    if (apiKey !== API_KEY_SECRET) {
+        return res.status(401).json({ error: 'Clave API inválida.' });
+    }
+    next();
+};
+exports.validarApiKeyInternet = validarApiKeyInternet;