gamma-app-controller 1.2.27 → 1.2.30

package/esm2020/lib/shared/template-dataset-call-service.mjs

@@ -0,0 +1,376 @@
+import { Inject, Injectable } from '@angular/core';
+import moment from '../application-controller/moment-helper';
+import { APP_ENVIRONMENT } from '../application-controller/environment';
+import { APP_SECURITY_PRINCIPAL } from './security_principal';
+import * as i0 from "@angular/core";
+import * as i1 from "../application-controller/kpi-service";
+import * as i2 from "ngx-toastr";
+export class TemplateDatasetCallService {
+    constructor(kpiService, toastr, environment, securityPrincipal) {
+        this.kpiService = kpiService;
+        this.toastr = toastr;
+        this.environment = environment;
+        this.securityPrincipal = securityPrincipal;
+        this.uniqueDataSetObject = {};
+    }
+    getDataFromDataSet(backendService, dataset, datasetId, filters) {
+        if (dataset.datasetType === 'mongo') {
+            return this.getDataSetForMongo(backendService, dataset, datasetId);
+        }
+        else if (dataset.datasetType === 'querybuilder') {
+            return this.getDatasetForImpala(backendService, dataset, datasetId, filters);
+        }
+        else if (dataset.datasetType === 'simpleApi') {
+            return this.getDatasetForSimpleApiImpala(backendService, dataset, datasetId, filters);
+        }
+        else if (dataset.datasetType === 'plainjson') {
+            return this.getDatasetForPlainJson(backendService, dataset, datasetId, filters);
+        }
+        else if (dataset.datasetType === 'sqlQuery') {
+            return this.getDatasetForSqlTemplate(backendService, dataset, datasetId, filters);
+        }
+        else {
+            return Promise.resolve();
+        }
+    }
+    getDataSetForMongo(backendService, dataset, datasetId) {
+        return new Promise((resolve, reject) => {
+            let apiJsonObject = {
+                requestId: dataset.config.serviceId
+            };
+            if (dataset.config.fixOperationLevles && dataset.config.fixOperationLevles.length != 0) {
+                for (const item of dataset.config.fixOperationLevles) {
+                    Object.assign(apiJsonObject, item);
+                }
+            }
+            const mon_config = this.kpiService.getAllSeviceApiJson(apiJsonObject);
+            backendService.getData(mon_config, dataset.config.api).subscribe({
+                next: (data) => {
+                    const payload = data['Payload'] || data;
+                    this.uniqueDataSetObject[datasetId] = payload;
+                    resolve();
+                },
+                error: (err) => {
+                    console.error('Error:', err);
+                    reject(err);
+                }
+            });
+        });
+    }
+    getDatasetForImpala(backendService, dataset, datasetId, filters) {
+        return new Promise((resolve, reject) => {
+            let request = dataset.config.queryConfig;
+            let transformedObject = {};
+            for (let item of request.reqFields) {
+                const key = Object.keys(item)[0];
+                const value = Object.values(item)[0];
+                if (key === 'startDate') {
+                    transformedObject.recordDate = value;
+                }
+                else {
+                    transformedObject[key] = value;
+                }
+            }
+            const operator = (filters && filters.length !== 0) ? Object.keys(filters.operationFilter).map(key => ({ [key]: filters.operationFilter[key] })) : [];
+            transformedObject['filters'] = this.transformDataForMFilter(operator, request.mapedFilters);
+            transformedObject['sorters'] = request.sorters;
+            transformedObject['paginationRequired'] = false;
+            if (dataset.config.api == "/kpi/genericAggregatePaginatedKpiServiceResponse") {
+                transformedObject['measures'] = request.measures;
+                transformedObject['dimensions'] = request.dimensions;
+            }
+            else {
+                transformedObject['columns'] = this.getFormatObjectForColumn(request.columns);
+            }
+            if (request.havings && request.havings.length !== 0) {
+                transformedObject['havings'] = request.havings;
+            }
+            backendService.getData(transformedObject, dataset.config.api).subscribe({
+                next: (data) => {
+                    const payload = data['dataset'];
+                    this.uniqueDataSetObject[datasetId] = payload;
+                    resolve();
+                },
+                error: (err) => {
+                    console.error('Error:', err);
+                    this.toastr.error(err.message);
+                    reject(err);
+                }
+            });
+        });
+    }
+    getFormatObjectForColumn(columns) {
+        let columnData = [];
+        columns.forEach(element => {
+            const { advancedColumn, columnName, enrichFunction, dataField } = element;
+            columnData.push({
+                advancedColumn,
+                columnName,
+                enrichFunction,
+                aliasName: dataField
+            });
+        });
+        return columnData;
+    }
+    transformDataForMFilter(filterdata, mapData) {
+        let result = [];
+        mapData.forEach(mapping => {
+            let resultObj = {
+                columnName: mapping.serverColumn,
+                dataType: mapping.dataType,
+                operator: mapping.operatorName,
+                value: mapping.defaultValue
+            };
+            if (mapping.serverColumn.includes('date') && typeof resultObj.value === 'string') {
+                if (mapping.formatter && mapping.formatter !== "") {
+                    resultObj.value = moment(resultObj.value, "YYYY-MM-DD").format(mapping.formatter);
+                }
+                else {
+                    resultObj.value = moment(resultObj.value, "YYYY-MM-DD").format(this.environment.dataFormat);
+                }
+            }
+            const filter = filterdata.find(f => f.hasOwnProperty(mapping.localColumn));
+            if (filter) {
+                if (mapping.defaultValue === "") {
+                    const value = filter[mapping.localColumn];
+                    if (Array.isArray(value)) {
+                        resultObj.operator = "in";
+                        resultObj.value = value.join(",");
+                    }
+                    else {
+                        resultObj.value = value;
+                    }
+                    if (mapping.serverColumn.includes('date') && typeof resultObj.value === 'string') {
+                        if (mapping.formatter && mapping.formatter !== "") {
+                            resultObj.value = moment(resultObj.value, "YYYY-MM-DD").format(mapping.formatter);
+                        }
+                        else {
+                            resultObj.value = moment(resultObj.value, "YYYY-MM-DD").format(this.environment.dataFormat);
+                        }
+                    }
+                }
+            }
+            else if (mapping.defaultValue === "") {
+                return;
+            }
+            result.push(resultObj);
+        });
+        filterdata = filterdata.filter(obj => {
+            const key = Object.keys(obj)[0];
+            return key !== 'startDate' && key !== 'endDate';
+        });
+        filterdata.forEach(filter => {
+            const filterKey = Object.keys(filter)[0];
+            const existingMapping = mapData.find(mapping => mapping.localColumn === filterKey);
+            if (!existingMapping) {
+                let resultObj = {
+                    columnName: filterKey,
+                    dataType: "string",
+                    operator: "eq",
+                    value: filter[filterKey]
+                };
+                if (Array.isArray(filter[filterKey])) {
+                    resultObj.operator = "in";
+                    resultObj.value = filter[filterKey].join(",");
+                }
+                else {
+                    resultObj.value = filter[filterKey];
+                }
+                if (filterKey == 'operator_key') {
+                    resultObj.operator = "eq";
+                }
+                result.push(resultObj);
+            }
+        });
+        result = result.filter(obj => obj.value !== null && obj.value !== "");
+        return result;
+    }
+    getDatasetForSimpleApiImpala(backendService, dataset, datasetId, filters) {
+        return new Promise((resolve, reject) => {
+            dataset.config.queryConfig.mapedFilters.forEach(filter => {
+                if (filters.operationFilter.hasOwnProperty(filter.localColumn)) {
+                    filter.defaultValue = filters.operationFilter[filter.localColumn];
+                }
+            });
+            if (dataset.config.apiType === "post") {
+                let serviceJson = {};
+                dataset.config.queryConfig.mapedFilters.forEach((filter) => {
+                    let datecolumn = filter.serverColumn.toLowerCase();
+                    if (datecolumn.includes('date') && typeof filter.dataType === 'string') {
+                        serviceJson[filter.serverColumn] = moment(filter.defaultValue, "YYYY-MM-DD").format(this.environment.dataFormat);
+                    }
+                    else {
+                        serviceJson[filter.serverColumn] = filter.defaultValue;
+                    }
+                });
+                backendService.getSimpleApiPostRequest(dataset.config.api, serviceJson).subscribe({
+                    next: (data) => {
+                        const payload = data["Payload"] || data;
+                        this.uniqueDataSetObject[datasetId] = payload;
+                        resolve();
+                    },
+                    error: (err) => {
+                        console.error('Error:', err);
+                        this.toastr.error(err.message);
+                        reject(err);
+                    }
+                });
+            }
+            else if (dataset.config.apiType === "get") {
+                let requestUrl = dataset.config.api + "?";
+                dataset.config.queryConfig.mapedFilters.forEach((filter, index) => {
+                    requestUrl += `${filter.serverColumn}=${filter.defaultValue}`;
+                    if (index < dataset.config.queryConfig.mapedFilters.length - 1) {
+                        requestUrl += "&";
+                    }
+                });
+                backendService.getSimpleApiGetRequest(requestUrl).subscribe({
+                    next: (data) => {
+                        const payload = data["Payload"] || data;
+                        this.uniqueDataSetObject[datasetId] = payload;
+                        resolve();
+                    },
+                    error: (err) => {
+                        console.error('Error:', err);
+                        this.toastr.error(err.message);
+                        reject(err);
+                    }
+                });
+            }
+        });
+    }
+    getDatasetForPlainJson(backendService, dataset, datasetId, _filter) {
+        return new Promise((resolve, reject) => {
+            let requestapi = dataset.config.api + '?datasetId=' + dataset.datasetId;
+            backendService.getJsonDatasetPayload(requestapi).subscribe({
+                next: (data) => {
+                    const payload = data["Payload"] || data;
+                    this.uniqueDataSetObject[datasetId] = payload;
+                    resolve();
+                },
+                error: (err) => {
+                    console.error('Error:', err);
+                    reject(err);
+                }
+            });
+        });
+    }
+    getDatasetForSqlTemplate(backendService, dataset, datasetId, filters) {
+        return new Promise((resolve, reject) => {
+            const operator = (filters && filters.length !== 0) ? Object.keys(filters.operationFilter).map(key => ({ [key]: filters.operationFilter[key] })) : [];
+            let requestAp = dataset.config.api;
+            const tenantIds = dataset.config.queryConfig.mapedFilters
+                .filter(f => f.serverColumn === "tenant_id")
+                .map(f => f.defaultValue);
+            const associatedTenants = this.securityPrincipal.getTargetTenantIds();
+            const isMatch = (associatedTenants) ? tenantIds.some(t => associatedTenants.includes(t)) : true;
+            if (!isMatch) {
+                this.toastr.error("Unauthorized Access");
+                this.uniqueDataSetObject[datasetId] = [];
+                resolve();
+            }
+            else {
+                let request_params = {
+                    datasetId: datasetId,
+                    filters: this.transformDataForMFilterForSQl(operator, dataset.config.queryConfig.mapedFilters),
+                };
+                backendService.genericSqlQueryResponse(requestAp, request_params).subscribe({
+                    next: (data) => {
+                        const payload = data["Payload"] || data;
+                        this.uniqueDataSetObject[datasetId] = payload;
+                        resolve();
+                    },
+                    error: (err) => {
+                        console.error('Error:', err);
+                        this.toastr.error(err.message);
+                        reject(err);
+                    }
+                });
+            }
+        });
+    }
+    transformDataForMFilterForSQl(filterdata, mapData) {
+        let result = [];
+        mapData.forEach(mapping => {
+            let resultObj = {
+                columnName: mapping.serverColumn,
+                dataType: mapping.dataType,
+                operator: mapping.operatorName,
+                value: mapping.defaultValue,
+                aliasColumnName: mapping.localColumn
+            };
+            if (mapping.serverColumn.includes('date') && typeof resultObj.value === 'string') {
+                if (mapping.formatter && mapping.formatter !== "") {
+                    resultObj.value = moment(resultObj.value, "YYYY-MM-DD").format(mapping.formatter);
+                }
+                else {
+                    resultObj.value = moment(resultObj.value, "YYYY-MM-DD").format(this.environment.dataFormat);
+                }
+            }
+            const filter = filterdata.find(f => f.hasOwnProperty(mapping.localColumn));
+            if (filter) {
+                if (mapping.defaultValue === "") {
+                    const value = filter[mapping.localColumn];
+                    if (Array.isArray(value)) {
+                        resultObj.operator = "in";
+                        resultObj.value = value.join(",");
+                    }
+                    else {
+                        resultObj.value = value;
+                    }
+                    if (mapping.serverColumn.includes('date') && typeof resultObj.value === 'string') {
+                        resultObj.value = moment(resultObj.value, "YYYY-MM-DD").format(this.environment.dataFormat);
+                    }
+                }
+            }
+            else if (mapping.defaultValue === "") {
+                return;
+            }
+            result.push(resultObj);
+        });
+        filterdata = filterdata.filter(obj => {
+            const key = Object.keys(obj)[0];
+            return key !== 'startDate' && key !== 'endDate';
+        });
+        filterdata.forEach(filter => {
+            const filterKey = Object.keys(filter)[0];
+            const existingMapping = mapData.find(mapping => mapping.localColumn === filterKey);
+            if (!existingMapping) {
+                let resultObj = {
+                    columnName: filterKey,
+                    dataType: "string",
+                    operator: "eq",
+                    value: filter[filterKey]
+                };
+                if (Array.isArray(filter[filterKey])) {
+                    resultObj.operator = "in";
+                    resultObj.value = filter[filterKey].join(",");
+                }
+                else {
+                    resultObj.value = filter[filterKey];
+                }
+                if (filterKey == 'operator_key') {
+                    resultObj.operator = "eq";
+                }
+                result.push(resultObj);
+            }
+        });
+        return result;
+    }
+    getUniqueDataSetObject() {
+        return this.uniqueDataSetObject;
+    }
+}
+TemplateDatasetCallService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TemplateDatasetCallService, deps: [{ token: i1.kpicommonService }, { token: i2.ToastrService }, { token: APP_ENVIRONMENT }, { token: APP_SECURITY_PRINCIPAL }], target: i0.ɵɵFactoryTarget.Injectable });
+TemplateDatasetCallService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TemplateDatasetCallService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: TemplateDatasetCallService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.kpicommonService }, { type: i2.ToastrService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [APP_ENVIRONMENT]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [APP_SECURITY_PRINCIPAL]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"template-dataset-call-service.js","sourceRoot":"","sources":["../../../../../projects/gamma-app-controller/src/lib/shared/template-dataset-call-service.ts"],"names":[],"mappings":"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","sourcesContent":["import {Inject, Injectable} from '@angular/core';\nimport moment from '../application-controller/moment-helper';\nimport {ToastrService} from 'ngx-toastr';\nimport {APP_ENVIRONMENT} from '../application-controller/environment';\nimport {kpicommonService} from '../application-controller/kpi-service';\nimport {APP_SECURITY_PRINCIPAL} from './security_principal';\n\n@Injectable({providedIn: 'root'})\nexport class TemplateDatasetCallService {\n    uniqueDataSetObject: any = {};\n\n    constructor(\n        private kpiService: kpicommonService,\n        private toastr: ToastrService,\n        @Inject(APP_ENVIRONMENT) private environment: any,\n        @Inject(APP_SECURITY_PRINCIPAL) private securityPrincipal: any\n    ) {\n    }\n\n    getDataFromDataSet(backendService: any, dataset: any, datasetId: string, filters: any) {\n        if (dataset.datasetType === 'mongo') {\n            return this.getDataSetForMongo(backendService, dataset, datasetId);\n        } else if (dataset.datasetType === 'querybuilder') {\n            return this.getDatasetForImpala(backendService, dataset, datasetId, filters);\n        } else if (dataset.datasetType === 'simpleApi') {\n            return this.getDatasetForSimpleApiImpala(backendService, dataset, datasetId, filters);\n        } else if (dataset.datasetType === 'plainjson') {\n            return this.getDatasetForPlainJson(backendService, dataset, datasetId, filters);\n        } else if (dataset.datasetType === 'sqlQuery') {\n            return this.getDatasetForSqlTemplate(backendService, dataset, datasetId, filters);\n        } else {\n            return Promise.resolve();\n        }\n    }\n\n    private getDataSetForMongo(backendService: any, dataset: any, datasetId: string) {\n        return new Promise<void>((resolve, reject) => {\n            let apiJsonObject = {\n                requestId: dataset.config.serviceId\n            };\n            if (dataset.config.fixOperationLevles && dataset.config.fixOperationLevles.length != 0) {\n                for (const item of dataset.config.fixOperationLevles) {\n                    Object.assign(apiJsonObject, item);\n                }\n            }\n            const mon_config = this.kpiService.getAllSeviceApiJson(apiJsonObject);\n            backendService.getData(mon_config, dataset.config.api).subscribe({\n                next: (data: any) => {\n                    const payload = data['Payload'] || data;\n                    this.uniqueDataSetObject[datasetId] = payload;\n                    resolve();\n                },\n                error: (err: any) => {\n                    console.error('Error:', err);\n                    reject(err);\n                }\n            });\n        });\n    }\n\n    private getDatasetForImpala(backendService: any, dataset: any, datasetId: string, filters: any) {\n        return new Promise<void>((resolve, reject) => {\n            let request = dataset.config.queryConfig;\n            let transformedObject: any = {};\n            for (let item of request.reqFields) {\n                const key = Object.keys(item)[0];\n                const value = Object.values(item)[0];\n                if (key === 'startDate') {\n                    transformedObject.recordDate = value;\n                } else {\n                    transformedObject[key] = value;\n                }\n            }\n            const operator = (filters && filters.length !== 0) ? Object.keys(filters.operationFilter).map(key => ({[key]: filters.operationFilter[key]})) : [];\n\n            transformedObject['filters'] = this.transformDataForMFilter(operator, request.mapedFilters);\n            transformedObject['sorters'] = request.sorters;\n            transformedObject['paginationRequired'] = false;\n\n            if (dataset.config.api == \"/kpi/genericAggregatePaginatedKpiServiceResponse\") {\n                transformedObject['measures'] = request.measures;\n                transformedObject['dimensions'] = request.dimensions;\n            } else {\n                transformedObject['columns'] = this.getFormatObjectForColumn(request.columns);\n            }\n            if (request.havings && request.havings.length !== 0) {\n                transformedObject['havings'] = request.havings;\n            }\n\n            backendService.getData(transformedObject, dataset.config.api).subscribe({\n                next: (data: any) => {\n                    const payload = data['dataset'];\n                    this.uniqueDataSetObject[datasetId] = payload;\n                    resolve();\n                },\n                error: (err: any) => {\n                    console.error('Error:', err);\n                    this.toastr.error(err.message)\n                    reject(err);\n                }\n            });\n        });\n    }\n\n    private getFormatObjectForColumn(columns: any[]) {\n        let columnData: any[] = [];\n        columns.forEach(element => {\n            const {advancedColumn, columnName, enrichFunction, dataField} = element;\n            columnData.push({\n                advancedColumn,\n                columnName,\n                enrichFunction,\n                aliasName: dataField\n            });\n        });\n        return columnData;\n    }\n\n    private transformDataForMFilter(filterdata: any[], mapData: any[]) {\n        let result: any[] = [];\n        mapData.forEach(mapping => {\n            let resultObj: any = {\n                columnName: mapping.serverColumn,\n                dataType: mapping.dataType,\n                operator: mapping.operatorName,\n                value: mapping.defaultValue\n            };\n            if (mapping.serverColumn.includes('date') && typeof resultObj.value === 'string') {\n                if (mapping.formatter && mapping.formatter !== \"\") {\n                    resultObj.value = moment(resultObj.value, \"YYYY-MM-DD\").format(mapping.formatter);\n                } else {\n                    resultObj.value = moment(resultObj.value, \"YYYY-MM-DD\").format(this.environment.dataFormat);\n                }\n            }\n            const filter = filterdata.find(f => f.hasOwnProperty(mapping.localColumn));\n            if (filter) {\n                if (mapping.defaultValue === \"\") {\n                    const value = filter[mapping.localColumn];\n\n                    if (Array.isArray(value)) {\n                        resultObj.operator = \"in\";\n                        resultObj.value = value.join(\",\");\n                    } else {\n                        resultObj.value = value;\n                    }\n                    if (mapping.serverColumn.includes('date') && typeof resultObj.value === 'string') {\n                        if (mapping.formatter && mapping.formatter !== \"\") {\n                            resultObj.value = moment(resultObj.value, \"YYYY-MM-DD\").format(mapping.formatter);\n                        } else {\n                            resultObj.value = moment(resultObj.value, \"YYYY-MM-DD\").format(this.environment.dataFormat);\n                        }\n                    }\n                }\n            } else if (mapping.defaultValue === \"\") {\n                return;\n            }\n            result.push(resultObj);\n        });\n\n        filterdata = filterdata.filter(obj => {\n            const key = Object.keys(obj)[0];\n            return key !== 'startDate' && key !== 'endDate';\n        });\n        filterdata.forEach(filter => {\n            const filterKey = Object.keys(filter)[0];\n            const existingMapping = mapData.find(mapping => mapping.localColumn === filterKey);\n\n            if (!existingMapping) {\n                let resultObj: any = {\n                    columnName: filterKey,\n                    dataType: \"string\",\n                    operator: \"eq\",\n                    value: filter[filterKey]\n                };\n\n                if (Array.isArray(filter[filterKey])) {\n                    resultObj.operator = \"in\";\n                    resultObj.value = filter[filterKey].join(\",\");\n                } else {\n                    resultObj.value = filter[filterKey];\n                }\n\n                if (filterKey == 'operator_key') {\n                    resultObj.operator = \"eq\";\n                }\n                result.push(resultObj);\n            }\n        });\n\n        result = result.filter(obj => obj.value !== null && obj.value !== \"\");\n        return result;\n    }\n\n    private getDatasetForSimpleApiImpala(backendService: any, dataset: any, datasetId: string, filters: any) {\n        return new Promise<void>((resolve, reject) => {\n            dataset.config.queryConfig.mapedFilters.forEach(filter => {\n                if (filters.operationFilter.hasOwnProperty(filter.localColumn)) {\n                    filter.defaultValue = filters.operationFilter[filter.localColumn];\n                }\n            });\n            if (dataset.config.apiType === \"post\") {\n                let serviceJson: any = {};\n                dataset.config.queryConfig.mapedFilters.forEach((filter: any) => {\n                    let datecolumn = filter.serverColumn.toLowerCase();\n                    if (datecolumn.includes('date') && typeof filter.dataType === 'string') {\n                        serviceJson[filter.serverColumn] = moment(filter.defaultValue, \"YYYY-MM-DD\").format(this.environment.dataFormat);\n                    } else {\n                        serviceJson[filter.serverColumn] = filter.defaultValue;\n                    }\n                });\n\n                backendService.getSimpleApiPostRequest(dataset.config.api, serviceJson).subscribe({\n                    next: (data: any) => {\n                        const payload = data[\"Payload\"] || data;\n                        this.uniqueDataSetObject[datasetId] = payload;\n                        resolve();\n                    },\n                    error: (err: any) => {\n                        console.error('Error:', err);\n                        this.toastr.error(err.message)\n                        reject(err);\n                    }\n                });\n            } else if (dataset.config.apiType === \"get\") {\n                let requestUrl = dataset.config.api + \"?\";\n                dataset.config.queryConfig.mapedFilters.forEach((filter: any, index: number) => {\n                    requestUrl += `${filter.serverColumn}=${filter.defaultValue}`;\n                    if (index < dataset.config.queryConfig.mapedFilters.length - 1) {\n                        requestUrl += \"&\";\n                    }\n                });\n\n                backendService.getSimpleApiGetRequest(requestUrl).subscribe({\n                    next: (data: any) => {\n                        const payload = data[\"Payload\"] || data;\n                        this.uniqueDataSetObject[datasetId] = payload;\n                        resolve();\n                    },\n                    error: (err: any) => {\n                        console.error('Error:', err);\n                        this.toastr.error(err.message)\n                        reject(err);\n                    }\n                });\n            }\n        });\n    }\n\n    private getDatasetForPlainJson(backendService: any, dataset: any, datasetId: string, _filter: any) {\n        return new Promise<void>((resolve, reject) => {\n            let requestapi = dataset.config.api + '?datasetId=' + dataset.datasetId;\n            backendService.getJsonDatasetPayload(requestapi).subscribe({\n                next: (data: any) => {\n                    const payload = data[\"Payload\"] || data;\n                    this.uniqueDataSetObject[datasetId] = payload;\n                    resolve();\n                },\n                error: (err: any) => {\n                    console.error('Error:', err);\n                    reject(err);\n                }\n            });\n        });\n    }\n\n    private getDatasetForSqlTemplate(backendService: any, dataset: any, datasetId: string, filters: any) {\n        return new Promise<void>((resolve, reject) => {\n            const operator = (filters && filters.length !== 0) ? Object.keys(filters.operationFilter).map(key => ({[key]: filters.operationFilter[key]})) : [];\n            let requestAp = dataset.config.api;\n\n            const tenantIds = dataset.config.queryConfig.mapedFilters\n                .filter(f => f.serverColumn === \"tenant_id\")\n                .map(f => f.defaultValue);\n\n            const associatedTenants = this.securityPrincipal.getTargetTenantIds();\n            const isMatch = (associatedTenants) ? tenantIds.some(t => associatedTenants.includes(t)) : true;\n            if (!isMatch) {\n                this.toastr.error(\"Unauthorized Access\");\n                this.uniqueDataSetObject[datasetId] = [];\n                resolve();\n            } else {\n\n                let request_params = {\n                    datasetId: datasetId,\n                    // dbConfig: dataset.config.queryConfig.dbConfig,\n                    // databaseName: dataset.config.queryConfig.databaseName,\n                    filters: this.transformDataForMFilterForSQl(operator, dataset.config.queryConfig.mapedFilters),\n                    // templateQuery: dataset.config.queryConfig.templateQuery,\n                    // enrichments: dataset.config.queryConfig.enrichments\n                };\n                backendService.genericSqlQueryResponse(requestAp, request_params).subscribe({\n                    next: (data: any) => {\n                        const payload = data[\"Payload\"] || data;\n                        this.uniqueDataSetObject[datasetId] = payload;\n                        resolve();\n                    },\n                    error: (err: any) => {\n                        console.error('Error:', err);\n                        this.toastr.error(err.message)\n                        reject(err);\n                    }\n                });\n            }\n        });\n    }\n\n    private transformDataForMFilterForSQl(filterdata: any[], mapData: any[]) {\n        let result: any[] = [];\n        mapData.forEach(mapping => {\n            let resultObj: any = {\n                columnName: mapping.serverColumn,\n                dataType: mapping.dataType,\n                operator: mapping.operatorName,\n                value: mapping.defaultValue,\n                aliasColumnName: mapping.localColumn\n            };\n            if (mapping.serverColumn.includes('date') && typeof resultObj.value === 'string') {\n                if (mapping.formatter && mapping.formatter !== \"\") {\n                    resultObj.value = moment(resultObj.value, \"YYYY-MM-DD\").format(mapping.formatter);\n                } else {\n                    resultObj.value = moment(resultObj.value, \"YYYY-MM-DD\").format(this.environment.dataFormat);\n                }\n            }\n            const filter = filterdata.find(f => f.hasOwnProperty(mapping.localColumn));\n            if (filter) {\n                if (mapping.defaultValue === \"\") {\n                    const value = filter[mapping.localColumn];\n\n                    if (Array.isArray(value)) {\n                        resultObj.operator = \"in\";\n                        resultObj.value = value.join(\",\");\n                    } else {\n                        resultObj.value = value;\n                    }\n                    if (mapping.serverColumn.includes('date') && typeof resultObj.value === 'string') {\n                        resultObj.value = moment(resultObj.value, \"YYYY-MM-DD\").format(this.environment.dataFormat);\n                    }\n                }\n            } else if (mapping.defaultValue === \"\") {\n                return;\n            }\n            result.push(resultObj);\n        });\n\n        filterdata = filterdata.filter(obj => {\n            const key = Object.keys(obj)[0];\n            return key !== 'startDate' && key !== 'endDate';\n        });\n        filterdata.forEach(filter => {\n            const filterKey = Object.keys(filter)[0];\n            const existingMapping = mapData.find(mapping => mapping.localColumn === filterKey);\n\n            if (!existingMapping) {\n                let resultObj: any = {\n                    columnName: filterKey,\n                    dataType: \"string\",\n                    operator: \"eq\",\n                    value: filter[filterKey]\n                };\n\n                if (Array.isArray(filter[filterKey])) {\n                    resultObj.operator = \"in\";\n                    resultObj.value = filter[filterKey].join(\",\");\n                } else {\n                    resultObj.value = filter[filterKey];\n                }\n\n                if (filterKey == 'operator_key') {\n                    resultObj.operator = \"eq\";\n                }\n                result.push(resultObj);\n            }\n        });\n\n        return result;\n    }\n\n    getUniqueDataSetObject() {\n        return this.uniqueDataSetObject;\n    }\n}"]}

package/esm2020/lib/shared/user-access/user-access.component.mjs

@@ -0,0 +1,51 @@
+import { Component, Input, Output, EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../application-controller/common";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "devextreme-angular/ui/select-box";
+import * as i5 from "devextreme-angular/ui/tag-box";
+export class UserAccessComponent {
+    constructor(commonService) {
+        this.commonService = commonService;
+        this.userOptionContainer = [];
+        this.userOptionContainerChange = new EventEmitter();
+        this.menuType = ['user', 'role', 'group', 'tenant', 'service_account'];
+    }
+    ngOnInit() {
+        if (!this.userOptionContainer || this.userOptionContainer.length === 0) {
+            this.userOptionContainer = [
+                {
+                    entityName: 'user',
+                    entityValues: ['${USER}']
+                }
+            ];
+            this.emitChanges();
+        }
+    }
+    addNewUser() {
+        this.userOptionContainer.push({
+            entityName: 'user',
+            entityValues: ['${USER}']
+        });
+        this.emitChanges();
+    }
+    deleteUser(index) {
+        this.userOptionContainer.splice(index, 1);
+        this.emitChanges();
+    }
+    emitChanges() {
+        this.userOptionContainerChange.emit(this.userOptionContainer);
+    }
+}
+UserAccessComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: UserAccessComponent, deps: [{ token: i1.CommonService }], target: i0.ɵɵFactoryTarget.Component });
+UserAccessComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: UserAccessComponent, selector: "app-user-access", inputs: { userOptionContainer: "userOptionContainer" }, outputs: { userOptionContainerChange: "userOptionContainerChange" }, ngImport: i0, template: "<div class=\"p-4 w-full\">\n  <div class=\"m-3 p-4 bg-white border border-gray-200 rounded-lg shadow-md dark:bg-gray-800 dark:border-gray-700\">\n\n    <h6 class=\"mb-2 text-lg tracking-tight text-gray-900 dark:text-white border-b pb-3 flex items-center\">\n      User Information\n      <div class=\"ml-auto\">\n        <div class=\"{{ commonService?.btn_primary_md }}\" (click)=\"addNewUser()\">\n          Add Permission Entity\n        </div>\n      </div>\n    </h6>\n\n    <div class=\"w-full m-2\">\n      <ng-container *ngFor=\"let item of userOptionContainer; let i = index\">\n        <div class=\"flex flex-row\">\n\n          <!-- Accessible User Type -->\n          <div class=\"mx-2 w-1/4\">\n            <div class=\"text-md p-2 capitalize\">Entity Type</div>\n            <dx-select-box [items]=\"menuType\" [(ngModel)]=\"item.entityName\" (onValueChanged)=\"emitChanges()\">\n            </dx-select-box>\n          </div>\n\n          <!-- User -->\n          <div class=\"mx-2 w-1/4\">\n            <div class=\"text-md p-2 capitalize\">Entity Value</div>\n            <dx-tag-box [(ngModel)]=\"item.entityValues\" [acceptCustomValue]=\"true\" (onValueChanged)=\"emitChanges()\">\n            </dx-tag-box>\n          </div>\n\n          <!-- Delete -->\n          <div class=\"mx-2\">\n            <div class=\"text-md p-2 capitalize\"></div>\n            <div class=\"mt-4\">\n              <div class=\"{{ commonService?.btn_danger_md }}\" (click)=\"deleteUser(i)\">\n                Delete\n              </div>\n            </div>\n          </div>\n\n        </div>\n      </ng-container>\n    </div>\n  </div>\n</div>", dependencies: [{ kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i4.DxSelectBoxComponent, selector: "dx-select-box", inputs: ["acceptCustomValue", "accessKey", "activeStateEnabled", "buttons", "dataSource", "deferRendering", "disabled", "displayExpr", "displayValue", "dropDownButtonTemplate", "dropDownOptions", "elementAttr", "fieldTemplate", "focusStateEnabled", "grouped", "groupTemplate", "height", "hint", "hoverStateEnabled", "inputAttr", "isValid", "items", "itemTemplate", "label", "labelMode", "maxLength", "minSearchLength", "name", "noDataText", "opened", "openOnFieldClick", "placeholder", "readOnly", "rtlEnabled", "searchEnabled", "searchExpr", "searchMode", "searchTimeout", "selectedItem", "showClearButton", "showDataBeforeSearch", "showDropDownButton", "showSelectionControls", "spellcheck", "stylingMode", "tabIndex", "text", "useItemTextAsTitle", "validationError", "validationErrors", "validationMessageMode", "validationStatus", "value", "valueChangeEvent", "valueExpr", "visible", "width", "wrapItemText"], outputs: ["onChange", "onClosed", "onContentReady", "onCopy", "onCustomItemCreating", "onCut", "onDisposing", "onEnterKey", "onFocusIn", "onFocusOut", "onInitialized", "onInput", "onItemClick", "onKeyDown", "onKeyUp", "onOpened", "onOptionChanged", "onPaste", "onSelectionChanged", "onValueChanged", "acceptCustomValueChange", "accessKeyChange", "activeStateEnabledChange", "buttonsChange", "dataSourceChange", "deferRenderingChange", "disabledChange", "displayExprChange", "displayValueChange", "dropDownButtonTemplateChange", "dropDownOptionsChange", "elementAttrChange", "fieldTemplateChange", "focusStateEnabledChange", "groupedChange", "groupTemplateChange", "heightChange", "hintChange", "hoverStateEnabledChange", "inputAttrChange", "isValidChange", "itemsChange", "itemTemplateChange", "labelChange", "labelModeChange", "maxLengthChange", "minSearchLengthChange", "nameChange", "noDataTextChange", "openedChange", "openOnFieldClickChange", "placeholderChange", "readOnlyChange", "rtlEnabledChange", "searchEnabledChange", "searchExprChange", "searchModeChange", "searchTimeoutChange", "selectedItemChange", "showClearButtonChange", "showDataBeforeSearchChange", "showDropDownButtonChange", "showSelectionControlsChange", "spellcheckChange", "stylingModeChange", "tabIndexChange", "textChange", "useItemTextAsTitleChange", "validationErrorChange", "validationErrorsChange", "validationMessageModeChange", "validationStatusChange", "valueChange", "valueChangeEventChange", "valueExprChange", "visibleChange", "widthChange", "wrapItemTextChange", "onBlur"] }, { kind: "component", type: i5.DxTagBoxComponent, selector: "dx-tag-box", inputs: ["acceptCustomValue", "accessKey", "activeStateEnabled", "applyValueMode", "buttons", "dataSource", "deferRendering", "disabled", "displayExpr", "dropDownButtonTemplate", "dropDownOptions", "elementAttr", "fieldTemplate", "focusStateEnabled", "grouped", "groupTemplate", "height", "hideSelectedItems", "hint", "hoverStateEnabled", "inputAttr", "isValid", "items", "itemTemplate", "label", "labelMode", "maxDisplayedTags", "maxFilterQueryLength", "maxLength", "minSearchLength", "multiline", "name", "noDataText", "opened", "openOnFieldClick", "placeholder", "readOnly", "rtlEnabled", "searchEnabled", "searchExpr", "searchMode", "searchTimeout", "selectAllMode", "selectAllText", "selectedItems", "showClearButton", "showDataBeforeSearch", "showDropDownButton", "showMultiTagOnly", "showSelectionControls", "stylingMode", "tabIndex", "tagTemplate", "text", "useItemTextAsTitle", "validationError", "validationErrors", "validationMessageMode", "validationStatus", "value", "valueExpr", "visible", "width", "wrapItemText"], outputs: ["onChange", "onClosed", "onContentReady", "onCustomItemCreating", "onDisposing", "onEnterKey", "onFocusIn", "onFocusOut", "onInitialized", "onInput", "onItemClick", "onKeyDown", "onKeyUp", "onMultiTagPreparing", "onOpened", "onOptionChanged", "onSelectAllValueChanged", "onSelectionChanged", "onValueChanged", "acceptCustomValueChange", "accessKeyChange", "activeStateEnabledChange", "applyValueModeChange", "buttonsChange", "dataSourceChange", "deferRenderingChange", "disabledChange", "displayExprChange", "dropDownButtonTemplateChange", "dropDownOptionsChange", "elementAttrChange", "fieldTemplateChange", "focusStateEnabledChange", "groupedChange", "groupTemplateChange", "heightChange", "hideSelectedItemsChange", "hintChange", "hoverStateEnabledChange", "inputAttrChange", "isValidChange", "itemsChange", "itemTemplateChange", "labelChange", "labelModeChange", "maxDisplayedTagsChange", "maxFilterQueryLengthChange", "maxLengthChange", "minSearchLengthChange", "multilineChange", "nameChange", "noDataTextChange", "openedChange", "openOnFieldClickChange", "placeholderChange", "readOnlyChange", "rtlEnabledChange", "searchEnabledChange", "searchExprChange", "searchModeChange", "searchTimeoutChange", "selectAllModeChange", "selectAllTextChange", "selectedItemsChange", "showClearButtonChange", "showDataBeforeSearchChange", "showDropDownButtonChange", "showMultiTagOnlyChange", "showSelectionControlsChange", "stylingModeChange", "tabIndexChange", "tagTemplateChange", "textChange", "useItemTextAsTitleChange", "validationErrorChange", "validationErrorsChange", "validationMessageModeChange", "validationStatusChange", "valueChange", "valueExprChange", "visibleChange", "widthChange", "wrapItemTextChange", "onBlur"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: UserAccessComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-user-access', template: "<div class=\"p-4 w-full\">\n  <div class=\"m-3 p-4 bg-white border border-gray-200 rounded-lg shadow-md dark:bg-gray-800 dark:border-gray-700\">\n\n    <h6 class=\"mb-2 text-lg tracking-tight text-gray-900 dark:text-white border-b pb-3 flex items-center\">\n      User Information\n      <div class=\"ml-auto\">\n        <div class=\"{{ commonService?.btn_primary_md }}\" (click)=\"addNewUser()\">\n          Add Permission Entity\n        </div>\n      </div>\n    </h6>\n\n    <div class=\"w-full m-2\">\n      <ng-container *ngFor=\"let item of userOptionContainer; let i = index\">\n        <div class=\"flex flex-row\">\n\n          <!-- Accessible User Type -->\n          <div class=\"mx-2 w-1/4\">\n            <div class=\"text-md p-2 capitalize\">Entity Type</div>\n            <dx-select-box [items]=\"menuType\" [(ngModel)]=\"item.entityName\" (onValueChanged)=\"emitChanges()\">\n            </dx-select-box>\n          </div>\n\n          <!-- User -->\n          <div class=\"mx-2 w-1/4\">\n            <div class=\"text-md p-2 capitalize\">Entity Value</div>\n            <dx-tag-box [(ngModel)]=\"item.entityValues\" [acceptCustomValue]=\"true\" (onValueChanged)=\"emitChanges()\">\n            </dx-tag-box>\n          </div>\n\n          <!-- Delete -->\n          <div class=\"mx-2\">\n            <div class=\"text-md p-2 capitalize\"></div>\n            <div class=\"mt-4\">\n              <div class=\"{{ commonService?.btn_danger_md }}\" (click)=\"deleteUser(i)\">\n                Delete\n              </div>\n            </div>\n          </div>\n\n        </div>\n      </ng-container>\n    </div>\n  </div>\n</div>" }]
+        }], ctorParameters: function () { return [{ type: i1.CommonService }]; }, propDecorators: { userOptionContainer: [{
+                type: Input
+            }], userOptionContainerChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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