fpavon-ee-shared 1.0.0

package/dist/estados/domain/flujos.repository.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/estados/infrastructure/controller/flujos.controller.js

@@ -0,0 +1,34 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlujosController = void 0;
+class FlujosController {
+    constructor(flujosUseCase) {
+        this.flujosUseCase = flujosUseCase;
+        this.getFlujoByModulo = (req, res) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const modulo = req.params.modulo;
+                const flujo = yield this.flujosUseCase.getFlujoByModulo(modulo);
+                if (flujo) {
+                    res.status(200).json(flujo);
+                }
+                else {
+                    res.status(404).send('Flujo no encontrado para el módulo especificado');
+                }
+            }
+            catch (error) {
+                console.error("FlujosController.getFlujoByModulo", error);
+                res.status(500).send('Error interno del servidor al obtener el flujo por módulo');
+            }
+        });
+    }
+}
+exports.FlujosController = FlujosController;

package/dist/estados/infrastructure/repositories/flujos.sql.repository.js

@@ -0,0 +1,36 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlujosRepository = void 0;
+const connection_sql_1 = require("../../../infrastructure/bd/connection.sql");
+class FlujosRepository {
+    insert(flujo) {
+        throw new Error("Method not implemented.");
+    }
+    selectByModulo(modulo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const query = `SELECT * FROM Flujos WHERE modulo = '${modulo}'`;
+            // console.log("QUERY", query)
+            return yield (0, connection_sql_1.getConnection)(query).then(resp => {
+                let flujo = JSON.parse(resp.recordset[0].flujo);
+                return flujo;
+            });
+        });
+    }
+    update(flujo) {
+        throw new Error("Method not implemented.");
+    }
+    delete(modulo) {
+        throw new Error("Method not implemented.");
+    }
+    delete2() { }
+}
+exports.FlujosRepository = FlujosRepository;

package/dist/estados/infrastructure/routes/flujo.route.js

@@ -0,0 +1,50 @@
+"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)();
+/**
+ * Iniciar Repository
+ */
+const flujo = dependency_injection_1.default.get('EE.Flujos.infrastructure.FlujosController');
+/**
+ * Routes
+ */
+/**
+* @openapi
+* /caratulas:
+*   post:
+*     summary: Crea una nueva caratula y genera el pdf del formulario correspondiente
+*     description: Crea una nueva caratula y genera el pdf del formulario correspondiente
+*     operationId: post caratulas
+*     tags:
+*       - Tramites
+*     requestBody:
+*       description: Marcadores del pdf a generar y metadatos de una caratula.
+*       required: true
+*       content:
+*         application/json:
+*           type: object
+*           schema:
+*             properties:
+*               marcadores:
+*                 type: object
+*               caratula:
+*                 type: object
+*     responses:
+*       '200':
+*         content-disposition: attachment;
+*         description: Se creo una nueva caratula.
+*       '400':
+*         description: Error
+*       '500':
+*         description: Error interno
+*     security:
+*       - Authentication: []
+*/
+route.get('/flujo/:modulo', middleware_auth_1.validarToken, flujo.getFlujoByModulo);
+exports.default = route;

package/dist/expediente-electronico/application/expediente-electronico.useCase.js

@@ -0,0 +1,171 @@
+"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.ExpedienteElectronicoUseCase = void 0;
+const digitalSignature_useCase_1 = require("../../digitalSignature/application/digitalSignature.useCase");
+const pagination_sql_1 = require("../../infrastructure/bd/pagination.sql");
+const middleware_auth_1 = require("../../infrastructure/middlewares/middleware.auth");
+const notas_class_1 = require("../domain/value-object/notas.class");
+const axios = require('axios');
+const fs = __importStar(require("fs"));
+class ExpedienteElectronicoUseCase {
+    constructor(expedienteRepo) {
+        this.expedienteRepo = expedienteRepo;
+        this.getExpedienteByIdUseCase = (id) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.expedienteRepo.getExpedienteById(id);
+                return response;
+            }
+            catch (error) {
+                console.error("Error ExpedienteUseCase.getExpedienteByIdUseCase=>", error);
+                throw error;
+            }
+        });
+        this.getExpedienteByIdCodigoInterno = (codigoInterno) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.expedienteRepo.getExpedienteByCodigoInterno(codigoInterno);
+                return response;
+            }
+            catch (error) {
+                console.error("Error ExpedienteUseCase.getExpedienteByCodigoInternoUseCase=>", error);
+                throw error;
+            }
+        });
+        this.getExpUseCase = (usuario, page, limit, estado, filtro) => __awaiter(this, void 0, void 0, function* () {
+            const unidades = yield (0, middleware_auth_1.getChildrenLabelNumbers)(usuario.unidad);
+            usuario.unidades = unidades;
+            const pagination = (0, pagination_sql_1.getPagination)(page, limit);
+            let response = yield this.expedienteRepo.getExpRepo(usuario, pagination, estado, filtro);
+            return response;
+        });
+        this.getExpSinPaginacionUseCase = (usuario, estado, filtros) => __awaiter(this, void 0, void 0, function* () {
+            const unidades = yield (0, middleware_auth_1.getChildrenLabelNumbers)(usuario.unidad);
+            usuario.unidades = unidades;
+            let response = yield this.expedienteRepo.getExpSinPaginacionRepo(usuario, estado, filtros);
+            return response;
+        });
+        this.getExpPendientesUseCase = (usuario, page, limit) => __awaiter(this, void 0, void 0, function* () {
+            const unidades = yield (0, middleware_auth_1.getChildrenLabelNumbers)(usuario.unidad);
+            usuario.unidades = unidades;
+            const pagination = (0, pagination_sql_1.getPagination)(page, limit);
+            let response = yield this.expedienteRepo.getExpPendientesRepo(usuario, pagination);
+            return response;
+        });
+        this.getExpPendientesSinPaginadoUseCase = (usuario) => __awaiter(this, void 0, void 0, function* () {
+            const unidades = yield (0, middleware_auth_1.getChildrenLabelNumbers)(usuario.unidad);
+            usuario.unidades = unidades;
+            let response = yield this.expedienteRepo.getExpPendientesSinPaginacionRepo(usuario);
+            return response;
+        });
+        this.getExpRechazadosUseCase = (usuario, page, limit) => __awaiter(this, void 0, void 0, function* () {
+            const unidades = yield (0, middleware_auth_1.getChildrenLabelNumbers)(usuario.unidad);
+            usuario.unidades = unidades;
+            const pagination = (0, pagination_sql_1.getPagination)(page, limit);
+            let response = yield this.expedienteRepo.getExpRechazadosRepo(usuario, pagination);
+            return response;
+        });
+        this.getExpAprobadosUseCase = (usuario, page, limit) => __awaiter(this, void 0, void 0, function* () {
+            const unidades = yield (0, middleware_auth_1.getChildrenLabelNumbers)(usuario.unidad);
+            usuario.unidades = unidades;
+            const pagination = (0, pagination_sql_1.getPagination)(page, limit);
+            let response = yield this.expedienteRepo.getExpAprobadosRepo(usuario, pagination);
+            return response;
+        });
+        this.getExpTotalesUseCase = (usuario) => __awaiter(this, void 0, void 0, function* () {
+            const unidades = yield (0, middleware_auth_1.getChildrenLabelNumbers)(usuario.unidad);
+            usuario.unidades = unidades;
+            let response = yield this.expedienteRepo.getExpTotalesRepo(usuario);
+            return response;
+        });
+        this.getExpCantidadPendientesUseCase = (usuario) => __awaiter(this, void 0, void 0, function* () {
+            const unidades = yield (0, middleware_auth_1.getChildrenLabelNumbers)(usuario.unidad);
+            usuario.unidades = unidades;
+            let response = yield this.expedienteRepo.getExpCantidadPendientesRepo(usuario);
+            return response;
+        });
+        this.getExpCantidadAprobadosUseCase = (usuario) => __awaiter(this, void 0, void 0, function* () {
+            const unidades = yield (0, middleware_auth_1.getChildrenLabelNumbers)(usuario.unidad);
+            usuario.unidades = unidades;
+            let response = yield this.expedienteRepo.getExpCantidadAprobadosRepo(usuario);
+            return response;
+        });
+        this.getExpCantidadRechazadosUseCase = (usuario) => __awaiter(this, void 0, void 0, function* () {
+            const unidades = yield (0, middleware_auth_1.getChildrenLabelNumbers)(usuario.unidad);
+            usuario.unidades = unidades;
+            let response = yield this.expedienteRepo.getExpCantidadRechazadosRepo(usuario);
+            return response;
+        });
+        this.guardarNotaUseCase = (idExpediente, notaParams, usuario) => __awaiter(this, void 0, void 0, function* () {
+            let expediente = yield this.expedienteRepo.getExpedienteById(idExpediente);
+            if (!expediente) {
+                throw new Error(`No existe la expediente con id: ${idExpediente}`);
+            }
+            if (!notaParams.unidades.includes(usuario.unidad)) {
+                notaParams.unidades.push(usuario.unidad);
+            }
+            if (usuario.unidad !== usuario.gerencia && !notaParams.unidades.includes(usuario.gerencia)) {
+                notaParams.unidades.push(usuario.gerencia);
+            }
+            let nuevaNota = new notas_class_1.Nota(notaParams, usuario);
+            expediente.notas.push(nuevaNota);
+            return yield this.expedienteRepo.updateExpediente(idExpediente, expediente);
+        });
+        this.leerNotaUseCase = (idExpediente, usuario) => __awaiter(this, void 0, void 0, function* () {
+            let expediente = yield this.expedienteRepo.getExpedienteById(idExpediente);
+            if (!expediente) {
+                throw new Error(`No existe expediente con id: ${idExpediente}`);
+            }
+            expediente.notas.forEach(nota => {
+                nota.marcarNotaComoLeida(usuario);
+            });
+            return yield this.expedienteRepo.updateExpediente(idExpediente, expediente);
+        });
+        this.getAllUnidades = () => __awaiter(this, void 0, void 0, function* () {
+            //SE REEMPLAZA POR API CON LA GERENCIA DE DIRECTORIO
+            // let response = await this.expedienteRepo.getUnidadesPref();
+            // return response;    
+            const unidades = yield (0, middleware_auth_1.getChildrenLabelNumbers)('0900');
+            return unidades;
+        });
+        this.getUnidadesByUnidad = (unidad) => __awaiter(this, void 0, void 0, function* () {
+            const unidades = yield (0, middleware_auth_1.getChildrenLabelNumbers)(unidad);
+            return unidades;
+        });
+        this.firmarDocumentoUseCase = (documento, usuario, firma, clave) => __awaiter(this, void 0, void 0, function* () {
+            let buffer = fs.readFileSync(documento.path);
+            return yield (0, digitalSignature_useCase_1.firmarDocumento)(buffer, usuario, firma, clave);
+        });
+    }
+}
+exports.ExpedienteElectronicoUseCase = ExpedienteElectronicoUseCase;

package/dist/expediente-electronico/domain/expediente-electronico.class.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpedienteElectronico = void 0;
+const documento_class_1 = require("../../documentos/domain/documento.class");
+const estado_class_1 = require("../../estados/domain/estado.class");
+const limited_string_class_1 = require("./value-object/limited-string.class");
+const notas_class_1 = require("./value-object/notas.class");
+class ExpedienteElectronico {
+    constructor(params) {
+        if (params) {
+            this.id = params.id;
+            this.fechaAlta = params.fechaAlta;
+            this.titulo = new limited_string_class_1.LimitedString(params.titulo, 255).getValue();
+            this.descripcion = new limited_string_class_1.LimitedString(params.descripcion, 1000).getValue();
+            this.tipo = params.tipo;
+            this.codigoInterno = params.codigoInterno;
+            this.fechaCierre = params.fechaCierre;
+            if (params.usuarioResponsable) {
+                this.usuarioResponsable = params.usuarioResponsable;
+            }
+            else {
+                throw new Error("usuarioResponsable debe estar definido");
+            }
+            this.setEstado(params.estado);
+            this.bitacora = this.asignarBitacora(params.bitacora);
+            let notas = [];
+            if (params.notas) {
+                params.notas.forEach(nota => {
+                    notas.push(new notas_class_1.Nota(nota, nota.usuarioResponsable));
+                });
+            }
+            this.notas = notas;
+            if (params.documentos)
+                this.setDocumentos(params.documentos);
+            else
+                this.documentos = [];
+            this.origen = new limited_string_class_1.LimitedString(params.origen, 4).getValue();
+            ;
+            this.destino = new limited_string_class_1.LimitedString(params.destino, 4).getValue();
+            ;
+            if (params.extras)
+                this.extras = params.extras;
+            else
+                this.extras = {};
+        }
+    }
+    asignarBitacora(bitacora) {
+        if (bitacora) {
+            if (Array.isArray(bitacora)) {
+                return bitacora;
+            }
+            else {
+                throw new Error('El atributo bitacora debe ser un array de objetos.');
+            }
+        }
+        else {
+            return [];
+        }
+    }
+    static fromRecordset(recordset) {
+        if (!recordset) {
+            throw new Error("comprasContrataciones.fromRecordset recordset es undefined");
+        }
+        let expediente = recordset;
+        expediente.bitacora = JSON.parse(expediente.bitacora);
+        expediente.notas = expediente.notas ? JSON.parse(expediente.notas) : [];
+        expediente.documentos = JSON.parse(expediente.documentos);
+        expediente.documentos.forEach((doc, index) => {
+            // Verificamos si existe el campo 'estadoWorkflow' en el documento
+            const estadoWorkflow = doc.estadoWorkflow;
+            // Verificar si doc.extras existe, y si no, crear un objeto vacío
+            const extras = doc.extras || {};
+            // Creamos la instancia de DocumentoCC con estadoWorkflow incluido
+            const documento = new documento_class_1.Documento(doc.uuid, doc.nombre, doc.descripcion, doc.size, {}, doc.firmado, estadoWorkflow);
+            expediente.documentos[index] = documento;
+        });
+        expediente.extras = JSON.parse(expediente.extras);
+        expediente.usuarioResponsable = JSON.parse(expediente.usuarioResponsable);
+        expediente.estado = JSON.parse(expediente.estado);
+        expediente.estado = new estado_class_1.Estado(expediente.estado);
+        let exp = Object.assign(expediente, expediente.extras);
+        delete exp.extras;
+        return new ExpedienteElectronico(exp);
+    }
+    /**
+     * Setea un estado al expediente. Si el estado es undefined, se setea un estado por default.
+     * @param estado El estado que se quiere setear al expediente
+     */
+    setEstado(estado) {
+        if (estado) {
+            if (estado instanceof estado_class_1.Estado) {
+                this.estado = estado;
+            }
+            else {
+                this.estado = new estado_class_1.Estado(estado);
+            }
+        }
+        else {
+            this.estado = estado_class_1.Estado.estadoPorDefault();
+        }
+    }
+    /**
+     *
+     * @returns Devuelve el estado actual del expediente.
+     */
+    getEstado() {
+        return this.estado;
+    }
+    /**
+     * Setea un arreglo de documentos al expediente
+     * @param documentos El nuevo arreglo de documentos que se quiere setear al expediente
+     */
+    setDocumentos(documentos) {
+        if (Array.isArray(documentos)) {
+            if (documentos.every(doc => doc instanceof documento_class_1.Documento)) {
+                this.documentos = documentos;
+            }
+            else {
+                throw new Error('El atributo documentos debe ser un array de objetos de tipo Documento');
+            }
+        }
+        else {
+            throw new Error('El atributo documentos debe ser un array');
+        }
+    }
+    /**
+     * Agrega un nuevo documento al arreglo de documentos del expediente.
+     * @param documento El documento que se quiere agregar al arreglo de documentos del expediente.
+     */
+    pushDocumento(documento) {
+        if (documento instanceof documento_class_1.Documento) {
+            this.documentos.push(documento);
+        }
+        else {
+            throw new Error('El atributo documento debe ser de tipo Documento');
+        }
+    }
+    /**
+     * Reemplaza el documento que esta en el indice indicado por el que se envia como parametro.
+     * @param index: Indice del docuemento a reemplazar.
+     * @param documento El documento que reemplaza al anterior.
+     */
+    modificarDocumento(index, documento) {
+        if (documento instanceof documento_class_1.Documento) {
+            this.documentos[index] = documento;
+        }
+        else {
+            throw new Error('El atributo documento debe ser de tipo Documento');
+        }
+    }
+    getDocumentos() {
+        return this.documentos;
+    }
+    avanzarEstado(usuario, flujo) {
+        this.setEstado(this.estado.autorizar(usuario, flujo));
+    }
+    updateFlagExito(exito) {
+        this.estado.setFlagExito(exito);
+    }
+    supervisar(usuario, flujo) {
+        this.setEstado(this.estado.supervisar(usuario, flujo));
+    }
+    observar(usuario, flujo) {
+        this.setEstado(this.estado.observar(usuario, flujo));
+    }
+    rechazar(usuario, flujo) {
+        this.setEstado(this.estado.rechazar(usuario, flujo));
+    }
+    cancelar(usuario, flujo) {
+        this.setEstado(this.estado.cancelar(usuario, flujo));
+    }
+    devolver(usuario, flujo) {
+        this.setEstado(this.estado.devolver(usuario, flujo));
+    }
+    firmar(usuario, flujo) {
+        this.setEstado(this.estado.firmar(usuario, flujo));
+    }
+    getAtributos() {
+        return this.extras;
+    }
+    static transferirExpediente(expediente, oficinaResponsable) {
+        const unidad = oficinaResponsable.split("-");
+        let result = unidad[1].replace(/\s/g, "");
+        if (!expediente.getEstado().esVisiblePor.includes(result)) {
+            expediente.getEstado().esVisiblePor.push(result);
+        }
+        return expediente.getEstado();
+    }
+}
+exports.ExpedienteElectronico = ExpedienteElectronico;

package/dist/expediente-electronico/domain/expediente-electronico.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/expediente-electronico/domain/expediente-electronico.repository.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/expediente-electronico/domain/value-object/limited-string.class.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LimitedString = void 0;
+class LimitedString {
+    constructor(value, maxLength) {
+        if (value === null || value === undefined) {
+            throw new Error('Value must be defined');
+        }
+        if (value.length > maxLength) {
+            throw new Error(`El valor debe tener menos de ${maxLength} caracteres.`);
+        }
+        this.value = value;
+        this.maxLength = maxLength;
+    }
+    getValue() {
+        return this.value;
+    }
+}
+exports.LimitedString = LimitedString;

package/dist/expediente-electronico/domain/value-object/notas.class.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Nota = void 0;
+const moment_1 = __importDefault(require("moment"));
+class Nota {
+    constructor(params, usuario) {
+        this.title = params.title;
+        this.importance = params.importance;
+        this.message = params.message;
+        this.unidades = params.unidades;
+        this.fechaHora = (0, moment_1.default)().locale('es').format('LLL'),
+            this.leida = false;
+        this.leidaPor = params.leidaPor ? params.leidaPor : [];
+        this.usuarioResponsable = {
+            nombreCompleto: usuario.nombreCompleto,
+            unidad: usuario.unidad,
+            uid: usuario.uid
+        };
+    }
+    marcarNotaComoLeida(usuario) {
+        if (!this.leidaPor) {
+            this.leidaPor = [];
+        }
+        let leidoPorUnidad = this.leidaPor.find(leido => leido.unidad === usuario.unidad);
+        if (this.unidades.includes(usuario.unidad)) {
+            this.leida = true;
+            if (!leidoPorUnidad) {
+                this.leidaPor.push({ unidad: usuario.unidad, afiliados: [usuario.uid] });
+            }
+            else {
+                if (!leidoPorUnidad.afiliados.includes(usuario.uid)) {
+                    leidoPorUnidad.afiliados.push(usuario.uid);
+                }
+            }
+        }
+    }
+}
+exports.Nota = Nota;