gamma-app-controller 1.1.25 → 1.1.27

package/esm2020/lib/template-module/kpiWithMultiLayout/kpiWithMultiayout.module.mjs

@@ -0,0 +1,154 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { DevExtremeModule, DxAccordionModule, DxButtonModule, DxCheckBoxModule, DxDataGridModule, DxDropDownBoxModule, DxFormModule, DxHtmlEditorModule, DxNumberBoxModule, DxPopupModule, DxSelectBoxModule, DxTagBoxModule, DxTextBoxModule, DxTreeViewModule, DxBulletModule, DxChartModule, DxDateBoxModule, DxLoadPanelModule, DxLookupModule, DxPivotGridModule, DxTemplateModule, DxTextAreaModule, DxValidationSummaryModule, DxValidatorModule, DxCalendarModule, DxTooltipModule, DxContextMenuModule, DxLoadIndicatorModule, DxPieChartModule, DxScrollViewModule } from "devextreme-angular";
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { MatButtonModule } from '@angular/material/button';
+import { MatDividerModule } from '@angular/material/divider';
+import { MatMenuModule } from '@angular/material/menu';
+import { MatIconModule } from '@angular/material/icon';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { LoadingModule } from '../../shared/loading/loadingModule';
+import { DynamicWidgetForMultilayoutComponent } from './dynamin-modal-multi.component';
+import { KpiWithMultilayoutSetTestComponent } from './kpi-with-multilayout.component';
+import * as i0 from "@angular/core";
+export class KpiWithMultiLayoutModule {
+}
+KpiWithMultiLayoutModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: KpiWithMultiLayoutModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+KpiWithMultiLayoutModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: KpiWithMultiLayoutModule, declarations: [KpiWithMultilayoutSetTestComponent,
+        DynamicWidgetForMultilayoutComponent], imports: [CommonModule,
+        LoadingModule,
+        CommonModule,
+        DevExtremeModule,
+        DxButtonModule,
+        DxCheckBoxModule,
+        DxNumberBoxModule,
+        DxDataGridModule,
+        DxDropDownBoxModule,
+        DxTreeViewModule,
+        DxScrollViewModule,
+        DxFormModule,
+        DxAccordionModule,
+        FormsModule,
+        DxTagBoxModule,
+        ReactiveFormsModule,
+        MatIconModule,
+        DxHtmlEditorModule,
+        DxBulletModule,
+        DxChartModule,
+        DxDateBoxModule,
+        DxLoadPanelModule,
+        DxLookupModule,
+        DxPivotGridModule,
+        DxTemplateModule,
+        DxTextAreaModule,
+        DxValidationSummaryModule,
+        DxValidatorModule,
+        DxCalendarModule,
+        DxTooltipModule,
+        DxContextMenuModule,
+        DxLoadIndicatorModule,
+        DxPieChartModule,
+        MatTooltipModule,
+        DxPopupModule, DxSelectBoxModule, DxTextBoxModule, DxTreeViewModule,
+        MatButtonModule,
+        MatDividerModule,
+        MatMenuModule,
+        MatIconModule,
+        LoadingModule], exports: [KpiWithMultilayoutSetTestComponent,
+        DynamicWidgetForMultilayoutComponent] });
+KpiWithMultiLayoutModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: KpiWithMultiLayoutModule, imports: [CommonModule,
+        LoadingModule,
+        CommonModule,
+        DevExtremeModule,
+        DxButtonModule,
+        DxCheckBoxModule,
+        DxNumberBoxModule,
+        DxDataGridModule,
+        DxDropDownBoxModule,
+        DxTreeViewModule,
+        DxScrollViewModule,
+        DxFormModule,
+        DxAccordionModule,
+        FormsModule,
+        DxTagBoxModule,
+        ReactiveFormsModule,
+        MatIconModule,
+        DxHtmlEditorModule,
+        DxBulletModule,
+        DxChartModule,
+        DxDateBoxModule,
+        DxLoadPanelModule,
+        DxLookupModule,
+        DxPivotGridModule,
+        DxTemplateModule,
+        DxTextAreaModule,
+        DxValidationSummaryModule,
+        DxValidatorModule,
+        DxCalendarModule,
+        DxTooltipModule,
+        DxContextMenuModule,
+        DxLoadIndicatorModule,
+        DxPieChartModule,
+        MatTooltipModule,
+        DxPopupModule, DxSelectBoxModule, DxTextBoxModule, DxTreeViewModule,
+        MatButtonModule,
+        MatDividerModule,
+        MatMenuModule,
+        MatIconModule,
+        LoadingModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: KpiWithMultiLayoutModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        KpiWithMultilayoutSetTestComponent,
+                        DynamicWidgetForMultilayoutComponent
+                    ],
+                    imports: [CommonModule,
+                        LoadingModule,
+                        CommonModule,
+                        DevExtremeModule,
+                        DxButtonModule,
+                        DxCheckBoxModule,
+                        DxNumberBoxModule,
+                        DxDataGridModule,
+                        DxDropDownBoxModule,
+                        DxTreeViewModule,
+                        DxScrollViewModule,
+                        DxFormModule,
+                        DxAccordionModule,
+                        FormsModule,
+                        DxTagBoxModule,
+                        ReactiveFormsModule,
+                        MatIconModule,
+                        DxHtmlEditorModule,
+                        DxBulletModule,
+                        DxChartModule,
+                        DxDateBoxModule,
+                        DxLoadPanelModule,
+                        DxLookupModule,
+                        DxPivotGridModule,
+                        DxTemplateModule,
+                        DxTextAreaModule,
+                        DxValidationSummaryModule,
+                        DxValidatorModule,
+                        DxCalendarModule,
+                        DxTooltipModule,
+                        DxContextMenuModule,
+                        DxLoadIndicatorModule,
+                        DxPieChartModule,
+                        MatTooltipModule,
+                        DxPopupModule, DxSelectBoxModule, DxTextBoxModule, DxTreeViewModule,
+                        MatButtonModule,
+                        MatDividerModule,
+                        MatMenuModule,
+                        MatIconModule,
+                        LoadingModule,
+                    ],
+                    exports: [
+                        KpiWithMultilayoutSetTestComponent,
+                        DynamicWidgetForMultilayoutComponent
+                    ],
+                    providers: [],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/template-module/kpiWithSingleLayout/dynamin-modal.component.mjs

@@ -0,0 +1,180 @@
+import { Component, Input, ViewChild } from '@angular/core';
+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";
+export class DynamicWidgetComponent {
+    constructor(viewContainerRef) {
+        this.viewContainerRef = viewContainerRef;
+        this.dynamicComponentRefs = [];
+        this.componentClassMap = {
+            GammaAdvanceChartComponent,
+            GammaTodayPreviousComponent,
+            AppAdvanceHeaderComponent,
+            GammaTableWithPercentageComponent,
+            GammSingleNumberCardComponent,
+            GammaAdvanceOperatorTableComponent,
+            AdvanceWidgetHeaderFilterComponent,
+            GammaGeoChartComponent,
+            GammaHeatChartComponent
+        };
+    }
+    set modalConfigs(value) {
+        if (value) {
+            const item = value.view;
+            const containerElement = this.popupContainer.nativeElement;
+            this.uniqueDataSetObject = value['datasource'];
+            const elementId = `id-${item.id}`;
+            if (item.nodeProperties.display) {
+                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);
+                ;
+                widgetDiv.innerText = item.nodeProperties.widgetParams || '';
+                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'] = value['datasource'][element.datasetId];
+                    element.kpiConfig['contextMenu'] = this.contextMenuDataSource;
+                    element['titleParams'] = item.nodeProperties.widgetParams || "";
+                    this.loadDynamicComponent(element, itemDiv);
+                });
+                containerElement.appendChild(itemDiv);
+                itemDiv.appendChild(innerDiv);
+            }
+        }
+    }
+    ngOnInit() {
+    }
+    loadDynamicComponent(data, 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 = "";
+        const cssClass = "w-full";
+        this.CompRefs.location.nativeElement.classList.add(cssClass);
+        containerElement.appendChild(this.CompRefs.location.nativeElement);
+    }
+    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', 'relative');
+        const titleDiv = document.createElement('div');
+        titleDiv.classList.add('relative', 'group');
+        const params = item.nodeProperties.widgetParams || "";
+        const widgetTitle = item.nodeProperties.widgetTitle;
+        const tooltipMatch = widgetTitle.match(/\$t\{([\s\S]*?)\}/);
+        const displayTitle = widgetTitle.replace(/\$t\{[\s\S]*?\}/g, '').trim();
+        titleDiv.innerText = displayTitle + params;
+        if (tooltipMatch) {
+            const tooltipContent = tooltipMatch[1].trim();
+            const tooltipDiv = document.createElement('div');
+            tooltipDiv.classList.add('absolute', 'left-0', 'bottom-full', 'mb-2', 'w-max', 'max-w-xs', 'bg-black', 'text-white', 'text-sm', 'p-2', 'rounded-lg', 'shadow-lg', 'opacity-0', 'group-hover:opacity-100', 'transition-opacity', 'duration-300', 'z-50');
+            tooltipDiv.innerHTML = tooltipContent;
+            titleDiv.appendChild(tooltipDiv);
+        }
+        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'] = [];
+        }
+        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 = '|';
+                    filterDiv.appendChild(textBox);
+                    filterDiv.appendChild(searchButton);
+                    filterDiv.appendChild(separerotButton);
+                }
+                searchContainerDiv.appendChild(filterDiv);
+            });
+        }
+        widgetDiv.appendChild(searchContainerDiv);
+        return widgetDiv;
+    }
+    loadWidgetFilterComponent(indexObj, containerElement, filterItems, viewIds) {
+        let userName = localStorage.getItem('user_name');
+        const componentClass = this.componentClassMap['AdvanceWidgetHeaderFilterComponent'];
+        this.CompRefs = this.viewContainerRef.createComponent(componentClass);
+        const dynamicComponentInstance = this.CompRefs.instance;
+        dynamicComponentInstance.selectedDates = {};
+        dynamicComponentInstance.filterItems = filterItems;
+        dynamicComponentInstance.viewIds = viewIds;
+        indexObj.compConfig.dynamicComponentRefs.push(this.CompRefs);
+        containerElement.appendChild(this.CompRefs.location.nativeElement);
+    }
+}
+DynamicWidgetComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: DynamicWidgetComponent, deps: [{ token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Component });
+DynamicWidgetComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: DynamicWidgetComponent, selector: "app-dynamic-widget", inputs: { view: "view", datasetById: "datasetById", contextMenuDataSource: "contextMenuDataSource", modalConfigs: "modalConfigs" }, viewQueries: [{ propertyName: "popupContainer", first: true, predicate: ["popupContainer"], descendants: true, static: true }], ngImport: i0, template: `<div #popupContainer></div>`, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: DynamicWidgetComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'app-dynamic-widget',
+                    template: `<div #popupContainer></div>`,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }]; }, propDecorators: { popupContainer: [{
+                type: ViewChild,
+                args: ['popupContainer', { static: true }]
+            }], view: [{
+                type: Input
+            }], datasetById: [{
+                type: Input
+            }], contextMenuDataSource: [{
+                type: Input
+            }], modalConfigs: [{
+                type: Input,
+                args: ['modalConfigs']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamin-modal.component.js","sourceRoot":"","sources":["../../../../../../projects/gamma-app-controller/src/lib/template-module/kpiWithSingleLayout/dynamin-modal.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnInit, ViewChild, ElementRef, ComponentRef, ViewContainerRef } from '@angular/core';\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@Component({\n    selector: 'app-dynamic-widget',\n    template: `<div #popupContainer></div>`,\n})\nexport class DynamicWidgetComponent implements OnInit {\n    @ViewChild('popupContainer', { static: true }) popupContainer!: ElementRef;\n    @Input() view: any;\n    @Input() datasetById: any;\n    @Input() contextMenuDataSource: any;\nisWidgetFilters:boolean;\n    dynamicComponentRefs: ComponentRef<any>[] = [];\n    nodeproperticeFilterDataSource:any;\n    uniqueDataSetObject: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\n    @Input('modalConfigs')\n    set modalConfigs(value) {\n        if (value) {\n            const item = value.view;\n            const containerElement = this.popupContainer.nativeElement;\n            this.uniqueDataSetObject = value['datasource'];\n            const elementId = `id-${item.id}`;\n            // const existingElement = document.querySelector(`#${elementId}`);\n            if (item.nodeProperties.display) {\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\n                const widgetDiv = this.getWidgetTitleDiv(item);;\n                widgetDiv.innerText = item.nodeProperties.widgetParams || ''; \n                itemDiv.appendChild(widgetDiv);\n\n                const innerDiv = document.createElement('div');\n                innerDiv.classList.add('rounded', 'justify-center', 'items-center', 'border', 'p-1', 'm-1', 'flex', 'flex-row');\n\n                item.compConfig.viewConfig.forEach(element => {\n                    element.kpiConfig['dataSource'] = value['datasource'][element.datasetId];\n                    element.kpiConfig['contextMenu'] = this.contextMenuDataSource;\n                    element['titleParams'] = item.nodeProperties.widgetParams || \"\";\n                    // loadDynamicComponent here if it's accessible \n                     this.loadDynamicComponent(element, itemDiv);\n                });\n\n                containerElement.appendChild(itemDiv);\n                itemDiv.appendChild(innerDiv);\n            }\n        }\n        \n    }\n\n    constructor(    private viewContainerRef: ViewContainerRef) { }\n\n    ngOnInit(): void {\n        // this.loadWidgetNode();\n    }\n\n  loadDynamicComponent(data, 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    // } else if (data.kpiConfig.componentName == \"GammaAdvanceChartComponent\") {\n\n    //   dynamicComponentInstance.onChartPointClick.subscribe((value: string) => {\n    //     this.getRowClick(value);\n    //   });\n    // }\n    const cssClass = \"w-full\";\n    this.CompRefs.location.nativeElement.classList.add(cssClass);\n    containerElement.appendChild(this.CompRefs.location.nativeElement);\n  }\n   \n\n\n\ngetWidgetTitleDiv(item) {\n    const widgetDiv = document.createElement('div');\n    widgetDiv.classList.add(\n      'flex', 'items-center', 'justify-between', 'font-bold', 'text-md',\n      'text-gray-900', 'dark:text-white', 'border-b', 'p-3', 'bg-gray-800',\n      'mx-2', 'rounded-t-lg', 'relative'\n    );\n\n    const titleDiv = document.createElement('div');\n    titleDiv.classList.add('relative', 'group');\n\n    const params = item.nodeProperties.widgetParams || \"\";\n\n    const widgetTitle = item.nodeProperties.widgetTitle;\n    const tooltipMatch = widgetTitle.match(/\\$t\\{([\\s\\S]*?)\\}/);\n\n    const displayTitle = widgetTitle.replace(/\\$t\\{[\\s\\S]*?\\}/g, '').trim();\n\n    titleDiv.innerText = displayTitle + params;\n\n    if (tooltipMatch) {\n      const tooltipContent = tooltipMatch[1].trim();\n      const tooltipDiv = document.createElement('div');\n      tooltipDiv.classList.add(\n        'absolute', 'left-0', 'bottom-full', 'mb-2', 'w-max', 'max-w-xs',\n        'bg-black', 'text-white', 'text-sm', 'p-2', 'rounded-lg', 'shadow-lg',\n        'opacity-0', 'group-hover:opacity-100', 'transition-opacity', 'duration-300',\n        'z-50'\n      );\n      tooltipDiv.innerHTML = tooltipContent;\n\n      titleDiv.appendChild(tooltipDiv);\n    }\n\n    widgetDiv.appendChild(titleDiv);\n\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  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 = {};\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}"]}