general-library-union 3.1.35 → 3.1.37

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';\nimport { Injectable, Inject } from '@angular/core';\nimport { TimeoutError, catchError, firstValueFrom, throwError } from 'rxjs';\nimport { StorageService } from './storage.service';\nimport { AuthService } from './auth.service';\nimport { CookieService } from 'ngx-cookie-service';\nimport { UtilsService } from './utils.service';\nimport { ErrorIntecertorService } from './error-interceptor.service';\nimport { ToastService } from './toast.service';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class TemplateService {\n  constructor(\n    private storageService: StorageService,\n    private cookieService: CookieService,\n    private authService: AuthService,\n    private utilsService: UtilsService,\n    private errorInterceptor : ErrorIntecertorService,\n    private http: HttpClient) {\n      this.handleError = this.handleError.bind(this);\n    }\n\n    private handleError(error: HttpErrorResponse) {\n      if (error instanceof TimeoutError) {\n        this.errorInterceptor.showError(JSON.stringify({tipo: 'ERR', traza: '.', mensaje: 'El servicio no está disponible. Por favor, inténtelo más tarde.'}));\n      } else if (error instanceof HttpErrorResponse) {\n        if (error.error instanceof ErrorEvent) {\n          // A client-side or network error occurreda\n          if (error.error.message.includes('ERR_CONNECTION_REFUSED')) {\n            this.errorInterceptor.showError(JSON.stringify({tipo: 'ERR', traza: '.', mensaje: 'El servicio no está disponible. Por favor, inténtelo más tarde.'}));\n          } else {\n            this.errorInterceptor.showError(JSON.stringify({tipo: 'ERR', traza: '.', mensaje: 'Se produjo un error de red. Por favor, inténtelo más tarde.'}));\n          }\n        } else {\n          if (error.status == 0) {\n            this.errorInterceptor.showError(JSON.stringify({tipo: 'ERR', traza: '.', mensaje: 'Se produjo un error de red. Por favor, inténtelo más tarde.'}));\n          } else {\n            console.error(`Error HTTP: ${error.status} - ${error.message}`);\n          }\n        }\n      }\n      if (error.status === 500) {\n        //Llamado a interceptor\n        this.errorInterceptor.showError(JSON.stringify(error.error));\n        // A client-side or network error occurred. Handle it accordingly.\n        console.error('An error occurred:', error.error);\n      } else {\n        // The backend returned an unsuccessful response code.\n        // The response body may contain clues as to what went wrong.\n        console.error(\n          `Backend returned code ${error.status}, body was: `, error.error);\n      }\n      // Return an observable with a user-facing error message.\n      return throwError(() => new Error('Something bad happened; please try again later.'));\n    }\n\n\n  async getTemplateColor(urlapinucleo, codigoAplicacion, nombreAplicacion): Promise<string> {\n    if (!this.cookieService.get('urlnucleo')){\n      this.cookieService.set('urlnucleo', urlapinucleo)\n    }\n    const color = this.storageService.getItem('color');\n    var basePortal: string = this.utilsService.obtenerBase();\n    if (window.location.href.endsWith('not-found')) {\n      return \"#F1710C\";\n    }\n    let data = await this.authService.generarTokenPublico(urlapinucleo).toPromise();\n    var headers = new HttpHeaders().set('Authorization', `Bearer ${data.token}`).set('Base', basePortal);\n    if (!color) {\n      const url = `${urlapinucleo}/authentication/inicio`;\n      let params = new HttpParams();\n      params = params.set('numeroAplicacion', codigoAplicacion);\n      params = params.set('tipo', 'color');\n      const response = await this.http.get(url, { params: params, headers: headers } ).pipe(\n        catchError(this.handleError)\n      ).toPromise();\n      const newColor = (response as any)?.colores?.color1;\n\n      if (newColor) {\n        this.storageService.setItem('color', newColor);\n        return newColor;\n      }\n\n      return '#ffffff';\n    }\n\n    return color;\n  }\n}\n"]}

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

@@ -0,0 +1,120 @@
+import { Injectable } from '@angular/core';
+import Swal from 'sweetalert2';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/api";
+import * as i2 from "./utils.service";
+export class ToastService {
+    messageService;
+    utilsService;
+    _delay = 10000;
+    constructor(messageService, utilsService) {
+        this.messageService = messageService;
+        this.utilsService = utilsService;
+    }
+    /**
+     * 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();
+                    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, 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) {
+        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'
+            });
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: ToastService, deps: [{ token: i1.MessageService }, { token: i2.UtilsService }], 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 }, { type: i2.UtilsService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toast.service.js","sourceRoot":"","sources":["../../../../../../src/app/core/servicios/toast.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { MessageService } from 'primeng/api';\nimport Swal from 'sweetalert2';\nimport { UtilsService } from './utils.service';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ToastService {\n  private _delay: number = 10000;\n\n  constructor(private messageService: MessageService, private utilsService: UtilsService) {}\n\n  /**\n   * Muestra el toast con el mensaje de éxito enviado.\n   * @param message\n   * @param title\n   */\n  showSuccess(message: string, title?: string): void {\n    this._showMessage('success', title ?? 'OK', message);\n  }\n\n  /**\n   * Muestra el toast con el mensaje informativo enviado.\n   * @param message\n   * @param title\n   */\n  showInfo(message: string, title?: string): void {\n    this._showMessage('success', title ?? 'Ok', message);\n  }\n\n  /**\n   * Muestra el toast con el mensaje de advertencia enviado.\n   * @param message\n   * @param title\n   */\n  showWarningPopup(message: string, title?: string): void {\n    message = message.replace(/\\n/g, '<br/>');\n    let contenidoHtml = `<p class=\"msjError\" stye=\"text-align: left;\">${message}</p>`\n    Swal.fire({\n      title:`<span style=\"color: var(--color-700);\">${title ? title : 'Información'}</span>`,\n      html: contenidoHtml,\n      icon: 'success',\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\n  /**\n   * Muestra el toast con el mensaje de advertencia enviado.\n   * @param message\n   * @param title\n   */\n  showWarning(message: string, title?: string): void {\n    this._showMessage('warn', title ?? 'Advertencia', message);\n  }\n\n  /**\n   * Muestra el toast con el mensaje de error enviado.\n   * @param message\n   * @param title\n   */\n  showError(message: string, title?: string): void {\n    this._showMessage('error', title ?? 'Error', message);\n  }\n\n  /**\n   * Agregar un mensaje al servicio para que el toast lo muestre.\n   * @param severity success | info | warn | error\n   * @param title\n   * @param message\n   */\n  private _showMessage(severity: string, title: string, message: string): void {\n    console.log('_showMessage')\n    console.log(window['env']['codigoAplicacion'])\n    if ('10' == window['env']['codigoAplicacion']) {\n      window.parent.postMessage({ type: 'toast', data: { severity: severity , summary: title, detail: message } }, '*');\n    } else {\n      this.messageService.add({\n        severity: severity,\n        summary: title,\n        detail: message,\n        life: this._delay,\n        styleClass: 'toast-salto-linea'\n      });\n    }\n    \n  }\n}\n"]}