general-library-union 3.0.49 → 3.0.51

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

@@ -0,0 +1,180 @@
+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;
+    storageService;
+    utilsService;
+    constructor(router, authService, storage, errorInterceptor, storageService, utilsService) {
+        this.router = router;
+        this.authService = authService;
+        this.storage = storage;
+        this.errorInterceptor = errorInterceptor;
+        this.storageService = storageService;
+        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.storageService.removeItem('roles');
+                this.storageService.removeItem('autenticacionUsuarioDTO');
+                this.storageService.removeItem('rol_seleccionado');
+                this.storageService.removeItem('token');
+                this.storageService.removeItem('__tareas');
+                this.storageService.removeItem('modulos');
+                this.storageService.removeItem('moduloSeleccionado');
+                if (this.authService.getTokenKey('aplicacion') == '10') {
+                    var idDBSeguridad;
+                    var idSitio;
+                    for (const match of this.urlNavegador.matchAll(/(?<inicio>.*)\/(?<seguridad>.*)\/(?<sitio>.*)\/(?<pagina>.*)/g)) {
+                        idDBSeguridad = match.groups?.['seguridad'];
+                        idSitio = match.groups?.['sitio'];
+                    }
+                    const dataToken = this.obtenerTokenSyncrono(request.url);
+                    const sessionSitio = this.portaltraerSitioSincrono(request.url, idDBSeguridad, idSitio, dataToken.token);
+                    const urlLocal2 = `${idDBSeguridad}/${sessionSitio.codigo}/${sessionSitio.codigoPaginaInicio}`;
+                    this.navegar(urlLocal2);
+                }
+                else {
+                    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);
+        }));
+    }
+    portaltraerSitioSincrono(url, idDBSeguridad, idSitio, token) {
+        const xhr = new XMLHttpRequest();
+        let result;
+        xhr.open('POST', url + '/portal/traerSitio', false);
+        xhr.setRequestHeader('Content-Type', 'application/json');
+        xhr.setRequestHeader('Authorization', `Bearer ${token}`);
+        xhr.setRequestHeader('Base', this.utilsService.obtenerBase());
+        xhr.onreadystatechange = () => {
+            result = JSON.parse(xhr.responseText);
+            result.status = xhr.status;
+        };
+        xhr.send(`{"conexion": "${idDBSeguridad}", "sitio": "${idSitio}", "url": "${window.parent.location.origin}"}`);
+        return result;
+    }
+    obtenerTokenSyncrono(url) {
+        const xhr = new XMLHttpRequest();
+        let result;
+        xhr.open('GET', url + '/authentication/generarTokenPublico', false);
+        xhr.setRequestHeader('Content-Type', 'application/json');
+        xhr.setRequestHeader('Base', this.utilsService.obtenerBase());
+        xhr.onreadystatechange = () => {
+            // if (xhr.readyState === XMLHttpRequest.DONE && xhr.status === 200) {
+            //   result = JSON.parse(xhr.responseText);
+            // }
+            result = JSON.parse(xhr.responseText);
+            result.status = xhr.status;
+        };
+        xhr.send();
+        return result;
+    }
+    navegar(url) {
+        window.location.href = window.location.origin + '/' + url;
+    }
+    get urlNavegador() {
+        const urlPathname = window.location.pathname;
+        return urlPathname;
+    }
+    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: i3.StorageService }, { 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: i3.StorageService }, { 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":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { Router } from '@angular/router';\r\nimport { HttpRequest, HttpHandler, HttpEvent, HttpInterceptor, HttpErrorResponse } from '@angular/common/http';\r\nimport { catchError, EMPTY, from, Observable, throwError, timeout, TimeoutError } from 'rxjs';\r\nimport { AuthService } from '../auth.service';\r\nimport { StorageService } from '../../servicios/storage.service';\r\nimport { UtilsService } from '../utils.service';\r\nimport { ToastService } from '../toast.service';\r\nimport { ErrorIntecertorService } from '../error-interceptor.service';\r\n\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class TokenInterceptorService implements HttpInterceptor {\r\n  constructor(private router: Router, \r\n              private authService: AuthService, \r\n              private storage: StorageService, \r\n              private errorInterceptor: ErrorIntecertorService,\r\n              private storageService: StorageService,\r\n              private utilsService: UtilsService) {}\r\n  \r\n  intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>{\r\n    return  from(this.interceptDetalle(request, next)).pipe(\r\n      catchError((error: any) => {\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.'}).toString());\r\n        } else if (error instanceof HttpErrorResponse) {\r\n          if (error.error instanceof ErrorEvent) {\r\n            // A client-side or network error occurred\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.'}).toString());\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.'}).toString());\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.'}).toString());\r\n            } else {\r\n              console.error(`Error HTTP: ${error.status} - ${error.message}`);\r\n            }\r\n          }\r\n        }\r\n        return throwError(error);\r\n      })\r\n    );\r\n  }\r\n\r\n  async interceptDetalle(request: HttpRequest<any>, next: HttpHandler): Promise<HttpEvent<any>>  {\r\n    if (request.url.includes('/requieretoken') && !request.url.includes('/portalPublico')) {\r\n      let token = this.authService.getToken();\r\n      if (token){\r\n        let fechaActual = new Date();\r\n        let fechaExpTokenIni = new Date(this.storage.getDecodedJWT().exp * 1000)\r\n        let fechaExpTokenFin = new Date(this.storage.getDecodedJWT().exp * 1000)\r\n        fechaExpTokenIni.setMinutes(fechaExpTokenIni.getMinutes() - 10);\r\n        if (fechaActual >= fechaExpTokenIni && fechaActual<=fechaExpTokenFin){\r\n          var tokenPublico = await this.authService.generarTokenPublico().toPromise()\r\n          var tokenRefrescar = await this.authService.refrescarToken({token: token }, (tokenPublico as any)?.token as string).toPromise();\r\n          token = (tokenRefrescar as any)?.token as string;\r\n          this.authService.deleteToken()\r\n          this.storage.setItem('token', token);\r\n        }\r\n      }\r\n    }\r\n    return await this.setearTokenRequest(request, next).toPromise();\r\n  } \r\n\r\n  setearTokenRequest(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>{\r\n    var basePortal: string = this.utilsService.obtenerBase();\r\n    let token = this.authService.getToken();\r\n    if (request.url.includes('/requieretoken') && !request.url.includes('/portalPublico')) {\r\n      request = request.clone({\r\n        headers: request.headers.set('Authorization', `Bearer ${token}`),\r\n      });\r\n    }\r\n\r\n    request = request.clone({\r\n      headers: request.headers.set('Base', basePortal),\r\n    });\r\n\r\n    return next.handle(request).pipe(\r\n      catchError((error) => {\r\n        if (error.status === 401) {\r\n          this.authService.deleteToken();\r\n          this.storageService.removeItem('roles')\r\n          this.storageService.removeItem('autenticacionUsuarioDTO')\r\n          this.storageService.removeItem('rol_seleccionado')\r\n          this.storageService.removeItem('token')\r\n          this.storageService.removeItem('__tareas')\r\n          this.storageService.removeItem('modulos')\r\n          this.storageService.removeItem('moduloSeleccionado')\r\n          if (this.authService.getTokenKey('aplicacion') == '10') {\r\n            var idDBSeguridad;\r\n            var idSitio;\r\n            for (const match of this.urlNavegador.matchAll(/(?<inicio>.*)\\/(?<seguridad>.*)\\/(?<sitio>.*)\\/(?<pagina>.*)/g)) {\r\n              idDBSeguridad = match.groups?.['seguridad'];\r\n              idSitio = match.groups?.['sitio'];\r\n            }\r\n            const dataToken = this.obtenerTokenSyncrono(request.url);\r\n            const sessionSitio = this.portaltraerSitioSincrono(request.url, idDBSeguridad, idSitio, dataToken.token);\r\n            const urlLocal2 = `${idDBSeguridad}/${sessionSitio.codigo}/${sessionSitio.codigoPaginaInicio}`;\r\n            this.navegar(urlLocal2);\r\n          } else {\r\n            this.router.navigateByUrl(this.utilsService.obtenerBase() + '/login');\r\n          }\r\n          return EMPTY;\r\n        }\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.'}).toString());\r\n        } else if (error instanceof HttpErrorResponse) {\r\n          if (error.error instanceof ErrorEvent) {\r\n            // A client-side or network error occurred\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.'}).toString());\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.'}).toString());\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.'}).toString());\r\n            } else {\r\n              console.error(`Error HTTP: ${error.status} - ${error.message}`);\r\n            }\r\n          }\r\n        }\r\n        return throwError(() => error);\r\n      })\r\n    );\r\n  }\r\n\r\n  portaltraerSitioSincrono(url: string, idDBSeguridad: any, idSitio: any, token: string): any {\r\n    const xhr = new XMLHttpRequest();\r\n    let result;\r\n\r\n    xhr.open('POST', url+'/portal/traerSitio', false); \r\n    xhr.setRequestHeader('Content-Type', 'application/json');\r\n    xhr.setRequestHeader('Authorization', `Bearer ${token}`);\r\n    xhr.setRequestHeader('Base', this.utilsService.obtenerBase());\r\n    xhr.onreadystatechange = () => {      \r\n      result = JSON.parse(xhr.responseText);\r\n      result.status = xhr.status;\r\n    };\r\n    xhr.send(`{\"conexion\": \"${idDBSeguridad}\", \"sitio\": \"${idSitio}\", \"url\": \"${window.parent.location.origin}\"}`);\r\n\r\n    return result;\r\n  }\r\n\r\n  obtenerTokenSyncrono(url): any {\r\n    const xhr = new XMLHttpRequest();\r\n    let result;\r\n\r\n    xhr.open('GET', url+'/authentication/generarTokenPublico', false); \r\n    xhr.setRequestHeader('Content-Type', 'application/json');\r\n    xhr.setRequestHeader('Base', this.utilsService.obtenerBase());\r\n    xhr.onreadystatechange = () => {\r\n      // if (xhr.readyState === XMLHttpRequest.DONE && xhr.status === 200) {\r\n      //   result = JSON.parse(xhr.responseText);\r\n      // }\r\n      result = JSON.parse(xhr.responseText);\r\n      result.status = xhr.status;\r\n    };\r\n    xhr.send();\r\n\r\n    return result;\r\n  }\r\n\r\n  private navegar(url: any) {\r\n    window.location.href = window.location.origin + '/' + url;\r\n  }\r\n\r\n  get urlNavegador(): string {\r\n    const urlPathname = window.location.pathname;\r\n    return urlPathname;\r\n  }\r\n\r\n}\r\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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

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

@@ -0,0 +1,146 @@
+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) => {
+            const arbolTareas = [];
+            let nodoBase = null;
+            let nodoHijo = null;
+            for (const unaTarea of tareas) {
+                const modulo = unaTarea.modulo + '';
+                if (!(modulo in this._menu)) {
+                    this._menu[modulo] = { label: unaTarea.nombreModulo, items: [] };
+                }
+                if (!unaTarea.nombrePadre) {
+                    arbolTareas.push(unaTarea);
+                    continue;
+                }
+                nodoBase = null;
+                // Buscar en el primer nivel
+                for (const unNodo of arbolTareas) {
+                    if (unNodo.tipo !== "M") {
+                        continue;
+                    }
+                    if (unaTarea.nombreAbuelo && unNodo.descripcion === unaTarea.nombreAbuelo && unNodo.modulo === unaTarea.modulo) {
+                        // Buscar en el segundo nivel
+                        for (const unNodo2 of unNodo.listaTareas || []) {
+                            if (unNodo2.tipo !== "M") {
+                                continue;
+                            }
+                            if (unNodo2.descripcion === unaTarea.nombrePadre && unNodo2.modulo === unaTarea.modulo) {
+                                nodoBase = unNodo2;
+                                break;
+                            }
+                        }
+                        if (!nodoBase) {
+                            nodoHijo = {
+                                descripcion: unaTarea.nombrePadre,
+                                gif: unaTarea.gifPadre,
+                                tipo: "M",
+                                listaTareas: [],
+                                modulo: unaTarea.modulo,
+                            };
+                            unNodo.listaTareas.push(nodoHijo);
+                            nodoBase = nodoHijo;
+                        }
+                        break;
+                    }
+                    if (unNodo.descripcion === unaTarea.nombrePadre && unNodo.modulo === unaTarea.modulo) {
+                        nodoBase = unNodo;
+                        break;
+                    }
+                }
+                if (!nodoBase) {
+                    nodoBase = {
+                        descripcion: unaTarea.nombreAbuelo || unaTarea.nombrePadre,
+                        gif: unaTarea.nombreAbuelo ? unaTarea.gifAbuelo : unaTarea.gifPadre,
+                        orden: unaTarea.nombreAbuelo ? unaTarea.ordenAbuelo : unaTarea.ordenPadre,
+                        tipo: "M",
+                        listaTareas: [],
+                        modulo: unaTarea.modulo,
+                    };
+                    arbolTareas.push(nodoBase);
+                    if (unaTarea.nombreAbuelo) {
+                        nodoHijo = {
+                            descripcion: unaTarea.nombrePadre,
+                            gif: unaTarea.gifPadre,
+                            tipo: "M",
+                            listaTareas: [],
+                            modulo: unaTarea.modulo,
+                        };
+                        nodoBase.listaTareas.push(nodoHijo);
+                        nodoBase = nodoHijo;
+                    }
+                }
+                nodoBase.listaTareas.push(unaTarea);
+            }
+            let respuesta = this.convertToMenuItems(arbolTareas);
+            respuesta.forEach(dato => {
+                const modulo = dato.tabindex;
+                this._menu[modulo].items.push(dato);
+            });
+        }));
+        /********************************************************/
+    }
+    convertToMenuItems(tareas) {
+        return tareas.map(tarea => {
+            const menuItem = {
+                label: tarea.descripcion,
+                icon: tarea.gif ? 'glyphicons ' + tarea.gif : undefined,
+                routerLink: tarea.urlprincipal ? tarea.urlprincipal.replace(/.jsf/, '') : undefined,
+                tabindex: tarea.modulo,
+                items: tarea.listaTareas ? this.convertToMenuItems(tarea.listaTareas) : undefined
+            };
+            return menuItem;
+        });
+    }
+    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,{"version":3,"file":"menu.service.js","sourceRoot":"","sources":["../../../../../../src/app/core/servicios/menu.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { MenuItem } from 'primeng/api/menuitem';\r\nimport { map, Observable, of, ReplaySubject, Subject } from 'rxjs';\r\nimport { StorageService } from './storage.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class MenuService {\r\n  private _menu: { [key: string]: MenuItem } = {};\r\n  private _menuSource = new Subject<MenuItem>();\r\n  private _breadcrumbSource = new Subject<MenuItem[]>();\r\n  private _menuObservable$ = this._menuSource.asObservable();\r\n  private _breadcrumbObservable$ = this._breadcrumbSource.asObservable();\r\n\r\n  constructor(private storageService: StorageService) {}\r\n\r\n  /**\r\n   * Observable para los eventos del breadcrumb\r\n   */\r\n  get breadcrumb() {\r\n    return this._breadcrumbObservable$;\r\n  }\r\n\r\n  /**\r\n   * Observable para el menu principal\r\n   */\r\n  get menu() {\r\n    return this._menuObservable$;\r\n  }\r\n\r\n  /**\r\n   * Agrega items al breadcrumb\r\n   * @param items\r\n   */\r\n  setBreadcrumb(items: MenuItem[]): void {\r\n    this._breadcrumbSource.next(items);\r\n  }\r\n\r\n  /**\r\n   * Consulta la lista de tareas del usuario para cargar el menú\r\n   * @returns\r\n   */\r\n  loadTareas(): Observable<void> {\r\n    /********************************************************/\r\n    /* Se debe cambiar con el request al servicio de tareas */\r\n    this._menu = {}\r\n    return of(JSON.parse(this.storageService.getItem('__tareas'))).pipe(\r\n      map((tareas: any[]) => {\r\n        const arbolTareas: any[] = [];\r\n\r\n     let nodoBase = null;\r\n     let nodoHijo = null;\r\n   \r\n     for (const unaTarea of tareas) {\r\n      const modulo = unaTarea.modulo+'';\r\n        if (!(modulo in this._menu)) {\r\n          this._menu[modulo] = { label: unaTarea.nombreModulo, items: [] };\r\n        }\r\n       if (!unaTarea.nombrePadre) {\r\n         arbolTareas.push(unaTarea);\r\n         continue;\r\n       }\r\n   \r\n       nodoBase = null;\r\n   \r\n       // Buscar en el primer nivel\r\n       for (const unNodo of arbolTareas) {\r\n        if (unNodo.tipo !== \"M\") {\r\n          continue;\r\n        }\r\n        if (unaTarea.nombreAbuelo && unNodo.descripcion === unaTarea.nombreAbuelo && unNodo.modulo === unaTarea.modulo) {\r\n          // Buscar en el segundo nivel\r\n          for (const unNodo2 of unNodo.listaTareas || []) {\r\n            if (unNodo2.tipo !== \"M\") {\r\n              continue;\r\n            }\r\n            if (unNodo2.descripcion === unaTarea.nombrePadre && unNodo2.modulo === unaTarea.modulo)  {\r\n              nodoBase = unNodo2;\r\n              break;\r\n            }\r\n          }\r\n          if (!nodoBase) {\r\n            nodoHijo = {\r\n              descripcion: unaTarea.nombrePadre,\r\n              gif: unaTarea.gifPadre,\r\n              tipo: \"M\",\r\n              listaTareas: [],\r\n              modulo: unaTarea.modulo,\r\n            };\r\n            unNodo.listaTareas!.push(nodoHijo);\r\n            nodoBase = nodoHijo;\r\n          }\r\n          break;\r\n        }\r\n        if (unNodo.descripcion === unaTarea.nombrePadre && unNodo.modulo === unaTarea.modulo) {\r\n          nodoBase = unNodo;\r\n          break;\r\n        }\r\n      }\r\n  \r\n      if (!nodoBase) {\r\n        nodoBase = {\r\n          descripcion: unaTarea.nombreAbuelo || unaTarea.nombrePadre,\r\n          gif: unaTarea.nombreAbuelo ? unaTarea.gifAbuelo : unaTarea.gifPadre,\r\n          orden: unaTarea.nombreAbuelo ? unaTarea.ordenAbuelo : unaTarea.ordenPadre,\r\n          tipo: \"M\",\r\n          listaTareas: [],\r\n          modulo: unaTarea.modulo,\r\n        };\r\n        arbolTareas.push(nodoBase);\r\n  \r\n        if (unaTarea.nombreAbuelo) {\r\n          nodoHijo = {\r\n            descripcion: unaTarea.nombrePadre,\r\n            gif: unaTarea.gifPadre,\r\n            tipo: \"M\",\r\n            listaTareas: [], \r\n            modulo: unaTarea.modulo,\r\n          };\r\n          nodoBase.listaTareas!.push(nodoHijo);\r\n          nodoBase = nodoHijo;\r\n        }\r\n      }\r\n      nodoBase.listaTareas!.push(unaTarea);\r\n    }\r\n     let respuesta = this.convertToMenuItems(arbolTareas);\r\n     respuesta.forEach(dato => {\r\n      const modulo = dato.tabindex;\r\n      this._menu[modulo].items.push(dato);\r\n     }) \r\n      })\r\n    );\r\n    /********************************************************/\r\n  }\r\n\r\n  convertToMenuItems(tareas: any[]): MenuItem[] {\r\n    return tareas.map(tarea => {\r\n      const menuItem: MenuItem = {\r\n        label: tarea.descripcion,\r\n        icon: tarea.gif ? 'glyphicons ' + tarea.gif : undefined,\r\n        routerLink: tarea.urlprincipal ? tarea.urlprincipal.replace(/.jsf/, '') : undefined,\r\n        tabindex: tarea.modulo,\r\n        items: tarea.listaTareas ? this.convertToMenuItems(tarea.listaTareas) : undefined\r\n      };\r\n      return menuItem;\r\n    });\r\n  }\r\n\r\n  setTareasDelModulo(modulo: string): void {\r\n    this._menuSource.next(this._menu[modulo]);\r\n  }\r\n}\r\n"]}

package/esm2022/src/app/core/servicios/spinner-service.mjs

@@ -0,0 +1,22 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class SpinnerService {
+    spinnerSubject = new BehaviorSubject(false);
+    spinner$ = this.spinnerSubject.asObservable();
+    show() {
+        this.spinnerSubject.next(true);
+    }
+    hide() {
+        this.spinnerSubject.next(false);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: SpinnerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: SpinnerService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: SpinnerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3Bpbm5lci1zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL2FwcC9jb3JlL3NlcnZpY2lvcy9zcGlubmVyLXNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sTUFBTSxDQUFDOztBQUt2QyxNQUFNLE9BQU8sY0FBYztJQUNqQixjQUFjLEdBQUcsSUFBSSxlQUFlLENBQVUsS0FBSyxDQUFDLENBQUM7SUFDN0QsUUFBUSxHQUFHLElBQUksQ0FBQyxjQUFjLENBQUMsWUFBWSxFQUFFLENBQUM7SUFFOUMsSUFBSTtRQUNGLElBQUksQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ2pDLENBQUM7SUFFRCxJQUFJO1FBQ0YsSUFBSSxDQUFDLGNBQWMsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDbEMsQ0FBQzt1R0FWVSxjQUFjOzJHQUFkLGNBQWMsY0FGYixNQUFNOzsyRkFFUCxjQUFjO2tCQUgxQixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgQmVoYXZpb3JTdWJqZWN0IH0gZnJvbSAncnhqcyc7XHJcblxyXG5ASW5qZWN0YWJsZSh7XHJcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBTcGlubmVyU2VydmljZSB7XHJcbiAgcHJpdmF0ZSBzcGlubmVyU3ViamVjdCA9IG5ldyBCZWhhdmlvclN1YmplY3Q8Ym9vbGVhbj4oZmFsc2UpO1xyXG4gIHNwaW5uZXIkID0gdGhpcy5zcGlubmVyU3ViamVjdC5hc09ic2VydmFibGUoKTtcclxuXHJcbiAgc2hvdygpOiB2b2lkIHtcclxuICAgIHRoaXMuc3Bpbm5lclN1YmplY3QubmV4dCh0cnVlKTtcclxuICB9XHJcblxyXG4gIGhpZGUoKTogdm9pZCB7XHJcbiAgICB0aGlzLnNwaW5uZXJTdWJqZWN0Lm5leHQoZmFsc2UpO1xyXG4gIH1cclxufVxyXG4iXX0=

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