general-library-union 3.2.90 → 3.2.91

package/esm2022/src/app/shared/servicios/encriptado-basico.service.mjs

@@ -0,0 +1,53 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class EncriptadoBasicoService {
+    tam = ['e', 'a', 'c', 'd'];
+    constructor() { }
+    encriptar(original) {
+        if (original == null) {
+            return null;
+        }
+        let res = '';
+        for (let index = 0; index < original.length; index++) {
+            let cod = Number(original.charCodeAt(index)).toString(16);
+            res = res.concat(this.tam[cod.length] + cod);
+        }
+        return res;
+    }
+    desencriptar(encriptado) {
+        if (encriptado == null) {
+            return null;
+        }
+        let res = '';
+        let i = 0;
+        while (i < encriptado.length) {
+            let largo = this.binarySearch(this.tam, encriptado.charAt(i));
+            let letra = String.fromCharCode(parseInt(encriptado.substring(i + 1, i + 1 + largo), 16));
+            res = res.concat(letra);
+            i += 1 + largo;
+        }
+        return res.toString();
+    }
+    binarySearch(arr, value) {
+        var low = 0, high = arr.length - 1, mid;
+        while (low <= high) {
+            mid = Math.floor((low + high) / 2);
+            if (arr[mid] == value)
+                return mid;
+            else if (arr[mid] < value)
+                low = mid + 1;
+            else
+                high = mid - 1;
+        }
+        return -1;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: EncriptadoBasicoService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: EncriptadoBasicoService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: EncriptadoBasicoService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/app/shared/servicios/general.service.mjs

@@ -0,0 +1,104 @@
+import { Injectable } from '@angular/core';
+import { catchError, throwError } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../core/servicios/error-interceptor.service";
+import * as i3 from "../../core/servicios/utils.service";
+export class GeneralService {
+    httpClient;
+    errorInterceptor;
+    utilsService;
+    constructor(httpClient, errorInterceptor, utilsService) {
+        this.httpClient = httpClient;
+        this.errorInterceptor = errorInterceptor;
+        this.utilsService = utilsService;
+        this.handleError = this.handleError.bind(this);
+    }
+    handleError(error) {
+        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.'));
+    }
+    listProcedure(objetoFiltro) {
+        throw new Error('Method not implemented.');
+    }
+    queryForList(general, ambiente) {
+        let url = this.utilsService.obtenerUrlApi();
+        if (!ambiente) {
+            ambiente = url;
+        }
+        return this.httpClient.post(`${ambiente}/requieretoken/general/queryForList`, general).pipe(catchError(this.handleError));
+    }
+    queryForObject(general, ambiente) {
+        let url = this.utilsService.obtenerUrlApi();
+        if (!ambiente) {
+            ambiente = url;
+        }
+        return this.httpClient.post(`${ambiente}/requieretoken/general/queryForObject`, general).pipe(catchError(this.handleError));
+    }
+    cantidadRegistros(general, ambiente) {
+        let url = this.utilsService.obtenerUrlApi();
+        if (!ambiente) {
+            ambiente = url;
+        }
+        return this.httpClient.post(`${ambiente}/requieretoken/general/cantidadRegistros`, general).pipe(catchError(this.handleError));
+    }
+    crearRegistro(general, ambiente) {
+        let url = this.utilsService.obtenerUrlApi();
+        if (!ambiente) {
+            ambiente = url;
+        }
+        return this.httpClient.post(`${ambiente}/requieretoken/general/crearRegistro`, general).pipe(catchError(this.handleError));
+    }
+    delete(general, ambiente) {
+        let url = this.utilsService.obtenerUrlApi();
+        if (!ambiente) {
+            ambiente = url;
+        }
+        return this.httpClient.post(`${ambiente}/requieretoken/general/delete`, general).pipe(catchError(this.handleError));
+    }
+    update(general, ambiente) {
+        let url = this.utilsService.obtenerUrlApi();
+        if (!ambiente) {
+            ambiente = url;
+        }
+        return this.httpClient.post(`${ambiente}/requieretoken/general/update`, general).pipe(catchError(this.handleError));
+    }
+    procedure(general, ambiente) {
+        console.log('Objeto: ' + JSON.stringify(general));
+        let url = this.utilsService.obtenerUrlApi();
+        if (!ambiente) {
+            ambiente = url;
+        }
+        console.log('INGRESO PROCEDIMIENTO: ' + ambiente + '/requieretoken/general/procedure');
+        return this.httpClient.post(`${ambiente}/requieretoken/general/procedure`, general).pipe(catchError(this.handleError));
+    }
+    obtenerJasper(rutaJasper, ambiente) {
+        let formData = new FormData();
+        formData.append("jasper", rutaJasper);
+        let url = this.utilsService.obtenerUrlApi();
+        if (!ambiente) {
+            ambiente = url;
+        }
+        return this.httpClient.post(`${ambiente}/requieretoken/general/obtenerJasper`, formData).pipe(catchError(this.handleError));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: GeneralService, deps: [{ token: i1.HttpClient }, { token: i2.ErrorIntecertorService }, { token: i3.UtilsService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: GeneralService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: GeneralService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.ErrorIntecertorService }, { type: i3.UtilsService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"general.service.js","sourceRoot":"","sources":["../../../../../../src/app/shared/servicios/general.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpErrorResponse } from '@angular/common/http';\r\nimport { Injectable } from '@angular/core';\r\nimport { Observable, catchError, throwError } from 'rxjs';\r\nimport { GeneralModel } from '../../seguridad/modelos/GeneralModel';\r\nimport { CookieService } from 'ngx-cookie-service';\r\nimport { UtilsService } from '../../core/servicios/utils.service';\r\nimport { ErrorIntecertorService } from '../../core/servicios/error-interceptor.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class GeneralService {\r\n\r\n  \r\n  constructor(private httpClient: HttpClient, private errorInterceptor: ErrorIntecertorService, private utilsService: UtilsService) {\r\n    this.handleError = this.handleError.bind(this);\r\n  }\r\n\r\n  private handleError(error: HttpErrorResponse) {\r\n    if (error.status === 500) {\r\n      //Llamado a interceptor\r\n      this.errorInterceptor.showError(JSON.stringify(error.error));\r\n      // A client-side or network error occurred. Handle it accordingly.\r\n      console.error('An error occurred:', error.error);\r\n    } else {\r\n      // The backend returned an unsuccessful response code.\r\n      // The response body may contain clues as to what went wrong.\r\n      console.error(\r\n        `Backend returned code ${error.status}, body was: `, error.error);\r\n    }\r\n    // Return an observable with a user-facing error message.\r\n    return throwError(() => new Error('Something bad happened; please try again later.'));\r\n  }\r\n\r\n  listProcedure(objetoFiltro: GeneralModel) {\r\n    throw new Error('Method not implemented.');\r\n  }\r\n\r\n  queryForList(general: GeneralModel,ambiente?: any): Observable<any[]> {\r\n    let url = this.utilsService.obtenerUrlApi();\r\n    if (!ambiente){\r\n      ambiente = url;\r\n    }\r\n    return this.httpClient.post<any[]>(`${ambiente}/requieretoken/general/queryForList`, general).pipe(\r\n      catchError(this.handleError)\r\n    );\r\n  }\r\n\r\n  queryForObject(general: GeneralModel,ambiente?: any): Observable<any> {\r\n    let url = this.utilsService.obtenerUrlApi();\r\n    if (!ambiente){\r\n      ambiente = url;\r\n    }\r\n      return this.httpClient.post<any>(`${ambiente}/requieretoken/general/queryForObject`, general).pipe(\r\n        catchError(this.handleError)\r\n      );\r\n  }\r\n\r\n  cantidadRegistros(general: GeneralModel,ambiente?: any): Observable<number> {\r\n    let url = this.utilsService.obtenerUrlApi();\r\n    if (!ambiente){\r\n      ambiente = url;\r\n    }\r\n    return this.httpClient.post<number>(`${ambiente}/requieretoken/general/cantidadRegistros`, general).pipe(\r\n      catchError(this.handleError)\r\n    );\r\n  }\r\n\r\n  crearRegistro(general: GeneralModel,ambiente?: any): Observable<any> {\r\n    let url = this.utilsService.obtenerUrlApi();\r\n    if (!ambiente){\r\n      ambiente = url;\r\n    }\r\n    return this.httpClient.post<any>(`${ambiente}/requieretoken/general/crearRegistro`, general).pipe(\r\n      catchError(this.handleError)\r\n    );\r\n  }\r\n\r\n  delete(general: GeneralModel,ambiente?: any): Observable<number> {\r\n    let url = this.utilsService.obtenerUrlApi();\r\n    if (!ambiente){\r\n      ambiente = url;\r\n    }\r\n    return this.httpClient.post<number>(`${ambiente}/requieretoken/general/delete`, general).pipe(\r\n      catchError(this.handleError)\r\n    );\r\n  }\r\n\r\n  update(general: GeneralModel,ambiente?: any): Observable<number> {\r\n    let url = this.utilsService.obtenerUrlApi();\r\n    if (!ambiente){\r\n      ambiente = url;\r\n    }\r\n    return this.httpClient.post<number>(`${ambiente}/requieretoken/general/update`, general).pipe(\r\n      catchError(this.handleError)\r\n    );\r\n  }\r\n\r\n  procedure(general: GeneralModel,ambiente?: any): Observable<any> {\r\n    console.log('Objeto: ' +  JSON.stringify(general));\r\n    let url = this.utilsService.obtenerUrlApi();\r\n    if (!ambiente){\r\n      ambiente = url;\r\n    }\r\n    console.log('INGRESO PROCEDIMIENTO: ' + ambiente + '/requieretoken/general/procedure');\r\n    return this.httpClient.post<any>(`${ambiente}/requieretoken/general/procedure`, general).pipe(\r\n      catchError(this.handleError)\r\n    );\r\n  }\r\n\r\n  obtenerJasper(rutaJasper,ambiente?: any): Observable<any> {\r\n    let formData = new FormData();\r\n    formData.append(\"jasper\", rutaJasper);\r\n    let url = this.utilsService.obtenerUrlApi();\r\n    if (!ambiente){\r\n      ambiente = url;\r\n    }\r\n    return this.httpClient.post<any>(`${ambiente}/requieretoken/general/obtenerJasper`, formData).pipe(\r\n      catchError(this.handleError)\r\n    );\r\n  }\r\n}\r\n\r\n\r\n"]}

package/esm2022/src/app/shared/servicios/parametros-navegacion.service.mjs

@@ -0,0 +1,21 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ParametrosNavegacionService {
+    parametros;
+    constructor() { }
+    setParametros(parametros) {
+        this.parametros = parametros;
+    }
+    getParametros() {
+        return this.parametros;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: ParametrosNavegacionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: ParametrosNavegacionService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: ParametrosNavegacionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyYW1ldHJvcy1uYXZlZ2FjaW9uLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBwL3NoYXJlZC9zZXJ2aWNpb3MvcGFyYW1ldHJvcy1uYXZlZ2FjaW9uLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFLM0MsTUFBTSxPQUFPLDJCQUEyQjtJQUV0QyxVQUFVLENBQU07SUFFaEIsZ0JBQWdCLENBQUM7SUFFakIsYUFBYSxDQUFDLFVBQWU7UUFDM0IsSUFBSSxDQUFDLFVBQVUsR0FBRyxVQUFVLENBQUM7SUFDL0IsQ0FBQztJQUVELGFBQWE7UUFDWCxPQUFPLElBQUksQ0FBQyxVQUFVLENBQUM7SUFDekIsQ0FBQzt1R0FaVSwyQkFBMkI7MkdBQTNCLDJCQUEyQixjQUYxQixNQUFNOzsyRkFFUCwyQkFBMkI7a0JBSHZDLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5cclxuQEluamVjdGFibGUoe1xyXG4gIHByb3ZpZGVkSW46ICdyb290J1xyXG59KVxyXG5leHBvcnQgY2xhc3MgUGFyYW1ldHJvc05hdmVnYWNpb25TZXJ2aWNlIHtcclxuXHJcbiAgcGFyYW1ldHJvczogYW55O1xyXG5cclxuICBjb25zdHJ1Y3RvcigpIHsgfVxyXG5cclxuICBzZXRQYXJhbWV0cm9zKHBhcmFtZXRyb3M6IGFueSkge1xyXG4gICAgdGhpcy5wYXJhbWV0cm9zID0gcGFyYW1ldHJvcztcclxuICB9XHJcblxyXG4gIGdldFBhcmFtZXRyb3MoKSB7XHJcbiAgICByZXR1cm4gdGhpcy5wYXJhbWV0cm9zO1xyXG4gIH1cclxuXHJcbn1cclxuIl19