fpavon-ee-shared 1.0.0

package/infrastructure/stream-handler/stream-handler.ts

@@ -0,0 +1,161 @@
+import { Request, Response } from "express";
+import { Readable } from "stream";
+import { Documento } from "../../documentos/domain/documento.class";
+
+
+export class DocumentStreamHandler {
+    static async sendDocumentStream(
+        req: Request, 
+        res: Response, 
+        archivoStream: Readable, 
+        documento: Documento
+    ) {
+        console.log(`[CONTROLLER] Stream obtenido, configurando headers: ${documento.uuid}`);
+        
+        // Detectar MIME type y filename desde el objeto Documento
+        const mimeType = this.getMimeTypeFromDocumento(documento);
+        const filename = this.getFilenameFromDocumento(documento);
+        
+        console.log(`[CONTROLLER] MIME Type detectado: ${mimeType}`);
+        console.log(`[CONTROLLER] Filename: ${filename}`);
+
+        // Codificamos el nombre UTF-8 para evitar los caracteres especiales
+        const safeName = encodeURIComponent(filename);
+        
+        // Headers para visualización correcta
+        res.setHeader('Content-Type', mimeType);
+        res.setHeader('Content-Disposition', `inline; filename*=UTF-8''${safeName}`);
+        
+        // Headers de cache más permisivos para visualización
+        res.setHeader('Cache-Control', 'public, max-age=3600'); // 1 hora de cache
+        res.setHeader('Accept-Ranges', 'bytes');
+        
+        // Timeouts
+        req.setTimeout(600000);
+        res.setTimeout(600000);
+        
+        console.log(`[CONTROLLER] Headers configurados para visualización`);
+        
+        // Debugging
+        let bytesTransmitted = 0;
+        let chunkCount = 0;
+        
+        archivoStream.on('data', (chunk: Buffer) => {
+            bytesTransmitted += chunk.length;
+            chunkCount++;
+            
+            if (chunkCount % 100 === 0) {
+                console.log(`[CONTROLLER] Chunk ${chunkCount}: ${chunk.length} bytes (Total: ${bytesTransmitted} bytes)`);
+            }
+        });
+        
+        archivoStream.on('end', () => {
+            console.log(`[CONTROLLER] Stream completado exitosamente!`);
+            console.log(`[CONTROLLER] Total chunks: ${chunkCount}, Total bytes: ${bytesTransmitted}`);
+        });
+        
+        archivoStream.on('error', (error) => {
+            console.error(`[CONTROLLER] Error en stream:`, error);
+            if (!res.headersSent) {
+                res.status(500).json({ message: 'Error al transmitir archivo' });
+            } else {
+                res.end();
+            }
+        });
+        
+        // Manejo de desconexión
+        req.on('close', () => {
+            console.log(`[CONTROLLER] Cliente desconectado: ${documento.uuid}`);
+            if (archivoStream && typeof archivoStream.destroy === 'function') {
+                archivoStream.destroy();
+            }
+        });
+        
+        req.on('aborted', () => {
+            console.log(`[CONTROLLER] Request abortado: ${documento.uuid}`);
+            if (archivoStream && typeof archivoStream.destroy === 'function') {
+                archivoStream.destroy();
+            }
+        });
+        
+        console.log(`[CONTROLLER] Iniciando transmisión: ${documento.uuid}`);
+        archivoStream.pipe(res);
+    }
+
+    private static getMimeTypeFromDocumento(documento: Documento): string {
+        // Extraer extensión del nombre del documento
+        const extension = documento.nombre ? documento.nombre.split('.').pop()?.toLowerCase() : 'pdf';
+        
+        const mimeTypes: Record<string, string> = {
+            // Documentos
+            'pdf': 'application/pdf',
+            'doc': 'application/msword',
+            'docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+            'xls': 'application/vnd.ms-excel',
+            'xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            'ppt': 'application/vnd.ms-powerpoint',
+            'pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+            
+            // Imágenes
+            'jpg': 'image/jpeg',
+            'jpeg': 'image/jpeg',
+            'png': 'image/png',
+            'gif': 'image/gif',
+            'bmp': 'image/bmp',
+            'webp': 'image/webp',
+            
+            // Texto
+            'txt': 'text/plain',
+            'csv': 'text/csv',
+            'xml': 'application/xml',
+            'json': 'application/json',
+            
+            // Comprimidos
+            'zip': 'application/zip',
+            'rar': 'application/x-rar-compressed',
+            '7z': 'application/x-7z-compressed',
+            
+            // Audio/Video
+            'mp3': 'audio/mpeg',
+            'mp4': 'video/mp4',
+            'avi': 'video/x-msvideo'
+        };
+        
+        return mimeTypes[extension || ''] || 'application/octet-stream';
+    }
+
+    private static getFilenameFromDocumento(documento: Documento): string {
+        // Si el nombre ya tiene extensión, usarlo directamente
+        if(!documento.nombre){
+            return documento.uuid;
+        }
+        if (documento.nombre.includes('.')) {
+            return documento.nombre;
+        }
+        
+        // Fallback: asumir que es PDF
+        return `${documento.nombre}.pdf`;
+    }
+
+    // Método alternativo si quieres forzar descarga en lugar de visualización
+    static async downloadDocumentStream(
+        req: Request,
+        res: Response, 
+        archivoStream: Readable,
+        documento: Documento
+    ) {
+        const mimeType = this.getMimeTypeFromDocumento(documento);
+        const filename = this.getFilenameFromDocumento(documento);
+
+        // Codificamos el nombre UTF-8 para evitar los caracteres especiales
+        const safeName = encodeURIComponent(filename);
+        
+        // Cambiar disposition a attachment para forzar descarga
+        res.setHeader('Content-Type', mimeType);
+        res.setHeader('Content-Disposition', `attachment; filename*=UTF-8''${safeName}`);
+        res.setHeader('Cache-Control', 'no-cache');
+        
+        // Resto igual...
+        archivoStream.pipe(res);
+    }
+}

package/jest.config.js

@@ -0,0 +1,8 @@
+module.exports = {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    transform: {
+      '^.+\\.ts?$': 'ts-jest',
+    },
+    transformIgnorePatterns: ['<rootDir>/node_modules/', '<rootDir>/dist'],
+  };

package/notificaciones/domain/datosNotificacion.class.ts

@@ -0,0 +1,13 @@
+import { IDatosNotificacion } from "./datosNotificacion.interface";
+
+export class DatosNotificacion implements IDatosNotificacion{
+    info?: string;
+    usuarioResponsable?: string;
+    icono?: string;
+
+    constructor(info?:string, usuario?:string, icono?:string){
+        this.info=info;
+        this.usuarioResponsable=usuario;
+        this.icono=icono;
+    }
+}

package/notificaciones/domain/datosNotificacion.interface.ts

@@ -0,0 +1,5 @@
+export interface IDatosNotificacion{
+    info?:string;
+    usuarioResponsable?:string;
+    icono?:string;
+}

package/notificaciones/domain/notificacion.class.ts

@@ -0,0 +1,23 @@
+import moment from "moment-timezone";
+import { DatosNotificacion } from "./datosNotificacion.class";
+import { IDatosNotificacion } from "./datosNotificacion.interface";
+import { INotificacion } from "./notificacion.interface";
+
+export class Notificacion implements INotificacion{
+    idNotificacion: string | undefined;
+    fecha: string;
+    unidadEmisora: string;
+    unidadReceptora: string;
+    descripcion: IDatosNotificacion;
+    lectores: string[];
+    idSolicitud?: string
+
+    constructor(unidadEmisora:string,unidadReceptora:string, info:string, usuario:string, icono:string, idSolicitud?:string){
+        const fecha = moment().tz('America/Argentina/Buenos_Aires').locale('es').toISOString();
+        this.unidadEmisora=unidadEmisora;
+        this.unidadReceptora=unidadReceptora;
+        this.descripcion=new DatosNotificacion(info, usuario, icono);
+        this.lectores=[];
+        this.idSolicitud = idSolicitud
+    }
+}

package/notificaciones/domain/notificacion.interface.ts

@@ -0,0 +1,15 @@
+import { IDatosNotificacion } from "./datosNotificacion.interface";
+
+
+export interface INotificacion{
+    idNotificacion:string | undefined;
+    fecha: string;
+    unidadEmisora: string;
+    unidadReceptora: string;
+    descripcion: IDatosNotificacion;
+    /**
+     *  @param lectores arreglo de usuarios que leyeron la notificacion.
+     */
+    lectores: string[];
+    idSolicitud?: string;
+}

package/notificaciones/domain/notificacion.repository.ts

@@ -0,0 +1,8 @@
+import { INotificacion } from "./notificacion.interface";
+
+export interface INotificacionRepository{
+    insert(notificacion:INotificacion):Promise<any>;
+    seleinsertctByUnidad(unidades:string[]):Promise<any>;
+    updateLectores(idNotificacion: string, notificacion:INotificacion):Promise<INotificacion>;
+    selectNotificacionById(idNotificacion:string):Promise<INotificacion>;
+}

package/notificaciones/infrastructure/notificacion.controller.ts

@@ -0,0 +1,16 @@
+import axios from "axios";
+import { Notificacion } from "../domain/notificacion.class"
+
+export class NotificacionController{
+
+    constructor(){}
+
+    guardarNotificacion = async(unidadEmisora,unidadReceptora, info, usuario, icono, codigoInterno?) => {
+        try {  
+            let notificacion = new Notificacion(unidadEmisora,unidadReceptora, info, usuario, icono, codigoInterno);
+            await axios.post(`${process.env.URL_SERVE}/notificaciones/guardar`, notificacion);
+        } catch (error:any) {
+            console.error("Error NotificacionesController.guardarNotificacion=>", error);
+        }
+    }
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "fpavon-ee-shared",
+  "version": "1.0.0",
+  "description": "Carpeta compartida entre servicios de Expediente Electronio",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "axios": "^1.6.7",
+    "basic-ftp": "^5.0.5",
+    "cors": "^2.8.5",
+    "express": "^4.18.2",
+    "express-validator": "^7.0.1",
+    "form-data": "^4.0.0",
+    "fs-extra": "^11.2.0",
+    "http": "^0.0.1-security",
+    "jsonwebtoken": "^9.0.2",
+    "moment": "^2.30.1",
+    "morgan-body": "^2.6.9",
+    "mssql": "^10.0.2",
+    "multiparty": "^4.2.3",
+    "node-cron": "^3.0.3",
+    "node-dependency-injection": "^3.1.2",
+    "node-schedule": "^2.1.1",
+    "node-signpdf": "^3.0.0",
+    "pdf-lib": "^1.17.1",
+    "pdf-merger-js": "^5.1.1",
+    "socket.io-client": "^4.7.4",
+    "stream-buffers": "^3.0.3",
+    "swagger-jsdoc": "^6.2.8",
+    "swagger-ui-express": "^5.0.0",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.3.3"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "jest": "^29.7.0"
+  }
+}

package/script.js

@@ -0,0 +1,135 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+const [param1] = process.argv.slice(2);
+
+if (param1) {
+  const mainFolderPath = path.join(param1);
+
+  if (!fs.existsSync(mainFolderPath)) {
+    // Crear la carpeta principal
+    fs.mkdirSync(mainFolderPath, { recursive: true });
+
+
+
+    // Crear subcarpetas dentro de la carpeta principal
+    const subfolders = [
+      "application",
+      "domain", 
+      "infrastructure", 
+      "infrastructure/controller",
+      "infrastructure/routes",
+      "infrastructure/repositories"
+    ];
+    subfolders.forEach(folder => {
+      fs.mkdirSync(path.join(mainFolderPath, folder));
+    });
+
+    prepararDomain(mainFolderPath);
+    prepararApplication(mainFolderPath);
+    prepararInfrastructure(mainFolderPath);
+    printDependencyInjection();
+    console.log(`Se creo correctamente la carpeta ${param1}`);
+  } else {
+    console.log(`The folder ${mainFolderPath} already exists. No changes made.`);
+  }
+} else {
+  console.log("Invalid command. Usage: node createProject.js <param1>");
+}
+
+
+function prepararDomain(mainFolderPath){
+    // Crear la clase dentro de la carpeta domain
+    const classFilePath = path.join(mainFolderPath, 'domain', `${param1}.class.ts`);
+    const className = `${param1.charAt(0).toUpperCase() + param1.slice(1)}`;
+    const classContent = `import { I${className} } from './${param1}.interface'
+export class ${className} implements I${className} {
+  constructor() {
+    // Constructor
+  }
+
+  // Methods
+}
+`;
+
+    fs.writeFileSync(classFilePath, classContent);
+
+    // Crear la interfaz dentro de la carpeta domain
+    const interfaceFilePath = path.join(mainFolderPath, 'domain', `${param1}.interface.ts`);
+    const interfaceName = `I${className}`;
+    const interfaceContent = `export interface ${interfaceName} {
+  // Interface properties
+}
+
+`;
+
+    fs.writeFileSync(interfaceFilePath, interfaceContent);
+
+
+    // Crear la interfaz dentro de la carpeta domain
+    const repoFilePath = path.join(mainFolderPath, 'domain', `${param1}.repository.ts`);
+    const repoName = `I${className}Repository`;
+    const repoContent = `export interface ${repoName} {
+  // Interface properties
+}
+
+`;
+
+    fs.writeFileSync(repoFilePath, repoContent);
+}
+
+function prepararInfrastructure(mainFolderPath){
+
+  const classFilePath = path.join(mainFolderPath, 'infrastructure/controller', `${param1}.controller.ts`);
+  const className = `${param1.charAt(0).toUpperCase() + param1.slice(1)}`;
+  const classContent = `import { ${className}UseCase } from '../../application/${param1}.useCase'
+export class ${className}Controller {
+constructor(private readonly ${param1}UseCase: ${className}UseCase) {
+  // Constructor
+}
+
+// Methods
+}
+`;
+  fs.writeFileSync(classFilePath, classContent);
+
+  const sqlRepositoryFilePath = path.join(mainFolderPath, 'infrastructure/repositories', `${param1}.sql.repository.ts`);
+  const sqlRepositoryContent = `import { I${className}Repository } from '../../domain/${param1}.repository'
+export class ${className}SqlRepository implements I${className}Repository{
+  //debe implementar la interfaz de repository
+}
+`;
+  fs.writeFileSync(sqlRepositoryFilePath, sqlRepositoryContent);
+}
+
+function prepararApplication(mainFolderPath){
+
+  const classFilePath = path.join(mainFolderPath, 'application', `${param1}.useCase.ts`);
+  const className = `${param1.charAt(0).toUpperCase() + param1.slice(1)}`;
+  const classContent = `import { I${className}Repository } from '../domain/${param1}.repository';
+export class ${className}UseCase {
+constructor(private readonly ${param1}Repository: I${className}Repository) {
+  // Constructor
+}
+
+// Methods
+}
+`;
+
+  fs.writeFileSync(classFilePath, classContent);
+}
+
+
+function printDependencyInjection(){
+  const name = `${param1.charAt(0).toUpperCase() + param1.slice(1)}`;
+  const content = `
+  container.register('EE.${name}.infrastructure.${name}Repository', ${name}Repository);
+  const ${name}Repo = container.get('EE.${name}.infrastructure.${name}Repository');
+  container.register('EE.${name}.application.${name}UseCase', ${name}UseCase).addArgument(${name}Repo);
+  const ${name}UseCase = container.get('EE.${name}.application.${name}UseCase');
+  container.register('EE.${name}.infrastructure.${name}Controller', ${name}Controller).addArgument(${name}UseCase);
+  const ${name}Controller = container.get('EE.${name}.infrastructure.${name}Controller');
+  `;
+  console.log("Dependency injection: ", content);
+  
+}

package/test/expediente-electronico/domain/expediente-electronico.class.test.ts

@@ -0,0 +1,186 @@
+import { Documento } from '../../../documentos/domain/documento.class';
+import { UUID } from '../../../documentos/domain/value-object/uuid';
+import { Estado } from '../../../estados/domain/estado.class';
+import { ExpedienteElectronico } from '../../../expediente-electronico/domain/expediente-electronico.class';
+import { expect, jest, test, describe, beforeEach, afterEach } from '@jest/globals';
+
+describe('class ExpedienteElectronico', () => {    
+
+    beforeEach(() => {
+        
+    });
+
+    test('Debe crear correctamente un ExpedienteElectronico', async () => {
+        const params = {
+            id: 1,
+            fechaAlta: new Date(),
+            fechaCierre: new Date(),
+            usuarioResponsable: {
+                uid: 'p001101',
+                nivel: ['NIVEL1', 'operador_REQ'],
+                nivelNumero: 1,
+                nombreCompleto: 'Fabian, Peralta',
+                cargo: 'ANALISTA',
+                unidad: '1238',
+                unidadSuperior: '1200',
+                gerencia: '1187',
+                nombreUnidad: 'Proyectos de desarrollo interno - 1238',
+                nombreGerencia: 'DESARROLLO DE SISTEMAS',
+                roles: ['consultar', 'crear'],
+                grupos: ['REQ']
+            },
+            titulo: 'Ejemplo de título',
+            descripcion: 'Ejemplo de descripción',
+            tipo: 'Ejemplo de tipo',
+            bitacora: [],
+            documentos: [new Documento(new UUID().getValue(),'nombreDoc', 'descripcion', '10')],
+            origen: '1234',
+            destino: '5678',
+            estado: Estado.estadoPorDefault()
+        };
+        
+          
+        const ee = new ExpedienteElectronico(params)
+        expect(ee).toBeInstanceOf(ExpedienteElectronico);   
+
+    });
+
+    test('Debe intentar crear un Expediente sin parametros y fallar', async () => {
+        const params = {};
+        expect(() => new ExpedienteElectronico(params)).toThrow();
+    });
+
+    test('Debe intentar crear un Expediente con documentos = string y fallar', async () => {
+        const params = {
+            id: 1,
+            fechaAlta: new Date(),
+            fechaCierre: new Date(),
+            usuarioResponsable: {
+                uid: 'p001101',
+                nivel: ['NIVEL1', 'operador_REQ'],
+                nivelNumero: 1,
+                nombreCompleto: 'Fabian, Peralta',
+                cargo: 'ANALISTA',
+                unidad: '1238',
+                unidadSuperior: '1200',
+                gerencia: '1187',
+                nombreUnidad: 'Proyectos de desarrollo interno - 1238',
+                nombreGerencia: 'DESARROLLO DE SISTEMAS',
+                roles: ['consultar', 'crear'],
+                grupos: ['REQ']
+            },
+            titulo: 'Ejemplo de título',
+            descripcion: 'Ejemplo de descripción',
+            tipo: 'Ejemplo de tipo',
+            bitacora: [],
+            documentos: 'documentos',
+            origen: '1234',
+            destino: '5678',
+            estado: Estado.estadoPorDefault()
+        };
+        expect(() => new ExpedienteElectronico(params)).toThrow(new Error('El atributo documentos debe ser un array'));
+    });
+
+    test('Debe intentar crear un Expediente con documentos = string[] y fallar', async () => {
+        const params = {
+            id: 1,
+            fechaAlta: new Date(),
+            fechaCierre: new Date(),
+            usuarioResponsable: {
+                uid: 'p001101',
+                nivel: ['NIVEL1', 'operador_REQ'],
+                nivelNumero: 1,
+                nombreCompleto: 'Fabian, Peralta',
+                cargo: 'ANALISTA',
+                unidad: '1238',
+                unidadSuperior: '1200',
+                gerencia: '1187',
+                nombreUnidad: 'Proyectos de desarrollo interno - 1238',
+                nombreGerencia: 'DESARROLLO DE SISTEMAS',
+                roles: ['consultar', 'crear'],
+                grupos: ['REQ']
+            },
+            titulo: 'Ejemplo de título',
+            descripcion: 'Ejemplo de descripción',
+            tipo: 'Ejemplo de tipo',
+            bitacora: [],
+            documentos: ['documentos'],
+            origen: '1234',
+            destino: '5678',
+            estado: Estado.estadoPorDefault()
+        };
+        expect(() => new ExpedienteElectronico(params)).toThrow(new Error('El atributo documentos debe ser un array de objetos de tipo Documento'));
+    });
+
+    test('Debe intentar crear un Expediente con documentos = []', async () => {
+        const params = {
+            id: 1,
+            fechaAlta: new Date(),
+            fechaCierre: new Date(),
+            usuarioResponsable: {
+                uid: 'p001101',
+                nivel: ['NIVEL1', 'operador_REQ'],
+                nivelNumero: 1,
+                nombreCompleto: 'Fabian, Peralta',
+                cargo: 'ANALISTA',
+                unidad: '1238',
+                unidadSuperior: '1200',
+                gerencia: '1187',
+                nombreUnidad: 'Proyectos de desarrollo interno - 1238',
+                nombreGerencia: 'DESARROLLO DE SISTEMAS',
+                roles: ['consultar', 'crear'],
+                grupos: ['REQ']
+            },
+            titulo: 'Ejemplo de título',
+            descripcion: 'Ejemplo de descripción',
+            tipo: 'Ejemplo de tipo',
+            bitacora: [],
+            documentos: [],
+            origen: '1234',
+            destino: '5678',
+            estado: Estado.estadoPorDefault()
+        };
+        const ee = new ExpedienteElectronico(params);
+        expect(ee).toBeInstanceOf(ExpedienteElectronico);
+    });
+
+    test('Debe crear un Expediente con documentos vacios y luego asignarle uno valido con el setter', async () => {
+        const params = {
+            id: 1,
+            fechaAlta: new Date(),
+            fechaCierre: new Date(),
+            usuarioResponsable: {
+                uid: 'p001101',
+                nivel: ['NIVEL1', 'operador_REQ'],
+                nivelNumero: 1,
+                nombreCompleto: 'Fabian, Peralta',
+                cargo: 'ANALISTA',
+                unidad: '1238',
+                unidadSuperior: '1200',
+                gerencia: '1187',
+                nombreUnidad: 'Proyectos de desarrollo interno - 1238',
+                nombreGerencia: 'DESARROLLO DE SISTEMAS',
+                roles: ['consultar', 'crear'],
+                grupos: ['REQ']
+            },
+            titulo: 'Ejemplo de título',
+            descripcion: 'Ejemplo de descripción',
+            tipo: 'Ejemplo de tipo',
+            bitacora: [],
+            documentos: [],
+            origen: '1234',
+            destino: '5678',
+            estado: Estado.estadoPorDefault()
+        };
+        const ee = new ExpedienteElectronico(params);
+        const doc = new Documento('','nombreDoc', 'descripcion', '10')
+        const docs:Documento[] = [new Documento('','nombreDoc', 'descripcion', '10')];
+        ee.setDocumentos(docs);
+        const a = ee.getDocumentos();
+        const uuid = new UUID().getValue();
+        console.log("uuid: ", uuid);
+        UUID.validate(uuid)
+
+        expect(a).toEqual(docs);
+    });
+});