general-library-union 2.5.36 → 2.5.38

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

@@ -0,0 +1,44 @@
+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('p', '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) {
+        const workbook = new Workbook();
+        const worksheet = workbook.addWorksheet('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}_export_${new Date().getTime()}${EXCEL_EXTENSION}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,148 @@
+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'
+        });
+    }
+    /**
+     * 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();
+                });
+            },
+        });
+    }
+    /**
+     * 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,
+                        });
+                    });
+                    OkButton.addEventListener('click', () => {
+                        Swal.close();
+                    });
+                }
+                else {
+                    Swal.update({
+                        html: contenidoHtml,
+                        showConfirmButton: true,
+                    });
+                }
+            },
+        });
+    }
+    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":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,IAAI,MAAM,aAAa,CAAC;;;;;;AAU/B,MAAM,OAAO,sBAAsB;IAEb;IACA;IACA;IACA;IAHpB,YAAoB,YAA0B,EAC1B,KAAa,EACb,WAAwB,EACxB,cAA8B;QAH9B,iBAAY,GAAZ,YAAY,CAAc;QAC1B,UAAK,GAAL,KAAK,CAAQ;QACb,gBAAW,GAAX,WAAW,CAAa;QACxB,mBAAc,GAAd,cAAc,CAAgB;IAC9C,CAAC;IAEJ;;;MAGE;IACH,SAAS,CAAC,SAAiB;QACzB,MAAM,KAAK,GAAuB,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QACxD,IAAI,KAAK,CAAC,MAAM,IAAI,YAAY,IAAI,KAAK,CAAC,MAAM,IAAI,YAAY;eAC3D,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,4BAA4B,CAAC,IAAI,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,gCAAgC,CAAC;eAClH,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,oBAAoB,CAAC,EAAG,CAAC;YACpD,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,kBAAkB,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;YAC/D,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,cAAc,EAAE,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YAClE,MAAM,CAAC,QAAQ,CAAC,IAAI,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC,YAAY,CAAC,WAAW,EAAE,GAAG,YAAY,CAAA;YACpG,sEAAsE;YACtE,OAAO;QACT,CAAC;QACD,IAAI,KAAK,CAAC,IAAI,KAAK,KAAK,EAAE,CAAC;YACzB,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;QAC7C,CAAC;aAAM,IAAI,KAAK,CAAC,IAAI,KAAK,KAAK,EAAE,CAAC;YAChC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;QACxF,CAAC;aAAM,IAAI,KAAK,CAAC,IAAI,KAAK,KAAK,EAAE,CAAC;YAChC,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;QACpG,CAAC;IACH,CAAC;IAED;;;;OAIG;IACK,QAAQ,CAAC,OAAe,EAAE,MAAc;QAC9C,IAAI,CAAC,IAAI,CAAC;YACR,UAAU,EAAE,SAAS;YACrB,QAAQ,EAAE,SAAS;YACnB,IAAI,EAAE,iCAAiC;gBAC/B,8CAA8C,GAAG,MAAM,GAAG,MAAM;gBAChE,8CAA8C,GAAG,OAAO,GAAG,MAAM;gBACnE,QAAQ;YACd,iBAAiB,EAAE,KAAK;YACxB,KAAK,EAAE,IAAI;YACX,KAAK,EAAE,SAAS;SACjB,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;OAOG;IACK,WAAW,CAAC,OAAe,EAAE,MAAc,EAAE,KAAa,EAAE,MAAc,EAAE,KAAa;QAC/F,IAAI,aAAa,GAAG,uBAAuB,OAAO,MAAM,CAAA;QACxD,aAAa,GAAG,aAAa,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,uBAAuB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,sCAAsC,MAAM,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAC/I,aAAa,GAAG,aAAa,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,uBAAuB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,qCAAqC,KAAK,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAC5I,aAAa,GAAG,aAAa,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,uBAAuB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,kDAAkD,MAAM,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAC3J,IAAI,iBAAiB,GAAG,uBAAuB,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,4EAA4E,CAAC;QAEjJ,IAAI,CAAC,IAAI,CAAC;YACR,KAAK,EAAE,yCAAyC,GAAG,aAAa,GAAG,SAAS;YAC5E,IAAI,EAAE,aAAa;YACnB,IAAI,EAAE,SAAS;YACf,gBAAgB,EAAE,KAAK;YACvB,eAAe,EAAE,IAAI;YACrB,iBAAiB,EAAE,IAAI;YACvB,OAAO,EAAE,GAAG,EAAE;gBACV,MAAM,QAAQ,GAAG,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;gBAC/C,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,cAAc,EAAE,cAAc,EAAE,QAAQ,CAAC,CAAC;gBACjE,QAAQ,CAAC,gBAAgB,CAAC,OAAO,EAAE,GAAG,EAAE;oBACtC,IAAI,CAAC,KAAK,EAAE,CAAC;gBACf,CAAC,CAAC,CAAC;YACP,CAAC;SACF,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACK,gBAAgB,CAAC,OAAe,EAAE,MAAc,EAAE,KAAa,EAAE,KAAe;QACpF,IAAI,aAAa,GAAG,uBAAuB,OAAO,0CAA0C,MAAM,yCAAyC,KAAK,0BAA0B,CAAC;QAC3K,IAAI,KAAK,IAAG,IAAI,IAAI,KAAK,IAAI,SAAS,EAAE,CAAC;YACvC,aAAa,GAAG,uBAAuB,OAAO,0CAA0C,MAAM,yCAAyC,KAAK,yCAAyC,KAAK,MAAM,CAAC;QACnM,CAAC;QACD,IAAI,iBAAiB,GAAG,uBAAuB,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,2FAA2F,CAAC;QAEhK,IAAI,CAAC,IAAI,CAAC;YACR,KAAK,EAAE,yCAAyC,GAAG,OAAO,GAAG,SAAS;YACtE,IAAI,EAAE,CAAC,OAAO,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,aAAa;YAC/E,IAAI,EAAE,OAAO;YACb,gBAAgB,EAAE,KAAK;YACvB,eAAe,EAAE,IAAI;YACrB,iBAAiB,EAAE,KAAK;YACxB,WAAW,EAAE,SAAS;YACtB,OAAO,EAAE,GAAG,EAAE;gBACZ,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,GAAG,EAAE,CAAC;oBAC1C,qCAAqC;oBACrC,MAAM,YAAY,GAAG,QAAQ,CAAC,cAAc,CAAC,cAAc,CAAC,CAAC;oBAC7D,YAAY,CAAC,SAAS,CAAC,GAAG,CAAC,cAAc,EAAE,cAAc,EAAE,YAAY,CAAE,CAAC;oBAE1E,MAAM,QAAQ,GAAG,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;oBAC/C,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,cAAc,EAAE,cAAc,EAAG,QAAQ,CAAC,CAAC;oBAElE,0FAA0F;oBAC1F,YAAY,CAAC,gBAAgB,CAAC,OAAO,EAAE,GAAG,EAAE;wBAC1C,IAAI,CAAC,MAAM,CAAC;4BACV,IAAI,EAAE,aAAa;4BACnB,iBAAiB,EAAE,IAAI;yBACxB,CAAC,CAAC;oBACL,CAAC,CAAC,CAAC;oBAEH,QAAQ,CAAC,gBAAgB,CAAC,OAAO,EAAE,GAAG,EAAE;wBACtC,IAAI,CAAC,KAAK,EAAE,CAAC;oBACf,CAAC,CAAC,CAAC;gBACL,CAAC;qBACG,CAAC;oBACH,IAAI,CAAC,MAAM,CAAC;wBACV,IAAI,EAAE,aAAa;wBACnB,iBAAiB,EAAE,IAAI;qBACxB,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;SACF,CAAC,CAAC;IACP,CAAC;uGArIU,sBAAsB;2GAAtB,sBAAsB,cAFrB,MAAM;;2FAEP,sBAAsB;kBAHlC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport Swal from 'sweetalert2';\nimport { ErrorResponseModel } from '../modelos/error-response.model';\nimport { UtilsService } from './utils.service';\nimport { Router } from '@angular/router';\nimport { AuthService } from './auth.service';\nimport { StorageService } from './storage.service';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ErrorIntecertorService {\n\n  constructor(private utilsService: UtilsService,\n              private route: Router,\n              private authService: AuthService,\n              private storageService: StorageService,\n  ) { }\n\n   /**\n   * Muestra un mensaje de error según el tipo de error proporcionado.\n   * @param errorJson El objeto JSON que representa el error.\n   */\n  showError(errorJson: string): void {\n    const error: ErrorResponseModel = JSON.parse(errorJson);\n    if (error.codigo == 'UNI-DB-002' || error.codigo == 'UNI-DB-003' \n      || error.mensaje?.includes('Se produjo un error de red') || error.mensaje?.includes('El servicio no está disponible') \n      || error.mensaje?.includes('Conexion no valida'))  {\n      this.storageService.setItem('mensaje_notfound', error.mensaje);\n      this.storageService.setItem('url_regresar', window.location.href);\n      window.location.href = window.location.origin + '/' + this.utilsService.obtenerBase() + '/not-found'\n      //this.route.navigate([this.utilsService.obtenerBase()+'/not-found']);\n      return;\n    }\n    if (error.tipo === 'INF') {\n      this.showInfo(error.mensaje, error.codigo);\n    } else if (error.tipo === 'WAR') {\n      this.showWarning(error.mensaje, error.codigo, error.causa, error.accion, error.traza);\n    } else if (error.tipo === 'ERR') {\n      this.showErrorDetails(error.mensaje ? error.mensaje : '', error.codigo, error.traza, error.causa);\n    }\n  }\n\n  /**\n   * Muestra un mensaje de información con el código.\n   * @param mensaje El mensaje a mostrar.\n   * @param codigo El código asociado al mensaje.\n   */\n  private showInfo(mensaje: string, codigo: string): void {\n    Swal.fire({\n      background: '#f7bfbf',\n      position: 'top-end',\n      html: '<div style=\"text-align: left;\">' +\n              '<p style=\"text-align: left;\"><b>Código:</b> ' + codigo + '</p>' +\n              '<p style=\"text-align: left; font-size:12px\">' + mensaje + '</p>' +\n            '</div>',\n      showConfirmButton: false,\n      timer: 5500,\n      color: '#ff0000'\n    });\n  }\n\n  /**\n   * Muestra una advertencia con detalles adicionales como causa, acción y traza.\n   * @param mensaje El mensaje a mostrar.\n   * @param codigo El código asociado al mensaje.\n   * @param causa La causa del error.\n   * @param accion La acción recomendada.\n   * @param traza La traza del error.\n   */\n  private showWarning(mensaje: string, codigo: string, causa: string, accion: string, traza: string): void {\n    let contenidoHtml = `<p class=\"msjError\">${mensaje}</p>`\n    contenidoHtml = contenidoHtml + (this.utilsService.validarCampoObligatorio(codigo) ? `<p class=\"cauError\"><b>Código:</b> ${codigo}</p>` : ' ');\n    contenidoHtml = contenidoHtml + (this.utilsService.validarCampoObligatorio(causa) ? `<p class=\"cauError\"><b>Causa:</b> ${causa}</p>` : ' ');\n    contenidoHtml = contenidoHtml + (this.utilsService.validarCampoObligatorio(accion) ? `<p class=\"cauError\"><b>Acción Recomendada:</b> ${accion}</p>` : ' ');\n    let contenidoPlusHtml = `<p class=\"msjError\">${mensaje.slice(0, 100)}</p><button id=\"verMasButton\">Ver más</button> <button id=\"Ok\">OK</button>`;\n\n    Swal.fire({\n      title: '<span style=\"color: var(--color-700);\">' + 'Advertencia' + '</span>',\n      html: contenidoHtml,\n      icon: 'warning',\n      showCancelButton: false,\n      showCloseButton: true,\n      showConfirmButton: true,\n      didOpen: () => {\n          const OkButton = document.getElementById('Ok');\n          OkButton.classList.add('swal2-styled', 'swal2-cancel', 'btn-ok');\n          OkButton.addEventListener('click', () => {\n            Swal.close();\n          });\n      },\n    });\n  }\n\n  /**\n   * Muestra un mensaje de error con detalles adicionales como el código de error y la traza.\n   * @param mensaje El mensaje a mostrar.\n   * @param errorCode El código de error asociado al mensaje.\n   * @param traza La traza del error.\n   */\n  private showErrorDetails(mensaje: string, codigo: string, traza: string, causa? : string): void {\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\">`;\n      if (causa!= null && causa != undefined) {\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>`;\n      }\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>`;\n\n      Swal.fire({\n        title: '<span style=\"color: var(--color-700);\">' + 'Error' + '</span>',\n        html: (mensaje.length + traza.length) > 100 ? contenidoPlusHtml : contenidoHtml,\n        icon: 'error',\n        showCancelButton: false,\n        showCloseButton: true,\n        showConfirmButton: false,\n        customClass: 'my-swal',\n        didOpen: () => {\n          if ((mensaje.length + traza.length) > 100) {\n            // Agregar estilos al botón \"Ver más\"\n            const verMasButton = document.getElementById('verMasButton');\n            verMasButton.classList.add('swal2-styled', 'swal2-cancel', 'btn-vermas' );\n\n            const OkButton = document.getElementById('Ok');\n            OkButton.classList.add('swal2-styled', 'swal2-cancel' , 'btn-ok');\n\n            // Agregar un evento al botón \"Ver más\" para mostrar todo el contenido cuando se hace clic\n            verMasButton.addEventListener('click', () => {\n              Swal.update({\n                html: contenidoHtml,\n                showConfirmButton: true,\n              });\n            });\n\n            OkButton.addEventListener('click', () => {\n              Swal.close();\n            });\n          }\n          else{\n            Swal.update({\n              html: contenidoHtml,\n              showConfirmButton: true,\n            });\n          }\n        },\n      });\n  }\n}\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/token-interceptor.service.mjs

@@ -0,0 +1,120 @@
+import { Injectable } from '@angular/core';
+import { HttpErrorResponse } from '@angular/common/http';
+import { catchError, EMPTY, from, throwError, TimeoutError } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../auth.service";
+import * as i3 from "../../servicios/storage.service";
+import * as i4 from "../error-interceptor.service";
+import * as i5 from "../utils.service";
+export class TokenInterceptorService {
+    router;
+    authService;
+    storage;
+    errorInterceptor;
+    utilsService;
+    constructor(router, authService, storage, errorInterceptor, utilsService) {
+        this.router = router;
+        this.authService = authService;
+        this.storage = storage;
+        this.errorInterceptor = errorInterceptor;
+        this.utilsService = utilsService;
+    }
+    intercept(request, next) {
+        return from(this.interceptDetalle(request, next)).pipe(catchError((error) => {
+            if (error instanceof TimeoutError) {
+                this.errorInterceptor.showError(JSON.stringify({ tipo: 'ERR', traza: '.', mensaje: 'El servicio no está disponible. Por favor, inténtelo más tarde.' }).toString());
+            }
+            else if (error instanceof HttpErrorResponse) {
+                if (error.error instanceof ErrorEvent) {
+                    // A client-side or network error occurred
+                    if (error.error.message.includes('ERR_CONNECTION_REFUSED')) {
+                        this.errorInterceptor.showError(JSON.stringify({ tipo: 'ERR', traza: '.', mensaje: 'El servicio no está disponible. Por favor, inténtelo más tarde.' }).toString());
+                    }
+                    else {
+                        this.errorInterceptor.showError(JSON.stringify({ tipo: 'ERR', traza: '.', mensaje: 'Se produjo un error de red. Por favor, inténtelo más tarde.' }).toString());
+                    }
+                }
+                else {
+                    if (error.status == 0) {
+                        this.errorInterceptor.showError(JSON.stringify({ tipo: 'ERR', traza: '.', mensaje: 'Se produjo un error de red. Por favor, inténtelo más tarde.' }).toString());
+                    }
+                    else {
+                        console.error(`Error HTTP: ${error.status} - ${error.message}`);
+                    }
+                }
+            }
+            return throwError(error);
+        }));
+    }
+    async interceptDetalle(request, next) {
+        if (request.url.includes('/requieretoken') && !request.url.includes('/portalPublico')) {
+            let token = this.authService.getToken();
+            if (token) {
+                let fechaActual = new Date();
+                let fechaExpTokenIni = new Date(this.storage.getDecodedJWT().exp * 1000);
+                let fechaExpTokenFin = new Date(this.storage.getDecodedJWT().exp * 1000);
+                fechaExpTokenIni.setMinutes(fechaExpTokenIni.getMinutes() - 10);
+                if (fechaActual >= fechaExpTokenIni && fechaActual <= fechaExpTokenFin) {
+                    var tokenPublico = await this.authService.generarTokenPublico().toPromise();
+                    var tokenRefrescar = await this.authService.refrescarToken({ token: token }, tokenPublico?.token).toPromise();
+                    token = tokenRefrescar?.token;
+                    this.authService.deleteToken();
+                    this.storage.setItem('token', token);
+                }
+            }
+        }
+        return await this.setearTokenRequest(request, next).toPromise();
+    }
+    setearTokenRequest(request, next) {
+        var basePortal = this.utilsService.obtenerBase();
+        let token = this.authService.getToken();
+        if (request.url.includes('/requieretoken') && !request.url.includes('/portalPublico')) {
+            request = request.clone({
+                headers: request.headers.set('Authorization', `Bearer ${token}`),
+            });
+        }
+        request = request.clone({
+            headers: request.headers.set('Base', basePortal),
+        });
+        return next.handle(request).pipe(catchError((error) => {
+            if (error.status === 401) {
+                this.authService.deleteToken();
+                this.router.navigateByUrl(this.utilsService.obtenerBase() + '/login');
+                return EMPTY;
+            }
+            if (error instanceof TimeoutError) {
+                this.errorInterceptor.showError(JSON.stringify({ tipo: 'ERR', traza: '.', mensaje: 'El servicio no está disponible. Por favor, inténtelo más tarde.' }).toString());
+            }
+            else if (error instanceof HttpErrorResponse) {
+                if (error.error instanceof ErrorEvent) {
+                    // A client-side or network error occurred
+                    if (error.error.message.includes('ERR_CONNECTION_REFUSED')) {
+                        this.errorInterceptor.showError(JSON.stringify({ tipo: 'ERR', traza: '.', mensaje: 'El servicio no está disponible. Por favor, inténtelo más tarde.' }).toString());
+                    }
+                    else {
+                        this.errorInterceptor.showError(JSON.stringify({ tipo: 'ERR', traza: '.', mensaje: 'Se produjo un error de red. Por favor, inténtelo más tarde.' }).toString());
+                    }
+                }
+                else {
+                    if (error.status == 0) {
+                        this.errorInterceptor.showError(JSON.stringify({ tipo: 'ERR', traza: '.', mensaje: 'Se produjo un error de red. Por favor, inténtelo más tarde.' }).toString());
+                    }
+                    else {
+                        console.error(`Error HTTP: ${error.status} - ${error.message}`);
+                    }
+                }
+            }
+            return throwError(() => error);
+        }));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: TokenInterceptorService, deps: [{ token: i1.Router }, { token: i2.AuthService }, { token: i3.StorageService }, { token: i4.ErrorIntecertorService }, { token: i5.UtilsService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: TokenInterceptorService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: TokenInterceptorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.Router }, { type: i2.AuthService }, { type: i3.StorageService }, { type: i4.ErrorIntecertorService }, { type: i5.UtilsService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"token-interceptor.service.js","sourceRoot":"","sources":["../../../../../../../src/app/core/servicios/interceptores/token-interceptor.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,EAAwD,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC/G,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,IAAI,EAAc,UAAU,EAAW,YAAY,EAAE,MAAM,MAAM,CAAC;;;;;;;AAW9F,MAAM,OAAO,uBAAuB;IACd;IACA;IACA;IACA;IACA;IAJpB,YAAoB,MAAc,EACd,WAAwB,EACxB,OAAuB,EACvB,gBAAwC,EACxC,YAA0B;QAJ1B,WAAM,GAAN,MAAM,CAAQ;QACd,gBAAW,GAAX,WAAW,CAAa;QACxB,YAAO,GAAP,OAAO,CAAgB;QACvB,qBAAgB,GAAhB,gBAAgB,CAAwB;QACxC,iBAAY,GAAZ,YAAY,CAAc;IAAG,CAAC;IAElD,SAAS,CAAC,OAAyB,EAAE,IAAiB;QACpD,OAAQ,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,IAAI,CACrD,UAAU,CAAC,CAAC,KAAU,EAAE,EAAE;YACxB,IAAI,KAAK,YAAY,YAAY,EAAE,CAAC;gBAClC,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,EAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,iEAAiE,EAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;YACpK,CAAC;iBAAM,IAAI,KAAK,YAAY,iBAAiB,EAAE,CAAC;gBAC9C,IAAI,KAAK,CAAC,KAAK,YAAY,UAAU,EAAE,CAAC;oBACtC,0CAA0C;oBAC1C,IAAI,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAAC,EAAE,CAAC;wBAC3D,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,EAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,iEAAiE,EAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;oBACpK,CAAC;yBAAM,CAAC;wBACN,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,EAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,6DAA6D,EAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;oBAChK,CAAC;gBACH,CAAC;qBAAM,CAAC;oBACN,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;wBACtB,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,EAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,6DAA6D,EAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;oBAChK,CAAC;yBAAM,CAAC;wBACN,OAAO,CAAC,KAAK,CAAC,eAAe,KAAK,CAAC,MAAM,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;oBAClE,CAAC;gBACH,CAAC;YACH,CAAC;YACD,OAAO,UAAU,CAAC,KAAK,CAAC,CAAC;QAC3B,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,gBAAgB,CAAC,OAAyB,EAAE,IAAiB;QACjE,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,gBAAgB,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,CAAC;YACtF,IAAI,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC;YACxC,IAAI,KAAK,EAAC,CAAC;gBACT,IAAI,WAAW,GAAG,IAAI,IAAI,EAAE,CAAC;gBAC7B,IAAI,gBAAgB,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC,GAAG,GAAG,IAAI,CAAC,CAAA;gBACxE,IAAI,gBAAgB,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC,GAAG,GAAG,IAAI,CAAC,CAAA;gBACxE,gBAAgB,CAAC,UAAU,CAAC,gBAAgB,CAAC,UAAU,EAAE,GAAG,EAAE,CAAC,CAAC;gBAChE,IAAI,WAAW,IAAI,gBAAgB,IAAI,WAAW,IAAE,gBAAgB,EAAC,CAAC;oBACpE,IAAI,YAAY,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,mBAAmB,EAAE,CAAC,SAAS,EAAE,CAAA;oBAC3E,IAAI,cAAc,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,EAAC,KAAK,EAAE,KAAK,EAAE,EAAG,YAAoB,EAAE,KAAe,CAAC,CAAC,SAAS,EAAE,CAAC;oBAChI,KAAK,GAAI,cAAsB,EAAE,KAAe,CAAC;oBACjD,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,CAAA;oBAC9B,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;gBACvC,CAAC;YACH,CAAC;QACH,CAAC;QACD,OAAO,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,SAAS,EAAE,CAAC;IAClE,CAAC;IAED,kBAAkB,CAAC,OAAyB,EAAE,IAAiB;QAC7D,IAAI,UAAU,GAAW,IAAI,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC;QACzD,IAAI,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC;QACxC,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,gBAAgB,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,CAAC;YACtF,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC;gBACtB,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,UAAU,KAAK,EAAE,CAAC;aACjE,CAAC,CAAC;QACL,CAAC;QAED,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC;YACtB,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC;SACjD,CAAC,CAAC;QAEH,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAC9B,UAAU,CAAC,CAAC,KAAK,EAAE,EAAE;YACnB,IAAI,KAAK,CAAC,MAAM,KAAK,GAAG,EAAE,CAAC;gBACzB,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC;gBAC/B,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,WAAW,EAAE,GAAG,QAAQ,CAAC,CAAC;gBACtE,OAAO,KAAK,CAAC;YACf,CAAC;YACD,IAAI,KAAK,YAAY,YAAY,EAAE,CAAC;gBAClC,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,EAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,iEAAiE,EAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;YACpK,CAAC;iBAAM,IAAI,KAAK,YAAY,iBAAiB,EAAE,CAAC;gBAC9C,IAAI,KAAK,CAAC,KAAK,YAAY,UAAU,EAAE,CAAC;oBACtC,0CAA0C;oBAC1C,IAAI,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAAC,EAAE,CAAC;wBAC3D,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,EAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,iEAAiE,EAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;oBACpK,CAAC;yBAAM,CAAC;wBACN,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,EAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,6DAA6D,EAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;oBAChK,CAAC;gBACH,CAAC;qBAAM,CAAC;oBACN,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;wBACtB,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,EAAC,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,6DAA6D,EAAC,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;oBAChK,CAAC;yBAAM,CAAC;wBACN,OAAO,CAAC,KAAK,CAAC,eAAe,KAAK,CAAC,MAAM,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;oBAClE,CAAC;gBACH,CAAC;YACH,CAAC;YACD,OAAO,UAAU,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;QACjC,CAAC,CAAC,CACH,CAAC;IACJ,CAAC;uGA9FU,uBAAuB;2GAAvB,uBAAuB,cAFtB,MAAM;;2FAEP,uBAAuB;kBAHnC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Router } from '@angular/router';\nimport { HttpRequest, HttpHandler, HttpEvent, HttpInterceptor, HttpErrorResponse } from '@angular/common/http';\nimport { catchError, EMPTY, from, Observable, throwError, timeout, TimeoutError } from 'rxjs';\nimport { AuthService } from '../auth.service';\nimport { StorageService } from '../../servicios/storage.service';\nimport { UtilsService } from '../utils.service';\nimport { ToastService } from '../toast.service';\nimport { ErrorIntecertorService } from '../error-interceptor.service';\n\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class TokenInterceptorService implements HttpInterceptor {\n  constructor(private router: Router, \n              private authService: AuthService, \n              private storage: StorageService, \n              private errorInterceptor: ErrorIntecertorService,\n              private utilsService: UtilsService) {}\n  \n  intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>{\n    return  from(this.interceptDetalle(request, next)).pipe(\n      catchError((error: any) => {\n        if (error instanceof TimeoutError) {\n          this.errorInterceptor.showError(JSON.stringify({tipo: 'ERR', traza: '.', mensaje: 'El servicio no está disponible. Por favor, inténtelo más tarde.'}).toString());\n        } else if (error instanceof HttpErrorResponse) {\n          if (error.error instanceof ErrorEvent) {\n            // A client-side or network error occurred\n            if (error.error.message.includes('ERR_CONNECTION_REFUSED')) {\n              this.errorInterceptor.showError(JSON.stringify({tipo: 'ERR', traza: '.', mensaje: 'El servicio no está disponible. Por favor, inténtelo más tarde.'}).toString());\n            } else {\n              this.errorInterceptor.showError(JSON.stringify({tipo: 'ERR', traza: '.', mensaje: 'Se produjo un error de red. Por favor, inténtelo más tarde.'}).toString());\n            }\n          } else {\n            if (error.status == 0) {\n              this.errorInterceptor.showError(JSON.stringify({tipo: 'ERR', traza: '.', mensaje: 'Se produjo un error de red. Por favor, inténtelo más tarde.'}).toString());\n            } else {\n              console.error(`Error HTTP: ${error.status} - ${error.message}`);\n            }\n          }\n        }\n        return throwError(error);\n      })\n    );\n  }\n\n  async interceptDetalle(request: HttpRequest<any>, next: HttpHandler): Promise<HttpEvent<any>>  {\n    if (request.url.includes('/requieretoken') && !request.url.includes('/portalPublico')) {\n      let token = this.authService.getToken();\n      if (token){\n        let fechaActual = new Date();\n        let fechaExpTokenIni = new Date(this.storage.getDecodedJWT().exp * 1000)\n        let fechaExpTokenFin = new Date(this.storage.getDecodedJWT().exp * 1000)\n        fechaExpTokenIni.setMinutes(fechaExpTokenIni.getMinutes() - 10);\n        if (fechaActual >= fechaExpTokenIni && fechaActual<=fechaExpTokenFin){\n          var tokenPublico = await this.authService.generarTokenPublico().toPromise()\n          var tokenRefrescar = await this.authService.refrescarToken({token: token }, (tokenPublico as any)?.token as string).toPromise();\n          token = (tokenRefrescar as any)?.token as string;\n          this.authService.deleteToken()\n          this.storage.setItem('token', token);\n        }\n      }\n    }\n    return await this.setearTokenRequest(request, next).toPromise();\n  } \n\n  setearTokenRequest(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>{\n    var basePortal: string = this.utilsService.obtenerBase();\n    let token = this.authService.getToken();\n    if (request.url.includes('/requieretoken') && !request.url.includes('/portalPublico')) {\n      request = request.clone({\n        headers: request.headers.set('Authorization', `Bearer ${token}`),\n      });\n    }\n\n    request = request.clone({\n      headers: request.headers.set('Base', basePortal),\n    });\n\n    return next.handle(request).pipe(\n      catchError((error) => {\n        if (error.status === 401) {\n          this.authService.deleteToken();\n          this.router.navigateByUrl(this.utilsService.obtenerBase() + '/login');\n          return EMPTY;\n        }\n        if (error instanceof TimeoutError) {\n          this.errorInterceptor.showError(JSON.stringify({tipo: 'ERR', traza: '.', mensaje: 'El servicio no está disponible. Por favor, inténtelo más tarde.'}).toString());\n        } else if (error instanceof HttpErrorResponse) {\n          if (error.error instanceof ErrorEvent) {\n            // A client-side or network error occurred\n            if (error.error.message.includes('ERR_CONNECTION_REFUSED')) {\n              this.errorInterceptor.showError(JSON.stringify({tipo: 'ERR', traza: '.', mensaje: 'El servicio no está disponible. Por favor, inténtelo más tarde.'}).toString());\n            } else {\n              this.errorInterceptor.showError(JSON.stringify({tipo: 'ERR', traza: '.', mensaje: 'Se produjo un error de red. Por favor, inténtelo más tarde.'}).toString());\n            }\n          } else {\n            if (error.status == 0) {\n              this.errorInterceptor.showError(JSON.stringify({tipo: 'ERR', traza: '.', mensaje: 'Se produjo un error de red. Por favor, inténtelo más tarde.'}).toString());\n            } else {\n              console.error(`Error HTTP: ${error.status} - ${error.message}`);\n            }\n          }\n        }\n        return throwError(() => error);\n      })\n    );\n  }\n}\n"]}

package/esm2022/src/app/core/servicios/loading.service.mjs

@@ -0,0 +1,43 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class LoadingService {
+    _loadingFullScreen = new BehaviorSubject(false);
+    _loadingFullScreenObservable$ = this._loadingFullScreen.asObservable();
+    _loadingBreadCrumb = new BehaviorSubject(false);
+    _loadingBreadCrumbObservable$ = this._loadingBreadCrumb.asObservable();
+    constructor() { }
+    /**
+     * Observable del loading full screen
+     */
+    get loadingFullScreen() {
+        return this._loadingFullScreenObservable$;
+    }
+    /**
+     * Observable del loading en el breadcrumb
+     */
+    get loadingBreadCrumb() {
+        return this._loadingBreadCrumbObservable$;
+    }
+    startFullScreenLoading() {
+        this._loadingFullScreen.next(true);
+    }
+    endFullScreenLoading() {
+        this._loadingFullScreen.next(false);
+    }
+    startBreadCrumLoading() {
+        this._loadingBreadCrumb.next(true);
+    }
+    endBreadCrumLoading() {
+        this._loadingBreadCrumb.next(false);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: LoadingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: LoadingService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: LoadingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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