raise-common-lib 0.0.206 → 0.0.207

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

@@ -0,0 +1,1553 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/dashboard/gadget-group/gadget-table/gadget-table.component.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { Component, Input, ChangeDetectorRef, ViewChild, ElementRef, Inject, Optional, } from "@angular/core";
+import { GridComponent, ExcelExportService, ColumnChooserService, VirtualScrollService, FilterService, ResizeService, PagerComponent, } from "@syncfusion/ej2-angular-grids";
+import { DashboardPorletsService } from "../../dashboardPorlets.service";
+import { ApiList } from "../../api";
+import { DashboardService } from "../../dashboard.service";
+import { DataUtil } from "@syncfusion/ej2-data";
+import { API_SERVICE_TOKEN, PBF_TOKEN } from "../../../service/InjectionToken";
+import moment from "moment";
+export class GadgetTableComponent {
+    /**
+     * @param {?} dashboardPorletsService
+     * @param {?} api
+     * @param {?} ref
+     * @param {?} dashboardService
+     * @param {?} el
+     * @param {?} pbf
+     * @param {?} http
+     */
+    constructor(dashboardPorletsService, api, ref, dashboardService, el, pbf, http) {
+        this.dashboardPorletsService = dashboardPorletsService;
+        this.api = api;
+        this.ref = ref;
+        this.dashboardService = dashboardService;
+        this.el = el;
+        this.pbf = pbf;
+        this.http = http;
+        this.tableList_footer = [];
+        this.formatSettings = [];
+        this.subscriptions = [];
+        // 已经保存过的列数据配置
+        this.configFields = [];
+        this.formatDates = [];
+        this.millionFields = [];
+        // Pager
+        this.currentPage = 1; // 当前页数
+        // 当前页数
+        this.pageSize = 10; // 一页显示行数
+    }
+    /**
+     * @return {?}
+     */
+    ngOnInit() {
+        this.getInfo();
+        this.filterSettings = { type: "Menu" };
+        this.ColumnChooserSettings = { operator: "contains" };
+        this.filter = { type: "CheckBox" };
+        this.toolbarOptions = ["ColumnChooser"];
+        this.options = { pageSize: 10, pageSizes: ["10", "50", "100"] };
+        this.quarterFormat = this.setQuarterFormat();
+        this.getTableData();
+    }
+    /**
+     * @return {?}
+     */
+    ngAfterViewInit() {
+        this.subscriptions.push(this.dashboardService.getchangeTable().subscribe((/**
+         * @param {?} updated
+         * @return {?}
+         */
+        (updated) => {
+            if (updated) {
+                this.pageSize = 10;
+                this.currentPage = 1;
+                this.getTableData();
+            }
+        })));
+        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.pageSize = 10;
+                this.currentPage = 1;
+                this.getTableData();
+            }
+        })));
+        this.subscriptions.push(this.dashboardService.getStartRefresh().subscribe((/**
+         * @param {?} dashboardId
+         * @return {?}
+         */
+        (dashboardId) => {
+            if (dashboardId === this.dashboard.id) {
+                this.pageLoading = true;
+                this.ref.markForCheck();
+            }
+        })));
+        this.subscriptions.push(this.dashboardService.getUpdated().subscribe((/**
+         * @param {?} newId
+         * @return {?}
+         */
+        (newId) => {
+            if (newId === this.portlet.newId || newId === this.portlet.id) {
+                this.pageSize = 10;
+                this.currentPage = 1;
+                this.getTableData();
+                if (this.grid) {
+                    this.grid.columns.forEach((/**
+                     * @param {?} item
+                     * @return {?}
+                     */
+                    (item) => {
+                        this.tableList.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 (["number", "percent"].includes(table.dataType)) {
+                                    /** @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();
+            }
+        })));
+        this.subscriptions.push(this.dashboardService.getTableFormat().subscribe((/**
+         * @param {?} data
+         * @return {?}
+         */
+        (data) => {
+            if (data === this.portlet.newId) {
+                this.getTableData();
+                this.grid.columns.forEach((/**
+                 * @param {?} item
+                 * @return {?}
+                 */
+                (item) => {
+                    this.tableList.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 (["number", "percent"].includes(table.dataType)) {
+                                /** @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.hideTable = true;
+                this.pageLoading = true;
+                this.ref.markForCheck();
+                setTimeout((/**
+                 * @return {?}
+                 */
+                () => {
+                    this.hideTable = false;
+                    this.pageLoading = false;
+                    this.ref.markForCheck();
+                }), 300);
+            }
+        })));
+    }
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        this.subscriptions.forEach((/**
+         * @param {?} sub
+         * @return {?}
+         */
+        (sub) => sub.unsubscribe()));
+    }
+    /**
+     * @param {?} args
+     * @return {?}
+     */
+    customiseCell(args) {
+        if (args.column.type === "date" || args.column.type === "dateTime") {
+            const { field } = args.column;
+            if (!args.data[field]) {
+                args.column.type = "string";
+                args.column.format = "";
+            }
+        }
+        /** @type {?} */
+        let queryCell = this.tableList &&
+            this.tableList.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.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
+        /** @type {?} */
+        let dateFields = this.formatDates &&
+            this.formatDates.map((/**
+             * @param {?} el
+             * @return {?}
+             */
+            (el) => {
+                return el.name;
+            }));
+        if (args.column.field &&
+            dateFields &&
+            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;
+            }
+        }
+        if (args.column.field)
+            if (["MOIC", "DPI", "TVPI", "RVPI", "PIC", "Multiple"].includes(args.column.field)) {
+                if (args.data && args.data[args.column.field]) {
+                    // 渲染过一次后，就用原数据就好了
+                    args.cell.innerHTML = `<div>${args.data[args.column.field].indexOf instanceof Function
+                        ? args.data[args.column.field]
+                        : this.getXTxt(args.column.field, args.data)}
+				</div>`;
+                }
+            }
+        if (args.column &&
+            args.column.format &&
+            args.column.format === "dd-MMM-yyyy") {
+            args.cell.innerHTML = `<div>${moment(args.data[args.column.field]).format("DD-MMM-yyyy")}</div>`;
+        }
+    }
+    /**
+     * @private
+     * @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`;
+                }
+        }
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    getTableData() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            this.pageLoading = false;
+            this.config = JSON.parse(this.portlet.config);
+            if (this.config.fields) {
+                if (this.dashboardPorletsService.allFieldsObj[this.portlet.id]) {
+                    this.config.fields =
+                        this.dashboardPorletsService.setConfigFields(this.dashboardPorletsService.allFieldsObj[this.portlet.id], this.config.fields);
+                }
+                this.configFields = [...this.config.fields];
+            }
+            // ejs-grid 坑点：列头数据，colName中不能含有空格
+            // GetSchema接口中获取的所有列的dataType和GetPortletDataOrCreate接口中返回的数据类型必须保持一致，否则会导致数据总量显示，但是列表中无数据
+            /** @type {?} */
+            const data = this.dashboardPorletsService.getResultByDataTable(this.portlet, false, false, this.dashboard.id);
+            this.data = data ? DataUtil.parse.parseJson(data) : [];
+            this.data = this.data.map((/**
+             * @param {?} item
+             * @return {?}
+             */
+            (item) => {
+                /** @type {?} */
+                const translationMap = {
+                    Indirect: this.translation.INDIRECT || "Indirect",
+                    Direct: this.translation.DIRECT || "Direct",
+                };
+                return Object.assign({}, item, { DirectIndirect: translationMap[item.DirectIndirect] || item.DirectIndirect });
+            }));
+            this.totalRecordsCount =
+                this.dashboardPorletsService.getResultByDataTable(this.portlet, true, true, this.dashboard.id);
+            if (this.config &&
+                this.configFields &&
+                this.configFields.length &&
+                this.data &&
+                this.data.length) {
+                this.formatSettings = [];
+                this.formatDates = [];
+                this.configFields.map((/**
+                 * @param {?} el
+                 * @return {?}
+                 */
+                (el) => {
+                    if (["number", "percent", "percentNum", "multiple"].includes(el.dataType)) {
+                        /** @type {?} */
+                        let format = this.getNumFormat(el);
+                        /** @type {?} */
+                        const formatData = {
+                            name: el.colName,
+                            format: format,
+                        };
+                        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].dateType == "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].dateType == "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);
+                                format = this.getDateFormat(format_);
+                            }
+                        }
+                        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);
+                        }
+                    }
+                }));
+                /** @type {?} */
+                const newTableList = [];
+                this.configFields.forEach((/**
+                 * @param {?} item
+                 * @return {?}
+                 */
+                (item) => {
+                    if (!item.isHidden) {
+                        /** @type {?} */
+                        const obj = Object.assign({}, item, { dataType: [
+                                "MOIC",
+                                "DPI",
+                                "TVPI",
+                                "RVPI",
+                                "PIC",
+                                "Multiple",
+                            ].includes(item.colName)
+                                ? "string"
+                                : item["dataType"] });
+                        if (Array.isArray(item.format) &&
+                            item.format.length > 0 &&
+                            item.format[0].formatChecked) {
+                            obj.displayName = item.format[0].displayName;
+                        }
+                        newTableList.push(obj);
+                    }
+                }));
+                this.tableList = newTableList;
+                /** @type {?} */
+                const typeMap = {};
+                this.tableList.forEach((/**
+                 * @param {?} col
+                 * @return {?}
+                 */
+                (col) => {
+                    if (col.dataType === "number") {
+                        typeMap[col.colName] = true;
+                    }
+                }));
+                this.data.forEach((/**
+                 * @param {?} _data
+                 * @return {?}
+                 */
+                (_data) => {
+                    Object.keys(typeMap).forEach((/**
+                     * @param {?} key
+                     * @return {?}
+                     */
+                    (key) => {
+                        _data[key] =
+                            _data[key] === null
+                                ? null
+                                : this.pbf.bankersRounding(Number(_data[key]));
+                    }));
+                }));
+            }
+            if (this.config.filterSettings && this.config.filterSettings.length) {
+                this.filterSettings.columns = this.config.filterSettings;
+            }
+            this.ref.markForCheck();
+            // this.ref.detectChanges();
+        });
+    }
+    /**
+     * @param {?} colName
+     * @return {?}
+     */
+    getFormatOptions(colName) {
+        /** @type {?} */
+        let res = this.formatSettings &&
+            this.formatSettings.filter((/**
+             * @param {?} el
+             * @return {?}
+             */
+            (el) => el.name === colName));
+        if (res && res.length)
+            return res[0].format;
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    getInfo() {
+        this.translation = JSON.parse(localStorage.getItem("translation"));
+        this.userInfo = JSON.parse(localStorage.getItem("userInfo"));
+        this.datePipeFormat = localStorage.getItem("datePipe");
+    }
+    /**
+     * @param {?} args
+     * @return {?}
+     */
+    actionComplete(args) {
+        if (args.requestType === "filtering") {
+            if (args.action === "filter") {
+                /** @type {?} */
+                let filteredvalues = [];
+                for (let item of args.columns) {
+                    // if (item.type === "datetime" || item.type === "date") {
+                    // 	item.value = this.pbf.time(item.value);
+                    // }
+                    filteredvalues.push({
+                        field: item.field,
+                        matchCase: item.matchCase,
+                        operator: item.operator,
+                        predicate: item.predicate,
+                        type: item.type,
+                        value: item.value,
+                    });
+                }
+                this.config.filterSettings = filteredvalues;
+            }
+            else {
+                this.currentFilterField = "";
+                this.config.filterSettings = [];
+            }
+            /** @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));
+            if (index > -1)
+                this.portlets[index] = portlet;
+            this.currentPage = 1;
+            this.reloadTableData({
+                page: this.currentPage,
+                size: this.pageSize,
+                sortedColumn: this.sortedColumn === null ? undefined : this.sortedColumn,
+                sort: this.sort === null ? undefined : this.sort,
+            });
+        }
+        // 列选择事件
+        if (args.requestType === "columnstate") {
+            /** @type {?} */
+            const hideColumns = this.grid.getHiddenColumns();
+            this.configFields.map((/**
+             * @param {?} el
+             * @return {?}
+             */
+            (el) => (el.visible = true)));
+            if (hideColumns.length > 0) {
+                for (let hideitem of hideColumns) {
+                    if (hideitem.field)
+                        this.configFields.filter((/**
+                         * @param {?} el
+                         * @return {?}
+                         */
+                        (el) => el.colName === hideitem.field))[0].visible = false;
+                }
+            }
+            this.config.fields = JSON.parse(JSON.stringify(this.configFields));
+            this.portlet.config = JSON.stringify(this.config);
+            /** @type {?} */
+            const index = this.portlets.findIndex((/**
+             * @param {?} x
+             * @return {?}
+             */
+            (x) => x.newId === this.portlet.newId));
+            this.portlets[index].config = JSON.stringify(this.config);
+            this.reloadTableData({
+                page: this.currentPage,
+                size: this.pageSize,
+                sortedColumn: this.sortedColumn === null
+                    ? undefined
+                    : this.sortedColumn,
+                sort: this.sort === null ? undefined : this.sort,
+            }, true);
+        }
+    }
+    /**
+     * @param {?} args
+     * @return {?}
+     */
+    actionBegin(args) {
+        if (args.requestType === "filterchoicerequest") {
+            /** @type {?} */
+            const checkboxfilter = (/** @type {?} */ (this.el.nativeElement.querySelector(".e-checkboxfilter")));
+            if (checkboxfilter) {
+                if (this.portlet.height == 1) {
+                    args.filterModel.dlg.style.minHeight = "calc(100% - 12px)";
+                    args.filterModel.dlg.style.maxHeight = "calc(100% - 12px)";
+                }
+                else {
+                    args.filterModel.dlg.style.minHeight = "350px";
+                    args.filterModel.dlg.style.maxHeight = "350px";
+                }
+            }
+        }
+        if (args.requestType == "filterchoicerequest" ||
+            args.requestType === "filtersearchbegin") {
+            args.filterChoiceCount = 3000;
+        }
+        // 显示过滤的选项
+        if (args.requestType === "filterbeforeopen" &&
+            this.currentFilterField !== args.columnName) {
+            args.cancel = true;
+            /** @type {?} */
+            let columnFilter = [];
+            /** @type {?} */
+            let field = args.columnName;
+            if (this.config.filterSettings.length) {
+                columnFilter = this.config.filterSettings.filter((/**
+                 * @param {?} x
+                 * @return {?}
+                 */
+                (x) => x.field !== field));
+            }
+            /** @type {?} */
+            let data = {
+                dashboardDataTableId: this.portlet.dashboardDataTableId,
+                displayColumnFilter: field,
+                columnFilter: columnFilter,
+            };
+            this.http.post(this.api.urlList.GetDistinctColumnValsByPortletDataParam, data, (/**
+             * @param {?} res
+             * @return {?}
+             */
+            (res) => {
+                this.pageLoading = false;
+                /** @type {?} */
+                let curFomart = this.formatSettings.find((/**
+                 * @param {?} x
+                 * @return {?}
+                 */
+                (x) => x.name === field));
+                if (curFomart &&
+                    ["date", "datetime"].includes(curFomart.type)) {
+                    res = res[field].map((/**
+                     * @param {?} x
+                     * @return {?}
+                     */
+                    (x) => new Date(x)));
+                }
+                else {
+                    res = res[field];
+                }
+                this.currentFilterField = args.columnName;
+                this.filterContents = res;
+                this.grid.filterModule.openMenuByField(args.columnName);
+                if (columnFilter.length) {
+                    this.grid.clearFiltering();
+                }
+            }));
+            if (args.requestType === "filterbeforeopen" &&
+                this.currentFilterField === args.columnName) {
+                /** @type {?} */
+                let columnName = args.columnName;
+                if (this.filterContents) {
+                    /** @type {?} */
+                    let curResult = this.filterContents;
+                    /** @type {?} */
+                    let filterOptions = curResult.map((/**
+                     * @param {?} x
+                     * @return {?}
+                     */
+                    (x) => {
+                        /** @type {?} */
+                        let obj = {};
+                        obj[columnName] = x;
+                        return obj;
+                    }));
+                    args.filterModel.options.dataSource = filterOptions;
+                }
+            }
+            // 处理排序
+            if (args.requestType === "sorting") {
+                if (args.columnName) {
+                    this.sort = args.direction === "Ascending" ? 1 : 0;
+                    this.sortedColumn = args.columnName;
+                    this.reloadTableData({
+                        page: this.currentPage,
+                        size: this.pageSize,
+                        sort: this.sort,
+                        sortedColumn: this.sortedColumn,
+                    });
+                }
+                else {
+                    this.sort = null;
+                    this.sortedColumn = null;
+                    this.reloadTableData({
+                        page: this.currentPage,
+                        size: this.pageSize,
+                    });
+                }
+                this.config.tableSortSetting = {
+                    sort: this.sort,
+                    sortedColumn: this.sortedColumn,
+                };
+                this.portlet.config = JSON.stringify(this.config);
+                /** @type {?} */
+                const index = this.portlets.findIndex((/**
+                 * @param {?} x
+                 * @return {?}
+                 */
+                (x) => x.newId === this.portlet.newId));
+                this.portlets[index].config = JSON.stringify(this.config);
+            }
+        }
+    }
+    /**
+     * @param {?} args
+     * @return {?}
+     */
+    resizeStop(args) {
+        /** @type {?} */
+        let field = this.configFields.filter((/**
+         * @param {?} el
+         * @return {?}
+         */
+        (el) => el.colName === args.column.field));
+        if (field && field.length > 0) {
+            field[0].width = parseInt(args.column.width);
+            /** @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] = portlet;
+        }
+    }
+    /**
+     * @param {?} args
+     * @return {?}
+     */
+    rowDataBound(args) {
+        if (args.row.ariaRowIndex % 2 === 0) {
+            args.row.style.backgroundColor = "#f8fafb";
+        }
+        else {
+            args.row.style.backgroundColor = "#ffffff";
+        }
+    }
+    /**
+     * @param {?} args
+     * @return {?}
+     */
+    created(args) {
+        if (this.config.showGrandTotals) {
+            /** @type {?} */
+            let el = this.grid.element.querySelector(".e-gridfooter");
+            if (el)
+                el.classList.remove("hidesummary");
+        }
+        else {
+            /** @type {?} */
+            let el = this.grid.element.querySelector(".e-gridfooter");
+            if (el)
+                el.classList.add("hidesummary");
+        }
+    }
+    /**
+     * @param {?} args
+     * @return {?}
+     */
+    exportQueryCellInfo(args) {
+        /** @type {?} */
+        let curFormat = this.formatSettings.find((/**
+         * @param {?} x
+         * @return {?}
+         */
+        (x) => x.name === args.column.field));
+        if (curFormat) {
+            if (curFormat.type === "date") {
+                args.value = this.pbf.convertDateFormat(args.value, curFormat.format
+                    ? curFormat.format.replace("dd", "DD")
+                    : null);
+            }
+        }
+        if (args.column.field &&
+            this.millionFields.includes(args.column.field)) {
+            args.value = args.data[args.column.field] / 1000000;
+        }
+        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;
+                }
+            }
+        }
+        // Excel Style Format
+        /** @type {?} */
+        let queryCell = this.tableList &&
+            this.tableList.filter((/**
+             * @param {?} item
+             * @return {?}
+             */
+            (item) => item.colName === args.column.field))[0];
+        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.cellAddStyleExcel(args, queryCell);
+            }
+            else
+                this.cellAddStyleExcel(args, queryCell);
+        }
+    }
+    /**
+     * @private
+     * @param {?} args
+     * @param {?} queryCell
+     * @return {?}
+     */
+    cellAddStyleExcel(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.style = {
+                        fontColor: this.pbf.rgbaToHex(`${queryCell.format[0].negaFontColor}`),
+                        fontSize: Number(`${queryCell.format[0].negaFontSizeValue}`.replace("px", "")),
+                        fontName: `${queryCell.format[0].negaFontFamilyValue}`,
+                        backColor: this.pbf.rgbaToHex(`${queryCell.format[0].negaBackgroundColor}`),
+                    };
+                }
+                else {
+                    args.style = {
+                        fontColor: this.pbf.rgbaToHex(`${queryCell.format[0].fontColor}`),
+                        fontSize: Number(`${queryCell.format[0].fontSizeValue}`.replace("px", "")),
+                        fontName: `${queryCell.format[0].fontFamilyValue}`,
+                        backColor: this.pbf.rgbaToHex(`${queryCell.format[0].backgroundColor}`),
+                    };
+                }
+        }
+    }
+    /**
+     * @param {?} colName
+     * @param {?} code
+     * @return {?}
+     */
+    getLogoInfo(colName, code) {
+        if (this.configFields && this.configFields.length) {
+            /** @type {?} */
+            let fields = this.configFields.filter((/**
+             * @param {?} el
+             * @return {?}
+             */
+            (el) => el.colName == colName));
+            if (fields && fields.length) {
+                return fields[0][code];
+            }
+            else {
+                return false;
+            }
+        }
+        else {
+            return false;
+        }
+    }
+    /**
+     * @param {?} logoDocId
+     * @return {?}
+     */
+    getLogoImage(logoDocId) {
+        /** @type {?} */
+        let img;
+        if (logoDocId !== undefined &&
+            logoDocId !== null &&
+            logoDocId !== "00000000-0000-0000-0000-000000000000") {
+            img =
+                this.api.baseurl +
+                    this.api.urlList.FileGet +
+                    "?username=" +
+                    this.userInfo.username +
+                    "&accountId=" +
+                    this.userInfo.accountId +
+                    "&docId=" +
+                    logoDocId +
+                    `&Authorization=Bearer`;
+        }
+        else {
+            img = "../../../../../../assets/img/default_profile_icon.png";
+        }
+        return img;
+    }
+    /**
+     * @private
+     * @return {?}
+     */
+    setQuarterFormat() {
+        return [
+            { 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" },
+        ];
+    }
+    /**
+     * @private
+     * @param {?} format_
+     * @return {?}
+     */
+    getDateFormat(format_) {
+        switch (format_) {
+            case "DD/MM/YYYY":
+                return "dd/MM/yyyy";
+            case "DD/MM/YY":
+                return "dd/MM/yy";
+            case "MM/DD/YYYY":
+                return "MM/dd/yyyy";
+            case "MM/DD/YY":
+                return "MM/dd/yy";
+            case "YYYY-MM-DD":
+                return "yyyy-MM-dd";
+            case "YY-MM-DD":
+                return "yy-MM-dd";
+            case "DD-MM-YYYY":
+                return "dd-MM-yyyy";
+            case "DD-MM-YY":
+                return "dd-MM-yy";
+            case "MM-DD-YYYY":
+                return "MM-dd-yyyy";
+            case "MM-DD-YY":
+                return "MM-dd-yy";
+            case "MMM DD, YYYY":
+                return "MMM dd, yyyy";
+            case "DD-MMM-YYYY":
+                return "dd-MMM-yyyy";
+            default:
+                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.millionFields.push(colName);
+        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);
+                    }
+                }));
+        }
+    }
+    /**
+     * @param {?} table
+     * @return {?}
+     */
+    getAlign(table) {
+        if (table.format &&
+            table.format.length &&
+            table.format[0].formatChecked)
+            return table.format[0].align;
+        return ["date", "datetime", "string", "nvarchar", "dropdown"].includes(table.dataType) &&
+            !["MOIC", "DPI", "TVPI", "RVPI", "PIC", "Multiple"].includes(table.colName)
+            ? "Left"
+            : "Right";
+    }
+    /**
+     * @param {?} args
+     * @return {?}
+     */
+    pageChanged(args) {
+        if (args.newProp) {
+            // 处理分页器点击事件
+            /** @type {?} */
+            let pageSize = args.newProp.pageSize;
+            if (pageSize) {
+                this.pageSize = pageSize;
+                this.currentPage = 1;
+            }
+            else {
+                this.currentPage = args.newProp.currentPage;
+            }
+            this.reloadTableData({
+                page: this.currentPage,
+                size: this.pageSize,
+                sortedColumn: this.sortedColumn === null
+                    ? undefined
+                    : this.sortedColumn,
+                sort: this.sort === null ? undefined : this.sort,
+            }, true);
+        }
+    }
+    /**
+     * @param {?=} setting
+     * @param {?=} refreshFormat
+     * @return {?}
+     */
+    reloadTableData(setting = {}, refreshFormat) {
+        /** @type {?} */
+        let params = {};
+        if (setting.page && setting.size) {
+            params.currentPage = setting.page;
+            params.pageSize = setting.size;
+        }
+        if (setting.sortedColumn) {
+            params.sortedColumn = setting.sortedColumn;
+            params.sort = setting.sort;
+        }
+        this.pageLoading = true;
+        this.dashboardPorletsService.getDataByPortletsNew([this.portlet], (/**
+         * @return {?}
+         */
+        () => {
+            this.pageLoading = false;
+            /** @type {?} */
+            const data = DataUtil.parse.parseJson(this.dashboardPorletsService.getResultByDataTable(this.portlet, false, false, this.dashboard.id));
+            this.data = data.map((/**
+             * @param {?} item
+             * @return {?}
+             */
+            (item) => {
+                return Object.assign({}, item, { MOIC: `${Number(item["MOIC"]).toFixed(2)}x`, DPI: `${Number(item["DPI"]).toFixed(2)}x`, TVPI: `${Number(item["TVPI"]).toFixed(2)}x`, RVPI: `${Number(item["RVPI"]).toFixed(2)}x`, PIC: `${Number(item["PIC"]).toFixed(2)}x`, Multiple: `${Number(item["Multiple"]).toFixed(2)}x` });
+            }));
+            // if (this.tableList && this.tableList.length) {
+            // 	const typeMap = {};
+            // 	this.tableList.forEach((col) => {
+            // 		if (col.dataType === "number") {
+            // 			typeMap[col.colName] = true;
+            // 		}
+            // 	});
+            // 	this.data.forEach((_data) => {
+            // 		Object.keys(typeMap).forEach((key) => {
+            // 			_data[key] =
+            // 				_data[key] === null
+            // 					? null
+            // 					: this.pbf.bankersRounding(
+            // 							Number(_data[key])
+            // 					  );
+            // 		});
+            // 	});
+            // }
+            this.totalRecordsCount =
+                this.dashboardPorletsService.getResultByDataTable(this.portlet, true, true, this.dashboard.id);
+            this.tableList = [...this.configFields];
+            this.tableList = this.tableList.filter((/**
+             * @param {?} fl
+             * @return {?}
+             */
+            (fl) => !fl.isHidden));
+            this.tableList = this.tableList.map((/**
+             * @param {?} item
+             * @return {?}
+             */
+            (item) => {
+                return Object.assign({}, item, { dataType: [
+                        "MOIC",
+                        "DPI",
+                        "TVPI",
+                        "RVPI",
+                        "PIC",
+                        "Multiple",
+                    ].includes(item.colName)
+                        ? "string"
+                        : item["dataType"] });
+            }));
+            /** @type {?} */
+            const typeMap = {};
+            this.tableList.forEach((/**
+             * @param {?} col
+             * @return {?}
+             */
+            (col) => {
+                if (col.dataType === "number") {
+                    typeMap[col.colName] = true;
+                }
+            }));
+            this.data.forEach((/**
+             * @param {?} _data
+             * @return {?}
+             */
+            (_data) => {
+                Object.keys(typeMap).forEach((/**
+                 * @param {?} key
+                 * @return {?}
+                 */
+                (key) => {
+                    _data[key] =
+                        _data[key] === null
+                            ? null
+                            : this.pbf.bankersRounding(Number(_data[key]));
+                }));
+            }));
+            if (this.grid) {
+                if (refreshFormat) {
+                    this.grid.columns.forEach((/**
+                     * @param {?} item
+                     * @return {?}
+                     */
+                    (item) => {
+                        item.format = this.getFormatOptions(item.field);
+                    }));
+                    if (this.grid.contentModule) {
+                        this.grid.refreshColumns();
+                    }
+                }
+                else {
+                    this.grid.refresh();
+                }
+            }
+            this.ref.markForCheck();
+            this.ref.detectChanges();
+        }), params, false, this.dashboard);
+    }
+    /**
+     * @param {?} colName
+     * @param {?} item
+     * @return {?}
+     */
+    getXTxt(colName, item) {
+        if (colName == "MOIC") {
+            return `${Number(item["MOIC"]).toFixed(2)}x`;
+        }
+        else if (colName == "DPI") {
+            return `${Number(item["DPI"]).toFixed(2)}x`;
+        }
+        else if (colName == "TVPI") {
+            return `${Number(item["TVPI"]).toFixed(2)}x`;
+        }
+        else if (colName == "RVPI") {
+            return `${Number(item["RVPI"]).toFixed(2)}x`;
+        }
+        else if (colName == "PIC") {
+            return `${Number(item["PIC"]).toFixed(2)}x`;
+        }
+        else if (colName == "Multiple") {
+            return `${Number(item["Multiple"]).toFixed(2)}x`;
+        }
+    }
+}
+GadgetTableComponent.decorators = [
+    { type: Component, args: [{
+                selector: "kt-gadget-table",
+                template: "<div class=\"control-section gadget-table\" style=\"height: 100%\" *ngIf=\"data && data.length\">\r\n\t<ejs-grid\r\n\t\t*ngIf=\"!hideTable\"\r\n\t\t#grid\r\n\t\t[dataSource]=\"data\"\r\n\t\t[allowSorting]=\"true\"\r\n\t\twidth=\"100%\"\r\n\t\t[pageSettings]=\"options\"\r\n\t\t[resizeSettings]=\"{ mode: 'Auto' }\"\r\n\t\t[allowExcelExport]=\"true\"\r\n\t\t[filterSettings]=\"filterSettings\"\r\n\t\t[allowResizing]=\"true\"\r\n\t\tshowColumnChooser=\"true\"\r\n\t\t[columnChooserSettings]=\"ColumnChooserSettings\"\r\n\t\t[aggregates]=\"aggregates\"\r\n\t\t(queryCellInfo)=\"customiseCell($event)\"\r\n\t\t(resizeStop)=\"resizeStop($event)\"\r\n\t\t(rowDataBound)=\"rowDataBound($event)\"\r\n\t\t(created)=\"created($event)\"\r\n\t\t(actionBegin)=\"actionBegin($event)\"\r\n\t\t(actionComplete)=\"actionComplete($event)\"\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*ngIf=\"getLogoInfo('logoDocId', 'langValue')\"\r\n\t\t\t\t[headerText]=\"getLogoInfo('logoDocId', 'langValue')\"\r\n\t\t\t\twidth=\"120\"\r\n\t\t\t\ttextAlign=\"Center\"\r\n\t\t\t\t[visible]=\"!getLogoInfo('logoDocId', 'isHidden')\"\r\n\t\t\t>\r\n\t\t\t\t<ng-template #template let-data>\r\n\t\t\t\t\t<div class=\"image-\">\r\n\t\t\t\t\t\t<img\r\n\t\t\t\t\t\t\t[src]=\"getLogoImage(data.logoDocId)\"\r\n\t\t\t\t\t\t\t[alt]=\"data.companyName\"\r\n\t\t\t\t\t\t/>\r\n\t\t\t\t\t</div>\r\n\t\t\t\t</ng-template>\r\n\t\t\t</e-column>\r\n\t\t\t<e-column\r\n\t\t\t\t*ngFor=\"let table of tableList\"\r\n\t\t\t\t[field]=\"table.colName\"\r\n\t\t\t\t[filter]=\"filter\"\r\n\t\t\t\t[headerText]=\"\r\n\t\t\t\t\t(table.displayName\r\n\t\t\t\t\t\t? table.displayName\r\n\t\t\t\t\t\t: translation[table.langCode]\r\n\t\t\t\t\t\t? translation[table.langCode]\r\n\t\t\t\t\t\t: table.langValue) +\r\n\t\t\t\t\t(table.addtionName ? ' ' + table.addtionName : '')\r\n\t\t\t\t\"\r\n\t\t\t\t[width]=\"table.width ? table.width : 200\"\r\n\t\t\t\tclipMode=\"EllipsisWithTooltip\"\r\n\t\t\t\t[visible]=\"table.visible\"\r\n\t\t\t\t[type]=\"\r\n\t\t\t\t\t['number', 'percentNum', 'percent'].includes(table.dataType)\r\n\t\t\t\t\t\t? 'number'\r\n\t\t\t\t\t\t: ['date', 'datetime'].includes(table.dataType)\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\t[format]=\"getFormatOptions(table.colName)\"\r\n\t\t\t\t[textAlign]=\"getAlign(table)\"\r\n\t\t\t>\r\n\t\t\t\t<ng-template\r\n\t\t\t\t\t#template\r\n\t\t\t\t\tlet-data\r\n\t\t\t\t\t*ngIf=\"millionFields.includes(table.colName); else elseBlock\"\r\n\t\t\t\t>\r\n\t\t\t\t\t{{ data[table.colName] / 1000000 }}\r\n\t\t\t\t</ng-template>\r\n\t\t\t\t<ng-template #elseBlock>\r\n\t\t\t\t\t{{ data[table.colName] }}\r\n\t\t\t\t</ng-template>\r\n\r\n\t\t\t\t<!-- terms\u5217 \u663E\u793A\u6362\u884C\u7B26 -->\r\n\t\t\t\t<ng-template\r\n\t\t\t\t\t#template\r\n\t\t\t\t\tlet-data\r\n\t\t\t\t\t*ngIf=\"table.colName == 'terms'\"\r\n\t\t\t\t>\r\n\t\t\t\t\t<div\r\n\t\t\t\t\t\tstyle=\"white-space: pre-line\"\r\n\t\t\t\t\t\t[innerHTML]=\"data[table.colName]\"\r\n\t\t\t\t\t></div>\r\n\t\t\t\t</ng-template>\r\n\t\t\t</e-column>\r\n\t\t</e-columns>\r\n\t</ejs-grid>\r\n\t<ejs-pager\r\n\t\t#pager\r\n\t\t[currentPage]=\"currentPage\"\r\n\t\t[pageCount]=\"5\"\r\n\t\t[pageSize]=\"pageSize\"\r\n\t\t[pageSizes]=\"[10, 50, 100]\"\r\n\t\t[totalRecordsCount]=\"totalRecordsCount\"\r\n\t\t(click)=\"pageChanged($event)\"\r\n\t>\r\n\t</ejs-pager>\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,
+                    FilterService,
+                    ResizeService,
+                ],
+                styles: [":host{display:block;height:100%}.gadget-table{display:flex;flex-direction:column;padding:0 12px}.gadget-table .e-grid{height:0;flex:1}.gadget-table .e-grid .e-gridheader{border-top:1px solid!important;border-bottom:1px solid!important;border-color:#eaedf0!important;padding-right:0!important}.gadget-table .e-grid .e-gridheader .e-headercontent{border:none!important}.gadget-table .e-grid .e-gridheader ::ng-deep .e-headercell{padding:0!important;height:22px!important}.gadget-table .e-grid .e-gridheader ::ng-deep .e-headercell:last-child .e-headercelldiv{border-right:none}.gadget-table .e-grid .e-gridheader ::ng-deep .e-headercell:first-child .e-headercelldiv{border-right:none;padding-left:0!important}.gadget-table .e-grid .e-gridheader ::ng-deep .e-headercell .e-headercelldiv{height:22px!important;padding:4px 8px!important;border-right:1px solid #eaedf0;border-radius:unset}.gadget-table .e-grid .e-gridcontent{margin-right:-5px}.gadget-table .e-grid .e-gridcontent .e-content{overflow:overlay!important}.gadget-table .e-grid .e-gridcontent .e-rowcell{padding:0 8px!important;height:22px!important;line-height:20px!important;border-right:1px solid #eaedf0}.gadget-table .e-grid .e-gridcontent .e-rowcell:first-child{padding-left:0!important}.gadget-table .e-grid .e-gridcontent .e-rowcell:last-child{border-right:none}.gadget-table .e-pager{padding:12px 0!important}"]
+            }] }
+];
+/** @nocollapse */
+GadgetTableComponent.ctorParameters = () => [
+    { type: DashboardPorletsService },
+    { type: ApiList },
+    { type: ChangeDetectorRef },
+    { type: DashboardService },
+    { type: ElementRef },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [PBF_TOKEN,] }] },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [API_SERVICE_TOKEN,] }] }
+];
+GadgetTableComponent.propDecorators = {
+    portlet: [{ type: Input }],
+    dashboard: [{ type: Input }],
+    portlets: [{ type: Input }],
+    grid: [{ type: ViewChild, args: ["grid", { static: false },] }],
+    pager: [{ type: ViewChild, args: ["pager", { static: false },] }]
+};
+if (false) {
+    /** @type {?} */
+    GadgetTableComponent.prototype.portlet;
+    /** @type {?} */
+    GadgetTableComponent.prototype.dashboard;
+    /** @type {?} */
+    GadgetTableComponent.prototype.portlets;
+    /** @type {?} */
+    GadgetTableComponent.prototype.grid;
+    /** @type {?} */
+    GadgetTableComponent.prototype.pager;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTableComponent.prototype.config;
+    /** @type {?} */
+    GadgetTableComponent.prototype.translation;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTableComponent.prototype.userInfo;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTableComponent.prototype.datePipeFormat;
+    /** @type {?} */
+    GadgetTableComponent.prototype.filterSettings;
+    /** @type {?} */
+    GadgetTableComponent.prototype.filter;
+    /** @type {?} */
+    GadgetTableComponent.prototype.data;
+    /** @type {?} */
+    GadgetTableComponent.prototype.tableList;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTableComponent.prototype.tableList_footer;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTableComponent.prototype.formatSettings;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTableComponent.prototype.toolbarOptions;
+    /** @type {?} */
+    GadgetTableComponent.prototype.options;
+    /** @type {?} */
+    GadgetTableComponent.prototype.aggregates;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTableComponent.prototype.subscriptions;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTableComponent.prototype.configFields;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTableComponent.prototype.quarterFormat;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTableComponent.prototype.formatDates;
+    /** @type {?} */
+    GadgetTableComponent.prototype.ColumnChooserSettings;
+    /** @type {?} */
+    GadgetTableComponent.prototype.millionFields;
+    /** @type {?} */
+    GadgetTableComponent.prototype.currentPage;
+    /** @type {?} */
+    GadgetTableComponent.prototype.pageSize;
+    /** @type {?} */
+    GadgetTableComponent.prototype.totalRecordsCount;
+    /** @type {?} */
+    GadgetTableComponent.prototype.filterContents;
+    /** @type {?} */
+    GadgetTableComponent.prototype.sort;
+    /** @type {?} */
+    GadgetTableComponent.prototype.sortedColumn;
+    /** @type {?} */
+    GadgetTableComponent.prototype.pageLoading;
+    /** @type {?} */
+    GadgetTableComponent.prototype.currentFilterField;
+    /** @type {?} */
+    GadgetTableComponent.prototype.allFields;
+    /** @type {?} */
+    GadgetTableComponent.prototype.hideTable;
+    /** @type {?} */
+    GadgetTableComponent.prototype.dashboardPorletsService;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTableComponent.prototype.api;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTableComponent.prototype.ref;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTableComponent.prototype.dashboardService;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTableComponent.prototype.el;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTableComponent.prototype.pbf;
+    /**
+     * @type {?}
+     * @private
+     */
+    GadgetTableComponent.prototype.http;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gadget-table.component.js","sourceRoot":"ng://raise-common-lib/","sources":["lib/dashboard/gadget-group/gadget-table/gadget-table.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n\tComponent,\r\n\tOnInit,\r\n\tInput,\r\n\tChangeDetectorRef,\r\n\tViewChild,\r\n\tElementRef,\r\n\tInject,\r\n\tOptional,\r\n} from \"@angular/core\";\r\nimport {\r\n\tPageSettingsModel,\r\n\tGridComponent,\r\n\tExcelExportService,\r\n\tQueryCellInfoEventArgs,\r\n\tToolbarItems,\r\n\tColumnChooserService,\r\n\tVirtualScrollService,\r\n\tFilterService,\r\n\tFilterSettingsModel,\r\n\tResizeService,\r\n\tExcelQueryCellInfoEventArgs,\r\n\tColumnChooserSettingsModel,\r\n\tPagerComponent,\r\n} from \"@syncfusion/ej2-angular-grids\";\r\n\r\nimport { DashboardPorletsService } from \"../../dashboardPorlets.service\";\r\nimport { ApiList } from \"../../api\";\r\nimport { DashboardService } from \"../../dashboard.service\";\r\nimport { Subscription } from \"rxjs\";\r\nimport { DataUtil } from \"@syncfusion/ej2-data\";\r\nimport { API_SERVICE_TOKEN, PBF_TOKEN } from \"../../../service/InjectionToken\";\r\n\r\nimport moment from \"moment\";\r\n\r\n@Component({\r\n\tselector: \"kt-gadget-table\",\r\n\ttemplateUrl: \"./gadget-table.component.html\",\r\n\tstyleUrls: [\"./gadget-table.component.scss\"],\r\n\tproviders: [\r\n\t\tExcelExportService,\r\n\t\tColumnChooserService,\r\n\t\tVirtualScrollService,\r\n\t\tFilterService,\r\n\t\tResizeService,\r\n\t],\r\n})\r\nexport class GadgetTableComponent implements OnInit {\r\n\t@Input() portlet;\r\n\t@Input() dashboard;\r\n\t@Input() portlets;\r\n\t@ViewChild(\"grid\", { static: false }) public grid: GridComponent;\r\n\t@ViewChild(\"pager\", { static: false }) public pager: PagerComponent;\r\n\tprivate config;\r\n\tpublic translation;\r\n\tprivate userInfo;\r\n\tprivate datePipeFormat;\r\n\tpublic filterSettings: FilterSettingsModel;\r\n\tpublic filter: Object;\r\n\tpublic data;\r\n\tpublic tableList;\r\n\tprivate tableList_footer = [];\r\n\tprivate formatSettings = [];\r\n\tprivate toolbarOptions: ToolbarItems[];\r\n\tpublic options: PageSettingsModel;\r\n\tpublic aggregates: object;\r\n\tprivate subscriptions: Subscription[] = [];\r\n\t// 已经保存过的列数据配置\r\n\tprivate configFields = [];\r\n\tprivate quarterFormat;\r\n\tprivate formatDates = [];\r\n\tpublic ColumnChooserSettings: ColumnChooserSettingsModel;\r\n\tpublic millionFields = [];\r\n\t// Pager\r\n\tpublic currentPage = 1; // 当前页数\r\n\tpublic pageSize = 10; // 一页显示行数\r\n\tpublic totalRecordsCount; // 总行数\r\n\tpublic filterContents; // 所有可以过滤的选项\r\n\tpublic sort; // 0表示降序 1表示升序\r\n\tpublic sortedColumn; // sort的列名\r\n\tpublic pageLoading;\r\n\tpublic currentFilterField; // 当前过滤的字段;\r\n\tpublic allFields;\r\n\thideTable: boolean;\r\n\tconstructor(\r\n\t\tpublic dashboardPorletsService: DashboardPorletsService,\r\n\t\tprivate api: ApiList,\r\n\t\tprivate ref: ChangeDetectorRef,\r\n\t\tprivate dashboardService: DashboardService,\r\n\t\tprivate el: ElementRef,\r\n\t\t@Optional() @Inject(PBF_TOKEN) private pbf: any,\r\n\t\t@Optional() @Inject(API_SERVICE_TOKEN) private http: any,\r\n\t) {}\r\n\tngOnInit() {\r\n\t\tthis.getInfo();\r\n\t\tthis.filterSettings = { type: \"Menu\" };\r\n\t\tthis.ColumnChooserSettings = { operator: \"contains\" };\r\n\t\tthis.filter = { type: \"CheckBox\" };\r\n\t\tthis.toolbarOptions = [\"ColumnChooser\"];\r\n\t\tthis.options = { pageSize: 10, pageSizes: [\"10\", \"50\", \"100\"] };\r\n\t\tthis.quarterFormat = this.setQuarterFormat();\r\n\t\tthis.getTableData();\r\n\t}\r\n\r\n\tngAfterViewInit(): void {\r\n\t\tthis.subscriptions.push(\r\n\t\t\tthis.dashboardService.getchangeTable().subscribe((updated) => {\r\n\t\t\t\tif (updated) {\r\n\t\t\t\t\tthis.pageSize = 10;\r\n\t\t\t\t\tthis.currentPage = 1;\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\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.pageSize = 10;\r\n\t\t\t\t\tthis.currentPage = 1;\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\r\n\t\tthis.subscriptions.push(\r\n\t\t\tthis.dashboardService.getStartRefresh().subscribe((dashboardId) => {\r\n\t\t\t\tif (dashboardId === this.dashboard.id) {\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.getUpdated().subscribe((newId) => {\r\n\t\t\t\tif (newId === this.portlet.newId || newId === this.portlet.id) {\r\n\t\t\t\t\tthis.pageSize = 10;\r\n\t\t\t\t\tthis.currentPage = 1;\r\n\t\t\t\t\tthis.getTableData();\r\n\t\t\t\t\tif (this.grid) {\r\n\t\t\t\t\t\tthis.grid.columns.forEach((item) => {\r\n\t\t\t\t\t\t\tthis.tableList.forEach((table) => {\r\n\t\t\t\t\t\t\t\tif (\r\n\t\t\t\t\t\t\t\t\titem.field === table.colName &&\r\n\t\t\t\t\t\t\t\t\ttable.format &&\r\n\t\t\t\t\t\t\t\t\ttable.format.length &&\r\n\t\t\t\t\t\t\t\t\ttable.format[0].formatChecked\r\n\t\t\t\t\t\t\t\t) {\r\n\t\t\t\t\t\t\t\t\titem.headerText =\r\n\t\t\t\t\t\t\t\t\t\ttable.displayName ||\r\n\t\t\t\t\t\t\t\t\t\ttable.langValue ||\r\n\t\t\t\t\t\t\t\t\t\tthis.translation[table.langCode] ||\r\n\t\t\t\t\t\t\t\t\t\ttable.langCode;\r\n\t\t\t\t\t\t\t\t\tif (\r\n\t\t\t\t\t\t\t\t\t\t[\"number\", \"percent\"].includes(\r\n\t\t\t\t\t\t\t\t\t\t\ttable.dataType\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\t\tlet formatString;\r\n\t\t\t\t\t\t\t\t\t\tif (table.dataType === \"number\") {\r\n\t\t\t\t\t\t\t\t\t\t\tformatString =\r\n\t\t\t\t\t\t\t\t\t\t\t\tthis.pbf.formatNumber(\r\n\t\t\t\t\t\t\t\t\t\t\t\t\ttable.format[0]\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t.selectedFormat\r\n\t\t\t\t\t\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\t\t\t\t} else if (\r\n\t\t\t\t\t\t\t\t\t\t\ttable.dataType === \"percent\"\r\n\t\t\t\t\t\t\t\t\t\t) {\r\n\t\t\t\t\t\t\t\t\t\t\tformatString =\r\n\t\t\t\t\t\t\t\t\t\t\t\tthis.pbf.formatPercent(\r\n\t\t\t\t\t\t\t\t\t\t\t\t\ttable.format[0]\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t.selectedFormat\r\n\t\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\t\titem.format = formatString;\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});\r\n\t\t\t\t\t}\r\n\t\t\t\t\t// this.grid.refreshColumns();\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.getTableFormat().subscribe((data) => {\r\n\t\t\t\tif (data === this.portlet.newId) {\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.tableList.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\t[\"number\", \"percent\"].includes(\r\n\t\t\t\t\t\t\t\t\t\ttable.dataType\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\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.hideTable = true;\r\n\t\t\t\t\tthis.pageLoading = true;\r\n\t\t\t\t\tthis.ref.markForCheck();\r\n\t\t\t\t\tsetTimeout(() => {\r\n\t\t\t\t\t\tthis.hideTable = false;\r\n\t\t\t\t\t\tthis.pageLoading = false;\r\n\t\t\t\t\t\tthis.ref.markForCheck();\r\n\t\t\t\t\t}, 300);\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\tpublic customiseCell(args: QueryCellInfoEventArgs) {\r\n\t\tif (args.column.type === \"date\" || args.column.type === \"dateTime\") {\r\n\t\t\tconst { field } = args.column;\r\n\t\t\tif (!args.data[field]) {\r\n\t\t\t\targs.column.type = \"string\";\r\n\t\t\t\targs.column.format = \"\";\r\n\t\t\t}\r\n\t\t}\r\n\t\tlet queryCell =\r\n\t\t\tthis.tableList &&\r\n\t\t\tthis.tableList.filter(\r\n\t\t\t\t(item) => item.colName === args.column.field\r\n\t\t\t)[0];\r\n\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\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\t\tlet dateFields =\r\n\t\t\tthis.formatDates &&\r\n\t\t\tthis.formatDates.map((el) => {\r\n\t\t\t\treturn el.name;\r\n\t\t\t});\r\n\t\tif (\r\n\t\t\targs.column.field &&\r\n\t\t\tdateFields &&\r\n\t\t\tdateFields.includes(args.column.field) &&\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\tlet date = new Date(args.data[args.column.field]);\r\n\t\t\tlet quarter =\r\n\t\t\t\tMath.floor((date.getMonth() + 1) % 3) == 0\r\n\t\t\t\t\t? Math.floor((date.getMonth() + 1) / 3)\r\n\t\t\t\t\t: Math.floor((date.getMonth() + 1) / 3) + 1;\r\n\r\n\t\t\tlet format;\r\n\r\n\t\t\tthis.formatDates.map((el) => {\r\n\t\t\t\tif (el.name == args.column.field) format = el.format;\r\n\t\t\t});\r\n\t\t\tlet year: any;\r\n\t\t\tswitch (format) {\r\n\t\t\t\tcase \"Q1 2021\":\r\n\t\t\t\t\tyear = date.getFullYear();\r\n\t\t\t\t\targs.cell.innerHTML = \"Q\" + quarter + \" \" + year;\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tcase \"Q1 21\":\r\n\t\t\t\t\tyear = (date as any).getYear() - 100;\r\n\t\t\t\t\targs.cell.innerHTML = \"Q\" + quarter + \" \" + year;\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tcase \"2021 Q1\":\r\n\t\t\t\t\tyear = date.getFullYear();\r\n\t\t\t\t\targs.cell.innerHTML = year + \" \" + \"Q\" + quarter;\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tcase \"21 Q1\":\r\n\t\t\t\t\tyear = (date as any).getYear() - 100;\r\n\t\t\t\t\targs.cell.innerHTML = year + \" \" + \"Q\" + quarter;\r\n\t\t\t\t\tbreak;\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tif (args.column.field)\r\n\t\t\tif (\r\n\t\t\t\t[\"MOIC\", \"DPI\", \"TVPI\", \"RVPI\", \"PIC\", \"Multiple\"].includes(\r\n\t\t\t\t\targs.column.field\r\n\t\t\t\t)\r\n\t\t\t) {\r\n\t\t\t\tif (args.data && args.data[args.column.field]) {\r\n\t\t\t\t\t// 渲染过一次后，就用原数据就好了\r\n\t\t\t\t\targs.cell.innerHTML = `<div>${\r\n\t\t\t\t\t\targs.data[args.column.field].indexOf instanceof Function\r\n\t\t\t\t\t\t\t? args.data[args.column.field]\r\n\t\t\t\t\t\t\t: this.getXTxt(args.column.field, args.data)\r\n\t\t\t\t\t}\r\n\t\t\t\t</div>`;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\tif (\r\n\t\t\targs.column &&\r\n\t\t\targs.column.format &&\r\n\t\t\targs.column.format === \"dd-MMM-yyyy\"\r\n\t\t) {\r\n\t\t\targs.cell.innerHTML = `<div>${moment(\r\n\t\t\t\targs.data[args.column.field]\r\n\t\t\t).format(\"DD-MMM-yyyy\")}</div>`;\r\n\t\t}\r\n\t}\r\n\r\n\tprivate cellAddStyle(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\tprivate async 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\tif (this.dashboardPorletsService.allFieldsObj[this.portlet.id]) {\r\n\t\t\t\tthis.config.fields =\r\n\t\t\t\t\tthis.dashboardPorletsService.setConfigFields(\r\n\t\t\t\t\t\tthis.dashboardPorletsService.allFieldsObj[\r\n\t\t\t\t\t\t\tthis.portlet.id\r\n\t\t\t\t\t\t],\r\n\t\t\t\t\t\tthis.config.fields\r\n\t\t\t\t\t);\r\n\t\t\t}\r\n\t\t\tthis.configFields = [...this.config.fields];\r\n\t\t}\r\n\t\t// ejs-grid 坑点：列头数据，colName中不能含有空格\r\n\t\t// GetSchema接口中获取的所有列的dataType和GetPortletDataOrCreate接口中返回的数据类型必须保持一致，否则会导致数据总量显示，但是列表中无数据\r\n\t\tconst data = 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.data = data ? DataUtil.parse.parseJson(data) : [];\r\n\t\tthis.data = this.data.map((item) => {\r\n\t\t\tconst translationMap = {\r\n\t\t\t\tIndirect: this.translation.INDIRECT || \"Indirect\",\r\n\t\t\t\tDirect: this.translation.DIRECT || \"Direct\",\r\n\t\t\t};\r\n\t\t\treturn {\r\n\t\t\t\t...item,\r\n\t\t\t\tDirectIndirect:\r\n\t\t\t\t\ttranslationMap[item.DirectIndirect] || item.DirectIndirect,\r\n\t\t\t};\r\n\t\t});\r\n\t\tthis.totalRecordsCount =\r\n\t\t\tthis.dashboardPorletsService.getResultByDataTable(\r\n\t\t\t\tthis.portlet,\r\n\t\t\t\ttrue,\r\n\t\t\t\ttrue,\r\n\t\t\t\tthis.dashboard.id\r\n\t\t\t);\r\n\r\n\t\tif (\r\n\t\t\tthis.config &&\r\n\t\t\tthis.configFields &&\r\n\t\t\tthis.configFields.length &&\r\n\t\t\tthis.data &&\r\n\t\t\tthis.data.length\r\n\t\t) {\r\n\t\t\tthis.formatSettings = [];\r\n\t\t\tthis.formatDates = [];\r\n\t\t\tthis.configFields.map((el) => {\r\n\t\t\t\tif (\r\n\t\t\t\t\t[\"number\", \"percent\", \"percentNum\", \"multiple\"].includes(\r\n\t\t\t\t\t\tel.dataType\r\n\t\t\t\t\t)\r\n\t\t\t\t) {\r\n\t\t\t\t\tlet format = this.getNumFormat(el);\r\n\t\t\t\t\tconst formatData = {\r\n\t\t\t\t\t\tname: el.colName,\r\n\t\t\t\t\t\tformat: format,\r\n\t\t\t\t\t};\r\n\t\t\t\t\tthis.formatSettings.push(formatData);\r\n\t\t\t\t}\r\n\t\t\t\tif (el.dataType == \"datetime\" || el.dataType == \"date\") {\r\n\t\t\t\t\tlet format = \"\";\r\n\t\t\t\t\tif (\r\n\t\t\t\t\t\tel.format &&\r\n\t\t\t\t\t\tel.format.length &&\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\tif (el.format[0].dateType == \"Quarter\") {\r\n\t\t\t\t\t\t\tlet format_ = el.format[0].selectedFormatDisplay;\r\n\t\t\t\t\t\t\tlet formatInfo = this.quarterFormat.filter(\r\n\t\t\t\t\t\t\t\t(qur) => qur.value == format_\r\n\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\tif (formatInfo.length) {\r\n\t\t\t\t\t\t\t\tformat = formatInfo[0].format;\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.formatDates.push(formatData);\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t} else if (el.format[0].dateType == \"Date\") {\r\n\t\t\t\t\t\t\tlet fromIdx =\r\n\t\t\t\t\t\t\t\tel.format[0].selectedFormatDisplay.indexOf(\"(\");\r\n\t\t\t\t\t\t\tlet toIdx =\r\n\t\t\t\t\t\t\t\tel.format[0].selectedFormatDisplay.indexOf(\")\");\r\n\t\t\t\t\t\t\tlet format_ =\r\n\t\t\t\t\t\t\t\tel.format[0].selectedFormatDisplay.slice(\r\n\t\t\t\t\t\t\t\t\tfromIdx + 1,\r\n\t\t\t\t\t\t\t\t\ttoIdx\r\n\t\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\tformat = this.getDateFormat(format_);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif (!format) {\r\n\t\t\t\t\t\tconst formatData = {\r\n\t\t\t\t\t\t\tname: el.colName,\r\n\t\t\t\t\t\t\tformat: this.datePipeFormat,\r\n\t\t\t\t\t\t\ttype: \"date\",\r\n\t\t\t\t\t\t};\r\n\t\t\t\t\t\tthis.formatSettings.push(formatData);\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tconst formatData = {\r\n\t\t\t\t\t\t\tname: el.colName,\r\n\t\t\t\t\t\t\tformat: format,\r\n\t\t\t\t\t\t\ttype: \"date\",\r\n\t\t\t\t\t\t};\r\n\t\t\t\t\t\tthis.formatSettings.push(formatData);\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t\t\tconst newTableList = [];\r\n\t\t\tthis.configFields.forEach((item) => {\r\n\t\t\t\tif (!item.isHidden) {\r\n\t\t\t\t\tconst obj = {\r\n\t\t\t\t\t\t...item,\r\n\t\t\t\t\t\tdataType: [\r\n\t\t\t\t\t\t\t\"MOIC\",\r\n\t\t\t\t\t\t\t\"DPI\",\r\n\t\t\t\t\t\t\t\"TVPI\",\r\n\t\t\t\t\t\t\t\"RVPI\",\r\n\t\t\t\t\t\t\t\"PIC\",\r\n\t\t\t\t\t\t\t\"Multiple\",\r\n\t\t\t\t\t\t].includes(item.colName)\r\n\t\t\t\t\t\t\t? \"string\"\r\n\t\t\t\t\t\t\t: item[\"dataType\"],\r\n\t\t\t\t\t};\r\n\t\t\t\t\tif (\r\n\t\t\t\t\t\tArray.isArray(item.format) &&\r\n\t\t\t\t\t\titem.format.length > 0 &&\r\n\t\t\t\t\t\titem.format[0].formatChecked\r\n\t\t\t\t\t) {\r\n\t\t\t\t\t\tobj.displayName = item.format[0].displayName;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tnewTableList.push(obj);\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t\t\tthis.tableList = newTableList;\r\n\t\t\tconst typeMap = {};\r\n\t\t\tthis.tableList.forEach((col) => {\r\n\t\t\t\tif (col.dataType === \"number\") {\r\n\t\t\t\t\ttypeMap[col.colName] = true;\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t\t\tthis.data.forEach((_data) => {\r\n\t\t\t\tObject.keys(typeMap).forEach((key) => {\r\n\t\t\t\t\t_data[key] =\r\n\t\t\t\t\t\t_data[key] === null\r\n\t\t\t\t\t\t\t? null\r\n\t\t\t\t\t\t\t: this.pbf.bankersRounding(Number(_data[key]));\r\n\t\t\t\t});\r\n\t\t\t});\r\n\t\t}\r\n\t\tif (this.config.filterSettings && this.config.filterSettings.length) {\r\n\t\t\tthis.filterSettings.columns = this.config.filterSettings;\r\n\t\t}\r\n\t\tthis.ref.markForCheck();\r\n\t\t// this.ref.detectChanges();\r\n\t}\r\n\r\n\tpublic getFormatOptions(colName) {\r\n\t\tlet res =\r\n\t\t\tthis.formatSettings &&\r\n\t\t\tthis.formatSettings.filter((el) => el.name === colName);\r\n\t\tif (res && res.length) return res[0].format;\r\n\t}\r\n\r\n\tprivate getInfo() {\r\n\t\tthis.translation = JSON.parse(localStorage.getItem(\"translation\"));\r\n\t\tthis.userInfo = JSON.parse(localStorage.getItem(\"userInfo\"));\r\n\t\tthis.datePipeFormat = localStorage.getItem(\"datePipe\");\r\n\t}\r\n\r\n\tpublic actionComplete(args) {\r\n\t\tif (args.requestType === \"filtering\") {\r\n\t\t\tif (args.action === \"filter\") {\r\n\t\t\t\tlet filteredvalues = [];\r\n\t\t\t\tfor (let item of args.columns) {\r\n\t\t\t\t\t// if (item.type === \"datetime\" || item.type === \"date\") {\r\n\t\t\t\t\t// \titem.value = this.pbf.time(item.value);\r\n\t\t\t\t\t// }\r\n\t\t\t\t\tfilteredvalues.push({\r\n\t\t\t\t\t\tfield: item.field,\r\n\t\t\t\t\t\tmatchCase: item.matchCase,\r\n\t\t\t\t\t\toperator: item.operator,\r\n\t\t\t\t\t\tpredicate: item.predicate,\r\n\t\t\t\t\t\ttype: item.type,\r\n\t\t\t\t\t\tvalue: item.value,\r\n\t\t\t\t\t});\r\n\t\t\t\t}\r\n\t\t\t\tthis.config.filterSettings = filteredvalues;\r\n\t\t\t} else {\r\n\t\t\t\tthis.currentFilterField = \"\";\r\n\t\t\t\tthis.config.filterSettings = [];\r\n\t\t\t}\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\tif (index > -1) this.portlets[index] = portlet;\r\n\t\t\tthis.currentPage = 1;\r\n\t\t\tthis.reloadTableData({\r\n\t\t\t\tpage: this.currentPage,\r\n\t\t\t\tsize: this.pageSize,\r\n\t\t\t\tsortedColumn:\r\n\t\t\t\t\tthis.sortedColumn === null ? undefined : this.sortedColumn,\r\n\t\t\t\tsort: this.sort === null ? undefined : this.sort,\r\n\t\t\t});\r\n\t\t}\r\n\t\t// 列选择事件\r\n\t\tif (args.requestType === \"columnstate\") {\r\n\t\t\tconst hideColumns = this.grid.getHiddenColumns();\r\n\t\t\tthis.configFields.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\tif (hideitem.field)\r\n\t\t\t\t\t\tthis.configFields.filter(\r\n\t\t\t\t\t\t\t(el) => el.colName === hideitem.field\r\n\t\t\t\t\t\t)[0].visible = false;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tthis.config.fields = JSON.parse(JSON.stringify(this.configFields));\r\n\t\t\tthis.portlet.config = JSON.stringify(this.config);\r\n\t\t\tconst index = this.portlets.findIndex(\r\n\t\t\t\t(x) => x.newId === this.portlet.newId\r\n\t\t\t);\r\n\t\t\tthis.portlets[index].config = JSON.stringify(this.config);\r\n\t\t\tthis.reloadTableData(\r\n\t\t\t\t{\r\n\t\t\t\t\tpage: this.currentPage,\r\n\t\t\t\t\tsize: this.pageSize,\r\n\t\t\t\t\tsortedColumn:\r\n\t\t\t\t\t\tthis.sortedColumn === null\r\n\t\t\t\t\t\t\t? undefined\r\n\t\t\t\t\t\t\t: this.sortedColumn,\r\n\t\t\t\t\tsort: this.sort === null ? undefined : this.sort,\r\n\t\t\t\t},\r\n\t\t\t\ttrue\r\n\t\t\t);\r\n\t\t}\r\n\t}\r\n\r\n\tpublic actionBegin(args) {\r\n\t\tif (args.requestType === \"filterchoicerequest\") {\r\n\t\t\tconst checkboxfilter = this.el.nativeElement.querySelector(\r\n\t\t\t\t\".e-checkboxfilter\"\r\n\t\t\t) as HTMLElement;\r\n\t\t\tif (checkboxfilter) {\r\n\t\t\t\tif (this.portlet.height == 1) {\r\n\t\t\t\t\targs.filterModel.dlg.style.minHeight = \"calc(100% - 12px)\";\r\n\t\t\t\t\targs.filterModel.dlg.style.maxHeight = \"calc(100% - 12px)\";\r\n\t\t\t\t} else {\r\n\t\t\t\t\targs.filterModel.dlg.style.minHeight = \"350px\";\r\n\t\t\t\t\targs.filterModel.dlg.style.maxHeight = \"350px\";\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t\tif (\r\n\t\t\targs.requestType == \"filterchoicerequest\" ||\r\n\t\t\targs.requestType === \"filtersearchbegin\"\r\n\t\t) {\r\n\t\t\targs.filterChoiceCount = 3000;\r\n\t\t}\r\n\r\n\t\t// 显示过滤的选项\r\n\t\tif (\r\n\t\t\targs.requestType === \"filterbeforeopen\" &&\r\n\t\t\tthis.currentFilterField !== args.columnName\r\n\t\t) {\r\n\t\t\targs.cancel = true;\r\n\t\t\tlet columnFilter = [];\r\n\t\t\tlet field = args.columnName;\r\n\t\t\tif (this.config.filterSettings.length) {\r\n\t\t\t\tcolumnFilter = this.config.filterSettings.filter(\r\n\t\t\t\t\t(x) => x.field !== field\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t\tlet data = {\r\n\t\t\t\tdashboardDataTableId: this.portlet.dashboardDataTableId,\r\n\t\t\t\tdisplayColumnFilter: field,\r\n\t\t\t\tcolumnFilter: columnFilter,\r\n\t\t\t};\r\n\t\t\tthis.http.post(\r\n\t\t\t\tthis.api.urlList.GetDistinctColumnValsByPortletDataParam,\r\n\t\t\t\tdata,\r\n\t\t\t\t(res) => {\r\n\t\t\t\t\tthis.pageLoading = false;\r\n\t\t\t\t\tlet curFomart = this.formatSettings.find(\r\n\t\t\t\t\t\t(x) => x.name === field\r\n\t\t\t\t\t);\r\n\t\t\t\t\tif (\r\n\t\t\t\t\t\tcurFomart &&\r\n\t\t\t\t\t\t[\"date\", \"datetime\"].includes(curFomart.type)\r\n\t\t\t\t\t) {\r\n\t\t\t\t\t\tres = res[field].map((x) => new Date(x));\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tres = res[field];\r\n\t\t\t\t\t}\r\n\t\t\t\t\tthis.currentFilterField = args.columnName;\r\n\t\t\t\t\tthis.filterContents = res;\r\n\t\t\t\t\tthis.grid.filterModule.openMenuByField(args.columnName);\r\n\t\t\t\t\tif (columnFilter.length) {\r\n\t\t\t\t\t\tthis.grid.clearFiltering();\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t);\r\n\t\t\tif (\r\n\t\t\t\targs.requestType === \"filterbeforeopen\" &&\r\n\t\t\t\tthis.currentFilterField === args.columnName\r\n\t\t\t) {\r\n\t\t\t\tlet columnName = args.columnName;\r\n\t\t\t\tif (this.filterContents) {\r\n\t\t\t\t\tlet curResult = this.filterContents;\r\n\t\t\t\t\tlet filterOptions = curResult.map((x) => {\r\n\t\t\t\t\t\tlet obj: any = {};\r\n\t\t\t\t\t\tobj[columnName] = x;\r\n\t\t\t\t\t\treturn obj;\r\n\t\t\t\t\t});\r\n\t\t\t\t\targs.filterModel.options.dataSource = filterOptions;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\t// 处理排序\r\n\t\t\tif (args.requestType === \"sorting\") {\r\n\t\t\t\tif (args.columnName) {\r\n\t\t\t\t\tthis.sort = args.direction === \"Ascending\" ? 1 : 0;\r\n\t\t\t\t\tthis.sortedColumn = args.columnName;\r\n\t\t\t\t\tthis.reloadTableData({\r\n\t\t\t\t\t\tpage: this.currentPage,\r\n\t\t\t\t\t\tsize: this.pageSize,\r\n\t\t\t\t\t\tsort: this.sort,\r\n\t\t\t\t\t\tsortedColumn: this.sortedColumn,\r\n\t\t\t\t\t});\r\n\t\t\t\t} else {\r\n\t\t\t\t\tthis.sort = null;\r\n\t\t\t\t\tthis.sortedColumn = null;\r\n\t\t\t\t\tthis.reloadTableData({\r\n\t\t\t\t\t\tpage: this.currentPage,\r\n\t\t\t\t\t\tsize: this.pageSize,\r\n\t\t\t\t\t});\r\n\t\t\t\t}\r\n\r\n\t\t\t\tthis.config.tableSortSetting = {\r\n\t\t\t\t\tsort: this.sort,\r\n\t\t\t\t\tsortedColumn: this.sortedColumn,\r\n\t\t\t\t};\r\n\t\t\t\tthis.portlet.config = JSON.stringify(this.config);\r\n\t\t\t\tconst index = this.portlets.findIndex(\r\n\t\t\t\t\t(x) => x.newId === this.portlet.newId\r\n\t\t\t\t);\r\n\t\t\t\tthis.portlets[index].config = JSON.stringify(this.config);\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tpublic resizeStop(args) {\r\n\t\tlet field = this.configFields.filter(\r\n\t\t\t(el) => el.colName === args.column.field\r\n\t\t);\r\n\t\tif (field && field.length > 0) {\r\n\t\t\tfield[0].width = parseInt(args.column.width);\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] = portlet;\r\n\t\t}\r\n\t}\r\n\r\n\tpublic rowDataBound(args) {\r\n\t\tif (args.row.ariaRowIndex % 2 === 0) {\r\n\t\t\targs.row.style.backgroundColor = \"#f8fafb\";\r\n\t\t} else {\r\n\t\t\targs.row.style.backgroundColor = \"#ffffff\";\r\n\t\t}\r\n\t}\r\n\r\n\tpublic created(args) {\r\n\t\tif (this.config.showGrandTotals) {\r\n\t\t\tlet el = this.grid.element.querySelector(\".e-gridfooter\");\r\n\t\t\tif (el) el.classList.remove(\"hidesummary\");\r\n\t\t} else {\r\n\t\t\tlet el = this.grid.element.querySelector(\".e-gridfooter\");\r\n\t\t\tif (el) el.classList.add(\"hidesummary\");\r\n\t\t}\r\n\t}\r\n\r\n\tpublic exportQueryCellInfo(args: ExcelQueryCellInfoEventArgs): void {\r\n\t\tlet curFormat = this.formatSettings.find(\r\n\t\t\t(x) => x.name === args.column.field\r\n\t\t);\r\n\t\tif (curFormat) {\r\n\t\t\tif (curFormat.type === \"date\") {\r\n\t\t\t\targs.value = this.pbf.convertDateFormat(\r\n\t\t\t\t\targs.value,\r\n\t\t\t\t\tcurFormat.format\r\n\t\t\t\t\t\t? curFormat.format.replace(\"dd\", \"DD\")\r\n\t\t\t\t\t\t: null\r\n\t\t\t\t);\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tif (\r\n\t\t\targs.column.field &&\r\n\t\t\tthis.millionFields.includes(args.column.field)\r\n\t\t) {\r\n\t\t\targs.value = args.data[args.column.field] / 1000000;\r\n\t\t}\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\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\r\n\t\t// Excel Style Format\r\n\t\tlet queryCell =\r\n\t\t\tthis.tableList &&\r\n\t\t\tthis.tableList.filter(\r\n\t\t\t\t(item) => item.colName === args.column.field\r\n\t\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].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.cellAddStyleExcel(args, queryCell);\r\n\t\t\t} else this.cellAddStyleExcel(args, queryCell);\r\n\t\t}\r\n\t}\r\n\r\n\tprivate cellAddStyleExcel(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.style = {\r\n\t\t\t\t\t\tfontColor: this.pbf.rgbaToHex(\r\n\t\t\t\t\t\t\t`${queryCell.format[0].negaFontColor}`\r\n\t\t\t\t\t\t),\r\n\t\t\t\t\t\tfontSize: Number(\r\n\t\t\t\t\t\t\t`${queryCell.format[0].negaFontSizeValue}`.replace(\r\n\t\t\t\t\t\t\t\t\"px\",\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\tfontName: `${queryCell.format[0].negaFontFamilyValue}`,\r\n\t\t\t\t\t\tbackColor: this.pbf.rgbaToHex(\r\n\t\t\t\t\t\t\t`${queryCell.format[0].negaBackgroundColor}`\r\n\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\targs.style = {\r\n\t\t\t\t\t\tfontColor: this.pbf.rgbaToHex(\r\n\t\t\t\t\t\t\t`${queryCell.format[0].fontColor}`\r\n\t\t\t\t\t\t),\r\n\t\t\t\t\t\tfontSize: Number(\r\n\t\t\t\t\t\t\t`${queryCell.format[0].fontSizeValue}`.replace(\r\n\t\t\t\t\t\t\t\t\"px\",\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\tfontName: `${queryCell.format[0].fontFamilyValue}`,\r\n\t\t\t\t\t\tbackColor: this.pbf.rgbaToHex(\r\n\t\t\t\t\t\t\t`${queryCell.format[0].backgroundColor}`\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}\r\n\t}\r\n\r\n\tpublic getLogoInfo(colName, code) {\r\n\t\tif (this.configFields && this.configFields.length) {\r\n\t\t\tlet fields = this.configFields.filter(\r\n\t\t\t\t(el) => el.colName == colName\r\n\t\t\t);\r\n\t\t\tif (fields && fields.length) {\r\n\t\t\t\treturn fields[0][code];\r\n\t\t\t} else {\r\n\t\t\t\treturn false;\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\treturn false;\r\n\t\t}\r\n\t}\r\n\r\n\tpublic getLogoImage(logoDocId) {\r\n\t\tlet img;\r\n\t\tif (\r\n\t\t\tlogoDocId !== undefined &&\r\n\t\t\tlogoDocId !== null &&\r\n\t\t\tlogoDocId !== \"00000000-0000-0000-0000-000000000000\"\r\n\t\t) {\r\n\t\t\timg =\r\n\t\t\t\tthis.api.baseurl +\r\n\t\t\t\tthis.api.urlList.FileGet +\r\n\t\t\t\t\"?username=\" +\r\n\t\t\t\tthis.userInfo.username +\r\n\t\t\t\t\"&accountId=\" +\r\n\t\t\t\tthis.userInfo.accountId +\r\n\t\t\t\t\"&docId=\" +\r\n\t\t\t\tlogoDocId +\r\n\t\t\t\t`&Authorization=Bearer`;\r\n\t\t} else {\r\n\t\t\timg = \"../../../../../../assets/img/default_profile_icon.png\";\r\n\t\t}\r\n\t\treturn img;\r\n\t}\r\n\r\n\tprivate setQuarterFormat() {\r\n\t\treturn [\r\n\t\t\t{ value: \"03/2021\", format: \"MM/yyyy\" },\r\n\t\t\t{ value: \"03/21\", format: \"MM/dd\" },\r\n\t\t\t{ value: \"3/2021\", format: \"M/yyyy\" },\r\n\t\t\t{ value: \"3/21\", format: \"M/yy\" },\r\n\t\t\t{ value: \"March 2021\", format: \"MMMM yyyy\" },\r\n\t\t\t{ value: \"Mar, 2021\", format: \"MMM, yyyy\" },\r\n\t\t\t{ value: \"March, 2021\", format: \"MMMM, yyyy\" },\r\n\t\t\t{ value: \"2021\", format: \"yyyy\" },\r\n\t\t];\r\n\t}\r\n\r\n\tprivate getDateFormat(format_) {\r\n\t\tswitch (format_) {\r\n\t\t\tcase \"DD/MM/YYYY\":\r\n\t\t\t\treturn \"dd/MM/yyyy\";\r\n\t\t\tcase \"DD/MM/YY\":\r\n\t\t\t\treturn \"dd/MM/yy\";\r\n\t\t\tcase \"MM/DD/YYYY\":\r\n\t\t\t\treturn \"MM/dd/yyyy\";\r\n\t\t\tcase \"MM/DD/YY\":\r\n\t\t\t\treturn \"MM/dd/yy\";\r\n\t\t\tcase \"YYYY-MM-DD\":\r\n\t\t\t\treturn \"yyyy-MM-dd\";\r\n\t\t\tcase \"YY-MM-DD\":\r\n\t\t\t\treturn \"yy-MM-dd\";\r\n\t\t\tcase \"DD-MM-YYYY\":\r\n\t\t\t\treturn \"dd-MM-yyyy\";\r\n\t\t\tcase \"DD-MM-YY\":\r\n\t\t\t\treturn \"dd-MM-yy\";\r\n\t\t\tcase \"MM-DD-YYYY\":\r\n\t\t\t\treturn \"MM-dd-yyyy\";\r\n\t\t\tcase \"MM-DD-YY\":\r\n\t\t\t\treturn \"MM-dd-yy\";\r\n\t\t\tcase \"MMM DD, YYYY\":\r\n\t\t\t\treturn \"MMM dd, yyyy\";\r\n\t\t\tcase \"DD-MMM-YYYY\":\r\n\t\t\t\treturn \"dd-MMM-yyyy\";\r\n\t\t\tdefault:\r\n\t\t\t\tbreak;\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.millionFields.push(colName);\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\tpublic getAlign(table) {\r\n\t\tif (\r\n\t\t\ttable.format &&\r\n\t\t\ttable.format.length &&\r\n\t\t\ttable.format[0].formatChecked\r\n\t\t)\r\n\t\t\treturn table.format[0].align;\r\n\t\treturn [\"date\", \"datetime\", \"string\", \"nvarchar\", \"dropdown\"].includes(\r\n\t\t\ttable.dataType\r\n\t\t) &&\r\n\t\t\t![\"MOIC\", \"DPI\", \"TVPI\", \"RVPI\", \"PIC\", \"Multiple\"].includes(\r\n\t\t\t\ttable.colName\r\n\t\t\t)\r\n\t\t\t? \"Left\"\r\n\t\t\t: \"Right\";\r\n\t}\r\n\r\n\tpublic pageChanged(args: any) {\r\n\t\tif (args.newProp) {\r\n\t\t\t// 处理分页器点击事件\r\n\t\t\tlet pageSize = args.newProp.pageSize;\r\n\t\t\tif (pageSize) {\r\n\t\t\t\tthis.pageSize = pageSize;\r\n\t\t\t\tthis.currentPage = 1;\r\n\t\t\t} else {\r\n\t\t\t\tthis.currentPage = args.newProp.currentPage;\r\n\t\t\t}\r\n\t\t\tthis.reloadTableData(\r\n\t\t\t\t{\r\n\t\t\t\t\tpage: this.currentPage,\r\n\t\t\t\t\tsize: this.pageSize,\r\n\t\t\t\t\tsortedColumn:\r\n\t\t\t\t\t\tthis.sortedColumn === null\r\n\t\t\t\t\t\t\t? undefined\r\n\t\t\t\t\t\t\t: this.sortedColumn,\r\n\t\t\t\t\tsort: this.sort === null ? undefined : this.sort,\r\n\t\t\t\t},\r\n\t\t\t\ttrue\r\n\t\t\t);\r\n\t\t}\r\n\t}\r\n\r\n\tpublic reloadTableData(setting: any = {}, refreshFormat?) {\r\n\t\tlet params: any = {};\r\n\t\tif (setting.page && setting.size) {\r\n\t\t\tparams.currentPage = setting.page;\r\n\t\t\tparams.pageSize = setting.size;\r\n\t\t}\r\n\t\tif (setting.sortedColumn) {\r\n\t\t\tparams.sortedColumn = setting.sortedColumn;\r\n\t\t\tparams.sort = setting.sort;\r\n\t\t}\r\n\t\tthis.pageLoading = true;\r\n\t\tthis.dashboardPorletsService.getDataByPortletsNew(\r\n\t\t\t[this.portlet],\r\n\t\t\t() => {\r\n\t\t\t\tthis.pageLoading = false;\r\n\t\t\t\tconst data = DataUtil.parse.parseJson(\r\n\t\t\t\t\tthis.dashboardPorletsService.getResultByDataTable(\r\n\t\t\t\t\t\tthis.portlet,\r\n\t\t\t\t\t\tfalse,\r\n\t\t\t\t\t\tfalse,\r\n\t\t\t\t\t\tthis.dashboard.id\r\n\t\t\t\t\t)\r\n\t\t\t\t);\r\n\r\n\t\t\t\tthis.data = data.map((item) => {\r\n\t\t\t\t\treturn {\r\n\t\t\t\t\t\t...item,\r\n\t\t\t\t\t\tMOIC: `${Number(item[\"MOIC\"]).toFixed(2)}x`,\r\n\t\t\t\t\t\tDPI: `${Number(item[\"DPI\"]).toFixed(2)}x`,\r\n\t\t\t\t\t\tTVPI: `${Number(item[\"TVPI\"]).toFixed(2)}x`,\r\n\t\t\t\t\t\tRVPI: `${Number(item[\"RVPI\"]).toFixed(2)}x`,\r\n\t\t\t\t\t\tPIC: `${Number(item[\"PIC\"]).toFixed(2)}x`,\r\n\t\t\t\t\t\tMultiple: `${Number(item[\"Multiple\"]).toFixed(2)}x`,\r\n\t\t\t\t\t};\r\n\t\t\t\t});\r\n\r\n\t\t\t\t// if (this.tableList && this.tableList.length) {\r\n\t\t\t\t// \tconst typeMap = {};\r\n\t\t\t\t// \tthis.tableList.forEach((col) => {\r\n\t\t\t\t// \t\tif (col.dataType === \"number\") {\r\n\t\t\t\t// \t\t\ttypeMap[col.colName] = true;\r\n\t\t\t\t// \t\t}\r\n\t\t\t\t// \t});\r\n\t\t\t\t// \tthis.data.forEach((_data) => {\r\n\t\t\t\t// \t\tObject.keys(typeMap).forEach((key) => {\r\n\t\t\t\t// \t\t\t_data[key] =\r\n\t\t\t\t// \t\t\t\t_data[key] === null\r\n\t\t\t\t// \t\t\t\t\t? null\r\n\t\t\t\t// \t\t\t\t\t: this.pbf.bankersRounding(\r\n\t\t\t\t// \t\t\t\t\t\t\tNumber(_data[key])\r\n\t\t\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\r\n\t\t\t\tthis.totalRecordsCount =\r\n\t\t\t\t\tthis.dashboardPorletsService.getResultByDataTable(\r\n\t\t\t\t\t\tthis.portlet,\r\n\t\t\t\t\t\ttrue,\r\n\t\t\t\t\t\ttrue,\r\n\t\t\t\t\t\tthis.dashboard.id\r\n\t\t\t\t\t);\r\n\t\t\t\tthis.tableList = [...this.configFields];\r\n\t\t\t\tthis.tableList = this.tableList.filter((fl) => !fl.isHidden);\r\n\r\n\t\t\t\tthis.tableList = this.tableList.map((item) => {\r\n\t\t\t\t\treturn {\r\n\t\t\t\t\t\t...item,\r\n\t\t\t\t\t\tdataType: [\r\n\t\t\t\t\t\t\t\"MOIC\",\r\n\t\t\t\t\t\t\t\"DPI\",\r\n\t\t\t\t\t\t\t\"TVPI\",\r\n\t\t\t\t\t\t\t\"RVPI\",\r\n\t\t\t\t\t\t\t\"PIC\",\r\n\t\t\t\t\t\t\t\"Multiple\",\r\n\t\t\t\t\t\t].includes(item.colName)\r\n\t\t\t\t\t\t\t? \"string\"\r\n\t\t\t\t\t\t\t: item[\"dataType\"],\r\n\t\t\t\t\t};\r\n\t\t\t\t});\r\n\t\t\t\tconst typeMap = {};\r\n\t\t\t\tthis.tableList.forEach((col) => {\r\n\t\t\t\t\tif (col.dataType === \"number\") {\r\n\t\t\t\t\t\ttypeMap[col.colName] = true;\r\n\t\t\t\t\t}\r\n\t\t\t\t});\r\n\t\t\t\tthis.data.forEach((_data) => {\r\n\t\t\t\t\tObject.keys(typeMap).forEach((key) => {\r\n\t\t\t\t\t\t_data[key] =\r\n\t\t\t\t\t\t\t_data[key] === null\r\n\t\t\t\t\t\t\t\t? null\r\n\t\t\t\t\t\t\t\t: this.pbf.bankersRounding(Number(_data[key]));\r\n\t\t\t\t\t});\r\n\t\t\t\t});\r\n\t\t\t\tif (this.grid) {\r\n\t\t\t\t\tif (refreshFormat) {\r\n\t\t\t\t\t\tthis.grid.columns.forEach((item) => {\r\n\t\t\t\t\t\t\titem.format = this.getFormatOptions(item.field);\r\n\t\t\t\t\t\t});\r\n\t\t\t\t\t\tif (this.grid.contentModule) {\r\n\t\t\t\t\t\t\tthis.grid.refreshColumns();\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tthis.grid.refresh();\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\tthis.ref.markForCheck();\r\n\t\t\t\tthis.ref.detectChanges();\r\n\t\t\t},\r\n\t\t\tparams,\r\n\t\t\tfalse,\r\n\t\t\tthis.dashboard\r\n\t\t);\r\n\t}\r\n\r\n\tgetXTxt(colName, item) {\r\n\t\tif (colName == \"MOIC\") {\r\n\t\t\treturn `${Number(item[\"MOIC\"]).toFixed(2)}x`;\r\n\t\t} else if (colName == \"DPI\") {\r\n\t\t\treturn `${Number(item[\"DPI\"]).toFixed(2)}x`;\r\n\t\t} else if (colName == \"TVPI\") {\r\n\t\t\treturn `${Number(item[\"TVPI\"]).toFixed(2)}x`;\r\n\t\t} else if (colName == \"RVPI\") {\r\n\t\t\treturn `${Number(item[\"RVPI\"]).toFixed(2)}x`;\r\n\t\t} else if (colName == \"PIC\") {\r\n\t\t\treturn `${Number(item[\"PIC\"]).toFixed(2)}x`;\r\n\t\t} else if (colName == \"Multiple\") {\r\n\t\t\treturn `${Number(item[\"Multiple\"]).toFixed(2)}x`;\r\n\t\t}\r\n\t}\r\n}\r\n"]}