general-library-union 2.3.36 → 2.3.37

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

@@ -0,0 +1,88 @@
+import { Injectable } from '@angular/core';
+import { map, of, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./storage.service";
+export class MenuService {
+    storageService;
+    _menu = {};
+    _menuSource = new Subject();
+    _breadcrumbSource = new Subject();
+    _menuObservable$ = this._menuSource.asObservable();
+    _breadcrumbObservable$ = this._breadcrumbSource.asObservable();
+    constructor(storageService) {
+        this.storageService = storageService;
+    }
+    /**
+     * Observable para los eventos del breadcrumb
+     */
+    get breadcrumb() {
+        return this._breadcrumbObservable$;
+    }
+    /**
+     * Observable para el menu principal
+     */
+    get menu() {
+        return this._menuObservable$;
+    }
+    /**
+     * Agrega items al breadcrumb
+     * @param items
+     */
+    setBreadcrumb(items) {
+        this._breadcrumbSource.next(items);
+    }
+    /**
+     * Consulta la lista de tareas del usuario para cargar el menú
+     * @returns
+     */
+    loadTareas() {
+        /********************************************************/
+        /* Se debe cambiar con el request al servicio de tareas */
+        this._menu = {};
+        return of(JSON.parse(this.storageService.getItem('__tareas'))).pipe(map((tareas) => {
+            tareas.forEach((tarea) => {
+                //const modulo = tarea.nombreModulo.trim();
+                const modulo = tarea.modulo + '';
+                if (!(modulo in this._menu)) {
+                    this._menu[modulo] = { label: tarea.nombreModulo, items: [] };
+                }
+                let item;
+                const nombreMenu = tarea.nombreAbuelo ?? tarea.nombrePadre;
+                item = this._menu[modulo].items.find((item) => item.label == nombreMenu);
+                if (!item) {
+                    item = { label: tarea.nombrePadre, icon: 'glyphicons ' + tarea.gifPadre, items: [] };
+                    if (nombreMenu === tarea.nombreAbuelo) {
+                        this._menu[modulo].items.push({ label: nombreMenu, icon: 'glyphicons ' + tarea.gifPadre, items: [item] });
+                    }
+                    else {
+                        this._menu[modulo].items.push(item);
+                    }
+                }
+                else {
+                    if (nombreMenu === tarea.nombreAbuelo) {
+                        item = item.items.find((item) => item.label == tarea.nombrePadre);
+                    }
+                }
+                if (item) {
+                    if (item.items) {
+                        const link = tarea.urlprincipal.replace(/.jsf/, '');
+                        item.items.push({ label: tarea.descripcion, routerLink: link });
+                    }
+                }
+            });
+        }));
+        /********************************************************/
+    }
+    setTareasDelModulo(modulo) {
+        this._menuSource.next(this._menu[modulo]);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: MenuService, deps: [{ token: i1.StorageService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: MenuService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: MenuService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.StorageService }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,68 @@
+import { Injectable } from '@angular/core';
+import { jwtDecode } from "jwt-decode";
+import * as i0 from "@angular/core";
+import * as i1 from "./utils.service";
+export class StorageService {
+    utilsService;
+    constructor(utilsService) {
+        this.utilsService = utilsService;
+    }
+    rolSeleccionado;
+    setRolSeleccionado(rolSeleccionado) {
+        this.rolSeleccionado = rolSeleccionado;
+    }
+    /**
+     * Guarda un valor string en la clave dada dentro del localStorage
+     * @param key Clave
+     * @param value Valor en formato texto
+     */
+    setItem(key, value) {
+        localStorage.setItem(this.utilsService.obtenerBase() + '_' + key, value);
+    }
+    /**
+     * Retorna el valor almacenado en el localStorage bajo la clave dada.
+     * Si no existe y se específica un valor por defecto se retorna el valor
+     * por defecto. En caso que no se especifique ningun valor, se retorna
+     * undefined.
+     * @param key clave
+     * @param defaultValue Valor opcional por defecto
+     * @returns string | undefined
+     */
+    getItem(key, defaultValue) {
+        return localStorage.getItem(this.utilsService.obtenerBase() + '_' + key) ?? defaultValue;
+    }
+    /**
+     * Borra del localStorage la clave/valor de la clave dada.
+     * @param key Clave
+     */
+    removeItem(key) {
+        localStorage.removeItem(this.utilsService.obtenerBase() + '_' + key);
+    }
+    /**
+     * Borra todos los datos del localStorage
+     */
+    clear() {
+        localStorage.clear();
+    }
+    getSessionToken() {
+        let tokenEncriptado = localStorage.getItem(this.utilsService.obtenerBase() + '_' + 'token');
+        /*let tokenDecrypt = CryptoJS.AES.decrypt(tokenEncriptado, environment.crypto_secret_key);
+        let tokenDecryptString = tokenDecrypt.toString(CryptoJS.enc.Utf8);
+        let token = JSON.parse(tokenDecryptString);*/
+        return tokenEncriptado;
+    }
+    getDecodedJWT() {
+        let jwt = this.getSessionToken();
+        let tokenDecoded = JSON.parse(JSON.stringify(jwtDecode(jwt)));
+        return tokenDecoded;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: StorageService, deps: [{ token: i1.UtilsService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: StorageService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: StorageService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.UtilsService }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,99 @@
+import { HttpErrorResponse, HttpHeaders, HttpParams } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { TimeoutError, catchError, throwError } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./storage.service";
+import * as i2 from "ngx-cookie-service";
+import * as i3 from "./auth.service";
+import * as i4 from "./utils.service";
+import * as i5 from "./error-interceptor.service";
+import * as i6 from "@angular/common/http";
+export class TemplateService {
+    storageService;
+    cookieService;
+    authService;
+    utilsService;
+    errorInterceptor;
+    http;
+    constructor(storageService, cookieService, authService, utilsService, errorInterceptor, http) {
+        this.storageService = storageService;
+        this.cookieService = cookieService;
+        this.authService = authService;
+        this.utilsService = utilsService;
+        this.errorInterceptor = errorInterceptor;
+        this.http = http;
+        this.handleError = this.handleError.bind(this);
+    }
+    handleError(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.' }));
+        }
+        else if (error instanceof HttpErrorResponse) {
+            if (error.error instanceof ErrorEvent) {
+                // A client-side or network error occurreda
+                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.' }));
+                }
+                else {
+                    this.errorInterceptor.showError(JSON.stringify({ tipo: 'ERR', traza: '.', mensaje: 'Se produjo un error de red. Por favor, inténtelo más tarde.' }));
+                }
+            }
+            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.' }));
+                }
+                else {
+                    console.error(`Error HTTP: ${error.status} - ${error.message}`);
+                }
+            }
+        }
+        if (error.status === 500) {
+            //Llamado a interceptor
+            this.errorInterceptor.showError(JSON.stringify(error.error));
+            // A client-side or network error occurred. Handle it accordingly.
+            console.error('An error occurred:', error.error);
+        }
+        else {
+            // The backend returned an unsuccessful response code.
+            // The response body may contain clues as to what went wrong.
+            console.error(`Backend returned code ${error.status}, body was: `, error.error);
+        }
+        // Return an observable with a user-facing error message.
+        return throwError(() => new Error('Something bad happened; please try again later.'));
+    }
+    async getTemplateColor(urlapinucleo, codigoAplicacion, nombreAplicacion) {
+        if (!this.cookieService.get('urlnucleo')) {
+            this.cookieService.set('urlnucleo', urlapinucleo);
+        }
+        const color = this.storageService.getItem('color');
+        var basePortal = this.utilsService.obtenerBase();
+        if (window.location.href.endsWith('not-found')) {
+            return "#F1710C";
+        }
+        let data = await this.authService.generarTokenPublico(urlapinucleo).toPromise();
+        var headers = new HttpHeaders().set('Authorization', `Bearer ${data.token}`).set('Base', basePortal);
+        if (!color) {
+            const url = `${urlapinucleo}/authentication/inicio`;
+            let params = new HttpParams();
+            params = params.set('numeroAplicacion', codigoAplicacion);
+            params = params.set('tipo', 'color');
+            const response = await this.http.get(url, { params: params, headers: headers }).pipe(catchError(this.handleError)).toPromise();
+            const newColor = response?.colores?.color1;
+            if (newColor) {
+                this.storageService.setItem('color', newColor);
+                return newColor;
+            }
+            return '#ffffff';
+        }
+        return color;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: TemplateService, deps: [{ token: i1.StorageService }, { token: i2.CookieService }, { token: i3.AuthService }, { token: i4.UtilsService }, { token: i5.ErrorIntecertorService }, { token: i6.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: TemplateService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: TemplateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.StorageService }, { type: i2.CookieService }, { type: i3.AuthService }, { type: i4.UtilsService }, { type: i5.ErrorIntecertorService }, { type: i6.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"template.service.js","sourceRoot":"","sources":["../../../../../../src/app/core/servicios/template.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpErrorResponse, HttpHeaders, HttpParams } from '@angular/common/http';\r\nimport { Injectable, Inject } from '@angular/core';\r\nimport { TimeoutError, catchError, firstValueFrom, throwError } from 'rxjs';\r\nimport { StorageService } from './storage.service';\r\nimport { AuthService } from './auth.service';\r\nimport { CookieService } from 'ngx-cookie-service';\r\nimport { UtilsService } from './utils.service';\r\nimport { ErrorIntecertorService } from './error-interceptor.service';\r\nimport { ToastService } from './toast.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class TemplateService {\r\n  constructor(\r\n    private storageService: StorageService,\r\n    private cookieService: CookieService,\r\n    private authService: AuthService,\r\n    private utilsService: UtilsService,\r\n    private errorInterceptor : ErrorIntecertorService,\r\n    private http: HttpClient) {\r\n      this.handleError = this.handleError.bind(this);\r\n    }\r\n\r\n    private handleError(error: HttpErrorResponse) {\r\n      if (error instanceof TimeoutError) {\r\n        this.errorInterceptor.showError(JSON.stringify({tipo: 'ERR', traza: '.', mensaje: 'El servicio no está disponible. Por favor, inténtelo más tarde.'}));\r\n      } else if (error instanceof HttpErrorResponse) {\r\n        if (error.error instanceof ErrorEvent) {\r\n          // A client-side or network error occurreda\r\n          if (error.error.message.includes('ERR_CONNECTION_REFUSED')) {\r\n            this.errorInterceptor.showError(JSON.stringify({tipo: 'ERR', traza: '.', mensaje: 'El servicio no está disponible. Por favor, inténtelo más tarde.'}));\r\n          } else {\r\n            this.errorInterceptor.showError(JSON.stringify({tipo: 'ERR', traza: '.', mensaje: 'Se produjo un error de red. Por favor, inténtelo más tarde.'}));\r\n          }\r\n        } else {\r\n          if (error.status == 0) {\r\n            this.errorInterceptor.showError(JSON.stringify({tipo: 'ERR', traza: '.', mensaje: 'Se produjo un error de red. Por favor, inténtelo más tarde.'}));\r\n          } else {\r\n            console.error(`Error HTTP: ${error.status} - ${error.message}`);\r\n          }\r\n        }\r\n      }\r\n      if (error.status === 500) {\r\n        //Llamado a interceptor\r\n        this.errorInterceptor.showError(JSON.stringify(error.error));\r\n        // A client-side or network error occurred. Handle it accordingly.\r\n        console.error('An error occurred:', error.error);\r\n      } else {\r\n        // The backend returned an unsuccessful response code.\r\n        // The response body may contain clues as to what went wrong.\r\n        console.error(\r\n          `Backend returned code ${error.status}, body was: `, error.error);\r\n      }\r\n      // Return an observable with a user-facing error message.\r\n      return throwError(() => new Error('Something bad happened; please try again later.'));\r\n    }\r\n\r\n\r\n  async getTemplateColor(urlapinucleo, codigoAplicacion, nombreAplicacion): Promise<string> {\r\n    if (!this.cookieService.get('urlnucleo')){\r\n      this.cookieService.set('urlnucleo', urlapinucleo)\r\n    }\r\n    const color = this.storageService.getItem('color');\r\n    var basePortal: string = this.utilsService.obtenerBase();\r\n    if (window.location.href.endsWith('not-found')) {\r\n      return \"#F1710C\";\r\n    }\r\n    let data = await this.authService.generarTokenPublico(urlapinucleo).toPromise();\r\n    var headers = new HttpHeaders().set('Authorization', `Bearer ${data.token}`).set('Base', basePortal);\r\n    if (!color) {\r\n      const url = `${urlapinucleo}/authentication/inicio`;\r\n      let params = new HttpParams();\r\n      params = params.set('numeroAplicacion', codigoAplicacion);\r\n      params = params.set('tipo', 'color');\r\n      const response = await this.http.get(url, { params: params, headers: headers } ).pipe(\r\n        catchError(this.handleError)\r\n      ).toPromise();\r\n      const newColor = (response as any)?.colores?.color1;\r\n\r\n      if (newColor) {\r\n        this.storageService.setItem('color', newColor);\r\n        return newColor;\r\n      }\r\n\r\n      return '#ffffff';\r\n    }\r\n\r\n    return color;\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,91 @@
+import { Injectable } from '@angular/core';
+import Swal from 'sweetalert2';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/api";
+export class ToastService {
+    messageService;
+    _delay = 10000;
+    constructor(messageService) {
+        this.messageService = messageService;
+    }
+    /**
+     * Muestra el toast con el mensaje de éxito enviado.
+     * @param message
+     * @param title
+     */
+    showSuccess(message, title) {
+        this._showMessage('success', title ?? 'OK', message);
+    }
+    /**
+     * Muestra el toast con el mensaje informativo enviado.
+     * @param message
+     * @param title
+     */
+    showInfo(message, title) {
+        this._showMessage('success', title ?? 'Ok', message);
+    }
+    /**
+     * Muestra el toast con el mensaje de advertencia enviado.
+     * @param message
+     * @param title
+     */
+    showWarningPopup(message, title) {
+        message = message.replace(/\n/g, '<br/>');
+        let contenidoHtml = `<p class="msjError" stye="text-align: left;">${message}</p>`;
+        Swal.fire({
+            title: `<span style="color: var(--color-700);">${title ? title : 'Información'}</span>`,
+            html: contenidoHtml,
+            icon: 'success',
+            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 el toast con el mensaje de advertencia enviado.
+     * @param message
+     * @param title
+     */
+    showWarning(message, title) {
+        this._showMessage('warn', title ?? 'Advertencia', message);
+    }
+    /**
+     * Muestra el toast con el mensaje de error enviado.
+     * @param message
+     * @param title
+     */
+    showError(message, title) {
+        this._showMessage('error', title ?? 'Error', message);
+    }
+    /**
+     * Agregar un mensaje al servicio para que el toast lo muestre.
+     * @param severity success | info | warn | error
+     * @param title
+     * @param message
+     */
+    _showMessage(severity, title, message) {
+        this.messageService.add({
+            severity: severity,
+            summary: title,
+            detail: message,
+            life: this._delay,
+            styleClass: 'toast-salto-linea'
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: ToastService, deps: [{ token: i1.MessageService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: ToastService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: ToastService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.MessageService }] });
+//# sourceMappingURL=data:application/json;base64,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