gamma-app-controller 1.1.27 → 1.1.29

package/esm2020/lib/template-module/kpiWithSingleLayout/kpi-single-layout.service.mjs

@@ -0,0 +1,121 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Inject, Injectable } from '@angular/core';
+import { catchError, map, Subject, throwError, BehaviorSubject } from 'rxjs';
+import { APP_ENVIRONMENT } from '../../application-controller/environment';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class KpiWithSingleLayoutService {
+    constructor(http, environment) {
+        this.http = http;
+        this.environment = environment;
+        this.headers = new HttpHeaders().set('Content-Type', 'application/json');
+        this.options = { headers: this.headers, withCredentials: true };
+        this._selectedKpiOnClick = new Subject();
+        this._kpilist = new Subject();
+        this._selectKpiFromDropDown = new Subject();
+        this._componentRegistry = new Map();
+        this.kpiFilter = new BehaviorSubject([]);
+    }
+    handleError(error) {
+        return throwError(error);
+    }
+    getlistKpiBrowser() {
+        const apiUrl = this.environment.appUrl + this.environment.apiVersion + '/kpi-config/listKpiBrowser';
+        return this.http
+            .get(apiUrl, { withCredentials: true })
+            .pipe(map((response) => {
+            return response;
+        }), catchError(this.handleError));
+    }
+    getAppPageDetailConfig(pageId) {
+        return this.http
+            .get(this.environment.appUrl + this.environment.apiVersion + '/kpi-config/getAppPageDetailConfig?pageConfigId=' + pageId, this.options)
+            .pipe(map((response) => {
+            return response;
+        }), catchError(this.handleError));
+    }
+    getAppPageConfigs() {
+        const apiUrl = this.environment.appUrl + this.environment.apiVersion + '/kpi-config/getAppPageConfigs';
+        return this.http
+            .get(apiUrl, { withCredentials: true })
+            .pipe(map((response) => {
+            return response;
+        }), catchError(this.handleError));
+    }
+    getAppDatasetConfigs() {
+        const apiUrl = this.environment.appUrl + this.environment.apiVersion + '/kpi-config/getAppDatasetConfigs';
+        return this.http
+            .get(apiUrl, { withCredentials: true })
+            .pipe(map((response) => {
+            return response;
+        }), catchError(this.handleError));
+    }
+    getAppDatasetConfig(datasetId) {
+        const apiUrl = this.environment.appUrl + this.environment.apiVersion + '/kpi-config/getAppDatasetConfig?datasetId=' + datasetId;
+        return this.http
+            .get(apiUrl, { withCredentials: true })
+            .pipe(map((response) => {
+            return response;
+        }), catchError(this.handleError));
+    }
+    getAppFilterConfig(filterId) {
+        return this.http
+            .get(this.environment.appUrl + this.environment.apiVersion + '/kpi-config/getAppFilterConfig?filterId=' + filterId, this.options)
+            .pipe(map((response) => {
+            return response;
+        }), catchError(this.handleError));
+    }
+    getAppViewConfigs() {
+        const apiUrl = this.environment.appUrl + this.environment.apiVersion + '/kpi-config/getAppViewConfigs';
+        return this.http
+            .get(apiUrl, { withCredentials: true })
+            .pipe(map((response) => {
+            return response;
+        }), catchError(this.handleError));
+    }
+    getData(body, requestID) {
+        return this.http
+            .post(this.environment.appUrl + this.environment.apiVersion + requestID, JSON.stringify(body), this.options)
+            .pipe(map((response) => {
+            return response;
+        }), catchError(this.handleError));
+    }
+    getSimpleApiPostRequest(requestApi, body) {
+        return this.http
+            .post(this.environment.appUrl + this.environment.apiVersion + requestApi, JSON.stringify(body), this.options)
+            .pipe(map((response) => {
+            return response;
+        }), catchError(this.handleError));
+    }
+    getSimpleApiGetRequest(requestApi) {
+        return this.http
+            .get(this.environment.appUrl + this.environment.apiVersion + requestApi, { withCredentials: true })
+            .pipe(map((response) => {
+            return response;
+        }), catchError(this.handleError));
+    }
+    getJsonDatasetPayload(requestApi) {
+        return this.http
+            .get(this.environment.appUrl + this.environment.apiVersion + requestApi, { withCredentials: true })
+            .pipe(map((response) => {
+            return response;
+        }), catchError(this.handleError));
+    }
+    genericSqlQueryResponse(requestApi, body) {
+        return this.http
+            .post(this.environment.appUrl + this.environment.apiVersion + requestApi, JSON.stringify(body), this.options)
+            .pipe(map((response) => {
+            return response;
+        }), catchError(this.handleError));
+    }
+}
+KpiWithSingleLayoutService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: KpiWithSingleLayoutService, deps: [{ token: i1.HttpClient }, { token: APP_ENVIRONMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+KpiWithSingleLayoutService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: KpiWithSingleLayoutService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: KpiWithSingleLayoutService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: "root" }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [APP_ENVIRONMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"kpi-single-layout.service.js","sourceRoot":"","sources":["../../../../../../projects/gamma-app-controller/src/lib/template-module/kpiWithSingleLayout/kpi-single-layout.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpHeaders } from '@angular/common/http'\nimport { Inject, Injectable } from '@angular/core';\nimport { catchError, map, Subject, throwError, BehaviorSubject, Observable } from 'rxjs';\nimport { APP_ENVIRONMENT } from '../../application-controller/environment';\n\n\n@Injectable({ providedIn: \"root\" })\nexport class KpiWithSingleLayoutService {\n\n\n    public headers = new HttpHeaders().set('Content-Type', 'application/json');\n    public options = { headers: this.headers, withCredentials: true };\n\n\n    _selectedKpiOnClick: Subject<any> = new Subject<any>();\n    _kpilist: Subject<any> = new Subject<any>();\n\n    _selectKpiFromDropDown: Subject<any> = new Subject<any>();\n\n    private _componentRegistry: Map<string, any> = new Map<string, any>();\n    private kpiFilter = new BehaviorSubject<any>([]);\n\n    constructor(public http: HttpClient, @Inject(APP_ENVIRONMENT) private environment: any) {\n    }\n\n    handleError(error: any): Observable<Response> {\n        return throwError(error);\n    }\n\n    getlistKpiBrowser(): any {\n        const apiUrl = this.environment.appUrl + this.environment.apiVersion + '/kpi-config/listKpiBrowser';\n        return this.http\n            .get(apiUrl, { withCredentials: true })\n            .pipe(map((response: Response) => {\n                return response;\n            }), catchError(this.handleError));\n\n    }\n\n    getAppPageDetailConfig(pageId): any {\n        return this.http\n            .get(this.environment.appUrl + this.environment.apiVersion + '/kpi-config/getAppPageDetailConfig?pageConfigId=' + pageId, this.options)\n            .pipe(map((response: Response): any => {\n                return response;\n            }),\n                catchError(this.handleError));\n    }\n\n    getAppPageConfigs(): any {\n        const apiUrl = this.environment.appUrl + this.environment.apiVersion + '/kpi-config/getAppPageConfigs';\n        return this.http\n            .get(apiUrl, { withCredentials: true })\n            .pipe(map((response: Response) => {\n                return response;\n            }), catchError(this.handleError));\n\n    }\n\n    getAppDatasetConfigs(): any {\n        const apiUrl = this.environment.appUrl + this.environment.apiVersion + '/kpi-config/getAppDatasetConfigs';\n        return this.http\n            .get(apiUrl, { withCredentials: true })\n            .pipe(map((response: Response) => {\n                return response;\n            }), catchError(this.handleError));\n\n    }\n    getAppDatasetConfig(datasetId): any {\n        const apiUrl = this.environment.appUrl + this.environment.apiVersion + '/kpi-config/getAppDatasetConfig?datasetId=' + datasetId;\n        return this.http\n            .get(apiUrl, { withCredentials: true })\n            .pipe(map((response: Response) => {\n                return response;\n            }), catchError(this.handleError));\n\n    }\n\n    getAppFilterConfig(filterId): any {\n        return this.http\n            .get(this.environment.appUrl + this.environment.apiVersion + '/kpi-config/getAppFilterConfig?filterId=' + filterId, this.options)\n            .pipe(map((response: Response): any => {\n                return response;\n            }),\n                catchError(this.handleError));\n    }\n    getAppViewConfigs(): any {\n        const apiUrl = this.environment.appUrl + this.environment.apiVersion + '/kpi-config/getAppViewConfigs';\n        return this.http\n            .get(apiUrl, { withCredentials: true })\n            .pipe(map((response: Response) => {\n                return response;\n            }), catchError(this.handleError));\n\n    }\n\n    getData(body, requestID): any {\n        return this.http\n            .post(this.environment.appUrl + this.environment.apiVersion + requestID, JSON.stringify(body), this.options)\n            .pipe(map((response: Response): any => {\n                return response;\n            }),\n                catchError(this.handleError));\n    }\n\n     getSimpleApiPostRequest(requestApi, body): any {\n        return this.http\n            .post(this.environment.appUrl + this.environment.apiVersion + requestApi, JSON.stringify(body), this.options)\n            .pipe(map((response: Response): any => {\n                return response;\n            }),\n                catchError(this.handleError));\n    }\n    getSimpleApiGetRequest(requestApi): any {\n        return this.http\n            .get(this.environment.appUrl + this.environment.apiVersion + requestApi, { withCredentials: true })\n            .pipe(map((response: Response): any => {\n                return response;\n            }),\n                catchError(this.handleError));\n    }\n\n     getJsonDatasetPayload(requestApi): any {\n        return this.http\n            .get(this.environment.appUrl + this.environment.apiVersion + requestApi, { withCredentials: true })\n            .pipe(map((response: Response): any => {\n                return response;\n            }),\n                catchError(this.handleError));\n    }\n    genericSqlQueryResponse(requestApi, body): any {\n        return this.http\n            .post(this.environment.appUrl + this.environment.apiVersion + requestApi, JSON.stringify(body), this.options)\n            .pipe(map((response: Response): any => {\n                return response;\n            }),\n                catchError(this.handleError));\n    }\n\n}\n"]}