gamma-app-controller 1.1.25 → 1.1.27

package/esm2020/lib/template-module/kpiWithMultiLayout/kpi-with-multilayout.component.mjs

@@ -0,0 +1,992 @@
+import { Component, ViewChild, ViewContainerRef } from '@angular/core';
+import { forkJoin } from 'rxjs';
+import moment from '../../application-controller/moment-helper';
+import { GammaAdvanceChartComponent } from '../../shared/advanced-component/gamma-advance-chart/gamma-advance-chart.component';
+import { GammaTodayPreviousComponent } from '../../shared/advanced-component/gamma-today-previous/gamma-today-previous.component';
+import { AppAdvanceHeaderComponent } from '../../shared/advanced-component/app-advance-header/app-header.component';
+import { GammaTableWithPercentageComponent } from '../../shared/advanced-component/gamma-table-with-percentage/gamma-table-with-percentage.component';
+import { GammSingleNumberCardComponent } from '../../shared/advanced-component/gamm-single-number-card/gamm-single-number-card.component';
+import { GammaAdvanceOperatorTableComponent } from '../../shared/advanced-component/gamma-advance-operator-table/gamma-advance-operator-table.component';
+import { AdvanceWidgetHeaderFilterComponent } from '../../shared/advanced-component/advance-widget-header-filter/advance-widget-header-filter.component';
+import { GammaGeoChartComponent } from '../../shared/advanced-component/gamma-geo-chart/gamma-geo-chart.component';
+import { GammaHeatChartComponent } from '../../shared/advanced-component/gamma-heatmap/gamma-heatmap.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../application-controller/common";
+import * as i2 from "@angular/router";
+import * as i3 from "../../application-controller/application-content.service";
+import * as i4 from "ngx-toastr";
+import * as i5 from "../../application-controller/application-dataset-call.service";
+import * as i6 from "@angular/common";
+import * as i7 from "../../shared/loading/loading.component";
+import * as i8 from "devextreme-angular/core";
+import * as i9 from "devextreme-angular/ui/popup";
+import * as i10 from "devextreme-angular/ui/scroll-view";
+import * as i11 from "devextreme-angular/ui/select-box";
+import * as i12 from "devextreme-angular/ui/text-box";
+import * as i13 from "@angular/forms";
+export class KpiWithMultilayoutSetTestComponent {
+    constructor(commonService, activatedRoute, viewContainerRef, componentFactoryResolver, service, toastr, router, datasetService) {
+        this.commonService = commonService;
+        this.activatedRoute = activatedRoute;
+        this.viewContainerRef = viewContainerRef;
+        this.componentFactoryResolver = componentFactoryResolver;
+        this.service = service;
+        this.toastr = toastr;
+        this.router = router;
+        this.datasetService = datasetService;
+        this.dashbord_container = [];
+        this.widget_width = ['w-full', 'w-1/2', 'w-1/3', 'w-1/4', 'w-1/5', 'w-1/6'];
+        this.page_title = 'Dashboard';
+        this.dynamicComponentRefs = [];
+        this.componentClassMap = {
+            GammaAdvanceChartComponent,
+            GammaTodayPreviousComponent,
+            AppAdvanceHeaderComponent,
+            GammaTableWithPercentageComponent,
+            GammSingleNumberCardComponent,
+            GammaAdvanceOperatorTableComponent,
+            AdvanceWidgetHeaderFilterComponent,
+            GammaGeoChartComponent,
+            GammaHeatChartComponent
+        };
+        this.dataSourceMataData = [];
+        this.queryType = "mongo";
+        this.dataSetModal = [];
+        this.componentConfigDataSource = [];
+        this.dataSourceModal = {};
+        this.isDashBoardContent = false;
+        this.selectedViewFormComponent = {};
+        this.addedwidGetConfig = {
+            "display": true,
+            "widgetTitle": "",
+            "width": "",
+            "height": ""
+        };
+        this.dashBoardWidgetConfig = [];
+        this.selectedIndexObjForChart = {};
+        this.selectedContainerObjectForChart = {};
+        this.uniqueDataSetObject = {};
+        this.isDashBoardContentTypeView = true;
+        this.allWidgetByDataset = [];
+        this.stateDataSource = new Map();
+        this.mainPageDivElement = new Map();
+        this.contextMenuDataSource = [];
+        this.havingDataObject = {};
+        this.globalDefaultFilter = {};
+    }
+    ngOnInit() {
+        this.service.getlistKpiBrowser().subscribe({
+            next: ((data) => {
+                this.kpi_breadcrumbs_container = data;
+            })
+        });
+        this.loadingModal = true;
+        this.pageId = this.activatedRoute.snapshot.queryParams['pageId'];
+        this.getPadeDataSource(false);
+    }
+    async getFiltersForTemplate(filter) {
+        this.filters = filter;
+        this.defaultStartDate = filter.startDate;
+        this.defaultEndDate = filter.endDate;
+        filter.operationFilter['startDate'] = filter.startDate;
+        filter.operationFilter['endDate'] = filter.endDate;
+        this.loadingModal = true;
+        this.dashBoardWidgetConfig = [];
+        await this.getPadeDataSource(true);
+        this.uniqueDataSetObject = {};
+        let apiCalls = [];
+        this.allWidgetByDataset.forEach(view => {
+            view.datasetIds.forEach(id => {
+                let found = this.dataSetModal.find(d => d.datasetId === id);
+                if (found) {
+                    apiCalls.push(this.datasetService.getDataFromDataSet(found, id, filter));
+                }
+            });
+        });
+        Promise.all(apiCalls).then(() => {
+            this.globalDefaultFilter = filter;
+            this.uniqueDataSetObject = this.datasetService.getUniqueDataSetObject();
+            this.createDivElements(this.uniqueDataSetObject, true);
+            this.loadingModal = false;
+        });
+    }
+    getPadeDataSource(context) {
+        return new Promise((resolve, reject) => {
+            this.service.getAppPageDetailConfig(this.pageId).subscribe({
+                next: (data) => {
+                    this.pageTitle = data.pageName;
+                    this.dashBoardWidgetConfig = data;
+                    if (!context) {
+                        if (Object.keys(this.uniqueDataSetObject).length != 0) {
+                            this.createDivElements(this.uniqueDataSetObject, false);
+                        }
+                        this.getComponentConfigSet();
+                    }
+                    resolve();
+                },
+                error: (err) => {
+                    this.toastr.error('Unexpected Server Exception. Please contact System Admin.', 'Error');
+                    reject(err);
+                }
+            });
+        });
+    }
+    getComponentConfigSet() {
+        let dataset = this.service.getAppDatasetConfigs();
+        let viewComponent = this.service.getAppViewConfigs();
+        forkJoin({
+            datasetConfig: dataset,
+            viewConfig: viewComponent
+        }).subscribe({
+            next: (({ datasetConfig, viewConfig }) => {
+                this.componentConfigDataSource = viewConfig;
+                this.dataSetModal = datasetConfig;
+                this.allWidgetByDataset = [];
+                let defaultFilters = { operationFilter: { startDate: "", endDate: "" } };
+                this.dashBoardWidgetConfig.widgets.forEach(widget => {
+                    widget.filters.filterItems.forEach(element => {
+                        if (element.filterType === 'date' || element.filterType === 'datetime') {
+                            if (element.defaultFilterType === "dynamic" && element.momentFunction !== "" && element.defaultFilterValue !== "" && element.momentFormat !== "") {
+                                let [count, unit] = element.defaultFilterValue.split(',');
+                                if (element.apiName === "endDate") {
+                                    if (element.display) {
+                                        defaultFilters.operationFilter.endDate = moment()[element.momentFunction](parseInt(count), unit).format(element.momentFormat);
+                                        this.defaultEndDate = moment()[element.momentFunction](parseInt(count), unit).format(element.momentFormat);
+                                    }
+                                }
+                                if (element.apiName === "startDate") {
+                                    defaultFilters.operationFilter.startDate = moment()[element.momentFunction](parseInt(count), unit).format(element.momentFormat);
+                                    this.defaultStartDate = moment()[element.momentFunction](parseInt(count), unit).format(element.momentFormat);
+                                }
+                            }
+                            else if (element.defaultFilterType === "static" && element.defaultFilterValue !== "") {
+                                if (element.apiName === "endDate") {
+                                    if (element.display) {
+                                        defaultFilters.operationFilter.endDate = element.defaultFilterValue;
+                                        this.defaultEndDate = element.defaultFilterValue;
+                                    }
+                                }
+                                if (element.apiName === "startDate") {
+                                    defaultFilters.operationFilter.startDate = element.defaultFilterValue;
+                                    this.defaultStartDate = element.defaultFilterValue;
+                                }
+                            }
+                        }
+                        else {
+                            if ((typeof element.filterDataSourceValue === "string" && element.filterDataSourceValue !== "") ||
+                                (Array.isArray(element.filterDataSourceValue) && element.filterDataSourceValue.length > 0)) {
+                                if (element.operatorName !== "") {
+                                    defaultFilters.operationFilter[element.operatorName] = Array.isArray(element.filterDataSourceValue)
+                                        ? element.filterDataSourceValue
+                                        : [element.filterDataSourceValue];
+                                }
+                                else {
+                                    defaultFilters.operationFilter[element.apiName] = element.filterDataSourceValue.join(",");
+                                }
+                            }
+                        }
+                    });
+                    let datasetIds = new Set();
+                    let viewIds = new Set();
+                    widget.widgetNode.forEach(node => {
+                        if (node.nodeProperties.display) {
+                            node.compConfig.viewConfig.forEach(view => {
+                                datasetIds.add(view.datasetId);
+                                viewIds.add(view.viewId);
+                            });
+                        }
+                        else {
+                            node.compConfig.viewConfig.forEach(view => {
+                                this.contextMenuDataSource.push({ viewId: view.viewId, viewName: node.nodeProperties.widgetTitle, displayKey: view.kpiConfig.keyToPass });
+                            });
+                        }
+                    });
+                    viewIds.forEach(element => {
+                        let obj = {
+                            "filters": JSON.parse(JSON.stringify(defaultFilters)),
+                            "keyToPass": [],
+                            "drillDownType": "natural",
+                            "drilldownFrom": "",
+                            "widgetId": widget.widgetId
+                        };
+                        this.stateDataSource.set(element, obj);
+                    });
+                    let obj = {
+                        widgetId: widget.widgetId,
+                        pageId: widget.pageId,
+                        filters: defaultFilters,
+                        datasetIds: datasetIds
+                    };
+                    this.allWidgetByDataset.push(obj);
+                });
+                console.log(this.stateDataSource);
+                this.uniqueDataSetObject = {};
+                let apiCalls = [];
+                this.allWidgetByDataset.forEach(view => {
+                    view.datasetIds.forEach(id => {
+                        let found = datasetConfig.find(d => d.datasetId === id);
+                        if (found) {
+                            apiCalls.push(this.datasetService.getDataFromDataSet(found, id, view.filters));
+                        }
+                    });
+                });
+                Promise.all(apiCalls).then(() => {
+                    this.uniqueDataSetObject = this.datasetService.getUniqueDataSetObject();
+                    this.createDivElements(this.uniqueDataSetObject, false);
+                    this.loadingModal = false;
+                    let urlParams = defaultFilters.operationFilter;
+                    urlParams['pageId'] = this.pageId;
+                    let navigation = {
+                        queryParams: urlParams,
+                        queryParamsHandling: "merge"
+                    };
+                    this.router.navigate([], navigation);
+                });
+            }), error: (err) => {
+                this.toastr.error('Unexpected Server Exception. Please contact System Admin.', 'Error');
+            }
+        });
+    }
+    getDataSet() {
+        this.service.getAppDatasetConfigs().subscribe({
+            next: (data) => {
+                this.dataSettableDataSource = data;
+            }, error: (err) => {
+                this.toastr.error('Unexpected Server Exception. Please contact System Admin.', 'Dataset Creation');
+            }
+        });
+    }
+    async createDivElements(datasetById, context) {
+        const container = this.dynamicContainer.nativeElement;
+        container.innerHTML = "";
+        if (this.dashBoardWidgetConfig.widgets.length > 0) {
+            const firstWidget = this.dashBoardWidgetConfig.widgets[0];
+            const rowDiv = document.createElement('div');
+            let w_height = (firstWidget.widgetProperties.height == "") ? "h-auto" : 'h-[' + firstWidget.widgetProperties.height + ']';
+            rowDiv.classList.add(firstWidget.widgetProperties.width, w_height);
+            const filterDiv = document.createElement('div');
+            const filterItems = (firstWidget.filters) ? firstWidget.filters.filterItems : [];
+            const context_filter = this.dashBoardWidgetConfig.filters ? this.dashBoardWidgetConfig.filters.filterItems : null;
+            this.loadFilterComponent(firstWidget, filterDiv, filterItems, context_filter);
+            rowDiv.appendChild(filterDiv);
+            container.appendChild(rowDiv);
+            const mainWrapperDiv = document.createElement('div');
+            mainWrapperDiv.classList.add("flex", "flex-row", "justify-between", "w-full");
+            this.dashBoardWidgetConfig.widgets.forEach(div => {
+                const childDiv = document.createElement('div');
+                childDiv.classList.add("w-full");
+                if (div.widgetNode.length != 0) {
+                    this.loadWidgetNodes(div, childDiv, datasetById);
+                }
+                mainWrapperDiv.appendChild(childDiv);
+            });
+            container.appendChild(mainWrapperDiv);
+        }
+    }
+    loadWidgetNodes(div, mainItemDiv, datasetById) {
+        this.mainPageDivElement.set(div.widgetId, mainItemDiv);
+        div.widgetNode.forEach(item => {
+            this.loadSingleWidgetNode(item, mainItemDiv, datasetById, null);
+        });
+    }
+    loadSingleWidgetNode(item, containerElement, datasetById, widgetId) {
+        const elementId = `id-${item.id}`;
+        const existingElement = document.querySelector(`#${elementId}`);
+        if (item.nodeProperties.display && !existingElement) {
+            const w_height = item.nodeProperties.height === "" ? "h-auto" : `h-[${item.nodeProperties.height}]`;
+            const itemDiv = document.createElement('div');
+            itemDiv.id = elementId;
+            itemDiv.classList.add(item.nodeProperties.width, w_height, 'mb-2');
+            const widgetDiv = this.getWidgetTitleDiv(item);
+            itemDiv.appendChild(widgetDiv);
+            const innerDiv = document.createElement('div');
+            innerDiv.classList.add('rounded', 'justify-center', 'items-center', 'border', 'p-1', 'm-1', 'flex', 'flex-row');
+            item.compConfig.viewConfig.forEach(element => {
+                element.kpiConfig['dataSource'] = datasetById[element.datasetId];
+                element.kpiConfig['contextMenu'] = this.contextMenuDataSource;
+                element['titleParams'] = item.nodeProperties.widgetParams || "";
+                const comp_object = this.findWidgetById(this.dashBoardWidgetConfig.widgets, item.id);
+                this.loadDynamicComponent(element, comp_object, itemDiv);
+            });
+            if (widgetId) {
+                let childelementContainer = containerElement.get(widgetId);
+                childelementContainer.appendChild(itemDiv);
+                if (!this.isDashBoardContentTypeView) {
+                    itemDiv.appendChild(innerDiv);
+                }
+                console.log(childelementContainer);
+            }
+            else {
+                containerElement.appendChild(itemDiv);
+                if (!this.isDashBoardContentTypeView) {
+                    itemDiv.appendChild(innerDiv);
+                }
+            }
+        }
+        else if (existingElement) {
+            const itemDiv = existingElement;
+            itemDiv.innerHTML = '';
+            const widgetDiv = this.getWidgetTitleDiv(item);
+            itemDiv.appendChild(widgetDiv);
+            item.compConfig.viewConfig.forEach(element => {
+                element.kpiConfig['dataSource'] = datasetById[element.datasetId];
+                element.kpiConfig['contextMenu'] = this.contextMenuDataSource;
+                element['titleParams'] = item.nodeProperties.widgetParams || "";
+                const comp_object = this.findWidgetById(this.dashBoardWidgetConfig.widgets, item.id);
+                this.loadDynamicComponent(element, comp_object, itemDiv);
+            });
+            if (!this.isDashBoardContentTypeView) {
+                const innerDiv = document.createElement('div');
+                innerDiv.classList.add('rounded', 'justify-center', 'items-center', 'border', 'p-1', 'm-1', 'flex', 'flex-row');
+                itemDiv.appendChild(innerDiv);
+            }
+        }
+    }
+    getWidgetTitleDiv(item) {
+        const widgetDiv = document.createElement('div');
+        widgetDiv.classList.add('flex', 'items-center', 'justify-between', 'font-bold', 'text-md', 'text-gray-900', 'dark:text-white', 'border-b', 'p-3', 'bg-gray-800', 'mx-2', 'rounded-t-lg');
+        const titleDiv = document.createElement('div');
+        const params = item.nodeProperties.widgetParams || "";
+        titleDiv.innerText = item.nodeProperties.widgetTitle + params;
+        widgetDiv.appendChild(titleDiv);
+        const searchContainerDiv = document.createElement('div');
+        searchContainerDiv.classList.add('flex', 'items-center', 'ml-auto', 'space-x-2', 'justify-end');
+        if (item.nodeProperties.isWidgetFilter) {
+            const searchButton = document.createElement('button');
+            searchButton.innerText = 'Filter';
+            searchButton.classList.add('px-3', 'py-1.5', 'bg-blue-600', 'mr-2', 'text-white', 'rounded', 'hover:bg-blue-700');
+            this.nodeproperticeFilterDataSource = {};
+            this.nodeproperticeFilterDataSource['viewConfig'] = item;
+            this.nodeproperticeFilterDataSource['havingConfig'] = [];
+            searchButton.addEventListener('click', () => {
+                this.isWidgetFilters = true;
+                let filtePropertice = [];
+                item.compConfig.viewConfig.forEach(element => {
+                    let key_name = this.uniqueDataSetObject[element.datasetId][0];
+                    Object.keys(key_name).forEach(key => {
+                        if (!filtePropertice.includes(key)) {
+                            filtePropertice.push(key);
+                        }
+                    });
+                });
+                filtePropertice.forEach(element => {
+                    let obj = {
+                        columnName: element,
+                        dataType: "float",
+                        operator: "",
+                        value: "",
+                    };
+                    this.nodeproperticeFilterDataSource.havingConfig.push(obj);
+                });
+            });
+            searchContainerDiv.appendChild(searchButton);
+        }
+        if (item.filterId) {
+            this.nodeproperticeFilterDataSource = {};
+            this.nodeproperticeFilterDataSource['viewConfig'] = item;
+            this.nodeproperticeFilterDataSource['havingConfig'] = [];
+            this.service.getAppFilterConfig(item.filterId).subscribe({
+                next: (data) => {
+                    const filterDiv = document.createElement('div');
+                    this.loadWidgetFilterComponent(item, widgetDiv, data.filterItems, item);
+                }, error: (err) => {
+                }
+            });
+        }
+        if (item.nodeProperties.nodefilters && item.nodeProperties.nodefilters.length !== 0) {
+            item.nodeProperties.nodefilters.forEach(filter => {
+                const filterDiv = document.createElement('div');
+                filterDiv.classList.add('flex', 'items-center');
+                if (filter.input_type === 'text') {
+                    const textBox = document.createElement('input');
+                    textBox.type = 'text';
+                    textBox.placeholder = `Enter ${filter.local_column}`;
+                    textBox.classList.add('px-2', 'py-1.5', 'rounded', 'border', 'mr-1', 'border-gray-500', 'text-gray-900', 'dark:bg-gray-700', 'dark:text-white');
+                    const searchButton = document.createElement('button');
+                    searchButton.innerText = 'Search';
+                    searchButton.classList.add('px-3', 'py-1.5', 'bg-blue-600', 'mr-2', 'text-white', 'rounded', 'hover:bg-blue-700');
+                    const separerotButton = document.createElement('div');
+                    separerotButton.innerHTML = '|';
+                    searchButton.addEventListener('click', () => {
+                        const searchTerm = textBox.value;
+                        this.getRearchResultFromInputBox(searchTerm, item, filter);
+                    });
+                    filterDiv.appendChild(textBox);
+                    filterDiv.appendChild(searchButton);
+                    filterDiv.appendChild(separerotButton);
+                }
+                searchContainerDiv.appendChild(filterDiv);
+            });
+        }
+        widgetDiv.appendChild(searchContainerDiv);
+        return widgetDiv;
+    }
+    loadDynamicComponent(data, indexObj, containerElement) {
+        const componentClass = this.componentClassMap[data.kpiConfig.componentName];
+        this.CompRefs = this.viewContainerRef.createComponent(componentClass);
+        const dynamicComponentInstance = this.CompRefs.instance;
+        dynamicComponentInstance.chartDataSource = data;
+        dynamicComponentInstance.kpi_name = "";
+        if (data.kpiConfig.componentName == "GammaAdvanceOperatorTableComponent" || data.kpiConfig.componentName == "GammaTableWithPercentageComponent") {
+            dynamicComponentInstance.oRowClick.subscribe((value) => {
+                this.getRowClick(value);
+            });
+            dynamicComponentInstance.onrightClickContextSelection.subscribe((value) => {
+                this.getContextClick(value);
+            });
+        }
+        const cssClass = "w-full";
+        this.CompRefs.location.nativeElement.classList.add(cssClass);
+        containerElement.appendChild(this.CompRefs.location.nativeElement);
+    }
+    loadFilterComponent(indexObj, containerElement, filterItems, context_filter) {
+        let userName = localStorage.getItem('user_name');
+        let selectedDates = { startDate: this.defaultStartDate, endDate: this.defaultEndDate };
+        const componentClass = this.componentClassMap['AppAdvanceHeaderComponent'];
+        this.CompRefs = this.viewContainerRef.createComponent(componentClass);
+        const dynamicComponentInstance = this.CompRefs.instance;
+        dynamicComponentInstance.selectedDates = selectedDates;
+        dynamicComponentInstance.filterItems = filterItems;
+        dynamicComponentInstance.contextFilterItems = context_filter;
+        dynamicComponentInstance.pageTitle = this.pageTitle;
+        dynamicComponentInstance.bread_crumbs_container = this.kpi_breadcrumbs_container;
+        dynamicComponentInstance.isEditButton = (userName && userName == "admin") ? true : false;
+        dynamicComponentInstance.isAdvanceButton = true;
+        dynamicComponentInstance.getFilterPageConfig.subscribe((value) => {
+            this.getFiltersForTemplate(value);
+        });
+        dynamicComponentInstance.getOperatorName.subscribe((value) => {
+            this.loadDataByOperator(value);
+        });
+        dynamicComponentInstance.getContextFilterData.subscribe((value) => {
+            this.getContextFilterData(value);
+        });
+        indexObj.compConfig.dynamicComponentRefs.push(this.CompRefs);
+        const cssClass = "w-full";
+        this.CompRefs.location.nativeElement.classList.add(cssClass);
+        containerElement.appendChild(this.CompRefs.location.nativeElement);
+    }
+    loadWidgetFilterComponent(indexObj, containerElement, filterItems, viewIds) {
+        let userName = localStorage.getItem('user_name');
+        let selectedDates = { startDate: this.defaultStartDate, endDate: this.defaultEndDate };
+        const componentClass = this.componentClassMap['AdvanceWidgetHeaderFilterComponent'];
+        this.CompRefs = this.viewContainerRef.createComponent(componentClass);
+        const dynamicComponentInstance = this.CompRefs.instance;
+        dynamicComponentInstance.selectedDates = selectedDates;
+        dynamicComponentInstance.filterItems = filterItems;
+        dynamicComponentInstance.viewIds = viewIds;
+        dynamicComponentInstance.getWidgetFilterConfig.subscribe((value) => {
+            this.getWidgetFilterForTemplate(value);
+        });
+        indexObj.compConfig.dynamicComponentRefs.push(this.CompRefs);
+        containerElement.appendChild(this.CompRefs.location.nativeElement);
+    }
+    getContextClick(event) {
+        const stateData = Array.from(this.stateDataSource.keys());
+        const currentViewIndex = stateData.indexOf(event.viewId);
+        const deletedViewIds = [];
+        for (let i = currentViewIndex + 1; i < stateData.length; i++) {
+            deletedViewIds.push(stateData[i]);
+        }
+        this.loadingModal = true;
+        this.dashBoardWidgetConfig.widgets.forEach(element => {
+            element.widgetNode.forEach((node, nodeIndex) => {
+                if (this.getElementOfCurrentView(node, event.drilldownTo)) {
+                    let view = element.widgetNode[nodeIndex];
+                    let apiCalls = [];
+                    let appliedFilters = this.getSetOperatorFilter(event, this.stateDataSource.get(event.drilldownFrom));
+                    view.compConfig.viewConfig.forEach(contentView => {
+                        let found = this.dataSetModal.find(d => d.datasetId === contentView.datasetId);
+                        if (found) {
+                            apiCalls.push(this.datasetService.getDataFromDataSet(found, contentView.datasetId, appliedFilters));
+                        }
+                    });
+                    Promise.all(apiCalls).then(() => {
+                        this.uniqueDataSetObject = this.datasetService.getUniqueDataSetObject();
+                        for (let entry of deletedViewIds) {
+                            element.widgetNode.forEach(viewValue => {
+                                viewValue.compConfig.viewConfig.forEach(viewId => {
+                                    if (viewId.viewId == entry) {
+                                        const exists = this.contextMenuDataSource.some(item => item.viewId === viewId.viewId);
+                                        if (!exists) {
+                                            this.contextMenuDataSource.push({
+                                                viewId: viewId.viewId,
+                                                viewName: node.nodeProperties.widgetTitle,
+                                                displayKey: viewId.kpiConfig.keyToPass
+                                            });
+                                        }
+                                        const startData = this.stateDataSource.get(entry);
+                                        if (startData) {
+                                            this.stateDataSource.delete(entry);
+                                        }
+                                        viewValue.nodeProperties['display'] = false;
+                                        const prefixedId = `id-${viewValue.id}`;
+                                        const elementToHide = document.querySelector(`#${prefixedId}`);
+                                        if (elementToHide) {
+                                            elementToHide.remove();
+                                        }
+                                    }
+                                });
+                            });
+                        }
+                        this.contextMenuDataSource = this.contextMenuDataSource.filter(e => e.displayKey !== event.keyToPass);
+                        view.compConfig.viewConfig.forEach(val => {
+                            let obj = {
+                                "filters": appliedFilters,
+                                "keyToPass": this.updateOperatorData(event.keyToPass, event.data),
+                                "drillDownType": event.drillDownType,
+                                "drilldownFrom": event.drilldownFrom,
+                                "widgetId": element.widgetId
+                            };
+                            this.stateDataSource.set(val['viewId'], obj);
+                        });
+                        view.nodeProperties['display'] = true;
+                        view.nodeProperties['widgetParams'] = event.tableTitle;
+                        const prefixedId = `id-${view.id}`;
+                        const containerElement = document.querySelector(`#${prefixedId}`);
+                        this.loadSingleWidgetNode(view, this.mainPageDivElement, this.uniqueDataSetObject, element.widgetId);
+                        setTimeout(() => {
+                            this.scrollToBottom(this.mainPageDivElement, element.widgetId);
+                        }, 200);
+                        let navigation = {
+                            queryParams: appliedFilters['operationFilter'],
+                            queryParamsHandling: "merge"
+                        };
+                        this.router.navigate([], navigation);
+                    });
+                }
+                else {
+                }
+            });
+        });
+    }
+    async getRowClick(event) {
+        const viewid_for_same = event.viewId;
+        const target = this.stateDataSource.get(viewid_for_same);
+        if (!target) {
+            console.warn('viewid not found in stateDataSource');
+            return;
+        }
+        const targetWidgetId = target.widgetId;
+        const matchingViewIds = Array.from(this.stateDataSource.entries())
+            .filter(([key, value]) => value.widgetId === targetWidgetId)
+            .map(([key]) => key);
+        console.log('Matching viewids:', targetWidgetId);
+        const currentViewIndex = matchingViewIds.indexOf(event.viewId);
+        const deletedViewIds = [];
+        for (let i = currentViewIndex + 1; i < matchingViewIds.length; i++) {
+            deletedViewIds.push(matchingViewIds[i]);
+        }
+        const hourlyNode = this.dashBoardWidgetConfig.widgets
+            .map(widget => widget.widgetNode.find(node => this.getHourlyData(node)))
+            .find(node => node);
+        if (hourlyNode && event.keyToPass.includes("recordDate")) {
+            this.getViewByRowCLickForHourlyChart(event, hourlyNode);
+        }
+        const currentViewNode = this.dashBoardWidgetConfig.widgets
+            .map(widget => widget.widgetNode.find(node => this.getElementOfCurrentView(node, event.viewId)))
+            .find(node => node);
+        const queryParams = this.activatedRoute.snapshot.queryParamMap;
+        if (currentViewNode) {
+            const drildownsForCurrentView = [];
+            currentViewNode.compConfig.viewConfig.forEach(async (element) => {
+                if (element.kpiConfig.viewProperties.enableClickEvent) {
+                    if (deletedViewIds && deletedViewIds.length !== 0) {
+                        this.dashBoardWidgetConfig.widgets.forEach(element => {
+                            for (let entry of deletedViewIds) {
+                                element.widgetNode.forEach(viewValue => {
+                                    viewValue.compConfig.viewConfig.forEach(viewId => {
+                                        if (viewId.viewId == entry) {
+                                            const exists = this.contextMenuDataSource.some(item => item.viewId === viewId.viewId);
+                                            if (!exists) {
+                                                this.contextMenuDataSource.push({
+                                                    viewId: viewId.viewId,
+                                                    viewName: currentViewNode.nodeProperties.widgetTitle,
+                                                    displayKey: viewId.kpiConfig.keyToPass
+                                                });
+                                            }
+                                            const startData = this.stateDataSource.get(entry);
+                                            if (startData) {
+                                                this.stateDataSource.delete(entry);
+                                            }
+                                            viewValue.nodeProperties['display'] = false;
+                                            const prefixedId = `id-${viewValue.id}`;
+                                            const elementToHide = document.querySelector(`#${prefixedId}`);
+                                            if (elementToHide) {
+                                                elementToHide.remove();
+                                            }
+                                        }
+                                    });
+                                });
+                            }
+                        });
+                    }
+                    if (element.kpiConfig.viewProperties.enableClickEvent) {
+                        if (element.kpiConfig.viewProperties.clickEventOptions?.eventType !== undefined &&
+                            element.kpiConfig.viewProperties.clickEventOptions.eventType !== "") {
+                            let eventType = element.kpiConfig.viewProperties.clickEventOptions.eventType;
+                            let associatedViews = element.kpiConfig.viewProperties.clickEventOptions.associatedViews;
+                            if (eventType == 'optionalDrillDown') {
+                                if (associatedViews && associatedViews.length != 0) {
+                                    for (let viewForDrillDown of associatedViews) {
+                                        const filterCondition = new URLSearchParams(viewForDrillDown['filterCondition']);
+                                        let matchFound = true;
+                                        filterCondition.forEach((value, key) => {
+                                            if (queryParams.get(key) !== value) {
+                                                matchFound = false;
+                                            }
+                                        });
+                                        if (matchFound) {
+                                            viewForDrillDown['viewId'].forEach(viewForId => {
+                                                drildownsForCurrentView.push(viewForId);
+                                            });
+                                        }
+                                    }
+                                }
+                            }
+                            else if (eventType == 'drilldown') {
+                                for (let entry of associatedViews) {
+                                    drildownsForCurrentView.push(entry);
+                                }
+                            }
+                            else if (eventType == 'sameViewDrilldown') {
+                            }
+                            if (drildownsForCurrentView.length != 0) {
+                                for (let viewIdForNext of drildownsForCurrentView) {
+                                    const nextViewNode = this.dashBoardWidgetConfig.widgets
+                                        .map(widget => widget.widgetNode.find(node => this.getElementOfCurrentView(node, viewIdForNext)))
+                                        .find(node => node);
+                                    this.loadingModal = true;
+                                    await this.getViewByRowCLick(event, nextViewNode, targetWidgetId);
+                                }
+                            }
+                        }
+                        else {
+                            const nextViewIndex = matchingViewIds.indexOf(event.viewId) + 1;
+                            const matchingWidget = this.dashBoardWidgetConfig.widgets
+                                .find(widget => widget.widgetId === targetWidgetId);
+                            const nextView = matchingWidget?.widgetNode?.[nextViewIndex];
+                            if (nextView) {
+                                this.loadingModal = true;
+                                await this.getViewByRowCLick(event, nextView, targetWidgetId);
+                            }
+                        }
+                    }
+                }
+            });
+        }
+    }
+    getViewByRowCLickForHourlyChart(event, node) {
+        let apiCalls = [];
+        const deletedViewIds = [];
+        node.compConfig.viewConfig.forEach(item => {
+            let appliedFilters = this.getSetOperatorFilter(event, this.stateDataSource.get(item.viewId));
+            let found = this.dataSetModal.find(d => d.datasetId === item.datasetId);
+            deletedViewIds.push(item.viewId);
+            if (found) {
+                apiCalls.push(this.datasetService.getDataFromDataSet(found, item.datasetId, appliedFilters));
+            }
+        });
+        Promise.all(apiCalls).then(() => {
+            this.uniqueDataSetObject = this.datasetService.getUniqueDataSetObject();
+            this.loadSingleWidgetNode(node, this.mainPageDivElement, this.uniqueDataSetObject, null);
+            setTimeout(() => {
+                this.scrollToBottom(this.mainPageDivElement, null);
+            }, 200);
+        });
+        console.log(this.stateDataSource);
+    }
+    async getViewByRowCLick(event, view, targetWidgetId) {
+        let apiCalls = [];
+        let appliedFilters = this.getSetOperatorFilter(event, this.stateDataSource.get(event.viewId));
+        view.compConfig.viewConfig.forEach(contentView => {
+            let found = this.dataSetModal.find(d => d.datasetId === contentView.datasetId);
+            if (found) {
+                apiCalls.push(this.datasetService.getDataFromDataSet(found, contentView.datasetId, appliedFilters));
+            }
+        });
+        await Promise.all(apiCalls);
+        this.contextMenuDataSource = this.contextMenuDataSource.filter(e => e.displayKey !== event.keyToPass);
+        view.compConfig.viewConfig.forEach(viewforDataSet => {
+            let obj = {
+                "filters": appliedFilters,
+                "keyToPass": this.updateOperatorData(event.keyToPass, event.data),
+                "drillDownType": event.drillDownType,
+                "drilldownFrom": event.drilldownFrom,
+                "widgetId": targetWidgetId
+            };
+            this.stateDataSource.set(viewforDataSet['viewId'], obj);
+        });
+        view.nodeProperties['display'] = true;
+        view.nodeProperties['widgetParams'] = event.tableTitle;
+        const prefixedId = `id-${view.id}`;
+        const containerElement = document.querySelector(`#${prefixedId}`);
+        this.uniqueDataSetObject = this.datasetService.getUniqueDataSetObject();
+        this.loadSingleWidgetNode(view, this.mainPageDivElement, this.uniqueDataSetObject, targetWidgetId);
+        setTimeout(() => {
+            this.scrollToBottom(this.mainPageDivElement, targetWidgetId);
+        }, 200);
+        let navigation = {
+            queryParams: appliedFilters['operationFilter'],
+            queryParamsHandling: "merge"
+        };
+        this.router.navigate([], navigation);
+        console.log(this.stateDataSource);
+    }
+    scrollToBottom(container, widgetId) {
+        if (widgetId) {
+            let containerElement = container.get(widgetId);
+            setTimeout(() => {
+                containerElement.scrollIntoView({ block: 'end' });
+                this.loadingModal = false;
+            }, 0);
+        }
+        else {
+            setTimeout(() => {
+                container.scrollIntoView({ block: 'end' });
+                this.loadingModal = false;
+            }, 0);
+        }
+    }
+    findWidgetById(configs, id) {
+        for (const config of configs) {
+            if (config.id === id) {
+                return config;
+            }
+            if (config.widgetNode && config.widgetNode.length > 0) {
+                const found = this.findWidgetById(config.widgetNode, id);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        return undefined;
+    }
+    updateOperatorData(key_name, value_data) {
+        let operator = [];
+        for (const key of key_name) {
+            let obj = {};
+            obj[key] = value_data[key];
+            operator.push(obj);
+        }
+        return operator;
+    }
+    getElementOfCurrentView(node, viewId) {
+        const matchedObject = node.compConfig.viewConfig.find(object => object.viewId === viewId);
+        return matchedObject ? node : null;
+    }
+    getHourlyData(node) {
+        const matchedObject = node.compConfig.viewConfig.find(object => object.kpiConfig.formate === 'hourly');
+        return matchedObject ? node : null;
+    }
+    getSetOperatorFilter(objectData, previousViewStates) {
+        const { data, keyToPass } = objectData;
+        const appliedFilter = JSON.parse(JSON.stringify(previousViewStates.filters.operationFilter));
+        keyToPass.forEach(key => {
+            if (key in data) {
+                const normalizedKey = key.toLowerCase().replace(/_/g, '');
+                if (normalizedKey === "recorddate" && "startDate" in appliedFilter && "endDate" in appliedFilter) {
+                    appliedFilter.startDate = data[key];
+                    appliedFilter.endDate = data[key];
+                }
+                else {
+                    appliedFilter[key] = data[key];
+                }
+            }
+        });
+        const defaultoperationFilter = this.globalDefaultFilter.operationFilter;
+        if (defaultoperationFilter) {
+            Object.keys(defaultoperationFilter).forEach(key => {
+                if (!appliedFilter.hasOwnProperty(key)) {
+                    appliedFilter[key] = defaultoperationFilter[key];
+                }
+            });
+        }
+        const operationFilter = {};
+        operationFilter['operationFilter'] = appliedFilter;
+        return operationFilter;
+    }
+    getRearchResultFromInputBox(inputValue, viewConfig, filterObject) {
+        let view = viewConfig;
+        let eventNode = { data: {}, keyToPass: [] };
+        eventNode.data[filterObject.server_column] = inputValue;
+        eventNode['keyToPass'] = [filterObject.server_column];
+        let apiCalls = [];
+        view.compConfig.viewConfig.forEach(contentView => {
+            let appliedFilters = this.getSetOperatorFilter(eventNode, this.stateDataSource.get(contentView.viewId));
+            let found = this.dataSetModal.find(d => d.datasetId === contentView.datasetId);
+            if (found) {
+                apiCalls.push(this.datasetService.getDataFromDataSet(found, contentView.datasetId, appliedFilters));
+            }
+        });
+        viewConfig.nodeProperties['display'] = false;
+        const prefixedId = `id-${viewConfig.id}`;
+        const elementToHide = document.querySelector(`#${prefixedId}`);
+        if (elementToHide) {
+            elementToHide.remove();
+        }
+        Promise.all(apiCalls).then(() => {
+            this.uniqueDataSetObject = this.datasetService.getUniqueDataSetObject();
+            this.loadingModal = true;
+            this.contextMenuDataSource = this.contextMenuDataSource.filter(e => e.displayKey !== viewConfig.keyToPass);
+            view.nodeProperties['display'] = true;
+            const prefixedId = `id-${view.id}`;
+            const containerElement = document.querySelector(`#${prefixedId}`);
+            this.loadSingleWidgetNode(view, this.mainPageDivElement, this.uniqueDataSetObject, null);
+            setTimeout(() => {
+                this.scrollToBottom(this.mainPageDivElement, null);
+            }, 200);
+            let params = {};
+            params[filterObject.server_column] = inputValue;
+            let navigation = {
+                queryParams: params,
+                queryParamsHandling: "merge"
+            };
+            this.router.navigate([], navigation);
+        });
+    }
+    submitFilter() {
+        let view = this.nodeproperticeFilterDataSource.viewConfig;
+        let apiCalls = [];
+        this.havingDataObject = this.nodeproperticeFilterDataSource.havingConfig.filter(value => value.value !== "");
+        view.compConfig.viewConfig.forEach(contentView => {
+            let appliedFilters = this.stateDataSource.get(contentView.viewId);
+            let found = this.dataSetModal.find(d => d.datasetId === contentView.datasetId);
+            if (found) {
+                apiCalls.push(this.datasetService.getDataFromDataSet(found, contentView.datasetId, appliedFilters.filters));
+            }
+        });
+        Promise.all(apiCalls).then(() => {
+            this.uniqueDataSetObject = this.datasetService.getUniqueDataSetObject();
+            this.nodeproperticeFilterDataSource.viewConfig.nodeProperties['display'] = false;
+            const prefixedId = `id-${this.nodeproperticeFilterDataSource.viewConfig.id}`;
+            const elementToHide = document.querySelector(`#${prefixedId}`);
+            if (elementToHide) {
+                elementToHide.remove();
+            }
+            this.loadingModal = true;
+            this.contextMenuDataSource = this.contextMenuDataSource.filter(e => e.displayKey !== this.nodeproperticeFilterDataSource.viewConfig.keyToPass);
+            this.isWidgetFilters = false;
+            view.nodeProperties['display'] = true;
+            this.loadSingleWidgetNode(view, this.mainPageDivElement, this.uniqueDataSetObject, null);
+            setTimeout(() => {
+                this.scrollToBottom(this.mainPageDivElement, null);
+            }, 200);
+        });
+    }
+    getWidgetFilterForTemplate(value) {
+        let apiCalls = [];
+        const deletedViewIds = [];
+        value.viewNodes.compConfig.viewConfig.forEach(item => {
+            let widgetFilter = this.stateDataSource.get(item.viewId);
+            let appliedFilters = widgetFilter.filters;
+            let found = this.dataSetModal.find(d => d.datasetId === item.datasetId);
+            deletedViewIds.push(item.viewId);
+            const having = Object.entries(value.operationFilter).map(([key, value]) => ({
+                columnName: key,
+                dataType: "float",
+                operator: "gte",
+                value: value
+            }));
+            if (found) {
+                found.config.queryConfig['havings'] = having;
+                apiCalls.push(this.datasetService.getDataFromDataSet(found, item.datasetId, appliedFilters));
+            }
+        });
+        Promise.all(apiCalls).then(() => {
+            this.uniqueDataSetObject = this.datasetService.getUniqueDataSetObject();
+            this.loadSingleWidgetNode(value.viewNodes, this.mainPageDivElement, this.uniqueDataSetObject, null);
+            setTimeout(() => {
+                this.scrollToBottom(this.mainPageDivElement, null);
+            }, 200);
+        });
+    }
+    async loadDataByOperator(opName) {
+        console.log(opName);
+        let filter = { operationFilter: { startDate: "", endDate: "", operator_key: "" } };
+        filter.operationFilter['startDate'] = this.defaultStartDate;
+        filter.operationFilter['endDate'] = this.defaultEndDate;
+        filter.operationFilter['operator_key'] = opName;
+        this.loadingModal = true;
+        let navigation = {
+            queryParams: {
+                "operatorName": opName
+            },
+            queryParamsHandling: "merge"
+        };
+        this.router.navigate([], navigation);
+        await this.getPadeDataSource(true);
+        this.uniqueDataSetObject = {};
+        let apiCalls = [];
+        this.allWidgetByDataset.forEach(view => {
+            view.datasetIds.forEach(id => {
+                let found = this.dataSetModal.find(d => d.datasetId === id);
+                if (found) {
+                    apiCalls.push(this.datasetService.getDataFromDataSet(found, id, filter));
+                }
+            });
+        });
+        Promise.all(apiCalls).then(() => {
+            this.globalDefaultFilter = filter;
+            this.uniqueDataSetObject = this.datasetService.getUniqueDataSetObject();
+            this.createDivElements(this.uniqueDataSetObject, true);
+            this.loadingModal = false;
+        });
+    }
+    async getContextFilterData(value) {
+        let filter = { operationFilter: { startDate: "", endDate: "" } };
+        filter.operationFilter['startDate'] = this.defaultStartDate;
+        filter.operationFilter['endDate'] = this.defaultEndDate;
+        filter.operationFilter[value.operatorName] = this.parseInput(value.defaultFilterValue);
+        this.loadingModal = true;
+        let obj = {};
+        obj[value.operatorName] = value.defaultFilterValue;
+        let navigation = {
+            queryParams: obj,
+            queryParamsHandling: "merge"
+        };
+        this.router.navigate([], navigation);
+        await this.getPadeDataSource(true);
+        this.uniqueDataSetObject = {};
+        let apiCalls = [];
+        this.allWidgetByDataset.forEach(view => {
+            view.datasetIds.forEach(id => {
+                let found = this.dataSetModal.find(d => d.datasetId === id);
+                if (found) {
+                    apiCalls.push(this.datasetService.getDataFromDataSet(found, id, filter));
+                }
+            });
+        });
+        Promise.all(apiCalls).then(() => {
+            this.globalDefaultFilter = filter;
+            this.uniqueDataSetObject = this.datasetService.getUniqueDataSetObject();
+            this.createDivElements(this.uniqueDataSetObject, true);
+            this.loadingModal = false;
+        });
+    }
+    parseInput(input) {
+        input = input.trim();
+        if (input.includes(',')) {
+            return input.split(',').map(item => item.trim());
+        }
+        else {
+            return input;
+        }
+    }
+}
+KpiWithMultilayoutSetTestComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: KpiWithMultilayoutSetTestComponent, deps: [{ token: i1.CommonService }, { token: i2.ActivatedRoute }, { token: i0.ViewContainerRef }, { token: i0.ComponentFactoryResolver }, { token: i3.ApplicationContentService }, { token: i4.ToastrService }, { token: i2.Router }, { token: i5.ApplicationDatssetsCall }], target: i0.ɵɵFactoryTarget.Component });
+KpiWithMultilayoutSetTestComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: KpiWithMultilayoutSetTestComponent, selector: "app-kpi-with-multilayout", viewQueries: [{ propertyName: "dynamicComponentContainer", first: true, predicate: ["dynamicComponentContainer"], descendants: true, read: ViewContainerRef }, { propertyName: "containerRef", first: true, predicate: ["container"], descendants: true, read: ViewContainerRef }, { propertyName: "dynamicContainer", first: true, predicate: ["dynamicContainer"], descendants: true, static: true }], ngImport: i0, template: "<app-loading *ngIf=\"loadingModal\"></app-loading>\n\n<div class=\"w-full\">\n    <div class=\"flex flex-wrap \" #dynamicContainer></div>\n</div>\n\n<dx-popup [(visible)]=\"isWidgetFilters\" [closeOnOutsideClick]=\"false\" [dragEnabled]=\"false\" [width]=\"800\" [height]=\"400\"\n    [showTitle]=\"true\" class=\"popup\" title=\"Dataset Filter\">\n    <div *dxTemplate=\"let data of 'content'\">\n        <div class=\"my-2\">\n            <dx-scroll-view [width]=\"'100%'\" [height]=\"'85%'\">\n                <ng-container *ngFor=\"let item of nodeproperticeFilterDataSource.havingConfig; let i = index\">\n                    <div class=\"flex flex-row my-2\">\n                        <div class=\"m-1\">\n                            <dx-text-box [(ngModel)]=\"item.columnName\"></dx-text-box>\n                        </div>\n                        <div class=\"m-1\">\n                            <dx-select-box [items]=\"['get','let']\" [(ngModel)]=\"item.operator\"\n                                placeholder=\"Operator\"></dx-select-box>\n                        </div>\n                        <div class=\"m-1\">\n                            <dx-text-box [(ngModel)]=\"item.value\"></dx-text-box>\n                        </div>\n                    </div>\n                </ng-container>\n\n            </dx-scroll-view>\n            <div class=\"flex justify-end mx-1 flex-grow border-t\">\n                <button class=\"{{commonService.btn_success_md}} cursor-pointer mt-2\"\n                    (click)=\"submitFilter()\">Submit</button>\n            </div>\n\n        </div>\n\n    </div>\n</dx-popup>\n\n\n\n", styles: [""], dependencies: [{ kind: "directive", type: i6.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i7.LoadingComponent, selector: "app-loading" }, { kind: "directive", type: i8.DxTemplateDirective, selector: "[dxTemplate]", inputs: ["dxTemplateOf"] }, { kind: "component", type: i9.DxPopupComponent, selector: "dx-popup", inputs: ["accessKey", "animation", "closeOnOutsideClick", "container", "contentTemplate", "copyRootClassesToWrapper", "deferRendering", "disabled", "dragAndResizeArea", "dragEnabled", "dragOutsideBoundary", "elementAttr", "focusStateEnabled", "fullScreen", "height", "hideOnOutsideClick", "hideOnParentScroll", "hint", "hoverStateEnabled", "maxHeight", "maxWidth", "minHeight", "minWidth", "position", "resizeEnabled", "restorePosition", "rtlEnabled", "shading", "shadingColor", "showCloseButton", "showTitle", "tabIndex", "title", "titleTemplate", "toolbarItems", "visible", "width", "wrapperAttr"], outputs: ["onContentReady", "onDisposing", "onHidden", "onHiding", "onInitialized", "onOptionChanged", "onResize", "onResizeEnd", "onResizeStart", "onShowing", "onShown", "onTitleRendered", "accessKeyChange", "animationChange", "closeOnOutsideClickChange", "containerChange", "contentTemplateChange", "copyRootClassesToWrapperChange", "deferRenderingChange", "disabledChange", "dragAndResizeAreaChange", "dragEnabledChange", "dragOutsideBoundaryChange", "elementAttrChange", "focusStateEnabledChange", "fullScreenChange", "heightChange", "hideOnOutsideClickChange", "hideOnParentScrollChange", "hintChange", "hoverStateEnabledChange", "maxHeightChange", "maxWidthChange", "minHeightChange", "minWidthChange", "positionChange", "resizeEnabledChange", "restorePositionChange", "rtlEnabledChange", "shadingChange", "shadingColorChange", "showCloseButtonChange", "showTitleChange", "tabIndexChange", "titleChange", "titleTemplateChange", "toolbarItemsChange", "visibleChange", "widthChange", "wrapperAttrChange"] }, { kind: "component", type: i10.DxScrollViewComponent, selector: "dx-scroll-view", inputs: ["bounceEnabled", "direction", "disabled", "elementAttr", "height", "pulledDownText", "pullingDownText", "reachBottomText", "refreshingText", "rtlEnabled", "scrollByContent", "scrollByThumb", "showScrollbar", "useNative", "width"], outputs: ["onDisposing", "onInitialized", "onOptionChanged", "onPullDown", "onReachBottom", "onScroll", "onUpdated", "bounceEnabledChange", "directionChange", "disabledChange", "elementAttrChange", "heightChange", "pulledDownTextChange", "pullingDownTextChange", "reachBottomTextChange", "refreshingTextChange", "rtlEnabledChange", "scrollByContentChange", "scrollByThumbChange", "showScrollbarChange", "useNativeChange", "widthChange"] }, { kind: "component", type: i11.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: i12.DxTextBoxComponent, selector: "dx-text-box", inputs: ["accessKey", "activeStateEnabled", "buttons", "disabled", "elementAttr", "focusStateEnabled", "height", "hint", "hoverStateEnabled", "inputAttr", "isValid", "label", "labelMode", "mask", "maskChar", "maskInvalidMessage", "maskRules", "maxLength", "mode", "name", "placeholder", "readOnly", "rtlEnabled", "showClearButton", "showMaskMode", "spellcheck", "stylingMode", "tabIndex", "text", "useMaskedValue", "validationError", "validationErrors", "validationMessageMode", "validationStatus", "value", "valueChangeEvent", "visible", "width"], outputs: ["onChange", "onContentReady", "onCopy", "onCut", "onDisposing", "onEnterKey", "onFocusIn", "onFocusOut", "onInitialized", "onInput", "onKeyDown", "onKeyUp", "onOptionChanged", "onPaste", "onValueChanged", "accessKeyChange", "activeStateEnabledChange", "buttonsChange", "disabledChange", "elementAttrChange", "focusStateEnabledChange", "heightChange", "hintChange", "hoverStateEnabledChange", "inputAttrChange", "isValidChange", "labelChange", "labelModeChange", "maskChange", "maskCharChange", "maskInvalidMessageChange", "maskRulesChange", "maxLengthChange", "modeChange", "nameChange", "placeholderChange", "readOnlyChange", "rtlEnabledChange", "showClearButtonChange", "showMaskModeChange", "spellcheckChange", "stylingModeChange", "tabIndexChange", "textChange", "useMaskedValueChange", "validationErrorChange", "validationErrorsChange", "validationMessageModeChange", "validationStatusChange", "valueChange", "valueChangeEventChange", "visibleChange", "widthChange", "onBlur"] }, { kind: "directive", type: i13.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i13.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: KpiWithMultilayoutSetTestComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-kpi-with-multilayout', template: "<app-loading *ngIf=\"loadingModal\"></app-loading>\n\n<div class=\"w-full\">\n    <div class=\"flex flex-wrap \" #dynamicContainer></div>\n</div>\n\n<dx-popup [(visible)]=\"isWidgetFilters\" [closeOnOutsideClick]=\"false\" [dragEnabled]=\"false\" [width]=\"800\" [height]=\"400\"\n    [showTitle]=\"true\" class=\"popup\" title=\"Dataset Filter\">\n    <div *dxTemplate=\"let data of 'content'\">\n        <div class=\"my-2\">\n            <dx-scroll-view [width]=\"'100%'\" [height]=\"'85%'\">\n                <ng-container *ngFor=\"let item of nodeproperticeFilterDataSource.havingConfig; let i = index\">\n                    <div class=\"flex flex-row my-2\">\n                        <div class=\"m-1\">\n                            <dx-text-box [(ngModel)]=\"item.columnName\"></dx-text-box>\n                        </div>\n                        <div class=\"m-1\">\n                            <dx-select-box [items]=\"['get','let']\" [(ngModel)]=\"item.operator\"\n                                placeholder=\"Operator\"></dx-select-box>\n                        </div>\n                        <div class=\"m-1\">\n                            <dx-text-box [(ngModel)]=\"item.value\"></dx-text-box>\n                        </div>\n                    </div>\n                </ng-container>\n\n            </dx-scroll-view>\n            <div class=\"flex justify-end mx-1 flex-grow border-t\">\n                <button class=\"{{commonService.btn_success_md}} cursor-pointer mt-2\"\n                    (click)=\"submitFilter()\">Submit</button>\n            </div>\n\n        </div>\n\n    </div>\n</dx-popup>\n\n\n\n" }]
+        }], ctorParameters: function () { return [{ type: i1.CommonService }, { type: i2.ActivatedRoute }, { type: i0.ViewContainerRef }, { type: i0.ComponentFactoryResolver }, { type: i3.ApplicationContentService }, { type: i4.ToastrService }, { type: i2.Router }, { type: i5.ApplicationDatssetsCall }]; }, propDecorators: { dynamicComponentContainer: [{
+                type: ViewChild,
+                args: ['dynamicComponentContainer', { read: ViewContainerRef }]
+            }], containerRef: [{
+                type: ViewChild,
+                args: ['container', { read: ViewContainerRef }]
+            }], dynamicContainer: [{
+                type: ViewChild,
+                args: ['dynamicContainer', { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"kpi-with-multilayout.component.js","sourceRoot":"","sources":["../../../../../../projects/gamma-app-controller/src/lib/template-module/kpiWithMultiLayout/kpi-with-multilayout.component.ts","../../../../../../projects/gamma-app-controller/src/lib/template-module/kpiWithMultiLayout/kpi-with-multilayout.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Component, ComponentFactoryResolver, ComponentRef, ElementRef, HostListener, OnDestroy, OnInit, QueryList, ViewChild, ViewChildren, ViewContainerRef } from '@angular/core';\nimport { ActivatedRoute, NavigationExtras, Router } from '@angular/router';\nimport { ToastrService } from 'ngx-toastr';\nimport { forkJoin } from 'rxjs';\nimport { take, tap } from 'rxjs/operators';\nimport moment from '../../application-controller/moment-helper';\nimport { CommonService } from '../../application-controller/common';\nimport { GammaAdvanceChartComponent } from '../../shared/advanced-component/gamma-advance-chart/gamma-advance-chart.component';\nimport { GammaTodayPreviousComponent } from '../../shared/advanced-component/gamma-today-previous/gamma-today-previous.component';\nimport { AppAdvanceHeaderComponent } from '../../shared/advanced-component/app-advance-header/app-header.component';\nimport { GammaTableWithPercentageComponent } from '../../shared/advanced-component/gamma-table-with-percentage/gamma-table-with-percentage.component';\nimport { GammSingleNumberCardComponent } from '../../shared/advanced-component/gamm-single-number-card/gamm-single-number-card.component';\nimport { GammaAdvanceOperatorTableComponent } from '../../shared/advanced-component/gamma-advance-operator-table/gamma-advance-operator-table.component';\nimport { AdvanceWidgetHeaderFilterComponent } from '../../shared/advanced-component/advance-widget-header-filter/advance-widget-header-filter.component';\nimport { GammaGeoChartComponent } from '../../shared/advanced-component/gamma-geo-chart/gamma-geo-chart.component';\nimport { GammaHeatChartComponent } from '../../shared/advanced-component/gamma-heatmap/gamma-heatmap.component';\nimport { ApplicationContentService } from '../../application-controller/application-content.service';\nimport { ApplicationDatssetsCall } from '../../application-controller/application-dataset-call.service';\n\n\n@Component({\n  selector: 'app-kpi-with-multilayout',\n  templateUrl: './kpi-with-multilayout.component.html',\n  styleUrls: ['./kpi-with-multilayout.scss']\n})\nexport class KpiWithMultilayoutSetTestComponent implements OnInit {\n  dashbord_container: any = [];\n  selected_width: any;\n  widget_width = ['w-full', 'w-1/2', 'w-1/3', 'w-1/4', 'w-1/5', 'w-1/6']\n  loadingModal: boolean;\n  page_title = 'Dashboard';\n  defaultStartDate;\n  defaultEndDate;\n  /**\n   * Constructor\n   */\n\n  @ViewChild('dynamicComponentContainer', { read: ViewContainerRef })\n  dynamicComponentContainer: ViewContainerRef;\n  @ViewChild('container', { read: ViewContainerRef })\n  containerRef: ViewContainerRef;\n  @ViewChild('dynamicContainer', { static: true }) dynamicContainer: ElementRef;\n\n  dynamicComponentRefs: ComponentRef<any>[] = [];\n  // dynamicComponentRefs: ComponentRef<any>[] = [];\n\n  CompRefs: ComponentRef<any>;\n\n  componentClassMap = {\n    GammaAdvanceChartComponent,\n    GammaTodayPreviousComponent,\n    AppAdvanceHeaderComponent,\n    GammaTableWithPercentageComponent,\n    GammSingleNumberCardComponent,\n    GammaAdvanceOperatorTableComponent,\n    AdvanceWidgetHeaderFilterComponent,\n    GammaGeoChartComponent,\n    GammaHeatChartComponent\n  };\n  dataSourceMataData: any = [];\n  queryType = \"mongo\";\n  dataSetModal: any = [];\n  componentConfigDataSource: any = [];\n  selescedDataSource: any;\n  dataSourceModal: any = {};\n  isDashBoardContent: boolean = false;\n\n  selectedViewFormComponent: any = {};\n  addedwidGetConfig = {\n    \"display\": true,\n    \"widgetTitle\": \"\",\n    \"width\": \"\",\n    \"height\": \"\"\n  }\n\n\n  dashBoardWidgetConfig: any = [\n\n  ];\n  isWidgetCreationContent: boolean;\n  selectedWidth: any;\n  selectedHeight: any;\n  newWidgetIndex: any;\n  selectedIndexObjForChart: any = {};\n  selectedContainerObjectForChart: any = {};\n  dataSettableDataSource: any;\n  uniqueDataSetObject = {};\n\n  isDashBoardContentTypeView: boolean = true;\n  filters: any;\n  allWidgetByDataset = [];\n  pageTitle: any;\n  stateDataSource = new Map();\n  mainPageDivElement = new Map();\n  contextMenuDataSource: any = [];\n  havingDataObject: any = {};\n  isWidgetFilters: boolean;\n  nodeproperticeFilterDataSource: any;\n  globalDefaultFilter: any = {};\n  pageId: any;\n\n  kpi_breadcrumbs_container: any;\n  operatorName: any;\n  constructor(\n    public commonService: CommonService,\n    private activatedRoute: ActivatedRoute,\n    private viewContainerRef: ViewContainerRef,\n    private componentFactoryResolver: ComponentFactoryResolver,\n    private service: ApplicationContentService,\n    private toastr: ToastrService,\n    private router: Router,\n    private datasetService: ApplicationDatssetsCall,\n\n  ) { }\n\n  ngOnInit(): void {\n\n    this.service.getlistKpiBrowser().subscribe({\n      next: ((data: any) => {\n        this.kpi_breadcrumbs_container = data;\n      })\n    })\n\n\n    this.loadingModal = true;\n    this.pageId = this.activatedRoute.snapshot.queryParams['pageId'];\n    this.getPadeDataSource(false);\n  }\n\n  async getFiltersForTemplate(filter) {\n    this.filters = filter;\n    this.defaultStartDate = filter.startDate;\n    this.defaultEndDate = filter.endDate;\n    filter.operationFilter['startDate'] = filter.startDate;\n    filter.operationFilter['endDate'] = filter.endDate;\n    this.loadingModal = true;\n    this.dashBoardWidgetConfig = [];\n    await this.getPadeDataSource(true);\n    this.uniqueDataSetObject = {};\n    let apiCalls = [];\n\n    this.allWidgetByDataset.forEach(view => {\n      view.datasetIds.forEach(id => {\n        let found = (this.dataSetModal as any[]).find(d => d.datasetId === id);\n        if (found) {\n          apiCalls.push(this.datasetService.getDataFromDataSet(found, id, filter));\n        }\n      });\n    });\n\n    Promise.all(apiCalls).then(() => {\n      this.globalDefaultFilter = filter;\n      this.uniqueDataSetObject = this.datasetService.getUniqueDataSetObject();\n      this.createDivElements(this.uniqueDataSetObject, true);\n      this.loadingModal = false;\n    });\n  }\n\n  getPadeDataSource(context): Promise<void> {\n    return new Promise((resolve, reject) => {\n      this.service.getAppPageDetailConfig(this.pageId).subscribe({\n        next: (data: any) => {\n\n          this.pageTitle = data.pageName;\n          this.dashBoardWidgetConfig = data;\n\n          if (!context) {\n            // this.defaultStartDate = moment().subtract('30', 'days').format('YYYY-MM-DD');\n            // this.defaultEndDate = moment().subtract('1', 'days').format('YYYY-MM-DD');\n\n            if (Object.keys(this.uniqueDataSetObject).length != 0) {\n              this.createDivElements(this.uniqueDataSetObject, false);\n\n            }\n\n            this.getComponentConfigSet();\n            // this.loadingModal = false;\n\n          }\n          resolve();\n        },\n        error: (err: any) => {\n          this.toastr.error('Unexpected Server Exception. Please contact System Admin.', 'Error');\n          reject(err);\n        }\n      });\n    });\n  }\n\n\n\n  getComponentConfigSet() {\n    let dataset = this.service.getAppDatasetConfigs();\n    let viewComponent = this.service.getAppViewConfigs();\n\n    forkJoin({\n      datasetConfig: dataset,\n      viewConfig: viewComponent\n    }).subscribe({\n      next: (({ datasetConfig, viewConfig }) => {\n        this.componentConfigDataSource = viewConfig;\n        this.dataSetModal = datasetConfig;\n        this.allWidgetByDataset = [];\n        let defaultFilters = { operationFilter: { startDate: \"\", endDate: \"\" } };\n\n        this.dashBoardWidgetConfig.widgets.forEach(widget => {\n          widget.filters.filterItems.forEach(element => {\n\n            if (element.filterType === 'date' || element.filterType === 'datetime') {\n              if (element.defaultFilterType === \"dynamic\" && element.momentFunction !== \"\" && element.defaultFilterValue !== \"\" && element.momentFormat !== \"\") {\n                let [count, unit] = element.defaultFilterValue.split(',');\n                if (element.apiName === \"endDate\") {\n                  if (element.display) {\n                    defaultFilters.operationFilter.endDate = moment()[element.momentFunction](parseInt(count), unit).format(element.momentFormat);\n                    this.defaultEndDate = moment()[element.momentFunction](parseInt(count), unit).format(element.momentFormat);\n                  }\n                }\n                if (element.apiName === \"startDate\") {\n                  defaultFilters.operationFilter.startDate = moment()[element.momentFunction](parseInt(count), unit).format(element.momentFormat);\n                  this.defaultStartDate = moment()[element.momentFunction](parseInt(count), unit).format(element.momentFormat);\n                }\n              } else if (element.defaultFilterType === \"static\" && element.defaultFilterValue !== \"\") {\n                if (element.apiName === \"endDate\") {\n                  if (element.display) {\n                    defaultFilters.operationFilter.endDate = element.defaultFilterValue;\n                    this.defaultEndDate = element.defaultFilterValue;\n                  }\n                }\n                if (element.apiName === \"startDate\") {\n                  defaultFilters.operationFilter.startDate = element.defaultFilterValue;\n\n                  this.defaultStartDate = element.defaultFilterValue;\n                }\n              }\n            } else {\n              if (\n                (typeof element.filterDataSourceValue === \"string\" && element.filterDataSourceValue !== \"\") ||\n                (Array.isArray(element.filterDataSourceValue) && element.filterDataSourceValue.length > 0)\n              ) {\n                if (element.operatorName !== \"\") {\n                  defaultFilters.operationFilter[element.operatorName] = Array.isArray(element.filterDataSourceValue)\n                    ? element.filterDataSourceValue\n                    : [element.filterDataSourceValue];\n                } else {\n                  defaultFilters.operationFilter[element.apiName] = element.filterDataSourceValue.join(\",\");\n\n                }\n              }\n            }\n\n          });\n\n\n          let datasetIds: Set<string> = new Set();\n          let viewIds: Set<string> = new Set();\n          widget.widgetNode.forEach(node => {\n            if (node.nodeProperties.display) {\n              node.compConfig.viewConfig.forEach(view => {\n                datasetIds.add(view.datasetId);\n                viewIds.add(view.viewId);\n              });\n            } else {\n              node.compConfig.viewConfig.forEach(view => {\n                this.contextMenuDataSource.push({ viewId: view.viewId, viewName: node.nodeProperties.widgetTitle, displayKey: view.kpiConfig.keyToPass })\n              });\n\n            }\n          });\n          //for RTDMS operatorname\n          // this.operatorName = this.activatedRoute.snapshot.queryParams['operatorName'];\n          // if (this.operatorName) {\n          //   defaultFilters.operationFilter['operator_key'] = this.operatorName;\n          // }\n\n          viewIds.forEach(element => {\n            let obj = {\n              \"filters\": JSON.parse(JSON.stringify(defaultFilters)),\n              \"keyToPass\": [],\n              \"drillDownType\": \"natural\",\n              \"drilldownFrom\": \"\",\n              \"widgetId\": widget.widgetId\n            }\n            this.stateDataSource.set(element, obj)\n          });\n          let obj = {\n            widgetId: widget.widgetId,\n            pageId: widget.pageId,\n            filters: defaultFilters,\n            datasetIds: datasetIds\n          }\n          this.allWidgetByDataset.push(obj);\n        });\n\n        console.log(this.stateDataSource);\n\n\n        this.uniqueDataSetObject = {};\n        let apiCalls = [];\n\n        this.allWidgetByDataset.forEach(view => {\n          view.datasetIds.forEach(id => {\n            let found = (datasetConfig as any[]).find(d => d.datasetId === id);\n            if (found) {\n              apiCalls.push(this.datasetService.getDataFromDataSet(found, id, view.filters));\n            }\n          });\n        });\n        Promise.all(apiCalls).then(() => {\n          this.uniqueDataSetObject = this.datasetService.getUniqueDataSetObject();\n          this.createDivElements(this.uniqueDataSetObject, false);\n          this.loadingModal = false;\n          let urlParams: any = defaultFilters.operationFilter\n          urlParams['pageId'] = this.pageId\n          let navigation: NavigationExtras = {\n            queryParams: urlParams,\n            queryParamsHandling: \"merge\"\n          };\n          this.router.navigate([], navigation);\n        });\n      }), error: (err: any) => {\n        this.toastr.error('Unexpected Server Exception. Please contact System Admin.', 'Error');\n      }\n    })\n  }\n\n  getDataSet() {\n    this.service.getAppDatasetConfigs().subscribe({\n      next: (data: any) => {\n        this.dataSettableDataSource = data;\n      }, error: (err: any) => {\n        this.toastr.error('Unexpected Server Exception. Please contact System Admin.', 'Dataset Creation')\n\n      }\n    })\n  }\n\n\n  async createDivElements(datasetById, context) {\n    const container = this.dynamicContainer.nativeElement;\n    container.innerHTML = \"\";\n\n    // Add filter section\n    if (this.dashBoardWidgetConfig.widgets.length > 0) {\n\n      const firstWidget = this.dashBoardWidgetConfig.widgets[0];\n      const rowDiv = document.createElement('div');\n      let w_height = (firstWidget.widgetProperties.height == \"\") ? \"h-auto\" : 'h-[' + firstWidget.widgetProperties.height + ']';\n      rowDiv.classList.add(firstWidget.widgetProperties.width, w_height);\n\n      const filterDiv = document.createElement('div');\n      const filterItems = (firstWidget.filters) ? firstWidget.filters.filterItems : [];\n      const context_filter = this.dashBoardWidgetConfig.filters ? this.dashBoardWidgetConfig.filters.filterItems : null;\n\n      // Load filter component\n      this.loadFilterComponent(firstWidget, filterDiv, filterItems, context_filter);\n      rowDiv.appendChild(filterDiv);\n\n      // Append the filter section to the container\n      container.appendChild(rowDiv);\n\n      // Create main wrapper div with \"flex flex-row justify-between\"\n      const mainWrapperDiv = document.createElement('div');\n      mainWrapperDiv.classList.add(\"flex\", \"flex-row\", \"justify-between\", \"w-full\");\n\n      // Loop through widgets to add each to \"flex flex-wrap\" divs\n      this.dashBoardWidgetConfig.widgets.forEach(div => {\n        const childDiv = document.createElement('div');\n        childDiv.classList.add(\"w-full\");\n\n        // Load widget nodes into the child div\n        if (div.widgetNode.length != 0) {\n          this.loadWidgetNodes(div, childDiv, datasetById);\n        }\n\n        // Append the child div to the main wrapper\n        mainWrapperDiv.appendChild(childDiv);\n      });\n\n      // Append the main wrapper div after the filterDiv\n      container.appendChild(mainWrapperDiv);\n    }\n  }\n  loadWidgetNodes(div: any, mainItemDiv: any, datasetById: any) {\n    this.mainPageDivElement.set(div.widgetId, mainItemDiv);\n    div.widgetNode.forEach(item => {\n      this.loadSingleWidgetNode(item, mainItemDiv, datasetById, null);\n    });\n  }\n\n\n  loadSingleWidgetNode(item: any, containerElement: any, datasetById: any, widgetId) {\n    const elementId = `id-${item.id}`;\n    const existingElement = document.querySelector(`#${elementId}`);\n    if (item.nodeProperties.display && !existingElement) {\n      const w_height = item.nodeProperties.height === \"\" ? \"h-auto\" : `h-[${item.nodeProperties.height}]`;\n      const itemDiv = document.createElement('div');\n      itemDiv.id = elementId;\n      itemDiv.classList.add(item.nodeProperties.width, w_height, 'mb-2');\n      const widgetDiv = this.getWidgetTitleDiv(item);\n      itemDiv.appendChild(widgetDiv);\n      const innerDiv = document.createElement('div');\n      innerDiv.classList.add('rounded', 'justify-center', 'items-center', 'border', 'p-1', 'm-1', 'flex', 'flex-row');\n      item.compConfig.viewConfig.forEach(element => {\n        element.kpiConfig['dataSource'] = datasetById[element.datasetId];\n        element.kpiConfig['contextMenu'] = this.contextMenuDataSource;\n        element['titleParams'] = item.nodeProperties.widgetParams || \"\";\n        const comp_object = this.findWidgetById(this.dashBoardWidgetConfig.widgets, item.id);\n        this.loadDynamicComponent(element, comp_object, itemDiv);\n      });\n\n      if (widgetId) {\n        let childelementContainer = containerElement.get(widgetId);\n        childelementContainer.appendChild(itemDiv);\n        if (!this.isDashBoardContentTypeView) {\n          itemDiv.appendChild(innerDiv);\n        }\n        console.log(childelementContainer);\n      } else {\n        containerElement.appendChild(itemDiv);\n        if (!this.isDashBoardContentTypeView) {\n          itemDiv.appendChild(innerDiv);\n        }\n      }\n\n\n    } else if (existingElement) {\n      const itemDiv = existingElement as HTMLElement;\n      itemDiv.innerHTML = '';\n      const widgetDiv = this.getWidgetTitleDiv(item);\n      itemDiv.appendChild(widgetDiv);\n      item.compConfig.viewConfig.forEach(element => {\n        element.kpiConfig['dataSource'] = datasetById[element.datasetId];\n        element.kpiConfig['contextMenu'] = this.contextMenuDataSource;\n        element['titleParams'] = item.nodeProperties.widgetParams || \"\";\n        const comp_object = this.findWidgetById(this.dashBoardWidgetConfig.widgets, item.id);\n        this.loadDynamicComponent(element, comp_object, itemDiv);\n      });\n\n      if (!this.isDashBoardContentTypeView) {\n        const innerDiv = document.createElement('div');\n        innerDiv.classList.add('rounded', 'justify-center', 'items-center', 'border', 'p-1', 'm-1', 'flex', 'flex-row');\n        itemDiv.appendChild(innerDiv);\n      }\n    }\n  }\n\n  getWidgetTitleDiv(item) {\n    const widgetDiv = document.createElement('div');\n    widgetDiv.classList.add('flex', 'items-center', 'justify-between', 'font-bold', 'text-md', 'text-gray-900', 'dark:text-white', 'border-b', 'p-3', 'bg-gray-800', 'mx-2', 'rounded-t-lg');\n    const titleDiv = document.createElement('div');\n    const params = item.nodeProperties.widgetParams || \"\";\n    titleDiv.innerText = item.nodeProperties.widgetTitle + params;\n    widgetDiv.appendChild(titleDiv);\n\n    const searchContainerDiv = document.createElement('div');\n    searchContainerDiv.classList.add('flex', 'items-center', 'ml-auto', 'space-x-2', 'justify-end'); // ml-auto pushes content to the right side\n\n    // Check for widget filter\n    if (item.nodeProperties.isWidgetFilter) {\n      const searchButton = document.createElement('button');\n      searchButton.innerText = 'Filter';\n      searchButton.classList.add('px-3', 'py-1.5', 'bg-blue-600', 'mr-2', 'text-white', 'rounded', 'hover:bg-blue-700');\n      this.nodeproperticeFilterDataSource = {};\n      this.nodeproperticeFilterDataSource['viewConfig'] = item;\n      this.nodeproperticeFilterDataSource['havingConfig'] = [];\n\n      searchButton.addEventListener('click', () => {\n        this.isWidgetFilters = true;\n        let filtePropertice = [];\n        item.compConfig.viewConfig.forEach(element => {\n          let key_name = this.uniqueDataSetObject[element.datasetId][0];\n          Object.keys(key_name).forEach(key => {\n            if (!filtePropertice.includes(key)) {\n              filtePropertice.push(key);\n            }\n          });\n        });\n        filtePropertice.forEach(element => {\n          let obj = {\n            columnName: element,\n            dataType: \"float\",\n            operator: \"\",\n            value: \"\",\n          }\n          this.nodeproperticeFilterDataSource.havingConfig.push(obj)\n        });\n      });\n      searchContainerDiv.appendChild(searchButton)\n    }\n\n    // Check for item filterId\n    if (item.filterId) {\n      this.nodeproperticeFilterDataSource = {};\n      this.nodeproperticeFilterDataSource['viewConfig'] = item;\n      this.nodeproperticeFilterDataSource['havingConfig'] = [];\n\n      this.service.getAppFilterConfig(item.filterId).subscribe({\n        next: (data: any) => {\n          const filterDiv = document.createElement('div');\n          this.loadWidgetFilterComponent(item, widgetDiv, data.filterItems, item);\n        }, error: (err: any) => {\n\n        }\n      });\n    }\n\n    // Check for node filters\n    if (item.nodeProperties.nodefilters && item.nodeProperties.nodefilters.length !== 0) {\n      item.nodeProperties.nodefilters.forEach(filter => {\n        const filterDiv = document.createElement('div');\n        filterDiv.classList.add('flex', 'items-center');\n\n        if (filter.input_type === 'text') {\n          const textBox = document.createElement('input');\n          textBox.type = 'text';\n          textBox.placeholder = `Enter ${filter.local_column}`;\n          textBox.classList.add('px-2', 'py-1.5', 'rounded', 'border', 'mr-1', 'border-gray-500', 'text-gray-900', 'dark:bg-gray-700', 'dark:text-white');\n\n          const searchButton = document.createElement('button');\n          searchButton.innerText = 'Search';\n          searchButton.classList.add('px-3', 'py-1.5', 'bg-blue-600', 'mr-2', 'text-white', 'rounded', 'hover:bg-blue-700');\n\n          const separerotButton = document.createElement('div');\n          separerotButton.innerHTML = '|';\n\n          searchButton.addEventListener('click', () => {\n            const searchTerm = textBox.value;\n            this.getRearchResultFromInputBox(searchTerm, item, filter);\n          });\n\n          filterDiv.appendChild(textBox);\n          filterDiv.appendChild(searchButton);\n          filterDiv.appendChild(separerotButton);\n        }\n\n        searchContainerDiv.appendChild(filterDiv);\n      });\n    }\n\n    widgetDiv.appendChild(searchContainerDiv);\n    return widgetDiv;\n  }\n\n\n\n  loadDynamicComponent(data, indexObj, containerElement): any {\n    const componentClass = this.componentClassMap[data.kpiConfig.componentName];\n    this.CompRefs = this.viewContainerRef.createComponent(componentClass);\n    const dynamicComponentInstance = this.CompRefs.instance;\n\n    dynamicComponentInstance.chartDataSource = data;\n    dynamicComponentInstance.kpi_name = \"\";\n    if (data.kpiConfig.componentName == \"GammaAdvanceOperatorTableComponent\" || data.kpiConfig.componentName == \"GammaTableWithPercentageComponent\") {\n      dynamicComponentInstance.oRowClick.subscribe((value: string) => {\n        this.getRowClick(value);\n      });\n      dynamicComponentInstance.onrightClickContextSelection.subscribe((value: string) => {\n        this.getContextClick(value);\n      });\n    }\n    // indexObj.compConfig.dynamicComponentRefs.push(this.CompRefs);\n    const cssClass = \"w-full\";\n    this.CompRefs.location.nativeElement.classList.add(cssClass);\n    containerElement.appendChild(this.CompRefs.location.nativeElement);\n  }\n\n  loadFilterComponent(indexObj, containerElement, filterItems, context_filter) {\n    let userName = localStorage.getItem('user_name')\n    let selectedDates = { startDate: this.defaultStartDate, endDate: this.defaultEndDate }\n    const componentClass = this.componentClassMap['AppAdvanceHeaderComponent'];\n    this.CompRefs = this.viewContainerRef.createComponent(componentClass);\n    const dynamicComponentInstance = this.CompRefs.instance;\n    dynamicComponentInstance.selectedDates = selectedDates;\n    dynamicComponentInstance.filterItems = filterItems;\n    dynamicComponentInstance.contextFilterItems = context_filter;\n\n    dynamicComponentInstance.pageTitle = this.pageTitle;\n    dynamicComponentInstance.bread_crumbs_container = this.kpi_breadcrumbs_container;\n    dynamicComponentInstance.isEditButton = (userName && userName == \"admin\") ? true : false;\n    dynamicComponentInstance.isAdvanceButton = true;\n    dynamicComponentInstance.getFilterPageConfig.subscribe((value: string) => {\n      this.getFiltersForTemplate(value);\n    });\n    dynamicComponentInstance.getOperatorName.subscribe((value: string) => {\n      this.loadDataByOperator(value);\n    });\n    dynamicComponentInstance.getContextFilterData.subscribe((value: string) => {\n      this.getContextFilterData(value);\n    });\n\n    indexObj.compConfig.dynamicComponentRefs.push(this.CompRefs);\n    const cssClass = \"w-full\";\n    this.CompRefs.location.nativeElement.classList.add(cssClass);\n    containerElement.appendChild(this.CompRefs.location.nativeElement);\n  }\n  loadWidgetFilterComponent(indexObj, containerElement, filterItems, viewIds) {\n    let userName = localStorage.getItem('user_name')\n    let selectedDates = { startDate: this.defaultStartDate, endDate: this.defaultEndDate }\n    const componentClass = this.componentClassMap['AdvanceWidgetHeaderFilterComponent'];\n    this.CompRefs = this.viewContainerRef.createComponent(componentClass);\n    const dynamicComponentInstance = this.CompRefs.instance;\n    dynamicComponentInstance.selectedDates = selectedDates;\n    dynamicComponentInstance.filterItems = filterItems;\n    dynamicComponentInstance.viewIds = viewIds;\n\n    dynamicComponentInstance.getWidgetFilterConfig.subscribe((value: string) => {\n      this.getWidgetFilterForTemplate(value);\n    });\n\n    indexObj.compConfig.dynamicComponentRefs.push(this.CompRefs);\n    containerElement.appendChild(this.CompRefs.location.nativeElement);\n  }\n\n  // for context menu function\n  getContextClick(event) {\n    const stateData = Array.from(this.stateDataSource.keys());\n    const currentViewIndex = stateData.indexOf(event.viewId);\n    const deletedViewIds = [];\n    for (let i = currentViewIndex + 1; i < stateData.length; i++) {\n      deletedViewIds.push(stateData[i])\n    }\n    this.loadingModal = true;\n    this.dashBoardWidgetConfig.widgets.forEach(element => {\n      element.widgetNode.forEach((node: any, nodeIndex: number) => {\n        if (this.getElementOfCurrentView(node, event.drilldownTo)) {\n          let view = element.widgetNode[nodeIndex];\n          let apiCalls = [];\n          let appliedFilters = this.getSetOperatorFilter(event, this.stateDataSource.get(event.drilldownFrom));\n          view.compConfig.viewConfig.forEach(contentView => {\n            let found = (this.dataSetModal as any[]).find(d => d.datasetId === contentView.datasetId);\n            if (found) {\n              apiCalls.push(this.datasetService.getDataFromDataSet(found, contentView.datasetId, appliedFilters));\n            }\n          });\n          Promise.all(apiCalls).then(() => {\n            this.uniqueDataSetObject = this.datasetService.getUniqueDataSetObject();\n            for (let entry of deletedViewIds) {\n              element.widgetNode.forEach(viewValue => {\n                viewValue.compConfig.viewConfig.forEach(viewId => {\n                  if (viewId.viewId == entry) {\n                    const exists = this.contextMenuDataSource.some(item => item.viewId === viewId.viewId);\n                    if (!exists) {\n                      // If not exists, push the new object\n                      this.contextMenuDataSource.push({\n                        viewId: viewId.viewId,\n                        viewName: node.nodeProperties.widgetTitle,\n                        displayKey: viewId.kpiConfig.keyToPass\n                      });\n                    }\n                    const startData = this.stateDataSource.get(entry);\n                    if (startData) {\n                      this.stateDataSource.delete(entry)\n                    }\n                    viewValue.nodeProperties['display'] = false;\n                    const prefixedId = `id-${viewValue.id}`;\n                    const elementToHide = document.querySelector(`#${prefixedId}`) as HTMLElement; // Cast to HTMLElement\n                    if (elementToHide) {\n                      elementToHide.remove();\n                    }\n                  }\n                });\n              });\n            }\n\n            this.contextMenuDataSource = this.contextMenuDataSource.filter(e => e.displayKey !== event.keyToPass);\n            view.compConfig.viewConfig.forEach(val => {\n              let obj = {\n                \"filters\": appliedFilters,\n                \"keyToPass\": this.updateOperatorData(event.keyToPass, event.data),\n                \"drillDownType\": event.drillDownType,\n                \"drilldownFrom\": event.drilldownFrom,\n                \"widgetId\": element.widgetId\n              }\n              this.stateDataSource.set(val['viewId'], obj)\n\n            });\n            view.nodeProperties['display'] = true;\n            view.nodeProperties['widgetParams'] = event.tableTitle;\n            const prefixedId = `id-${view.id}`;\n            const containerElement = document.querySelector(`#${prefixedId}`) as HTMLElement;\n            this.loadSingleWidgetNode(view, this.mainPageDivElement, this.uniqueDataSetObject, element.widgetId);\n            setTimeout(() => {\n              this.scrollToBottom(this.mainPageDivElement, element.widgetId);\n            }, 200);\n\n\n            let navigation: NavigationExtras = {\n              queryParams: appliedFilters['operationFilter'],\n              queryParamsHandling: \"merge\"\n            };\n            this.router.navigate([], navigation);\n          });\n\n        } else {\n          // node.nodeProperties['display'] = false;\n        }\n      });\n    });\n  }\n  // for row click function\n  async getRowClick(event) {\n    const viewid_for_same = event.viewId;\n    const target = this.stateDataSource.get(viewid_for_same);\n    if (!target) {\n      console.warn('viewid not found in stateDataSource');\n      return;\n    }\n    const targetWidgetId = target.widgetId;\n    const matchingViewIds = Array.from(this.stateDataSource.entries())\n      .filter(([key, value]) => value.widgetId === targetWidgetId)\n      .map(([key]) => key);\n\n    console.log('Matching viewids:', targetWidgetId);\n\n    // const stateData = Array.from(this.stateDataSource.keys());\n    const currentViewIndex = matchingViewIds.indexOf(event.viewId);\n    const deletedViewIds = [];\n    for (let i = currentViewIndex + 1; i < matchingViewIds.length; i++) {\n      deletedViewIds.push(matchingViewIds[i]);\n    }\n    const hourlyNode = this.dashBoardWidgetConfig.widgets\n      .map(widget => widget.widgetNode.find(node => this.getHourlyData(node)))\n      .find(node => node);\n\n    if (hourlyNode && event.keyToPass.includes(\"recordDate\")) {\n      this.getViewByRowCLickForHourlyChart(event, hourlyNode);\n    }\n\n    const currentViewNode = this.dashBoardWidgetConfig.widgets\n      .map(widget => widget.widgetNode.find(node => this.getElementOfCurrentView(node, event.viewId)))\n      .find(node => node);\n\n\n\n    const queryParams = this.activatedRoute.snapshot.queryParamMap;\n    if (currentViewNode) {\n\n      const drildownsForCurrentView = [];\n      currentViewNode.compConfig.viewConfig.forEach(async element => {\n        if (element.kpiConfig.viewProperties.enableClickEvent) {\n          if (deletedViewIds && deletedViewIds.length !== 0) {\n            this.dashBoardWidgetConfig.widgets.forEach(element => {\n              for (let entry of deletedViewIds) {\n                element.widgetNode.forEach(viewValue => {\n                  viewValue.compConfig.viewConfig.forEach(viewId => {\n                    if (viewId.viewId == entry) {\n                      const exists = this.contextMenuDataSource.some(item => item.viewId === viewId.viewId);\n                      if (!exists) {\n                        this.contextMenuDataSource.push({\n                          viewId: viewId.viewId,\n                          viewName: currentViewNode.nodeProperties.widgetTitle,\n                          displayKey: viewId.kpiConfig.keyToPass\n                        });\n                      }\n                      const startData = this.stateDataSource.get(entry);\n                      if (startData) {\n                        this.stateDataSource.delete(entry)\n                      }\n                      viewValue.nodeProperties['display'] = false;\n                      const prefixedId = `id-${viewValue.id}`;\n                      const elementToHide = document.querySelector(`#${prefixedId}`) as HTMLElement; // Cast to HTMLElement\n                      if (elementToHide) {\n                        elementToHide.remove();\n                      }\n                    }\n                  });\n                });\n              }\n            });\n          }\n\n\n\n          if (element.kpiConfig.viewProperties.enableClickEvent) {\n            if (element.kpiConfig.viewProperties.clickEventOptions?.eventType !== undefined &&\n              element.kpiConfig.viewProperties.clickEventOptions.eventType !== \"\") {\n              let eventType = element.kpiConfig.viewProperties.clickEventOptions.eventType;\n              let associatedViews = element.kpiConfig.viewProperties.clickEventOptions.associatedViews;\n              if (eventType == 'optionalDrillDown') {\n                if (associatedViews && associatedViews.length != 0) {\n                  for (let viewForDrillDown of associatedViews) {\n                    const filterCondition = new URLSearchParams(viewForDrillDown['filterCondition']);\n                    let matchFound = true;\n                    filterCondition.forEach((value, key) => {\n                      if (queryParams.get(key) !== value) {\n                        matchFound = false;\n                      }\n                    });\n                    if (matchFound) {\n                      viewForDrillDown['viewId'].forEach(viewForId => {\n                        drildownsForCurrentView.push(viewForId);\n                      });\n\n                    }\n                  }\n                }\n\n              } else if (eventType == 'drilldown') {\n                for (let entry of associatedViews) {\n                  drildownsForCurrentView.push(entry);\n                }\n              } else if (eventType == 'sameViewDrilldown') {\n\n              }\n\n              if (drildownsForCurrentView.length != 0) {\n                for (let viewIdForNext of drildownsForCurrentView) {\n                  const nextViewNode = this.dashBoardWidgetConfig.widgets\n                    .map(widget => widget.widgetNode.find(node => this.getElementOfCurrentView(node, viewIdForNext)))\n                    .find(node => node);\n\n                  this.loadingModal = true;\n                  await this.getViewByRowCLick(event, nextViewNode, targetWidgetId);\n                }\n              }\n            } else {\n              const nextViewIndex = matchingViewIds.indexOf(event.viewId) + 1;\n\n              const matchingWidget = this.dashBoardWidgetConfig.widgets\n                .find(widget => widget.widgetId === targetWidgetId);\n\n              const nextView = matchingWidget?.widgetNode?.[nextViewIndex];\n\n              // const nextView = this.dashBoardWidgetConfig.widgets\n              //   .map(widget => widget.widgetNode[nextViewIndex])\n              //   .find(node => node);\n\n              if (nextView) {\n                this.loadingModal = true;\n                await this.getViewByRowCLick(event, nextView, targetWidgetId);\n              }\n            }\n\n          }\n          //  else {\n\n          //   const nextViewIndex = stateData.indexOf(event.viewId) + 1;\n          //   const nextView = this.dashBoardWidgetConfig.widgets\n          //     .map(widget => widget.widgetNode[nextViewIndex])\n          //     .find(node => node);\n\n          //   if (nextView) {\n          //     this.loadingModal = true;\n          //     await this.getViewByRowCLick(event, nextView);\n          //   }\n          // }\n\n\n\n        }\n      });\n\n\n      // for view group\n\n\n\n    }\n  }\n\n  getViewByRowCLickForHourlyChart(event, node) {\n\n    let apiCalls = [];\n    const deletedViewIds = [];\n    node.compConfig.viewConfig.forEach(item => {\n      let appliedFilters = this.getSetOperatorFilter(event, this.stateDataSource.get(item.viewId));\n      let found = (this.dataSetModal as any[]).find(d => d.datasetId === item.datasetId);\n      deletedViewIds.push(item.viewId);\n      if (found) {\n        apiCalls.push(this.datasetService.getDataFromDataSet(found, item.datasetId, appliedFilters));\n      }\n    });\n    Promise.all(apiCalls).then(() => {\n      this.uniqueDataSetObject = this.datasetService.getUniqueDataSetObject();\n      this.loadSingleWidgetNode(node, this.mainPageDivElement, this.uniqueDataSetObject, null);\n      setTimeout(() => {\n        this.scrollToBottom(this.mainPageDivElement, null);\n      }, 200);\n\n    });\n    // }\n    console.log(this.stateDataSource);\n  }\n\n  async getViewByRowCLick(event, view, targetWidgetId) {\n\n    let apiCalls = [];\n    let appliedFilters = this.getSetOperatorFilter(event, this.stateDataSource.get(event.viewId));\n    view.compConfig.viewConfig.forEach(contentView => {\n      let found = (this.dataSetModal as any[]).find(d => d.datasetId === contentView.datasetId);\n      if (found) {\n        apiCalls.push(this.datasetService.getDataFromDataSet(found, contentView.datasetId, appliedFilters));\n      }\n    });\n    await Promise.all(apiCalls)\n\n    this.contextMenuDataSource = this.contextMenuDataSource.filter(e => e.displayKey !== event.keyToPass);\n    view.compConfig.viewConfig.forEach(viewforDataSet => {\n\n      let obj = {\n        \"filters\": appliedFilters,\n        \"keyToPass\": this.updateOperatorData(event.keyToPass, event.data),\n        \"drillDownType\": event.drillDownType,\n        \"drilldownFrom\": event.drilldownFrom,\n        \"widgetId\": targetWidgetId\n      }\n      this.stateDataSource.set(viewforDataSet['viewId'], obj)\n    });\n    view.nodeProperties['display'] = true;\n    view.nodeProperties['widgetParams'] = event.tableTitle;\n    const prefixedId = `id-${view.id}`;\n    const containerElement = document.querySelector(`#${prefixedId}`) as HTMLElement;\n    this.uniqueDataSetObject = this.datasetService.getUniqueDataSetObject();\n    // this.loadSingleWidgetNode(view, this.mainPageDivElement, this.uniqueDataSetObject);\n    this.loadSingleWidgetNode(view, this.mainPageDivElement, this.uniqueDataSetObject, targetWidgetId);\n    setTimeout(() => {\n      this.scrollToBottom(this.mainPageDivElement, targetWidgetId);\n    }, 200);\n    let navigation: NavigationExtras = {\n      queryParams: appliedFilters['operationFilter'],\n      queryParamsHandling: \"merge\"\n    };\n    this.router.navigate([], navigation);\n    // });\n    // }\n    console.log(this.stateDataSource);\n  }\n\n  scrollToBottom(container: any, widgetId) {\n\n    if (widgetId) {\n      let containerElement = container.get(widgetId)\n      setTimeout(() => {\n        containerElement.scrollIntoView({ block: 'end' });\n        this.loadingModal = false;\n      }, 0);\n    } else {\n      setTimeout(() => {\n        container.scrollIntoView({ block: 'end' });\n        this.loadingModal = false;\n      }, 0);\n    }\n\n  }\n\n  findWidgetById(configs: any[], id: string): any | undefined {\n    for (const config of configs) {\n      if (config.id === id) {\n        return config;\n      }\n      if (config.widgetNode && config.widgetNode.length > 0) {\n        const found = this.findWidgetById(config.widgetNode, id);\n        if (found) {\n          return found;\n        }\n      }\n    }\n    return undefined;\n  }\n\n  updateOperatorData(key_name: string[], value_data: any): any {\n    let operator = [];\n    for (const key of key_name) {\n      let obj: any = {};\n      obj[key] = value_data[key];\n      operator.push(obj)\n    }\n    return operator;\n  }\n\n\n  getElementOfCurrentView(node, viewId) {\n    const matchedObject = node.compConfig.viewConfig.find(object => object.viewId === viewId);\n    return matchedObject ? node : null;\n  }\n  getHourlyData(node) {\n    const matchedObject = node.compConfig.viewConfig.find(object => object.kpiConfig.formate === 'hourly');\n    return matchedObject ? node : null;\n  }\n\n  getSetOperatorFilter(objectData, previousViewStates) {\n\n    const { data, keyToPass } = objectData;\n    const appliedFilter = JSON.parse(JSON.stringify(previousViewStates.filters.operationFilter));\n\n    keyToPass.forEach(key => {\n      if (key in data) {\n        const normalizedKey = key.toLowerCase().replace(/_/g, '');\n        if (normalizedKey === \"recorddate\" && \"startDate\" in appliedFilter && \"endDate\" in appliedFilter) {\n          appliedFilter.startDate = data[key];\n          appliedFilter.endDate = data[key];\n        } else {\n          appliedFilter[key] = data[key];\n        }\n      }\n    });\n    const defaultoperationFilter = this.globalDefaultFilter.operationFilter;\n    if (defaultoperationFilter) {\n      Object.keys(defaultoperationFilter).forEach(key => {\n        if (!appliedFilter.hasOwnProperty(key)) {\n          appliedFilter[key] = defaultoperationFilter[key];\n        }\n      });\n    }\n\n    const operationFilter = {};\n    operationFilter['operationFilter'] = appliedFilter;\n    return operationFilter;\n  }\n\n\n  getRearchResultFromInputBox(inputValue, viewConfig, filterObject) {\n    let view = viewConfig;\n    let eventNode = { data: {}, keyToPass: [] }\n    eventNode.data[filterObject.server_column] = inputValue;\n    eventNode['keyToPass'] = [filterObject.server_column];\n    let apiCalls = [];\n\n    view.compConfig.viewConfig.forEach(contentView => {\n      let appliedFilters = this.getSetOperatorFilter(eventNode, this.stateDataSource.get(contentView.viewId));\n      let found = (this.dataSetModal as any[]).find(d => d.datasetId === contentView.datasetId);\n      if (found) {\n        apiCalls.push(this.datasetService.getDataFromDataSet(found, contentView.datasetId, appliedFilters));\n      }\n    });\n    viewConfig.nodeProperties['display'] = false;\n    const prefixedId = `id-${viewConfig.id}`;\n    const elementToHide = document.querySelector(`#${prefixedId}`) as HTMLElement; // Cast to HTMLElement\n    if (elementToHide) {\n      elementToHide.remove();\n    }\n\n    Promise.all(apiCalls).then(() => {\n      this.uniqueDataSetObject = this.datasetService.getUniqueDataSetObject();\n\n      this.loadingModal = true;\n      this.contextMenuDataSource = this.contextMenuDataSource.filter(e => e.displayKey !== viewConfig.keyToPass);\n\n      view.nodeProperties['display'] = true;\n      // view.nodeProperties['widgetParams'] = event.tableTitle;\n      const prefixedId = `id-${view.id}`;\n      const containerElement = document.querySelector(`#${prefixedId}`) as HTMLElement;\n      this.loadSingleWidgetNode(view, this.mainPageDivElement, this.uniqueDataSetObject, null);\n      setTimeout(() => {\n        this.scrollToBottom(this.mainPageDivElement, null);\n      }, 200);\n      let params = {};\n      params[filterObject.server_column] = inputValue;\n      let navigation: NavigationExtras = {\n        queryParams: params,\n        queryParamsHandling: \"merge\"\n      };\n      this.router.navigate([], navigation);\n    });\n  }\n\n\n  submitFilter() {\n    let view = this.nodeproperticeFilterDataSource.viewConfig;\n    // let cal_value = (parseFloat(searchTerm) / 100)\n    let apiCalls = [];\n    this.havingDataObject = this.nodeproperticeFilterDataSource.havingConfig.filter(value => value.value !== \"\");\n    view.compConfig.viewConfig.forEach(contentView => {\n      let appliedFilters = this.stateDataSource.get(contentView.viewId);\n      let found = (this.dataSetModal as any[]).find(d => d.datasetId === contentView.datasetId);\n      if (found) {\n        apiCalls.push(this.datasetService.getDataFromDataSet(found, contentView.datasetId, appliedFilters.filters));\n      }\n    });\n    Promise.all(apiCalls).then(() => {\n      this.uniqueDataSetObject = this.datasetService.getUniqueDataSetObject();\n\n      this.nodeproperticeFilterDataSource.viewConfig.nodeProperties['display'] = false;\n      const prefixedId = `id-${this.nodeproperticeFilterDataSource.viewConfig.id}`;\n      const elementToHide = document.querySelector(`#${prefixedId}`) as HTMLElement; // Cast to HTMLElement\n      if (elementToHide) {\n        elementToHide.remove();\n      }\n\n      this.loadingModal = true;\n      this.contextMenuDataSource = this.contextMenuDataSource.filter(e => e.displayKey !== this.nodeproperticeFilterDataSource.viewConfig.keyToPass);\n      this.isWidgetFilters = false;\n      view.nodeProperties['display'] = true;\n      // view.nodeProperties['widgetParams'] = event.tableTitle;\n      // const prefixedId = `id-${view.id}`;\n      // const containerElement = document.querySelector(`#${prefixedId}`) as HTMLElement;\n      this.loadSingleWidgetNode(view, this.mainPageDivElement, this.uniqueDataSetObject, null);\n      setTimeout(() => {\n        this.scrollToBottom(this.mainPageDivElement, null);\n      }, 200);\n    });\n  }\n\n\n  getWidgetFilterForTemplate(value) {\n    let apiCalls = [];\n    const deletedViewIds = [];\n    value.viewNodes.compConfig.viewConfig.forEach(item => {\n      let widgetFilter = this.stateDataSource.get(item.viewId);\n      let appliedFilters = widgetFilter.filters;\n      let found = (this.dataSetModal as any[]).find(d => d.datasetId === item.datasetId);\n      deletedViewIds.push(item.viewId);\n      const having = Object.entries(value.operationFilter).map(([key, value]) => ({\n        columnName: key,\n        dataType: \"float\",\n        operator: \"gte\",\n        value: value\n      }));\n\n      if (found) {\n        found.config.queryConfig['havings'] = having;\n        apiCalls.push(this.datasetService.getDataFromDataSet(found, item.datasetId, appliedFilters));\n      }\n    });\n    Promise.all(apiCalls).then(() => {\n      this.uniqueDataSetObject = this.datasetService.getUniqueDataSetObject();\n      // value.viewNodes.nodeProperties['widgetParams'] = event.tableTitle;\n      this.loadSingleWidgetNode(value.viewNodes, this.mainPageDivElement, this.uniqueDataSetObject, null);\n      setTimeout(() => {\n        this.scrollToBottom(this.mainPageDivElement, null);\n      }, 200);\n\n    });\n    // }\n  }\n\n  async loadDataByOperator(opName) {\n    console.log(opName)\n    let filter = { operationFilter: { startDate: \"\", endDate: \"\", operator_key: \"\" } };\n    filter.operationFilter['startDate'] = this.defaultStartDate;\n    filter.operationFilter['endDate'] = this.defaultEndDate;\n    filter.operationFilter['operator_key'] = opName;\n    this.loadingModal = true;\n\n    let navigation: NavigationExtras = {\n      queryParams: {\n        \"operatorName\": opName\n      },\n      queryParamsHandling: \"merge\"\n    };\n    this.router.navigate([], navigation);\n\n    // this.dashBoardWidgetConfig = [];\n    await this.getPadeDataSource(true);\n    this.uniqueDataSetObject = {};\n    let apiCalls = [];\n\n    this.allWidgetByDataset.forEach(view => {\n      view.datasetIds.forEach(id => {\n        let found = (this.dataSetModal as any[]).find(d => d.datasetId === id);\n        if (found) {\n          apiCalls.push(this.datasetService.getDataFromDataSet(found, id, filter));\n        }\n      });\n    });\n\n    Promise.all(apiCalls).then(() => {\n      this.globalDefaultFilter = filter;\n      this.uniqueDataSetObject = this.datasetService.getUniqueDataSetObject();\n      this.createDivElements(this.uniqueDataSetObject, true);\n      this.loadingModal = false;\n    });\n\n  }\n\n  async getContextFilterData(value) {\n\n    let filter = { operationFilter: { startDate: \"\", endDate: \"\" } };\n    filter.operationFilter['startDate'] = this.defaultStartDate;\n    filter.operationFilter['endDate'] = this.defaultEndDate;\n    filter.operationFilter[value.operatorName] = this.parseInput(value.defaultFilterValue);\n    this.loadingModal = true;\n    let obj = {};\n    obj[value.operatorName] = value.defaultFilterValue;\n    let navigation: NavigationExtras = {\n      queryParams: obj,\n      queryParamsHandling: \"merge\"\n    };\n    this.router.navigate([], navigation);\n\n    // this.dashBoardWidgetConfig = [];\n    await this.getPadeDataSource(true);\n    this.uniqueDataSetObject = {};\n    let apiCalls = [];\n\n    this.allWidgetByDataset.forEach(view => {\n      view.datasetIds.forEach(id => {\n        let found = (this.dataSetModal as any[]).find(d => d.datasetId === id);\n        if (found) {\n          apiCalls.push(this.datasetService.getDataFromDataSet(found, id, filter));\n        }\n      });\n    });\n\n    Promise.all(apiCalls).then(() => {\n      this.globalDefaultFilter = filter;\n      this.uniqueDataSetObject = this.datasetService.getUniqueDataSetObject();\n      this.createDivElements(this.uniqueDataSetObject, true);\n      this.loadingModal = false;\n    });\n  }\n\n  parseInput(input) {\n    input = input.trim();\n\n    if (input.includes(',')) {\n      return input.split(',').map(item => item.trim());\n    } else {\n      return input;\n    }\n  }\n\n\n}\n","<app-loading *ngIf=\"loadingModal\"></app-loading>\n\n<div class=\"w-full\">\n    <div class=\"flex flex-wrap \" #dynamicContainer></div>\n</div>\n\n<dx-popup [(visible)]=\"isWidgetFilters\" [closeOnOutsideClick]=\"false\" [dragEnabled]=\"false\" [width]=\"800\" [height]=\"400\"\n    [showTitle]=\"true\" class=\"popup\" title=\"Dataset Filter\">\n    <div *dxTemplate=\"let data of 'content'\">\n        <div class=\"my-2\">\n            <dx-scroll-view [width]=\"'100%'\" [height]=\"'85%'\">\n                <ng-container *ngFor=\"let item of nodeproperticeFilterDataSource.havingConfig; let i = index\">\n                    <div class=\"flex flex-row my-2\">\n                        <div class=\"m-1\">\n                            <dx-text-box [(ngModel)]=\"item.columnName\"></dx-text-box>\n                        </div>\n                        <div class=\"m-1\">\n                            <dx-select-box [items]=\"['get','let']\" [(ngModel)]=\"item.operator\"\n                                placeholder=\"Operator\"></dx-select-box>\n                        </div>\n                        <div class=\"m-1\">\n                            <dx-text-box [(ngModel)]=\"item.value\"></dx-text-box>\n                        </div>\n                    </div>\n                </ng-container>\n\n            </dx-scroll-view>\n            <div class=\"flex justify-end mx-1 flex-grow border-t\">\n                <button class=\"{{commonService.btn_success_md}} cursor-pointer mt-2\"\n                    (click)=\"submitFilter()\">Submit</button>\n            </div>\n\n        </div>\n\n    </div>\n</dx-popup>\n\n\n\n"]}