general-library-union 2.8.18 → 2.8.19

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"]}

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

@@ -0,0 +1,335 @@
+import { Inject, Injectable } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-cookie-service";
+export class UtilsService {
+    cookieService;
+    document;
+    RESERVADAS_SQL_NOPUEDECONTENER = [';'];
+    reservadas = ['ALTER', 'DELETE', 'DROP', 'MODIFY', 'CREATE', 'DATABASE', 'TABLE', 'UPDATE', 'TRIGGER', 'GRANT', 'REVOKE', 'CALL', 'INSERT', 'TRUNCATE', 'USE', '--'];
+    constructor(cookieService, document) {
+        this.cookieService = cookieService;
+        this.document = document;
+    }
+    generarLlave() {
+        let result = '';
+        const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        const charactersLength = 32;
+        for (let i = 0; i < charactersLength; i++) {
+            result += characters.charAt(Math.floor(Math.random() * charactersLength));
+        }
+        return result.toLowerCase();
+    }
+    generarPin(cantidad) {
+        let result = '';
+        const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        for (let i = 0; i < cantidad; i++) {
+            result += characters.charAt(Math.floor(Math.random() * cantidad));
+        }
+        return result.toLowerCase();
+    }
+    rightpad(str, length, char) {
+        if (str === undefined) {
+            return null;
+        }
+        if (typeof str !== 'string' || typeof length !== 'number') {
+            throw new TypeError('Los argumentos deben ser una cadena y un número.');
+        }
+        if (str.length >= length) {
+            return str;
+        }
+        char = char || ' '; // Utiliza un espacio como carácter de relleno si no se proporciona uno
+        var padLength = length - str.length;
+        var padding = char.repeat(padLength);
+        return str + padding;
+    }
+    validarCampoNumerico(event) {
+        const input = event.target;
+        const regex = /[^0-9]/gi;
+        input.value = input.value.replace(regex, '');
+    }
+    isNotBlank(str) {
+        return str != null && str.trim().length > 0;
+    }
+    isBlank(str) {
+        return str == null || str?.trim() === '';
+    }
+    validarCampoObligatorio(valor) {
+        // Verificar si el valor no es null ni undefined
+        if (valor !== null && valor !== undefined) {
+            // Verificar si el valor no es una cadena vacía (en caso de ser una cadena)
+            if (typeof valor === 'string' && valor.trim() === '') {
+                return false;
+            }
+            // Verificar si el valor no es un arreglo vacío (en caso de ser un arreglo)
+            if (Array.isArray(valor) && valor.length === 0) {
+                return false;
+            }
+            /*if (typeof valor === 'object' && Object.keys(valor).length === 0) {
+              return false;
+            }*/
+            return true;
+        }
+        return false;
+    }
+    capitalizeFully(inputString) {
+        if (!inputString) {
+            return '';
+        }
+        const words = inputString.split(' ');
+        const capitalizedWords = words.map(word => {
+            if (word.length > 0) {
+                return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+            }
+            return '';
+        });
+        const result = capitalizedWords.join(' ');
+        return result;
+    }
+    ordenarSelectItemsAlfabeticamente(arrayDeObjetos) {
+        arrayDeObjetos.sort((a, b) => {
+            const nombreA = a.label.toLowerCase();
+            const nombreB = b.label.toLowerCase();
+            if (nombreA < nombreB) {
+                return -1;
+            }
+            if (nombreA > nombreB) {
+                return 1;
+            }
+            return 0;
+        });
+        return arrayDeObjetos;
+    }
+    obtenerParametroDeURL(urlString, parametro) {
+        const url = new URL(urlString);
+        const searchParams = new URLSearchParams(url.search);
+        return searchParams.get(parametro);
+    }
+    validarEmail(email) {
+        const patronEmail = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
+        return patronEmail.test(email);
+    }
+    obtenerBase() {
+        var basePortal = null;
+        var paginaActual = window.location.href;
+        var url = new URL(paginaActual);
+        var params = new URLSearchParams(url.search);
+        if (paginaActual.toString().includes('PortalSara')) {
+            for (var match of paginaActual.matchAll(/(?<inicio>.*)\/(?<seguridad>.*)\/(?<sitio>.*)\/(?<pagina>.*)/g)) {
+                basePortal = match.groups?.seguridad;
+            }
+        }
+        else if (params?.get('us_id')) {
+            paginaActual = window.parent.location.href;
+            for (var match of paginaActual.matchAll(/(?<inicio>.*)\/(?<seguridad>.*)\/(?<sitio>.*)\/(?<pagina>.*)/g)) {
+                basePortal = match.groups?.seguridad;
+            }
+        }
+        else {
+            const regex = /^.*?\/\/.*?\/(.*?)\//g; // Expresión regular para obtener la primera parte de la URL
+            const match = Array.from(paginaActual.matchAll(regex));
+            if (match && match[0] && match[0][1]) {
+                basePortal = match[0][1];
+            }
+        }
+        return basePortal;
+    }
+    validarEspacio(caracter) {
+        const regex = /\s/; // La expresión regular para espacios en blanco
+        return regex.test(caracter); // Devuelve true si el carácter es un espacio en blanco
+    }
+    validarTextoSQL(valor, obligatorio, select, longitud, validarSentencia) {
+        // Verifica obligatoriedad
+        if (obligatorio && (valor == null || valor.trim().length == 0 || valor == '--')) {
+            return 'Obligatorio';
+        }
+        // Verifica longitud máxima
+        if (longitud > 0) {
+            if (valor != null && valor != '--' && valor.length > longitud) {
+                return 'Longitud maxima de ' + longitud;
+            }
+        }
+        // Realiza las demás validacion solo en el caso de que la cadena SQL/valor no sea vacia
+        if (valor == null || valor.trim().length == 0 || valor == '--')
+            return null;
+        if (validarSentencia) {
+            if (select) {
+                if (!valor.toUpperCase().startsWith('SELECT')) {
+                    return 'El texto debe iniciar con la palabra Select';
+                }
+            }
+            else {
+                if (valor.toUpperCase().includes('SELECT')) {
+                    return 'No puede contener la palabra Select';
+                }
+            }
+        }
+        var indice;
+        var mensaje;
+        this.RESERVADAS_SQL_NOPUEDECONTENER.forEach(item => {
+            if (valor.includes(item)) {
+                mensaje = 'No puede contener ' + item;
+            }
+        });
+        this.reservadas.forEach(item => {
+            if (valor.toUpperCase().includes(item.toUpperCase())) {
+                indice = (valor.toUpperCase().indexOf(item.toUpperCase()));
+                if (indice == 0 || (this.validarEspacio(valor.charAt(indice - 1)) && this.validarEspacio(valor.charAt(item.length + indice)))) {
+                    mensaje = 'No puede contener ' + item;
+                }
+            }
+        });
+        return mensaje;
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    validarTextoArchivoJasper(texto) {
+        if (texto.trim() == '' || texto == null) {
+            return "El campo no puede estar vacio";
+        }
+        if (texto.match("^[^\\D].*")) {
+            return "El campo no puede iniciar con numeros";
+        }
+        if (texto.match("^[^\\S].*")) {
+            return "El campo no puede iniciar con caracteres en blanco";
+        }
+        if (!texto.match("^[^\\W].*")) {
+            return "El campo no puede iniciar con caracteres especiales";
+        }
+        return null;
+    }
+    resizeWindowIFrame() {
+        if (window.frameElement != null) {
+            this.resizeIframeKeepPosition(window.frameElement);
+        }
+    }
+    /**
+     * Funcion para mantener la posición actual en el iframe.
+     * @param obj es un "FrameElement"
+     */
+    resizeIframeKeepPosition(obj) {
+        var ifrm = obj;
+        var doc = ifrm.contentDocument ? ifrm.contentDocument : ifrm.contentWindow.document;
+        var tamanio = this.getDocHeight(doc) + 40;
+        ifrm.style.height = tamanio + "px";
+    }
+    getDocHeight(doc) {
+        console.log('getDocHeight');
+        let navegador = this.obtenerNavegador().toLowerCase();
+        var height = 0;
+        doc = doc || document;
+        const appRoot = doc.querySelector('app-root');
+        const swalPopup = doc.querySelector('.swal2-popup');
+        if (swalPopup) {
+            return swalPopup.offsetHeight + 40;
+        }
+        // Si encuentra el elemento <app-root>, retorna su altura
+        if (appRoot) {
+            return appRoot.offsetHeight;
+        }
+        //var body = doc.body, html = doc.documentElement;
+        //height = Math.max( body.scrollHeight, body.offsetHeight, 
+        //html.clientHeight, html.scrollHeight, html.offsetHeight );
+        if (navegador.indexOf('firefox') !== -1) {
+            if (doc.formDetalleConvocatoria) {
+                let cantidadMiles = height / 1000;
+                height = height + 600 + (cantidadMiles * 40);
+            }
+        }
+        //	console.warn('FCO : llama a getDocHeight');
+        return height;
+    }
+    obtenerNavegador() {
+        var ua = navigator.userAgent, tem, M = ua.match(/(opera|chrome|safari|firefox|msie|trident(?=\/))\/?\s*(\d+)/i) || [];
+        if (/trident/i.test(M[1])) {
+            tem = /\brv[ :]+(\d+)/g.exec(ua) || [];
+            return 'IE ' + (tem[1] || '');
+        }
+        if (M[1] === 'Chrome') {
+            tem = ua.match(/\b(OPR|Edge)\/(\d+)/);
+            if (tem != null)
+                return tem.slice(1).join(' ').replace('OPR', 'Opera');
+        }
+        M = M[2] ? [M[1], M[2]] : [navigator.appName, navigator.appVersion, '-?'];
+        if ((tem = ua.match(/version\/(\d+)/i)) != null)
+            M.splice(1, 1, tem[1]);
+        return M.join(' ');
+    }
+    obtenerUrlApi(urlapi) {
+        if (urlapi) {
+            return urlapi;
+        }
+        switch (this.getTokenKey('aplicacion')) {
+            case '1':
+                return window['env']['urlapisara'] ? window['env']['urlapisara'] : this.cookieService.get('urlnucleo');
+            case '13':
+                return window['env']['urlapimana'] ? window['env']['urlapimana'] : this.cookieService.get('urlnucleo');
+            case '10':
+                return window['env']['urlapisara'] ? window['env']['urlapisara'] : this.cookieService.get('urlnucleo');
+            //return window['env']['urlapi'] ? window['env']['urlapi'] : this.cookieService.get('urlnucleo');
+            case '77':
+                return window['env']['urlapimanaaps'] ? window['env']['urlapimanaaps'] : this.cookieService.get('urlnucleo');
+            default:
+                return this.cookieService.get('urlnucleo');
+        }
+    }
+    getTokenKey(key) {
+        try {
+            const data = this._decodeToken();
+            return data[key].toString();
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    _decodeToken() {
+        try {
+            const token = this.getItem('token', '');
+            const data = token.split('.')[1];
+            return JSON.parse(atob(data));
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    getItem(key, defaultValue) {
+        return localStorage.getItem(this.obtenerBase() + '_' + key) ?? defaultValue;
+    }
+    cambiarTema(tema) {
+        localStorage.setItem(this.obtenerBase() + '_' + 'tema', tema);
+        let linkTema = this.document.getElementById('temaApp');
+        linkTema.href = `${tema}.css`;
+    }
+    calcularPosicionDialog() {
+        var parentWindow = window.parent;
+        var obj = window.frameElement;
+        var ifrm = obj;
+        if (ifrm) {
+            const scrollTop = parentWindow.pageYOffset || parentWindow.document.documentElement.scrollTop || parentWindow.document.body.scrollTop || 0;
+            const dialog = document.querySelector('.p-dialog');
+            if (dialog) {
+                const scrollHeight = parentWindow.document.documentElement.scrollHeight;
+                const mitadScrollHeight = scrollHeight / 2;
+                const inicio = -mitadScrollHeight;
+                dialog.style.top = `${inicio + 50 + (scrollTop)}px`;
+            }
+        }
+    }
+    validarPalabra(texto) {
+        const pletras = /^[a-zA-Z][0-9a-zA-Z]*$/;
+        return pletras.test(texto);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: UtilsService, deps: [{ token: i1.CookieService }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: UtilsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: UtilsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.CookieService }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.service.js","sourceRoot":"","sources":["../../../../../../src/app/core/servicios/utils.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { CookieService } from 'ngx-cookie-service';\nimport { DOCUMENT } from '@angular/common';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class UtilsService {\n\n  private RESERVADAS_SQL_NOPUEDECONTENER: any[] = [';']\n  private reservadas: any[] = ['ALTER', 'DELETE', 'DROP', 'MODIFY', 'CREATE', 'DATABASE', 'TABLE', 'UPDATE', 'TRIGGER', 'GRANT', 'REVOKE', 'CALL', 'INSERT', 'TRUNCATE', 'USE', '--']\n  \n  constructor(private cookieService: CookieService, @Inject(DOCUMENT) private document: Document,){\n  }\n  \n  public generarLlave() {\n    let result = '';\n    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\n    const charactersLength = 32;\n    for (let i = 0; i < charactersLength; i++) {\n      result += characters.charAt(Math.floor(Math.random() * charactersLength));\n    }\n\n    return result.toLowerCase();\n  }\n\n\n\n  public generarPin(cantidad: number) {\n    let result = '';\n    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\n    for (let i = 0; i < cantidad; i++) {\n      result += characters.charAt(Math.floor(Math.random() * cantidad));\n    }\n\n    return result.toLowerCase();\n  }\n\n  rightpad(str, length, char) {\n    if (str === undefined) {\n      return null;\n    }\n    if (typeof str !== 'string' || typeof length !== 'number') {\n      throw new TypeError('Los argumentos deben ser una cadena y un número.');\n    }\n\n    if (str.length >= length) {\n      return str;\n    }\n\n    char = char || ' '; // Utiliza un espacio como carácter de relleno si no se proporciona uno\n\n    var padLength = length - str.length;\n    var padding = char.repeat(padLength);\n\n    return str + padding;\n  }\n\n  validarCampoNumerico(event: any) {\n    const input = event.target;\n    const regex = /[^0-9]/gi;\n    input.value = input.value.replace(regex, '');\n  }\n\n  isNotBlank(str: string | String | null | undefined): boolean {\n    return str != null && str.trim().length > 0;\n  }\n\n  isBlank(str: string | String | null | undefined): boolean {\n    return str == null || str?.trim() === '';\n  }\n\n  validarCampoObligatorio(valor): boolean {\n    // Verificar si el valor no es null ni undefined\n    if (valor !== null && valor !== undefined) {\n      // Verificar si el valor no es una cadena vacía (en caso de ser una cadena)\n      if (typeof valor === 'string' && valor.trim() === '') {\n        return false;\n      }\n      // Verificar si el valor no es un arreglo vacío (en caso de ser un arreglo)\n      if (Array.isArray(valor) && valor.length === 0) {\n        return false;\n      }\n      /*if (typeof valor === 'object' && Object.keys(valor).length === 0) {\n        return false;\n      }*/\n      return true;\n    }\n    return false;\n  }\n\n  capitalizeFully(inputString: string): string {\n    if (!inputString) {\n      return '';\n    }\n    const words = inputString.split(' ');\n    const capitalizedWords = words.map(word => {\n      if (word.length > 0) {\n        return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();\n      }\n      return '';\n    });\n    const result = capitalizedWords.join(' ');\n    return result;\n  }\n\n  ordenarSelectItemsAlfabeticamente(arrayDeObjetos: any[]): any[] {\n    arrayDeObjetos.sort((a, b) => {\n      const nombreA = a.label.toLowerCase();\n      const nombreB = b.label.toLowerCase();\n\n      if (nombreA < nombreB) {\n        return -1;\n      }\n      if (nombreA > nombreB) {\n        return 1;\n      }\n      return 0;\n    });\n    return arrayDeObjetos;\n  }\n\n  obtenerParametroDeURL(urlString: string, parametro: string): string | null {\n    const url = new URL(urlString);\n    const searchParams = new URLSearchParams(url.search);\n    return searchParams.get(parametro);\n  }\n\n  validarEmail(email: string): boolean {\n    const patronEmail = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$/;\n    return patronEmail.test(email);\n  }\n\n  obtenerBase(): (string | null) {\n\n    var basePortal: string = null;\n    var paginaActual: any = window.location.href\n    var url = new URL(paginaActual);\n    var params = new URLSearchParams(url.search);\n    if (paginaActual.toString().includes('PortalSara')) {\n      for (var match of paginaActual.matchAll(/(?<inicio>.*)\\/(?<seguridad>.*)\\/(?<sitio>.*)\\/(?<pagina>.*)/g)) {\n        basePortal = match.groups?.seguridad;\n      }\n    } else if (params?.get('us_id')) {\n      paginaActual = window.parent.location.href;\n      for (var match of paginaActual.matchAll(/(?<inicio>.*)\\/(?<seguridad>.*)\\/(?<sitio>.*)\\/(?<pagina>.*)/g)) {\n        basePortal = match.groups?.seguridad;\n      }\n    } else {\n      const regex = /^.*?\\/\\/.*?\\/(.*?)\\//g; // Expresión regular para obtener la primera parte de la URL\n      const match = Array.from(paginaActual.matchAll(regex));\n\n      if (match && match[0] && match[0][1]) {\n        basePortal = match[0][1];\n      }\n    }\n    return basePortal;\n  }\n\n  private validarEspacio(caracter: string): boolean {\n    const regex = /\\s/; // La expresión regular para espacios en blanco\n    return regex.test(caracter); // Devuelve true si el carácter es un espacio en blanco\n  }\n\n  public validarTextoSQL(valor: string, obligatorio: boolean, select: boolean, longitud: number, validarSentencia: boolean): (string | null) {\n    // Verifica obligatoriedad\n    if (obligatorio && (valor == null || valor.trim().length == 0 || valor == '--')) {\n      return 'Obligatorio';\n    }\n    // Verifica longitud máxima\n    if (longitud > 0) {\n      if (valor != null && valor != '--' && valor.length > longitud) {\n        return 'Longitud maxima de ' + longitud;\n      }\n    }\n    // Realiza las demás validacion solo en el caso de que la cadena SQL/valor no sea vacia\n    if (valor == null || valor.trim().length == 0 || valor == '--')\n      return null;\n\n    if (validarSentencia) {\n      if (select) {\n        if (!valor.toUpperCase().startsWith('SELECT')) {\n          return 'El texto debe iniciar con la palabra Select';\n        }\n      } else {\n        if (valor.toUpperCase().includes('SELECT')) {\n          return 'No puede contener la palabra Select';\n        }\n      }\n    }\n    var indice: number;\n    var mensaje: string;\n    this.RESERVADAS_SQL_NOPUEDECONTENER.forEach(item => {\n      if (valor.includes(item)) {\n        mensaje = 'No puede contener ' + item;\n      }\n    })\n    this.reservadas.forEach(item => {\n      if (valor.toUpperCase().includes(item.toUpperCase())) {\n        indice = (valor.toUpperCase().indexOf(item.toUpperCase()));\n        if (indice == 0 || (this.validarEspacio(valor.charAt(indice - 1)) && this.validarEspacio(valor.charAt(item.length + indice)))) {\n          mensaje = 'No puede contener ' + item;\n        }\n      }\n    })\n    return mensaje;\n  }\n\n  sleep(ms: number): Promise<void> {\n    return new Promise((resolve) => setTimeout(resolve, ms));\n  }\n\n  validarTextoArchivoJasper(texto: string): (string | null) {\n    if (texto.trim() == '' || texto == null) {\n      return \"El campo no puede estar vacio\";\n    }\n    if (texto.match(\"^[^\\\\D].*\")) {\n      return \"El campo no puede iniciar con numeros\";\n    }\n    if (texto.match(\"^[^\\\\S].*\")) {\n      return \"El campo no puede iniciar con caracteres en blanco\";\n    }\n    if (!texto.match(\"^[^\\\\W].*\")) {\n      return \"El campo no puede iniciar con caracteres especiales\";\n    }\n    return null;\n  }\n\n  resizeWindowIFrame() {\n\t\tif ( window.frameElement != null) {\n\t\t\tthis.resizeIframeKeepPosition(window.frameElement);\n\t\t}\n\t}\n\t\n\t/**\n\t * Funcion para mantener la posición actual en el iframe.\n\t * @param obj es un \"FrameElement\"\n\t */\n\tprivate resizeIframeKeepPosition(obj) {\n\t\t\n\t\tvar ifrm = obj;\n\t\tvar doc = ifrm.contentDocument ? ifrm.contentDocument: ifrm.contentWindow.document;\n    var tamanio: number=  this.getDocHeight( doc )  + 40\n\t\tifrm.style.height = tamanio + \"px\";\n\t}\n\n\tprivate getDocHeight(doc){\n    console.log('getDocHeight')\n\t\tlet navegador = this.obtenerNavegador().toLowerCase();\n\t\tvar height = 0;\n\t\tdoc = doc || document;\n    const appRoot = doc.querySelector('app-root');\n\n    const swalPopup = doc.querySelector('.swal2-popup');\n    if (swalPopup) {\n        return swalPopup.offsetHeight + 40;\n    }\n\n    // Si encuentra el elemento <app-root>, retorna su altura\n    if (appRoot) {\n        return appRoot.offsetHeight;\n    }\n\t\t//var body = doc.body, html = doc.documentElement;\n\t\t//height = Math.max( body.scrollHeight, body.offsetHeight, \n\t\t//html.clientHeight, html.scrollHeight, html.offsetHeight );\n\t\t\n\t\tif (navegador.indexOf('firefox') !== -1){\n\t\t\tif(doc.formDetalleConvocatoria){\n\t\t\t\tlet cantidadMiles = height / 1000;\n\t\t\t\theight = height + 600 + (cantidadMiles*40)\n\t\t\t}\n\t\t}\n\t\t\n\t//\tconsole.warn('FCO : llama a getDocHeight');\n\t\n\t\treturn height;\n\t}\n\n\tobtenerNavegador(){\n\t\tvar ua= navigator.userAgent, tem, \n\t\tM= ua.match(/(opera|chrome|safari|firefox|msie|trident(?=\\/))\\/?\\s*(\\d+)/i) || [];\n\t\tif(/trident/i.test(M[1])){\n\t\t\ttem=  /\\brv[ :]+(\\d+)/g.exec(ua) || [];\n\t\t\treturn 'IE '+(tem[1] || '');\n\t\t}\n\t\tif(M[1]=== 'Chrome'){\n\t\t\ttem= ua.match(/\\b(OPR|Edge)\\/(\\d+)/);\n\t\t\tif(tem!= null) return tem.slice(1).join(' ').replace('OPR', 'Opera');\n\t\t}\n\t\tM= M[2]? [M[1], M[2]]: [navigator.appName, navigator.appVersion, '-?'];\n\t\tif((tem= ua.match(/version\\/(\\d+)/i))!= null) M.splice(1, 1, tem[1]);\n\t\treturn M.join(' ');\n\t}\n\n  obtenerUrlApi(urlapi?: string ): string {\n    if (urlapi){\n      return urlapi;\n    }\n    switch (this.getTokenKey('aplicacion')) {\n      case '1':\n        return window['env']['urlapisara'] ? window['env']['urlapisara'] : this.cookieService.get('urlnucleo');\n      case '13':\n        return window['env']['urlapimana'] ? window['env']['urlapimana'] : this.cookieService.get('urlnucleo');\n      case '10':\n        return window['env']['urlapisara'] ? window['env']['urlapisara'] : this.cookieService.get('urlnucleo');\n        //return window['env']['urlapi'] ? window['env']['urlapi'] : this.cookieService.get('urlnucleo');\n      case '77':\n        return window['env']['urlapimanaaps'] ? window['env']['urlapimanaaps'] : this.cookieService.get('urlnucleo');\n      default:\n        return  this.cookieService.get('urlnucleo');\n    }\n  }\n\n  private getTokenKey(key: string): string {\n    try {\n      const data = this._decodeToken();\n      return data[key].toString();\n    } catch (error) {\n      return undefined;\n    }\n  }\n\n  private _decodeToken(): any {\n    try {\n      const token = this.getItem('token', '');\n      const data = token.split('.')[1];\n      return JSON.parse(atob(data));\n    } catch (error) {\n      throw error;\n    }\n  }\n\n  getItem(key: string, defaultValue?: string): string | undefined {\n    return localStorage.getItem(this.obtenerBase() + '_' +  key) ?? defaultValue;\n  }\n\n  cambiarTema(tema : ('temaClaro' | 'temaOscuro')){\n    localStorage.setItem(this.obtenerBase() + '_' +'tema', tema);\n    let linkTema = this.document.getElementById('temaApp') as HTMLLinkElement;\n    linkTema.href = `${tema}.css`\n  }\n\n  calcularPosicionDialog() {\n    var parentWindow: Window = window.parent;\n    var obj: any = window.frameElement ;\n    var ifrm = obj;\n    if (ifrm) {\n      const scrollTop = parentWindow.pageYOffset || parentWindow.document.documentElement.scrollTop || parentWindow.document.body.scrollTop || 0;\n      const dialog = document.querySelector('.p-dialog') as HTMLElement;\n      if (dialog) {\n        const scrollHeight = parentWindow.document.documentElement.scrollHeight\n        const mitadScrollHeight = scrollHeight / 2;\n        const inicio = -mitadScrollHeight;\n        dialog.style.top = `${inicio + 50 + (scrollTop ) }px`;      }\n    }\n  }\n\n  validarPalabra(texto: string): boolean {\n    const pletras = /^[a-zA-Z][0-9a-zA-Z]*$/;\n    return pletras.test(texto);\n  }\n}"]}