raise-common-lib 0.0.206 → 0.0.207

package/esm2015/lib/dashboard/gadget-group/gadget-transpose/gadget-transpose.component.js

@@ -0,0 +1,857 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/dashboard/gadget-group/gadget-transpose/gadget-transpose.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Component, Input, ViewChild, ChangeDetectorRef, Inject, Optional, } from "@angular/core";
+import { DashboardPorletsService } from "../../dashboardPorlets.service";
+import { GridComponent, ColumnChooserService, ExcelExportService, VirtualScrollService, } from "@syncfusion/ej2-angular-grids";
+import { DashboardService } from "../../dashboard.service";
+import moment from "moment";
+import { DataUtil } from "@syncfusion/ej2-data";
+import { PBF_TOKEN } from "../../../service/InjectionToken";
+export class GadgetTransposeComponent {
+    /**
+     * @param {?} DashboardPorletsService
+     * @param {?} dashboardService
+     * @param {?} ref
+     * @param {?} pbf
+     */
+    constructor(DashboardPorletsService, dashboardService, ref, pbf) {
+        this.DashboardPorletsService = DashboardPorletsService;
+        this.dashboardService = dashboardService;
+        this.ref = ref;
+        this.pbf = pbf;
+        this.fields = [];
+        this.pageLoading = false;
+        this.formatSettings = [];
+        this.subscriptions = [];
+        this.quarterFormat = [
+            { value: "03/2021", format: "MM/yyyy" },
+            { value: "03/21", format: "MM/dd" },
+            { value: "3/2021", format: "M/yyyy" },
+            { value: "3/21", format: "M/yy" },
+            { value: "March 2021", format: "MMMM yyyy" },
+            { value: "Mar, 2021", format: "MMM, yyyy" },
+            { value: "March, 2021", format: "MMMM, yyyy" },
+            { value: "2021", format: "yyyy" },
+        ];
+        this.formatDates = [];
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+        this.getInfo();
+        this.pageSettings = { pageSizes: true, pageSize: 20 };
+        this.ColumnChooserSettings = { operator: "contains" };
+        this.filter = { type: "CheckBox" };
+        this.rowMode = "Vertical";
+        this.getTableData();
+    }
+    /**
+     * @return {?}
+     */
+    ngAfterViewInit() {
+        this.subscriptions.push(this.dashboardService.getUpdated().subscribe((/**
+         * @param {?} newId
+         * @return {?}
+         */
+        (newId) => {
+            if (newId === this.portlet.newId || newId === this.portlet.id) {
+                this.getTableData();
+            }
+        })));
+        this.subscriptions.push(this.dashboardService.getStartRefresh().subscribe((/**
+         * @param {?} dashboardId
+         * @return {?}
+         */
+        (dashboardId) => {
+            if (this.dashboard.id === dashboardId) {
+                this.pageLoading = true;
+                this.ref.markForCheck();
+            }
+        })));
+        this.subscriptions.push(this.dashboardService.getRefreshGadget().subscribe((/**
+         * @param {?} e
+         * @return {?}
+         */
+        (e) => {
+            if (!e) {
+                return;
+            }
+            /** @type {?} */
+            const id = e["newId"];
+            if (id === this.portlet.newId || id === this.portlet.id) {
+                this.getTableData();
+            }
+        })));
+        this.subscriptions.push(this.dashboardService.getTableFormat().subscribe((/**
+         * @param {?} id
+         * @return {?}
+         */
+        (id) => {
+            if (id === this.portlet.newId || id === this.portlet.id) {
+                this.getTableData();
+                this.grid.columns.forEach((/**
+                 * @param {?} item
+                 * @return {?}
+                 */
+                (item) => {
+                    this.fields.forEach((/**
+                     * @param {?} table
+                     * @return {?}
+                     */
+                    (table) => {
+                        if (item.field === table.colName &&
+                            table.format &&
+                            table.format.length &&
+                            table.format[0].formatChecked) {
+                            item.headerText =
+                                table.displayName ||
+                                    table.langValue ||
+                                    this.translation[table.langCode] ||
+                                    table.langCode;
+                            if (table.format &&
+                                (table.dataType === "number" ||
+                                    table.dataType === "percent")) {
+                                /** @type {?} */
+                                let formatString;
+                                if (table.dataType === "number") {
+                                    formatString = this.pbf.formatNumber(table.format[0].selectedFormat);
+                                }
+                                else if (table.dataType === "percent") {
+                                    formatString = this.pbf.formatPercent(table.format[0].selectedFormat);
+                                }
+                                item.format = formatString;
+                            }
+                        }
+                    }));
+                }));
+                this.grid.refreshColumns();
+            }
+        })));
+    }
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        this.subscriptions.forEach((/**
+         * @param {?} sub
+         * @return {?}
+         */
+        (sub) => sub.unsubscribe()));
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    getTableData() {
+        this.pageLoading = false;
+        this.config = JSON.parse(this.portlet.config);
+        if (this.config.fields) {
+            /** @type {?} */
+            let fields = this.config.fields.filter((/**
+             * @param {?} fl
+             * @return {?}
+             */
+            (fl) => !fl.isHidden));
+            /** @type {?} */
+            const fieldsCopy = JSON.parse(JSON.stringify(fields));
+            if (fieldsCopy.length) {
+                /** @type {?} */
+                let _index = 0;
+                this.fields = fieldsCopy.map((/**
+                 * @param {?} el
+                 * @return {?}
+                 */
+                (el) => {
+                    // 处理format的displayName，之前未赋值
+                    /** @type {?} */
+                    let displayName = "";
+                    if (Array.isArray(el.format) &&
+                        el.format.length > 0 &&
+                        el.format[0].formatChecked) {
+                        displayName = el.format[0].displayName;
+                    }
+                    if (el.visible) {
+                        _index += 1;
+                        return Object.assign({}, el, { _index,
+                            displayName });
+                    }
+                    else {
+                        return Object.assign({}, el, { _index: null, displayName });
+                    }
+                }));
+            }
+        }
+        this.tranposeData = this.DashboardPorletsService.getResultByDataTable(this.portlet, false, false, this.dashboard.id);
+        this.tranposeData = DataUtil.parse.parseJson(this.tranposeData);
+        if (this.tranposeData && this.tranposeData.length)
+            this.filterData((/**
+             * @param {?} res
+             * @return {?}
+             */
+            (res) => {
+                if (this.config && this.fields && this.fields.length) {
+                    this.formatSettings = [];
+                    this.fields.map((/**
+                     * @param {?} el
+                     * @return {?}
+                     */
+                    (el) => {
+                        /** @type {?} */
+                        let numberTypes = [
+                            "number",
+                            "percent",
+                            "percentNum",
+                            "multiple",
+                        ];
+                        if (numberTypes.includes(el.dataType)) {
+                            /** @type {?} */
+                            let format = this.getNumFormat(el);
+                            /** @type {?} */
+                            const formatData = {
+                                name: el.colName,
+                                format: format,
+                            };
+                            // if (el.dataType === "number")
+                            // 	formatData["useGrouping"] = true;
+                            this.formatSettings.push(formatData);
+                        }
+                        if (el.dataType == "datetime" ||
+                            el.dataType == "date") {
+                            /** @type {?} */
+                            let format = "";
+                            if (el.format &&
+                                el.format.length &&
+                                el.format[0].formatChecked) {
+                                if (el.format[0].compareValue2 == "Quarter") {
+                                    /** @type {?} */
+                                    let format_ = el.format[0].selectedFormatDisplay;
+                                    /** @type {?} */
+                                    let formatInfo = this.quarterFormat.filter((/**
+                                     * @param {?} qur
+                                     * @return {?}
+                                     */
+                                    (qur) => qur.value == format_));
+                                    if (formatInfo.length) {
+                                        format = formatInfo[0].format;
+                                    }
+                                    else {
+                                        /** @type {?} */
+                                        const formatData = {
+                                            name: el.colName,
+                                            format: format_,
+                                            type: "date",
+                                        };
+                                        this.formatDates.push(formatData);
+                                    }
+                                }
+                                else if (el.format[0].compareValue2 == "Date") {
+                                    /** @type {?} */
+                                    let fromIdx = el.format[0].selectedFormatDisplay.indexOf("(");
+                                    /** @type {?} */
+                                    let toIdx = el.format[0].selectedFormatDisplay.indexOf(")");
+                                    /** @type {?} */
+                                    let format_ = el.format[0].selectedFormatDisplay.slice(fromIdx + 1, toIdx);
+                                    switch (format_) {
+                                        case "DD/MM/YYYY":
+                                            format = "dd/MM/yyyy";
+                                            break;
+                                        case "DD/MM/YY":
+                                            format = "dd/MM/yy";
+                                            break;
+                                        case "MM/DD/YYYY":
+                                            format = "MM/dd/yyyy";
+                                            break;
+                                        case "MM/DD/YY":
+                                            format = "MM/dd/yy";
+                                            break;
+                                        case "YYYY-MM-DD":
+                                            format = "yyyy-MM-dd";
+                                            break;
+                                        case "YY-MM-DD":
+                                            format = "yy-MM-dd";
+                                            break;
+                                        case "DD-MM-YYYY":
+                                            format = "dd-MM-yyyy";
+                                            break;
+                                        case "DD-MM-YY":
+                                            format = "dd-MM-yy";
+                                            break;
+                                        case "MM-DD-YYYY":
+                                            format = "MM-dd-yyyy";
+                                            break;
+                                        case "MM-DD-YY":
+                                            format = "MM-dd-yy";
+                                            break;
+                                        case "MMM DD, YYYY":
+                                            format = "MMM dd, yyyy";
+                                            break;
+                                        case "DD-MMM-YYYY":
+                                            format = "dd-MMM-yyyy";
+                                            break;
+                                        default:
+                                            break;
+                                    }
+                                }
+                            }
+                            if (!format) {
+                                /** @type {?} */
+                                const formatData = {
+                                    name: el.colName,
+                                    format: this.datePipeFormat,
+                                    type: "date",
+                                };
+                                this.formatSettings.push(formatData);
+                            }
+                            else {
+                                /** @type {?} */
+                                const formatData = {
+                                    name: el.colName,
+                                    format: format,
+                                    type: "date",
+                                };
+                                this.formatSettings.push(formatData);
+                            }
+                        }
+                    }));
+                }
+                if (this.grid)
+                    this.grid.refresh();
+                this.ref.markForCheck();
+                this.ref.detectChanges();
+            }));
+    }
+    /**
+     * @private
+     * @param {?} callback
+     * @return {?}
+     */
+    filterData(callback) {
+        this.data = [];
+        if (this.config.filterSettings && this.config.filterSettings.length) {
+            if (this.tranposeData) {
+                /** @type {?} */
+                let dataType = this.fields.filter((/**
+                 * @param {?} el
+                 * @return {?}
+                 */
+                (el) => el.colName == this.config.filterSettings[0].field)).length
+                    ? this.fields.filter((/**
+                     * @param {?} el
+                     * @return {?}
+                     */
+                    (el) => el.colName ==
+                        this.config.filterSettings[0].field))[0].dataType
+                    : "";
+                /** @type {?} */
+                let transpose_data = [];
+                if (dataType == "date" || dataType == "datetime") {
+                    transpose_data = this.tranposeData.filter((/**
+                     * @param {?} el
+                     * @return {?}
+                     */
+                    (el) => moment(el[this.config.filterSettings[0].field]).format("YYYY-MM-DD") ==
+                        moment(this.config.filterSettings[0].value).format("YYYY-MM-DD")));
+                }
+                else {
+                    transpose_data = this.tranposeData.filter((/**
+                     * @param {?} el
+                     * @return {?}
+                     */
+                    (el) => el[this.config.filterSettings[0].field] ==
+                        this.config.filterSettings[0].value));
+                }
+                if (transpose_data.length) {
+                    this.data.push(transpose_data[0]);
+                }
+                else {
+                    this.data.push(this.tranposeData[0]);
+                }
+            }
+        }
+        else {
+            this.data.push(this.tranposeData[0]);
+        }
+        // if (this.grid) this.grid.refresh();
+        callback();
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    getInfo() {
+        this.translation = JSON.parse(localStorage.getItem("translation"));
+        this.datePipeFormat = localStorage.getItem("datePipe");
+    }
+    /**
+     * @param {?} colName
+     * @return {?}
+     */
+    getFormatOptions(colName) {
+        /** @type {?} */
+        let res = this.formatSettings.filter((/**
+         * @param {?} el
+         * @return {?}
+         */
+        (el) => el.name === colName));
+        if (res && res.length) {
+            // let obj = JSON.parse(JSON.stringify(res[0]));
+            // delete obj.name;
+            // return obj;
+            return res[0].format;
+        }
+    }
+    /**
+     * @param {?} args
+     * @return {?}
+     */
+    customiseCell(args) {
+        /** @type {?} */
+        let queryCell = this.fields.filter((/**
+         * @param {?} item
+         * @return {?}
+         */
+        (item) => item.colName === args.column.field))[0];
+        if (queryCell &&
+            queryCell.format &&
+            queryCell.format.length &&
+            queryCell.format[0].formatChecked) {
+            // SMP2-3416 0的format start
+            if ([2, 5, 8, 11, 14, 17].includes(queryCell.format[0].selectedFormat) &&
+                args.data[queryCell.colName] === 0)
+                args.cell.innerHTML = "-";
+            if ([3, 6, 9, 12, 15, 18].includes(queryCell.format[0].selectedFormat) &&
+                args.data[queryCell.colName] === 0)
+                args.cell.innerHTML = "";
+            // SMP2-3416 0的format end
+        }
+        if (queryCell && queryCell._index) {
+            if (queryCell._index === 1) {
+                args.cell.classList.add("first-cell");
+            }
+            // args.cell.classList.add(
+            // 	`${queryCell._index % 2 === 0 ? "even" : "odd"}`
+            // );
+            this.ref.markForCheck();
+        }
+        if (queryCell &&
+            queryCell.format &&
+            queryCell.format.length &&
+            queryCell.format[0].fontSettingChecked) {
+            if (queryCell.format[0].formatChecked &&
+                queryCell.format[0].compareSelect) {
+                /** @type {?} */
+                let cellData = args.data[args.column.field];
+                /** @type {?} */
+                let condition = false;
+                switch (queryCell.format[0].compareSelect) {
+                    case "LessThan":
+                        condition =
+                            cellData <
+                                Number(queryCell.format[0].compareValue1);
+                        break;
+                    case "LessThanOrEqualTo":
+                        condition =
+                            cellData <=
+                                Number(queryCell.format[0].compareValue1);
+                        break;
+                    case "GreaterThan":
+                        condition =
+                            cellData >
+                                Number(queryCell.format[0].compareValue1);
+                        break;
+                    case "GreaterThanOrEqualTo":
+                        condition =
+                            cellData >=
+                                Number(queryCell.format[0].compareValue1);
+                        break;
+                    case "Equals":
+                        condition =
+                            cellData ===
+                                Number(queryCell.format[0].compareValue1);
+                        break;
+                    case "NotEquals":
+                        condition =
+                            cellData !==
+                                Number(queryCell.format[0].compareValue1);
+                        break;
+                    case "Between":
+                        condition =
+                            cellData >=
+                                Number(queryCell.format[0].compareValue1) &&
+                                cellData <= queryCell.format[0].compareValue2;
+                        break;
+                    case "NotBetween":
+                        condition =
+                            cellData <
+                                Number(queryCell.format[0].compareValue1) &&
+                                cellData >
+                                    Number(queryCell.format[0].compareValue2);
+                        break;
+                    default:
+                        break;
+                }
+                if (condition)
+                    this.cellAddStyle(args, queryCell);
+            }
+            else
+                this.cellAddStyle(args, queryCell);
+        }
+        // date format about quarterly
+        if (this.formatDates && this.formatDates.length) {
+            /** @type {?} */
+            let dateFields = this.formatDates.map((/**
+             * @param {?} el
+             * @return {?}
+             */
+            (el) => {
+                return el.name;
+            }));
+            if (args.column.field &&
+                dateFields.includes(args.column.field) &&
+                queryCell.format &&
+                queryCell.format.length &&
+                queryCell.format[0].formatChecked) {
+                /** @type {?} */
+                let date = new Date(args.data[args.column.field]);
+                /** @type {?} */
+                let quarter = Math.floor((date.getMonth() + 1) % 3) == 0
+                    ? Math.floor((date.getMonth() + 1) / 3)
+                    : Math.floor((date.getMonth() + 1) / 3) + 1;
+                /** @type {?} */
+                let format;
+                this.formatDates.map((/**
+                 * @param {?} el
+                 * @return {?}
+                 */
+                (el) => {
+                    if (el.name == args.column.field)
+                        format = el.format;
+                }));
+                /** @type {?} */
+                let year;
+                switch (format) {
+                    case "Q1 2021":
+                        year = date.getFullYear();
+                        args.cell.innerHTML = "Q" + quarter + " " + year;
+                        break;
+                    case "Q1 21":
+                        year = ((/** @type {?} */ (date))).getYear() - 100;
+                        args.cell.innerHTML = "Q" + quarter + " " + year;
+                        break;
+                    case "2021 Q1":
+                        year = date.getFullYear();
+                        args.cell.innerHTML = year + " " + "Q" + quarter;
+                        break;
+                    case "21 Q1":
+                        year = ((/** @type {?} */ (date))).getYear() - 100;
+                        args.cell.innerHTML = year + " " + "Q" + quarter;
+                        break;
+                }
+            }
+        }
+    }
+    /**
+     * @param {?} args
+     * @param {?} queryCell
+     * @return {?}
+     */
+    cellAddStyle(args, queryCell) {
+        if (queryCell.format[0].fontSettingChecked) {
+            /** @type {?} */
+            let formatCellData = args.data[args.column.field];
+            if (Math.sign(formatCellData) !== 0)
+                if (Math.sign(formatCellData) === -1) {
+                    args.cell.style.cssText += `color: ${queryCell.format[0].negaFontColor} !important`;
+                    args.cell.style.cssText += `font-size: ${queryCell.format[0].negaFontSizeValue} !important`;
+                    args.cell.style.cssText += `font-family: ${queryCell.format[0].negaFontFamilyValue} !important`;
+                    args.cell.style.cssText += `background-color: ${queryCell.format[0].negaBackgroundColor} !important`;
+                }
+                else {
+                    args.cell.style.cssText += `color: ${queryCell.format[0].fontColor} !important`;
+                    args.cell.style.cssText += `font-size: ${queryCell.format[0].fontSizeValue} !important`;
+                    args.cell.style.cssText += `font-family: ${queryCell.format[0].fontFamilyValue} !important`;
+                    args.cell.style.cssText += `background-color: ${queryCell.format[0].backgroundColor} !important`;
+                }
+        }
+    }
+    /**
+     * @param {?} args
+     * @return {?}
+     */
+    actionComplete(args) {
+        if (args.requestType === "columnstate") {
+            /** @type {?} */
+            const hideColumns = this.grid.getHiddenColumns();
+            this.fields.map((/**
+             * @param {?} el
+             * @return {?}
+             */
+            (el) => (el.visible = true)));
+            if (hideColumns.length > 0) {
+                for (let hideitem of hideColumns) {
+                    this.fields.forEach((/**
+                     * @param {?} field
+                     * @return {?}
+                     */
+                    (field) => {
+                        if (field.colName === hideitem.field) {
+                            field.visible = false;
+                            field._index = null;
+                        }
+                    }));
+                }
+            }
+            /** @type {?} */
+            let _index = 0;
+            this.fields.forEach((/**
+             * @param {?} field
+             * @return {?}
+             */
+            (field) => {
+                if (field.visible) {
+                    _index += 1;
+                    field._index = _index;
+                }
+            }));
+            this.config.fields = JSON.parse(JSON.stringify(this.fields));
+            /** @type {?} */
+            const portlet = this.portlet;
+            portlet.config = JSON.stringify(this.config);
+            /** @type {?} */
+            const index = this.portlets.findIndex((/**
+             * @param {?} x
+             * @return {?}
+             */
+            (x) => x.newId === portlet.newId));
+            this.portlets[index].config = JSON.stringify(this.config);
+            if (this.grid)
+                this.grid.refresh();
+        }
+    }
+    /**
+     * @param {?} args
+     * @return {?}
+     */
+    exportQueryCellInfo(args) {
+        if (this.formatDates && this.formatDates.length) {
+            /** @type {?} */
+            let dateFields = this.formatDates.map((/**
+             * @param {?} el
+             * @return {?}
+             */
+            (el) => {
+                return el.name;
+            }));
+            if (args.column.field && dateFields.includes(args.column.field)) {
+                /** @type {?} */
+                let date = new Date(args.data[args.column.field]);
+                /** @type {?} */
+                let quarter = Math.floor((date.getMonth() + 1) % 3) == 0
+                    ? Math.floor((date.getMonth() + 1) / 3)
+                    : Math.floor((date.getMonth() + 1) / 3) + 1;
+                /** @type {?} */
+                let format;
+                this.formatDates.map((/**
+                 * @param {?} el
+                 * @return {?}
+                 */
+                (el) => {
+                    if (el.name == args.column.field)
+                        format = el.format;
+                }));
+                /** @type {?} */
+                let year;
+                switch (format) {
+                    case "Q1 2021":
+                        year = date.getFullYear();
+                        args.value = "Q" + quarter + " " + year;
+                        break;
+                    case "Q1 21":
+                        year = ((/** @type {?} */ (date))).getYear() - 100;
+                        args.value = "Q" + quarter + " " + year;
+                        break;
+                    case "2021 Q1":
+                        year = date.getFullYear();
+                        args.value = year + " " + "Q" + quarter;
+                        break;
+                    case "21 Q1":
+                        year = ((/** @type {?} */ (date))).getYear() - 100;
+                        args.value = year + " " + "Q" + quarter;
+                        break;
+                }
+            }
+        }
+    }
+    /**
+     * @private
+     * @param {?} el
+     * @return {?}
+     */
+    getNumFormat(el) {
+        //SMP2-3026
+        if (el.dataType === "number" &&
+            el.colName !== "PortInvStk" &&
+            el.colName !== "PortFdInvStk") {
+            if (el.format && el.format.length && el.format[0].formatChecked) {
+                if ([10, 11, 12, 13, 14, 15, 16, 17, 18].includes(el.format[0].selectedFormat))
+                    this.millionData(el.colName);
+                return this.pbf.formatNumber(el.format[0].selectedFormat);
+            }
+            else
+                return this.DashboardPorletsService.formatNumber(el.dp);
+        }
+        if (el.dataType === "percent") {
+            if (el.format && el.format.length && el.format[0].formatChecked)
+                return this.pbf.formatPercent(el.format[0].selectedFormat);
+            else
+                return this.DashboardPorletsService.formatPercent(el.dp);
+        }
+        if (el.dataType === "percentNum")
+            return this.DashboardPorletsService.formatPercentNum(el.dp);
+        if (el.dataType === "multiple")
+            return this.DashboardPorletsService.formatMultiple(el.dp);
+    }
+    /**
+     * @private
+     * @param {?} colName
+     * @return {?}
+     */
+    millionData(colName) {
+        this.data.map((/**
+         * @param {?} el
+         * @return {?}
+         */
+        (el) => {
+            el[colName] = Number(el[colName] / 1000000);
+        }));
+        if (this.config.filterSettings && this.config.filterSettings.length) {
+            /** @type {?} */
+            let filterFields = this.config.filterSettings.map((/**
+             * @param {?} el
+             * @return {?}
+             */
+            (el) => {
+                return el.field;
+            }));
+            if (filterFields.includes(colName))
+                this.config.filterSettings.map((/**
+                 * @param {?} el
+                 * @return {?}
+                 */
+                (el) => {
+                    if (el.field == colName) {
+                        el.value = Number(el.value / 1000000);
+                    }
+                }));
+        }
+    }
+}
+GadgetTransposeComponent.decorators = [
+    { type: Component, args: [{
+                selector: "kt-gadget-transpose",
+                template: "<div class=\"e-bigger transpose-grid\">\r\n\t<!-- \u865A\u62DF\u6EDA\u52A8\u4F1A\u5F15\u8D77\u4E0D\u663E\u793A\u7684bug -->\r\n\t<!-- [enableVirtualization]=\"true\" -->\r\n\t<ejs-grid\r\n\t\t#grid\r\n\t\t[dataSource]=\"data\"\r\n\t\t[rowRenderingMode]=\"rowMode\"\r\n\t\t[allowExcelExport]=\"true\"\r\n\t\tshowColumnChooser=\"true\"\r\n\t\tenableAdaptiveUI=\"true\"\r\n\t\twidth=\"100%\"\r\n\t\theight=\"100%\"\r\n\t\t[columnChooserSettings]=\"ColumnChooserSettings\"\r\n\t\t(queryCellInfo)=\"customiseCell($event)\"\r\n\t\t(actionComplete)=\"actionComplete($event)\"\r\n\t\t[allowPdfExport]=\"true\"\r\n\t\t[allowExcelExport]=\"true\"\r\n\t\t(excelQueryCellInfo)=\"exportQueryCellInfo($event)\"\r\n\t>\r\n\t\t<e-columns>\r\n\t\t\t<e-column\r\n\t\t\t\t*ngFor=\"let item of fields\"\r\n\t\t\t\t[field]=\"item.colName\"\r\n\t\t\t\t[headerText]=\"\r\n\t\t\t\t\titem.displayName\r\n\t\t\t\t\t\t? item.displayName\r\n\t\t\t\t\t\t: item.addtionName\r\n\t\t\t\t\t\t? item.langValue + ' ' + item.addtionName\r\n\t\t\t\t\t\t: item.langValue\r\n\t\t\t\t\"\r\n\t\t\t\t[visible]=\"item.visible\"\r\n\t\t\t\twidth=\"200\"\r\n\t\t\t\t[type]=\"\r\n\t\t\t\t\titem.dataType === 'number' ||\r\n\t\t\t\t\titem.dataType === 'percentNum' ||\r\n\t\t\t\t\titem.dataType === 'percent'\r\n\t\t\t\t\t\t? 'number'\r\n\t\t\t\t\t\t: item.dataType == 'date' || item.dataType == 'datetime'\r\n\t\t\t\t\t\t? 'date'\r\n\t\t\t\t\t\t: null\r\n\t\t\t\t\"\r\n\t\t\t\tclipMode=\"EllipsisWithTooltip\"\r\n\t\t\t\t[format]=\"getFormatOptions(item.colName)\"\r\n\t\t\t>\r\n\t\t\t</e-column>\r\n\t\t</e-columns>\r\n\t</ejs-grid>\r\n\t<div class=\"full-box-mask\" *ngIf=\"pageLoading\">\r\n\t\t<mat-spinner\r\n\t\t\tstyle=\"z-index: 999\"\r\n\t\t\tmode=\"indeterminate\"\r\n\t\t\t[diameter]=\"24\"\r\n\t\t></mat-spinner>\r\n\t</div>\r\n</div>\r\n",
+                providers: [ExcelExportService, ColumnChooserService, VirtualScrollService],
+                styles: [".e-bigger{height:100%}.transpose-grid{padding:0 12px 12px}.transpose-grid .e-gridcontent{border:0}.transpose-grid .e-gridcontent .e-content{width:100%!important}.transpose-grid .e-gridcontent .e-content .e-rowcell{padding:0 12px 0 55%!important;font-family:Arial;font-size:11px!important;font-weight:400;line-height:14px;background-color:#fff!important}td{border-bottom:1px solid #eff1f3!important;display:inline-block;height:35px!important;font-size:13px!important;text-align:right}td::before{color:#0b5496!important;text-align:left}:host::ng-deep .e-bigger ejs-grid{height:100%!important}:host::ng-deep .e-ccdlg.e-cc.e-control.e-dialog.e-lib.e-popup.e-popup-open{max-height:300px!important;z-index:100000!important;top:14px!important;left:200px!important}:host::ng-deep .e-bigger .e-dialog .e-dlg-header-content,:host::ng-deep .e-bigger.e-dialog .e-dlg-header-content{padding:14px!important}:host::ng-deep .e-bigger .e-dialog .e-dlg-header,:host::ng-deep .e-bigger.e-dialog .e-dlg-header{font-size:16px!important}:host::ng-deep .e-grid .e-ccdlg li.e-cclist{padding:7px 0!important;height:37px!important}:host::ng-deep .e-checkbox-wrapper .e-label,:host::ng-deep .e-css.e-checkbox-wrapper .e-label{font-size:14px!important}:host::ng-deep .e-btn,:host::ng-deep .e-css.e-btn{font-size:14px!important;padding:4px 8px!important}:host::ng-deep .e-dialog .e-footer-content{padding:14px!important}:host::ng-deep .e-bigger .e-float-input input,:host::ng-deep .e-bigger .e-float-input input.e-input,:host::ng-deep .e-bigger .e-float-input.e-control-wrapper input,:host::ng-deep .e-bigger .e-float-input.e-control-wrapper input.e-input,:host::ng-deep .e-bigger .e-input-group input,:host::ng-deep .e-bigger .e-input-group input.e-input,:host::ng-deep .e-bigger .e-input-group.e-control-wrapper input,:host::ng-deep .e-bigger .e-input-group.e-control-wrapper input.e-input,:host::ng-deep .e-float-input.e-bigger input,:host::ng-deep .e-float-input.e-bigger input.e-input,:host::ng-deep .e-float-input.e-control-wrapper.e-bigger input,:host::ng-deep .e-float-input.e-control-wrapper.e-bigger input.e-input,:host::ng-deep .e-input-group.e-bigger input,:host::ng-deep .e-input-group.e-bigger input.e-input,:host::ng-deep .e-input-group.e-control-wrapper.e-bigger input,:host::ng-deep .e-input-group.e-control-wrapper.e-bigger input.e-input,:host::ng-deep input.e-input.e-bigger{height:29px!important}:host::ng-deep .e-label{margin-left:7px!important}:host::ng-deep .e-grid .e-ccdlg .e-cc-contentdiv{height:121px!important}::ng-deep kt-gadget-transpose .e-grid .e-dialog.e-ccdlg{width:300px!important}::ng-deep kt-gadget-transpose .e-checkbox-wrapper.e-css{width:100%!important}::ng-deep kt-gadget-transpose .e-grid .e-row:not(.e-disable-gridhover):not(.e-editedrow):not(.e-detailrow):hover .e-rowcell:not(.e-cellselectionbackground):not(.e-active):not(.e-updatedtd):not(.e-indentcell).odd{background:#f8fafb!important}::ng-deep kt-gadget-transpose .e-grid .e-row:not(.e-disable-gridhover):not(.e-editedrow):not(.e-detailrow):hover .e-rowcell:not(.e-cellselectionbackground):not(.e-active):not(.e-updatedtd):not(.e-indentcell).even{background:#fff!important}::ng-deep kt-gadget-transpose .e-spin-show,::ng-deep kt-gadget-transpose .e-spinner-pane{display:none!important}::ng-deep kt-gadget-transpose .e-label{display:inline-block!important;width:calc(100% - 30px)!important;overflow:hidden!important;white-space:nowrap!important;height:16px!important;line-height:16px!important}::ng-deep kt-gadget-transpose .e-table .e-row{height:auto!important}::ng-deep kt-gadget-transpose .e-table .e-row td{height:22px!important;line-height:22px!important;color:#44566c!important;border-color:#eff1f3!important}::ng-deep kt-gadget-transpose .e-table .e-row td.first-cell{border-top:1px solid #eff1f3!important}::ng-deep kt-gadget-transpose .e-table .e-row td::before{top:0!important;left:0!important;color:#44566c!important}::ng-deep kt-gadget-transpose .e-table .odd{background:#f8fafb!important}::ng-deep kt-gadget-transpose .e-table .even{background:#fff!important}::ng-deep kt-gadget-transpose .e-bigger .e-grid.e-row-responsive .e-gridcontent .e-row,::ng-deep kt-gadget-transpose .e-bigger .e-grid.e-row-responsive .e-summarycontent .e-row,::ng-deep kt-gadget-transpose .e-bigger.e-grid.e-row-responsive .e-gridcontent .e-row,::ng-deep kt-gadget-transpose .e-bigger.e-grid.e-row-responsive .e-summarycontent .e-row{border-color:#eff1f3!important}::ng-deep kt-gadget-transpose .full-screen-mask{width:100%;height:100%;background:rgba(0,0,0,.3);position:absolute;top:0;left:0;z-index:9999}::ng-deep kt-gadget-transpose mat-spinner.mat-spinner.mat-progress-spinner.mat-primary.mat-progress-spinner-indeterminate-animation{position:absolute;top:45%;left:47.5%!important;transform:translate(-25%,-25%)}"]
+            }] }
+];
+/** @nocollapse */
+GadgetTransposeComponent.ctorParameters = () => [
+    { type: DashboardPorletsService },
+    { type: DashboardService },
+    { type: ChangeDetectorRef },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [PBF_TOKEN,] }] }
+];
+GadgetTransposeComponent.propDecorators = {
+    portlet: [{ type: Input }],
+    portlets: [{ type: Input }],
+    dashboard: [{ type: Input }],
+    grid: [{ type: ViewChild, args: ["grid", { static: false },] }]
+};
+if (false) {
+    /** @type {?} */
+    GadgetTransposeComponent.prototype.portlet;
+    /** @type {?} */
+    GadgetTransposeComponent.prototype.portlets;
+    /** @type {?} */
+    GadgetTransposeComponent.prototype.dashboard;
+    /** @type {?} */
+    GadgetTransposeComponent.prototype.grid;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTransposeComponent.prototype.translation;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTransposeComponent.prototype.userInfo;
+    /** @type {?} */
+    GadgetTransposeComponent.prototype.datePipeFormat;
+    /** @type {?} */
+    GadgetTransposeComponent.prototype.fields;
+    /** @type {?} */
+    GadgetTransposeComponent.prototype.data;
+    /** @type {?} */
+    GadgetTransposeComponent.prototype.pageSettings;
+    /** @type {?} */
+    GadgetTransposeComponent.prototype.pageLoading;
+    /** @type {?} */
+    GadgetTransposeComponent.prototype.filter;
+    /** @type {?} */
+    GadgetTransposeComponent.prototype.rowMode;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTransposeComponent.prototype.formatSettings;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTransposeComponent.prototype.config;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTransposeComponent.prototype.tranposeData;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTransposeComponent.prototype.subscriptions;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTransposeComponent.prototype.quarterFormat;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTransposeComponent.prototype.formatDates;
+    /** @type {?} */
+    GadgetTransposeComponent.prototype.ColumnChooserSettings;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTransposeComponent.prototype.DashboardPorletsService;
+    /** @type {?} */
+    GadgetTransposeComponent.prototype.dashboardService;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTransposeComponent.prototype.ref;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTransposeComponent.prototype.pbf;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gadget-transpose.component.js","sourceRoot":"ng://raise-common-lib/","sources":["lib/dashboard/gadget-group/gadget-transpose/gadget-transpose.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n\tComponent,\r\n\tOnInit,\r\n\tInput,\r\n\tViewChild,\r\n\tChangeDetectorRef,\r\n\tInject,\r\n\tOptional,\r\n} from \"@angular/core\";\r\nimport { DashboardPorletsService } from \"../../dashboardPorlets.service\";\r\nimport {\r\n\tPageSettingsModel,\r\n\tGridComponent,\r\n\tQueryCellInfoEventArgs,\r\n\tColumnChooserService,\r\n\tExcelExportService,\r\n\tFilterSettingsModel,\r\n\tColumnChooserSettingsModel,\r\n\tVirtualScrollService,\r\n} from \"@syncfusion/ej2-angular-grids\";\r\nimport { DashboardService } from \"../../dashboard.service\";\r\nimport moment from \"moment\";\r\nimport { Subscription } from \"rxjs\";\r\nimport { DataUtil } from \"@syncfusion/ej2-data\";\r\nimport { PBF_TOKEN } from \"../../../service/InjectionToken\";\r\n\r\n@Component({\r\n\tselector: \"kt-gadget-transpose\",\r\n\ttemplateUrl: \"./gadget-transpose.component.html\",\r\n\tstyleUrls: [\"./gadget-transpose.component.scss\"],\r\n\tproviders: [ExcelExportService, ColumnChooserService, VirtualScrollService],\r\n})\r\nexport class GadgetTransposeComponent implements OnInit {\r\n\t@Input() portlet;\r\n\t@Input() portlets;\r\n\t@Input() dashboard;\r\n\t@ViewChild(\"grid\", { static: false }) public grid: GridComponent;\r\n\tprivate translation;\r\n\tprivate userInfo;\r\n\tpublic datePipeFormat;\r\n\tpublic fields = [];\r\n\tpublic data;\r\n\tpublic pageSettings: PageSettingsModel;\r\n\tpublic pageLoading = false;\r\n\t// public filterSettings: FilterSettingsModel;\r\n\tpublic filter: Object;\r\n\tpublic rowMode: string;\r\n\tprivate formatSettings = [];\r\n\tprivate config;\r\n\tprivate tranposeData;\r\n\tprivate subscriptions: Subscription[] = [];\r\n\tprivate quarterFormat = [\r\n\t\t{ value: \"03/2021\", format: \"MM/yyyy\" },\r\n\t\t{ value: \"03/21\", format: \"MM/dd\" },\r\n\t\t{ value: \"3/2021\", format: \"M/yyyy\" },\r\n\t\t{ value: \"3/21\", format: \"M/yy\" },\r\n\t\t{ value: \"March 2021\", format: \"MMMM yyyy\" },\r\n\t\t{ value: \"Mar, 2021\", format: \"MMM, yyyy\" },\r\n\t\t{ value: \"March, 2021\", format: \"MMMM, yyyy\" },\r\n\t\t{ value: \"2021\", format: \"yyyy\" },\r\n\t];\r\n\tprivate formatDates = [];\r\n\tpublic ColumnChooserSettings: ColumnChooserSettingsModel;\r\n\r\n\tconstructor(\r\n\t\tprivate DashboardPorletsService: DashboardPorletsService,\r\n\t\tpublic dashboardService: DashboardService,\r\n\t\tprivate ref: ChangeDetectorRef,\r\n\t\t@Optional() @Inject(PBF_TOKEN) private pbf: any,\r\n\t) {}\r\n\r\n\tngOnInit() {\r\n\t\tthis.getInfo();\r\n\t\tthis.pageSettings = { pageSizes: true, pageSize: 20 };\r\n\t\tthis.ColumnChooserSettings = { operator: \"contains\" };\r\n\t\tthis.filter = { type: \"CheckBox\" };\r\n\t\tthis.rowMode = \"Vertical\";\r\n\t\tthis.getTableData();\r\n\t}\r\n\tngAfterViewInit() {\r\n\t\tthis.subscriptions.push(\r\n\t\t\tthis.dashboardService.getUpdated().subscribe((newId) => {\r\n\t\t\t\tif (newId === this.portlet.newId || newId === this.portlet.id) {\r\n\t\t\t\t\tthis.getTableData();\r\n\t\t\t\t}\r\n\t\t\t})\r\n\t\t);\r\n\t\tthis.subscriptions.push(\r\n\t\t\tthis.dashboardService.getStartRefresh().subscribe((dashboardId) => {\r\n\t\t\t\tif (this.dashboard.id === dashboardId) {\r\n\t\t\t\t\tthis.pageLoading = true;\r\n\t\t\t\t\tthis.ref.markForCheck();\r\n\t\t\t\t}\r\n\t\t\t})\r\n\t\t);\r\n\r\n\t\tthis.subscriptions.push(\r\n\t\t\tthis.dashboardService.getRefreshGadget().subscribe((e) => {\r\n\t\t\t\tif (!e) {\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\t\t\t\tconst id = e[\"newId\"];\r\n\t\t\t\tif (id === this.portlet.newId || id === this.portlet.id) {\r\n\t\t\t\t\tthis.getTableData();\r\n\t\t\t\t}\r\n\t\t\t})\r\n\t\t);\r\n\t\tthis.subscriptions.push(\r\n\t\t\tthis.dashboardService.getTableFormat().subscribe((id) => {\r\n\t\t\t\tif (id === this.portlet.newId || id === this.portlet.id) {\r\n\t\t\t\t\tthis.getTableData();\r\n\t\t\t\t\tthis.grid.columns.forEach((item) => {\r\n\t\t\t\t\t\tthis.fields.forEach((table) => {\r\n\t\t\t\t\t\t\tif (\r\n\t\t\t\t\t\t\t\titem.field === table.colName &&\r\n\t\t\t\t\t\t\t\ttable.format &&\r\n\t\t\t\t\t\t\t\ttable.format.length &&\r\n\t\t\t\t\t\t\t\ttable.format[0].formatChecked\r\n\t\t\t\t\t\t\t) {\r\n\t\t\t\t\t\t\t\titem.headerText =\r\n\t\t\t\t\t\t\t\t\ttable.displayName ||\r\n\t\t\t\t\t\t\t\t\ttable.langValue ||\r\n\t\t\t\t\t\t\t\t\tthis.translation[table.langCode] ||\r\n\t\t\t\t\t\t\t\t\ttable.langCode;\r\n\t\t\t\t\t\t\t\tif (\r\n\t\t\t\t\t\t\t\t\ttable.format &&\r\n\t\t\t\t\t\t\t\t\t(table.dataType === \"number\" ||\r\n\t\t\t\t\t\t\t\t\t\ttable.dataType === \"percent\")\r\n\t\t\t\t\t\t\t\t) {\r\n\t\t\t\t\t\t\t\t\tlet formatString;\r\n\t\t\t\t\t\t\t\t\tif (table.dataType === \"number\") {\r\n\t\t\t\t\t\t\t\t\t\tformatString = this.pbf.formatNumber(\r\n\t\t\t\t\t\t\t\t\t\t\ttable.format[0].selectedFormat\r\n\t\t\t\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\t\t\t} else if (table.dataType === \"percent\") {\r\n\t\t\t\t\t\t\t\t\t\tformatString = this.pbf.formatPercent(\r\n\t\t\t\t\t\t\t\t\t\t\ttable.format[0].selectedFormat\r\n\t\t\t\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t\t\titem.format = formatString;\r\n\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t});\r\n\t\t\t\t\t});\r\n\t\t\t\t\tthis.grid.refreshColumns();\r\n\t\t\t\t}\r\n\t\t\t})\r\n\t\t);\r\n\t}\r\n\r\n\tngOnDestroy(): void {\r\n\t\tthis.subscriptions.forEach((sub) => sub.unsubscribe());\r\n\t}\r\n\r\n\tprivate getTableData() {\r\n\t\tthis.pageLoading = false;\r\n\t\tthis.config = JSON.parse(this.portlet.config);\r\n\t\tif (this.config.fields) {\r\n\t\t\tlet fields = this.config.fields.filter((fl) => !fl.isHidden);\r\n\t\t\tconst fieldsCopy = JSON.parse(JSON.stringify(fields));\r\n\t\t\tif (fieldsCopy.length) {\r\n\t\t\t\tlet _index = 0;\r\n\t\t\t\tthis.fields = fieldsCopy.map((el) => {\r\n\t\t\t\t\t// 处理format的displayName，之前未赋值\r\n\t\t\t\t\tlet displayName = \"\";\r\n\t\t\t\t\tif (\r\n\t\t\t\t\t\tArray.isArray(el.format) &&\r\n\t\t\t\t\t\tel.format.length > 0 &&\r\n\t\t\t\t\t\tel.format[0].formatChecked\r\n\t\t\t\t\t) {\r\n\t\t\t\t\t\tdisplayName = el.format[0].displayName;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif (el.visible) {\r\n\t\t\t\t\t\t_index += 1;\r\n\t\t\t\t\t\treturn {\r\n\t\t\t\t\t\t\t...el,\r\n\t\t\t\t\t\t\t_index,\r\n\t\t\t\t\t\t\tdisplayName,\r\n\t\t\t\t\t\t};\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\treturn {\r\n\t\t\t\t\t\t\t...el,\r\n\t\t\t\t\t\t\t_index: null,\r\n\t\t\t\t\t\t\tdisplayName,\r\n\t\t\t\t\t\t};\r\n\t\t\t\t\t}\r\n\t\t\t\t});\r\n\t\t\t}\r\n\t\t}\r\n\t\tthis.tranposeData = this.DashboardPorletsService.getResultByDataTable(\r\n\t\t\tthis.portlet,\r\n\t\t\tfalse,\r\n\t\t\tfalse,\r\n\t\t\tthis.dashboard.id\r\n\t\t);\r\n\t\tthis.tranposeData = DataUtil.parse.parseJson(this.tranposeData);\r\n\t\tif (this.tranposeData && this.tranposeData.length)\r\n\t\t\tthis.filterData((res) => {\r\n\t\t\t\tif (this.config && this.fields && this.fields.length) {\r\n\t\t\t\t\tthis.formatSettings = [];\r\n\t\t\t\t\tthis.fields.map((el) => {\r\n\t\t\t\t\t\tlet numberTypes = [\r\n\t\t\t\t\t\t\t\"number\",\r\n\t\t\t\t\t\t\t\"percent\",\r\n\t\t\t\t\t\t\t\"percentNum\",\r\n\t\t\t\t\t\t\t\"multiple\",\r\n\t\t\t\t\t\t];\r\n\t\t\t\t\t\tif (numberTypes.includes(el.dataType)) {\r\n\t\t\t\t\t\t\tlet format = this.getNumFormat(el);\r\n\t\t\t\t\t\t\tconst formatData = {\r\n\t\t\t\t\t\t\t\tname: el.colName,\r\n\t\t\t\t\t\t\t\tformat: format,\r\n\t\t\t\t\t\t\t};\r\n\t\t\t\t\t\t\t// if (el.dataType === \"number\")\r\n\t\t\t\t\t\t\t// \tformatData[\"useGrouping\"] = true;\r\n\t\t\t\t\t\t\tthis.formatSettings.push(formatData);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tif (\r\n\t\t\t\t\t\t\tel.dataType == \"datetime\" ||\r\n\t\t\t\t\t\t\tel.dataType == \"date\"\r\n\t\t\t\t\t\t) {\r\n\t\t\t\t\t\t\tlet format = \"\";\r\n\t\t\t\t\t\t\tif (\r\n\t\t\t\t\t\t\t\tel.format &&\r\n\t\t\t\t\t\t\t\tel.format.length &&\r\n\t\t\t\t\t\t\t\tel.format[0].formatChecked\r\n\t\t\t\t\t\t\t) {\r\n\t\t\t\t\t\t\t\tif (el.format[0].compareValue2 == \"Quarter\") {\r\n\t\t\t\t\t\t\t\t\tlet format_ =\r\n\t\t\t\t\t\t\t\t\t\tel.format[0].selectedFormatDisplay;\r\n\t\t\t\t\t\t\t\t\tlet formatInfo = this.quarterFormat.filter(\r\n\t\t\t\t\t\t\t\t\t\t(qur) => qur.value == format_\r\n\t\t\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\t\t\tif (formatInfo.length) {\r\n\t\t\t\t\t\t\t\t\t\tformat = formatInfo[0].format;\r\n\t\t\t\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\t\t\t\tconst formatData = {\r\n\t\t\t\t\t\t\t\t\t\t\tname: el.colName,\r\n\t\t\t\t\t\t\t\t\t\t\tformat: format_,\r\n\t\t\t\t\t\t\t\t\t\t\ttype: \"date\",\r\n\t\t\t\t\t\t\t\t\t\t};\r\n\t\t\t\t\t\t\t\t\t\tthis.formatDates.push(formatData);\r\n\t\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t\t} else if (\r\n\t\t\t\t\t\t\t\t\tel.format[0].compareValue2 == \"Date\"\r\n\t\t\t\t\t\t\t\t) {\r\n\t\t\t\t\t\t\t\t\tlet fromIdx =\r\n\t\t\t\t\t\t\t\t\t\tel.format[0].selectedFormatDisplay.indexOf(\r\n\t\t\t\t\t\t\t\t\t\t\t\"(\"\r\n\t\t\t\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\t\t\tlet toIdx =\r\n\t\t\t\t\t\t\t\t\t\tel.format[0].selectedFormatDisplay.indexOf(\r\n\t\t\t\t\t\t\t\t\t\t\t\")\"\r\n\t\t\t\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\t\t\tlet format_ =\r\n\t\t\t\t\t\t\t\t\t\tel.format[0].selectedFormatDisplay.slice(\r\n\t\t\t\t\t\t\t\t\t\t\tfromIdx + 1,\r\n\t\t\t\t\t\t\t\t\t\t\ttoIdx\r\n\t\t\t\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\t\t\tswitch (format_) {\r\n\t\t\t\t\t\t\t\t\t\tcase \"DD/MM/YYYY\":\r\n\t\t\t\t\t\t\t\t\t\t\tformat = \"dd/MM/yyyy\";\r\n\t\t\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t\t\t\tcase \"DD/MM/YY\":\r\n\t\t\t\t\t\t\t\t\t\t\tformat = \"dd/MM/yy\";\r\n\t\t\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t\t\t\tcase \"MM/DD/YYYY\":\r\n\t\t\t\t\t\t\t\t\t\t\tformat = \"MM/dd/yyyy\";\r\n\t\t\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t\t\t\tcase \"MM/DD/YY\":\r\n\t\t\t\t\t\t\t\t\t\t\tformat = \"MM/dd/yy\";\r\n\t\t\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t\t\t\tcase \"YYYY-MM-DD\":\r\n\t\t\t\t\t\t\t\t\t\t\tformat = \"yyyy-MM-dd\";\r\n\t\t\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t\t\t\tcase \"YY-MM-DD\":\r\n\t\t\t\t\t\t\t\t\t\t\tformat = \"yy-MM-dd\";\r\n\t\t\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t\t\t\tcase \"DD-MM-YYYY\":\r\n\t\t\t\t\t\t\t\t\t\t\tformat = \"dd-MM-yyyy\";\r\n\t\t\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t\t\t\tcase \"DD-MM-YY\":\r\n\t\t\t\t\t\t\t\t\t\t\tformat = \"dd-MM-yy\";\r\n\t\t\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t\t\t\tcase \"MM-DD-YYYY\":\r\n\t\t\t\t\t\t\t\t\t\t\tformat = \"MM-dd-yyyy\";\r\n\t\t\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t\t\t\tcase \"MM-DD-YY\":\r\n\t\t\t\t\t\t\t\t\t\t\tformat = \"MM-dd-yy\";\r\n\t\t\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t\t\t\tcase \"MMM DD, YYYY\":\r\n\t\t\t\t\t\t\t\t\t\t\tformat = \"MMM dd, yyyy\";\r\n\t\t\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t\t\t\tcase \"DD-MMM-YYYY\":\r\n\t\t\t\t\t\t\t\t\t\t\tformat = \"dd-MMM-yyyy\";\r\n\t\t\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t\t\t\tdefault:\r\n\t\t\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\tif (!format) {\r\n\t\t\t\t\t\t\t\tconst formatData = {\r\n\t\t\t\t\t\t\t\t\tname: el.colName,\r\n\t\t\t\t\t\t\t\t\tformat: this.datePipeFormat,\r\n\t\t\t\t\t\t\t\t\ttype: \"date\",\r\n\t\t\t\t\t\t\t\t};\r\n\t\t\t\t\t\t\t\tthis.formatSettings.push(formatData);\r\n\t\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\t\tconst formatData = {\r\n\t\t\t\t\t\t\t\t\tname: el.colName,\r\n\t\t\t\t\t\t\t\t\tformat: format,\r\n\t\t\t\t\t\t\t\t\ttype: \"date\",\r\n\t\t\t\t\t\t\t\t};\r\n\t\t\t\t\t\t\t\tthis.formatSettings.push(formatData);\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t});\r\n\t\t\t\t}\r\n\t\t\t\tif (this.grid) this.grid.refresh();\r\n\t\t\t\tthis.ref.markForCheck();\r\n\t\t\t\tthis.ref.detectChanges();\r\n\t\t\t});\r\n\t}\r\n\r\n\tprivate filterData(callback) {\r\n\t\tthis.data = [];\r\n\t\tif (this.config.filterSettings && this.config.filterSettings.length) {\r\n\t\t\tif (this.tranposeData) {\r\n\t\t\t\tlet dataType = this.fields.filter(\r\n\t\t\t\t\t(el) => el.colName == this.config.filterSettings[0].field\r\n\t\t\t\t).length\r\n\t\t\t\t\t? this.fields.filter(\r\n\t\t\t\t\t\t\t(el) =>\r\n\t\t\t\t\t\t\t\tel.colName ==\r\n\t\t\t\t\t\t\t\tthis.config.filterSettings[0].field\r\n\t\t\t\t\t  )[0].dataType\r\n\t\t\t\t\t: \"\";\r\n\t\t\t\tlet transpose_data = [];\r\n\t\t\t\tif (dataType == \"date\" || dataType == \"datetime\") {\r\n\t\t\t\t\ttranspose_data = this.tranposeData.filter(\r\n\t\t\t\t\t\t(el) =>\r\n\t\t\t\t\t\t\tmoment(\r\n\t\t\t\t\t\t\t\tel[this.config.filterSettings[0].field]\r\n\t\t\t\t\t\t\t).format(\"YYYY-MM-DD\") ==\r\n\t\t\t\t\t\t\tmoment(this.config.filterSettings[0].value).format(\r\n\t\t\t\t\t\t\t\t\"YYYY-MM-DD\"\r\n\t\t\t\t\t\t\t)\r\n\t\t\t\t\t);\r\n\t\t\t\t} else {\r\n\t\t\t\t\ttranspose_data = this.tranposeData.filter(\r\n\t\t\t\t\t\t(el) =>\r\n\t\t\t\t\t\t\tel[this.config.filterSettings[0].field] ==\r\n\t\t\t\t\t\t\tthis.config.filterSettings[0].value\r\n\t\t\t\t\t);\r\n\t\t\t\t}\r\n\t\t\t\tif (transpose_data.length) {\r\n\t\t\t\t\tthis.data.push(transpose_data[0]);\r\n\t\t\t\t} else {\r\n\t\t\t\t\tthis.data.push(this.tranposeData[0]);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tthis.data.push(this.tranposeData[0]);\r\n\t\t}\r\n\t\t// if (this.grid) this.grid.refresh();\r\n\t\tcallback();\r\n\t}\r\n\r\n\tprivate getInfo() {\r\n\t\tthis.translation = JSON.parse(localStorage.getItem(\"translation\"));\r\n\t\tthis.datePipeFormat = localStorage.getItem(\"datePipe\");\r\n\t}\r\n\tgetFormatOptions(colName) {\r\n\t\tlet res = this.formatSettings.filter((el) => el.name === colName);\r\n\t\tif (res && res.length) {\r\n\t\t\t// let obj = JSON.parse(JSON.stringify(res[0]));\r\n\t\t\t// delete obj.name;\r\n\t\t\t// return obj;\r\n\t\t\treturn res[0].format;\r\n\t\t}\r\n\t}\r\n\r\n\tcustomiseCell(args: QueryCellInfoEventArgs) {\r\n\t\tlet queryCell = this.fields.filter(\r\n\t\t\t(item) => item.colName === args.column.field\r\n\t\t)[0];\r\n\t\tif (\r\n\t\t\tqueryCell &&\r\n\t\t\tqueryCell.format &&\r\n\t\t\tqueryCell.format.length &&\r\n\t\t\tqueryCell.format[0].formatChecked\r\n\t\t) {\r\n\t\t\t// SMP2-3416 0的format start\r\n\t\t\tif (\r\n\t\t\t\t[2, 5, 8, 11, 14, 17].includes(\r\n\t\t\t\t\tqueryCell.format[0].selectedFormat\r\n\t\t\t\t) &&\r\n\t\t\t\targs.data[queryCell.colName] === 0\r\n\t\t\t)\r\n\t\t\t\targs.cell.innerHTML = \"-\";\r\n\t\t\tif (\r\n\t\t\t\t[3, 6, 9, 12, 15, 18].includes(\r\n\t\t\t\t\tqueryCell.format[0].selectedFormat\r\n\t\t\t\t) &&\r\n\t\t\t\targs.data[queryCell.colName] === 0\r\n\t\t\t)\r\n\t\t\t\targs.cell.innerHTML = \"\";\r\n\t\t\t// SMP2-3416 0的format end\r\n\t\t}\r\n\t\tif (queryCell && queryCell._index) {\r\n\t\t\tif (queryCell._index === 1) {\r\n\t\t\t\targs.cell.classList.add(\"first-cell\");\r\n\t\t\t}\r\n\t\t\t// args.cell.classList.add(\r\n\t\t\t// \t`${queryCell._index % 2 === 0 ? \"even\" : \"odd\"}`\r\n\t\t\t// );\r\n\t\t\tthis.ref.markForCheck();\r\n\t\t}\r\n\t\tif (\r\n\t\t\tqueryCell &&\r\n\t\t\tqueryCell.format &&\r\n\t\t\tqueryCell.format.length &&\r\n\t\t\tqueryCell.format[0].fontSettingChecked\r\n\t\t) {\r\n\t\t\tif (\r\n\t\t\t\tqueryCell.format[0].formatChecked &&\r\n\t\t\t\tqueryCell.format[0].compareSelect\r\n\t\t\t) {\r\n\t\t\t\tlet cellData = args.data[args.column.field];\r\n\t\t\t\tlet condition: Boolean = false;\r\n\t\t\t\tswitch (queryCell.format[0].compareSelect) {\r\n\t\t\t\t\tcase \"LessThan\":\r\n\t\t\t\t\t\tcondition =\r\n\t\t\t\t\t\t\tcellData <\r\n\t\t\t\t\t\t\tNumber(queryCell.format[0].compareValue1);\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t\tcase \"LessThanOrEqualTo\":\r\n\t\t\t\t\t\tcondition =\r\n\t\t\t\t\t\t\tcellData <=\r\n\t\t\t\t\t\t\tNumber(queryCell.format[0].compareValue1);\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t\tcase \"GreaterThan\":\r\n\t\t\t\t\t\tcondition =\r\n\t\t\t\t\t\t\tcellData >\r\n\t\t\t\t\t\t\tNumber(queryCell.format[0].compareValue1);\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t\tcase \"GreaterThanOrEqualTo\":\r\n\t\t\t\t\t\tcondition =\r\n\t\t\t\t\t\t\tcellData >=\r\n\t\t\t\t\t\t\tNumber(queryCell.format[0].compareValue1);\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t\tcase \"Equals\":\r\n\t\t\t\t\t\tcondition =\r\n\t\t\t\t\t\t\tcellData ===\r\n\t\t\t\t\t\t\tNumber(queryCell.format[0].compareValue1);\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t\tcase \"NotEquals\":\r\n\t\t\t\t\t\tcondition =\r\n\t\t\t\t\t\t\tcellData !==\r\n\t\t\t\t\t\t\tNumber(queryCell.format[0].compareValue1);\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t\tcase \"Between\":\r\n\t\t\t\t\t\tcondition =\r\n\t\t\t\t\t\t\tcellData >=\r\n\t\t\t\t\t\t\t\tNumber(queryCell.format[0].compareValue1) &&\r\n\t\t\t\t\t\t\tcellData <= queryCell.format[0].compareValue2;\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t\tcase \"NotBetween\":\r\n\t\t\t\t\t\tcondition =\r\n\t\t\t\t\t\t\tcellData <\r\n\t\t\t\t\t\t\t\tNumber(queryCell.format[0].compareValue1) &&\r\n\t\t\t\t\t\t\tcellData >\r\n\t\t\t\t\t\t\t\tNumber(queryCell.format[0].compareValue2);\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t\tdefault:\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t}\r\n\t\t\t\tif (condition) this.cellAddStyle(args, queryCell);\r\n\t\t\t} else this.cellAddStyle(args, queryCell);\r\n\t\t}\r\n\r\n\t\t// date format about quarterly\r\n\r\n\t\tif (this.formatDates && this.formatDates.length) {\r\n\t\t\tlet dateFields = this.formatDates.map((el) => {\r\n\t\t\t\treturn el.name;\r\n\t\t\t});\r\n\t\t\tif (\r\n\t\t\t\targs.column.field &&\r\n\t\t\t\tdateFields.includes(args.column.field) &&\r\n\t\t\t\tqueryCell.format &&\r\n\t\t\t\tqueryCell.format.length &&\r\n\t\t\t\tqueryCell.format[0].formatChecked\r\n\t\t\t) {\r\n\t\t\t\tlet date = new Date(args.data[args.column.field]);\r\n\r\n\t\t\t\tlet quarter =\r\n\t\t\t\t\tMath.floor((date.getMonth() + 1) % 3) == 0\r\n\t\t\t\t\t\t? Math.floor((date.getMonth() + 1) / 3)\r\n\t\t\t\t\t\t: Math.floor((date.getMonth() + 1) / 3) + 1;\r\n\r\n\t\t\t\tlet format;\r\n\r\n\t\t\t\tthis.formatDates.map((el) => {\r\n\t\t\t\t\tif (el.name == args.column.field) format = el.format;\r\n\t\t\t\t});\r\n\t\t\t\tlet year: any;\r\n\t\t\t\tswitch (format) {\r\n\t\t\t\t\tcase \"Q1 2021\":\r\n\t\t\t\t\t\tyear = date.getFullYear();\r\n\t\t\t\t\t\targs.cell.innerHTML = \"Q\" + quarter + \" \" + year;\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t\tcase \"Q1 21\":\r\n\t\t\t\t\t\tyear = (date as any).getYear() - 100;\r\n\t\t\t\t\t\targs.cell.innerHTML = \"Q\" + quarter + \" \" + year;\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t\tcase \"2021 Q1\":\r\n\t\t\t\t\t\tyear = date.getFullYear();\r\n\t\t\t\t\t\targs.cell.innerHTML = year + \" \" + \"Q\" + quarter;\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t\tcase \"21 Q1\":\r\n\t\t\t\t\t\tyear = (date as any).getYear() - 100;\r\n\t\t\t\t\t\targs.cell.innerHTML = year + \" \" + \"Q\" + quarter;\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tcellAddStyle(args, queryCell) {\r\n\t\tif (queryCell.format[0].fontSettingChecked) {\r\n\t\t\tlet formatCellData = args.data[args.column.field];\r\n\t\t\tif (Math.sign(formatCellData) !== 0)\r\n\t\t\t\tif (Math.sign(formatCellData) === -1) {\r\n\t\t\t\t\targs.cell.style.cssText += `color: ${queryCell.format[0].negaFontColor} !important`;\r\n\t\t\t\t\targs.cell.style.cssText += `font-size: ${queryCell.format[0].negaFontSizeValue} !important`;\r\n\t\t\t\t\targs.cell.style.cssText += `font-family: ${queryCell.format[0].negaFontFamilyValue} !important`;\r\n\t\t\t\t\targs.cell.style.cssText += `background-color: ${queryCell.format[0].negaBackgroundColor} !important`;\r\n\t\t\t\t} else {\r\n\t\t\t\t\targs.cell.style.cssText += `color: ${queryCell.format[0].fontColor} !important`;\r\n\t\t\t\t\targs.cell.style.cssText += `font-size: ${queryCell.format[0].fontSizeValue} !important`;\r\n\t\t\t\t\targs.cell.style.cssText += `font-family: ${queryCell.format[0].fontFamilyValue} !important`;\r\n\t\t\t\t\targs.cell.style.cssText += `background-color: ${queryCell.format[0].backgroundColor} !important`;\r\n\t\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tactionComplete(args) {\r\n\t\tif (args.requestType === \"columnstate\") {\r\n\t\t\tconst hideColumns = this.grid.getHiddenColumns();\r\n\t\t\tthis.fields.map((el) => (el.visible = true));\r\n\t\t\tif (hideColumns.length > 0) {\r\n\t\t\t\tfor (let hideitem of hideColumns) {\r\n\t\t\t\t\tthis.fields.forEach((field) => {\r\n\t\t\t\t\t\tif (field.colName === hideitem.field) {\r\n\t\t\t\t\t\t\tfield.visible = false;\r\n\t\t\t\t\t\t\tfield._index = null;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t});\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\tlet _index = 0;\r\n\t\t\tthis.fields.forEach((field) => {\r\n\t\t\t\tif (field.visible) {\r\n\t\t\t\t\t_index += 1;\r\n\t\t\t\t\tfield._index = _index;\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t\t\tthis.config.fields = JSON.parse(JSON.stringify(this.fields));\r\n\t\t\tconst portlet = this.portlet;\r\n\t\t\tportlet.config = JSON.stringify(this.config);\r\n\t\t\tconst index = this.portlets.findIndex(\r\n\t\t\t\t(x) => x.newId === portlet.newId\r\n\t\t\t);\r\n\t\t\tthis.portlets[index].config = JSON.stringify(this.config);\r\n\r\n\t\t\tif (this.grid) this.grid.refresh();\r\n\t\t}\r\n\t}\r\n\texportQueryCellInfo(args): void {\r\n\t\tif (this.formatDates && this.formatDates.length) {\r\n\t\t\tlet dateFields = this.formatDates.map((el) => {\r\n\t\t\t\treturn el.name;\r\n\t\t\t});\r\n\r\n\t\t\tif (args.column.field && dateFields.includes(args.column.field)) {\r\n\t\t\t\tlet date = new Date(args.data[args.column.field]);\r\n\r\n\t\t\t\tlet quarter =\r\n\t\t\t\t\tMath.floor((date.getMonth() + 1) % 3) == 0\r\n\t\t\t\t\t\t? Math.floor((date.getMonth() + 1) / 3)\r\n\t\t\t\t\t\t: Math.floor((date.getMonth() + 1) / 3) + 1;\r\n\r\n\t\t\t\tlet format;\r\n\r\n\t\t\t\tthis.formatDates.map((el) => {\r\n\t\t\t\t\tif (el.name == args.column.field) format = el.format;\r\n\t\t\t\t});\r\n\t\t\t\tlet year: any;\r\n\t\t\t\tswitch (format) {\r\n\t\t\t\t\tcase \"Q1 2021\":\r\n\t\t\t\t\t\tyear = date.getFullYear();\r\n\t\t\t\t\t\targs.value = \"Q\" + quarter + \" \" + year;\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t\tcase \"Q1 21\":\r\n\t\t\t\t\t\tyear = (date as any).getYear() - 100;\r\n\t\t\t\t\t\targs.value = \"Q\" + quarter + \" \" + year;\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t\tcase \"2021 Q1\":\r\n\t\t\t\t\t\tyear = date.getFullYear();\r\n\t\t\t\t\t\targs.value = year + \" \" + \"Q\" + quarter;\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t\tcase \"21 Q1\":\r\n\t\t\t\t\t\tyear = (date as any).getYear() - 100;\r\n\t\t\t\t\t\targs.value = year + \" \" + \"Q\" + quarter;\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tprivate getNumFormat(el) {\r\n\t\t//SMP2-3026\r\n\t\tif (\r\n\t\t\tel.dataType === \"number\" &&\r\n\t\t\tel.colName !== \"PortInvStk\" &&\r\n\t\t\tel.colName !== \"PortFdInvStk\"\r\n\t\t) {\r\n\t\t\tif (el.format && el.format.length && el.format[0].formatChecked) {\r\n\t\t\t\tif (\r\n\t\t\t\t\t[10, 11, 12, 13, 14, 15, 16, 17, 18].includes(\r\n\t\t\t\t\t\tel.format[0].selectedFormat\r\n\t\t\t\t\t)\r\n\t\t\t\t)\r\n\t\t\t\t\tthis.millionData(el.colName);\r\n\t\t\t\treturn this.pbf.formatNumber(el.format[0].selectedFormat);\r\n\t\t\t} else return this.DashboardPorletsService.formatNumber(el.dp);\r\n\t\t}\r\n\t\tif (el.dataType === \"percent\") {\r\n\t\t\tif (el.format && el.format.length && el.format[0].formatChecked)\r\n\t\t\t\treturn this.pbf.formatPercent(el.format[0].selectedFormat);\r\n\t\t\telse return this.DashboardPorletsService.formatPercent(el.dp);\r\n\t\t}\r\n\t\tif (el.dataType === \"percentNum\")\r\n\t\t\treturn this.DashboardPorletsService.formatPercentNum(el.dp);\r\n\t\tif (el.dataType === \"multiple\")\r\n\t\t\treturn this.DashboardPorletsService.formatMultiple(el.dp);\r\n\t}\r\n\r\n\tprivate millionData(colName) {\r\n\t\tthis.data.map((el) => {\r\n\t\t\tel[colName] = Number(el[colName] / 1000000);\r\n\t\t});\r\n\t\tif (this.config.filterSettings && this.config.filterSettings.length) {\r\n\t\t\tlet filterFields = this.config.filterSettings.map((el) => {\r\n\t\t\t\treturn el.field;\r\n\t\t\t});\r\n\t\t\tif (filterFields.includes(colName))\r\n\t\t\t\tthis.config.filterSettings.map((el) => {\r\n\t\t\t\t\tif (el.field == colName) {\r\n\t\t\t\t\t\tel.value = Number(el.value / 1000000);\r\n\t\t\t\t\t}\r\n\t\t\t\t});\r\n\t\t}\r\n\t}\r\n}\r\n"]}