general-library-union 3.2.47 → 3.2.49

package/esm2022/src/app/core/servicios/cargar-control-funcionalidad.service.mjs

@@ -0,0 +1,54 @@
+import { Injectable } from '@angular/core';
+import { catchError, map } from 'rxjs';
+import { AuthenticationError } from '../errores/authentication.error';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./storage.service";
+import * as i3 from "./utils.service";
+export class CargarControlFuncionalidadService {
+    httpClient;
+    storageService;
+    utilsService;
+    constructor(httpClient, storageService, utilsService) {
+        this.httpClient = httpClient;
+        this.storageService = storageService;
+        this.utilsService = utilsService;
+    }
+    cargarFuncionalidad(rol, url, headers) {
+        return this.httpClient.post(url, rol, { headers }).pipe(map((data) => {
+            const controlFuncionalidades = data?.controlFuncionalidades;
+            this.storageService.setItem('controlFuncionalidades', controlFuncionalidades);
+            return null;
+        }), catchError((error) => {
+            if (error.status >= 400) {
+                throw new AuthenticationError('Error consultando control de funcionalidades.');
+            }
+            throw error;
+        }));
+    }
+    getControlFuncionalidad(valor) {
+        if (this.storageService.getItem('controlFuncionalidades') != null) {
+            let listaFuncionalidades = this.storageService.getItem('controlFuncionalidades');
+            if (listaFuncionalidades !== null) {
+                const funcionalidades = listaFuncionalidades.split(',');
+                return funcionalidades.includes(valor);
+            }
+        }
+        return false;
+    }
+    /**
+     * Borra controles de funcionalidad en la sesión
+     */
+    eliminarFuncionalidades() {
+        this.storageService.removeItem('controlFuncionalidades');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: CargarControlFuncionalidadService, deps: [{ token: i1.HttpClient }, { token: i2.StorageService }, { token: i3.UtilsService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: CargarControlFuncionalidadService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: CargarControlFuncionalidadService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.StorageService }, { type: i3.UtilsService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/app/core/servicios/click-posicion.service.mjs

@@ -0,0 +1,20 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ClickPosicionService {
+    lastClickPosition = { x: 0, y: 0 };
+    setClickPosition(x, y) {
+        this.lastClickPosition = { x, y };
+    }
+    getClickPosition() {
+        return this.lastClickPosition;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: ClickPosicionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: ClickPosicionService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: ClickPosicionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpY2stcG9zaWNpb24uc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvY29yZS9zZXJ2aWNpb3MvY2xpY2stcG9zaWNpb24uc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUszQyxNQUFNLE9BQU8sb0JBQW9CO0lBQ3ZCLGlCQUFpQixHQUFHLEVBQUUsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDLEVBQUUsQ0FBQyxFQUFFLENBQUM7SUFFM0MsZ0JBQWdCLENBQUMsQ0FBUyxFQUFFLENBQVM7UUFDbkMsSUFBSSxDQUFDLGlCQUFpQixHQUFHLEVBQUUsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUFDO0lBQ3BDLENBQUM7SUFFRCxnQkFBZ0I7UUFDZCxPQUFPLElBQUksQ0FBQyxpQkFBaUIsQ0FBQztJQUNoQyxDQUFDO3VHQVRVLG9CQUFvQjsyR0FBcEIsb0JBQW9CLGNBRm5CLE1BQU07OzJGQUVQLG9CQUFvQjtrQkFIaEMsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcblxyXG5ASW5qZWN0YWJsZSh7XHJcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBDbGlja1Bvc2ljaW9uU2VydmljZSB7XHJcbiAgcHJpdmF0ZSBsYXN0Q2xpY2tQb3NpdGlvbiA9IHsgeDogMCwgeTogMCB9O1xyXG5cclxuICBzZXRDbGlja1Bvc2l0aW9uKHg6IG51bWJlciwgeTogbnVtYmVyKTogdm9pZCB7XHJcbiAgICB0aGlzLmxhc3RDbGlja1Bvc2l0aW9uID0geyB4LCB5IH07XHJcbiAgfVxyXG5cclxuICBnZXRDbGlja1Bvc2l0aW9uKCk6IHsgeDogbnVtYmVyLCB5OiBudW1iZXIgfSB7XHJcbiAgICByZXR1cm4gdGhpcy5sYXN0Q2xpY2tQb3NpdGlvbjtcclxuICB9XHJcbn1cclxuIl19

package/esm2022/src/app/core/servicios/data-exporter-table.utils.mjs

@@ -0,0 +1,64 @@
+import jsPDF from "jspdf";
+import "jspdf-autotable";
+import * as FileSaver from 'file-saver';
+import { Workbook } from 'exceljs';
+export class DataExporter {
+    constructor() { }
+    exportPdf(lista, exportColumns, nombreArchivo) {
+        console.log(lista);
+        const doc = new jsPDF('l', 'pt');
+        doc['autoTable'](exportColumns, lista);
+        doc.save(nombreArchivo + ".pdf");
+    }
+    async exportExcel(lista, nombreArchivo) {
+        const workbook = new Workbook();
+        const worksheet = workbook.addWorksheet('data');
+        worksheet.columns = Object.keys(lista[0]).map(key => ({ header: key, key }));
+        lista.forEach(item => {
+            worksheet.addRow(item);
+        });
+        const buffer = await workbook.xlsx.writeBuffer();
+        this.saveAsExcelFile(buffer, nombreArchivo);
+    }
+    async exportExcelColumnas(lista, nombreArchivo, columnas, nombreHoja) {
+        const workbook = new Workbook();
+        const worksheet = workbook.addWorksheet(nombreHoja ? nombreHoja : 'data');
+        worksheet.columns = columnas.map(col => ({ header: col, key: col }));
+        lista.forEach(item => {
+            const filteredItem = {};
+            columnas.forEach(col => {
+                filteredItem[col] = item[col];
+            });
+            worksheet.addRow(filteredItem);
+        });
+        const buffer = await workbook.xlsx.writeBuffer();
+        this.saveAsExcelFile(buffer, nombreArchivo);
+    }
+    saveAsExcelFile(buffer, fileName) {
+        const EXCEL_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;charset=UTF-8';
+        const EXCEL_EXTENSION = '.xlsx';
+        const data = new Blob([buffer], { type: EXCEL_TYPE });
+        FileSaver.saveAs(data, `${fileName}${EXCEL_EXTENSION}`);
+    }
+    exportCSV(lista, columnas, nombreArchivo) {
+        const listaParaExportar = lista;
+        const csvContent = this.convertirAFormatoCSV(listaParaExportar, columnas);
+        this.descargarArchivoCSV(csvContent, nombreArchivo);
+    }
+    convertirAFormatoCSV(data, columns) {
+        const csvHeader = columns.join(',') + '\n';
+        const csvRows = data.map(item => columns.map(col => item[col]).join(',')).join('\n');
+        return csvHeader + csvRows + '\n';
+    }
+    descargarArchivoCSV(csvContent, nombreArchivo) {
+        const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });
+        const url = window.URL.createObjectURL(blob);
+        const link = document.createElement('a');
+        link.href = url;
+        link.setAttribute('download', `${nombreArchivo}.csv`);
+        document.body.appendChild(link);
+        link.click();
+        document.body.removeChild(link);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-exporter-table.utils.js","sourceRoot":"","sources":["../../../../../../src/app/core/servicios/data-exporter-table.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import jsPDF from \"jspdf\";\r\nimport \"jspdf-autotable\";\r\nimport * as FileSaver from 'file-saver';\r\nimport { Workbook } from 'exceljs';\r\n\r\nexport class DataExporter {\r\n\r\n    constructor() { }\r\n\r\n    exportPdf(lista: any[], exportColumns: any[], nombreArchivo: string) {\r\n        console.log(lista);\r\n        const doc = new jsPDF('l', 'pt');\r\n        doc['autoTable'](exportColumns, lista);\r\n        doc.save(nombreArchivo + \".pdf\");\r\n    }\r\n\r\n    async exportExcel(lista: any[], nombreArchivo: string) {\r\n        const workbook = new Workbook();\r\n        const worksheet = workbook.addWorksheet('data');\r\n\r\n        worksheet.columns = Object.keys(lista[0]).map(key => ({ header: key, key }));\r\n\r\n        lista.forEach(item => {\r\n            worksheet.addRow(item);\r\n        });\r\n\r\n        const buffer = await workbook.xlsx.writeBuffer();\r\n        this.saveAsExcelFile(buffer, nombreArchivo);\r\n    }\r\n\r\n    async exportExcelColumnas(lista: any[], nombreArchivo: string, columnas: string[], nombreHoja?: string) {\r\n        const workbook = new Workbook();\r\n        const worksheet = workbook.addWorksheet(nombreHoja ? nombreHoja : 'data');\r\n\r\n        worksheet.columns = columnas.map(col => ({ header: col, key: col }));\r\n\r\n        lista.forEach(item => {\r\n            const filteredItem: any = {};\r\n            columnas.forEach(col => {\r\n                filteredItem[col] = item[col];\r\n            });\r\n            worksheet.addRow(filteredItem);\r\n        });\r\n\r\n        const buffer = await workbook.xlsx.writeBuffer();\r\n        this.saveAsExcelFile(buffer, nombreArchivo);\r\n    }\r\n\r\n    saveAsExcelFile(buffer: any, fileName: string): void {\r\n        const EXCEL_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;charset=UTF-8';\r\n        const EXCEL_EXTENSION = '.xlsx';\r\n        const data: Blob = new Blob([buffer], { type: EXCEL_TYPE });\r\n        FileSaver.saveAs(data, `${fileName}${EXCEL_EXTENSION}`);\r\n    }\r\n\r\n    exportCSV(lista: any[], columnas: string[], nombreArchivo: string) {\r\n        const listaParaExportar = lista;\r\n        const csvContent = this.convertirAFormatoCSV(listaParaExportar, columnas );\r\n        this.descargarArchivoCSV(csvContent, nombreArchivo);\r\n    }\r\n\r\n    convertirAFormatoCSV(data: any[], columns: string[]) {\r\n        const csvHeader = columns.join(',') + '\\n';\r\n        const csvRows = data.map(item => columns.map(col => item[col]).join(',')).join('\\n');\r\n        return csvHeader + csvRows + '\\n';\r\n    }\r\n\r\n    descargarArchivoCSV(csvContent: any, nombreArchivo: string) {\r\n        const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });\r\n        const url = window.URL.createObjectURL(blob);\r\n        const link = document.createElement('a');\r\n        link.href = url;\r\n        link.setAttribute('download', `${nombreArchivo}.csv`);\r\n        document.body.appendChild(link);\r\n        link.click();\r\n        document.body.removeChild(link);\r\n    }\r\n}\r\n"]}

package/esm2022/src/app/core/servicios/error-interceptor.service.mjs

@@ -0,0 +1,214 @@
+import { Injectable } from '@angular/core';
+import Swal from 'sweetalert2';
+import * as i0 from "@angular/core";
+import * as i1 from "./utils.service";
+import * as i2 from "@angular/router";
+import * as i3 from "./auth.service";
+import * as i4 from "./storage.service";
+export class ErrorIntecertorService {
+    utilsService;
+    route;
+    authService;
+    storageService;
+    constructor(utilsService, route, authService, storageService) {
+        this.utilsService = utilsService;
+        this.route = route;
+        this.authService = authService;
+        this.storageService = storageService;
+    }
+    /**
+    * Muestra un mensaje de error según el tipo de error proporcionado.
+    * @param errorJson El objeto JSON que representa el error.
+    */
+    showError(errorJson) {
+        const error = JSON.parse(errorJson);
+        if (error.codigo == 'UNI-DB-002' || error.codigo == 'UNI-DB-003'
+            || error.mensaje?.includes('Se produjo un error de red') || error.mensaje?.includes('El servicio no está disponible')
+            || error.mensaje?.includes('Conexion no valida')) {
+            this.storageService.setItem('mensaje_notfound', error.mensaje);
+            this.storageService.setItem('url_regresar', window.location.href);
+            window.location.href = window.location.origin + '/' + this.utilsService.obtenerBase() + '/not-found';
+            //this.route.navigate([this.utilsService.obtenerBase()+'/not-found']);
+            return;
+        }
+        if (error.tipo === 'INF') {
+            this.showInfo(error.mensaje, error.codigo);
+        }
+        else if (error.tipo === 'WAR') {
+            this.showWarning(error.mensaje, error.codigo, error.causa, error.accion, error.traza);
+        }
+        else if (error.tipo === 'ERR') {
+            this.showErrorDetails(error.mensaje ? error.mensaje : '', error.codigo, error.traza, error.causa);
+        }
+    }
+    /**
+     * Muestra un mensaje de información con el código.
+     * @param mensaje El mensaje a mostrar.
+     * @param codigo El código asociado al mensaje.
+     */
+    showInfo(mensaje, codigo) {
+        Swal.fire({
+            background: '#f7bfbf',
+            position: 'top-end',
+            html: '<div style="text-align: left;">' +
+                '<p style="text-align: left;"><b>Código:</b> ' + codigo + '</p>' +
+                '<p style="text-align: left; font-size:12px">' + mensaje + '</p>' +
+                '</div>',
+            showConfirmButton: false,
+            timer: 5500,
+            color: '#ff0000'
+        }).then((result) => {
+            if (result.isConfirmed) {
+                this.utilsService.sleep(500).then(data => {
+                    this.utilsService.resizeWindowIFrame();
+                });
+            }
+            else if (result.dismiss === Swal.DismissReason.cancel) {
+                this.utilsService.sleep(500).then(data => {
+                    this.utilsService.resizeWindowIFrame();
+                });
+            }
+            else if (result.dismiss === Swal.DismissReason.close) {
+                this.utilsService.sleep(500).then(data => {
+                    this.utilsService.resizeWindowIFrame();
+                });
+            }
+        });
+        this.utilsService.sleep(500).then(data => {
+            this.utilsService.resizeWindowIFrame();
+        });
+    }
+    /**
+     * Muestra una advertencia con detalles adicionales como causa, acción y traza.
+     * @param mensaje El mensaje a mostrar.
+     * @param codigo El código asociado al mensaje.
+     * @param causa La causa del error.
+     * @param accion La acción recomendada.
+     * @param traza La traza del error.
+     */
+    showWarning(mensaje, codigo, causa, accion, traza) {
+        let contenidoHtml = `<p class="msjError">${mensaje}</p>`;
+        contenidoHtml = contenidoHtml + (this.utilsService.validarCampoObligatorio(codigo) ? `<p class="cauError"><b>Código:</b> ${codigo}</p>` : ' ');
+        contenidoHtml = contenidoHtml + (this.utilsService.validarCampoObligatorio(causa) ? `<p class="cauError"><b>Causa:</b> ${causa}</p>` : ' ');
+        contenidoHtml = contenidoHtml + (this.utilsService.validarCampoObligatorio(accion) ? `<p class="cauError"><b>Acción Recomendada:</b> ${accion}</p>` : ' ');
+        let contenidoPlusHtml = `<p class="msjError">${mensaje.slice(0, 100)}</p><button id="verMasButton">Ver más</button> <button id="Ok">OK</button>`;
+        Swal.fire({
+            title: '<span style="color: var(--color-700);">' + 'Advertencia' + '</span>',
+            html: contenidoHtml,
+            icon: 'warning',
+            showCancelButton: false,
+            showCloseButton: true,
+            showConfirmButton: true,
+            didOpen: () => {
+                const OkButton = document.getElementById('Ok');
+                OkButton.classList.add('swal2-styled', 'swal2-cancel', 'btn-ok');
+                OkButton.addEventListener('click', () => {
+                    Swal.close();
+                    this.utilsService.sleep(500).then(data => {
+                        this.utilsService.resizeWindowIFrame();
+                    });
+                });
+            },
+        }).then((result) => {
+            if (result.isConfirmed) {
+                this.utilsService.sleep(500).then(data => {
+                    this.utilsService.resizeWindowIFrame();
+                });
+            }
+            else if (result.dismiss === Swal.DismissReason.cancel) {
+                this.utilsService.sleep(500).then(data => {
+                    this.utilsService.resizeWindowIFrame();
+                });
+            }
+            else if (result.dismiss === Swal.DismissReason.close) {
+                this.utilsService.sleep(500).then(data => {
+                    this.utilsService.resizeWindowIFrame();
+                });
+            }
+        });
+        this.utilsService.sleep(500).then(data => {
+            this.utilsService.resizeWindowIFrame();
+        });
+    }
+    /**
+     * Muestra un mensaje de error con detalles adicionales como el código de error y la traza.
+     * @param mensaje El mensaje a mostrar.
+     * @param errorCode El código de error asociado al mensaje.
+     * @param traza La traza del error.
+     */
+    showErrorDetails(mensaje, codigo, traza, causa) {
+        let contenidoHtml = `<p class="msjError">${mensaje}</p><p class="codError"><b>Código:</b> ${codigo}</p><p class="traError"><b>Traza:</b> ${traza}</p><p class="cauError">`;
+        if (causa != null && causa != undefined) {
+            contenidoHtml = `<p class="msjError">${mensaje}</p><p class="codError"><b>Código:</b> ${codigo}</p><p class="traError"><b>Traza:</b> ${traza}</p><p class="cauError"><b>Causa:</b> ${causa}</p>`;
+        }
+        let contenidoPlusHtml = `<p class="msjError">${mensaje.slice(0, 100)}</p><button id="verMasButton">Ver más</button> <button class="btn-ok" id="Ok">OK</button>`;
+        Swal.fire({
+            title: '<span style="color: var(--color-700);">' + 'Error' + '</span>',
+            html: (mensaje.length + traza.length) > 100 ? contenidoPlusHtml : contenidoHtml,
+            icon: 'error',
+            showCancelButton: false,
+            showCloseButton: true,
+            showConfirmButton: false,
+            customClass: 'my-swal',
+            didOpen: () => {
+                if ((mensaje.length + traza.length) > 100) {
+                    // Agregar estilos al botón "Ver más"
+                    const verMasButton = document.getElementById('verMasButton');
+                    verMasButton.classList.add('swal2-styled', 'swal2-cancel', 'btn-vermas');
+                    const OkButton = document.getElementById('Ok');
+                    OkButton.classList.add('swal2-styled', 'swal2-cancel', 'btn-ok');
+                    // Agregar un evento al botón "Ver más" para mostrar todo el contenido cuando se hace clic
+                    verMasButton.addEventListener('click', () => {
+                        Swal.update({
+                            html: contenidoHtml,
+                            showConfirmButton: true,
+                        });
+                        this.utilsService.sleep(500).then(data => {
+                            this.utilsService.resizeWindowIFrame();
+                        });
+                    });
+                    OkButton.addEventListener('click', () => {
+                        Swal.close();
+                        this.utilsService.sleep(500).then(data => {
+                            this.utilsService.resizeWindowIFrame();
+                        });
+                    });
+                }
+                else {
+                    Swal.update({
+                        html: contenidoHtml,
+                        showConfirmButton: true,
+                    });
+                }
+            },
+        }).then((result) => {
+            if (result.isConfirmed) {
+                this.utilsService.sleep(500).then(data => {
+                    this.utilsService.resizeWindowIFrame();
+                });
+            }
+            else if (result.dismiss === Swal.DismissReason.cancel) {
+                this.utilsService.sleep(500).then(data => {
+                    this.utilsService.resizeWindowIFrame();
+                });
+            }
+            else if (result.dismiss === Swal.DismissReason.close) {
+                this.utilsService.sleep(500).then(data => {
+                    this.utilsService.resizeWindowIFrame();
+                });
+            }
+        });
+        this.utilsService.sleep(500).then(data => {
+            this.utilsService.resizeWindowIFrame();
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: ErrorIntecertorService, deps: [{ token: i1.UtilsService }, { token: i2.Router }, { token: i3.AuthService }, { token: i4.StorageService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: ErrorIntecertorService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: ErrorIntecertorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.UtilsService }, { type: i2.Router }, { type: i3.AuthService }, { type: i4.StorageService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error-interceptor.service.js","sourceRoot":"","sources":["../../../../../../src/app/core/servicios/error-interceptor.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport Swal from 'sweetalert2';\r\nimport { ErrorResponseModel } from '../modelos/error-response.model';\r\nimport { UtilsService } from './utils.service';\r\nimport { Router } from '@angular/router';\r\nimport { AuthService } from './auth.service';\r\nimport { StorageService } from './storage.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ErrorIntecertorService {\r\n\r\n  constructor(private utilsService: UtilsService,\r\n              private route: Router,\r\n              private authService: AuthService,\r\n              private storageService: StorageService,\r\n  ) { }\r\n\r\n   /**\r\n   * Muestra un mensaje de error según el tipo de error proporcionado.\r\n   * @param errorJson El objeto JSON que representa el error.\r\n   */\r\n  showError(errorJson: string): void {\r\n    const error: ErrorResponseModel = JSON.parse(errorJson);\r\n    if (error.codigo == 'UNI-DB-002' || error.codigo == 'UNI-DB-003' \r\n      || error.mensaje?.includes('Se produjo un error de red') || error.mensaje?.includes('El servicio no está disponible') \r\n      || error.mensaje?.includes('Conexion no valida'))  {\r\n      this.storageService.setItem('mensaje_notfound', error.mensaje);\r\n      this.storageService.setItem('url_regresar', window.location.href);\r\n      window.location.href = window.location.origin + '/' + this.utilsService.obtenerBase() + '/not-found'\r\n      //this.route.navigate([this.utilsService.obtenerBase()+'/not-found']);\r\n      return;\r\n    }\r\n    if (error.tipo === 'INF') {\r\n      this.showInfo(error.mensaje, error.codigo);\r\n    } else if (error.tipo === 'WAR') {\r\n      this.showWarning(error.mensaje, error.codigo, error.causa, error.accion, error.traza);\r\n    } else if (error.tipo === 'ERR') {\r\n      this.showErrorDetails(error.mensaje ? error.mensaje : '', error.codigo, error.traza, error.causa);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Muestra un mensaje de información con el código.\r\n   * @param mensaje El mensaje a mostrar.\r\n   * @param codigo El código asociado al mensaje.\r\n   */\r\n  private showInfo(mensaje: string, codigo: string): void {\r\n    Swal.fire({\r\n      background: '#f7bfbf',\r\n      position: 'top-end',\r\n      html: '<div style=\"text-align: left;\">' +\r\n              '<p style=\"text-align: left;\"><b>Código:</b> ' + codigo + '</p>' +\r\n              '<p style=\"text-align: left; font-size:12px\">' + mensaje + '</p>' +\r\n            '</div>',\r\n      showConfirmButton: false,\r\n      timer: 5500,\r\n      color: '#ff0000'\r\n    }).then((result) => {\r\n      if (result.isConfirmed) {\r\n        this.utilsService.sleep(500).then(data => {\r\n          this.utilsService.resizeWindowIFrame();\r\n        })\r\n      } else if (result.dismiss === Swal.DismissReason.cancel) {\r\n        this.utilsService.sleep(500).then(data => {\r\n          this.utilsService.resizeWindowIFrame();\r\n        })\r\n      } else if (result.dismiss === Swal.DismissReason.close) {\r\n        this.utilsService.sleep(500).then(data => {\r\n          this.utilsService.resizeWindowIFrame();\r\n        })\r\n      }\r\n    });\r\n    this.utilsService.sleep(500).then(data => {\r\n      this.utilsService.resizeWindowIFrame();\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Muestra una advertencia con detalles adicionales como causa, acción y traza.\r\n   * @param mensaje El mensaje a mostrar.\r\n   * @param codigo El código asociado al mensaje.\r\n   * @param causa La causa del error.\r\n   * @param accion La acción recomendada.\r\n   * @param traza La traza del error.\r\n   */\r\n  private showWarning(mensaje: string, codigo: string, causa: string, accion: string, traza: string): void {\r\n    let contenidoHtml = `<p class=\"msjError\">${mensaje}</p>`\r\n    contenidoHtml = contenidoHtml + (this.utilsService.validarCampoObligatorio(codigo) ? `<p class=\"cauError\"><b>Código:</b> ${codigo}</p>` : ' ');\r\n    contenidoHtml = contenidoHtml + (this.utilsService.validarCampoObligatorio(causa) ? `<p class=\"cauError\"><b>Causa:</b> ${causa}</p>` : ' ');\r\n    contenidoHtml = contenidoHtml + (this.utilsService.validarCampoObligatorio(accion) ? `<p class=\"cauError\"><b>Acción Recomendada:</b> ${accion}</p>` : ' ');\r\n    let contenidoPlusHtml = `<p class=\"msjError\">${mensaje.slice(0, 100)}</p><button id=\"verMasButton\">Ver más</button> <button id=\"Ok\">OK</button>`;\r\n\r\n    Swal.fire({\r\n      title: '<span style=\"color: var(--color-700);\">' + 'Advertencia' + '</span>',\r\n      html: contenidoHtml,\r\n      icon: 'warning',\r\n      showCancelButton: false,\r\n      showCloseButton: true,\r\n      showConfirmButton: true,\r\n      didOpen: () => {\r\n          const OkButton = document.getElementById('Ok');\r\n          OkButton.classList.add('swal2-styled', 'swal2-cancel', 'btn-ok');\r\n          OkButton.addEventListener('click', () => {\r\n            Swal.close();\r\n            this.utilsService.sleep(500).then(data => {\r\n              this.utilsService.resizeWindowIFrame();\r\n            })\r\n          });\r\n      },\r\n    }).then((result) => {\r\n      if (result.isConfirmed) {\r\n        this.utilsService.sleep(500).then(data => {\r\n          this.utilsService.resizeWindowIFrame();\r\n        })\r\n      } else if (result.dismiss === Swal.DismissReason.cancel) {\r\n        this.utilsService.sleep(500).then(data => {\r\n          this.utilsService.resizeWindowIFrame();\r\n        })\r\n      } else if (result.dismiss === Swal.DismissReason.close) {\r\n        this.utilsService.sleep(500).then(data => {\r\n          this.utilsService.resizeWindowIFrame();\r\n        })\r\n      }\r\n    });\r\n    \r\n    this.utilsService.sleep(500).then(data => {\r\n      this.utilsService.resizeWindowIFrame();\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Muestra un mensaje de error con detalles adicionales como el código de error y la traza.\r\n   * @param mensaje El mensaje a mostrar.\r\n   * @param errorCode El código de error asociado al mensaje.\r\n   * @param traza La traza del error.\r\n   */\r\n  private showErrorDetails(mensaje: string, codigo: string, traza: string, causa? : string): void {\r\n      let contenidoHtml = `<p class=\"msjError\">${mensaje}</p><p class=\"codError\"><b>Código:</b> ${codigo}</p><p class=\"traError\"><b>Traza:</b> ${traza}</p><p class=\"cauError\">`;\r\n      if (causa!= null && causa != undefined) {\r\n        contenidoHtml = `<p class=\"msjError\">${mensaje}</p><p class=\"codError\"><b>Código:</b> ${codigo}</p><p class=\"traError\"><b>Traza:</b> ${traza}</p><p class=\"cauError\"><b>Causa:</b> ${causa}</p>`;\r\n      }\r\n      let contenidoPlusHtml = `<p class=\"msjError\">${mensaje.slice(0, 100)}</p><button id=\"verMasButton\">Ver más</button> <button class=\"btn-ok\" id=\"Ok\">OK</button>`;\r\n\r\n      Swal.fire({\r\n        title: '<span style=\"color: var(--color-700);\">' + 'Error' + '</span>',\r\n        html: (mensaje.length + traza.length) > 100 ? contenidoPlusHtml : contenidoHtml,\r\n        icon: 'error',\r\n        showCancelButton: false,\r\n        showCloseButton: true,\r\n        showConfirmButton: false,\r\n        customClass: 'my-swal',\r\n        didOpen: () => {\r\n          if ((mensaje.length + traza.length) > 100) {\r\n            // Agregar estilos al botón \"Ver más\"\r\n            const verMasButton = document.getElementById('verMasButton');\r\n            verMasButton.classList.add('swal2-styled', 'swal2-cancel', 'btn-vermas' );\r\n\r\n            const OkButton = document.getElementById('Ok');\r\n            OkButton.classList.add('swal2-styled', 'swal2-cancel' , 'btn-ok');\r\n\r\n            // Agregar un evento al botón \"Ver más\" para mostrar todo el contenido cuando se hace clic\r\n            verMasButton.addEventListener('click', () => {\r\n              Swal.update({\r\n                html: contenidoHtml,\r\n                showConfirmButton: true,\r\n              });\r\n              this.utilsService.sleep(500).then(data => {\r\n                this.utilsService.resizeWindowIFrame();\r\n              })\r\n            });\r\n\r\n            OkButton.addEventListener('click', () => {\r\n              Swal.close();\r\n              this.utilsService.sleep(500).then(data => {\r\n                this.utilsService.resizeWindowIFrame();\r\n              })\r\n            });\r\n          }\r\n          else{\r\n            Swal.update({\r\n              html: contenidoHtml,\r\n              showConfirmButton: true,\r\n            });\r\n          }\r\n        },\r\n      }).then((result) => {\r\n        if (result.isConfirmed) {\r\n          this.utilsService.sleep(500).then(data => {\r\n            this.utilsService.resizeWindowIFrame();\r\n          })\r\n        } else if (result.dismiss === Swal.DismissReason.cancel) {\r\n          this.utilsService.sleep(500).then(data => {\r\n            this.utilsService.resizeWindowIFrame();\r\n          })\r\n        } else if (result.dismiss === Swal.DismissReason.close) {\r\n          this.utilsService.sleep(500).then(data => {\r\n            this.utilsService.resizeWindowIFrame();\r\n          })\r\n        }\r\n      });\r\n      \r\n    this.utilsService.sleep(500).then(data => {\r\n      this.utilsService.resizeWindowIFrame();\r\n    })\r\n  }\r\n}\r\n"]}

package/esm2022/src/app/core/servicios/guardias/auth.guard.mjs

@@ -0,0 +1,66 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../core/servicios/auth.service";
+import * as i2 from "../utils.service";
+import * as i3 from "@angular/router";
+import * as i4 from "../../../core/servicios/toast.service";
+import * as i5 from "../storage.service";
+export class AuthGuard {
+    authService;
+    utilsService;
+    route;
+    toastService;
+    storageService;
+    constructor(authService, utilsService, route, toastService, storageService) {
+        this.authService = authService;
+        this.utilsService = utilsService;
+        this.route = route;
+        this.toastService = toastService;
+        this.storageService = storageService;
+    }
+    canLoad(route, segments) {
+        if (!this.authService.isTokenValid()) {
+            this.authService.deleteToken();
+            this.toastService.showError('Tu sesión no es válida. Primero debes autenticarte con tu usuario y contraseña.', 'Acceso Denegado');
+            return this.route.createUrlTree(['/' + this.utilsService.obtenerBase() + '/login']);
+        }
+        let aplicacion = this.authService.getTokenKey('aplicacion');
+        console.log('aplicacion:' + aplicacion);
+        if (aplicacion.trim() == '10') {
+            return true;
+        }
+        let tareasss = JSON.parse(this.storageService.getItem('__tareas'));
+        let ruta = '';
+        let continuar = true;
+        segments.forEach(data => {
+            if (continuar) {
+                if (data.path !== 'US_editar') {
+                    ruta = ruta + '/' + data.path;
+                }
+                else {
+                    continuar = false;
+                }
+            }
+        });
+        let respuesta = false;
+        console.log(ruta);
+        tareasss.forEach(element => {
+            if (element.urlprincipal.replace(/.jsf/, '') === ruta) {
+                respuesta = true;
+            }
+        });
+        if (!respuesta) {
+            return this.route.createUrlTree(['/' + this.utilsService.obtenerBase() + '/not-found']);
+        }
+        return respuesta;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: AuthGuard, deps: [{ token: i1.AuthService }, { token: i2.UtilsService }, { token: i3.Router }, { token: i4.ToastService }, { token: i5.StorageService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: AuthGuard, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: AuthGuard, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.AuthService }, { type: i2.UtilsService }, { type: i3.Router }, { type: i4.ToastService }, { type: i5.StorageService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/app/core/servicios/guardias/publico.guard.mjs

@@ -0,0 +1,35 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../core/servicios/auth.service";
+import * as i2 from "@angular/router";
+import * as i3 from "../utils.service";
+export class PublicoGuard {
+    authService;
+    route;
+    utilsService;
+    constructor(authService, route, utilsService) {
+        this.authService = authService;
+        this.route = route;
+        this.utilsService = utilsService;
+    }
+    canActivate(route, state) {
+        if (this.authService.isTokenValid()) {
+            if (window.location.href.toString().includes('admonPortal')) {
+                return this.route.createUrlTree(['/' + this.utilsService.obtenerBase() + '/admonPortal/inicio']);
+            }
+            else {
+                return this.route.createUrlTree(['/' + this.utilsService.obtenerBase() + '/inicio']);
+            }
+        }
+        return true;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: PublicoGuard, deps: [{ token: i1.AuthService }, { token: i2.Router }, { token: i3.UtilsService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: PublicoGuard, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: PublicoGuard, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.AuthService }, { type: i2.Router }, { type: i3.UtilsService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/app/core/servicios/interceptores/loading-interceptor.mjs

@@ -0,0 +1,37 @@
+import { Injectable } from '@angular/core';
+import { finalize } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../spinner-service";
+export class LoadingInterceptor {
+    spinnerService;
+    constructor(spinnerService) {
+        this.spinnerService = spinnerService;
+    }
+    intercept(req, next) {
+        var spinnerActivated = false;
+        var timeElapsed = 0;
+        var intervalId;
+        intervalId = setInterval(() => {
+            timeElapsed++;
+            if (timeElapsed > 5 && !spinnerActivated) {
+                spinnerActivated = true;
+                this.spinnerService.show();
+            }
+        }, 1000);
+        return next.handle(req).pipe(finalize(() => {
+            this.spinnerService.hide();
+            if (intervalId) {
+                clearInterval(intervalId);
+            }
+        }));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: LoadingInterceptor, deps: [{ token: i1.SpinnerService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: LoadingInterceptor, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: LoadingInterceptor, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.SpinnerService }] });
+//# sourceMappingURL=data:application/json;base64,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