gamma-app-controller 1.1.25 → 1.1.27

package/esm2020/lib/shared/advanced-component/gamma-heatmap/gamma-heatmap.component.mjs

@@ -0,0 +1,334 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import moment from '../../../application-controller/moment-helper';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../application-controller/common";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/tooltip";
+import * as i4 from "../../loader/loader.component";
+export class GammaHeatChartComponent {
+    constructor(commonService) {
+        this.commonService = commonService;
+        this.dataSourseForTable = [];
+        this.isLoader = true;
+        this.tableDataConfig = {};
+        this.enrichNameList = ["formatBytes", "formatBytsToKb", "formatBytsToGb", "reformatNumberWithThousandSeparatorV3", "formatBytesv2"];
+        this.activeTab = 'basic';
+        this.isAdvanceFilter = false;
+        this.isHeatMapClick = false;
+        this.heatChartDataSource = {};
+        this.chartDataForTooltip = {};
+        this.dataSourseForHeatMap = [];
+        this.viewProperties = {
+            enableClickEvent: false,
+            enableRightClickEvent: true,
+            clickEventOptions: {
+                associatedViews: [],
+                eventType: ""
+            }
+        };
+        this.optionalDrilDownDataSource = [];
+        this.allConfiguredViews = [];
+        this.colorArray = [];
+        this.firstColor = "rgba(45, 110, 18, 1)";
+        this.secondColor = "rgba(255, 204, 0, 1)";
+        this.singleColor = "rgba(255, 204, 0, 1)";
+        this.heatmapChartConfig = {};
+        this.getTableConfigOutPut = new EventEmitter();
+        this.oRowClick = new EventEmitter();
+        this.onrightClickContextSelection = new EventEmitter();
+        this.rightClickEnable = true;
+    }
+    set chartDataSource(value) {
+        if (value === undefined || value.length === 0) {
+            return;
+        }
+        else {
+            this.isLoader = true;
+            this.page_config = value;
+            this.page_parms = value.titleParams;
+            if (value.kpiConfig.dataSource && value.kpiConfig.dataSource.length !== 0) {
+                this.heatmapChartConfig = value.kpiConfig.dataConfig;
+                this.colorArray = value.kpiConfig.dataConfig.color;
+                this.getHeatmapData(value.kpiConfig.dataSource);
+                setTimeout(() => {
+                    this.isLoader = false;
+                }, 200);
+            }
+            else {
+                setTimeout(() => {
+                    this.dataSourseForTable = [];
+                    this.tableDataConfig['columns'] = [];
+                    this.isLoader = false;
+                }, 200);
+            }
+        }
+    }
+    ngOnInit() {
+    }
+    getHeatmapData(heatMapData) {
+        debugger;
+        this.heatChartDataSource = {};
+        this.isAdvanceFilter = false;
+        if (heatMapData && heatMapData.length !== 0) {
+            if (this.heatmapChartConfig.chartFormat == "topx") {
+                const { result, uniqueDates } = this.generateDateWiseColorCodedData(heatMapData);
+                this.heatChartDataSource.dataSet = this.getTransposedHeatmapData(result);
+                this.heatChartDataSource["argumentValue"] = uniqueDates;
+            }
+            else if ((this.heatmapChartConfig.chartFormat == "simple")) {
+                const { result, uniqueDates } = this.generateData(heatMapData);
+                this.heatChartDataSource["dataSet"] = result;
+                this.heatChartDataSource["argumentValue"] = uniqueDates;
+            }
+            this.isHeatMapClick = false;
+        }
+        else {
+            this.isHeatMapClick = false;
+        }
+    }
+    getTransposedHeatmapData(dataSet) {
+        const transposed = [];
+        const maxBoxes = Math.max(...dataSet.map(item => item.dataset.length));
+        for (let i = 0; i < maxBoxes; i++) {
+            const row = [];
+            for (let j = 0; j < dataSet.length; j++) {
+                const box = dataSet[j].dataset[i];
+                row.push({
+                    box: box || null,
+                    date: dataSet[j].record_date
+                });
+            }
+            transposed.push(row);
+        }
+        return transposed;
+    }
+    generateDateWiseColorCodedData(data) {
+        const result = [];
+        const uniqueDates = new Set();
+        const allEntries = [];
+        const topArg = this.heatmapChartConfig.topArgument;
+        const leftArg = this.heatmapChartConfig.leftArgument;
+        const valueField = this.heatmapChartConfig.columns[0].dataField;
+        data.forEach(entry => {
+            const formattedDate = (moment(entry[topArg]).format('YYYY-MM-DD')) ? moment(entry[topArg]).format('YYYY-MM-DD') : topArg;
+            uniqueDates.add(formattedDate);
+            entry.resultDataset.forEach(item => {
+                allEntries.push({
+                    [topArg]: formattedDate,
+                    [leftArg]: item[`${leftArg}`],
+                    [valueField]: item[`${valueField}`]
+                });
+            });
+        });
+        let coloredData;
+        if (this.heatmapChartConfig.type === 'gradient') {
+            coloredData = this.getFormateDataByColorCodeForGradient(allEntries, valueField);
+        }
+        else if (this.heatmapChartConfig.type === 'twoColor') {
+            coloredData = this.getFormateDataByColorCodeForWithTwoColor(allEntries, valueField);
+        }
+        else {
+            coloredData = this.getFormateDataByColorCodeForWithSingleColor(allEntries, valueField);
+        }
+        const dateMap = {};
+        coloredData.forEach(item => {
+            const date = item[topArg];
+            if (!dateMap[date]) {
+                dateMap[date] = [];
+            }
+            let toolTip = `Record Date : ${item[topArg]} \n${this.commonService.convertString(valueField)} : ${this.commonService.ThousandSeparatorWithTwoDecimals(item[valueField])}`;
+            dateMap[date].push({
+                [leftArg]: item[leftArg],
+                [valueField]: item[valueField],
+                color: item.color,
+                toolTip: toolTip,
+                [topArg]: date,
+            });
+        });
+        const sortedDates = Array.from(uniqueDates).sort((a, b) => moment(b).diff(moment(a)));
+        for (const date of sortedDates) {
+            result.push({
+                record_date: date,
+                dataset: dateMap[date] || []
+            });
+        }
+        return {
+            result,
+            uniqueDates: sortedDates
+        };
+    }
+    generateData(data) {
+        const result = [];
+        const uniqueDates = new Set();
+        const dataSourceMap = {};
+        const topArg = this.heatmapChartConfig.topArgument;
+        const leftArg = this.heatmapChartConfig.leftArgument;
+        const valueField = this.heatmapChartConfig.columns[0].dataField;
+        data.forEach(item => {
+            const rowKey = item[leftArg];
+            const columnKey = moment(item[topArg]).format('YYYY-MM-DD');
+            if (!dataSourceMap[rowKey]) {
+                dataSourceMap[rowKey] = {
+                    datasource: rowKey,
+                    dataset: []
+                };
+            }
+            let toolTip = `${this.commonService.convertString(leftArg)} : ${item[leftArg]} \nRecord Date : ${columnKey} \n${this.commonService.convertString(valueField)} : ${this.commonService.ThousandSeparatorWithTwoDecimals(item[valueField])}`;
+            dataSourceMap[rowKey].dataset.push({
+                ...item,
+                toolTip: toolTip,
+                [topArg]: columnKey,
+            });
+            uniqueDates.add(columnKey);
+        });
+        const uniqueDatesArray = Array.from(uniqueDates);
+        for (const key in dataSourceMap) {
+            const dataset = dataSourceMap[key].dataset;
+            let formattedDataset;
+            if (this.heatmapChartConfig.type == "gradient") {
+                formattedDataset = this.getFormateDataByColorCodeForGradient(dataset, this.heatmapChartConfig.columns[0].dataField);
+            }
+            else if (this.heatmapChartConfig.type == "twoColor") {
+                formattedDataset = this.getFormateDataByColorCodeForWithTwoColor(dataset, this.heatmapChartConfig.columns[0].dataField);
+            }
+            else {
+                formattedDataset = this.getFormateDataByColorCodeForWithSingleColor(dataset, this.heatmapChartConfig.columns[0].dataField);
+            }
+            const dateToItemMap = {};
+            formattedDataset.forEach(item => {
+                dateToItemMap[item[topArg]] = item;
+            });
+            const completeDataset = uniqueDatesArray.map((date) => {
+                if (dateToItemMap[date]) {
+                    return dateToItemMap[date];
+                }
+                else {
+                    return {
+                        [topArg]: date,
+                        avgSize: "No Data",
+                        fileCount: 0,
+                        fileSize: 0,
+                        color: "rgb(242, 118, 109)"
+                    };
+                }
+            });
+            result.push({
+                datasource: key,
+                dataset: completeDataset
+            });
+        }
+        return {
+            result: result,
+            uniqueDates: uniqueDatesArray
+        };
+    }
+    getFormateDataByColorCodeForGradient(filedata, column) {
+        filedata.forEach(item => {
+            item.avgSize = parseFloat(item[column]);
+        });
+        const maxAvgSize = Math.max(...filedata.map(item => item[column]));
+        const minAvgSize = Math.min(...filedata.map(item => item[column]));
+        const [minColorStr, maxColorStr] = this.colorArray || ["rgba(45, 110, 18,1)", "rgba(255, 204, 0,1)"];
+        const minColor = this.parseRGBA(minColorStr);
+        const maxColor = this.parseRGBA(maxColorStr);
+        filedata.forEach(item => {
+            item.color = this.calculateColor(item[column], minAvgSize, maxAvgSize, minColor, maxColor);
+        });
+        return filedata;
+    }
+    getFormateDataByColorCodeForWithTwoColor(filedata, column) {
+        filedata.forEach(item => {
+            item[column] = parseFloat(item[column]);
+        });
+        const [minColorStr, maxColorStr] = this.colorArray || ["rgba(45, 110, 18,1)", "rgba(255, 204, 0,1)"];
+        const minColor = this.parseRGBA(minColorStr);
+        const maxColor = this.parseRGBA(maxColorStr);
+        filedata.forEach(item => {
+            if (item[column] == 0) {
+                item.color = `rgb(${minColor.join(',')})`;
+            }
+            else {
+                item.color = `rgb(${maxColor.join(',')})`;
+            }
+        });
+        return filedata;
+    }
+    getFormateDataByColorCodeForWithSingleColor(filedata, column) {
+        filedata.forEach(item => {
+            item[column] = parseFloat(item[column]);
+        });
+        const [singleColor] = this.colorArray || ["rgba(255, 204, 0,1)"];
+        const minColor = this.parseRGBA(singleColor);
+        filedata.forEach(item => {
+            item.color = `rgb(${minColor.join(',')})`;
+        });
+        return filedata;
+    }
+    parseRGBA(colorStr) {
+        const values = colorStr.match(/[\d.]+/g)?.map(Number) || [];
+        if (values.length === 3)
+            values.push(1);
+        return [
+            values[0] ?? 0,
+            values[1] ?? 0,
+            values[2] ?? 0,
+            values[3] ?? 1
+        ];
+    }
+    calculateColor(avgSize, minAvgSize, maxAvgSize, minColor, maxColor) {
+        if (minAvgSize != maxAvgSize) {
+            let gradient = (avgSize - minAvgSize) / (maxAvgSize - minAvgSize);
+            let color = minColor.map((channel, index) => {
+                return Math.round(channel + gradient * (maxColor[index] - channel));
+            });
+            return `rgb(${color.join(',')})`;
+        }
+        else {
+            return `rgb(${minColor.join(',')})`;
+        }
+    }
+    transformColumns(mainobj) {
+        return Object.keys(mainobj).map(key => {
+            return {
+                visible: true,
+                dataField: key,
+                caption: key
+            };
+        });
+    }
+    getObjectKeys(obj) {
+        return Object.keys(obj);
+    }
+    callServiceFunction(functionName, value) {
+        if (value !== undefined) {
+            if (typeof this.commonService[functionName] === "function") {
+                return this.commonService[functionName](value);
+            }
+            else {
+                console.error(`Function ${functionName} not found in CommonService`);
+                return null;
+            }
+        }
+        else {
+            return "No Data";
+        }
+    }
+}
+GammaHeatChartComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: GammaHeatChartComponent, deps: [{ token: i1.CommonService }], target: i0.ɵɵFactoryTarget.Component });
+GammaHeatChartComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: GammaHeatChartComponent, selector: "app-gamma-heatmap", inputs: { rightClickEnable: "rightClickEnable", chartDataSource: "chartDataSource" }, outputs: { getTableConfigOutPut: "getTableConfigOutPut", oRowClick: "oRowClick", onrightClickContextSelection: "onrightClickContextSelection" }, ngImport: i0, template: "<div class=\"mx-2 bg-gray-800\">\n    <app-loader *ngIf=\"isLoader\"></app-loader>\n    <ng-container *ngIf=\"!isLoader\">\n        <ng-container *ngIf=\"heatmapChartConfig.chartFormat == 'simple'\">\n            <div class=\"p-3 h-auto overflow-x-auto\">\n                <div class=\"inline-block\">\n                    <div class=\"flex flex-nowrap justify-center\">\n                        <div class=\"flex-shrink-0 w-22 max-w-[20%] h-10 flex items-center justify-center\"></div>\n                        <div *ngFor=\"let item of heatChartDataSource.argumentValue\"\n                            class=\"flex-shrink-0 min-w-22 max-w-[20%] h-8 text-sm flex items-center justify-center\">\n                            {{item}}\n                        </div>\n                    </div>\n                </div>\n                <ng-container *ngFor=\"let item of heatChartDataSource.dataSet\">\n                    <div class=\"flex flex-row\">\n                        <div class=\"h-8 flex text-sm items-center min-w-22 justify-end px-2 inline\">\n                            {{ item.datasource }}\n                        </div>\n                        <div class=\"inline-block\">\n                            <div class=\"flex flex-nowrap justify-start\">\n                                <ng-container *ngFor=\"let box of item.dataset\">\n                                    <div class=\"flex-shrink-0 min-w-22 max-w-[20%] h-8 border-2 text-sm cursor-pointer flex items-center justify-center text-gray-800\"\n                                        [ngStyle]=\"{ 'background-color': box.color }\" [matTooltip]=\"box.toolTip\"\n                                        matTooltipClass=\"custom-tooltip\">\n                                        {{ callServiceFunction(heatmapChartConfig.columns[0].enrichName,\n                                        box[heatmapChartConfig.columns[0].dataField]) }}\n                                    </div>\n                                </ng-container>\n                            </div>\n                        </div>\n                    </div>\n                </ng-container>\n            </div>\n        </ng-container>\n        <ng-container *ngIf=\"heatmapChartConfig.chartFormat == 'topx'\">\n            <div class=\"p-3 h-auto overflow-x-auto\">\n                <div class=\"flex flex-row\">\n                    <ng-container *ngFor=\"let header of heatChartDataSource.argumentValue\">\n                        <div class=\"min-w-32 text-sm font-medium text-center mb-2\">\n                            {{ header }}\n                        </div>\n                    </ng-container>\n                </div>\n\n                <div *ngFor=\"let row of heatChartDataSource.dataSet\" class=\"flex flex-row\">\n                    <ng-container *ngFor=\"let cell of row\">\n                        <div *ngIf=\"cell.box\"\n                            class=\"h-8 border-2 text-sm cursor-pointer flex items-center justify-center text-gray-800 min-w-32 cursor-pointer\"\n                            [ngStyle]=\"{ 'background-color': cell.box.color }\" [matTooltip]=\"cell.box.toolTip\"\n                            matTooltipClass=\"custom-tooltip\">\n                            {{ cell.box[heatmapChartConfig.leftArgument] }} ({{\n                            callServiceFunction(heatmapChartConfig.columns[0].enrichName,\n                            cell.box[heatmapChartConfig.columns[0].dataField]) }})\n                        </div>\n                        <div *ngIf=\"!cell.box\" class=\"h-8 min-w-32\"></div>\n                    </ng-container>\n                </div>\n            </div>\n        </ng-container>\n    </ng-container>\n</div>", dependencies: [{ kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "directive", type: i3.MatTooltip, selector: "[matTooltip]", exportAs: ["matTooltip"] }, { kind: "component", type: i4.LoaderComponent, selector: "app-loader" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: GammaHeatChartComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-gamma-heatmap', template: "<div class=\"mx-2 bg-gray-800\">\n    <app-loader *ngIf=\"isLoader\"></app-loader>\n    <ng-container *ngIf=\"!isLoader\">\n        <ng-container *ngIf=\"heatmapChartConfig.chartFormat == 'simple'\">\n            <div class=\"p-3 h-auto overflow-x-auto\">\n                <div class=\"inline-block\">\n                    <div class=\"flex flex-nowrap justify-center\">\n                        <div class=\"flex-shrink-0 w-22 max-w-[20%] h-10 flex items-center justify-center\"></div>\n                        <div *ngFor=\"let item of heatChartDataSource.argumentValue\"\n                            class=\"flex-shrink-0 min-w-22 max-w-[20%] h-8 text-sm flex items-center justify-center\">\n                            {{item}}\n                        </div>\n                    </div>\n                </div>\n                <ng-container *ngFor=\"let item of heatChartDataSource.dataSet\">\n                    <div class=\"flex flex-row\">\n                        <div class=\"h-8 flex text-sm items-center min-w-22 justify-end px-2 inline\">\n                            {{ item.datasource }}\n                        </div>\n                        <div class=\"inline-block\">\n                            <div class=\"flex flex-nowrap justify-start\">\n                                <ng-container *ngFor=\"let box of item.dataset\">\n                                    <div class=\"flex-shrink-0 min-w-22 max-w-[20%] h-8 border-2 text-sm cursor-pointer flex items-center justify-center text-gray-800\"\n                                        [ngStyle]=\"{ 'background-color': box.color }\" [matTooltip]=\"box.toolTip\"\n                                        matTooltipClass=\"custom-tooltip\">\n                                        {{ callServiceFunction(heatmapChartConfig.columns[0].enrichName,\n                                        box[heatmapChartConfig.columns[0].dataField]) }}\n                                    </div>\n                                </ng-container>\n                            </div>\n                        </div>\n                    </div>\n                </ng-container>\n            </div>\n        </ng-container>\n        <ng-container *ngIf=\"heatmapChartConfig.chartFormat == 'topx'\">\n            <div class=\"p-3 h-auto overflow-x-auto\">\n                <div class=\"flex flex-row\">\n                    <ng-container *ngFor=\"let header of heatChartDataSource.argumentValue\">\n                        <div class=\"min-w-32 text-sm font-medium text-center mb-2\">\n                            {{ header }}\n                        </div>\n                    </ng-container>\n                </div>\n\n                <div *ngFor=\"let row of heatChartDataSource.dataSet\" class=\"flex flex-row\">\n                    <ng-container *ngFor=\"let cell of row\">\n                        <div *ngIf=\"cell.box\"\n                            class=\"h-8 border-2 text-sm cursor-pointer flex items-center justify-center text-gray-800 min-w-32 cursor-pointer\"\n                            [ngStyle]=\"{ 'background-color': cell.box.color }\" [matTooltip]=\"cell.box.toolTip\"\n                            matTooltipClass=\"custom-tooltip\">\n                            {{ cell.box[heatmapChartConfig.leftArgument] }} ({{\n                            callServiceFunction(heatmapChartConfig.columns[0].enrichName,\n                            cell.box[heatmapChartConfig.columns[0].dataField]) }})\n                        </div>\n                        <div *ngIf=\"!cell.box\" class=\"h-8 min-w-32\"></div>\n                    </ng-container>\n                </div>\n            </div>\n        </ng-container>\n    </ng-container>\n</div>" }]
+        }], ctorParameters: function () { return [{ type: i1.CommonService }]; }, propDecorators: { getTableConfigOutPut: [{
+                type: Output
+            }], oRowClick: [{
+                type: Output
+            }], onrightClickContextSelection: [{
+                type: Output
+            }], rightClickEnable: [{
+                type: Input
+            }], chartDataSource: [{
+                type: Input,
+                args: ['chartDataSource']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gamma-heatmap.component.js","sourceRoot":"","sources":["../../../../../../../projects/gamma-app-controller/src/lib/shared/advanced-component/gamma-heatmap/gamma-heatmap.component.ts","../../../../../../../projects/gamma-app-controller/src/lib/shared/advanced-component/gamma-heatmap/gamma-heatmap.component.html"],"names":[],"mappings":"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","sourcesContent":["\n\n\nimport { Component, EventEmitter, Input, OnInit, Output } from '@angular/core';\nimport moment from '../../../application-controller/moment-helper';\nimport { CommonService } from '../../../application-controller/common';\n\n@Component({\n  selector: 'app-gamma-heatmap',\n  templateUrl: './gamma-heatmap.component.html',\n})\nexport class GammaHeatChartComponent implements OnInit {\n isJsonPreview: boolean\n  dataSourseForTable: any = [];\n  jsaonDatasource: any;\n  configColume: any;\n  isLoader: boolean = true;\n  tableDataConfig: any = {};\n  enrichNameList = [\"formatBytes\", \"formatBytsToKb\", \"formatBytsToGb\", \"reformatNumberWithThousandSeparatorV3\", \"formatBytesv2\"]\n  page_config: any;\n  page_parms: any;\n  page_selected_operator: any;\n  activeTab: string = 'basic';\n\n  tableHeight: any;\n\n\n  isAdvanceFilter: boolean = false;\n  isHeatMapClick: boolean = false;\n\n  heatChartDataSource: any = {};\n  chartDataForTooltip: any = {};\n\n\n\n  dataSourseForHeatMap: any = [];\n  selectedViewConfigs: any;\n\n  viewProperties: any = {\n    enableClickEvent: false,\n    enableRightClickEvent: true,\n    clickEventOptions: {\n      associatedViews: [],\n      eventType: \"\"\n    }\n  };\n  optionalDrilDownDataSource: any = [];\n  selectedTableViewType: any;\n\n  allConfiguredViews: any = [];\n  colorArray: any = [];\n  firstColor = \"rgba(45, 110, 18, 1)\";\n  secondColor = \"rgba(255, 204, 0, 1)\";\n  singleColor = \"rgba(255, 204, 0, 1)\";\n\n  heatmapChartConfig: any = {};\n  @Output() public getTableConfigOutPut: EventEmitter<any> = new EventEmitter();\n  @Output() public oRowClick: EventEmitter<any> = new EventEmitter();\n  @Output() public onrightClickContextSelection: EventEmitter<any> = new EventEmitter();\n  @Input() rightClickEnable: boolean = true;\n\n  @Input('chartDataSource')\n  set chartDataSource(value) {\n    if (value === undefined || value.length === 0) {\n      return;\n    } else {\n      this.isLoader = true;\n      this.page_config = value;\n      this.page_parms = value.titleParams;\n      if (value.kpiConfig.dataSource && value.kpiConfig.dataSource.length !== 0) {\n        this.heatmapChartConfig = value.kpiConfig.dataConfig;\n        this.colorArray = value.kpiConfig.dataConfig.color;\n        this.getHeatmapData(value.kpiConfig.dataSource);\n        setTimeout(() => {\n          this.isLoader = false;\n        }, 200);\n      } else {\n        setTimeout(() => {\n          this.dataSourseForTable = [];\n          this.tableDataConfig['columns'] = [];\n          this.isLoader = false;\n        }, 200);\n      }\n    }\n  }\n\n  constructor(public commonService: CommonService) { }\n\n  ngOnInit(): void {\n  }\n\n  getHeatmapData(heatMapData) {\n    debugger\n    this.heatChartDataSource = {};\n    this.isAdvanceFilter = false;\n    if (heatMapData && heatMapData.length !== 0) {\n      if (this.heatmapChartConfig.chartFormat == \"topx\") {\n        const { result, uniqueDates } = this.generateDateWiseColorCodedData(heatMapData);\n        // uniqueDates.sort();\n        this.heatChartDataSource.dataSet = this.getTransposedHeatmapData(result);\n        this.heatChartDataSource[\"argumentValue\"] = uniqueDates;\n      } else if ((this.heatmapChartConfig.chartFormat == \"simple\")) {\n        const { result, uniqueDates } = this.generateData(heatMapData);\n        // uniqueDates.sort();\n        this.heatChartDataSource[\"dataSet\"] = result;\n        this.heatChartDataSource[\"argumentValue\"] = uniqueDates;\n      }\n\n      this.isHeatMapClick = false;\n    } else {\n      this.isHeatMapClick = false;\n    }\n\n    // this.heatChartDataSource = {};\n    // this.isAdvanceFilter = false;\n\n    // if (heatMapData && heatMapData.length !== 0) {\n    //   const { result, uniqueDates } = this.generateData(heatMapData)\n    //   uniqueDates.sort();\n    //   this.heatChartDataSource[\"dataSet\"] = result;\n    //   this.heatChartDataSource[\"argumentValue\"] = uniqueDates;\n    //   this.isHeatMapClick = false;\n    // } else {\n    //   this.isHeatMapClick = false;\n    // }\n\n\n  }\n\n  getTransposedHeatmapData(dataSet: any[]): any[] {\n    const transposed: any[] = [];\n    const maxBoxes = Math.max(...dataSet.map(item => item.dataset.length));\n\n    for (let i = 0; i < maxBoxes; i++) {\n      const row: any[] = [];\n      for (let j = 0; j < dataSet.length; j++) {\n        const box = dataSet[j].dataset[i];\n        row.push({\n          box: box || null,\n          date: dataSet[j].record_date\n        });\n      }\n      transposed.push(row);\n    }\n\n    return transposed;\n  }\n\n  generateDateWiseColorCodedData(data: any[]) {\n    const result: any[] = [];\n    const uniqueDates = new Set();\n    const allEntries: any[] = [];\n\n    const topArg = this.heatmapChartConfig.topArgument;\n    const leftArg = this.heatmapChartConfig.leftArgument;\n    const valueField = this.heatmapChartConfig.columns[0].dataField;\n\n    data.forEach(entry => {\n      const formattedDate = (moment(entry[topArg]).format('YYYY-MM-DD')) ? moment(entry[topArg]).format('YYYY-MM-DD') : topArg;\n      uniqueDates.add(formattedDate);\n\n      entry.resultDataset.forEach(item => {\n        allEntries.push({\n          [topArg]: formattedDate,\n          [leftArg]: item[`${leftArg}`],\n          [valueField]: item[`${valueField}`]\n        });\n      });\n    });\n\n    let coloredData;\n    if (this.heatmapChartConfig.type === 'gradient') {\n      coloredData = this.getFormateDataByColorCodeForGradient(allEntries, valueField);\n    } else if (this.heatmapChartConfig.type === 'twoColor') {\n      coloredData = this.getFormateDataByColorCodeForWithTwoColor(allEntries, valueField);\n    } else {\n      coloredData = this.getFormateDataByColorCodeForWithSingleColor(allEntries, valueField);\n    }\n\n    const dateMap: { [date: string]: any[] } = {};\n\n    coloredData.forEach(item => {\n      const date: any = item[topArg];\n\n      if (!dateMap[date]) {\n        dateMap[date] = [];\n      }\n      let toolTip = `Record Date : ${item[topArg]} \\n${this.commonService.convertString(valueField)} : ${this.commonService.ThousandSeparatorWithTwoDecimals(item[valueField])}`\n      dateMap[date].push({\n        [leftArg]: item[leftArg],\n        [valueField]: item[valueField],\n        color: item.color,\n        toolTip: toolTip,\n        [topArg]: date,\n      });\n    });\n    \n    const sortedDates = Array.from(uniqueDates).sort((a, b) => moment(b).diff(moment(a)));\n\n    for (const date of sortedDates as string[]) {\n      result.push({\n        record_date: date,\n        dataset: dateMap[date] || []\n      });\n    }\n\n    return {\n      result,\n      uniqueDates: sortedDates\n    };\n  }\n\n  generateData(data) {\n    const result = [];\n    const uniqueDates = new Set();\n    const dataSourceMap = {};\n    const topArg = this.heatmapChartConfig.topArgument;\n    const leftArg = this.heatmapChartConfig.leftArgument;\n    const valueField = this.heatmapChartConfig.columns[0].dataField;\n\n    data.forEach(item => {\n      const rowKey = item[leftArg];\n      const columnKey = moment(item[topArg]).format('YYYY-MM-DD');\n\n      if (!dataSourceMap[rowKey]) {\n        dataSourceMap[rowKey] = {\n          datasource: rowKey,\n          dataset: []\n        };\n      }\n      let toolTip = `${this.commonService.convertString(leftArg)} : ${item[leftArg]} \\nRecord Date : ${columnKey} \\n${this.commonService.convertString(valueField)} : ${this.commonService.ThousandSeparatorWithTwoDecimals(item[valueField])}`\n\n      dataSourceMap[rowKey].dataset.push({\n        ...item,\n         toolTip: toolTip,\n        [topArg]: columnKey,\n\n      });\n\n      uniqueDates.add(columnKey);\n    });\n\n    const uniqueDatesArray = Array.from(uniqueDates);\n\n    for (const key in dataSourceMap) {\n      const dataset = dataSourceMap[key].dataset;\n      let formattedDataset;\n\n      if (this.heatmapChartConfig.type == \"gradient\") {\n        formattedDataset = this.getFormateDataByColorCodeForGradient(dataset, this.heatmapChartConfig.columns[0].dataField);\n      } else if (this.heatmapChartConfig.type == \"twoColor\") {\n        formattedDataset = this.getFormateDataByColorCodeForWithTwoColor(dataset, this.heatmapChartConfig.columns[0].dataField);\n      } else {\n        formattedDataset = this.getFormateDataByColorCodeForWithSingleColor(dataset, this.heatmapChartConfig.columns[0].dataField);\n\n      }\n\n      const dateToItemMap = {};\n      formattedDataset.forEach(item => {\n        dateToItemMap[item[topArg]] = item;\n      });\n\n      const completeDataset = uniqueDatesArray.map((date: any) => {\n        if (dateToItemMap[date]) {\n          return dateToItemMap[date];\n        } else {\n          return {\n            [topArg]: date,\n            avgSize: \"No Data\",\n            fileCount: 0,\n            fileSize: 0,\n            color: \"rgb(242, 118, 109)\"\n          };\n        }\n      });\n\n      result.push({\n        datasource: key,\n        dataset: completeDataset\n      });\n    }\n\n    return {\n      result: result,\n      uniqueDates: uniqueDatesArray\n    };\n  }\n\n\n\n  getFormateDataByColorCodeForGradient(filedata, column) {\n    filedata.forEach(item => {\n      item.avgSize = parseFloat(item[column]);\n    });\n\n    const maxAvgSize = Math.max(...filedata.map(item => item[column]));\n    const minAvgSize = Math.min(...filedata.map(item => item[column]));\n\n    const [minColorStr, maxColorStr] = this.colorArray || [\"rgba(45, 110, 18,1)\", \"rgba(255, 204, 0,1)\"];\n    const minColor = this.parseRGBA(minColorStr);\n    const maxColor = this.parseRGBA(maxColorStr);\n\n    filedata.forEach(item => {\n      item.color = this.calculateColor(item[column], minAvgSize, maxAvgSize, minColor, maxColor);\n    });\n\n    return filedata;\n  }\n  getFormateDataByColorCodeForWithTwoColor(filedata, column) {\n    filedata.forEach(item => {\n      item[column] = parseFloat(item[column]);\n    });\n\n    const [minColorStr, maxColorStr] = this.colorArray || [\"rgba(45, 110, 18,1)\", \"rgba(255, 204, 0,1)\"];\n    const minColor = this.parseRGBA(minColorStr);\n    const maxColor = this.parseRGBA(maxColorStr);\n\n    filedata.forEach(item => {\n      if (item[column] == 0) {\n        item.color = `rgb(${minColor.join(',')})`;\n      } else {\n        item.color = `rgb(${maxColor.join(',')})`;\n      }\n\n    });\n\n    return filedata;\n  }\n  getFormateDataByColorCodeForWithSingleColor(filedata, column) {\n    filedata.forEach(item => {\n      item[column] = parseFloat(item[column]);\n    });\n\n    const [singleColor] = this.colorArray || [\"rgba(255, 204, 0,1)\"];\n    const minColor = this.parseRGBA(singleColor);\n\n    filedata.forEach(item => {\n      item.color = `rgb(${minColor.join(',')})`;\n    });\n\n    return filedata;\n  }\n\n  parseRGBA(colorStr: string): number[] {\n    const values = colorStr.match(/[\\d.]+/g)?.map(Number) || [];\n    if (values.length === 3) values.push(1);\n    return [\n      values[0] ?? 0,\n      values[1] ?? 0,\n      values[2] ?? 0,\n      values[3] ?? 1\n    ];\n  }\n\n  calculateColor(avgSize, minAvgSize, maxAvgSize, minColor, maxColor) {\n    if (minAvgSize != maxAvgSize) {\n      let gradient = (avgSize - minAvgSize) / (maxAvgSize - minAvgSize);\n      let color = minColor.map((channel, index) => {\n        return Math.round(channel + gradient * (maxColor[index] - channel));\n      });\n      return `rgb(${color.join(',')})`;\n    } else {\n      return `rgb(${minColor.join(',')})`\n    }\n\n  }\n\n\n\n  transformColumns(mainobj: any): any[] {\n    return Object.keys(mainobj).map(key => {\n      return {\n        visible: true,\n        dataField: key,\n        caption: key\n      };\n    });\n  }\n\n\n\n  getObjectKeys(obj: any): string[] {\n    return Object.keys(obj);\n  }\n\n\n  callServiceFunction(functionName: string, value): any {\n\n    if (value !== undefined) {\n      if (typeof this.commonService[functionName] === \"function\") {\n        return this.commonService[functionName](value);\n      } else {\n        console.error(`Function ${functionName} not found in CommonService`);\n        return null;\n      }\n    } else {\n      return \"No Data\"\n    }\n\n  }\n\n\n}\n","<div class=\"mx-2 bg-gray-800\">\n    <app-loader *ngIf=\"isLoader\"></app-loader>\n    <ng-container *ngIf=\"!isLoader\">\n        <ng-container *ngIf=\"heatmapChartConfig.chartFormat == 'simple'\">\n            <div class=\"p-3 h-auto overflow-x-auto\">\n                <div class=\"inline-block\">\n                    <div class=\"flex flex-nowrap justify-center\">\n                        <div class=\"flex-shrink-0 w-22 max-w-[20%] h-10 flex items-center justify-center\"></div>\n                        <div *ngFor=\"let item of heatChartDataSource.argumentValue\"\n                            class=\"flex-shrink-0 min-w-22 max-w-[20%] h-8 text-sm flex items-center justify-center\">\n                            {{item}}\n                        </div>\n                    </div>\n                </div>\n                <ng-container *ngFor=\"let item of heatChartDataSource.dataSet\">\n                    <div class=\"flex flex-row\">\n                        <div class=\"h-8 flex text-sm items-center min-w-22 justify-end px-2 inline\">\n                            {{ item.datasource }}\n                        </div>\n                        <div class=\"inline-block\">\n                            <div class=\"flex flex-nowrap justify-start\">\n                                <ng-container *ngFor=\"let box of item.dataset\">\n                                    <div class=\"flex-shrink-0 min-w-22 max-w-[20%] h-8 border-2 text-sm cursor-pointer flex items-center justify-center text-gray-800\"\n                                        [ngStyle]=\"{ 'background-color': box.color }\" [matTooltip]=\"box.toolTip\"\n                                        matTooltipClass=\"custom-tooltip\">\n                                        {{ callServiceFunction(heatmapChartConfig.columns[0].enrichName,\n                                        box[heatmapChartConfig.columns[0].dataField]) }}\n                                    </div>\n                                </ng-container>\n                            </div>\n                        </div>\n                    </div>\n                </ng-container>\n            </div>\n        </ng-container>\n        <ng-container *ngIf=\"heatmapChartConfig.chartFormat == 'topx'\">\n            <div class=\"p-3 h-auto overflow-x-auto\">\n                <div class=\"flex flex-row\">\n                    <ng-container *ngFor=\"let header of heatChartDataSource.argumentValue\">\n                        <div class=\"min-w-32 text-sm font-medium text-center mb-2\">\n                            {{ header }}\n                        </div>\n                    </ng-container>\n                </div>\n\n                <div *ngFor=\"let row of heatChartDataSource.dataSet\" class=\"flex flex-row\">\n                    <ng-container *ngFor=\"let cell of row\">\n                        <div *ngIf=\"cell.box\"\n                            class=\"h-8 border-2 text-sm cursor-pointer flex items-center justify-center text-gray-800 min-w-32 cursor-pointer\"\n                            [ngStyle]=\"{ 'background-color': cell.box.color }\" [matTooltip]=\"cell.box.toolTip\"\n                            matTooltipClass=\"custom-tooltip\">\n                            {{ cell.box[heatmapChartConfig.leftArgument] }} ({{\n                            callServiceFunction(heatmapChartConfig.columns[0].enrichName,\n                            cell.box[heatmapChartConfig.columns[0].dataField]) }})\n                        </div>\n                        <div *ngIf=\"!cell.box\" class=\"h-8 min-w-32\"></div>\n                    </ng-container>\n                </div>\n            </div>\n        </ng-container>\n    </ng-container>\n</div>"]}