general-library-union 2.7.24 → 2.7.26

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('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, 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\";\nimport \"jspdf-autotable\";\nimport * as FileSaver from 'file-saver';\nimport { Workbook } from 'exceljs';\n\nexport class DataExporter {\n\n    constructor() { }\n\n    exportPdf(lista: any[], exportColumns: any[], nombreArchivo: string) {\n        console.log(lista);\n        const doc = new jsPDF('p', 'pt');\n        doc['autoTable'](exportColumns, lista);\n        doc.save(nombreArchivo + \".pdf\");\n    }\n\n    async exportExcel(lista: any[], nombreArchivo: string) {\n        const workbook = new Workbook();\n        const worksheet = workbook.addWorksheet('data');\n\n        worksheet.columns = Object.keys(lista[0]).map(key => ({ header: key, key }));\n\n        lista.forEach(item => {\n            worksheet.addRow(item);\n        });\n\n        const buffer = await workbook.xlsx.writeBuffer();\n        this.saveAsExcelFile(buffer, nombreArchivo);\n    }\n\n    async exportExcelColumnas(lista: any[], nombreArchivo: string, columnas: string[], nombreHoja?: string) {\n        const workbook = new Workbook();\n        const worksheet = workbook.addWorksheet(nombreHoja ? nombreHoja : 'data');\n\n        worksheet.columns = columnas.map(col => ({ header: col, key: col }));\n\n        lista.forEach(item => {\n            const filteredItem: any = {};\n            columnas.forEach(col => {\n                filteredItem[col] = item[col];\n            });\n            worksheet.addRow(filteredItem);\n        });\n\n        const buffer = await workbook.xlsx.writeBuffer();\n        this.saveAsExcelFile(buffer, nombreArchivo);\n    }\n\n    saveAsExcelFile(buffer: any, fileName: string): void {\n        const EXCEL_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;charset=UTF-8';\n        const EXCEL_EXTENSION = '.xlsx';\n        const data: Blob = new Blob([buffer], { type: EXCEL_TYPE });\n        FileSaver.saveAs(data, `${fileName}${EXCEL_EXTENSION}`);\n    }\n\n    exportCSV(lista: any[], columnas: string[], nombreArchivo: string) {\n        const listaParaExportar = lista;\n        const csvContent = this.convertirAFormatoCSV(listaParaExportar, columnas );\n        this.descargarArchivoCSV(csvContent, nombreArchivo);\n    }\n\n    convertirAFormatoCSV(data: any[], columns: string[]) {\n        const csvHeader = columns.join(',') + '\\n';\n        const csvRows = data.map(item => columns.map(col => item[col]).join(',')).join('\\n');\n        return csvHeader + csvRows + '\\n';\n    }\n\n    descargarArchivoCSV(csvContent: any, nombreArchivo: string) {\n        const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });\n        const url = window.URL.createObjectURL(blob);\n        const link = document.createElement('a');\n        link.href = url;\n        link.setAttribute('download', `${nombreArchivo}.csv`);\n        document.body.appendChild(link);\n        link.click();\n        document.body.removeChild(link);\n    }\n}\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';\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    }).then((result) => {\n      if (result.isConfirmed) {\n        this.utilsService.sleep(500).then(data => {\n          this.utilsService.resizeWindowIFrame();\n        })\n      } else if (result.dismiss === Swal.DismissReason.cancel) {\n        this.utilsService.sleep(500).then(data => {\n          this.utilsService.resizeWindowIFrame();\n        })\n      } else if (result.dismiss === Swal.DismissReason.close) {\n        this.utilsService.sleep(500).then(data => {\n          this.utilsService.resizeWindowIFrame();\n        })\n      }\n    });\n    this.utilsService.sleep(500).then(data => {\n      this.utilsService.resizeWindowIFrame();\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            this.utilsService.sleep(500).then(data => {\n              this.utilsService.resizeWindowIFrame();\n            })\n          });\n      },\n    }).then((result) => {\n      if (result.isConfirmed) {\n        this.utilsService.sleep(500).then(data => {\n          this.utilsService.resizeWindowIFrame();\n        })\n      } else if (result.dismiss === Swal.DismissReason.cancel) {\n        this.utilsService.sleep(500).then(data => {\n          this.utilsService.resizeWindowIFrame();\n        })\n      } else if (result.dismiss === Swal.DismissReason.close) {\n        this.utilsService.sleep(500).then(data => {\n          this.utilsService.resizeWindowIFrame();\n        })\n      }\n    });\n    \n    this.utilsService.sleep(500).then(data => {\n      this.utilsService.resizeWindowIFrame();\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              this.utilsService.sleep(500).then(data => {\n                this.utilsService.resizeWindowIFrame();\n              })\n            });\n\n            OkButton.addEventListener('click', () => {\n              Swal.close();\n              this.utilsService.sleep(500).then(data => {\n                this.utilsService.resizeWindowIFrame();\n              })\n            });\n          }\n          else{\n            Swal.update({\n              html: contenidoHtml,\n              showConfirmButton: true,\n            });\n          }\n        },\n      }).then((result) => {\n        if (result.isConfirmed) {\n          this.utilsService.sleep(500).then(data => {\n            this.utilsService.resizeWindowIFrame();\n          })\n        } else if (result.dismiss === Swal.DismissReason.cancel) {\n          this.utilsService.sleep(500).then(data => {\n            this.utilsService.resizeWindowIFrame();\n          })\n        } else if (result.dismiss === Swal.DismissReason.close) {\n          this.utilsService.sleep(500).then(data => {\n            this.utilsService.resizeWindowIFrame();\n          })\n        }\n      });\n      \n    this.utilsService.sleep(500).then(data => {\n      this.utilsService.resizeWindowIFrame();\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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljby5ndWFyZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9hcHAvY29yZS9zZXJ2aWNpb3MvZ3VhcmRpYXMvcHVibGljby5ndWFyZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOzs7OztBQVMzQyxNQUFNLE9BQU8sWUFBWTtJQUNIO0lBQWtDO0lBQXVCO0lBQTdFLFlBQW9CLFdBQXdCLEVBQVUsS0FBYSxFQUFVLFlBQTBCO1FBQW5GLGdCQUFXLEdBQVgsV0FBVyxDQUFhO1FBQVUsVUFBSyxHQUFMLEtBQUssQ0FBUTtRQUFVLGlCQUFZLEdBQVosWUFBWSxDQUFjO0lBQUcsQ0FBQztJQUUzRyxXQUFXLENBQ1QsS0FBNkIsRUFDN0IsS0FBMEI7UUFFMUIsSUFBSSxJQUFJLENBQUMsV0FBVyxDQUFDLFlBQVksRUFBRSxFQUFFLENBQUM7WUFDcEMsSUFBSSxNQUFNLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQyxRQUFRLENBQUMsYUFBYSxDQUFDLEVBQUUsQ0FBQztnQkFDNUQsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLGFBQWEsQ0FBQyxDQUFDLEdBQUcsR0FBRyxJQUFJLENBQUMsWUFBWSxDQUFDLFdBQVcsRUFBRSxHQUFFLHFCQUFxQixDQUFDLENBQUMsQ0FBQztZQUNsRyxDQUFDO2lCQUFNLENBQUM7Z0JBQ04sT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLGFBQWEsQ0FBQyxDQUFDLEdBQUcsR0FBRyxJQUFJLENBQUMsWUFBWSxDQUFDLFdBQVcsRUFBRSxHQUFFLFNBQVMsQ0FBQyxDQUFDLENBQUM7WUFDdEYsQ0FBQztRQUNILENBQUM7UUFDRCxPQUFPLElBQUksQ0FBQztJQUNkLENBQUM7dUdBZlUsWUFBWTsyR0FBWixZQUFZLGNBRlgsTUFBTTs7MkZBRVAsWUFBWTtrQkFIeEIsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBBY3RpdmF0ZWRSb3V0ZVNuYXBzaG90LCBDYW5BY3RpdmF0ZSwgUm91dGVyLCBSb3V0ZXJTdGF0ZVNuYXBzaG90LCBVcmxUcmVlIH0gZnJvbSAnQGFuZ3VsYXIvcm91dGVyJztcbmltcG9ydCB7IE9ic2VydmFibGUgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IEF1dGhTZXJ2aWNlIH0gZnJvbSAnLi4vLi4vLi4vY29yZS9zZXJ2aWNpb3MvYXV0aC5zZXJ2aWNlJztcbmltcG9ydCB7IFV0aWxzU2VydmljZSB9IGZyb20gJy4uL3V0aWxzLnNlcnZpY2UnO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290Jyxcbn0pXG5leHBvcnQgY2xhc3MgUHVibGljb0d1YXJkIGltcGxlbWVudHMgQ2FuQWN0aXZhdGUge1xuICBjb25zdHJ1Y3Rvcihwcml2YXRlIGF1dGhTZXJ2aWNlOiBBdXRoU2VydmljZSwgcHJpdmF0ZSByb3V0ZTogUm91dGVyLCBwcml2YXRlIHV0aWxzU2VydmljZTogVXRpbHNTZXJ2aWNlKSB7fVxuXG4gIGNhbkFjdGl2YXRlKFxuICAgIHJvdXRlOiBBY3RpdmF0ZWRSb3V0ZVNuYXBzaG90LFxuICAgIHN0YXRlOiBSb3V0ZXJTdGF0ZVNuYXBzaG90XG4gICk6IGFueXsvL09ic2VydmFibGU8Ym9vbGVhbiB8IFVybFRyZWU+IHwgUHJvbWlzZTxib29sZWFuIHwgVXJsVHJlZT4gfCBib29sZWFuIHwgVXJsVHJlZSB7XG4gICAgaWYgKHRoaXMuYXV0aFNlcnZpY2UuaXNUb2tlblZhbGlkKCkpIHtcbiAgICAgIGlmICh3aW5kb3cubG9jYXRpb24uaHJlZi50b1N0cmluZygpLmluY2x1ZGVzKCdhZG1vblBvcnRhbCcpKSB7XG4gICAgICAgIHJldHVybiB0aGlzLnJvdXRlLmNyZWF0ZVVybFRyZWUoWycvJyArIHRoaXMudXRpbHNTZXJ2aWNlLm9idGVuZXJCYXNlKCkrICcvYWRtb25Qb3J0YWwvaW5pY2lvJ10pO1xuICAgICAgfSBlbHNlIHtcbiAgICAgICAgcmV0dXJuIHRoaXMucm91dGUuY3JlYXRlVXJsVHJlZShbJy8nICsgdGhpcy51dGlsc1NlcnZpY2Uub2J0ZW5lckJhc2UoKSsgJy9pbmljaW8nXSk7XG4gICAgICB9XG4gICAgfVxuICAgIHJldHVybiB0cnVlO1xuICB9XG59XG4iXX0=

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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