general-library-union 2.4.76 → 2.4.78

package/esm2022/src/app/webcommon/services/dashboard.service.mjs

@@ -0,0 +1,253 @@
+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";
+import * as i4 from "../pipes/dashboard.pipe";
+export class DashboardService {
+    httpClient;
+    errorInterceptor;
+    utilsService;
+    dashboardPipe;
+    listProcedure(objetoFiltro) {
+        throw new Error('Method not implemented.');
+    }
+    constructor(httpClient, errorInterceptor, utilsService, dashboardPipe) {
+        this.httpClient = httpClient;
+        this.errorInterceptor = errorInterceptor;
+        this.utilsService = utilsService;
+        this.dashboardPipe = dashboardPipe;
+        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.'));
+    }
+    consultarDashboard() {
+        return this.httpClient.get(`${this.utilsService.obtenerUrlApi()}/requieretoken/dashboard/consultarDashboard`).pipe(catchError(this.handleError));
+    }
+    cargarGrafica(columna) {
+        console.log('cargar grafica');
+        console.log(columna);
+        switch (columna.accion) {
+            case this.dashboardPipe.DIAGRAMA_BARRAS:
+                columna = this.cargarDiagramaBarras(columna);
+                break;
+            case this.dashboardPipe.DIAGRAMA_BARRAS_HOR:
+                columna = this.cargarDiagramaBarrasHorizontal(columna);
+                break;
+            case this.dashboardPipe.DIAGRAMA_TORTA:
+                columna = this.cargarDiagramaBarrasTorta(columna);
+                break;
+            case this.dashboardPipe.DIAGRAMA_AREA:
+                columna = this.cargarDiagramaArea(columna);
+                break;
+            case this.dashboardPipe.DIAGRAMA_POLAR:
+                columna = this.cargarDiagramaPolar(columna);
+                break;
+            case this.dashboardPipe.DIAGRAMA_DONA:
+                columna = this.cargarDiagramaDona(columna);
+                break;
+            case this.dashboardPipe.DIAGRAMA_RADAR:
+                columna = this.cargarDiagramaRadar(columna);
+                break;
+            default:
+                break;
+        }
+        return columna;
+    }
+    cargarDiagramaBarras(columna) {
+        columna.datosGrafica.total = columna.datosGrafica.datasets[0].data.reduce((acumulador, valorActual) => acumulador + valorActual, 0);
+        columna.datosGrafica.data = {
+            labels: columna.datosGrafica.labels,
+            datasets: columna.datosGrafica.datasets
+        };
+        columna.datosGrafica.options = {
+            maintainAspectRatio: false,
+            aspectRatio: 0.8,
+            plugins: {
+                title: {
+                    display: true,
+                    text: columna.datosGrafica.title
+                },
+                legend: {
+                    labels: {
+                        color: "#2980B9",
+                    }
+                }
+            },
+        };
+        return columna;
+    }
+    cargarDiagramaBarrasHorizontal(columna) {
+        columna.datosGrafica.total = columna.datosGrafica.datasets[0].data.reduce((acumulador, valorActual) => acumulador + valorActual, 0);
+        console.log(columna);
+        columna.datosGrafica.data = {
+            labels: columna.datosGrafica.labels,
+            datasets: columna.datosGrafica.datasets
+        };
+        columna.datosGrafica.options = {
+            indexAxis: 'y',
+            maintainAspectRatio: false,
+            aspectRatio: 0.8,
+            plugins: {
+                title: {
+                    display: true,
+                    text: columna.datosGrafica.title
+                },
+                legend: {
+                    labels: {
+                        color: "#2980B9",
+                    }
+                }
+            },
+        };
+        return columna;
+    }
+    cargarDiagramaBarrasTorta(columna) {
+        columna.datosGrafica.total = columna.datosGrafica.data.reduce((acumulador, valorActual) => acumulador + valorActual, 0);
+        columna.datosGrafica.data = {
+            labels: columna.datosGrafica.labels,
+            datasets: [
+                {
+                    data: columna.datosGrafica.data,
+                    backgroundColor: columna.datosGrafica.backgroundColor
+                }
+            ]
+        };
+        columna.datosGrafica.options = {
+            plugins: {
+                title: {
+                    display: true,
+                    text: columna.datosGrafica.title
+                },
+                legend: {
+                    labels: {
+                        usePointStyle: true,
+                        color: "#2980B9",
+                    }
+                }
+            }
+        };
+        return columna;
+    }
+    cargarDiagramaArea(columna) {
+        columna.datosGrafica.total = columna.datosGrafica.datasets[0].data.reduce((acumulador, valorActual) => acumulador + valorActual, 0);
+        columna.datosGrafica.data = {
+            labels: columna.datosGrafica.labels,
+            datasets: columna.datosGrafica.datasets
+        };
+        columna.datosGrafica.options = {
+            stacked: false,
+            maintainAspectRatio: false,
+            aspectRatio: 0.6,
+            plugins: {
+                title: {
+                    display: true,
+                    text: columna.datosGrafica.title
+                },
+                legend: {
+                    labels: {
+                        color: "#2980B9",
+                    }
+                }
+            },
+        };
+        return columna;
+    }
+    cargarDiagramaPolar(columna) {
+        columna.datosGrafica.total = columna.datosGrafica.data.reduce((acumulador, valorActual) => acumulador + valorActual, 0);
+        columna.datosGrafica.data = {
+            labels: columna.datosGrafica.labels,
+            datasets: [
+                {
+                    data: columna.datosGrafica.data,
+                    backgroundColor: columna.datosGrafica.backgroundColor
+                }
+            ]
+        };
+        columna.datosGrafica.options = {
+            plugins: {
+                title: {
+                    display: true,
+                    text: columna.datosGrafica.title
+                },
+                legend: {
+                    labels: {
+                        color: "#2980B9",
+                    }
+                }
+            },
+        };
+        return columna;
+    }
+    cargarDiagramaDona(columna) {
+        columna.datosGrafica.total = columna.datosGrafica.data.reduce((acumulador, valorActual) => acumulador + valorActual, 0);
+        columna.datosGrafica.data = {
+            labels: columna.datosGrafica.labels,
+            datasets: [
+                {
+                    data: columna.datosGrafica.data,
+                    backgroundColor: columna.datosGrafica.backgroundColor
+                }
+            ]
+        };
+        columna.datosGrafica.options = {
+            cutout: '60%',
+            plugins: {
+                title: {
+                    display: true,
+                    text: columna.datosGrafica.title
+                },
+                legend: {
+                    labels: {
+                        color: "#2980B9",
+                    }
+                }
+            },
+        };
+        return columna;
+    }
+    cargarDiagramaRadar(columna) {
+        columna.datosGrafica.total = columna.datosGrafica.datasets[0].data.reduce((acumulador, valorActual) => acumulador + valorActual, 0);
+        columna.datosGrafica.data = {
+            labels: columna.datosGrafica.labels,
+            datasets: columna.datosGrafica.datasets
+        };
+        columna.datosGrafica.options = {
+            plugins: {
+                title: {
+                    display: true,
+                    text: columna.datosGrafica.title
+                },
+                legend: {
+                    labels: {
+                        color: "#2980B9",
+                    }
+                }
+            },
+        };
+        return columna;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: DashboardService, deps: [{ token: i1.HttpClient }, { token: i2.ErrorIntecertorService }, { token: i3.UtilsService }, { token: i4.DashboardPipe }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: DashboardService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: DashboardService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.ErrorIntecertorService }, { type: i3.UtilsService }, { type: i4.DashboardPipe }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dashboard.service.js","sourceRoot":"","sources":["../../../../../../src/app/webcommon/services/dashboard.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpRequest, HttpEvent,HttpErrorResponse } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { Observable, catchError, throwError } from 'rxjs';\nimport { ErrorIntecertorService } from '../../core/servicios/error-interceptor.service';\nimport { UtilsService } from '../../core/servicios/utils.service';\nimport { GeneralModel } from '../../seguridad/modelos/GeneralModel';\nimport { DashboardPipe } from '../pipes/dashboard.pipe';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class DashboardService {\n\n\n  listProcedure(objetoFiltro: GeneralModel) {\n    throw new Error('Method not implemented.');\n  }\n\n  constructor(private httpClient: HttpClient , private errorInterceptor : ErrorIntecertorService, private utilsService: UtilsService, private dashboardPipe: DashboardPipe) {\n    this.handleError = this.handleError.bind(this);\n  }\n\n  private handleError(error: HttpErrorResponse) {\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  consultarDashboard(): Observable<any>{\n    return this.httpClient.get(`${this.utilsService.obtenerUrlApi()}/requieretoken/dashboard/consultarDashboard`).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  cargarGrafica(columna) {\n    console.log('cargar grafica')\n    console.log(columna)\n    switch (columna.accion) {\n      case this.dashboardPipe.DIAGRAMA_BARRAS:\n        columna = this.cargarDiagramaBarras(columna);\n        break;\n      case this.dashboardPipe.DIAGRAMA_BARRAS_HOR:\n        columna = this.cargarDiagramaBarrasHorizontal(columna);\n        break;\n      case this.dashboardPipe.DIAGRAMA_TORTA:\n        columna = this.cargarDiagramaBarrasTorta(columna);\n        break;\n      case this.dashboardPipe.DIAGRAMA_AREA:\n        columna = this.cargarDiagramaArea(columna);\n        break;\n      case this.dashboardPipe.DIAGRAMA_POLAR:\n        columna = this.cargarDiagramaPolar(columna);\n        break;\n      case this.dashboardPipe.DIAGRAMA_DONA:\n        columna = this.cargarDiagramaDona(columna);\n        break;\n      case this.dashboardPipe.DIAGRAMA_RADAR:\n        columna = this.cargarDiagramaRadar(columna);\n        break;\n    default:\n      break;\n  }\n  return columna;\n  }\n\n  cargarDiagramaBarras(columna) {\n    columna.datosGrafica.total = columna.datosGrafica.datasets[0].data.reduce((acumulador, valorActual) => acumulador + valorActual, 0);\n    columna.datosGrafica.data = {\n      labels: columna.datosGrafica.labels,\n      datasets: columna.datosGrafica.datasets\n    };\n    columna.datosGrafica.options = {\n      maintainAspectRatio: false,\n      aspectRatio: 0.8,\n      plugins: {\n        title: {\n          display: true,\n          text: columna.datosGrafica.title\n        },\n        legend: {\n            labels: {\n                color: \"#2980B9\",\n            }\n        }\n      },\n    };\n    return columna;\n  }\n\n  cargarDiagramaBarrasHorizontal(columna) {\n    columna.datosGrafica.total = columna.datosGrafica.datasets[0].data.reduce((acumulador, valorActual) => acumulador + valorActual, 0);\n    console.log(columna)\n\n    columna.datosGrafica.data = {\n      labels: columna.datosGrafica.labels,\n      datasets: columna.datosGrafica.datasets\n    };\n    columna.datosGrafica.options = {\n      indexAxis: 'y',\n      maintainAspectRatio: false,\n      aspectRatio: 0.8,\n      plugins: {\n        title: {\n          display: true,\n          text: columna.datosGrafica.title\n        },\n        legend: {\n            labels: {\n                color: \"#2980B9\",\n            }\n        }\n      },\n    };\n    return columna;\n  }\n\n  cargarDiagramaBarrasTorta(columna) {\n    columna.datosGrafica.total = columna.datosGrafica.data.reduce((acumulador, valorActual) => acumulador + valorActual, 0);\n    columna.datosGrafica.data = {\n      labels: columna.datosGrafica.labels,\n      datasets: [\n        {\n          data: columna.datosGrafica.data,\n          backgroundColor: columna.datosGrafica.backgroundColor\n        }\n      ]\n    };\n    columna.datosGrafica.options = {\n      plugins: {\n        title: {\n          display: true,\n          text: columna.datosGrafica.title\n        },\n        legend: {\n            labels: {\n                usePointStyle: true,\n                color: \"#2980B9\",\n            }\n        }\n    }\n    };\n    return columna;\n  }\n  \n  cargarDiagramaArea(columna) {\n    columna.datosGrafica.total = columna.datosGrafica.datasets[0].data.reduce((acumulador, valorActual) => acumulador + valorActual, 0);\n    columna.datosGrafica.data = {\n      labels: columna.datosGrafica.labels,\n      datasets: columna.datosGrafica.datasets\n    };\n    columna.datosGrafica.options = {\n      stacked: false,\n      maintainAspectRatio: false,\n      aspectRatio: 0.6,\n      plugins: {\n        title: {\n          display: true,\n          text: columna.datosGrafica.title\n        },\n        legend: {\n            labels: {\n                color: \"#2980B9\",\n            }\n        }\n      },\n    };\n    return columna;\n  }\n\n  cargarDiagramaPolar(columna) {\n    columna.datosGrafica.total = columna.datosGrafica.data.reduce((acumulador, valorActual) => acumulador + valorActual, 0);\n    columna.datosGrafica.data = {\n      labels: columna.datosGrafica.labels,\n      datasets: [\n        {\n          data: columna.datosGrafica.data,\n          backgroundColor: columna.datosGrafica.backgroundColor\n        }\n      ]\n    };\n    columna.datosGrafica.options = {\n      plugins: {\n        title: {\n          display: true,\n          text: columna.datosGrafica.title\n        },\n        legend: {\n            labels: {\n                color: \"#2980B9\",\n            }\n        }\n      },\n    };\n    return columna;\n  }\n\n  cargarDiagramaDona(columna) {\n    columna.datosGrafica.total = columna.datosGrafica.data.reduce((acumulador, valorActual) => acumulador + valorActual, 0);\n    columna.datosGrafica.data = {\n      labels: columna.datosGrafica.labels,\n      datasets: [\n        {\n          data: columna.datosGrafica.data,\n          backgroundColor: columna.datosGrafica.backgroundColor\n        }\n      ]\n    };\n    columna.datosGrafica.options = {\n      cutout: '60%',\n      plugins: {\n        title: {\n          display: true,\n          text: columna.datosGrafica.title\n        },\n        legend: {\n            labels: {\n                color: \"#2980B9\",\n            }\n        }\n      },\n    };\n    return columna;\n  }\n\n  cargarDiagramaRadar(columna) {\n    columna.datosGrafica.total = columna.datosGrafica.datasets[0].data.reduce((acumulador, valorActual) => acumulador + valorActual, 0);\n    columna.datosGrafica.data = {\n      labels: columna.datosGrafica.labels,\n      datasets: columna.datosGrafica.datasets\n    };\n    columna.datosGrafica.options = {\n      plugins: {\n        title: {\n          display: true,\n          text: columna.datosGrafica.title\n        },\n        legend: {\n            labels: {\n                color: \"#2980B9\",\n            }\n        }\n      },\n    };\n    return columna;\n  }\n\n}"]}

package/esm2022/src/app/webcommon/services/ejecucionreporte.service.mjs

@@ -3,18 +3,18 @@ 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 "ngx-cookie-service";
+import * as i3 from "../../core/servicios/utils.service";
 export class EjecucionReporteService {
     httpClient;
     errorInterceptor;
-    cookieService;
+    utilsService;
     listProcedure(objetoFiltro) {
         throw new Error('Method not implemented.');
     }
-    constructor(httpClient, errorInterceptor, cookieService) {
+    constructor(httpClient, errorInterceptor, utilsService) {
         this.httpClient = httpClient;
         this.errorInterceptor = errorInterceptor;
-        this.cookieService = cookieService;
+        this.utilsService = utilsService;
         this.handleError = this.handleError.bind(this);
     }
     handleError(error) {
@@ -33,59 +33,56 @@ export class EjecucionReporteService {
         // Return an observable with a user-facing error message.
         return throwError(() => new Error('Something bad happened; please try again later.'));
     }
-    getUrl() {
-        return this.cookieService.get('urlnucleo');
-    }
     getDatosEjecucionReporte(reporte) {
-        return this.httpClient.post(`${this.getUrl()}/requieretoken/reporte/consultar`, reporte).pipe(catchError(this.handleError));
+        return this.httpClient.post(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/consultar`, reporte).pipe(catchError(this.handleError));
     }
     guardarReporte(reporte) {
-        return this.httpClient.post(`${this.getUrl()}/requieretoken/reporte/guardarReporte`, reporte).pipe(catchError(this.handleError));
+        return this.httpClient.post(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/guardarReporte`, reporte).pipe(catchError(this.handleError));
     }
     eliminarReporte(reporte) {
-        return this.httpClient.post(`${this.getUrl()}/requieretoken/reporte/eliminarReporte`, reporte).pipe(catchError(this.handleError));
+        return this.httpClient.post(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/eliminarReporte`, reporte).pipe(catchError(this.handleError));
     }
     consultarListas() {
-        return this.httpClient.get(`${this.getUrl()}/requieretoken/reporte/consultarListas`).pipe(catchError(this.handleError));
+        return this.httpClient.get(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/consultarListas`).pipe(catchError(this.handleError));
     }
     guardarEntrada(entrada) {
-        return this.httpClient.post(`${this.getUrl()}/requieretoken/reporte/guardarEntrada`, entrada).pipe(catchError(this.handleError));
+        return this.httpClient.post(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/guardarEntrada`, entrada).pipe(catchError(this.handleError));
     }
     cargarCampos(entrada) {
-        return this.httpClient.post(`${this.getUrl()}/requieretoken/reporte/cargarCampos`, entrada).pipe(catchError(this.handleError));
+        return this.httpClient.post(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/cargarCampos`, entrada).pipe(catchError(this.handleError));
     }
     construirColumnas(entrada) {
-        return this.httpClient.post(`${this.getUrl()}/requieretoken/reporte/construirColumnas`, entrada).pipe(catchError(this.handleError));
+        return this.httpClient.post(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/construirColumnas`, entrada).pipe(catchError(this.handleError));
     }
     generarJasper(llaveReporte, jasper) {
         let formData = new FormData();
         formData.append("llaveReporte", llaveReporte);
         formData.append("jasper", jasper);
-        return this.httpClient.post(`${this.getUrl()}/requieretoken/reporte/generarJasper`, formData).pipe(catchError(this.handleError));
+        return this.httpClient.post(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/generarJasper`, formData).pipe(catchError(this.handleError));
     }
     eliminarEjecucionReporte(reporte) {
-        return this.httpClient.post(`${this.getUrl()}/requieretoken/reporte/eliminarEjecucionReporte`, reporte).pipe(catchError(this.handleError));
+        return this.httpClient.post(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/eliminarEjecucionReporte`, reporte).pipe(catchError(this.handleError));
     }
     obtenerListaEntradaEjecucion(reporte) {
-        return this.httpClient.post(`${this.getUrl()}/requieretoken/reporte/obtenerListaEntradaEjecucion`, reporte).pipe(catchError(this.handleError));
+        return this.httpClient.post(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/obtenerListaEntradaEjecucion`, reporte).pipe(catchError(this.handleError));
     }
     obtenerSentencia(reporte) {
-        return this.httpClient.post(`${this.getUrl()}/requieretoken/reporte/obtenerSentencia`, reporte).pipe(catchError(this.handleError));
+        return this.httpClient.post(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/obtenerSentencia`, reporte).pipe(catchError(this.handleError));
     }
     enviarSegundoPlano(reporte) {
-        return this.httpClient.post(`${this.getUrl()}/requieretoken/reporte/enviarSegundoPlano`, reporte).pipe(catchError(this.handleError));
+        return this.httpClient.post(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/enviarSegundoPlano`, reporte).pipe(catchError(this.handleError));
     }
     descargarReporte(reporte) {
-        return this.httpClient.post(`${this.getUrl()}/requieretoken/reporte/descargarReporte`, reporte).pipe(catchError(this.handleError));
+        return this.httpClient.post(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/descargarReporte`, reporte).pipe(catchError(this.handleError));
     }
     generarTabla(reporte) {
-        return this.httpClient.post(`${this.getUrl()}/requieretoken/reporte/generarTabla`, reporte).pipe(catchError(this.handleError));
+        return this.httpClient.post(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/generarTabla`, reporte).pipe(catchError(this.handleError));
     }
     actualizarReporteColumnaOrden(reporte) {
-        return this.httpClient.post(`${this.getUrl()}/requieretoken/reporte/actualizarReporteColumnaOrden`, reporte).pipe(catchError(this.handleError));
+        return this.httpClient.post(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/actualizarReporteColumnaOrden`, reporte).pipe(catchError(this.handleError));
     }
     descargarArchivo(parametroGeneral) {
-        const url = `${this.getUrl()}/requieretoken/generalSara/descargarArchivo`;
+        const url = `${this.utilsService.obtenerUrlApi()}/requieretoken/generalSara/descargarArchivo`;
         return this.httpClient.post(url, parametroGeneral, {
             responseType: 'blob',
             headers: {
@@ -94,7 +91,7 @@ export class EjecucionReporteService {
         });
     }
     descargarArchivoMasivo(parametroGeneral) {
-        const url = `${this.getUrl()}/requieretoken/generalSara/descargarArchivoMasivo`;
+        const url = `${this.utilsService.obtenerUrlApi()}/requieretoken/generalSara/descargarArchivoMasivo`;
         return this.httpClient.post(url, parametroGeneral, {
             responseType: 'blob',
             headers: {
@@ -102,7 +99,10 @@ export class EjecucionReporteService {
             }
         });
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: EjecucionReporteService, deps: [{ token: i1.HttpClient }, { token: i2.ErrorIntecertorService }, { token: i3.CookieService }], target: i0.ɵɵFactoryTarget.Injectable });
+    verGrafico(reporte) {
+        return this.httpClient.post(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/verGrafico`, reporte).pipe(catchError(this.handleError));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: EjecucionReporteService, 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: EjecucionReporteService, providedIn: 'root' });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: EjecucionReporteService, decorators: [{
@@ -110,5 +110,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImpor
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.ErrorIntecertorService }, { type: i3.CookieService }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ejecucionreporte.service.js","sourceRoot":"","sources":["../../../../../../src/app/webcommon/services/ejecucionreporte.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpErrorResponse } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { Observable, catchError, map, of, throwError } from 'rxjs';\nimport { GeneralModel } from '../../seguridad/modelos/GeneralModel';\nimport { ErrorIntecertorService } from '../../core/servicios/error-interceptor.service';\nimport { CookieService } from 'ngx-cookie-service';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class EjecucionReporteService {\n\n  listProcedure(objetoFiltro: GeneralModel) {\n    throw new Error('Method not implemented.');\n  }\n\n  constructor(private httpClient: HttpClient, private errorInterceptor: ErrorIntecertorService, private cookieService: CookieService) {\n    this.handleError = this.handleError.bind(this);\n  }\n\n  private handleError(error: HttpErrorResponse) {\n    console.log(error)\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  getUrl(): string | null {\n    return this.cookieService.get('urlnucleo')\n  }\n\n  getDatosEjecucionReporte(reporte): Observable<any> {\n    return this.httpClient.post<any>(`${this.getUrl()}/requieretoken/reporte/consultar`, reporte).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  guardarReporte(reporte: any): Observable<any> {\n    return this.httpClient.post<any>(`${this.getUrl()}/requieretoken/reporte/guardarReporte`, reporte).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  eliminarReporte(reporte: any): Observable<any> {\n    return this.httpClient.post<any>(`${this.getUrl()}/requieretoken/reporte/eliminarReporte`, reporte).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  consultarListas(): Observable<any> {\n    return this.httpClient.get<any>(`${this.getUrl()}/requieretoken/reporte/consultarListas`).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  guardarEntrada(entrada: any): Observable<any> {\n    return this.httpClient.post<any>(`${this.getUrl()}/requieretoken/reporte/guardarEntrada`, entrada).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  cargarCampos(entrada: any): Observable<any[]> {\n    return this.httpClient.post<any[]>(`${this.getUrl()}/requieretoken/reporte/cargarCampos`, entrada).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  construirColumnas(entrada: any): Observable<any[]> {\n    return this.httpClient.post<any[]>(`${this.getUrl()}/requieretoken/reporte/construirColumnas`, entrada).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  generarJasper(llaveReporte, jasper): Observable<any> {\n    let formData = new FormData();\n    formData.append(\"llaveReporte\", llaveReporte);\n    formData.append(\"jasper\", jasper);\n    return this.httpClient.post<any>(`${this.getUrl()}/requieretoken/reporte/generarJasper`, formData).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  eliminarEjecucionReporte(reporte: any): Observable<any> {\n    return this.httpClient.post<any>(`${this.getUrl()}/requieretoken/reporte/eliminarEjecucionReporte`, reporte).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  obtenerListaEntradaEjecucion(reporte: any): Observable<any> {\n    return this.httpClient.post<any>(`${this.getUrl()}/requieretoken/reporte/obtenerListaEntradaEjecucion`, reporte).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  obtenerSentencia(reporte: any): Observable<any> {\n    return this.httpClient.post<any>(`${this.getUrl()}/requieretoken/reporte/obtenerSentencia`, reporte).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  enviarSegundoPlano(reporte: any): Observable<any> {\n    return this.httpClient.post<any>(`${this.getUrl()}/requieretoken/reporte/enviarSegundoPlano`, reporte).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  descargarReporte(reporte: any): Observable<any> {\n    return this.httpClient.post<any>(`${this.getUrl()}/requieretoken/reporte/descargarReporte`, reporte).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  generarTabla(reporte: any): Observable<any> {\n    return this.httpClient.post<any>(`${this.getUrl()}/requieretoken/reporte/generarTabla`, reporte).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  actualizarReporteColumnaOrden(reporte: any): Observable<any> {\n    return this.httpClient.post<any>(`${this.getUrl()}/requieretoken/reporte/actualizarReporteColumnaOrden`, reporte).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  descargarArchivo(parametroGeneral: any): Observable<any> {\n\n    const url = `${this.getUrl()}/requieretoken/generalSara/descargarArchivo`;\n    return this.httpClient.post(url, parametroGeneral, {\n      \n      responseType: 'blob',\n      headers: {\n        'Content-Type': 'application/json'\n    }\n    })\n  }\n  \n  descargarArchivoMasivo(parametroGeneral: any): Observable<Blob> {\n\n    const url = `${this.getUrl()}/requieretoken/generalSara/descargarArchivoMasivo`;\n    return this.httpClient.post(url, parametroGeneral, {\n      responseType: 'blob',\n      headers: {\n        'Content-Type': 'application/json'\n    }\n    })\n  }\n\n}"]}
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.ErrorIntecertorService }, { type: i3.UtilsService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ejecucionreporte.service.js","sourceRoot":"","sources":["../../../../../../src/app/webcommon/services/ejecucionreporte.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpErrorResponse } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\nimport { Observable, catchError, map, of, throwError } from 'rxjs';\nimport { GeneralModel } from '../../seguridad/modelos/GeneralModel';\nimport { ErrorIntecertorService } from '../../core/servicios/error-interceptor.service';\nimport { UtilsService } from '../../core/servicios/utils.service';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class EjecucionReporteService {\n\n  listProcedure(objetoFiltro: GeneralModel) {\n    throw new Error('Method not implemented.');\n  }\n\n  constructor(private httpClient: HttpClient, private errorInterceptor: ErrorIntecertorService, private utilsService: UtilsService) {\n    this.handleError = this.handleError.bind(this);\n  }\n\n  private handleError(error: HttpErrorResponse) {\n    console.log(error)\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  getDatosEjecucionReporte(reporte): Observable<any> {\n    return this.httpClient.post<any>(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/consultar`, reporte).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  guardarReporte(reporte: any): Observable<any> {\n    return this.httpClient.post<any>(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/guardarReporte`, reporte).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  eliminarReporte(reporte: any): Observable<any> {\n    return this.httpClient.post<any>(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/eliminarReporte`, reporte).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  consultarListas(): Observable<any> {\n    return this.httpClient.get<any>(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/consultarListas`).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  guardarEntrada(entrada: any): Observable<any> {\n    return this.httpClient.post<any>(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/guardarEntrada`, entrada).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  cargarCampos(entrada: any): Observable<any[]> {\n    return this.httpClient.post<any[]>(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/cargarCampos`, entrada).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  construirColumnas(entrada: any): Observable<any[]> {\n    return this.httpClient.post<any[]>(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/construirColumnas`, entrada).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  generarJasper(llaveReporte, jasper): Observable<any> {\n    let formData = new FormData();\n    formData.append(\"llaveReporte\", llaveReporte);\n    formData.append(\"jasper\", jasper);\n    return this.httpClient.post<any>(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/generarJasper`, formData).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  eliminarEjecucionReporte(reporte: any): Observable<any> {\n    return this.httpClient.post<any>(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/eliminarEjecucionReporte`, reporte).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  obtenerListaEntradaEjecucion(reporte: any): Observable<any> {\n    return this.httpClient.post<any>(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/obtenerListaEntradaEjecucion`, reporte).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  obtenerSentencia(reporte: any): Observable<any> {\n    return this.httpClient.post<any>(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/obtenerSentencia`, reporte).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  enviarSegundoPlano(reporte: any): Observable<any> {\n    return this.httpClient.post<any>(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/enviarSegundoPlano`, reporte).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  descargarReporte(reporte: any): Observable<any> {\n    return this.httpClient.post<any>(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/descargarReporte`, reporte).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  generarTabla(reporte: any): Observable<any> {\n    return this.httpClient.post<any>(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/generarTabla`, reporte).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  actualizarReporteColumnaOrden(reporte: any): Observable<any> {\n    return this.httpClient.post<any>(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/actualizarReporteColumnaOrden`, reporte).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n  descargarArchivo(parametroGeneral: any): Observable<any> {\n\n    const url = `${this.utilsService.obtenerUrlApi()}/requieretoken/generalSara/descargarArchivo`;\n    return this.httpClient.post(url, parametroGeneral, {\n      \n      responseType: 'blob',\n      headers: {\n        'Content-Type': 'application/json'\n    }\n    })\n  }\n  \n  descargarArchivoMasivo(parametroGeneral: any): Observable<Blob> {\n\n    const url = `${this.utilsService.obtenerUrlApi()}/requieretoken/generalSara/descargarArchivoMasivo`;\n    return this.httpClient.post(url, parametroGeneral, {\n      responseType: 'blob',\n      headers: {\n        'Content-Type': 'application/json'\n    }\n    })\n  }\n\n  verGrafico(reporte: any): Observable<any> {\n    return this.httpClient.post<any>(`${this.utilsService.obtenerUrlApi()}/requieretoken/reporte/verGrafico`, reporte).pipe(\n      catchError(this.handleError)\n    );\n  }\n\n}"]}

package/esm2022/src/app/webcommon/services/fechaUtils.service.mjs

@@ -4,22 +4,22 @@ 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 "ngx-cookie-service";
+import * as i4 from "../../core/servicios/utils.service";
 export class FechaUtilsService {
     httpClient;
     errorInterceptor;
     cookieService;
+    utilService;
     listProcedure(objetoFiltro) {
         throw new Error('Method not implemented.');
     }
-    constructor(httpClient, errorInterceptor, cookieService) {
+    constructor(httpClient, errorInterceptor, cookieService, utilService) {
         this.httpClient = httpClient;
         this.errorInterceptor = errorInterceptor;
         this.cookieService = cookieService;
+        this.utilService = utilService;
         this.handleError = this.handleError.bind(this);
     }
-    getUrl() {
-        return this.cookieService.get('urlnucleo');
-    }
     handleError(error) {
         if (error.status === 500) {
             //Llamado a interceptor
@@ -44,39 +44,39 @@ export class FechaUtilsService {
         const seconds = general.getUTCSeconds();
         const milliseconds = general.getUTCMilliseconds();
         const fechaFormateada = `${year}-${month.toString().padStart(2, '0')}-${day.toString().padStart(2, '0')} ${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}.${milliseconds}`;
-        return this.httpClient.post(`${this.getUrl()}/requieretoken/webcommon/fechaUtils/horaMinuto`, fechaFormateada).pipe(catchError(this.handleError));
+        return this.httpClient.post(`${this.utilService.obtenerUrlApi()}/requieretoken/webcommon/fechaUtils/horaMinuto`, fechaFormateada).pipe(catchError(this.handleError));
     }
     horaminutoFecha(general) {
-        return this.httpClient.post(`${this.getUrl()}/requieretoken/webcommon/fechaUtils/horaminutoFecha`, general).pipe(catchError(this.handleError));
+        return this.httpClient.post(`${this.utilService.obtenerUrlApi()}/requieretoken/webcommon/fechaUtils/horaminutoFecha`, general).pipe(catchError(this.handleError));
     }
     formatFecha(general) {
-        return this.httpClient.post(`${this.getUrl()}/requieretoken/webcommon/fechaUtils/formatFecha`, general).pipe(catchError(this.handleError));
+        return this.httpClient.post(`${this.utilService.obtenerUrlApi()}/requieretoken/webcommon/fechaUtils/formatFecha`, general).pipe(catchError(this.handleError));
     }
     sumaDiaFecha(general) {
-        return this.httpClient.post(`${this.getUrl()}/requieretoken/webcommon/fechaUtils/sumaDiaFecha`, general).pipe(catchError(this.handleError));
+        return this.httpClient.post(`${this.utilService.obtenerUrlApi()}/requieretoken/webcommon/fechaUtils/sumaDiaFecha`, general).pipe(catchError(this.handleError));
     }
     primerDiaSemana(general) {
-        return this.httpClient.post(`${this.getUrl()}/requieretoken/webcommon/fechaUtils/primerDiaSemana`, general).pipe(catchError(this.handleError));
+        return this.httpClient.post(`${this.utilService.obtenerUrlApi()}/requieretoken/webcommon/fechaUtils/primerDiaSemana`, general).pipe(catchError(this.handleError));
     }
     cambiarDiaSemana(general) {
-        return this.httpClient.post(`${this.getUrl()}/requieretoken/webcommon/fechaUtils/cambiarDiaSemana`, general).pipe(catchError(this.handleError));
+        return this.httpClient.post(`${this.utilService.obtenerUrlApi()}/requieretoken/webcommon/fechaUtils/cambiarDiaSemana`, general).pipe(catchError(this.handleError));
     }
     calcularHoras(general) {
-        return this.httpClient.post(`${this.getUrl()}/requieretoken/webcommon/fechaUtils/calcularHoras`, general).pipe(catchError(this.handleError));
+        return this.httpClient.post(`${this.utilService.obtenerUrlApi()}/requieretoken/webcommon/fechaUtils/calcularHoras`, general).pipe(catchError(this.handleError));
     }
     fechaTexto(general) {
-        return this.httpClient.post(`${this.getUrl()}/requieretoken/webcommon/fechaUtils/fechaTexto`, general).pipe(catchError(this.handleError));
+        return this.httpClient.post(`${this.utilService.obtenerUrlApi()}/requieretoken/webcommon/fechaUtils/fechaTexto`, general).pipe(catchError(this.handleError));
     }
     fechasTexto(general) {
-        return this.httpClient.post(`${this.getUrl()}/requieretoken/webcommon/fechaUtils/fechasTexto`, general).pipe(catchError(this.handleError));
+        return this.httpClient.post(`${this.utilService.obtenerUrlApi()}/requieretoken/webcommon/fechaUtils/fechasTexto`, general).pipe(catchError(this.handleError));
     }
     obtenerFecha(general) {
-        return this.httpClient.post(`${this.getUrl()}/requieretoken/webcommon/fechaUtils/obtenerFecha`, general).pipe(catchError(this.handleError));
+        return this.httpClient.post(`${this.utilService.obtenerUrlApi()}/requieretoken/webcommon/fechaUtils/obtenerFecha`, general).pipe(catchError(this.handleError));
     }
     ultimoDiaMes(general) {
-        return this.httpClient.post(`${this.getUrl()}/requieretoken/webcommon/fechaUtils/ultimoDiaMes`, general).pipe(catchError(this.handleError));
+        return this.httpClient.post(`${this.utilService.obtenerUrlApi()}/requieretoken/webcommon/fechaUtils/ultimoDiaMes`, general).pipe(catchError(this.handleError));
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: FechaUtilsService, deps: [{ token: i1.HttpClient }, { token: i2.ErrorIntecertorService }, { token: i3.CookieService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: FechaUtilsService, deps: [{ token: i1.HttpClient }, { token: i2.ErrorIntecertorService }, { token: i3.CookieService }, { token: i4.UtilsService }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: FechaUtilsService, providedIn: 'root' });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImport: i0, type: FechaUtilsService, decorators: [{
@@ -84,5 +84,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.4", ngImpor
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.ErrorIntecertorService }, { type: i3.CookieService }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fechaUtils.service.js","sourceRoot":"","sources":["../../../../../../src/app/webcommon/services/fechaUtils.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpRequest, HttpEvent, HttpErrorResponse } from '@angular/common/http';\nimport { Observable, catchError, throwError } from 'rxjs';\nimport { Injectable } from '@angular/core';\nimport { GeneralModel } from '../../seguridad/modelos/GeneralModel';\nimport { ErrorIntecertorService } from '../../core/servicios/error-interceptor.service';\n\nimport { CookieService } from 'ngx-cookie-service';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class FechaUtilsService {\n\n\n    listProcedure(objetoFiltro: GeneralModel) {\n        throw new Error('Method not implemented.');\n    }\n\n    constructor(private httpClient: HttpClient, private errorInterceptor: ErrorIntecertorService, private cookieService: CookieService) {\n        this.handleError = this.handleError.bind(this);\n    }\n\n    getUrl(): string | null {\n        return this.cookieService.get('urlnucleo')\n      }\n\n    private handleError(error: HttpErrorResponse) {\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    horaMinuto(general: any): Observable<any> {\n\n        const year = general.getFullYear();\n        const month = general.getMonth() + 1;\n        const day = general.getDate();\n        const hours = general.getHours();\n        const minutes = general.getMinutes();\n        const seconds = general.getUTCSeconds();\n        const milliseconds = general.getUTCMilliseconds();\n        const fechaFormateada = `${year}-${month.toString().padStart(2, '0')}-${day.toString().padStart(2, '0')} ${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}.${milliseconds}`;\n\n        return this.httpClient.post<any>(`${this.getUrl()}/requieretoken/webcommon/fechaUtils/horaMinuto`, fechaFormateada).pipe(\n            catchError(this.handleError)\n        );\n    }\n\n    horaminutoFecha(general: any): Observable<any> {\n\n        return this.httpClient.post<any>(`${this.getUrl()}/requieretoken/webcommon/fechaUtils/horaminutoFecha`, general).pipe(\n            catchError(this.handleError)\n        );\n    }\n\n    formatFecha(general: any): Observable<any> {\n        return this.httpClient.post<any>(`${this.getUrl()}/requieretoken/webcommon/fechaUtils/formatFecha`, general).pipe(\n            catchError(this.handleError)\n        );\n    }\n\n    sumaDiaFecha(general: any): Observable<any> {\n        return this.httpClient.post<any>(`${this.getUrl()}/requieretoken/webcommon/fechaUtils/sumaDiaFecha`, general).pipe(\n            catchError(this.handleError)\n        );\n    }\n    \n    primerDiaSemana(general: any): Observable<any> {\n        return this.httpClient.post<any>(`${this.getUrl()}/requieretoken/webcommon/fechaUtils/primerDiaSemana`, general).pipe(\n            catchError(this.handleError)\n        );\n    }\n\n    cambiarDiaSemana(general: any): Observable<any> {\n        return this.httpClient.post<any>(`${this.getUrl()}/requieretoken/webcommon/fechaUtils/cambiarDiaSemana`, general).pipe(\n            catchError(this.handleError)\n        );\n    }\n\n    calcularHoras(general: any): Observable<any> {\n        return this.httpClient.post<any>(`${this.getUrl()}/requieretoken/webcommon/fechaUtils/calcularHoras`, general).pipe(\n            catchError(this.handleError)\n        );\n    }\n\n    fechaTexto(general: any): Observable<any> {\n        return this.httpClient.post<any>(`${this.getUrl()}/requieretoken/webcommon/fechaUtils/fechaTexto`, general).pipe(\n            catchError(this.handleError)\n        );\n    }\n\n    fechasTexto(general: any): Observable<any> {\n        return this.httpClient.post<any>(`${this.getUrl()}/requieretoken/webcommon/fechaUtils/fechasTexto`, general).pipe(\n            catchError(this.handleError)\n        );\n    }\n\n    obtenerFecha(general: any): Observable<any> {\n        return this.httpClient.post<any>(`${this.getUrl()}/requieretoken/webcommon/fechaUtils/obtenerFecha`, general).pipe(\n            catchError(this.handleError)\n        );\n    }\n\n    ultimoDiaMes(general: any): Observable<any> {\n        return this.httpClient.post<any>(`${this.getUrl()}/requieretoken/webcommon/fechaUtils/ultimoDiaMes`, general).pipe(\n            catchError(this.handleError)\n        );\n    }\n\n}"]}
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.ErrorIntecertorService }, { type: i3.CookieService }, { type: i4.UtilsService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fechaUtils.service.js","sourceRoot":"","sources":["../../../../../../src/app/webcommon/services/fechaUtils.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpRequest, HttpEvent, HttpErrorResponse } from '@angular/common/http';\nimport { Observable, catchError, throwError } from 'rxjs';\nimport { Injectable } from '@angular/core';\nimport { GeneralModel } from '../../seguridad/modelos/GeneralModel';\nimport { ErrorIntecertorService } from '../../core/servicios/error-interceptor.service';\n\nimport { CookieService } from 'ngx-cookie-service';\nimport { UtilsService } from '../../core/servicios/utils.service';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class FechaUtilsService {\n\n\n    listProcedure(objetoFiltro: GeneralModel) {\n        throw new Error('Method not implemented.');\n    }\n\n    constructor(private httpClient: HttpClient, private errorInterceptor: ErrorIntecertorService, private cookieService: CookieService, private utilService: UtilsService) {\n        this.handleError = this.handleError.bind(this);\n    }\n\n    private handleError(error: HttpErrorResponse) {\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    horaMinuto(general: any): Observable<any> {\n\n        const year = general.getFullYear();\n        const month = general.getMonth() + 1;\n        const day = general.getDate();\n        const hours = general.getHours();\n        const minutes = general.getMinutes();\n        const seconds = general.getUTCSeconds();\n        const milliseconds = general.getUTCMilliseconds();\n        const fechaFormateada = `${year}-${month.toString().padStart(2, '0')}-${day.toString().padStart(2, '0')} ${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}.${milliseconds}`;\n\n        return this.httpClient.post<any>(`${this.utilService.obtenerUrlApi()}/requieretoken/webcommon/fechaUtils/horaMinuto`, fechaFormateada).pipe(\n            catchError(this.handleError)\n        );\n    }\n\n    horaminutoFecha(general: any): Observable<any> {\n\n        return this.httpClient.post<any>(`${this.utilService.obtenerUrlApi()}/requieretoken/webcommon/fechaUtils/horaminutoFecha`, general).pipe(\n            catchError(this.handleError)\n        );\n    }\n\n    formatFecha(general: any): Observable<any> {\n        return this.httpClient.post<any>(`${this.utilService.obtenerUrlApi()}/requieretoken/webcommon/fechaUtils/formatFecha`, general).pipe(\n            catchError(this.handleError)\n        );\n    }\n\n    sumaDiaFecha(general: any): Observable<any> {\n        return this.httpClient.post<any>(`${this.utilService.obtenerUrlApi()}/requieretoken/webcommon/fechaUtils/sumaDiaFecha`, general).pipe(\n            catchError(this.handleError)\n        );\n    }\n    \n    primerDiaSemana(general: any): Observable<any> {\n        return this.httpClient.post<any>(`${this.utilService.obtenerUrlApi()}/requieretoken/webcommon/fechaUtils/primerDiaSemana`, general).pipe(\n            catchError(this.handleError)\n        );\n    }\n\n    cambiarDiaSemana(general: any): Observable<any> {\n        return this.httpClient.post<any>(`${this.utilService.obtenerUrlApi()}/requieretoken/webcommon/fechaUtils/cambiarDiaSemana`, general).pipe(\n            catchError(this.handleError)\n        );\n    }\n\n    calcularHoras(general: any): Observable<any> {\n        return this.httpClient.post<any>(`${this.utilService.obtenerUrlApi()}/requieretoken/webcommon/fechaUtils/calcularHoras`, general).pipe(\n            catchError(this.handleError)\n        );\n    }\n\n    fechaTexto(general: any): Observable<any> {\n        return this.httpClient.post<any>(`${this.utilService.obtenerUrlApi()}/requieretoken/webcommon/fechaUtils/fechaTexto`, general).pipe(\n            catchError(this.handleError)\n        );\n    }\n\n    fechasTexto(general: any): Observable<any> {\n        return this.httpClient.post<any>(`${this.utilService.obtenerUrlApi()}/requieretoken/webcommon/fechaUtils/fechasTexto`, general).pipe(\n            catchError(this.handleError)\n        );\n    }\n\n    obtenerFecha(general: any): Observable<any> {\n        return this.httpClient.post<any>(`${this.utilService.obtenerUrlApi()}/requieretoken/webcommon/fechaUtils/obtenerFecha`, general).pipe(\n            catchError(this.handleError)\n        );\n    }\n\n    ultimoDiaMes(general: any): Observable<any> {\n        return this.httpClient.post<any>(`${this.utilService.obtenerUrlApi()}/requieretoken/webcommon/fechaUtils/ultimoDiaMes`, general).pipe(\n            catchError(this.handleError)\n        );\n    }\n\n}"]}