general-library-union 3.2.96 → 3.2.97

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

@@ -0,0 +1,177 @@
+import { Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import { HttpRequest, HttpHandler, HttpEvent, HttpInterceptor, HttpErrorResponse } from '@angular/common/http';
+import { catchError, EMPTY, from, Observable, throwError, timeout, TimeoutError } from 'rxjs';
+import { AuthService } from '../auth.service';
+import { StorageService } from '../../servicios/storage.service';
+import { UtilsService } from '../utils.service';
+import { ToastService } from '../toast.service';
+import { ErrorIntecertorService } from '../error-interceptor.service';
+
+
+@Injectable({
+  providedIn: 'root',
+})
+export class TokenInterceptorService implements HttpInterceptor {
+  constructor(private router: Router, 
+              private authService: AuthService, 
+              private storage: StorageService, 
+              private errorInterceptor: ErrorIntecertorService,
+              private storageService: StorageService,
+              private utilsService: UtilsService) {}
+  
+  intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>{
+    return  from(this.interceptDetalle(request, next)).pipe(
+      catchError((error: any) => {
+        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: HttpRequest<any>, next: HttpHandler): Promise<HttpEvent<any>>  {
+    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 as any)?.token as string).toPromise();
+          token = (tokenRefrescar as any)?.token as string;
+          this.authService.deleteToken()
+          this.storage.setItem('token', token);
+        }
+      }
+    }
+    return await this.setearTokenRequest(request, next).toPromise();
+  } 
+
+  setearTokenRequest(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>{
+    var basePortal: string = 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: string, idDBSeguridad: any, idSitio: any, token: string): any {
+    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): any {
+    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;
+  }
+
+  private navegar(url: any) {
+    window.location.href = window.location.origin + '/' + url;
+  }
+
+  get urlNavegador(): string {
+    const urlPathname = window.location.pathname;
+    return urlPathname;
+  }
+
+}

package/src/app/core/servicios/loading.service.ts

@@ -0,0 +1,48 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class LoadingService {
+
+  private _loadingFullScreen: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);
+  private _loadingFullScreenObservable$ = this._loadingFullScreen.asObservable();
+
+  private _loadingBreadCrumb: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);
+  private _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$;
+  }
+
+  public startFullScreenLoading(): void{
+    this._loadingFullScreen.next(true);
+  }
+
+  public endFullScreenLoading(): void {
+    this._loadingFullScreen.next(false);
+  }
+
+  public startBreadCrumLoading(): void {
+    this._loadingBreadCrumb.next(true);
+  }
+
+  public endBreadCrumLoading(): void {
+    this._loadingBreadCrumb.next(false);
+  }
+
+}

package/src/app/core/servicios/menu.service.ts

@@ -0,0 +1,153 @@
+import { Injectable } from '@angular/core';
+import { MenuItem } from 'primeng/api/menuitem';
+import { map, Observable, of, ReplaySubject, Subject } from 'rxjs';
+import { StorageService } from './storage.service';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class MenuService {
+  private _menu: { [key: string]: MenuItem } = {};
+  private _menuSource = new Subject<MenuItem>();
+  private _breadcrumbSource = new Subject<MenuItem[]>();
+  private _menuObservable$ = this._menuSource.asObservable();
+  private _breadcrumbObservable$ = this._breadcrumbSource.asObservable();
+
+  constructor(private 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: MenuItem[]): void {
+    this._breadcrumbSource.next(items);
+  }
+
+  /**
+   * Consulta la lista de tareas del usuario para cargar el menú
+   * @returns
+   */
+  loadTareas(): Observable<void> {
+    /********************************************************/
+    /* Se debe cambiar con el request al servicio de tareas */
+    this._menu = {}
+    return of(JSON.parse(this.storageService.getItem('__tareas'))).pipe(
+      map((tareas: any[]) => {
+        const arbolTareas: any[] = [];
+
+     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: any[]): MenuItem[] {
+    return tareas.map(tarea => {
+      const menuItem: 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: string): void {
+    this._menuSource.next(this._menu[modulo]);
+  }
+}

package/src/app/core/servicios/spinner-service.ts

@@ -0,0 +1,18 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class SpinnerService {
+  private spinnerSubject = new BehaviorSubject<boolean>(false);
+  spinner$ = this.spinnerSubject.asObservable();
+
+  show(): void {
+    this.spinnerSubject.next(true);
+  }
+
+  hide(): void {
+    this.spinnerSubject.next(false);
+  }
+}

package/src/app/core/servicios/storage.service.ts

@@ -0,0 +1,68 @@
+import { Injectable } from '@angular/core';
+import { UtilsService } from './utils.service';
+import { jwtDecode } from "jwt-decode";
+
+@Injectable({
+  providedIn: 'root',
+})
+export class StorageService {
+  constructor(private utilsService: UtilsService) {}
+
+  private 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: string, value: string): void {
+    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: string, defaultValue?: string): string | undefined {
+    return localStorage.getItem(this.utilsService.obtenerBase() + '_' +  key) ?? defaultValue;
+  }
+
+  /**
+   * Borra del localStorage la clave/valor de la clave dada.
+   * @param key Clave
+   */
+  removeItem(key: string): void {
+    localStorage.removeItem(this.utilsService.obtenerBase() + '_' + key);
+  }
+
+  /**
+   * Borra todos los datos del localStorage
+   */
+  clear(): void {
+    localStorage.clear();
+  }
+
+  getSessionToken() {
+    let tokenEncriptado: any = 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;
+  }
+}

package/src/app/core/servicios/template.service.ts

@@ -0,0 +1,91 @@
+import { HttpClient, HttpErrorResponse, HttpHeaders, HttpParams } from '@angular/common/http';
+import { Injectable, Inject } from '@angular/core';
+import { TimeoutError, catchError, firstValueFrom, throwError } from 'rxjs';
+import { StorageService } from './storage.service';
+import { AuthService } from './auth.service';
+import { CookieService } from 'ngx-cookie-service';
+import { UtilsService } from './utils.service';
+import { ErrorIntecertorService } from './error-interceptor.service';
+import { ToastService } from './toast.service';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class TemplateService {
+  constructor(
+    private storageService: StorageService,
+    private cookieService: CookieService,
+    private authService: AuthService,
+    private utilsService: UtilsService,
+    private errorInterceptor : ErrorIntecertorService,
+    private http: HttpClient) {
+      this.handleError = this.handleError.bind(this);
+    }
+
+    private handleError(error: HttpErrorResponse) {
+      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): Promise<string> {
+    if (!this.cookieService.get('urlnucleo')){
+      this.cookieService.set('urlnucleo', urlapinucleo)
+    }
+    const color = this.storageService.getItem('color');
+    var basePortal: string = 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 as any)?.colores?.color1;
+
+      if (newColor) {
+        this.storageService.setItem('color', newColor);
+        return newColor;
+      }
+
+      return '#ffffff';
+    }
+
+    return color;
+  }
+}

package/src/app/core/servicios/toast.service.ts

@@ -0,0 +1,114 @@
+import { Injectable } from '@angular/core';
+import { MessageService } from 'primeng/api';
+import Swal from 'sweetalert2';
+import { UtilsService } from './utils.service';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class ToastService {
+  private _delay: number = 3000;
+
+  constructor(private messageService: MessageService, private utilsService: UtilsService) {}
+
+  /**
+   * Muestra el toast con el mensaje de éxito enviado.
+   * @param message
+   * @param title
+   */
+  showSuccess(message: string, title?: string): void {
+    this._showMessage('success', title ?? 'OK', message);
+  }
+
+  /**
+   * Muestra el toast con el mensaje informativo enviado.
+   * @param message
+   * @param title
+   */
+  showInfo(message: string, title?: string): void {
+    this._showMessage('success', title ?? 'Ok', message);
+  }
+
+  /**
+   * Muestra el toast con el mensaje de advertencia enviado.
+   * @param message
+   * @param title
+   */
+  showWarningPopup(message: string, title?: string): void {
+    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();
+            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();
+        })
+      }
+    });
+  }
+
+  /**
+   * Muestra el toast con el mensaje de advertencia enviado.
+   * @param message
+   * @param title
+   */
+  showWarning(message: string, title?: string): void {
+    this._showMessage('warn', title ?? 'Advertencia', message);
+  }
+
+  /**
+   * Muestra el toast con el mensaje de error enviado.
+   * @param message
+   * @param title
+   */
+  showError(message: string, title?: string): void {
+    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
+   */
+  private _showMessage(severity: string, title: string, message: string): void {
+    console.log('_showMessage')
+    console.log(window['env']['codigoAplicacion'])
+    if ('10' == window['env']['codigoAplicacion']) {
+      window.parent.postMessage({ type: 'toast', data: { severity: severity , summary: title, detail: message } }, '*');
+    } else {
+      this.messageService.add({
+        severity: severity,
+        summary: title,
+        detail: message,
+        life: this._delay,
+        styleClass: 'toast-salto-linea'
+      });
+    }
+    
+  }
+}