raise-common-lib-new 0.0.63 → 0.0.64

package/esm2022/lib/dashboard/gadget-group/gadget-pivot-chart/gadget-pivot.component.mjs

@@ -0,0 +1,3117 @@
+import { Component, Input, ViewChild, ChangeDetectionStrategy, EventEmitter, Output, Optional, Inject, } from "@angular/core";
+import { ToolbarService, FieldListService, NumberFormattingService, CalculatedFieldService, GroupingBarService, VirtualScrollService, DrillThroughService, } from "@syncfusion/ej2-angular-pivotview";
+import { L10n, createElement, enableRipple } from "@syncfusion/ej2-base";
+import { PBF_TOKEN } from "../../../service/InjectionToken";
+import { sortBy, differenceWith, startsWith, cloneDeep, uniqBy, filter as _filter, maxBy, minBy, sumBy, meanBy, mean, } from "lodash";
+import { AGGREGATE_TYPES_TEXT, ALL_AGGREGATE_TYPES, } from "../../dashboardPorlets.service";
+import { Browser } from "@syncfusion/ej2-base";
+import { Observable } from "rxjs";
+import { MaskedTextBox } from "@syncfusion/ej2-inputs/src/maskedtextbox/maskedtextbox";
+import { DataManager } from "@syncfusion/ej2-data/src/manager";
+import { Predicate, Query } from "@syncfusion/ej2-data/src/query";
+import { DataUtil } from "@syncfusion/ej2-data";
+import moment from "moment";
+import * as i0 from "@angular/core";
+import * as i1 from "../../dashboardPorlets.service";
+import * as i2 from "../../dashboard.service";
+import * as i3 from "@angular/common";
+import * as i4 from "@syncfusion/ej2-angular-pivotview";
+enableRipple(false);
+export class GadgetPivotChartComponent {
+    dashboardPorletsService;
+    dashboardService;
+    ref;
+    pbf;
+    portlet;
+    dashboard;
+    portlets;
+    updatePorletConfig = new EventEmitter();
+    Pivot_Data;
+    config;
+    dataSourceSettings;
+    excludeFields = [];
+    filterSettings = [];
+    datePipeFormat;
+    translation;
+    pivotObj;
+    fieldlistObj;
+    grandTotals = {};
+    subTotals = {};
+    previousSort;
+    subscriptions = [];
+    allDataValue;
+    // private calculatedFieldSettings;
+    isInit = true;
+    pivotSearchBox;
+    displayOption = {
+        view: "Both",
+        primary: "Chart",
+    };
+    chartSettings;
+    tooltipSettings = {
+        enable: false,
+    };
+    columnTexts = [];
+    configFields = [];
+    quarterFormat = [
+        { value: "03/2021", format: "MM/yyyy" },
+        { value: "03/21", format: "MM/dd" },
+        { value: "3/2021", format: "M/yyyy" },
+        { value: "3/21", format: "M/yy" },
+        { value: "March 2021", format: "MMMM yyyy" },
+        { value: "Mar, 2021", format: "MMM, yyyy" },
+        { value: "March, 2021", format: "MMMM, yyyy" },
+        { value: "2021", format: "yyyy" },
+    ];
+    zoomSettings = {
+        enable: false,
+    };
+    itemDataTypeSortArr = [
+        "Assets",
+        "Liabilities",
+        "Equity",
+        "P&L",
+        "Cashflow",
+    ];
+    formatDates = [];
+    customCalculatedFields = []; // 自定义计算列
+    allowedCalculatedFields = []; // 允许自定义算法的字段
+    zeroFormatData = {
+        emptyList: [],
+        hgList: [],
+    };
+    millionFields = [];
+    tempSubtotals = [];
+    orderByColumns; // Eg: "DueDate, Sequence"
+    isApplyIRR = false;
+    calcIRRData;
+    percentNumFields = [];
+    pageLoading;
+    observable = new Observable();
+    isloaded; // 是否已经初始化过
+    constructor(dashboardPorletsService, dashboardService, ref, pbf) {
+        this.dashboardPorletsService = dashboardPorletsService;
+        this.dashboardService = dashboardService;
+        this.ref = ref;
+        this.pbf = pbf;
+    }
+    ngOnInit() {
+        this.chartSettings = {
+            legendSettings: {
+                visible: false,
+            },
+            enableMultipleAxis: false,
+            showMultiLevelLabels: false,
+            chartSeries: {
+                type: "Column",
+                columnSpacing: 0.1,
+                columnWidth: 0.9,
+            },
+            multipleAxisMode: "Stacked",
+            primaryXAxis: {
+                title: " ",
+                labelFormat: "N2",
+                majorGridLines: { width: 0 },
+                minorGridLines: {
+                    width: 0,
+                    color: "transparent",
+                    visible: false,
+                },
+                minorTickLines: { visible: false },
+                lineStyle: {
+                    width: 0,
+                },
+            },
+            chartArea: {
+                opacity: 0,
+                border: {
+                    width: 0,
+                },
+            },
+            palettes: [
+                "#594bb9",
+                "#f1af32",
+                "#4688ed",
+                "#e0563e",
+                "#803a63",
+                "#6dd8b5",
+                "#e87225",
+                "#c5df42",
+                "#c6437d",
+            ],
+            primaryYAxis: {
+                // Y轴标题设置为空
+                title: " ",
+                labelFormat: "N2",
+            },
+            zoomSettings: {
+                enableMouseWheelZooming: false,
+                enablePinchZooming: false,
+                enableSelectionZooming: false,
+                enableDeferredZooming: false,
+                toolbarItems: [],
+                enableScrollbar: false,
+                enableZooming: false,
+            },
+            title: " ",
+        };
+        this.getInfo();
+        this.getData();
+    }
+    ngAfterViewInit() {
+        this.subscriptions.push(this.dashboardService.getStartRefresh().subscribe((dashboardId) => {
+            if (this.dashboard.id === dashboardId) {
+                this.pageLoading = true;
+                this.ref.markForCheck();
+            }
+        }));
+        this.subscriptions.push(this.dashboardService.getRefreshGadget().subscribe((e) => {
+            if (!e) {
+                return;
+            }
+            const id = e["newId"];
+            const config = e["config"];
+            if (id === this.portlet.newId || id === this.portlet.id) {
+                this.pageLoading = false;
+                this.getData(config);
+            }
+        }));
+        this.subscriptions.push(this.dashboardService.getchangePivot().subscribe((updated) => {
+            if (updated === this.portlet.newId) {
+                this.getData();
+            }
+        }));
+        this.subscriptions.push(this.dashboardService.getUpdated().subscribe((newId) => {
+            if (newId === this.portlet.newId || newId === this.portlet.id) {
+                this.getData();
+                if (this.pivotObj)
+                    this.pivotObj.refreshData();
+            }
+        }));
+        this.subscriptions.push(this.dashboardService.getTableFormat().subscribe((updated) => {
+            if (updated === this.portlet.newId) {
+                this.getData();
+                if (this.pivotObj)
+                    this.pivotObj.refreshData();
+            }
+        }));
+        this.subscriptions.push(this.dashboardService
+            .clearFieldListObservable()
+            .subscribe((updated) => {
+            if (updated === this.portlet.newId) {
+                this.pivotObj.dataSourceSettings.dataSource = [];
+                if (this.pivotObj)
+                    this.pivotObj.refreshData();
+                this.ref.markForCheck();
+                this.ref.detectChanges();
+            }
+        }));
+        this.subscriptions.push(this.dashboardService
+            .getPvtableDisplayOptionChartChange()
+            .subscribe((data) => {
+            if (!data ||
+                !this.portlet ||
+                this.portlet.newId !== data.newId) {
+                return;
+            }
+            if (this.chartSettings["pointRender"]) {
+                this.chartSettings["pointRender"].complete();
+            }
+            this.initChartSetting(data.chartType);
+            this.setConfigToPorlet();
+            if (this.pivotObj)
+                this.pivotObj.refreshData();
+        }));
+        this.subscriptions.push(this.dashboardService
+            .getEnableMultipleAxisChange()
+            .subscribe((data) => {
+            if (!data ||
+                !this.portlet ||
+                this.portlet.newId !== data.newId) {
+                return;
+            }
+            if (this.chartSettings["pointRender"]) {
+                this.chartSettings["pointRender"].complete();
+            }
+            this.chartSettings.enableMultipleAxis =
+                data.enableMultipleAxis;
+            this.chartSettings.multipleAxisMode = data.multipleAxisMode;
+            this.chartSettings.legendSettings = {
+                visible: data.visible,
+            };
+            this.chartSettings = Object.assign({}, this.chartSettings);
+            if (this.pivotObj)
+                setTimeout(() => this.pivotObj.refreshData());
+            this.setConfigToPorlet();
+        }));
+        this.subscriptions.push(this.dashboardService.getChartTypeChange().subscribe((data) => {
+            if (!data ||
+                !this.portlet ||
+                this.portlet.newId !== data.newId) {
+                return;
+            }
+            this.chartSettings.chartSeries.type =
+                data.chartSettings.chartSeries.type === "Stacked Column"
+                    ? "StackingColumn"
+                    : data.chartSettings.chartSeries.type;
+            this.chartSettings = Object.assign({}, this.chartSettings);
+            if (this.pivotObj)
+                this.pivotObj.refreshData();
+            this.setConfigToPorlet();
+        }));
+        this.subscriptions.push(this.dashboardService.getTheme().subscribe((data) => {
+            if (!data ||
+                !this.portlet ||
+                this.portlet.newId !== data.newId) {
+                return;
+            }
+            this.chartSettings.palettes = [...data.theme];
+            this.chartSettings = Object.assign({}, this.chartSettings);
+            if (this.pivotObj)
+                this.pivotObj.layoutRefresh();
+            this.setConfigToPorlet();
+        }));
+    }
+    ngOnDestroy() {
+        this.subscriptions.forEach((sub) => sub.unsubscribe());
+    }
+    // 找到数组中出现最多频次的元素
+    findMostFrequent(arr) {
+        let maxCount = 0;
+        let mostFrequentNum = null;
+        // 使用一个对象来计数
+        const countMap = {};
+        arr.forEach((num) => {
+            countMap[num] = (countMap[num] || 0) + 1;
+            // 检查是否是最多的
+            if (countMap[num] > maxCount) {
+                maxCount = countMap[num];
+                mostFrequentNum = num;
+            }
+        });
+        return mostFrequentNum;
+    }
+    loaded(args) {
+        // 找到所有y轴标签
+        const elements = document.querySelectorAll(`[id^="${this.pivotObj.element.id}_chart2_AxisLabel"],
+			[id^="${this.pivotObj.element.id}_chart3_AxisLabel"]`);
+        let isErrorAccuracy = false;
+        let xPosition = [];
+        elements.forEach((element) => {
+            // 是否有精度问题
+            if (Boolean(Number(element.innerHTML)) &&
+                element.innerHTML.length > 15) {
+                isErrorAccuracy = true;
+            }
+            // 记录一下y轴标签的x坐标
+            const currentX = parseFloat(element.getAttribute("x"));
+            xPosition.push(currentX);
+            if (element.innerHTML.endsWith("...")) {
+                let innerHTML = element.innerHTML.replace("...", "");
+                element.innerHTML = Number(innerHTML).toFixed(2);
+                element.setAttribute("x", currentX + innerHTML.length * 3 - 3 + ""); // 矫正长度
+            }
+        });
+        if (isErrorAccuracy) {
+            // 找到所有y轴标签中的平均x坐标
+            let x = mean(xPosition);
+            elements.forEach((element) => {
+                // 手动精度修正
+                element.innerHTML = Number(element.innerHTML).toFixed(2);
+                if (element.innerHTML === "-0.00") {
+                    element.innerHTML = Number(0).toFixed(2);
+                }
+                // 手动设置 x坐标
+                element.setAttribute("x", x.toString());
+            });
+        }
+    }
+    setConfigToPorlet() {
+        const config = JSON.parse(this.portlet.config);
+        if (!config) {
+            return;
+        }
+        config.pvtableChartSetting = {
+            displayOption: this.displayOption,
+            chartSettings: this.chartSettings,
+        };
+        this.chartSettings["pointRender"] = null;
+        this.config = { ...config };
+        this.updatePorletConfig.emit({
+            newId: this.portlet.newId,
+            config,
+        });
+    }
+    chartSeriesCreated(e) { }
+    initChartSetting(type) {
+        const setting = this.config.pvtableChartSetting;
+        if (!setting) {
+            return;
+        }
+        setting.chartSettings.chartSeries.dataLabel = {
+            visible: true,
+            position: "Outside",
+            // Define the template for data label content
+            template: '<div style="color: Black"> ${(point.y).toLocaleString()}</div>',
+        };
+        this.chartSettings = {
+            ...setting.chartSettings,
+            primaryXAxis: {
+                title: " ",
+                labelFormat: "N2",
+                majorGridLines: { width: 0 },
+                minorGridLines: {
+                    width: 0,
+                    color: "transparent",
+                    visible: false,
+                },
+                minorTickLines: { visible: false },
+                lineStyle: {
+                    width: 0,
+                },
+            },
+            pointRender: this.observable.subscribe((args) => {
+                if (args && args.point && args.point.y) {
+                    args.point.y = parseFloat(args.point.y.toFixed(2));
+                }
+            }),
+            chartArea: {
+                opacity: 0,
+                border: {
+                    width: 0,
+                },
+            },
+            primaryYAxis: {
+                // Y轴标题设置为空
+                title: " ",
+                labelFormat: "N2",
+            },
+            loaded: this.isloaded
+                ? null
+                : this.observable.subscribe(this.loaded.bind(this)),
+            zoomSettings: {
+                enableMouseWheelZooming: false,
+                enablePinchZooming: false,
+                enableSelectionZooming: false,
+                enableDeferredZooming: false,
+                toolbarItems: [],
+                enableScrollbar: false,
+                enableZooming: false,
+            },
+        };
+        this.isloaded = true;
+        // @ts-ignore
+        if (!this.chartSettings.palettes) {
+            this.chartSettings.palettes = [
+                "#594bb9",
+                "#f1af32",
+                "#4688ed",
+                "#e0563e",
+                "#803a63",
+                "#6dd8b5",
+                "#e87225",
+                "#c5df42",
+                "#c6437d",
+            ];
+        }
+        this.chartSettings.chartSeries.columnSpacing = 0.1;
+        this.chartSettings.chartSeries.columnWidth = 0.9;
+        if (type) {
+            this.chartSettings.chartSeries = {
+                type,
+                columnSpacing: 0.1,
+                columnWidth: 0.9,
+            };
+        }
+    }
+    onMemberEditorOpen(args) {
+        // 你可以在这里根据需要修改args来自定义过滤窗口的行为
+        // 11247 专门为item data type而设置
+        if (args.fieldName === "AccountTypeCode") {
+            let res = new Array(5).fill(null);
+            const fieldMembers = [...args.fieldMembers];
+            for (let i = fieldMembers.length - 1; i >= 0; i--) {
+                let index = -1;
+                const item = this.itemDataTypeSortArr.find((name, ind) => {
+                    if (fieldMembers[i].actualText === name) {
+                        index = ind;
+                    }
+                    return fieldMembers[i].actualText === name;
+                });
+                if (!item) {
+                    continue;
+                }
+                const fillItem = fieldMembers.splice(i, 1);
+                res[index] = fillItem[0];
+            }
+            res = res.filter((item) => item) || [];
+            args.fieldMembers = [...res, ...fieldMembers];
+            setTimeout(() => {
+                const ele = document.querySelector(".e-member-editor-dialog");
+                if (ele) {
+                    ele.querySelector(".e-filter-sort").setAttribute("style", "display: none");
+                }
+            });
+        }
+    }
+    beforeExport(exportData) {
+        if (exportData) {
+            const keyMap = {};
+            this.dataSourceSettings.formatSettings.forEach((data) => {
+                if (data.format === "#,###,,.0;(#,###,,.0)" ||
+                    data.format === "#,###,,;(#,###,,)" ||
+                    data.format === "#,###,,.00;(#,###,,.00)") {
+                    keyMap[data.name] = true;
+                }
+            });
+            if (exportData.dataCollections &&
+                exportData.dataCollections.length) {
+                exportData.dataCollections[0].forEach((row) => {
+                    row.forEach((cell) => {
+                        if (keyMap[cell.actualText]) {
+                            cell.value = cell.actualValue;
+                        }
+                    });
+                });
+            }
+        }
+    }
+    async getData(config) {
+        this.pageLoading = false;
+        let columns = [];
+        let values = [];
+        let formatSettings = [];
+        let rows = [];
+        let fieldMapping = [];
+        // 清空grandTotals和subTotals
+        this.grandTotals = {};
+        this.subTotals = {};
+        this.config = config
+            ? JSON.parse(config)
+            : JSON.parse(this.portlet.config);
+        let type = this.config &&
+            this.config.pvtableChartSetting &&
+            this.config.pvtableChartSetting.chartSettings
+            ? this.config.pvtableChartSetting.chartSettings.chartSeries.type
+            : null;
+        if (type && type === "Stacked Column") {
+            type = "StackingColumn";
+        }
+        this.initChartSetting(type);
+        if (this.config.fields) {
+            this.configFields = JSON.parse(JSON.stringify(this.config.fields));
+        }
+        this.Pivot_Data = this.dashboardPorletsService.getResultByDataTable(this.portlet, false, false, this.dashboard.id);
+        this.orderByColumns = this.dashboardPorletsService.getOrderByColumnsNew(this.portlet.figureCode, this.dashboard);
+        this.Pivot_Data = DataUtil.parse.parseJson(this.Pivot_Data);
+        if (this.Pivot_Data && this.Pivot_Data.length > 0) {
+            this.getexcludeFields(this.configFields, this.Pivot_Data[0]);
+            if (!this.allowedCalculatedFields.length) {
+                this.allowedCalculatedFields = Object.keys(this.Pivot_Data[0]);
+            }
+            for (let item of this.configFields) {
+                fieldMapping.push({
+                    name: item.colName,
+                    caption: item.addtionName
+                        ? `${item.langValue} ${item.addtionName}`
+                        : item.langValue,
+                    dataType: item.dataType,
+                });
+            }
+        }
+        if (this.configFields) {
+            this.percentNumFields = [];
+            this.formatDates = [];
+            this.zeroFormatData.hgList = [];
+            this.zeroFormatData.emptyList = [];
+            this.millionFields = [];
+            this.configFields.map((el) => {
+                // SMP2-2486 & percentNum的format问题
+                if (el.dataType == "percentNum") {
+                    this.percentNumFields.push(el.colName);
+                }
+                if (el.format &&
+                    el.format.length &&
+                    el.format[0].formatChecked &&
+                    [2, 5, 8, 11, 14, 17].includes(el.format[0].selectedFormat))
+                    this.zeroFormatData.hgList.push(el.colName);
+                if (el.format &&
+                    el.format.length &&
+                    el.format[0].formatChecked &&
+                    [3, 6, 9, 12, 15, 18].includes(el.format[0].selectedFormat))
+                    this.zeroFormatData.emptyList.push(el.colName);
+                if (el.format &&
+                    el.format.length &&
+                    el.format[0].formatChecked &&
+                    [10, 11, 12, 13, 14, 15, 16, 17, 18].includes(el.format[0].selectedFormat))
+                    this.millionFields.push(el.colName);
+                if (el.dataType === "number" &&
+                    (!el.format ||
+                        (el.format &&
+                            el.format.length &&
+                            !el.format[0].formatChecked))) {
+                    const formatData = {
+                        name: el.colName,
+                        //SMP2-3026 and SMP2-3059
+                        format: el.colName !== "PortInvStk" &&
+                            el.colName !== "PortFdInvStk"
+                            ? this.dashboardPorletsService.formatNumber(el.dp)
+                            : "##0.#######0",
+                        useGrouping: true,
+                    };
+                    formatSettings.push(formatData);
+                }
+                if ((el.dataType === "percent" ||
+                    el.dataType === "percentNum") &&
+                    (!el.format ||
+                        (el.format &&
+                            el.format.length &&
+                            !el.format[0].formatChecked))) {
+                    const formatData = {
+                        name: el.colName,
+                        format: this.dashboardPorletsService.formatPercent(el.dp),
+                    };
+                    formatSettings.push(formatData);
+                }
+                if (el.dataType === "multiple" &&
+                    (!el.format ||
+                        (el.format &&
+                            el.format.length &&
+                            !el.format[0].formatChecked))) {
+                    const formatData = {
+                        name: el.colName,
+                        format: this.dashboardPorletsService.formatMultiple(el.dp),
+                    };
+                    formatSettings.push(formatData);
+                }
+                if (el.dataType === "datetime" || el.dataType === "date") {
+                    let format = "";
+                    if (el.format &&
+                        el.format.length &&
+                        el.format[0].formatChecked) {
+                        if (el.format[0].dateType == "Quarter") {
+                            let format_ = el.format[0].selectedFormatDisplay;
+                            let formatInfo = this.quarterFormat.filter((qur) => qur.value == format_);
+                            if (formatInfo.length) {
+                                format = formatInfo[0].format;
+                            }
+                            else {
+                                const formatData = {
+                                    name: el.colName,
+                                    format: format_,
+                                    type: "date",
+                                };
+                                this.formatDates.push(formatData);
+                            }
+                        }
+                        else if (el.format[0].dateType == "Date") {
+                            let fromIdx = el.format[0].selectedFormatDisplay.indexOf("(");
+                            let toIdx = el.format[0].selectedFormatDisplay.indexOf(")");
+                            let format_ = el.format[0].selectedFormatDisplay.slice(fromIdx + 1, toIdx);
+                            switch (format_) {
+                                case "DD/MM/YYYY":
+                                    format = "dd/MM/yyyy";
+                                    break;
+                                case "DD/MM/YY":
+                                    format = "dd/MM/yy";
+                                    break;
+                                case "MM/DD/YYYY":
+                                    format = "MM/dd/yyyy";
+                                    break;
+                                case "MM/DD/YY":
+                                    format = "MM/dd/yy";
+                                    break;
+                                case "YYYY-MM-DD":
+                                    format = "yyyy-MM-dd";
+                                    break;
+                                case "YY-MM-DD":
+                                    format = "yy-MM-dd";
+                                    break;
+                                case "DD-MM-YYYY":
+                                    format = "dd-MM-yyyy";
+                                    break;
+                                case "DD-MM-YY":
+                                    format = "dd-MM-yy";
+                                    break;
+                                case "MM-DD-YYYY":
+                                    format = "MM-dd-yyyy";
+                                    break;
+                                case "MM-DD-YY":
+                                    format = "MM-dd-yy";
+                                    break;
+                                case "MMM DD, YYYY":
+                                    format = "MMM dd, yyyy";
+                                    break;
+                                case "DD-MMM-YYYY":
+                                    format = "dd-MMM-yyyy";
+                                    break;
+                                default:
+                                    break;
+                            }
+                        }
+                    }
+                    if (!format) {
+                        const formatData = {
+                            name: el.colName,
+                            format: this.datePipeFormat,
+                            type: "date",
+                        };
+                        formatSettings.push(formatData);
+                    }
+                    else {
+                        const formatData = {
+                            name: el.colName,
+                            format: format,
+                            type: "date",
+                        };
+                        formatSettings.push(formatData);
+                    }
+                }
+            });
+        }
+        //calculatedFieldSettings format push to formatSettings
+        if (this.config.calculatedFieldSettings &&
+            this.config.calculatedFieldSettings.length > 0) {
+            this.config.calculatedFieldSettings.map((el) => {
+                if (el.formatString !== "") {
+                    formatSettings.push({
+                        name: el.name,
+                        format: el.formatString,
+                    });
+                }
+            });
+        }
+        let series = this.config.yaxis.series;
+        if (series) {
+            for (let item of series) {
+                const value = {
+                    name: item.colName,
+                    caption: item.title,
+                    type: item.calMethod,
+                };
+                values.push(value);
+            }
+        }
+        let groups = this.config.xaxis.groups;
+        if (groups) {
+            for (let gitem of groups) {
+                const field = this.configFields.filter((el) => el.colName === gitem.name);
+                if (field.length > 0) {
+                    gitem.showSubTotals = field[0].showSubTotals;
+                }
+                rows.push(gitem);
+            }
+        }
+        if (this.config.columnGroup && this.config.columnGroup.length) {
+            for (let item of this.config.columnGroup) {
+                const field = this.configFields.filter((el) => el.colName === item.name);
+                if (field.length > 0) {
+                    item.showSubTotals = field[0].showSubTotals;
+                }
+                columns.push(item);
+            }
+        }
+        let conditionalFormatSettings = [];
+        this.configFields.forEach((field) => {
+            if (field.format && field.format.length) {
+                if (field.format[0].fontSettingChecked) {
+                    let conditionalFormatObj = {
+                        applyGrandTotals: true,
+                        measure: "",
+                        value1: null,
+                        value2: null,
+                        conditions: "",
+                        style: {
+                            backgroundColor: "",
+                            color: "",
+                            fontFamily: "",
+                            fontSize: "",
+                        },
+                    };
+                    let negaConditionalFormatObj = {
+                        applyGrandTotals: true,
+                        measure: "",
+                        value1: null,
+                        value2: null,
+                        conditions: "",
+                        style: {
+                            backgroundColor: "",
+                            color: "",
+                            fontFamily: "",
+                            fontSize: "",
+                        },
+                    };
+                    // font setting start
+                    negaConditionalFormatObj.measure =
+                        field.format[0].selectedField;
+                    conditionalFormatObj.measure =
+                        field.format[0].selectedField;
+                    if (field.format[0].formatChecked &&
+                        field.format[0].compareSelect) {
+                        this.setCompareConditional(negaConditionalFormatObj, conditionalFormatObj, field.format[0]);
+                    }
+                    else {
+                        delete conditionalFormatObj.value2;
+                        delete negaConditionalFormatObj.value2;
+                        negaConditionalFormatObj.value1 = 0;
+                        negaConditionalFormatObj.conditions = "LessThan";
+                        conditionalFormatObj.value1 = 0;
+                        conditionalFormatObj.conditions = "GreaterThan";
+                        this.setFontSettingConditional(negaConditionalFormatObj, field.format[0], -1);
+                        this.setFontSettingConditional(conditionalFormatObj, field.format[0], 1);
+                    }
+                    conditionalFormatSettings.push(negaConditionalFormatObj);
+                    conditionalFormatSettings.unshift(conditionalFormatObj);
+                    // font setting end
+                }
+                let formatSettingsObj = {
+                    name: "",
+                    format: "",
+                };
+                if (field.format[0].formatChecked) {
+                    formatSettingsObj.name = field.format[0].selectedField;
+                    formatSettingsObj.format =
+                        this.dashboardPorletsService.pivotTableformatNumber(field.format[0].selectedFormat);
+                    switch (field.format[0].dataType) {
+                        case "number":
+                            formatSettingsObj.format =
+                                this.dashboardPorletsService.pivotTableformatNumber(field.format[0].selectedFormat);
+                            break;
+                        case "integer":
+                            formatSettingsObj.format =
+                                this.dashboardPorletsService.pivotTableformatInteger(field.format[0].selectedFormat);
+                            break;
+                        case "percentNum":
+                        case "percent":
+                            formatSettingsObj.format =
+                                this.dashboardPorletsService.pivotTableformatPercent(field.format[0].selectedFormat);
+                            break;
+                        case "multiple":
+                            formatSettingsObj.format =
+                                this.dashboardPorletsService.pivotTableformatMultiple(field.format[0].selectedFormat);
+                            break;
+                        case "date":
+                        case "datetime":
+                            let format = "";
+                            if (field.format && field.format.length) {
+                                if (field.format[0].dateType == "Quarter") {
+                                    format =
+                                        field.format[0].selectedFormatDisplay;
+                                }
+                                else if (field.format[0].dateType == "Date") {
+                                    let fromIdx = field.format[0].selectedFormatDisplay.indexOf("(");
+                                    let toIdx = field.format[0].selectedFormatDisplay.indexOf(")");
+                                    format =
+                                        field.format[0].selectedFormatDisplay.slice(fromIdx + 1, toIdx);
+                                }
+                            }
+                            if (format) {
+                                formatSettingsObj = {
+                                    name: field.colName,
+                                    format: "",
+                                };
+                                // field.dataType = "string";
+                            }
+                            else {
+                                formatSettingsObj.format = this.datePipeFormat;
+                                formatSettingsObj["type"] = "date";
+                            }
+                            break;
+                        default:
+                            break;
+                    }
+                }
+                if (field.format[0].dataType !== "string" &&
+                    formatSettingsObj.format) {
+                    formatSettings.push(formatSettingsObj);
+                }
+            }
+        });
+        this.customCalculatedFields = this.config.customCalculatedFields
+            ? this.config.customCalculatedFields
+            : [];
+        // SMP2-4582 AGIC - Dashboard item sequence
+        let isExistSeq = false;
+        let sortSettings = this.config.sortSettings || [];
+        if (this.Pivot_Data &&
+            this.Pivot_Data[0] &&
+            this.Pivot_Data[0].Seq !== null) {
+            // 取消Name的默认排序，根据Seq来排序
+            sortSettings.push({ name: "Name", order: "None" });
+            isExistSeq = true;
+        }
+        let filterSettings = this.dashboardPorletsService.checkFilterSettings(this.config, this.configFields, this.Pivot_Data);
+        let nameFilter = filterSettings.find((x) => x.name === "Name");
+        // 存在 Name的filter时，会按照默认排序，需要对Name进行Seq排序处理
+        if (isExistSeq && nameFilter && rows.some((x) => x.name === "Name")) {
+            let items = nameFilter.items; // 拿到当前排序，默认A-Z
+            let seqArr = [];
+            items.forEach((name) => {
+                let obj = this.Pivot_Data.find((x) => x.Name === name);
+                let item = {
+                    name: name,
+                    seq: obj.Seq,
+                };
+                seqArr.push(item);
+            });
+            seqArr.sort((a, b) => a.seq - b.seq);
+            nameFilter.items = seqArr.map((x) => x.name);
+        }
+        let hasItemDataType = false;
+        if (this.Pivot_Data) {
+            this.Pivot_Data.map((data) => {
+                if (data["AccountTypeCode"]) {
+                    hasItemDataType = true;
+                }
+                rows.forEach((row) => {
+                    if (data[row.name] === "") {
+                        data[row.name] = "null";
+                    }
+                });
+            });
+        }
+        if (hasItemDataType) {
+            sortSettings.push({
+                name: "AccountTypeCode",
+                order: "Ascending",
+                membersOrder: [...this.itemDataTypeSortArr],
+            });
+        }
+        this.dataSourceSettings = {
+            dataSource: this.Pivot_Data,
+            rows: rows,
+            columns: columns,
+            values: values,
+            filters: this.config.filters,
+            filterSettings: filterSettings,
+            excludeFields: this.excludeFields,
+            formatSettings: formatSettings,
+            conditionalFormatSettings: conditionalFormatSettings,
+            expandAll: true,
+            enableSorting: true,
+            fieldMapping: fieldMapping,
+            calculatedFieldSettings: this.config.calculatedFieldSettings,
+            sortSettings: sortSettings,
+            valueSortSettings: this.config.valueSortSettings,
+            showGrandTotals: this.config.showGrandTotals,
+            showRowGrandTotals: this.config.showRowGrandTotals,
+            showColumnGrandTotals: this.config.showColumnGrandTotals,
+            showSubTotals: this.config.showSubTotals,
+            showRowSubTotals: this.config.showRowSubTotals,
+            showColumnSubTotals: this.config.showColumnSubTotals,
+        };
+        if (this.pivotObj)
+            this.pivotObj.refreshData();
+        this.ref.markForCheck();
+    }
+    afterPopulate(args) {
+        this.tempSubtotals = [];
+        this.grandTotals = {};
+        this.subTotals = {};
+        let tempshowArray = [];
+        this.config.yaxis.series.forEach((item) => {
+            if (item.hasOwnProperty("showSubTotals") &&
+                item.hasOwnProperty("showGrandTotals")) {
+                tempshowArray.push({
+                    name: item.colName,
+                    calMethod: item.calMethod,
+                    showSubTotals: item.showSubTotals,
+                    showGrandTotals: item.showGrandTotals,
+                });
+            }
+            else {
+                if (item.hasOwnProperty("showGrandTotals")) {
+                    tempshowArray.push({
+                        name: item.colName,
+                        calMethod: item.calMethod,
+                        showGrandTotals: item.showGrandTotals,
+                    });
+                }
+                if (item.hasOwnProperty("showSubTotals")) {
+                    tempshowArray.push({
+                        name: item.colName,
+                        calMethod: item.calMethod,
+                        showSubTotals: item.showSubTotals,
+                    });
+                }
+            }
+        });
+        if (this.fieldlistObj && this.pivotObj) {
+            this.config.columnGroup = [];
+            this.config.xaxis.groups = [];
+            this.config.yaxis.series = [];
+            this.config.filters = [];
+            this.config.filterSettings = [];
+            this.config.calculatedFieldSettings = [];
+            let groupSettings = this.getDataSourceSettingsProp(this.fieldlistObj, "groupSettings");
+            let columns = this.getDataSourceSettingsProp(this.fieldlistObj, "columns");
+            let rows = this.getDataSourceSettingsProp(this.fieldlistObj, "rows");
+            let filters = this.getDataSourceSettingsProp(this.fieldlistObj, "filters");
+            let filterSettings = this.getDataSourceSettingsProp(this.fieldlistObj, "filterSettings");
+            let values = this.getDataSourceSettingsProp(this.fieldlistObj, "values");
+            let sortSettings = this.getDataSourceSettingsProp(this.fieldlistObj, "sortSettings");
+            let calculatedFieldSettings = this.getDataSourceSettingsProp(this.fieldlistObj, "calculatedFieldSettings");
+            if (groupSettings.length === 0) {
+                for (let column of columns) {
+                    this.config.columnGroup.push({
+                        name: column.name,
+                        caption: column.caption,
+                    });
+                }
+            }
+            else {
+                //If there is a group, first filter the columns of the group field, and then only save the last one
+                for (let column of columns) {
+                    if (!startsWith(column.name, groupSettings[0].name + "_")) {
+                        this.config.columnGroup.push({
+                            name: column.name,
+                            caption: column.name === groupSettings[0].name
+                                ? ""
+                                : column.caption,
+                        });
+                    }
+                }
+            }
+            for (let row of rows) {
+                this.config.xaxis.groups.push({
+                    name: row.name,
+                    caption: row.caption,
+                });
+            }
+            for (let filter of filters) {
+                this.config.filters.push({
+                    name: filter.name,
+                    caption: filter.caption,
+                });
+            }
+            if (this.filterSettings && this.filterSettings.length > 0) {
+                args.dataSourceSettings.filterSettings = this.filterSettings;
+                this.config.filterSettings = this.filterSettings;
+                delete this.filterSettings;
+            }
+            else {
+                this.config.filterSettings = filterSettings;
+            }
+            for (let value of values) {
+                let seriesData;
+                let tempShowObj;
+                let filterTempshowArray = [];
+                if (tempshowArray.length) {
+                    filterTempshowArray = tempshowArray.filter((item) => item.name === value.name &&
+                        item.calMethod === value.type);
+                    if (filterTempshowArray.length) {
+                        tempShowObj = filterTempshowArray[0];
+                        if (tempShowObj.hasOwnProperty("showSubTotals") &&
+                            tempShowObj.hasOwnProperty("showGrandTotals")) {
+                            seriesData = {
+                                colName: value.name,
+                                calMethod: value.type,
+                                title: value.caption,
+                                showSubTotals: tempShowObj.showSubTotals,
+                                showGrandTotals: tempShowObj.showGrandTotals,
+                            };
+                        }
+                        else {
+                            if (tempShowObj.hasOwnProperty("showGrandTotals")) {
+                                seriesData = {
+                                    colName: value.name,
+                                    calMethod: value.type,
+                                    title: value.caption,
+                                    showGrandTotals: tempShowObj.showGrandTotals,
+                                };
+                            }
+                            if (tempShowObj.hasOwnProperty("showSubTotals")) {
+                                seriesData = {
+                                    colName: value.name,
+                                    calMethod: value.type,
+                                    title: value.caption,
+                                    showSubTotals: tempShowObj.showSubTotals,
+                                };
+                            }
+                        }
+                    }
+                }
+                if (!seriesData) {
+                    seriesData = {
+                        colName: value.name,
+                        title: value.caption,
+                        calMethod: value.type,
+                    };
+                }
+                this.config.yaxis.series.push(seriesData);
+            }
+            for (let calculate of calculatedFieldSettings) {
+                const calculateData = {
+                    name: calculate.name,
+                    formula: calculate.formula,
+                    formatString: calculate.formatString === ""
+                        ? "N2"
+                        : calculate.formatString,
+                };
+                this.config.calculatedFieldSettings.push(calculateData);
+            }
+            this.config.customCalculatedFields = this.customCalculatedFields;
+            this.config.sortSettings = sortSettings;
+            this.config.groupSettings = groupSettings;
+            this.fieldlistObj.updateView(this.pivotObj);
+        }
+        this.portlet.config = JSON.stringify(this.config);
+        //remove the sort
+        if (this.pivotObj.dataSourceSettings.sortSettings.length > 0) {
+            this.previousSort = this.fieldlistObj.lastSortInfo;
+            this.fieldlistObj.lastSortInfo = [];
+        }
+    }
+    afterEnginePopulate(args) {
+        if (!Browser.isDevice && this.fieldlistObj && this.pivotObj) {
+            this.config.groupSettings = this.getDataSourceSettingsProp(this.pivotObj, "groupSettings");
+            // this.portlet.config = JSON.stringify(this.config);
+            if (this.fieldlistObj)
+                this.fieldlistObj.update(this.pivotObj);
+        }
+        if (this.Pivot_Data && this.Pivot_Data.length) {
+            setTimeout(() => {
+                this.enginePopulated(args);
+            }, 1500);
+        }
+    }
+    getDataSourceSettingsProp(obj, key) {
+        let prop = null;
+        if (obj && obj.dataSourceSettings) {
+            prop = obj.dataSourceSettings[key];
+            if (Object.prototype.toString.call(prop) === "[object Array]" &&
+                prop.length > 0) {
+                prop = prop.map((item) => item.properties || item);
+            }
+        }
+        return prop;
+    }
+    enginePopulating(args) {
+        this.grandTotals = {};
+        this.subTotals = {};
+        this.allDataValue = [];
+        if (args.dataSourceSettings.sortSettings.length) {
+            for (let i = 0; i < args.dataSourceSettings.sortSettings.length; i++) {
+                if (this.fieldlistObj.lastSortInfo &&
+                    this.fieldlistObj.lastSortInfo.name ===
+                        args.dataSourceSettings.sortSettings[i].name &&
+                    this.fieldlistObj.lastSortInfo.order === "Ascending" &&
+                    !(this.fieldlistObj.lastSortInfo.name ===
+                        this.previousSort.name &&
+                        this.previousSort.order === "None")) {
+                    args.dataSourceSettings.sortSettings[i].order = "None";
+                }
+                else if (this.previousSort &&
+                    this.fieldlistObj.lastSortInfo &&
+                    this.fieldlistObj.lastSortInfo.name ===
+                        this.previousSort.name &&
+                    this.previousSort.order === "Ascending") {
+                    args.dataSourceSettings.sortSettings[i].order = "Ascending";
+                }
+            }
+        }
+    }
+    cellClick(args) {
+        // 清除排序
+        if (this.pivotObj.dataSourceSettings.valueSortSettings.sortOrder &&
+            this.pivotObj.dataSourceSettings.valueSortSettings.headerText &&
+            this.pivotObj.dataSourceSettings.valueSortSettings.sortOrder ===
+                "Descending" &&
+            args.data.valueSort &&
+            this.pivotObj.dataSourceSettings.valueSortSettings.headerText ===
+                args.data.valueSort.levelName) {
+            this.pivotObj.setProperties({
+                dataSourceSettings: {
+                    valueSortSettings: {
+                        sortOrder: "Descending",
+                        headerText: "",
+                    },
+                },
+            }, true);
+            if (this.pivotObj)
+                this.pivotObj.refreshData();
+            this.config.valueSortSettings = {};
+            this.portlet.config = JSON.stringify(this.config);
+        }
+    }
+    dataBound(e) {
+        if (this.isInit) {
+            this.isInit = false;
+        }
+        this.grandTotals = {};
+        this.subTotals = {};
+        if (this.pivotObj.grid) {
+            this.pivotObj.grid.resizeStop = this.resizeStop.bind(this);
+        }
+        if (this.fieldlistObj &&
+            this.fieldlistObj.pivotButtonModule &&
+            this.fieldlistObj.pivotButtonModule.menuOption) {
+            this.fieldlistObj.pivotButtonModule.menuOption.stringAggregateTypes = [
+                "Count",
+                "DistinctCount",
+                "First",
+                "Last",
+            ];
+        }
+        if (this.pivotObj.pivotButtonModule &&
+            this.pivotObj.pivotButtonModule.menuOption) {
+            this.pivotObj.pivotButtonModule.menuOption.stringAggregateTypes = [
+                "Count",
+                "DistinctCount",
+                "First",
+                "Last",
+            ];
+        }
+        let allSummaryType = ALL_AGGREGATE_TYPES;
+        this.pivotObj.getAllSummaryType = () => allSummaryType;
+        if (this.fieldlistObj) {
+            this.fieldlistObj.aggregateTypes = allSummaryType;
+            this.fieldlistObj.getAllSummaryType = () => allSummaryType;
+        }
+    }
+    calculatedCellSets(args, curFields) {
+        let matchFields = curFields["matchFields"];
+        let formula = curFields["formula"];
+        let value = 0;
+        let rows = this.pivotObj.dataSourceSettings.rows;
+        let invalidTypes = ["string", "nvarchar", "date", "datetime"];
+        let isInvalid = matchFields.some((f) => invalidTypes.includes(this.configFields.filter((el) => el.colName === f.matchWord)[0]["dataType"]));
+        let currentrowCellType = args.rowCellType;
+        if (isInvalid)
+            return "-";
+        if (args.rowCellType === "subTotal" ||
+            args.rowCellType === "grandTotal") {
+            let childHeaders = [];
+            let sum = 0;
+            let cloneCellSets = cloneDeep(args.cellSets);
+            let groupNameArrays = [];
+            for (let index = args.row.level; index < rows.length; index++) {
+                groupNameArrays.push(rows[index].name);
+            }
+            for (let i = 0; i < cloneCellSets.length; i++) {
+                let values = [];
+                let header = groupNameArrays
+                    .map((name) => {
+                    values.push(cloneCellSets[i][name]);
+                    return cloneCellSets[i][name];
+                })
+                    .join("-");
+                if (!childHeaders.includes(header)) {
+                    childHeaders.push(header);
+                    let filterObj = {};
+                    groupNameArrays.map((name, i) => (filterObj[name] = values[i]));
+                    args.cellSets = _filter(cloneCellSets, filterObj);
+                    args.rowCellType = "value";
+                    sum += this.calculatedValues(args, matchFields, formula);
+                }
+            }
+            args.rowCellType = currentrowCellType;
+            // 暂存当前SubTotal， 用于收缩时读取
+            let prefixHeader = this.getCalcHeader(args, formula);
+            this.updateTempSubtotals(prefixHeader, sum);
+            return sum;
+        }
+        else if (args.rowCellType === "value") {
+            if (args.row.hasChild) {
+                // collapse 读取SubTotal
+                let header = this.getCalcHeader(args, formula);
+                let index = this.tempSubtotals.findIndex((item) => item.rowName === header);
+                if (index > -1) {
+                    value = this.tempSubtotals[index].rowValue;
+                }
+            }
+            else {
+                // expand
+                value = this.calculatedValues(args, matchFields, formula);
+            }
+        }
+        return value;
+    }
+    actionFailure(args) {
+        if (args.actionName == "Drill down" || args.actionName == "Drill up") {
+            // Triggers when the current UI action fails to achieve the desired result.
+        }
+    }
+    getCalcHeader(args, formula) {
+        let header = "";
+        let rows = this.pivotObj.dataSourceSettings.rows;
+        let groupNameArrays = [];
+        for (let index = 0; index < args.row.level; index++) {
+            groupNameArrays.push(rows[index].name);
+        }
+        header = groupNameArrays.length
+            ? groupNameArrays
+                .map((name) => {
+                return args.cellSets[0][name];
+            })
+                .join("-") +
+                "-" +
+                args.row.actualText
+            : args.row.actualText;
+        if (formula)
+            header += "___" + formula;
+        return header;
+    }
+    updateTempSubtotals(rowName, rowValue) {
+        let index = this.tempSubtotals.findIndex((item) => item.rowName === rowName);
+        let temp = {};
+        temp.rowName = rowName;
+        temp.rowValue = rowValue;
+        if (index > -1) {
+            this.tempSubtotals.splice(index, 1, temp);
+        }
+        else {
+            this.tempSubtotals.push(temp);
+        }
+    }
+    calculatedValues(args, matchFields, formula) {
+        if (matchFields.length) {
+            let calculedMatchFields = matchFields.map((f) => {
+                switch (f.matchMethod) {
+                    case "First":
+                    case "Last":
+                        f.replaceValue = this.calculatedFistLast(args, f.matchMethod, f.matchWord);
+                        break;
+                    case "Max":
+                        f.replaceValue = maxBy(args.cellSets, (o) => Number(o[f.matchWord]))[f.matchWord];
+                        break;
+                    case "Min":
+                        f.replaceValue = minBy(args.cellSets, (o) => Number(o[f.matchWord]))[f.matchWord];
+                        break;
+                    case "Sum":
+                        f.replaceValue = sumBy(args.cellSets, (o) => Number(o[f.matchWord]));
+                        // SMP2-4094 Unicorn - L3 Adjusted NAV value issues
+                        f.replaceValue =
+                            f.replaceValue && f.replaceValue.toFixed(10);
+                        break;
+                    case "Avg":
+                        f.replaceValue = meanBy(args.cellSets, (o) => Number(o[f.matchWord]));
+                        break;
+                    default:
+                        break;
+                }
+                return f;
+            });
+            let resultFormula = formula;
+            if (calculedMatchFields.length) {
+                for (let i = 0; i < calculedMatchFields.length; i++) {
+                    resultFormula = resultFormula.replace(calculedMatchFields[i].matchStr, "(" + calculedMatchFields[i].replaceValue + ")");
+                }
+            }
+            try {
+                let result = new Function("return " + resultFormula.replace(/[^-<>?:()\d/*+.]/g, ""))();
+                if (isNaN(result) || !isFinite(result)) {
+                    return 0;
+                }
+                else {
+                    return result;
+                }
+            }
+            catch (error) {
+                return NaN;
+            }
+        }
+        return 0;
+    }
+    getIrrHeader(level, ele, type) {
+        if (type === "row") {
+            let curRows = this.getDataSourceSettingsProp(this.fieldlistObj, "rows");
+            let rowsArr = curRows.map((item) => item.name);
+            let headerArr = [];
+            let rowLevel = level;
+            for (let index = 0; index <= rowLevel; index++) {
+                headerArr.push(ele.Row[rowsArr[index]]);
+            }
+            return headerArr.join(".");
+        }
+        else if (type === "col") {
+            let curCloumns = this.getDataSourceSettingsProp(this.fieldlistObj, "columns");
+            let colsArr = curCloumns.map((item) => item.name);
+            let headerArr = [];
+            let colLevel = level;
+            for (let index = 0; index <= colLevel; index++) {
+                headerArr.push(ele.Col[colsArr[index]]);
+            }
+            return headerArr.join(".");
+        }
+    }
+    totalFormatted = {};
+    aggregateCellInfo(args) {
+        let asOfDate = this.pbf.time(this.dashboard.asOfDate);
+        // if calculated field
+        if (args.aggregateType == "CalculatedField") {
+            for (let i = 0; i < this.customCalculatedFields.length; i++) {
+                if (args.fieldName == this.customCalculatedFields[i].name) {
+                    args.value = this.calculatedCellSets(args, this.customCalculatedFields[i]);
+                }
+            }
+        }
+        if ([
+            "CalculateIRR",
+            "CalculateIRRBeforeCarried",
+            "CalculateIRRIRRDate",
+            "CalculateIRRMTD",
+            "CalculateIRRQTD",
+            "CalculateIRRYTD",
+        ].includes(args.aggregateType)) {
+            let valueField;
+            let dateField;
+            let startDate;
+            let endDate;
+            switch (args.aggregateType) {
+                case "CalculateIRR":
+                    valueField = "IRRAdjValue";
+                    dateField = "IRRDate";
+                    break;
+                case "CalculateIRRMTD":
+                    startDate = moment(asOfDate)
+                        .startOf("month")
+                        .format("YYYY-MM-DD");
+                    endDate = moment(asOfDate).format("YYYY-MM-DD");
+                    valueField = "IRRAdjValue";
+                    dateField = "IRRDate";
+                    break;
+                case "CalculateIRRQTD":
+                    startDate = moment(asOfDate)
+                        .startOf("quarter")
+                        .format("YYYY-MM-DD");
+                    endDate = moment(asOfDate).format("YYYY-MM-DD");
+                    valueField = "IRRAdjValue";
+                    dateField = "IRRDate";
+                    break;
+                case "CalculateIRRYTD":
+                    startDate = moment(asOfDate)
+                        .startOf("year")
+                        .format("YYYY-MM-DD");
+                    endDate = moment(asOfDate).format("YYYY-MM-DD");
+                    valueField = "IRRAdjValue";
+                    dateField = "IRRDate";
+                    break;
+                case "CalculateIRRIRRDate":
+                    valueField = "IRRAdjValue";
+                    dateField = "CalculateIRRDate";
+                    break;
+                case "CalculateIRRBeforeCarried":
+                    valueField = "IRRAdjValueBeforeCarry";
+                    dateField = "IRRDate";
+                    break;
+                default:
+                    break;
+            }
+            let NAVAdj = 0;
+            let values = [];
+            let beforeStartNAVAdj = 0; // 存储上一个阶段的NAVAdj总和
+            let beforeStartValues = []; // 存储上一个阶段的累计集合 (只是为了打印，没有实际用途)
+            let field = this.configFields.filter((el) => el.colName ===
+                this.dashboardPorletsService.getAggregateType(args.aggregateType));
+            for (let i = 0; i < args.cellSets.length; i++) {
+                const data = {
+                    amount: args.cellSets[i]["IRRAmount"],
+                    date: this.pbf.time(args.cellSets[i][dateField]) ===
+                        "Invalid date"
+                        ? asOfDate
+                        : this.pbf.time(args.cellSets[i][dateField]),
+                };
+                // SMP2-16920
+                // If IRR Date > Dashboard report date = Takes as of dashboard report date
+                if (args.aggregateType === "CalculateIRRIRRDate" &&
+                    asOfDate < this.pbf.time(args.cellSets[i][dateField])) {
+                    data.date = asOfDate;
+                }
+                NAVAdj += args.cellSets[i][valueField];
+                // SMP2-17219 MTD QTD YTD IRR
+                if (startDate && endDate) {
+                    if (moment(data.date).isBefore(startDate)) {
+                        data[valueField] = args.cellSets[i][valueField];
+                        beforeStartValues.push(data);
+                        beforeStartNAVAdj += data[valueField];
+                    }
+                    if (!moment(data.date).isBetween(startDate, endDate, null, "[]")) {
+                        continue;
+                    }
+                }
+                if (data.amount != 0) {
+                    values.push(data);
+                }
+            }
+            if (NAVAdj > 0.0001 || NAVAdj < -0.0001) {
+                values.push({
+                    amount: NAVAdj,
+                    date: asOfDate,
+                });
+            }
+            values = sortBy(values, "date");
+            // 如果是MTD,QTD,YTD 则需要把当前阶段以前的所有数据进行汇总，加入计算
+            if (startDate && endDate) {
+                values.unshift({
+                    amount: -beforeStartNAVAdj,
+                    date: this.pbf.time(startDate),
+                });
+            }
+            // console.log("beforeStartValues:", beforeStartValues);
+            // console.log("values:", values);
+            if (values.length > 0) {
+                let guess = 0.1;
+                const sumAmount = values
+                    .map((item) => item.amount)
+                    .reduce((prev, curr) => prev + curr, 0);
+                if (sumAmount < 0) {
+                    guess = -0.1;
+                }
+                //SMP2-2249 fixed the big irr issue
+                if (sumAmount === 0) {
+                    args.value = 0;
+                }
+                else {
+                    const valueItems = values.slice(0, values.length - 1);
+                    const valueList = valueItems.map((item) => item.amount);
+                    const dateList = valueItems.map((item) => item.date);
+                    const lastItem = values[values.length - 1];
+                    const navAdjust = lastItem.amount;
+                    const latestDate = lastItem.date;
+                    let irr = this.dashboardPorletsService.ExcelFormulas._CalculateXirr(valueList, dateList, navAdjust, latestDate);
+                    args.value = irr === null ? "" : irr;
+                }
+            }
+            else {
+                args.value = "";
+            }
+            if (this.pivotObj.engineModule &&
+                this.pivotObj.engineModule.formatFields[args.fieldName]) {
+                delete this.pivotObj.engineModule.formatFields[args.fieldName];
+                this.pivotObj.engineModule.formatFields[args.fieldName] = {
+                    name: args.fieldName,
+                    format: field.length > 0
+                        ? field[0].format &&
+                            field[0].format.length &&
+                            field[0].format[0].formatChecked
+                            ? this.dashboardPorletsService.pivotTableformatPercent(field[0].format[0].selectedFormat)
+                            : this.dashboardPorletsService.formatPercent(field[0].dp)
+                        : "P2",
+                };
+            }
+        }
+        //  SMP2-16520 TWR 月/季/年 && SMP2-16683 VAR
+        if ([
+            "CalculateTWRMTD",
+            "CalculateTWRQTD",
+            "CalculateTWRYTD",
+            "CalculateVARMTD_99",
+            "CalculateVARQTD_99",
+            "CalculateVARYTD_99",
+            "CalculateVARMTD_95",
+            "CalculateVARQTD_95",
+            "CalculateVARYTD_95",
+        ].includes(args.aggregateType)) {
+            // console.log("==========================");
+            // console.log("args:", args);
+            let valueField = "IRRAdjValue";
+            let dateField = "IRRDate";
+            let timeRange;
+            switch (args.aggregateType) {
+                case "CalculateTWRMTD":
+                case "CalculateVARMTD_99":
+                case "CalculateVARMTD_95":
+                    timeRange = "month";
+                    break;
+                case "CalculateTWRQTD":
+                case "CalculateVARQTD_99":
+                case "CalculateVARQTD_95":
+                    timeRange = "quarter";
+                    break;
+                case "CalculateTWRYTD":
+                case "CalculateVARYTD_99":
+                case "CalculateVARYTD_95":
+                    timeRange = "year";
+                    break;
+                default:
+                    break;
+            }
+            let values = []; // 这个阶段的累计集合
+            let field = this.configFields.filter((el) => el.colName ===
+                this.dashboardPorletsService.getAggregateType(args.aggregateType));
+            for (let i = 0; i < args.cellSets.length; i++) {
+                const data = {
+                    [valueField]: args.cellSets[i][valueField],
+                    date: this.pbf.time(args.cellSets[i][dateField]) ===
+                        "Invalid date"
+                        ? asOfDate
+                        : this.pbf.time(args.cellSets[i][dateField]),
+                };
+                values.push(data);
+            }
+            // 如果asOfDate不是 本月/季度/年 的最后一天，都是截至 上个月/季度/年 的最后一天的数据去计算
+            let _asOfDate = moment(asOfDate);
+            // console.log("_asOfDate:", _asOfDate);
+            let isEndOfPeriod = (unit) => {
+                return (_asOfDate.format("YYYY-MM-DD") ===
+                    _asOfDate.endOf(unit).format("YYYY-MM-DD"));
+            };
+            let endDate = isEndOfPeriod(timeRange)
+                ? moment(asOfDate).format("YYYY-MM-DD")
+                : moment(asOfDate)
+                    .subtract(1, timeRange)
+                    .endOf(timeRange)
+                    .format("YYYY-MM-DD");
+            // console.log("endDate:", endDate);
+            values = values.filter((item) => moment(item.date).isSameOrBefore(endDate));
+            values = sortBy(values, "date");
+            // console.log("values:", values);
+            if (values.length > 0) {
+                let result = this.getTimeRanges(values, endDate, timeRange, "date"); // 各个阶段的数据
+                let resultTotal = {}; // 各个阶段总和
+                for (const prop in result) {
+                    resultTotal[prop] = result[prop].reduce((acc, cur) => {
+                        return acc + (cur[valueField] || 0);
+                    }, 0);
+                }
+                // console.log("result:", result);
+                // console.log("resultTotal:", resultTotal);
+                const cumulativeSum = {}; // 各个阶段累计和
+                let sum = 0;
+                for (const key of Object.keys(resultTotal)) {
+                    sum += resultTotal[key];
+                    cumulativeSum[`${key}`] = sum;
+                }
+                // console.log("cumulativeSum:", cumulativeSum);
+                const keys = Object.keys(cumulativeSum);
+                let twrList = [];
+                // 遍历每两个阶段 计算TWR
+                for (let i = 0; i < keys.length - 1; i++) {
+                    const key1 = keys[i];
+                    const key2 = keys[i + 1];
+                    // 计算两个阶段之间的递增量, 出数不能为0
+                    if (cumulativeSum[key1] != 0) {
+                        const increment = cumulativeSum[key2] - cumulativeSum[key1];
+                        let twr = increment / cumulativeSum[key1];
+                        twrList.push({
+                            date: key2,
+                            twr: twr,
+                        });
+                    }
+                }
+                // 计算Average TWR
+                // console.log("twrList:", twrList);
+                let averageTWR = this.calculateGrowthRate(twrList.map((x) => x.twr));
+                // console.log("计算Average TWR:", averageTWR);
+                if ([
+                    "CalculateTWRMTD",
+                    "CalculateTWRQTD",
+                    "CalculateTWRYTD",
+                ].includes(args.aggregateType)) {
+                    // SMP2-16520 TWR 月/季/年
+                    args.value =
+                        isNaN(averageTWR) || averageTWR == null
+                            ? ""
+                            : averageTWR.toFixed(4);
+                }
+                else {
+                    if (isNaN(averageTWR) || averageTWR == null) {
+                        args.value = "";
+                    }
+                    else {
+                        // SMP2-16683 VAR 区分99%和95%
+                        let ZScore = [
+                            "CalculateVARMTD_99",
+                            "CalculateVARQTD_99",
+                            "CalculateVARYTD_99",
+                        ].includes(args.aggregateType)
+                            ? 2.33
+                            : 1.65;
+                        if (twrList.length < 2) {
+                            args.value = "";
+                        }
+                        else {
+                            let SD = this.calculateStandardDeviation(twrList.map((x) => x.twr));
+                            // console.log("calculateStandardDeviation:", SD);
+                            let VAR = averageTWR - SD * ZScore;
+                            args.value = VAR.toFixed(4);
+                        }
+                    }
+                }
+                // console.log("args.value:", args.value);
+            }
+            if (this.pivotObj.engineModule &&
+                this.pivotObj.engineModule.formatFields[args.fieldName]) {
+                delete this.pivotObj.engineModule.formatFields[args.fieldName];
+                this.pivotObj.engineModule.formatFields[args.fieldName] = {
+                    name: args.fieldName,
+                    format: field.length > 0
+                        ? field[0].format &&
+                            field[0].format.length &&
+                            field[0].format[0].formatChecked
+                            ? this.dashboardPorletsService.pivotTableformatPercent(field[0].format[0].selectedFormat)
+                            : this.dashboardPorletsService.formatPercent(field[0].dp)
+                        : "P2",
+                };
+            }
+        }
+        //SMP2-2701
+        if (args.aggregateType === "CalculateIRRActualAudited") {
+            let NAVAdj = 0;
+            let values = [];
+            let field = this.configFields.filter((el) => el.colName ===
+                this.dashboardPorletsService.getAggregateType(args.aggregateType));
+            //SMP2-2713 only judge for this dataMart(GrossNet)
+            if (this.portlet.figureCode === "GrossNet" ||
+                this.portlet.figureCode ===
+                    "CombinedInvestmentFundNCompanyCashflow") {
+                for (let i = 0; i < args.cellSets.length; i++) {
+                    const data = {
+                        amount: args.cellSets[i]["IRRAmount"],
+                        date: this.pbf.time(args.cellSets[i]["IRRDate"]) ===
+                            "Invalid date"
+                            ? asOfDate
+                            : this.pbf.time(args.cellSets[i]["IRRDate"]),
+                    };
+                    NAVAdj += args.cellSets[i]["ActualAuditedNAV"];
+                    if (data.amount != 0) {
+                        values.push(data);
+                    }
+                }
+            }
+            //filter the data by the DataType(Actual Reported Audited)
+            else {
+                let argsdata = args.cellSets.filter((el) => el.DataType === "ACTUAL_AUDITED" ||
+                    el.DataType === "REPORTED");
+                for (let i = 0; i < argsdata.length; i++) {
+                    const data = {
+                        amount: argsdata[i]["IRRAmount"],
+                        date: this.pbf.time(argsdata[i]["IRRDate"]) ===
+                            "Invalid date"
+                            ? asOfDate
+                            : this.pbf.time(argsdata[i]["IRRDate"]),
+                    };
+                    NAVAdj += argsdata[i]["IRRAdjValue"];
+                    if (data.amount != 0) {
+                        values.push(data);
+                    }
+                }
+            }
+            if (NAVAdj > 0.0001 || NAVAdj < -0.0001) {
+                values.push({
+                    amount: NAVAdj,
+                    date: asOfDate,
+                });
+            }
+            values = sortBy(values, "date");
+            if (values.length > 0) {
+                let guess = 0.1;
+                const sumAmount = values
+                    .map((item) => item.amount)
+                    .reduce((prev, curr) => prev + curr, 0);
+                if (sumAmount < 0) {
+                    guess = -0.1;
+                }
+                //SMP2-2249 fixed the big irr issue
+                if (sumAmount === 0) {
+                    args.value = 0;
+                }
+                else {
+                    const valueItems = values.slice(0, values.length - 1);
+                    const valueList = valueItems.map((item) => item.amount);
+                    const dateList = valueItems.map((item) => item.date);
+                    const lastItem = values[values.length - 1];
+                    const navAdjust = lastItem.amount;
+                    const latestDate = lastItem.date;
+                    let irr = this.dashboardPorletsService.ExcelFormulas._CalculateXirr(valueList, dateList, navAdjust, latestDate);
+                    args.value = irr === null ? 0 : irr;
+                }
+            }
+            else {
+                args.value = 0;
+            }
+            if (this.pivotObj.engineModule &&
+                this.pivotObj.engineModule.formatFields[args.fieldName]) {
+                delete this.pivotObj.engineModule.formatFields[args.fieldName];
+                this.pivotObj.engineModule.formatFields[args.fieldName] = {
+                    name: args.fieldName,
+                    format: field.length > 0
+                        ? field[0].format &&
+                            field[0].format.length &&
+                            field[0].format[0].formatChecked
+                            ? this.dashboardPorletsService.pivotTableformatPercent(field[0].format[0].selectedFormat)
+                            : this.dashboardPorletsService.formatPercent(field[0].dp)
+                        : "P2",
+                };
+            }
+        }
+        //SMP2-3411
+        if (args.aggregateType === "CalculateIRRReported") {
+            let NAVAdj = 0;
+            let values = [];
+            let field = this.configFields.filter((el) => el.colName ===
+                this.dashboardPorletsService.getAggregateType(args.aggregateType));
+            if (this.portlet.figureCode === "GrossNet" ||
+                this.portlet.figureCode ===
+                    "CombinedInvestmentFundNCompanyCashflow") {
+                for (let i = 0; i < args.cellSets.length; i++) {
+                    const data = {
+                        amount: args.cellSets[i]["IRRAmount"],
+                        date: this.pbf.time(args.cellSets[i]["IRRDate"]) ===
+                            "Invalid date"
+                            ? asOfDate
+                            : this.pbf.time(args.cellSets[i]["IRRDate"]),
+                    };
+                    NAVAdj += args.cellSets[i]["ReportedNAV"];
+                    if (data.amount != 0) {
+                        values.push(data);
+                    }
+                }
+            }
+            else {
+                for (let i = 0; i < args.cellSets.length; i++) {
+                    const data = {
+                        amount: args.cellSets[i]["IRRAmount"],
+                        date: this.pbf.time(args.cellSets[i]["IRRDate"]) ===
+                            "Invalid date"
+                            ? asOfDate
+                            : this.pbf.time(args.cellSets[i]["IRRDate"]),
+                    };
+                    NAVAdj += args.cellSets[i]["IRRAdjValue"];
+                    if (data.amount != 0) {
+                        values.push(data);
+                    }
+                }
+            }
+            if (NAVAdj > 0.0001 || NAVAdj < -0.0001) {
+                values.push({
+                    amount: NAVAdj,
+                    date: asOfDate,
+                });
+            }
+            values = sortBy(values, "date");
+            if (values.length > 0) {
+                let guess = 0.1;
+                const sumAmount = values
+                    .map((item) => item.amount)
+                    .reduce((prev, curr) => prev + curr, 0);
+                if (sumAmount < 0) {
+                    guess = -0.1;
+                }
+                //SMP2-2249 fixed the big irr issue
+                if (sumAmount === 0) {
+                    args.value = 0;
+                }
+                else {
+                    const valueItems = values.slice(0, values.length - 1);
+                    const valueList = valueItems.map((item) => item.amount);
+                    const dateList = valueItems.map((item) => item.date);
+                    const lastItem = values[values.length - 1];
+                    const navAdjust = lastItem.amount;
+                    const latestDate = lastItem.date;
+                    let irr = this.dashboardPorletsService.ExcelFormulas._CalculateXirr(valueList, dateList, navAdjust, latestDate);
+                    args.value = irr === null ? 0 : irr;
+                }
+            }
+            else {
+                args.value = 0;
+            }
+            if (this.pivotObj.engineModule &&
+                this.pivotObj.engineModule.formatFields[args.fieldName]) {
+                delete this.pivotObj.engineModule.formatFields[args.fieldName];
+                this.pivotObj.engineModule.formatFields[args.fieldName] = {
+                    name: args.fieldName,
+                    format: field.length > 0
+                        ? field[0].format &&
+                            field[0].format.length &&
+                            field[0].format[0].formatChecked
+                            ? this.dashboardPorletsService.pivotTableformatPercent(field[0].format[0].selectedFormat)
+                            : this.dashboardPorletsService.formatPercent(field[0].dp)
+                        : "P2",
+                };
+            }
+        }
+        if (args.aggregateType === "CalculateMultiple" ||
+            args.aggregateType === "CalculatePIC" ||
+            args.aggregateType === "CalculateDPI" ||
+            args.aggregateType === "CalculateTVPI" ||
+            args.aggregateType === "CalculateRVPI" ||
+            args.aggregateType === "CalculateMActualAudited" ||
+            args.aggregateType === "CalculateMReported") {
+            let totalNumerator = 0;
+            let totalDenominator = 0;
+            let numeratorName;
+            let denominatorName;
+            let field = this.configFields.filter((el) => el.colName ===
+                this.dashboardPorletsService.getAggregateType(args.aggregateType));
+            if (field.length > 0) {
+                const formulaArray = field[0].formula.split("/");
+                numeratorName = formulaArray[0];
+                denominatorName = formulaArray[1];
+            }
+            for (let j = 0; j < args.cellSets.length; j++) {
+                totalNumerator += args.cellSets[j][numeratorName];
+                totalDenominator += args.cellSets[j][denominatorName];
+            }
+            if (totalDenominator !== 0) {
+                args.value = totalNumerator / totalDenominator;
+                if (this.pivotObj.engineModule &&
+                    this.pivotObj.engineModule.formatFields[args.fieldName]) {
+                    delete this.pivotObj.engineModule.formatFields[args.fieldName];
+                    this.pivotObj.engineModule.formatFields[args.fieldName] = {
+                        name: args.fieldName,
+                        format: field.length > 0
+                            ? field[0].format &&
+                                field[0].format.length &&
+                                field[0].format[0].formatChecked
+                                ? this.dashboardPorletsService.pivotTableformatMultiple(field[0].format[0].selectedFormat)
+                                : this.dashboardPorletsService.formatMultiple(field[0].dp)
+                            : "###0.00'x'",
+                    };
+                }
+            }
+            else {
+                args.value = "";
+            }
+        }
+        if (args.aggregateType === "First" || args.aggregateType === "Last") {
+            args.value = this.calculatedFistLast(args, args.aggregateType, args.fieldName);
+        }
+        if (args.aggregateType === "Count" ||
+            args.aggregateType === "DistinctCount") {
+            if (args.value) {
+                args.value = args.value.toFixed(2);
+            }
+        }
+        if (!args.value &&
+            args.value !== 0 &&
+            args.value !== false &&
+            args.value !== "false") {
+            args.skipFormatting = true;
+            args.value = "";
+        }
+        // 新建pivot table, 还没有设置row, 选了column之后grandtotal会有值
+        if (args.rowCellType === "grandTotal" &&
+            !this.pivotObj.dataSourceSettings.rows.length) {
+            args.value = "";
+        }
+        //SMP2-2889
+        if (args.rowCellType === "subTotal") {
+            const valueField_data = this.config.yaxis.series.filter((el) => el.colName === args.fieldName);
+            if (valueField_data.length > 0) {
+                if (valueField_data[0].showSubTotals === false) {
+                    args.value = "";
+                    args.skipFormatting = true;
+                }
+            }
+        }
+        if (args.rowCellType === "grandTotal") {
+            const valueField_data = this.config.yaxis.series.filter((el) => el.colName === args.fieldName);
+            if (valueField_data.length > 0) {
+                if (valueField_data[0].showGrandTotals === false) {
+                    args.value = "";
+                    args.skipFormatting = true;
+                }
+            }
+        }
+        // SMP2-3416 start
+        if (this.zeroFormatData.hgList.includes(args.fieldName) &&
+            args.value === 0) {
+            args.value = "-";
+            args.skipFormatting = true;
+        }
+        if (this.zeroFormatData.emptyList.includes(args.fieldName) &&
+            args.value === 0) {
+            args.value = "";
+            args.skipFormatting = true;
+        }
+        if (this.millionFields.includes(args.fieldName) &&
+            !isNaN(Number(args.value)) &&
+            args.value !== 0 &&
+            args.value !== "" &&
+            args.value !== null) {
+            if (args.columnCellType == "grandTotal" &&
+                args.rowCellType == "grandTotal") {
+                if (!this.totalFormatted[args.fieldName]) {
+                    this.totalFormatted[args.fieldName] = true;
+                    args.value = args.value / 1000000;
+                }
+            }
+            else {
+                args.value = args.value / 1000000;
+            }
+        }
+        // SMP2-2486 & percentNum的format问题
+        if (this.percentNumFields.length &&
+            this.percentNumFields.includes(args.fieldName) &&
+            !isNaN(Number(args.value)) &&
+            args.value !== 0 &&
+            args.value !== "" &&
+            args.value !== null) {
+            if (args.columnCellType == "grandTotal" &&
+                args.rowCellType == "grandTotal") {
+                if (!this.totalFormatted[args.fieldName]) {
+                    this.totalFormatted[args.fieldName] = true;
+                    args.value = args.value / 100;
+                }
+            }
+            else {
+                args.value = args.value / 100;
+            }
+        }
+        if (args.aggregateType == "CalculatedField" &&
+            !Number.isNaN(args.value)) {
+            args.value = Number(args.value).toFixed(2);
+        }
+        // SMP2-3416 end
+        this.ref.markForCheck();
+        this.ref.detectChanges();
+    }
+    calculatedFistLast(args, aggregateType, fieldName) {
+        if (!args.row.actualText)
+            args.row.actualText = args.row.formattedText;
+        if (!args.column.actualText)
+            args.column.actualText = args.column.formattedText;
+        let field = this.configFields.filter((el) => el.colName === fieldName)[0];
+        if (args.rowCellType === "value" && !args.row.hasChild) {
+            if (args.cellSets[0]) {
+                if (aggregateType === "First") {
+                    for (let firstIndex = 0; firstIndex < args.cellSets.length; firstIndex++) {
+                        if (this.pivotObj.dataSourceSettings.columns.length ==
+                            1 &&
+                            args.columnCellType == "grandTotal") {
+                            if (field.dataType == "string" ||
+                                field.dataType == "nvarchar" ||
+                                field.dataType == "date" ||
+                                field.dataType == "datetime") {
+                                args.value = "";
+                            }
+                            else {
+                                if (this.allDataValue &&
+                                    this.allDataValue.length) {
+                                    let rowObjs = this.allDataValue[args.row.rowIndex];
+                                    if (rowObjs) {
+                                        let rowObjsArr = JSON.parse(JSON.stringify(rowObjs));
+                                        let obj = rowObjsArr.filter((el) => el.actualText == fieldName &&
+                                            el.isGrandSum)[0];
+                                        if (obj)
+                                            args.value = obj.value;
+                                    }
+                                }
+                                else {
+                                    args.value = isNaN(Number(this.grandTotals["row" +
+                                        args.row.actualText +
+                                        fieldName]))
+                                        ? null
+                                        : Number(this.grandTotals["row" +
+                                            args.row.actualText +
+                                            fieldName]);
+                                }
+                            }
+                        }
+                        else {
+                            args.value = args.cellSets[firstIndex][fieldName];
+                        }
+                        if (field.dataType == "number" ||
+                            field.dataType == "multiple" ||
+                            field.dataType == "percent" ||
+                            field.dataType == "percentNum") {
+                            if (args.value != null)
+                                break;
+                        }
+                        else if (field.dataType == "date" ||
+                            field.dataType == "datetime") {
+                            if (this.pbf.time(args.value) > "1900-01-01")
+                                break;
+                        }
+                        else if (args.value)
+                            break;
+                    }
+                }
+                if (aggregateType === "Last") {
+                    for (let lastIndex = args.cellSets.length - 1; lastIndex >= 0; lastIndex--) {
+                        if (this.pivotObj.dataSourceSettings.columns.length ==
+                            1 &&
+                            args.columnCellType == "grandTotal") {
+                            if (field.dataType == "string" ||
+                                field.dataType == "nvarchar" ||
+                                field.dataType == "date" ||
+                                field.dataType == "datetime") {
+                                args.value = "";
+                            }
+                            else {
+                                if (this.allDataValue &&
+                                    this.allDataValue.length) {
+                                    let rowObjs = this.allDataValue[args.row.rowIndex];
+                                    if (rowObjs) {
+                                        let rowObjsArr = JSON.parse(JSON.stringify(rowObjs));
+                                        let obj = rowObjsArr.filter((el) => el.actualText == fieldName &&
+                                            el.isGrandSum)[0];
+                                        if (obj)
+                                            args.value = obj.value;
+                                    }
+                                }
+                                else {
+                                    args.value = isNaN(Number(this.grandTotals["row" +
+                                        args.row.actualText +
+                                        fieldName]))
+                                        ? null
+                                        : Number(this.grandTotals["row" +
+                                            args.row.actualText +
+                                            fieldName]);
+                                }
+                            }
+                        }
+                        else {
+                            args.value = args.cellSets[lastIndex][fieldName];
+                        }
+                        if (field.dataType == "number" ||
+                            field.dataType == "multiple" ||
+                            field.dataType == "percent" ||
+                            field.dataType == "percentNum") {
+                            if (args.value != null)
+                                break;
+                        }
+                        else if (field.dataType == "date" ||
+                            field.dataType == "datetime") {
+                            if (this.pbf.time(args.value) > "1900-01-01")
+                                break;
+                        }
+                        else if (args.value)
+                            break;
+                    }
+                }
+                if (field.dataType == "number" ||
+                    field.dataType == "multiple" ||
+                    field.dataType == "percent" ||
+                    field.dataType == "percentNum") {
+                    if (this.pivotObj.dataSourceSettings.rows.length) {
+                        if (!this.pivotObj.dataSourceSettings.columns.length) {
+                            if (!Number(this.grandTotals[fieldName]) ||
+                                isNaN(Number(this.grandTotals[fieldName]))) {
+                                this.grandTotals[fieldName] = 0;
+                            }
+                            if (args.aggregateType !== "CalculatedField") {
+                                this.grandTotals[fieldName] += Number(args.value);
+                            }
+                        }
+                        else if (this.pivotObj.dataSourceSettings.columns.length == 1) {
+                            // "row" + args.row.actualText + fieldName 表示(cell: args.rowCellType === "value" && args.columnCellType === "grandTotal")
+                            if (!Number(this.grandTotals["row" + args.row.actualText + fieldName]) ||
+                                isNaN(Number(this.grandTotals["row" +
+                                    args.row.actualText +
+                                    fieldName]))) {
+                                this.grandTotals["row" + args.row.actualText + fieldName] = 0;
+                            }
+                            this.grandTotals["row" + args.row.actualText + fieldName] += Number(args.value);
+                            // "col" + args.column.actualText + fieldName 表示(cell: args.rowCellType === "grandTotal" && args.columnCellType === "value")
+                            if (!Number(this.grandTotals["col" +
+                                args.column.actualText +
+                                fieldName]) ||
+                                isNaN(Number(this.grandTotals["col" +
+                                    args.column.actualText +
+                                    fieldName]))) {
+                                this.grandTotals["col" + args.column.actualText + fieldName] = 0;
+                            }
+                            this.grandTotals["col" + args.column.actualText + fieldName] += Number(args.value);
+                        }
+                    }
+                }
+            }
+        }
+        else if (args.rowCellType === "subTotal" || args.row.hasChild) {
+            const dataType = field.dataType;
+            if (dataType === "string" ||
+                dataType === "nvarchar" ||
+                dataType == "date" ||
+                dataType == "datetime") {
+                args.value = "";
+            }
+            else {
+                let value = 0;
+                let childHeaders = [];
+                if (aggregateType === "First") {
+                    let groupNameArrays = [];
+                    let rows = this.pivotObj.dataSourceSettings.rows;
+                    for (let index = args.row.level; index < rows.length; index++) {
+                        groupNameArrays.push(rows[index].name);
+                    }
+                    for (let i = 0; i < args.cellSets.length; i++) {
+                        let values = [];
+                        let header = groupNameArrays
+                            .map((name) => {
+                            values.push(args.cellSets[i][name]);
+                            return args.cellSets[i][name];
+                        })
+                            .join("-");
+                        if (!childHeaders.includes(header)) {
+                            let filterObj = {};
+                            groupNameArrays.map((name, x) => (filterObj[name] = values[x]));
+                            let _CellSets = _filter(args.cellSets, filterObj);
+                            childHeaders.push(header);
+                            value += Number(_CellSets[0][fieldName]) || 0;
+                        }
+                    }
+                }
+                if (aggregateType === "Last") {
+                    let groupNameArrays = [];
+                    let rows = this.pivotObj.dataSourceSettings.rows;
+                    for (let index = args.row.level; index < rows.length; index++) {
+                        groupNameArrays.push(rows[index].name);
+                    }
+                    for (let i = args.cellSets.length - 1; i >= 0; i--) {
+                        let values = [];
+                        let header = groupNameArrays
+                            .map((name) => {
+                            values.push(args.cellSets[i][name]);
+                            return args.cellSets[i][name];
+                        })
+                            .join("-");
+                        if (!childHeaders.includes(header)) {
+                            let filterObj = {};
+                            groupNameArrays.map((name, x) => (filterObj[name] = values[x]));
+                            let _CellSets = _filter(args.cellSets, filterObj);
+                            childHeaders.push(header);
+                            value +=
+                                Number(_CellSets[_CellSets.length - 1][fieldName]) || 0;
+                        }
+                    }
+                }
+                if (args.column.actualText !== "Grand Total")
+                    this.columnTexts.push(args.column.actualText);
+                if (!this.pivotObj.dataSourceSettings.columns.length) {
+                    if (!Number(this.subTotals[fieldName]) ||
+                        isNaN(Number(this.subTotals[fieldName]))) {
+                        this.subTotals[fieldName] = 0;
+                    }
+                    this.subTotals[fieldName] += Number(value);
+                }
+                else if (this.pivotObj.dataSourceSettings.columns.length == 1) {
+                    // "row" + args.row.actualText + fieldName 表示(cell: args.rowCellType === "value" && args.columnCellType === "grandTotal")
+                    if (!Number(this.subTotals[args.row.actualText +
+                        args.column.actualText +
+                        fieldName]) ||
+                        isNaN(Number(this.subTotals[args.row.actualText +
+                            args.column.actualText +
+                            fieldName]))) {
+                        this.subTotals[args.row.actualText +
+                            args.column.actualText +
+                            fieldName] = 0;
+                    }
+                    this.subTotals[args.row.actualText + args.column.actualText + fieldName] += Number(value);
+                }
+                // ---> allDataValue中这个单元格的值不正确
+                if (args.columnCellType === "grandTotal" &&
+                    this.pivotObj.dataSourceSettings.columns.length == 1) {
+                    if (this.allDataValue && this.allDataValue.length) {
+                        args.value =
+                            this.subTotals[args.row.actualText + "Grand Total" + fieldName];
+                    }
+                    else {
+                        // 把前边这个field的几列subtotal加起来
+                        this.columnTexts = uniqBy(this.columnTexts, (el) => el);
+                        let val = 0;
+                        for (let i = 0; i < this.columnTexts.length; i++) {
+                            const element = this.columnTexts[i];
+                            val +=
+                                this.subTotals[args.row.actualText + element + fieldName];
+                        }
+                        args.value = val;
+                    }
+                }
+                else {
+                    args.value = value;
+                }
+            }
+        }
+        else if (args.rowCellType === "grandTotal") {
+            const dataType = field.dataType;
+            if (dataType == "string" ||
+                dataType == "nvarchar" ||
+                dataType == "date" ||
+                dataType == "datetime") {
+                args.value = "";
+            }
+            else {
+                if (!this.pivotObj.dataSourceSettings.columns.length) {
+                    if (this.allDataValue && this.allDataValue.length) {
+                        let rowObjs = this.allDataValue[this.allDataValue.length - 1];
+                        if (rowObjs) {
+                            let rowObjsArr = JSON.parse(JSON.stringify(rowObjs));
+                            let objArr = rowObjsArr.filter((el) => el.actualText == fieldName && el.isGrandSum);
+                            if (objArr && objArr.length) {
+                                args.value = objArr[objArr.length - 1].value;
+                            }
+                            else if (Object.keys(this.grandTotals).includes(fieldName)) {
+                                args.value = this.grandTotals[fieldName];
+                            }
+                        }
+                    }
+                    else {
+                        args.value = this.grandTotals[fieldName];
+                    }
+                }
+                else {
+                    if (args.columnCellType === "grandTotal") {
+                        if (this.allDataValue && this.allDataValue.length) {
+                            let rowObjs = this.allDataValue[this.allDataValue.length - 1];
+                            if (rowObjs) {
+                                let rowObjsArr = JSON.parse(JSON.stringify(rowObjs));
+                                let objArr = rowObjsArr.filter((el) => el.actualText == fieldName &&
+                                    el.isGrandSum);
+                                if (objArr && objArr.length) {
+                                    args.value =
+                                        objArr[objArr.length - 1].value;
+                                }
+                                else if (Object.keys(this.grandTotals).includes("col" +
+                                    args.column.actualText +
+                                    fieldName)) {
+                                    args.value =
+                                        this.grandTotals["col" +
+                                            args.column.actualText +
+                                            fieldName];
+                                }
+                            }
+                        }
+                        else {
+                            args.value =
+                                this.grandTotals["col" + args.column.actualText + fieldName];
+                        }
+                    }
+                    else {
+                        // if (
+                        // 	this.pivotObj.dataSourceSettings.columns.length == 1
+                        // ) {
+                        // 	args.value = this.grandTotals[
+                        // 		"col" + args.column.actualText + fieldName
+                        // 	];
+                        // }
+                        if (this.allDataValue && this.allDataValue.length) {
+                            let rowObjs = this.allDataValue[this.allDataValue.length - 1];
+                            let rowObjsArr = JSON.parse(JSON.stringify(rowObjs));
+                            let objArr = rowObjsArr.filter((el) => el.actualText == fieldName &&
+                                el.isGrandSum &&
+                                el.columnHeaders == args.column.actualText);
+                            if (objArr && objArr.length) {
+                                args.value = objArr[objArr.length - 1].value;
+                            }
+                            else if (Object.keys(this.grandTotals).includes("col" + args.column.actualText + fieldName)) {
+                                args.value =
+                                    this.grandTotals["col" +
+                                        args.column.actualText +
+                                        fieldName];
+                            }
+                        }
+                        else {
+                            args.value =
+                                this.grandTotals["col" + args.column.actualText + fieldName];
+                        }
+                    }
+                }
+            }
+        }
+        this.formatVal(args, fieldName);
+        return args.value;
+    }
+    formatVal(args, fieldName) {
+        this.configFields.forEach((field) => {
+            if (field.colName == fieldName) {
+                switch (field.dataType) {
+                    case "date":
+                    case "datetime":
+                        if (args.value)
+                            args.value = new Date(args.value);
+                        break;
+                    default:
+                        break;
+                }
+            }
+        });
+    }
+    getexcludeFields(fields, data) {
+        let namearray = [];
+        let array = [];
+        for (let prop in data) {
+            array.push(prop);
+        }
+        for (let item of fields) {
+            namearray.push(item.colName);
+        }
+        this.excludeFields = differenceWith(array, namearray);
+        if (this.excludeFields.length &&
+            this.config.groupSettings &&
+            this.config.groupSettings.length) {
+            for (let i = 0; i < this.excludeFields.length; i++) {
+                const el = this.excludeFields[i];
+                if (startsWith(el, this.config.groupSettings[0].name + "_")) {
+                    this.excludeFields.splice(i, 1);
+                    i--;
+                }
+            }
+        }
+    }
+    getInfo() {
+        this.datePipeFormat = localStorage.getItem("datePipe");
+        this.translation = JSON.parse(localStorage.getItem("translation"));
+        L10n.load({
+            "en-US": {
+                pivotview: AGGREGATE_TYPES_TEXT,
+                pivotfieldlist: AGGREGATE_TYPES_TEXT,
+            },
+            zh: {
+                pivotview: AGGREGATE_TYPES_TEXT,
+                pivotfieldlist: AGGREGATE_TYPES_TEXT,
+            },
+            "zh-Hant-HK": {
+                pivotview: AGGREGATE_TYPES_TEXT,
+                pivotfieldlist: AGGREGATE_TYPES_TEXT,
+            },
+            ja: {
+                pivotview: AGGREGATE_TYPES_TEXT,
+                pivotfieldlist: AGGREGATE_TYPES_TEXT,
+            },
+            ko: {
+                pivotview: AGGREGATE_TYPES_TEXT,
+                pivotfieldlist: AGGREGATE_TYPES_TEXT,
+            },
+            fr: {
+                pivotview: AGGREGATE_TYPES_TEXT,
+                pivotfieldlist: AGGREGATE_TYPES_TEXT,
+            },
+        });
+    }
+    onFieldDrop(args) {
+        //change the calcualteField method use the corresponding calculate
+        const calcualteField = this.configFields.filter((el) => el.colName === args.fieldName && el.isCalculatedField);
+        if (calcualteField.length > 0) {
+            args.dropField.type =
+                this.dashboardPorletsService.getCalculateMethod(calcualteField[0].colName);
+            args.dropField.caption = args.dropField.caption
+                .replace("Calculate", "")
+                .trim();
+        }
+        for (let i = 0; i < args.dataSourceSettings.filterSettings.length; i++) {
+            if (args.dataSourceSettings.filterSettings[i].name ===
+                args.fieldName &&
+                args.dropAxis === "") {
+                args.dataSourceSettings.filterSettings.splice(i, 1);
+                this.filterSettings = args.dataSourceSettings.filterSettings;
+                break;
+            }
+        }
+    }
+    createButtonText(field, i, axis, valuePos) {
+        let buttonText;
+        let aggregation;
+        let filterMem;
+        if (axis === "filters") {
+            filterMem = this.fieldlistObj.pivotButtonModule.updateButtontext(field[i].name);
+        }
+        let engineModule = this.pivotObj.engineModule;
+        if (engineModule.fieldList[field[i].name] !== undefined) {
+            aggregation = engineModule.fieldList[field[i].name].aggregateType;
+            aggregation =
+                aggregation === "Sum"
+                    ? engineModule.fieldList[field[i].name].type !== "number"
+                        ? "Count"
+                        : "Sum"
+                    : aggregation;
+        }
+        let text = field[i].caption ? field[i].caption : field[i].name;
+        buttonText = createElement("span", {
+            attrs: {
+                title: axis === "filters"
+                    ? text + " (" + filterMem + ")"
+                    : !this.pivotObj.dataSourceSettings
+                        .showAggregationOnValueField ||
+                        axis !== "values" ||
+                        aggregation === "CalculatedField"
+                        ? text
+                        : this.pivotObj.localeObj.getConstant(aggregation) +
+                            " " +
+                            this.pivotObj.localeObj.getConstant("of") +
+                            " " +
+                            text,
+                tabindex: "-1",
+                "aria-disabled": "false",
+                oncontextmenu: "return false;",
+                "data-type": valuePos === i ? "" : aggregation,
+            },
+            className: "e-content" +
+                " " +
+                (this.pivotObj.getModuleName() === "pivotview"
+                    ? this.pivotObj.groupingBarSettings.allowDragAndDrop &&
+                        field[i].allowDragAndDrop
+                        ? ""
+                        : "e-disable-drag"
+                    : ""),
+            innerHTML: axis === "filters"
+                ? text + " (" + filterMem + ")"
+                : !this.pivotObj.dataSourceSettings
+                    .showAggregationOnValueField ||
+                    axis !== "values" ||
+                    aggregation === "CalculatedField"
+                    ? text
+                    : this.pivotObj.localeObj.getConstant(aggregation) +
+                        " " +
+                        this.pivotObj.localeObj.getConstant("of") +
+                        " " +
+                        text,
+        });
+        return buttonText;
+    }
+    // Calculated field事件：创建
+    calculatedFieldCreate(args) {
+        if (args.calculatedField.name !== "" &&
+            args.calculatedField.name.trim() !== "") {
+            let index = this.fieldlistObj.dataSourceSettings.calculatedFieldSettings.findIndex((el) => el.name === args.calculatedField.name);
+            if (index !== -1) {
+                if (args.calculatedField.formatString === "") {
+                    this.fieldlistObj.dataSourceSettings.calculatedFieldSettings[index].formatString = "N2";
+                }
+                else {
+                    this.fieldlistObj.dataSourceSettings.calculatedFieldSettings[index].formatString = args.calculatedField.formatString;
+                }
+            }
+            else {
+                if (args.calculatedField.formatString === "") {
+                    args.calculatedField.formatString = "N2";
+                }
+            }
+            // 移除重复
+            let fIndex = this.customCalculatedFields.findIndex((f) => f.name === args.calculatedField.name);
+            if (fIndex > -1) {
+                this.customCalculatedFields.splice(fIndex, 1);
+            }
+            // 匹配运算符 First || Last
+            let formulaStr = args.calculatedField.formula;
+            let reg1 = /"First\((.+?)\)"/g;
+            let reg2 = /"Last\((.+?)\)"/g;
+            if (reg1.test(formulaStr) || reg2.test(formulaStr)) {
+                // 判断是否存在First || Last 表达式
+                let matchFirstFields = Array.from(formulaStr["matchAll"](/"First\((.+?)\)"/g), (m) => {
+                    return {
+                        matchStr: m[0],
+                        matchWord: m[1],
+                        replaceValue: "",
+                        matchMethod: "First",
+                    };
+                });
+                let matchLastFields = Array.from(formulaStr["matchAll"](/"Last\((.+?)\)"/g), (m) => {
+                    return {
+                        matchStr: m[0],
+                        matchWord: m[1],
+                        replaceValue: "",
+                        matchMethod: "Last",
+                    };
+                });
+                let matchMaxFields = Array.from(formulaStr["matchAll"](/"Max\((.+?)\)"/g), (m) => {
+                    return {
+                        matchStr: m[0],
+                        matchWord: m[1],
+                        replaceValue: "",
+                        matchMethod: "Max",
+                    };
+                });
+                let matchMinFields = Array.from(formulaStr["matchAll"](/"Min\((.+?)\)"/g), (m) => {
+                    return {
+                        matchStr: m[0],
+                        matchWord: m[1],
+                        replaceValue: "",
+                        matchMethod: "Min",
+                    };
+                });
+                let matchSumFields = Array.from(formulaStr["matchAll"](/"Sum\((.+?)\)"/g), (m) => {
+                    return {
+                        matchStr: m[0],
+                        matchWord: m[1],
+                        replaceValue: "",
+                        matchMethod: "Sum",
+                    };
+                });
+                let matchAvgFields = Array.from(formulaStr["matchAll"](/"Avg\((.+?)\)"/g), (m) => {
+                    return {
+                        matchStr: m[0],
+                        matchWord: m[1],
+                        replaceValue: "",
+                        matchMethod: "Avg",
+                    };
+                });
+                if (matchFirstFields.every((x) => this.allowedCalculatedFields.includes(x.matchWord)) &&
+                    matchLastFields.every((x) => this.allowedCalculatedFields.includes(x.matchWord))) {
+                    // 判断First和Last表达式内的字段是否合法
+                    this.customCalculatedFields.push({
+                        name: args.calculatedField.name,
+                        formula: args.calculatedField.formula,
+                        matchFields: [
+                            // @ts-ignore
+                            ...matchFirstFields,
+                            ...matchLastFields,
+                            ...matchMaxFields,
+                            ...matchMinFields,
+                            ...matchSumFields,
+                            ...matchAvgFields,
+                        ],
+                        grandTotal: 0,
+                    });
+                    let fieldName = (formulaStr.split("First(")[1] ||
+                        formulaStr.split("Last(")[1]).split(")")[0];
+                    args.calculatedField.formula =
+                        "'\"" + "Sum(" + fieldName + ')"=' + formulaStr + "'";
+                }
+            }
+        }
+    }
+    // Calculated field事件：完成
+    actionComplete(args) {
+        if (args.actionName == "Field removed") {
+            if (args.fieldInfo &&
+                args.fieldInfo.fieldItem &&
+                args.fieldInfo.fieldItem.type == "CalculatedField") {
+                let field = args.fieldInfo.fieldName;
+                // Remove the deleted calculated field from an stored array.
+                this.customCalculatedFields =
+                    this.customCalculatedFields.filter(function (obj) {
+                        return obj.name !== field;
+                    });
+            }
+        }
+    }
+    // Calculated field事件：开始
+    actionBegin(args) {
+        if (args.actionName === "Edit calculated field") {
+            for (let i = 0; i < this.customCalculatedFields.length; i++) {
+                if (this.customCalculatedFields[i].name &&
+                    this.pivotObj.engineModule.fieldList[this.customCalculatedFields[i].name]) {
+                    this.pivotObj.engineModule.fieldList[this.customCalculatedFields[i].name].formula = this.customCalculatedFields[i].formula;
+                }
+            }
+        }
+    }
+    resizeStop(args) {
+        if (this.config.columnsWidth) {
+            const header_field = this.config.columnsWidth.filter((el) => el.headerText === args.column.headerText);
+            if (header_field.length > 0) {
+                header_field[0].width = parseInt(args.column.width);
+            }
+            else {
+                this.config.columnsWidth.push({
+                    headerText: args.column.headerText,
+                    width: parseInt(args.column.width),
+                });
+            }
+        }
+        else {
+            this.config.columnsWidth = [];
+            this.config.columnsWidth.push({
+                headerText: args.column.headerText,
+                width: parseInt(args.column.width),
+            });
+        }
+        const portlet = this.portlet;
+        portlet.config = JSON.stringify(this.config);
+        const index = this.portlets.findIndex((x) => x.newId === portlet.newId);
+        if (index > -1)
+            this.portlets[index] = portlet;
+    }
+    onLoad() { }
+    enginePopulated(args) {
+        let clonedValues;
+        let currentPivotValues = this.getClonedPivotValues(this.pivotObj.engineModule.pivotValues);
+        let pageSettings = this.pivotObj.engineModule.pageSettings;
+        // this.pivotObj.engineModule.pageSettings = null;
+        if (this.pivotObj.engineModule.generateGridData) {
+            this.pivotObj.engineModule.generateGridData(this.pivotObj.dataSourceSettings, true);
+            clonedValues = this.getClonedPivotValues(this.pivotObj.engineModule.pivotValues);
+            this.pivotObj.engineModule.pivotValues = currentPivotValues;
+            this.pivotObj.engineModule.pageSettings = pageSettings;
+            // Here "clonedValues" contains the whole pivot values.
+            this.allDataValue = clonedValues;
+        }
+    }
+    getClonedPivotValues(pivotValues) {
+        let clonedSets = [];
+        if (pivotValues && pivotValues.length) {
+            for (let i = 0; i < pivotValues.length; i++) {
+                if (pivotValues[i]) {
+                    clonedSets[i] = [];
+                    for (let j = 0; j < pivotValues[i].length; j++) {
+                        if (pivotValues[i][j]) {
+                            /* eslint-disable */
+                            clonedSets[i][j] = this.getClonedPivotValueObj(pivotValues[i][j]);
+                            /* eslint-enable */
+                        }
+                    }
+                }
+            }
+        }
+        return clonedSets;
+    }
+    getClonedPivotValueObj(data) {
+        let keyPos = 0;
+        let framedSet = {};
+        if (!(data === null || data === undefined)) {
+            let fields = Object.keys(data);
+            while (keyPos < fields.length) {
+                framedSet[fields[keyPos]] = data[fields[keyPos]];
+                keyPos++;
+            }
+        }
+        else {
+            framedSet = data;
+        }
+        return framedSet;
+    }
+    //#region Filtering the TreeNodes
+    searchNodes(args) {
+        let _text = args.maskedValue;
+        let predicats = [], _array = [], _filter = [];
+        if (_text == "") {
+            this.changeDataSource(this.fieldlistObj.treeViewModule.getTreeData());
+        }
+        else {
+            let predicate = new Predicate("caption", "contains", _text, true);
+            let filteredList = new DataManager(this.fieldlistObj.treeViewModule.getTreeData()).executeLocal(new Query().where(predicate));
+            for (let j = 0; j < filteredList.length; j++) {
+                _filter.push(filteredList[j]["id"]);
+                let filters = this.getFilterItems(filteredList[j], this.fieldlistObj.treeViewModule.getTreeData());
+                for (let i = 0; i < filters.length; i++) {
+                    if (_array.indexOf(filters[i]) == -1 &&
+                        filters[i] != null) {
+                        _array.push(filters[i]);
+                        predicats.push(new Predicate("id", "equal", filters[i], false));
+                    }
+                }
+            }
+            if (predicats.length == 0) {
+                this.changeDataSource([]);
+            }
+            else {
+                let query = new Query().where(Predicate.or(predicats));
+                let newList = new DataManager(this.fieldlistObj.treeViewModule.getTreeData()).executeLocal(query);
+                this.changeDataSource(newList);
+            }
+        }
+    }
+    //Find the Parent Nodes for corresponding childs
+    getFilterItems(fList, list) {
+        let nodes = [];
+        nodes.push(fList["id"]);
+        let query2 = new Query().where("id", "equal", fList["pid"], false);
+        let fList1 = new DataManager(list).executeLocal(query2);
+        if (fList1.length != 0) {
+            let pNode = this.getFilterItems(fList1[0], list);
+            for (let i = 0; i < pNode.length; i++) {
+                if (nodes.indexOf(pNode[i]) == -1 && pNode[i] != null)
+                    nodes.push(pNode[i]);
+            }
+            return nodes;
+        }
+        return nodes;
+    }
+    created(args) {
+        if (this.fieldlistObj && !this.fieldlistObj.engineModule.fields) {
+            this.fieldlistObj.engineModule.fields = [];
+        }
+        let search = document.createElement("input");
+        search.id = "pivotSearchBox" + this.fieldlistObj.element.id;
+        let el = document.querySelector("#" + this.fieldlistObj.element.id + "_Container .e-field-table");
+        if (el)
+            el.prepend(search);
+        this.pivotSearchBox = new MaskedTextBox({
+            placeholder: this.translation.SEARCH || ".SEARCH",
+            cssClass: "pivot-search",
+            change: this.searchNodes.bind(this),
+        });
+        this.pivotSearchBox.appendTo("#pivotSearchBox" + this.fieldlistObj.element.id);
+        // NEW Dashboard 点击"apply"时，请求新数据
+        let applyBtn = document.getElementById(this.fieldlistObj.element.id + "_DeferUpdateButton1");
+        applyBtn &&
+            applyBtn.addEventListener("click", () => {
+                this.pbf.pageLoading = true;
+                this.dashboardPorletsService.getDataByPortletsNew([this.portlet], () => {
+                    this.getData();
+                    setTimeout(() => {
+                        this.pbf.pageLoading = false;
+                    });
+                }, null, false, this.dashboard, false);
+            });
+    }
+    fieldListRefreshed(args) {
+        if (this.pivotSearchBox) {
+            this.pivotSearchBox.value = "";
+            this.changeDataSource(this.fieldlistObj.treeViewModule.getTreeData());
+        }
+    }
+    changeDataSource(data) {
+        let fieldTable = this.fieldlistObj.treeViewModule.fieldTable;
+        if (fieldTable) {
+            fieldTable.fields = {
+                dataSource: data,
+                id: "id",
+                text: "caption",
+                isChecked: "isSelected",
+                parentID: "pid",
+                iconCss: "spriteCssClass",
+            };
+        }
+    }
+    //SMP2-2957 fix the date issue on the raw data
+    drillThrough(args) {
+        for (let i = 0; i < args.gridColumns.length; i++) {
+            const data = this.configFields.filter((el) => el.colName === args.gridColumns[i].field);
+            if (data && data.length > 0) {
+                if (data[0].dataType === "date" ||
+                    data[0].dataType === "datetime") {
+                    args.gridColumns[i].type = "date";
+                }
+            }
+        }
+    }
+    //#endregion
+    setFontSettingConditional(obj, data, code) {
+        if (code === -1) {
+            obj.style.color = data.negaFontColor;
+            obj.style.fontFamily = data.negaFontFamilyValue;
+            obj.style.fontSize = data.negaFontSizeValue;
+            obj.style.backgroundColor = data.negaBackgroundColor;
+        }
+        else {
+            obj.style.color = data.fontColor;
+            obj.style.fontFamily = data.fontFamilyValue;
+            obj.style.fontSize = data.fontSizeValue;
+            obj.style.backgroundColor = data.backgroundColor;
+        }
+    }
+    setCompareConditional(negaConditionalFormatObj, conditionalFormatObj, data) {
+        if (Math.sign(data.compareValue1) == 0) {
+            switch (data.compareSelect) {
+                case "LessThan": // 小于
+                case "LessThanOrEqualTo": // 小于等于
+                    negaConditionalFormatObj.value1 = 0;
+                    negaConditionalFormatObj.conditions = "LessThan";
+                    this.setFontSettingConditional(negaConditionalFormatObj, data, -1);
+                    break;
+                case "GreaterThan": // 大于
+                case "GreaterThanOrEqualTo": // 大于等于
+                    conditionalFormatObj.value1 = 0;
+                    conditionalFormatObj.conditions = "GreaterThan";
+                    this.setFontSettingConditional(conditionalFormatObj, data, 1);
+                    break;
+                case "NotEquals": // 不等于
+                    negaConditionalFormatObj.value1 = 0;
+                    negaConditionalFormatObj.conditions = "LessThan";
+                    this.setFontSettingConditional(negaConditionalFormatObj, data, -1);
+                    conditionalFormatObj.value1 = 0;
+                    conditionalFormatObj.conditions = "GreaterThan";
+                    this.setFontSettingConditional(conditionalFormatObj, data, 1);
+                    break;
+                case "Between": // value1<= val <=value2
+                    if (Math.sign(data.compareValue2) === 1) {
+                        conditionalFormatObj.value1 = 0;
+                        conditionalFormatObj.value2 = Number(data.compareValue2);
+                        conditionalFormatObj.conditions = "Between";
+                        this.setFontSettingConditional(conditionalFormatObj, data, 1);
+                    }
+                    break;
+                case "NotBetween": // val >= value2, val <= value1
+                    if (Math.sign(data.compareValue2) === 1) {
+                        conditionalFormatObj.value1 = Number(data.compareValue2);
+                        conditionalFormatObj.conditions = "GreaterThan";
+                        this.setFontSettingConditional(conditionalFormatObj, data, 1);
+                        negaConditionalFormatObj.value1 = 0;
+                        negaConditionalFormatObj.conditions = "LessThan";
+                        this.setFontSettingConditional(negaConditionalFormatObj, data, -1);
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+        else if (Math.sign(data.compareValue1) === 1) {
+            switch (data.compareSelect) {
+                case "LessThan": // 小于
+                case "LessThanOrEqualTo": // 小于等于
+                    conditionalFormatObj.value1 = 0;
+                    conditionalFormatObj.value2 = Number(data.compareValue1);
+                    conditionalFormatObj.conditions = "Between";
+                    this.setFontSettingConditional(conditionalFormatObj, data, 1);
+                    negaConditionalFormatObj.value1 = 0;
+                    negaConditionalFormatObj.conditions = "LessThan";
+                    this.setFontSettingConditional(negaConditionalFormatObj, data, -1);
+                    break;
+                case "GreaterThan": // 大于
+                case "GreaterThanOrEqualTo": // 大于等于
+                    conditionalFormatObj.value1 = Number(data.compareValue1);
+                    conditionalFormatObj.conditions = "GreaterThan";
+                    this.setFontSettingConditional(conditionalFormatObj, data, 1);
+                    break;
+                case "Equals": // 等于
+                    conditionalFormatObj.value1 = Number(data.compareValue1);
+                    conditionalFormatObj.conditions = "Equals";
+                    this.setFontSettingConditional(conditionalFormatObj, data, 1);
+                    break;
+                case "NotEquals": // 不等于
+                    conditionalFormatObj.value1 = 0;
+                    conditionalFormatObj.value2 = Number(data.compareValue1);
+                    conditionalFormatObj.conditions = "Between";
+                    // push进数组
+                    conditionalFormatObj.value1 = Number(data.compareValue1);
+                    conditionalFormatObj.conditions = "GreaterThan";
+                    // push进数组
+                    negaConditionalFormatObj.value1 = 0;
+                    negaConditionalFormatObj.conditions = "LessThanOrEqualTo";
+                    this.setFontSettingConditional(negaConditionalFormatObj, data, -1);
+                    this.setFontSettingConditional(conditionalFormatObj, data, 1);
+                    break;
+                case "Between": // value1<= val <=value2
+                    if (Math.sign(data.compareValue2) === 1) {
+                        conditionalFormatObj.value1 = Number(data.compareValue1);
+                        conditionalFormatObj.value2 = Number(data.compareValue2);
+                        conditionalFormatObj.conditions = "Between";
+                        this.setFontSettingConditional(conditionalFormatObj, data, 1);
+                    }
+                    break;
+                case "NotBetween": // val >= value2, val <= value1
+                    if (Math.sign(data.compareValue2) === 1) {
+                        conditionalFormatObj.value1 = 0;
+                        conditionalFormatObj.value2 = Number(data.compareValue1);
+                        conditionalFormatObj.conditions = "Between";
+                        // push进数组
+                        conditionalFormatObj.value1 = Number(data.compareValue2);
+                        conditionalFormatObj.conditions = "GreaterThan";
+                        // push进数组
+                        this.setFontSettingConditional(conditionalFormatObj, data, 1);
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+        else if (Math.sign(data.compareValue1) === -1) {
+            switch (data.compareSelect) {
+                case "LessThan": // 小于
+                case "LessThanOrEqualTo": // 小于等于
+                    negaConditionalFormatObj.value1 = data.compareValue1;
+                    negaConditionalFormatObj.conditions = data.compareSelect;
+                    this.setFontSettingConditional(negaConditionalFormatObj, data, -1);
+                    break;
+                case "GreaterThan": // 大于
+                case "GreaterThanOrEqualTo": // 大于等于
+                    conditionalFormatObj.value1 = 0;
+                    conditionalFormatObj.conditions = "GreaterThanOrEqualTo";
+                    negaConditionalFormatObj.value1 = 0;
+                    negaConditionalFormatObj.value2 = data.compareValue1;
+                    negaConditionalFormatObj.conditions = "Between";
+                    this.setFontSettingConditional(conditionalFormatObj, data, 1);
+                    this.setFontSettingConditional(negaConditionalFormatObj, data, -1);
+                    break;
+                case "Equals": // 等于
+                    negaConditionalFormatObj.value1 = data.compareValue1;
+                    negaConditionalFormatObj.conditions = "Equals";
+                    this.setFontSettingConditional(negaConditionalFormatObj, data, -1);
+                case "NotEquals": // 不等于
+                    negaConditionalFormatObj.value1 = data.compareValue1;
+                    negaConditionalFormatObj.conditions = "NotEquals";
+                    this.setFontSettingConditional(negaConditionalFormatObj, data, -1);
+                    conditionalFormatObj.value1 = 0;
+                    conditionalFormatObj.conditions = "GreaterThan";
+                    this.setFontSettingConditional(conditionalFormatObj, data, 1);
+                    break;
+                case "Between": // value1<= val <=value2
+                    if (Math.sign(data.compareValue2)) {
+                        negaConditionalFormatObj.value1 = 0;
+                        negaConditionalFormatObj.value2 = data.compareValue1;
+                        negaConditionalFormatObj.conditions = "Between";
+                        this.setFontSettingConditional(negaConditionalFormatObj, data, -1);
+                        conditionalFormatObj.value1 = 0;
+                        conditionalFormatObj.value2 = data.compareValue2;
+                        conditionalFormatObj.conditions = "Between";
+                        this.setFontSettingConditional(conditionalFormatObj, data, 1);
+                    }
+                    else {
+                        negaConditionalFormatObj.value1 = data.compareValue1;
+                        negaConditionalFormatObj.value2 = data.compareValue2;
+                        negaConditionalFormatObj.conditions = "Between";
+                        this.setFontSettingConditional(negaConditionalFormatObj, data, -1);
+                    }
+                    break;
+                case "NotBetween": // val >= value2, val <= value1
+                    if (Math.sign(data.compareValue2)) {
+                        negaConditionalFormatObj.value1 = data.compareValue1;
+                        negaConditionalFormatObj.conditions = "LessThan";
+                        this.setFontSettingConditional(negaConditionalFormatObj, data, -1);
+                        conditionalFormatObj.value1 = data.compareValue2;
+                        conditionalFormatObj.conditions = "GreaterThan";
+                        this.setFontSettingConditional(conditionalFormatObj, data, 1);
+                    }
+                    else {
+                        negaConditionalFormatObj.value1 = data.compareValue1;
+                        negaConditionalFormatObj.value2 = data.compareValue2;
+                        negaConditionalFormatObj.conditions = "NotBetween";
+                        this.setFontSettingConditional(negaConditionalFormatObj, data, -1);
+                        conditionalFormatObj.value1 = 0;
+                        conditionalFormatObj.conditions = "GreaterThan";
+                        this.setFontSettingConditional(conditionalFormatObj, data, 1);
+                    }
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    /**
+     * @param timeArray 数组对象 [{"date":"2021-01-01"},{"date":"2021-02-01"}]
+     * @param endDate 截至时间
+     * @param interval 时间间隔 year / quarter / month
+     * @param timeKey 时间字段名 date
+     * @returns 划分后的时间分组对象
+     */
+    getTimeRanges(timeArray, endDate, interval, timeKey) {
+        // 将时间字符串转换为 moment 对象
+        const dates = timeArray.map((item) => moment(item[timeKey || "date"]));
+        // 分隔符
+        const delimiter = "-";
+        // 找到最小时间和最大时间
+        const minDate = moment.min(dates);
+        const maxDate = moment(endDate);
+        // 初始化结果对象
+        const result = {};
+        // 根据入参进行划分
+        if (interval === "year") {
+            const startYear = minDate.year();
+            const endYear = maxDate.year();
+            for (let year = startYear; year <= endYear; year++) {
+                result[year] = [];
+            }
+            dates.forEach((date, index) => {
+                const year = date.year();
+                result[year].push(timeArray[index]);
+            });
+        }
+        else if (interval === "quarter") {
+            // 存储季度字符串
+            const quarters = [];
+            // 逐一遍历每个季度
+            for (let currentDate = minDate.clone(); currentDate.isSameOrBefore(maxDate); currentDate.add(3, "months")) {
+                const year = currentDate.year();
+                const quarter = Math.ceil((currentDate.month() + 1) / 3); // 计算季度
+                quarters.push(`${year}${delimiter}Q${quarter}`); // 格式化并添加到数组
+            }
+            // 输出所有季度
+            quarters.forEach((quarter, index) => {
+                result[quarter] = [];
+            });
+            dates.forEach((date, index) => {
+                const year = date.year();
+                const quarter = date.quarter(); // 获取季度
+                if (quarter === 1)
+                    result[year + delimiter + "Q1"].push(timeArray[index]);
+                else if (quarter === 2)
+                    result[year + delimiter + "Q2"].push(timeArray[index]);
+                else if (quarter === 3)
+                    result[year + delimiter + "Q3"].push(timeArray[index]);
+                else if (quarter === 4)
+                    result[year + delimiter + "Q4"].push(timeArray[index]);
+            });
+        }
+        else if (interval === "month") {
+            // 存储月份字符串
+            const months = [];
+            // 逐一遍历每个月
+            for (let currentDate = minDate.clone(); currentDate.isSameOrBefore(maxDate); currentDate.add(1, "months")) {
+                months.push(currentDate.format(`YYYY${delimiter}MM`)); // 格式化并添加到数组
+            }
+            // 输出所有月份
+            months.forEach((month, index) => {
+                result[month] = [];
+            });
+            dates.forEach((date, index) => {
+                const year = date.year();
+                const month = (date.month() + 1).toString().padStart(2, "0"); // 0-11
+                result[year + delimiter + month].push(timeArray[index]);
+            });
+        }
+        return result;
+    }
+    /**
+     * 计算几何算数平方更
+     * @param values 数组 [0, 0, 0.2575]
+     * @returns
+     */
+    calculateGrowthRate(values) {
+        const product = values.reduce((acc, val) => acc * (1 + val), 1);
+        if (product >= 0) {
+            return Math.pow(product, 1 / values.length) - 1;
+        }
+        else if (product < 0) {
+            if (values.length % 2 == 0) {
+                return null;
+            }
+            else {
+                return this.nthroot(product, values.length) - 1;
+            }
+        }
+    }
+    nthroot(x, n) {
+        let ng = n % 2;
+        if (ng == 1 || x < 0)
+            x = -x;
+        var r = Math.pow(x, 1 / n);
+        n = Math.pow(r, n);
+        if (Math.abs(x - n) < 1 && x > 0 === n > 0)
+            return ng ? -r : r;
+    }
+    /**
+     * 标准偏差
+     * @param values 数组 [0, 0, -0.4775]
+     * @returns 0.2756847535380463
+     */
+    calculateStandardDeviation(values) {
+        const n = values.length;
+        // 检查数据点数量
+        if (n < 2) {
+            throw new Error("至少需要两个数据点来计算样本标准偏差");
+        }
+        // 计算均值
+        const mean = values.reduce((acc, val) => acc + val, 0) / n;
+        // 计算方差
+        const variance = values.reduce((acc, val) => acc + Math.pow(val - mean, 2), 0) /
+            (n - 1);
+        // 返回标准偏差
+        return Math.sqrt(variance);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: GadgetPivotChartComponent, deps: [{ token: i1.DashboardPorletsService }, { token: i2.DashboardService }, { token: i0.ChangeDetectorRef }, { token: PBF_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: GadgetPivotChartComponent, selector: "rs-gadget-pivot-chart", inputs: { portlet: "portlet", dashboard: "dashboard", portlets: "portlets" }, outputs: { updatePorletConfig: "updatePorletConfig" }, providers: [
+            ToolbarService,
+            FieldListService,
+            NumberFormattingService,
+            CalculatedFieldService,
+            GroupingBarService,
+            VirtualScrollService,
+            DrillThroughService,
+        ], viewQueries: [{ propertyName: "pivotObj", first: true, predicate: ["pivotview"], descendants: true }, { propertyName: "fieldlistObj", first: true, predicate: ["pivotfieldlist"], descendants: true }], ngImport: i0, template: "<div class=\"control-section\" style=\"overflow: hidden; height: 100%\">\r\n\t<ejs-pivotview\r\n\t\twidth=\"100%\"\r\n\t\theight=\"100%\"\r\n\t\tstyle=\"display: block\"\r\n\t\t[dataSourceSettings]=\"dataSourceSettings\"\r\n\t\t#pivotview\r\n\t\t(dataBound)=\"dataBound($event)\"\r\n\t\tenableValueSorting=\"true\"\r\n\t\tallowConditionalFormatting=\"true\"\r\n\t\tallowExcelExport=\"true\"\r\n\t\tallowGrouping=\"true\"\r\n\t\t[zoomSettings]=\"zoomSettings\"\r\n\t\tenableVirtualization=\"true\"\r\n\t\t(aggregateCellInfo)=\"aggregateCellInfo($event)\"\r\n\t\t(cellClick)=\"cellClick($event)\"\r\n\t\tallowDrillThrough=\"true\"\r\n\t\t(actionFailure)=\"actionFailure($event)\"\r\n\t\t(fieldListRefreshed)=\"fieldListRefreshed($event)\"\r\n\t\t(drillThrough)=\"drillThrough($event)\"\r\n\t\t[chartSettings]=\"chartSettings\"\r\n\t\t(chartSeriesCreated)=\"chartSeriesCreated($event)\"\r\n\t\t[displayOption]=\"displayOption\"\r\n\t\t[showTooltip]=\"false\"\r\n\t\t(enginePopulated)=\"afterEnginePopulate($event)\"\r\n\t\t(beforeExport)=\"beforeExport($event)\"\r\n\t>\r\n\t</ejs-pivotview>\r\n\r\n\t<div class=\"pivotfieldlist-control\">\r\n\t\t<ejs-pivotfieldlist\r\n\t\t\t[id]=\"portlet.newId\"\r\n\t\t\t#pivotfieldlist\r\n\t\t\thidden=\"true\"\r\n\t\t\tenableValueSorting=\"true\"\r\n\t\t\tshowFieldList=\"true\"\r\n\t\t\tallowCalculatedField=\"true\"\r\n\t\t\tallowDeferLayoutUpdate=\"true\"\r\n\t\t\trenderMode=\"Popup\"\r\n\t\t\t(enginePopulated)=\"afterPopulate($event)\"\r\n\t\t\t(memberEditorOpen)=\"onMemberEditorOpen($event)\"\r\n\t\t\t(enginePopulating)=\"enginePopulating($event)\"\r\n\t\t\t(aggregateCellInfo)=\"aggregateCellInfo($event)\"\r\n\t\t\t(fieldDrop)=\"onFieldDrop($event)\"\r\n\t\t\t(actionComplete)=\"actionComplete($event)\"\r\n\t\t\t(actionBegin)=\"actionBegin($event)\"\r\n\t\t\t(calculatedFieldCreate)=\"calculatedFieldCreate($event)\"\r\n\t\t\t(load)=\"onLoad()\"\r\n\t\t\t(created)=\"created($event)\"\r\n\t\t>\r\n\t\t</ejs-pivotfieldlist>\r\n\t</div>\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", styles: [".pivotview{width:100%;height:100%}.gadgetBar ul{margin:0;padding:0;list-style:none;display:inline-block;background:#fff;border-radius:5px}.gadgetBar ul li{display:inline-block;width:45px;height:39px;line-height:39px;text-align:center;cursor:pointer}:host::ng-deep .e-cellvalue{color:unset!important}:host ::ng-deep .e-pivotview .e-gtot{font-weight:400!important}:host ::ng-deep .e-pivotview .odd-class{background-color:#f8fafb!important}:host ::ng-deep .e-pivotview .odd-class .e-cellvalue{font-size:13px;font-weight:400!important}:host ::ng-deep .e-pivotview .even-class{background-color:#fff!important}:host ::ng-deep .e-pivotview .even-class .e-cellvalue{font-size:13px;font-weight:400!important}:host ::ng-deep .e-pivotview .grand-class{background-color:#eaedf0!important}:host ::ng-deep .e-pivotview .grand-class .e-cellvalue{font-size:13px;font-weight:700!important}:host ::ng-deep .e-headercell{background-color:#eaedf0!important}:host ::ng-deep .e-headercell .e-headertext{font-size:12px!important}:host ::ng-deep .e-columnsheader{background-color:#f8fafb!important}.logoImg{position:absolute!important;left:10px!important}:host ::ng-deep .image-{height:55px;width:55px;border-radius:50px;overflow:hidden;margin:5px 5px 5px 0;display:inline-flex;justify-content:center;align-items:center}:host ::ng-deep .image- img{width:55px}:host::ng-deep .e-pivotview .e-customclass .e-cellvalue{font-weight:700!important}:host::ng-deep .e-gridcontent .e-rowcell .e-cellvalue{background-color:transparent!important}:host ::ng-deep .control-section .e-spin-show,:host ::ng-deep .control-section .e-spinner-pane{display:none!important}:host ::ng-deep .control-section .e-control.e-grid,:host ::ng-deep .control-section .e-control.e-pivotchart{height:100%!important}:host ::ng-deep .control-section .e-pivotview{border:none!important}:host ::ng-deep .control-section .e-pivotview tr{height:32px!important}:host ::ng-deep .control-section .e-pivotview tr th{height:40px!important;background:#eaedf0!important}:host ::ng-deep .control-section .e-pivotview .e-grid.e-default.e-bothlines .e-headercell{border-right:none!important;border-left:none!important}:host ::ng-deep .control-section .e-pivotview .e-table{border-right:none!important}:host ::ng-deep .control-section .e-pivotview svg{outline:none!important}:host ::ng-deep .control-section .e-pivotview svg>g>rect{stroke-width:0!important}:host ::ng-deep .control-section .e-pivotview .e-gridcontent .e-rowcell{border-right:none!important;border-left:none!important}::ng-deep .e-pivotfieldlist-container #AccountTypeCode .e-sort{opacity:0;pointer-events:none}\n"], dependencies: [{ kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i4.PivotViewComponent, selector: "ejs-pivotview", inputs: ["aggregateTypes", "allowCalculatedField", "allowConditionalFormatting", "allowDataCompression", "allowDeferLayoutUpdate", "allowDrillThrough", "allowExcelExport", "allowGrouping", "allowNumberFormatting", "allowPdfExport", "cellTemplate", "chartSettings", "chartTypes", "cssClass", "dataSourceSettings", "displayOption", "editSettings", "enableFieldSearching", "enableHtmlSanitizer", "enablePaging", "enablePersistence", "enableRtl", "enableValueSorting", "enableVirtualization", "exportAllPages", "gridSettings", "groupingBarSettings", "height", "hyperlinkSettings", "loadOnDemandInMemberEditor", "locale", "maxNodeLimitInMemberEditor", "maxRowsInDrillThrough", "pageSettings", "pagerSettings", "pivotValues", "showFieldList", "showGroupingBar", "showToolbar", "showTooltip", "showValuesButton", "spinnerTemplate", "toolbar", "toolbarTemplate", "tooltipTemplate", "virtualScrollSettings", "width"], outputs: ["actionBegin", "actionComplete", "actionFailure", "afterServiceInvoke", "aggregateCellInfo", "aggregateMenuOpen", "beforeExport", "beforeServiceInvoke", "beginDrillThrough", "calculatedFieldCreate", "cellClick", "cellSelected", "cellSelecting", "chartSeriesCreated", "conditionalFormatting", "created", "dataBound", "destroyed", "drill", "drillThrough", "editCompleted", "enginePopulated", "enginePopulating", "exportComplete", "fetchReport", "fieldDragStart", "fieldDrop", "fieldListRefreshed", "fieldRemove", "hyperlinkCellClick", "load", "loadReport", "memberEditorOpen", "memberFiltering", "newReport", "numberFormatting", "onFieldDropped", "onHeadersSort", "onPdfCellRender", "removeReport", "renameReport", "saveReport", "toolbarClick", "toolbarRender"] }, { kind: "component", type: i4.PivotFieldListComponent, selector: "ejs-pivotfieldlist", inputs: ["aggregateTypes", "allowCalculatedField", "allowDeferLayoutUpdate", "cssClass", "currencyCode", "dataSourceSettings", "enableFieldSearching", "enableHtmlSanitizer", "enablePersistence", "enableRtl", "loadOnDemandInMemberEditor", "locale", "maxNodeLimitInMemberEditor", "renderMode", "showValuesButton", "spinnerTemplate", "target"], outputs: ["actionBegin", "actionComplete", "actionFailure", "afterServiceInvoke", "aggregateCellInfo", "aggregateMenuOpen", "beforeServiceInvoke", "calculatedFieldCreate", "created", "dataBound", "destroyed", "enginePopulated", "enginePopulating", "fieldDragStart", "fieldDrop", "fieldRemove", "load", "memberEditorOpen", "memberFiltering", "onFieldDropped", "onHeadersSort"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: GadgetPivotChartComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "rs-gadget-pivot-chart", providers: [
+                        ToolbarService,
+                        FieldListService,
+                        NumberFormattingService,
+                        CalculatedFieldService,
+                        GroupingBarService,
+                        VirtualScrollService,
+                        DrillThroughService,
+                    ], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"control-section\" style=\"overflow: hidden; height: 100%\">\r\n\t<ejs-pivotview\r\n\t\twidth=\"100%\"\r\n\t\theight=\"100%\"\r\n\t\tstyle=\"display: block\"\r\n\t\t[dataSourceSettings]=\"dataSourceSettings\"\r\n\t\t#pivotview\r\n\t\t(dataBound)=\"dataBound($event)\"\r\n\t\tenableValueSorting=\"true\"\r\n\t\tallowConditionalFormatting=\"true\"\r\n\t\tallowExcelExport=\"true\"\r\n\t\tallowGrouping=\"true\"\r\n\t\t[zoomSettings]=\"zoomSettings\"\r\n\t\tenableVirtualization=\"true\"\r\n\t\t(aggregateCellInfo)=\"aggregateCellInfo($event)\"\r\n\t\t(cellClick)=\"cellClick($event)\"\r\n\t\tallowDrillThrough=\"true\"\r\n\t\t(actionFailure)=\"actionFailure($event)\"\r\n\t\t(fieldListRefreshed)=\"fieldListRefreshed($event)\"\r\n\t\t(drillThrough)=\"drillThrough($event)\"\r\n\t\t[chartSettings]=\"chartSettings\"\r\n\t\t(chartSeriesCreated)=\"chartSeriesCreated($event)\"\r\n\t\t[displayOption]=\"displayOption\"\r\n\t\t[showTooltip]=\"false\"\r\n\t\t(enginePopulated)=\"afterEnginePopulate($event)\"\r\n\t\t(beforeExport)=\"beforeExport($event)\"\r\n\t>\r\n\t</ejs-pivotview>\r\n\r\n\t<div class=\"pivotfieldlist-control\">\r\n\t\t<ejs-pivotfieldlist\r\n\t\t\t[id]=\"portlet.newId\"\r\n\t\t\t#pivotfieldlist\r\n\t\t\thidden=\"true\"\r\n\t\t\tenableValueSorting=\"true\"\r\n\t\t\tshowFieldList=\"true\"\r\n\t\t\tallowCalculatedField=\"true\"\r\n\t\t\tallowDeferLayoutUpdate=\"true\"\r\n\t\t\trenderMode=\"Popup\"\r\n\t\t\t(enginePopulated)=\"afterPopulate($event)\"\r\n\t\t\t(memberEditorOpen)=\"onMemberEditorOpen($event)\"\r\n\t\t\t(enginePopulating)=\"enginePopulating($event)\"\r\n\t\t\t(aggregateCellInfo)=\"aggregateCellInfo($event)\"\r\n\t\t\t(fieldDrop)=\"onFieldDrop($event)\"\r\n\t\t\t(actionComplete)=\"actionComplete($event)\"\r\n\t\t\t(actionBegin)=\"actionBegin($event)\"\r\n\t\t\t(calculatedFieldCreate)=\"calculatedFieldCreate($event)\"\r\n\t\t\t(load)=\"onLoad()\"\r\n\t\t\t(created)=\"created($event)\"\r\n\t\t>\r\n\t\t</ejs-pivotfieldlist>\r\n\t</div>\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", styles: [".pivotview{width:100%;height:100%}.gadgetBar ul{margin:0;padding:0;list-style:none;display:inline-block;background:#fff;border-radius:5px}.gadgetBar ul li{display:inline-block;width:45px;height:39px;line-height:39px;text-align:center;cursor:pointer}:host::ng-deep .e-cellvalue{color:unset!important}:host ::ng-deep .e-pivotview .e-gtot{font-weight:400!important}:host ::ng-deep .e-pivotview .odd-class{background-color:#f8fafb!important}:host ::ng-deep .e-pivotview .odd-class .e-cellvalue{font-size:13px;font-weight:400!important}:host ::ng-deep .e-pivotview .even-class{background-color:#fff!important}:host ::ng-deep .e-pivotview .even-class .e-cellvalue{font-size:13px;font-weight:400!important}:host ::ng-deep .e-pivotview .grand-class{background-color:#eaedf0!important}:host ::ng-deep .e-pivotview .grand-class .e-cellvalue{font-size:13px;font-weight:700!important}:host ::ng-deep .e-headercell{background-color:#eaedf0!important}:host ::ng-deep .e-headercell .e-headertext{font-size:12px!important}:host ::ng-deep .e-columnsheader{background-color:#f8fafb!important}.logoImg{position:absolute!important;left:10px!important}:host ::ng-deep .image-{height:55px;width:55px;border-radius:50px;overflow:hidden;margin:5px 5px 5px 0;display:inline-flex;justify-content:center;align-items:center}:host ::ng-deep .image- img{width:55px}:host::ng-deep .e-pivotview .e-customclass .e-cellvalue{font-weight:700!important}:host::ng-deep .e-gridcontent .e-rowcell .e-cellvalue{background-color:transparent!important}:host ::ng-deep .control-section .e-spin-show,:host ::ng-deep .control-section .e-spinner-pane{display:none!important}:host ::ng-deep .control-section .e-control.e-grid,:host ::ng-deep .control-section .e-control.e-pivotchart{height:100%!important}:host ::ng-deep .control-section .e-pivotview{border:none!important}:host ::ng-deep .control-section .e-pivotview tr{height:32px!important}:host ::ng-deep .control-section .e-pivotview tr th{height:40px!important;background:#eaedf0!important}:host ::ng-deep .control-section .e-pivotview .e-grid.e-default.e-bothlines .e-headercell{border-right:none!important;border-left:none!important}:host ::ng-deep .control-section .e-pivotview .e-table{border-right:none!important}:host ::ng-deep .control-section .e-pivotview svg{outline:none!important}:host ::ng-deep .control-section .e-pivotview svg>g>rect{stroke-width:0!important}:host ::ng-deep .control-section .e-pivotview .e-gridcontent .e-rowcell{border-right:none!important;border-left:none!important}::ng-deep .e-pivotfieldlist-container #AccountTypeCode .e-sort{opacity:0;pointer-events:none}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.DashboardPorletsService }, { type: i2.DashboardService }, { type: i0.ChangeDetectorRef }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [PBF_TOKEN]
+                }] }]; }, propDecorators: { portlet: [{
+                type: Input
+            }], dashboard: [{
+                type: Input
+            }], portlets: [{
+                type: Input
+            }], updatePorletConfig: [{
+                type: Output
+            }], pivotObj: [{
+                type: ViewChild,
+                args: ["pivotview", { static: false }]
+            }], fieldlistObj: [{
+                type: ViewChild,
+                args: ["pivotfieldlist", { static: false }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gadget-pivot.component.js","sourceRoot":"","sources":["../../../../../../../projects/raise-common-lib/src/lib/dashboard/gadget-group/gadget-pivot-chart/gadget-pivot.component.ts","../../../../../../../projects/raise-common-lib/src/lib/dashboard/gadget-group/gadget-pivot-chart/gadget-pivot.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n\tChangeDetectorRef,\r\n\tComponent,\r\n\tInput,\r\n\tOnInit,\r\n\tViewChild,\r\n\tChangeDetectionStrategy,\r\n\tEventEmitter,\r\n\tOutput,\r\n\tOptional,\r\n\tInject,\r\n} from \"@angular/core\";\r\n\r\nimport {\r\n\tIDataOptions,\r\n\tPivotFieldListComponent,\r\n\tPivotViewComponent,\r\n\tEnginePopulatedEventArgs,\r\n\tIDataSet,\r\n\tToolbarService,\r\n\tFieldListService,\r\n\tNumberFormattingService,\r\n\tCalculatedFieldService,\r\n\tCalculatedFieldCreateEventArgs,\r\n\tGroupingBarService,\r\n\tFieldDropEventArgs,\r\n\tISort,\r\n\tVirtualScrollService,\r\n\tIPivotValues,\r\n\tIPageSettings,\r\n\tDrillThroughEventArgs,\r\n\tDrillThroughService,\r\n\tPivotActionFailureEventArgs,\r\n} from \"@syncfusion/ej2-angular-pivotview\";\r\n\r\nimport { L10n, createElement, enableRipple } from \"@syncfusion/ej2-base\";\r\nimport { PBF_TOKEN } from \"../../../service/InjectionToken\";\r\n\r\nimport {\r\n\tsortBy,\r\n\tdifferenceWith,\r\n\tstartsWith,\r\n\tcloneDeep,\r\n\tuniqBy,\r\n\tfilter as _filter,\r\n\tmaxBy,\r\n\tminBy,\r\n\tsumBy,\r\n\tmeanBy,\r\n\tmean,\r\n} from \"lodash\";\r\nimport { DashboardService } from \"../../dashboard.service\";\r\nimport {\r\n\tAGGREGATE_TYPES_TEXT,\r\n\tALL_AGGREGATE_TYPES,\r\n\tDashboardPorletsService,\r\n} from \"../../dashboardPorlets.service\";\r\nimport { Browser } from \"@syncfusion/ej2-base\";\r\nimport { Observable, Subscription } from \"rxjs\";\r\nimport { MaskedTextBox } from \"@syncfusion/ej2-inputs/src/maskedtextbox/maskedtextbox\";\r\nimport { DataManager } from \"@syncfusion/ej2-data/src/manager\";\r\nimport { Predicate, Query } from \"@syncfusion/ej2-data/src/query\";\r\nimport { DataUtil } from \"@syncfusion/ej2-data\";\r\nimport moment from \"moment\";\r\nenableRipple(false);\r\n\r\n@Component({\r\n\tselector: \"rs-gadget-pivot-chart\",\r\n\ttemplateUrl: \"./gadget-pivot.component.html\",\r\n\tstyleUrls: [\"./gadget-pivot.component.scss\"],\r\n\tproviders: [\r\n\t\tToolbarService,\r\n\t\tFieldListService,\r\n\t\tNumberFormattingService,\r\n\t\tCalculatedFieldService,\r\n\t\tGroupingBarService,\r\n\t\tVirtualScrollService,\r\n\t\tDrillThroughService,\r\n\t],\r\n\tchangeDetection: ChangeDetectionStrategy.OnPush,\r\n})\r\nexport class GadgetPivotChartComponent implements OnInit {\r\n\t@Input() portlet;\r\n\t@Input() dashboard;\r\n\t@Input() portlets;\r\n\t@Output() updatePorletConfig = new EventEmitter();\r\n\tprivate Pivot_Data: IDataSet[];\r\n\tprivate config;\r\n\tpublic dataSourceSettings: IDataOptions;\r\n\tprivate excludeFields = [];\r\n\tprivate filterSettings = [];\r\n\tprivate datePipeFormat;\r\n\tpublic translation;\r\n\t@ViewChild(\"pivotview\", { static: false })\r\n\tprivate pivotObj: PivotViewComponent;\r\n\t@ViewChild(\"pivotfieldlist\", { static: false })\r\n\tpublic fieldlistObj: PivotFieldListComponent;\r\n\tprivate grandTotals = {};\r\n\tprivate subTotals = {};\r\n\tprivate previousSort: ISort;\r\n\tprivate subscriptions: Subscription[] = [];\r\n\tprivate allDataValue;\r\n\t// private calculatedFieldSettings;\r\n\tprivate isInit: boolean = true;\r\n\tprivate pivotSearchBox: MaskedTextBox;\r\n\tpublic displayOption = {\r\n\t\tview: \"Both\",\r\n\t\tprimary: \"Chart\",\r\n\t};\r\n\tpublic chartSettings;\r\n\tpublic tooltipSettings = {\r\n\t\tenable: false,\r\n\t};\r\n\tprivate columnTexts = [];\r\n\tprivate configFields = [];\r\n\tprivate quarterFormat = [\r\n\t\t{ value: \"03/2021\", format: \"MM/yyyy\" },\r\n\t\t{ value: \"03/21\", format: \"MM/dd\" },\r\n\t\t{ value: \"3/2021\", format: \"M/yyyy\" },\r\n\t\t{ value: \"3/21\", format: \"M/yy\" },\r\n\t\t{ value: \"March 2021\", format: \"MMMM yyyy\" },\r\n\t\t{ value: \"Mar, 2021\", format: \"MMM, yyyy\" },\r\n\t\t{ value: \"March, 2021\", format: \"MMMM, yyyy\" },\r\n\t\t{ value: \"2021\", format: \"yyyy\" },\r\n\t];\r\n\tzoomSettings = {\r\n\t\tenable: false,\r\n\t};\r\n\titemDataTypeSortArr = [\r\n\t\t\"Assets\",\r\n\t\t\"Liabilities\",\r\n\t\t\"Equity\",\r\n\t\t\"P&L\",\r\n\t\t\"Cashflow\",\r\n\t];\r\n\tprivate formatDates = [];\r\n\tprivate customCalculatedFields: any[] = []; // 自定义计算列\r\n\tprivate allowedCalculatedFields: any[] = []; // 允许自定义算法的字段\r\n\tprivate zeroFormatData = {\r\n\t\temptyList: [],\r\n\t\thgList: [],\r\n\t};\r\n\tprivate millionFields = [];\r\n\tprivate tempSubtotals = [];\r\n\tpublic orderByColumns; // Eg: \"DueDate, Sequence\"\r\n\tpublic isApplyIRR: boolean = false;\r\n\tpublic calcIRRData: any;\r\n\tprivate percentNumFields = [];\r\n\tpublic pageLoading;\r\n\tobservable = new Observable();\r\n\tpublic isloaded: boolean; // 是否已经初始化过\r\n\r\n\tconstructor(\r\n\t\tprivate dashboardPorletsService: DashboardPorletsService,\r\n\t\tprivate dashboardService: DashboardService,\r\n\t\tprivate ref: ChangeDetectorRef,\r\n\t\t@Optional() @Inject(PBF_TOKEN) private pbf: any,\r\n\t) {}\r\n\r\n\tngOnInit() {\r\n\t\tthis.chartSettings = {\r\n\t\t\tlegendSettings: {\r\n\t\t\t\tvisible: false,\r\n\t\t\t},\r\n\t\t\tenableMultipleAxis: false,\r\n\t\t\tshowMultiLevelLabels: false,\r\n\t\t\tchartSeries: {\r\n\t\t\t\ttype: \"Column\",\r\n\t\t\t\tcolumnSpacing: 0.1,\r\n\t\t\t\tcolumnWidth: 0.9,\r\n\t\t\t},\r\n\t\t\tmultipleAxisMode: \"Stacked\",\r\n\t\t\tprimaryXAxis: {\r\n\t\t\t\ttitle: \" \",\r\n\t\t\t\tlabelFormat: \"N2\",\r\n\t\t\t\tmajorGridLines: { width: 0 },\r\n\t\t\t\tminorGridLines: {\r\n\t\t\t\t\twidth: 0,\r\n\t\t\t\t\tcolor: \"transparent\",\r\n\t\t\t\t\tvisible: false,\r\n\t\t\t\t},\r\n\t\t\t\tminorTickLines: { visible: false },\r\n\t\t\t\tlineStyle: {\r\n\t\t\t\t\twidth: 0,\r\n\t\t\t\t},\r\n\t\t\t},\r\n\t\t\tchartArea: {\r\n\t\t\t\topacity: 0,\r\n\t\t\t\tborder: {\r\n\t\t\t\t\twidth: 0,\r\n\t\t\t\t},\r\n\t\t\t},\r\n\t\t\tpalettes: [\r\n\t\t\t\t\"#594bb9\",\r\n\t\t\t\t\"#f1af32\",\r\n\t\t\t\t\"#4688ed\",\r\n\t\t\t\t\"#e0563e\",\r\n\t\t\t\t\"#803a63\",\r\n\t\t\t\t\"#6dd8b5\",\r\n\t\t\t\t\"#e87225\",\r\n\t\t\t\t\"#c5df42\",\r\n\t\t\t\t\"#c6437d\",\r\n\t\t\t],\r\n\t\t\tprimaryYAxis: {\r\n\t\t\t\t// Y轴标题设置为空\r\n\t\t\t\ttitle: \" \",\r\n\t\t\t\tlabelFormat: \"N2\",\r\n\t\t\t},\r\n\t\t\tzoomSettings: {\r\n\t\t\t\tenableMouseWheelZooming: false, // 禁用鼠标滚轮缩放\r\n\t\t\t\tenablePinchZooming: false, // 禁用触摸缩放\r\n\t\t\t\tenableSelectionZooming: false, // 禁用选择区域缩放\r\n\t\t\t\tenableDeferredZooming: false, // 禁用延迟缩放\r\n\t\t\t\ttoolbarItems: [],\r\n\t\t\t\tenableScrollbar: false,\r\n\t\t\t\tenableZooming: false,\r\n\t\t\t},\r\n\t\t\ttitle: \" \",\r\n\t\t};\r\n\t\tthis.getInfo();\r\n\t\tthis.getData();\r\n\t}\r\n\r\n\tngAfterViewInit(): void {\r\n\t\tthis.subscriptions.push(\r\n\t\t\tthis.dashboardService.getStartRefresh().subscribe((dashboardId) => {\r\n\t\t\t\tif (this.dashboard.id === dashboardId) {\r\n\t\t\t\t\tthis.pageLoading = true;\r\n\t\t\t\t\tthis.ref.markForCheck();\r\n\t\t\t\t}\r\n\t\t\t})\r\n\t\t);\r\n\r\n\t\tthis.subscriptions.push(\r\n\t\t\tthis.dashboardService.getRefreshGadget().subscribe((e) => {\r\n\t\t\t\tif (!e) {\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\t\t\t\tconst id = e[\"newId\"];\r\n\t\t\t\tconst config = e[\"config\"];\r\n\t\t\t\tif (id === this.portlet.newId || id === this.portlet.id) {\r\n\t\t\t\t\tthis.pageLoading = false;\r\n\t\t\t\t\tthis.getData(config);\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.getchangePivot().subscribe((updated) => {\r\n\t\t\t\tif (updated === this.portlet.newId) {\r\n\t\t\t\t\tthis.getData();\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.getData();\r\n\t\t\t\t\tif (this.pivotObj) this.pivotObj.refreshData();\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((updated) => {\r\n\t\t\t\tif (updated === this.portlet.newId) {\r\n\t\t\t\t\tthis.getData();\r\n\t\t\t\t\tif (this.pivotObj) this.pivotObj.refreshData();\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\r\n\t\t\t\t.clearFieldListObservable()\r\n\t\t\t\t.subscribe((updated) => {\r\n\t\t\t\t\tif (updated === this.portlet.newId) {\r\n\t\t\t\t\t\tthis.pivotObj.dataSourceSettings.dataSource = [];\r\n\t\t\t\t\t\tif (this.pivotObj) this.pivotObj.refreshData();\r\n\t\t\t\t\t\tthis.ref.markForCheck();\r\n\t\t\t\t\t\tthis.ref.detectChanges();\r\n\t\t\t\t\t}\r\n\t\t\t\t})\r\n\t\t);\r\n\r\n\t\tthis.subscriptions.push(\r\n\t\t\tthis.dashboardService\r\n\t\t\t\t.getPvtableDisplayOptionChartChange()\r\n\t\t\t\t.subscribe((data) => {\r\n\t\t\t\t\tif (\r\n\t\t\t\t\t\t!data ||\r\n\t\t\t\t\t\t!this.portlet ||\r\n\t\t\t\t\t\tthis.portlet.newId !== data.newId\r\n\t\t\t\t\t) {\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif (this.chartSettings[\"pointRender\"]) {\r\n\t\t\t\t\t\tthis.chartSettings[\"pointRender\"].complete();\r\n\t\t\t\t\t}\r\n\t\t\t\t\tthis.initChartSetting(data.chartType);\r\n\t\t\t\t\tthis.setConfigToPorlet();\r\n\t\t\t\t\tif (this.pivotObj) this.pivotObj.refreshData();\r\n\t\t\t\t})\r\n\t\t);\r\n\r\n\t\tthis.subscriptions.push(\r\n\t\t\tthis.dashboardService\r\n\t\t\t\t.getEnableMultipleAxisChange()\r\n\t\t\t\t.subscribe((data) => {\r\n\t\t\t\t\tif (\r\n\t\t\t\t\t\t!data ||\r\n\t\t\t\t\t\t!this.portlet ||\r\n\t\t\t\t\t\tthis.portlet.newId !== data.newId\r\n\t\t\t\t\t) {\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif (this.chartSettings[\"pointRender\"]) {\r\n\t\t\t\t\t\tthis.chartSettings[\"pointRender\"].complete();\r\n\t\t\t\t\t}\r\n\t\t\t\t\tthis.chartSettings.enableMultipleAxis =\r\n\t\t\t\t\t\tdata.enableMultipleAxis;\r\n\r\n\t\t\t\t\tthis.chartSettings.multipleAxisMode = data.multipleAxisMode;\r\n\r\n\t\t\t\t\tthis.chartSettings.legendSettings = {\r\n\t\t\t\t\t\tvisible: data.visible,\r\n\t\t\t\t\t};\r\n\t\t\t\t\tthis.chartSettings = Object.assign({}, this.chartSettings);\r\n\t\t\t\t\tif (this.pivotObj)\r\n\t\t\t\t\t\tsetTimeout(() => this.pivotObj.refreshData());\r\n\t\t\t\t\tthis.setConfigToPorlet();\r\n\t\t\t\t})\r\n\t\t);\r\n\r\n\t\tthis.subscriptions.push(\r\n\t\t\tthis.dashboardService.getChartTypeChange().subscribe((data) => {\r\n\t\t\t\tif (\r\n\t\t\t\t\t!data ||\r\n\t\t\t\t\t!this.portlet ||\r\n\t\t\t\t\tthis.portlet.newId !== data.newId\r\n\t\t\t\t) {\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\t\t\t\tthis.chartSettings.chartSeries.type =\r\n\t\t\t\t\tdata.chartSettings.chartSeries.type === \"Stacked Column\"\r\n\t\t\t\t\t\t? \"StackingColumn\"\r\n\t\t\t\t\t\t: data.chartSettings.chartSeries.type;\r\n\t\t\t\tthis.chartSettings = Object.assign({}, this.chartSettings);\r\n\t\t\t\tif (this.pivotObj) this.pivotObj.refreshData();\r\n\t\t\t\tthis.setConfigToPorlet();\r\n\t\t\t})\r\n\t\t);\r\n\r\n\t\tthis.subscriptions.push(\r\n\t\t\tthis.dashboardService.getTheme().subscribe((data) => {\r\n\t\t\t\tif (\r\n\t\t\t\t\t!data ||\r\n\t\t\t\t\t!this.portlet ||\r\n\t\t\t\t\tthis.portlet.newId !== data.newId\r\n\t\t\t\t) {\r\n\t\t\t\t\treturn;\r\n\t\t\t\t}\r\n\t\t\t\tthis.chartSettings.palettes = [...data.theme];\r\n\t\t\t\tthis.chartSettings = Object.assign({}, this.chartSettings);\r\n\t\t\t\tif (this.pivotObj) this.pivotObj.layoutRefresh();\r\n\t\t\t\tthis.setConfigToPorlet();\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\t// 找到数组中出现最多频次的元素\r\n\tfindMostFrequent(arr) {\r\n\t\tlet maxCount = 0;\r\n\t\tlet mostFrequentNum = null;\r\n\r\n\t\t// 使用一个对象来计数\r\n\t\tconst countMap = {};\r\n\r\n\t\tarr.forEach((num) => {\r\n\t\t\tcountMap[num] = (countMap[num] || 0) + 1;\r\n\r\n\t\t\t// 检查是否是最多的\r\n\t\t\tif (countMap[num] > maxCount) {\r\n\t\t\t\tmaxCount = countMap[num];\r\n\t\t\t\tmostFrequentNum = num;\r\n\t\t\t}\r\n\t\t});\r\n\r\n\t\treturn mostFrequentNum;\r\n\t}\r\n\r\n\tloaded(args) {\r\n\t\t// 找到所有y轴标签\r\n\t\tconst elements = document.querySelectorAll(\r\n\t\t\t`[id^=\"${this.pivotObj.element.id}_chart2_AxisLabel\"],\r\n\t\t\t[id^=\"${this.pivotObj.element.id}_chart3_AxisLabel\"]`\r\n\t\t);\r\n\t\tlet isErrorAccuracy = false;\r\n\t\tlet xPosition = [];\r\n\t\telements.forEach((element) => {\r\n\t\t\t// 是否有精度问题\r\n\t\t\tif (\r\n\t\t\t\tBoolean(Number(element.innerHTML)) &&\r\n\t\t\t\telement.innerHTML.length > 15\r\n\t\t\t) {\r\n\t\t\t\tisErrorAccuracy = true;\r\n\t\t\t}\r\n\t\t\t// 记录一下y轴标签的x坐标\r\n\t\t\tconst currentX = parseFloat(element.getAttribute(\"x\"));\r\n\t\t\txPosition.push(currentX);\r\n\r\n\t\t\tif (element.innerHTML.endsWith(\"...\")) {\r\n\t\t\t\tlet innerHTML = element.innerHTML.replace(\"...\", \"\");\r\n\t\t\t\telement.innerHTML = Number(innerHTML).toFixed(2);\r\n\t\t\t\telement.setAttribute(\r\n\t\t\t\t\t\"x\",\r\n\t\t\t\t\tcurrentX + innerHTML.length * 3 - 3 + \"\"\r\n\t\t\t\t); // 矫正长度\r\n\t\t\t}\r\n\t\t});\r\n\t\tif (isErrorAccuracy) {\r\n\t\t\t// 找到所有y轴标签中的平均x坐标\r\n\t\t\tlet x = mean(xPosition);\r\n\t\t\telements.forEach((element) => {\r\n\t\t\t\t// 手动精度修正\r\n\t\t\t\telement.innerHTML = Number(element.innerHTML).toFixed(2);\r\n\t\t\t\tif (element.innerHTML === \"-0.00\") {\r\n\t\t\t\t\telement.innerHTML = Number(0).toFixed(2);\r\n\t\t\t\t}\r\n\t\t\t\t// 手动设置 x坐标\r\n\t\t\t\telement.setAttribute(\"x\", x.toString());\r\n\t\t\t});\r\n\t\t}\r\n\t}\r\n\r\n\tprivate setConfigToPorlet() {\r\n\t\tconst config = JSON.parse(this.portlet.config);\r\n\t\tif (!config) {\r\n\t\t\treturn;\r\n\t\t}\r\n\t\tconfig.pvtableChartSetting = {\r\n\t\t\tdisplayOption: this.displayOption,\r\n\t\t\tchartSettings: this.chartSettings,\r\n\t\t};\r\n\t\tthis.chartSettings[\"pointRender\"] = null;\r\n\t\tthis.config = { ...config };\r\n\t\tthis.updatePorletConfig.emit({\r\n\t\t\tnewId: this.portlet.newId,\r\n\t\t\tconfig,\r\n\t\t});\r\n\t}\r\n\r\n\tchartSeriesCreated(e) {}\r\n\r\n\tprivate initChartSetting(type?: string) {\r\n\t\tconst setting = this.config.pvtableChartSetting;\r\n\t\tif (!setting) {\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tsetting.chartSettings.chartSeries.dataLabel = {\r\n\t\t\tvisible: true, // Make the data label visible\r\n\t\t\tposition: \"Outside\", // Position the data label outside the chart\r\n\t\t\t// Define the template for data label content\r\n\t\t\ttemplate:\r\n\t\t\t\t'<div style=\"color: Black\"> ${(point.y).toLocaleString()}</div>',\r\n\t\t};\r\n\t\tthis.chartSettings = {\r\n\t\t\t...setting.chartSettings,\r\n\t\t\tprimaryXAxis: {\r\n\t\t\t\ttitle: \" \",\r\n\t\t\t\tlabelFormat: \"N2\",\r\n\t\t\t\tmajorGridLines: { width: 0 },\r\n\t\t\t\tminorGridLines: {\r\n\t\t\t\t\twidth: 0,\r\n\t\t\t\t\tcolor: \"transparent\",\r\n\t\t\t\t\tvisible: false,\r\n\t\t\t\t},\r\n\t\t\t\tminorTickLines: { visible: false },\r\n\t\t\t\tlineStyle: {\r\n\t\t\t\t\twidth: 0,\r\n\t\t\t\t},\r\n\t\t\t},\r\n\t\t\tpointRender: this.observable.subscribe((args: any) => {\r\n\t\t\t\tif (args && args.point && args.point.y) {\r\n\t\t\t\t\targs.point.y = parseFloat(args.point.y.toFixed(2));\r\n\t\t\t\t}\r\n\t\t\t}) as any,\r\n\t\t\tchartArea: {\r\n\t\t\t\topacity: 0,\r\n\t\t\t\tborder: {\r\n\t\t\t\t\twidth: 0,\r\n\t\t\t\t},\r\n\t\t\t},\r\n\t\t\tprimaryYAxis: {\r\n\t\t\t\t// Y轴标题设置为空\r\n\t\t\t\ttitle: \" \",\r\n\t\t\t\tlabelFormat: \"N2\",\r\n\t\t\t},\r\n\t\t\tloaded: this.isloaded\r\n\t\t\t\t? null\r\n\t\t\t\t: (this.observable.subscribe(this.loaded.bind(this)) as any),\r\n\t\t\tzoomSettings: {\r\n\t\t\t\tenableMouseWheelZooming: false, // 禁用鼠标滚轮缩放\r\n\t\t\t\tenablePinchZooming: false, // 禁用触摸缩放\r\n\t\t\t\tenableSelectionZooming: false, // 禁用选择区域缩放\r\n\t\t\t\tenableDeferredZooming: false, // 禁用延迟缩放\r\n\t\t\t\ttoolbarItems: [],\r\n\t\t\t\tenableScrollbar: false,\r\n\t\t\t\tenableZooming: false,\r\n\t\t\t},\r\n\t\t};\r\n\t\tthis.isloaded = true;\r\n\t\t// @ts-ignore\r\n\t\tif (!this.chartSettings.palettes) {\r\n\t\t\tthis.chartSettings.palettes = [\r\n\t\t\t\t\"#594bb9\",\r\n\t\t\t\t\"#f1af32\",\r\n\t\t\t\t\"#4688ed\",\r\n\t\t\t\t\"#e0563e\",\r\n\t\t\t\t\"#803a63\",\r\n\t\t\t\t\"#6dd8b5\",\r\n\t\t\t\t\"#e87225\",\r\n\t\t\t\t\"#c5df42\",\r\n\t\t\t\t\"#c6437d\",\r\n\t\t\t];\r\n\t\t}\r\n\t\tthis.chartSettings.chartSeries.columnSpacing = 0.1;\r\n\t\tthis.chartSettings.chartSeries.columnWidth = 0.9;\r\n\t\tif (type) {\r\n\t\t\tthis.chartSettings.chartSeries = {\r\n\t\t\t\ttype,\r\n\t\t\t\tcolumnSpacing: 0.1,\r\n\t\t\t\tcolumnWidth: 0.9,\r\n\t\t\t};\r\n\t\t}\r\n\t}\r\n\r\n\tonMemberEditorOpen(args: any): void {\r\n\t\t// 你可以在这里根据需要修改args来自定义过滤窗口的行为\r\n\t\t// 11247 专门为item data type而设置\r\n\t\tif (args.fieldName === \"AccountTypeCode\") {\r\n\t\t\tlet res = new Array(5).fill(null);\r\n\t\t\tconst fieldMembers = [...args.fieldMembers];\r\n\r\n\t\t\tfor (let i = fieldMembers.length - 1; i >= 0; i--) {\r\n\t\t\t\tlet index = -1;\r\n\t\t\t\tconst item = this.itemDataTypeSortArr.find((name, ind) => {\r\n\t\t\t\t\tif (fieldMembers[i].actualText === name) {\r\n\t\t\t\t\t\tindex = ind;\r\n\t\t\t\t\t}\r\n\t\t\t\t\treturn fieldMembers[i].actualText === name;\r\n\t\t\t\t});\r\n\t\t\t\tif (!item) {\r\n\t\t\t\t\tcontinue;\r\n\t\t\t\t}\r\n\t\t\t\tconst fillItem = fieldMembers.splice(i, 1);\r\n\t\t\t\tres[index] = fillItem[0];\r\n\t\t\t}\r\n\t\t\tres = res.filter((item) => item) || [];\r\n\t\t\targs.fieldMembers = [...res, ...fieldMembers];\r\n\t\t\tsetTimeout(() => {\r\n\t\t\t\tconst ele = document.querySelector(\".e-member-editor-dialog\");\r\n\t\t\t\tif (ele) {\r\n\t\t\t\t\tele.querySelector(\".e-filter-sort\").setAttribute(\r\n\t\t\t\t\t\t\"style\",\r\n\t\t\t\t\t\t\"display: none\"\r\n\t\t\t\t\t);\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t\t}\r\n\t}\r\n\r\n\tbeforeExport(exportData) {\r\n\t\tif (exportData) {\r\n\t\t\tconst keyMap = {};\r\n\t\t\tthis.dataSourceSettings.formatSettings.forEach((data) => {\r\n\t\t\t\tif (\r\n\t\t\t\t\tdata.format === \"#,###,,.0;(#,###,,.0)\" ||\r\n\t\t\t\t\tdata.format === \"#,###,,;(#,###,,)\" ||\r\n\t\t\t\t\tdata.format === \"#,###,,.00;(#,###,,.00)\"\r\n\t\t\t\t) {\r\n\t\t\t\t\tkeyMap[data.name] = true;\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t\t\tif (\r\n\t\t\t\texportData.dataCollections &&\r\n\t\t\t\texportData.dataCollections.length\r\n\t\t\t) {\r\n\t\t\t\texportData.dataCollections[0].forEach((row) => {\r\n\t\t\t\t\trow.forEach((cell) => {\r\n\t\t\t\t\t\tif (keyMap[cell.actualText]) {\r\n\t\t\t\t\t\t\tcell.value = cell.actualValue;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t});\r\n\t\t\t\t});\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tprivate async getData(config?: any) {\r\n\t\tthis.pageLoading = false;\r\n\t\tlet columns = [];\r\n\t\tlet values = [];\r\n\t\tlet formatSettings = [];\r\n\t\tlet rows = [];\r\n\t\tlet fieldMapping = [];\r\n\t\t// 清空grandTotals和subTotals\r\n\t\tthis.grandTotals = {};\r\n\t\tthis.subTotals = {};\r\n\t\tthis.config = config\r\n\t\t\t? JSON.parse(config)\r\n\t\t\t: JSON.parse(this.portlet.config);\r\n\r\n\t\tlet type =\r\n\t\t\tthis.config &&\r\n\t\t\tthis.config.pvtableChartSetting &&\r\n\t\t\tthis.config.pvtableChartSetting.chartSettings\r\n\t\t\t\t? this.config.pvtableChartSetting.chartSettings.chartSeries.type\r\n\t\t\t\t: null;\r\n\t\tif (type && type === \"Stacked Column\") {\r\n\t\t\ttype = \"StackingColumn\";\r\n\t\t}\r\n\t\tthis.initChartSetting(type);\r\n\r\n\t\tif (this.config.fields) {\r\n\t\t\tthis.configFields = JSON.parse(JSON.stringify(this.config.fields));\r\n\t\t}\r\n\r\n\t\tthis.Pivot_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\r\n\t\tthis.orderByColumns = this.dashboardPorletsService.getOrderByColumnsNew(\r\n\t\t\tthis.portlet.figureCode,\r\n\t\t\tthis.dashboard\r\n\t\t);\r\n\r\n\t\tthis.Pivot_Data = DataUtil.parse.parseJson(this.Pivot_Data);\r\n\t\tif (this.Pivot_Data && this.Pivot_Data.length > 0) {\r\n\t\t\tthis.getexcludeFields(this.configFields, this.Pivot_Data[0]);\r\n\t\t\tif (!this.allowedCalculatedFields.length) {\r\n\t\t\t\tthis.allowedCalculatedFields = Object.keys(this.Pivot_Data[0]);\r\n\t\t\t}\r\n\t\t\tfor (let item of this.configFields) {\r\n\t\t\t\tfieldMapping.push({\r\n\t\t\t\t\tname: item.colName,\r\n\t\t\t\t\tcaption: item.addtionName\r\n\t\t\t\t\t\t? `${item.langValue} ${item.addtionName}`\r\n\t\t\t\t\t\t: item.langValue,\r\n\t\t\t\t\tdataType: item.dataType,\r\n\t\t\t\t});\r\n\t\t\t}\r\n\t\t}\r\n\t\tif (this.configFields) {\r\n\t\t\tthis.percentNumFields = [];\r\n\t\t\tthis.formatDates = [];\r\n\t\t\tthis.zeroFormatData.hgList = [];\r\n\t\t\tthis.zeroFormatData.emptyList = [];\r\n\t\t\tthis.millionFields = [];\r\n\t\t\tthis.configFields.map((el) => {\r\n\t\t\t\t// SMP2-2486 & percentNum的format问题\r\n\t\t\t\tif (el.dataType == \"percentNum\") {\r\n\t\t\t\t\tthis.percentNumFields.push(el.colName);\r\n\t\t\t\t}\r\n\t\t\t\tif (\r\n\t\t\t\t\tel.format &&\r\n\t\t\t\t\tel.format.length &&\r\n\t\t\t\t\tel.format[0].formatChecked &&\r\n\t\t\t\t\t[2, 5, 8, 11, 14, 17].includes(el.format[0].selectedFormat)\r\n\t\t\t\t)\r\n\t\t\t\t\tthis.zeroFormatData.hgList.push(el.colName);\r\n\t\t\t\tif (\r\n\t\t\t\t\tel.format &&\r\n\t\t\t\t\tel.format.length &&\r\n\t\t\t\t\tel.format[0].formatChecked &&\r\n\t\t\t\t\t[3, 6, 9, 12, 15, 18].includes(el.format[0].selectedFormat)\r\n\t\t\t\t)\r\n\t\t\t\t\tthis.zeroFormatData.emptyList.push(el.colName);\r\n\t\t\t\tif (\r\n\t\t\t\t\tel.format &&\r\n\t\t\t\t\tel.format.length &&\r\n\t\t\t\t\tel.format[0].formatChecked &&\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.millionFields.push(el.colName);\r\n\t\t\t\tif (\r\n\t\t\t\t\tel.dataType === \"number\" &&\r\n\t\t\t\t\t(!el.format ||\r\n\t\t\t\t\t\t(el.format &&\r\n\t\t\t\t\t\t\tel.format.length &&\r\n\t\t\t\t\t\t\t!el.format[0].formatChecked))\r\n\t\t\t\t) {\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\t//SMP2-3026 and SMP2-3059\r\n\t\t\t\t\t\tformat:\r\n\t\t\t\t\t\t\tel.colName !== \"PortInvStk\" &&\r\n\t\t\t\t\t\t\tel.colName !== \"PortFdInvStk\"\r\n\t\t\t\t\t\t\t\t? this.dashboardPorletsService.formatNumber(\r\n\t\t\t\t\t\t\t\t\t\tel.dp\r\n\t\t\t\t\t\t\t\t  )\r\n\t\t\t\t\t\t\t\t: \"##0.#######0\",\r\n\t\t\t\t\t\tuseGrouping: true,\r\n\t\t\t\t\t};\r\n\t\t\t\t\tformatSettings.push(formatData);\r\n\t\t\t\t}\r\n\t\t\t\tif (\r\n\t\t\t\t\t(el.dataType === \"percent\" ||\r\n\t\t\t\t\t\tel.dataType === \"percentNum\") &&\r\n\t\t\t\t\t(!el.format ||\r\n\t\t\t\t\t\t(el.format &&\r\n\t\t\t\t\t\t\tel.format.length &&\r\n\t\t\t\t\t\t\t!el.format[0].formatChecked))\r\n\t\t\t\t) {\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: this.dashboardPorletsService.formatPercent(\r\n\t\t\t\t\t\t\tel.dp\r\n\t\t\t\t\t\t),\r\n\t\t\t\t\t};\r\n\t\t\t\t\tformatSettings.push(formatData);\r\n\t\t\t\t}\r\n\t\t\t\tif (\r\n\t\t\t\t\tel.dataType === \"multiple\" &&\r\n\t\t\t\t\t(!el.format ||\r\n\t\t\t\t\t\t(el.format &&\r\n\t\t\t\t\t\t\tel.format.length &&\r\n\t\t\t\t\t\t\t!el.format[0].formatChecked))\r\n\t\t\t\t) {\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: this.dashboardPorletsService.formatMultiple(\r\n\t\t\t\t\t\t\tel.dp\r\n\t\t\t\t\t\t),\r\n\t\t\t\t\t};\r\n\t\t\t\t\tformatSettings.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\tswitch (format_) {\r\n\t\t\t\t\t\t\t\tcase \"DD/MM/YYYY\":\r\n\t\t\t\t\t\t\t\t\tformat = \"dd/MM/yyyy\";\r\n\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t\tcase \"DD/MM/YY\":\r\n\t\t\t\t\t\t\t\t\tformat = \"dd/MM/yy\";\r\n\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t\tcase \"MM/DD/YYYY\":\r\n\t\t\t\t\t\t\t\t\tformat = \"MM/dd/yyyy\";\r\n\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t\tcase \"MM/DD/YY\":\r\n\t\t\t\t\t\t\t\t\tformat = \"MM/dd/yy\";\r\n\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t\tcase \"YYYY-MM-DD\":\r\n\t\t\t\t\t\t\t\t\tformat = \"yyyy-MM-dd\";\r\n\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t\tcase \"YY-MM-DD\":\r\n\t\t\t\t\t\t\t\t\tformat = \"yy-MM-dd\";\r\n\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t\tcase \"DD-MM-YYYY\":\r\n\t\t\t\t\t\t\t\t\tformat = \"dd-MM-yyyy\";\r\n\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t\tcase \"DD-MM-YY\":\r\n\t\t\t\t\t\t\t\t\tformat = \"dd-MM-yy\";\r\n\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t\tcase \"MM-DD-YYYY\":\r\n\t\t\t\t\t\t\t\t\tformat = \"MM-dd-yyyy\";\r\n\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t\tcase \"MM-DD-YY\":\r\n\t\t\t\t\t\t\t\t\tformat = \"MM-dd-yy\";\r\n\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t\tcase \"MMM DD, YYYY\":\r\n\t\t\t\t\t\t\t\t\tformat = \"MMM dd, yyyy\";\r\n\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t\tcase \"DD-MMM-YYYY\":\r\n\t\t\t\t\t\t\t\t\tformat = \"dd-MMM-yyyy\";\r\n\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t\tdefault:\r\n\t\t\t\t\t\t\t\t\tbreak;\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\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\tformatSettings.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\tformatSettings.push(formatData);\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t\t}\r\n\t\t//calculatedFieldSettings format push to formatSettings\r\n\t\tif (\r\n\t\t\tthis.config.calculatedFieldSettings &&\r\n\t\t\tthis.config.calculatedFieldSettings.length > 0\r\n\t\t) {\r\n\t\t\tthis.config.calculatedFieldSettings.map((el) => {\r\n\t\t\t\tif (el.formatString !== \"\") {\r\n\t\t\t\t\tformatSettings.push({\r\n\t\t\t\t\t\tname: el.name,\r\n\t\t\t\t\t\tformat: el.formatString,\r\n\t\t\t\t\t});\r\n\t\t\t\t}\r\n\t\t\t});\r\n\t\t}\r\n\t\tlet series = this.config.yaxis.series;\r\n\t\tif (series) {\r\n\t\t\tfor (let item of series) {\r\n\t\t\t\tconst value = {\r\n\t\t\t\t\tname: item.colName,\r\n\t\t\t\t\tcaption: item.title,\r\n\t\t\t\t\ttype: item.calMethod,\r\n\t\t\t\t};\r\n\t\t\t\tvalues.push(value);\r\n\t\t\t}\r\n\t\t}\r\n\t\tlet groups = this.config.xaxis.groups;\r\n\t\tif (groups) {\r\n\t\t\tfor (let gitem of groups) {\r\n\t\t\t\tconst field = this.configFields.filter(\r\n\t\t\t\t\t(el) => el.colName === gitem.name\r\n\t\t\t\t);\r\n\t\t\t\tif (field.length > 0) {\r\n\t\t\t\t\tgitem.showSubTotals = field[0].showSubTotals;\r\n\t\t\t\t}\r\n\t\t\t\trows.push(gitem);\r\n\t\t\t}\r\n\t\t}\r\n\t\tif (this.config.columnGroup && this.config.columnGroup.length) {\r\n\t\t\tfor (let item of this.config.columnGroup) {\r\n\t\t\t\tconst field = this.configFields.filter(\r\n\t\t\t\t\t(el) => el.colName === item.name\r\n\t\t\t\t);\r\n\t\t\t\tif (field.length > 0) {\r\n\t\t\t\t\titem.showSubTotals = field[0].showSubTotals;\r\n\t\t\t\t}\r\n\t\t\t\tcolumns.push(item);\r\n\t\t\t}\r\n\t\t}\r\n\t\tlet conditionalFormatSettings = [];\r\n\t\tthis.configFields.forEach((field) => {\r\n\t\t\tif (field.format && field.format.length) {\r\n\t\t\t\tif (field.format[0].fontSettingChecked) {\r\n\t\t\t\t\tlet conditionalFormatObj = {\r\n\t\t\t\t\t\tapplyGrandTotals: true,\r\n\t\t\t\t\t\tmeasure: \"\",\r\n\t\t\t\t\t\tvalue1: null,\r\n\t\t\t\t\t\tvalue2: null,\r\n\t\t\t\t\t\tconditions: \"\",\r\n\t\t\t\t\t\tstyle: {\r\n\t\t\t\t\t\t\tbackgroundColor: \"\",\r\n\t\t\t\t\t\t\tcolor: \"\",\r\n\t\t\t\t\t\t\tfontFamily: \"\",\r\n\t\t\t\t\t\t\tfontSize: \"\",\r\n\t\t\t\t\t\t},\r\n\t\t\t\t\t};\r\n\t\t\t\t\tlet negaConditionalFormatObj = {\r\n\t\t\t\t\t\tapplyGrandTotals: true,\r\n\t\t\t\t\t\tmeasure: \"\",\r\n\t\t\t\t\t\tvalue1: null,\r\n\t\t\t\t\t\tvalue2: null,\r\n\t\t\t\t\t\tconditions: \"\",\r\n\t\t\t\t\t\tstyle: {\r\n\t\t\t\t\t\t\tbackgroundColor: \"\",\r\n\t\t\t\t\t\t\tcolor: \"\",\r\n\t\t\t\t\t\t\tfontFamily: \"\",\r\n\t\t\t\t\t\t\tfontSize: \"\",\r\n\t\t\t\t\t\t},\r\n\t\t\t\t\t};\r\n\t\t\t\t\t// font setting start\r\n\t\t\t\t\tnegaConditionalFormatObj.measure =\r\n\t\t\t\t\t\tfield.format[0].selectedField;\r\n\t\t\t\t\tconditionalFormatObj.measure =\r\n\t\t\t\t\t\tfield.format[0].selectedField;\r\n\r\n\t\t\t\t\tif (\r\n\t\t\t\t\t\tfield.format[0].formatChecked &&\r\n\t\t\t\t\t\tfield.format[0].compareSelect\r\n\t\t\t\t\t) {\r\n\t\t\t\t\t\tthis.setCompareConditional(\r\n\t\t\t\t\t\t\tnegaConditionalFormatObj,\r\n\t\t\t\t\t\t\tconditionalFormatObj,\r\n\t\t\t\t\t\t\tfield.format[0]\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tdelete conditionalFormatObj.value2;\r\n\t\t\t\t\t\tdelete negaConditionalFormatObj.value2;\r\n\t\t\t\t\t\tnegaConditionalFormatObj.value1 = 0;\r\n\t\t\t\t\t\tnegaConditionalFormatObj.conditions = \"LessThan\";\r\n\t\t\t\t\t\tconditionalFormatObj.value1 = 0;\r\n\t\t\t\t\t\tconditionalFormatObj.conditions = \"GreaterThan\";\r\n\t\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\t\tnegaConditionalFormatObj,\r\n\t\t\t\t\t\t\tfield.format[0],\r\n\t\t\t\t\t\t\t-1\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\t\tconditionalFormatObj,\r\n\t\t\t\t\t\t\tfield.format[0],\r\n\t\t\t\t\t\t\t1\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t}\r\n\t\t\t\t\tconditionalFormatSettings.push(negaConditionalFormatObj);\r\n\t\t\t\t\tconditionalFormatSettings.unshift(conditionalFormatObj);\r\n\t\t\t\t\t// font setting end\r\n\t\t\t\t}\r\n\t\t\t\tlet formatSettingsObj = {\r\n\t\t\t\t\tname: \"\",\r\n\t\t\t\t\tformat: \"\",\r\n\t\t\t\t};\r\n\t\t\t\tif (field.format[0].formatChecked) {\r\n\t\t\t\t\tformatSettingsObj.name = field.format[0].selectedField;\r\n\t\t\t\t\tformatSettingsObj.format =\r\n\t\t\t\t\t\tthis.dashboardPorletsService.pivotTableformatNumber(\r\n\t\t\t\t\t\t\tfield.format[0].selectedFormat\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\tswitch (field.format[0].dataType) {\r\n\t\t\t\t\t\tcase \"number\":\r\n\t\t\t\t\t\t\tformatSettingsObj.format =\r\n\t\t\t\t\t\t\t\tthis.dashboardPorletsService.pivotTableformatNumber(\r\n\t\t\t\t\t\t\t\t\tfield.format[0].selectedFormat\r\n\t\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\tcase \"integer\":\r\n\t\t\t\t\t\t\tformatSettingsObj.format =\r\n\t\t\t\t\t\t\t\tthis.dashboardPorletsService.pivotTableformatInteger(\r\n\t\t\t\t\t\t\t\t\tfield.format[0].selectedFormat\r\n\t\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\tcase \"percentNum\":\r\n\t\t\t\t\t\tcase \"percent\":\r\n\t\t\t\t\t\t\tformatSettingsObj.format =\r\n\t\t\t\t\t\t\t\tthis.dashboardPorletsService.pivotTableformatPercent(\r\n\t\t\t\t\t\t\t\t\tfield.format[0].selectedFormat\r\n\t\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\tcase \"multiple\":\r\n\t\t\t\t\t\t\tformatSettingsObj.format =\r\n\t\t\t\t\t\t\t\tthis.dashboardPorletsService.pivotTableformatMultiple(\r\n\t\t\t\t\t\t\t\t\tfield.format[0].selectedFormat\r\n\t\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\tcase \"date\":\r\n\t\t\t\t\t\tcase \"datetime\":\r\n\t\t\t\t\t\t\tlet format = \"\";\r\n\t\t\t\t\t\t\tif (field.format && field.format.length) {\r\n\t\t\t\t\t\t\t\tif (field.format[0].dateType == \"Quarter\") {\r\n\t\t\t\t\t\t\t\t\tformat =\r\n\t\t\t\t\t\t\t\t\t\tfield.format[0].selectedFormatDisplay;\r\n\t\t\t\t\t\t\t\t} else if (field.format[0].dateType == \"Date\") {\r\n\t\t\t\t\t\t\t\t\tlet fromIdx =\r\n\t\t\t\t\t\t\t\t\t\tfield.format[0].selectedFormatDisplay.indexOf(\r\n\t\t\t\t\t\t\t\t\t\t\t\"(\"\r\n\t\t\t\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\t\t\tlet toIdx =\r\n\t\t\t\t\t\t\t\t\t\tfield.format[0].selectedFormatDisplay.indexOf(\r\n\t\t\t\t\t\t\t\t\t\t\t\")\"\r\n\t\t\t\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\t\t\tformat =\r\n\t\t\t\t\t\t\t\t\t\tfield.format[0].selectedFormatDisplay.slice(\r\n\t\t\t\t\t\t\t\t\t\t\tfromIdx + 1,\r\n\t\t\t\t\t\t\t\t\t\t\ttoIdx\r\n\t\t\t\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\tif (format) {\r\n\t\t\t\t\t\t\t\tformatSettingsObj = {\r\n\t\t\t\t\t\t\t\t\tname: field.colName,\r\n\t\t\t\t\t\t\t\t\tformat: \"\",\r\n\t\t\t\t\t\t\t\t};\r\n\t\t\t\t\t\t\t\t// field.dataType = \"string\";\r\n\t\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\t\tformatSettingsObj.format = this.datePipeFormat;\r\n\t\t\t\t\t\t\t\tformatSettingsObj[\"type\"] = \"date\";\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\tdefault:\r\n\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\tif (\r\n\t\t\t\t\tfield.format[0].dataType !== \"string\" &&\r\n\t\t\t\t\tformatSettingsObj.format\r\n\t\t\t\t) {\r\n\t\t\t\t\tformatSettings.push(formatSettingsObj);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t});\r\n\t\tthis.customCalculatedFields = this.config.customCalculatedFields\r\n\t\t\t? this.config.customCalculatedFields\r\n\t\t\t: [];\r\n\r\n\t\t// SMP2-4582 AGIC - Dashboard item sequence\r\n\t\tlet isExistSeq = false;\r\n\t\tlet sortSettings = this.config.sortSettings || [];\r\n\t\tif (\r\n\t\t\tthis.Pivot_Data &&\r\n\t\t\tthis.Pivot_Data[0] &&\r\n\t\t\tthis.Pivot_Data[0].Seq !== null\r\n\t\t) {\r\n\t\t\t// 取消Name的默认排序，根据Seq来排序\r\n\t\t\tsortSettings.push({ name: \"Name\", order: \"None\" });\r\n\t\t\tisExistSeq = true;\r\n\t\t}\r\n\t\tlet filterSettings = this.dashboardPorletsService.checkFilterSettings(\r\n\t\t\tthis.config,\r\n\t\t\tthis.configFields,\r\n\t\t\tthis.Pivot_Data\r\n\t\t);\r\n\t\tlet nameFilter = filterSettings.find((x) => x.name === \"Name\");\r\n\t\t// 存在 Name的filter时，会按照默认排序，需要对Name进行Seq排序处理\r\n\t\tif (isExistSeq && nameFilter && rows.some((x) => x.name === \"Name\")) {\r\n\t\t\tlet items = nameFilter.items; // 拿到当前排序，默认A-Z\r\n\t\t\tlet seqArr = [];\r\n\t\t\titems.forEach((name) => {\r\n\t\t\t\tlet obj = this.Pivot_Data.find((x) => x.Name === name);\r\n\t\t\t\tlet item: any = {\r\n\t\t\t\t\tname: name,\r\n\t\t\t\t\tseq: obj.Seq,\r\n\t\t\t\t};\r\n\t\t\t\tseqArr.push(item);\r\n\t\t\t});\r\n\t\t\tseqArr.sort((a, b) => a.seq - b.seq);\r\n\t\t\tnameFilter.items = seqArr.map((x) => x.name);\r\n\t\t}\r\n\t\tlet hasItemDataType = false;\r\n\t\tif (this.Pivot_Data) {\r\n\t\t\tthis.Pivot_Data.map((data) => {\r\n\t\t\t\tif (data[\"AccountTypeCode\"]) {\r\n\t\t\t\t\thasItemDataType = true;\r\n\t\t\t\t}\r\n\t\t\t\trows.forEach((row) => {\r\n\t\t\t\t\tif (data[row.name] === \"\") {\r\n\t\t\t\t\t\tdata[row.name] = \"null\";\r\n\t\t\t\t\t}\r\n\t\t\t\t});\r\n\t\t\t});\r\n\t\t}\r\n\t\tif (hasItemDataType) {\r\n\t\t\tsortSettings.push({\r\n\t\t\t\tname: \"AccountTypeCode\",\r\n\t\t\t\torder: \"Ascending\",\r\n\t\t\t\tmembersOrder: [...this.itemDataTypeSortArr],\r\n\t\t\t});\r\n\t\t}\r\n\t\tthis.dataSourceSettings = {\r\n\t\t\tdataSource: this.Pivot_Data,\r\n\t\t\trows: rows,\r\n\t\t\tcolumns: columns,\r\n\t\t\tvalues: values,\r\n\t\t\tfilters: this.config.filters,\r\n\t\t\tfilterSettings: filterSettings,\r\n\t\t\texcludeFields: this.excludeFields,\r\n\t\t\tformatSettings: formatSettings,\r\n\t\t\tconditionalFormatSettings: conditionalFormatSettings,\r\n\t\t\texpandAll: true,\r\n\t\t\tenableSorting: true,\r\n\t\t\tfieldMapping: fieldMapping,\r\n\t\t\tcalculatedFieldSettings: this.config.calculatedFieldSettings,\r\n\t\t\tsortSettings: sortSettings,\r\n\t\t\tvalueSortSettings: this.config.valueSortSettings,\r\n\t\t\tshowGrandTotals: this.config.showGrandTotals,\r\n\t\t\tshowRowGrandTotals: this.config.showRowGrandTotals,\r\n\t\t\tshowColumnGrandTotals: this.config.showColumnGrandTotals,\r\n\t\t\tshowSubTotals: this.config.showSubTotals,\r\n\t\t\tshowRowSubTotals: this.config.showRowSubTotals,\r\n\t\t\tshowColumnSubTotals: this.config.showColumnSubTotals,\r\n\t\t};\r\n\t\tif (this.pivotObj) this.pivotObj.refreshData();\r\n\t\tthis.ref.markForCheck();\r\n\t}\r\n\r\n\tpublic afterPopulate(args: EnginePopulatedEventArgs): void {\r\n\t\tthis.tempSubtotals = [];\r\n\t\tthis.grandTotals = {};\r\n\t\tthis.subTotals = {};\r\n\t\tlet tempshowArray = [];\r\n\t\tthis.config.yaxis.series.forEach((item) => {\r\n\t\t\tif (\r\n\t\t\t\titem.hasOwnProperty(\"showSubTotals\") &&\r\n\t\t\t\titem.hasOwnProperty(\"showGrandTotals\")\r\n\t\t\t) {\r\n\t\t\t\ttempshowArray.push({\r\n\t\t\t\t\tname: item.colName,\r\n\t\t\t\t\tcalMethod: item.calMethod,\r\n\t\t\t\t\tshowSubTotals: item.showSubTotals,\r\n\t\t\t\t\tshowGrandTotals: item.showGrandTotals,\r\n\t\t\t\t});\r\n\t\t\t} else {\r\n\t\t\t\tif (item.hasOwnProperty(\"showGrandTotals\")) {\r\n\t\t\t\t\ttempshowArray.push({\r\n\t\t\t\t\t\tname: item.colName,\r\n\t\t\t\t\t\tcalMethod: item.calMethod,\r\n\t\t\t\t\t\tshowGrandTotals: item.showGrandTotals,\r\n\t\t\t\t\t});\r\n\t\t\t\t}\r\n\t\t\t\tif (item.hasOwnProperty(\"showSubTotals\")) {\r\n\t\t\t\t\ttempshowArray.push({\r\n\t\t\t\t\t\tname: item.colName,\r\n\t\t\t\t\t\tcalMethod: item.calMethod,\r\n\t\t\t\t\t\tshowSubTotals: item.showSubTotals,\r\n\t\t\t\t\t});\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t});\r\n\r\n\t\tif (this.fieldlistObj && this.pivotObj) {\r\n\t\t\tthis.config.columnGroup = [];\r\n\t\t\tthis.config.xaxis.groups = [];\r\n\t\t\tthis.config.yaxis.series = [];\r\n\t\t\tthis.config.filters = [];\r\n\t\t\tthis.config.filterSettings = [];\r\n\t\t\tthis.config.calculatedFieldSettings = [];\r\n\t\t\tlet groupSettings = this.getDataSourceSettingsProp(\r\n\t\t\t\tthis.fieldlistObj,\r\n\t\t\t\t\"groupSettings\"\r\n\t\t\t);\r\n\t\t\tlet columns = this.getDataSourceSettingsProp(\r\n\t\t\t\tthis.fieldlistObj,\r\n\t\t\t\t\"columns\"\r\n\t\t\t);\r\n\t\t\tlet rows = this.getDataSourceSettingsProp(\r\n\t\t\t\tthis.fieldlistObj,\r\n\t\t\t\t\"rows\"\r\n\t\t\t);\r\n\t\t\tlet filters = this.getDataSourceSettingsProp(\r\n\t\t\t\tthis.fieldlistObj,\r\n\t\t\t\t\"filters\"\r\n\t\t\t);\r\n\t\t\tlet filterSettings = this.getDataSourceSettingsProp(\r\n\t\t\t\tthis.fieldlistObj,\r\n\t\t\t\t\"filterSettings\"\r\n\t\t\t);\r\n\t\t\tlet values = this.getDataSourceSettingsProp(\r\n\t\t\t\tthis.fieldlistObj,\r\n\t\t\t\t\"values\"\r\n\t\t\t);\r\n\t\t\tlet sortSettings = this.getDataSourceSettingsProp(\r\n\t\t\t\tthis.fieldlistObj,\r\n\t\t\t\t\"sortSettings\"\r\n\t\t\t);\r\n\t\t\tlet calculatedFieldSettings = this.getDataSourceSettingsProp(\r\n\t\t\t\tthis.fieldlistObj,\r\n\t\t\t\t\"calculatedFieldSettings\"\r\n\t\t\t);\r\n\t\t\tif (groupSettings.length === 0) {\r\n\t\t\t\tfor (let column of columns) {\r\n\t\t\t\t\tthis.config.columnGroup.push({\r\n\t\t\t\t\t\tname: column.name,\r\n\t\t\t\t\t\tcaption: column.caption,\r\n\t\t\t\t\t});\r\n\t\t\t\t}\r\n\t\t\t} else {\r\n\t\t\t\t//If there is a group, first filter the columns of the group field, and then only save the last one\r\n\t\t\t\tfor (let column of columns) {\r\n\t\t\t\t\tif (!startsWith(column.name, groupSettings[0].name + \"_\")) {\r\n\t\t\t\t\t\tthis.config.columnGroup.push({\r\n\t\t\t\t\t\t\tname: column.name,\r\n\t\t\t\t\t\t\tcaption:\r\n\t\t\t\t\t\t\t\tcolumn.name === groupSettings[0].name\r\n\t\t\t\t\t\t\t\t\t? \"\"\r\n\t\t\t\t\t\t\t\t\t: column.caption,\r\n\t\t\t\t\t\t});\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tfor (let row of rows) {\r\n\t\t\t\tthis.config.xaxis.groups.push({\r\n\t\t\t\t\tname: row.name,\r\n\t\t\t\t\tcaption: row.caption,\r\n\t\t\t\t});\r\n\t\t\t}\r\n\t\t\tfor (let filter of filters) {\r\n\t\t\t\tthis.config.filters.push({\r\n\t\t\t\t\tname: filter.name,\r\n\t\t\t\t\tcaption: filter.caption,\r\n\t\t\t\t});\r\n\t\t\t}\r\n\t\t\tif (this.filterSettings && this.filterSettings.length > 0) {\r\n\t\t\t\targs.dataSourceSettings.filterSettings = this.filterSettings;\r\n\t\t\t\tthis.config.filterSettings = this.filterSettings;\r\n\t\t\t\tdelete this.filterSettings;\r\n\t\t\t} else {\r\n\t\t\t\tthis.config.filterSettings = filterSettings;\r\n\t\t\t}\r\n\t\t\tfor (let value of values) {\r\n\t\t\t\tlet seriesData;\r\n\t\t\t\tlet tempShowObj;\r\n\t\t\t\tlet filterTempshowArray = [];\r\n\t\t\t\tif (tempshowArray.length) {\r\n\t\t\t\t\tfilterTempshowArray = tempshowArray.filter(\r\n\t\t\t\t\t\t(item) =>\r\n\t\t\t\t\t\t\titem.name === value.name &&\r\n\t\t\t\t\t\t\titem.calMethod === value.type\r\n\t\t\t\t\t);\r\n\t\t\t\t\tif (filterTempshowArray.length) {\r\n\t\t\t\t\t\ttempShowObj = filterTempshowArray[0];\r\n\t\t\t\t\t\tif (\r\n\t\t\t\t\t\t\ttempShowObj.hasOwnProperty(\"showSubTotals\") &&\r\n\t\t\t\t\t\t\ttempShowObj.hasOwnProperty(\"showGrandTotals\")\r\n\t\t\t\t\t\t) {\r\n\t\t\t\t\t\t\tseriesData = {\r\n\t\t\t\t\t\t\t\tcolName: value.name,\r\n\t\t\t\t\t\t\t\tcalMethod: value.type,\r\n\t\t\t\t\t\t\t\ttitle: value.caption,\r\n\t\t\t\t\t\t\t\tshowSubTotals: tempShowObj.showSubTotals,\r\n\t\t\t\t\t\t\t\tshowGrandTotals: tempShowObj.showGrandTotals,\r\n\t\t\t\t\t\t\t};\r\n\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\tif (tempShowObj.hasOwnProperty(\"showGrandTotals\")) {\r\n\t\t\t\t\t\t\t\tseriesData = {\r\n\t\t\t\t\t\t\t\t\tcolName: value.name,\r\n\t\t\t\t\t\t\t\t\tcalMethod: value.type,\r\n\t\t\t\t\t\t\t\t\ttitle: value.caption,\r\n\t\t\t\t\t\t\t\t\tshowGrandTotals:\r\n\t\t\t\t\t\t\t\t\t\ttempShowObj.showGrandTotals,\r\n\t\t\t\t\t\t\t\t};\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\tif (tempShowObj.hasOwnProperty(\"showSubTotals\")) {\r\n\t\t\t\t\t\t\t\tseriesData = {\r\n\t\t\t\t\t\t\t\t\tcolName: value.name,\r\n\t\t\t\t\t\t\t\t\tcalMethod: value.type,\r\n\t\t\t\t\t\t\t\t\ttitle: value.caption,\r\n\t\t\t\t\t\t\t\t\tshowSubTotals: tempShowObj.showSubTotals,\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}\r\n\t\t\t\tif (!seriesData) {\r\n\t\t\t\t\tseriesData = {\r\n\t\t\t\t\t\tcolName: value.name,\r\n\t\t\t\t\t\ttitle: value.caption,\r\n\t\t\t\t\t\tcalMethod: value.type,\r\n\t\t\t\t\t};\r\n\t\t\t\t}\r\n\t\t\t\tthis.config.yaxis.series.push(seriesData);\r\n\t\t\t}\r\n\t\t\tfor (let calculate of calculatedFieldSettings) {\r\n\t\t\t\tconst calculateData = {\r\n\t\t\t\t\tname: calculate.name,\r\n\t\t\t\t\tformula: calculate.formula,\r\n\t\t\t\t\tformatString:\r\n\t\t\t\t\t\tcalculate.formatString === \"\"\r\n\t\t\t\t\t\t\t? \"N2\"\r\n\t\t\t\t\t\t\t: calculate.formatString,\r\n\t\t\t\t};\r\n\t\t\t\tthis.config.calculatedFieldSettings.push(calculateData);\r\n\t\t\t}\r\n\t\t\tthis.config.customCalculatedFields = this.customCalculatedFields;\r\n\t\t\tthis.config.sortSettings = sortSettings;\r\n\t\t\tthis.config.groupSettings = groupSettings;\r\n\t\t\tthis.fieldlistObj.updateView(this.pivotObj);\r\n\t\t}\r\n\t\tthis.portlet.config = JSON.stringify(this.config);\r\n\t\t//remove the sort\r\n\t\tif (this.pivotObj.dataSourceSettings.sortSettings.length > 0) {\r\n\t\t\tthis.previousSort = this.fieldlistObj.lastSortInfo;\r\n\t\t\t(this.fieldlistObj as any).lastSortInfo = [];\r\n\t\t}\r\n\t}\r\n\r\n\tpublic afterEnginePopulate(args: any) {\r\n\t\tif (!Browser.isDevice && this.fieldlistObj && this.pivotObj) {\r\n\t\t\tthis.config.groupSettings = this.getDataSourceSettingsProp(\r\n\t\t\t\tthis.pivotObj,\r\n\t\t\t\t\"groupSettings\"\r\n\t\t\t);\r\n\t\t\t// this.portlet.config = JSON.stringify(this.config);\r\n\t\t\tif (this.fieldlistObj) this.fieldlistObj.update(this.pivotObj);\r\n\t\t}\r\n\t\tif (this.Pivot_Data && this.Pivot_Data.length) {\r\n\t\t\tsetTimeout(() => {\r\n\t\t\t\tthis.enginePopulated(args);\r\n\t\t\t}, 1500);\r\n\t\t}\r\n\t}\r\n\r\n\tprivate getDataSourceSettingsProp(obj, key) {\r\n\t\tlet prop = null;\r\n\t\tif (obj && obj.dataSourceSettings) {\r\n\t\t\tprop = obj.dataSourceSettings[key];\r\n\t\t\tif (\r\n\t\t\t\tObject.prototype.toString.call(prop) === \"[object Array]\" &&\r\n\t\t\t\tprop.length > 0\r\n\t\t\t) {\r\n\t\t\t\tprop = prop.map((item) => item.properties || item);\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn prop;\r\n\t}\r\n\r\n\tpublic enginePopulating(args) {\r\n\t\tthis.grandTotals = {};\r\n\t\tthis.subTotals = {};\r\n\t\tthis.allDataValue = [];\r\n\t\tif (args.dataSourceSettings.sortSettings.length) {\r\n\t\t\tfor (\r\n\t\t\t\tlet i = 0;\r\n\t\t\t\ti < args.dataSourceSettings.sortSettings.length;\r\n\t\t\t\ti++\r\n\t\t\t) {\r\n\t\t\t\tif (\r\n\t\t\t\t\tthis.fieldlistObj.lastSortInfo &&\r\n\t\t\t\t\tthis.fieldlistObj.lastSortInfo.name ===\r\n\t\t\t\t\t\targs.dataSourceSettings.sortSettings[i].name &&\r\n\t\t\t\t\tthis.fieldlistObj.lastSortInfo.order === \"Ascending\" &&\r\n\t\t\t\t\t!(\r\n\t\t\t\t\t\tthis.fieldlistObj.lastSortInfo.name ===\r\n\t\t\t\t\t\t\tthis.previousSort.name &&\r\n\t\t\t\t\t\tthis.previousSort.order === \"None\"\r\n\t\t\t\t\t)\r\n\t\t\t\t) {\r\n\t\t\t\t\targs.dataSourceSettings.sortSettings[i].order = \"None\";\r\n\t\t\t\t} else if (\r\n\t\t\t\t\tthis.previousSort &&\r\n\t\t\t\t\tthis.fieldlistObj.lastSortInfo &&\r\n\t\t\t\t\tthis.fieldlistObj.lastSortInfo.name ===\r\n\t\t\t\t\t\tthis.previousSort.name &&\r\n\t\t\t\t\tthis.previousSort.order === \"Ascending\"\r\n\t\t\t\t) {\r\n\t\t\t\t\targs.dataSourceSettings.sortSettings[i].order = \"Ascending\";\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tpublic cellClick(args) {\r\n\t\t// 清除排序\r\n\t\tif (\r\n\t\t\tthis.pivotObj.dataSourceSettings.valueSortSettings.sortOrder &&\r\n\t\t\tthis.pivotObj.dataSourceSettings.valueSortSettings.headerText &&\r\n\t\t\tthis.pivotObj.dataSourceSettings.valueSortSettings.sortOrder ===\r\n\t\t\t\t\"Descending\" &&\r\n\t\t\targs.data.valueSort &&\r\n\t\t\tthis.pivotObj.dataSourceSettings.valueSortSettings.headerText ===\r\n\t\t\t\targs.data.valueSort.levelName\r\n\t\t) {\r\n\t\t\tthis.pivotObj.setProperties(\r\n\t\t\t\t{\r\n\t\t\t\t\tdataSourceSettings: {\r\n\t\t\t\t\t\tvalueSortSettings: {\r\n\t\t\t\t\t\t\tsortOrder: \"Descending\",\r\n\t\t\t\t\t\t\theaderText: \"\",\r\n\t\t\t\t\t\t},\r\n\t\t\t\t\t},\r\n\t\t\t\t},\r\n\t\t\t\ttrue\r\n\t\t\t);\r\n\t\t\tif (this.pivotObj) this.pivotObj.refreshData();\r\n\t\t\tthis.config.valueSortSettings = {};\r\n\t\t\tthis.portlet.config = JSON.stringify(this.config);\r\n\t\t}\r\n\t}\r\n\r\n\tpublic dataBound(e) {\r\n\t\tif (this.isInit) {\r\n\t\t\tthis.isInit = false;\r\n\t\t}\r\n\t\tthis.grandTotals = {};\r\n\t\tthis.subTotals = {};\r\n\t\tif (this.pivotObj.grid) {\r\n\t\t\tthis.pivotObj.grid.resizeStop = this.resizeStop.bind(this);\r\n\t\t}\r\n\t\tif (\r\n\t\t\tthis.fieldlistObj &&\r\n\t\t\tthis.fieldlistObj.pivotButtonModule &&\r\n\t\t\tthis.fieldlistObj.pivotButtonModule.menuOption\r\n\t\t) {\r\n\t\t\t(\r\n\t\t\t\tthis.fieldlistObj.pivotButtonModule.menuOption as any\r\n\t\t\t).stringAggregateTypes = [\r\n\t\t\t\t\"Count\",\r\n\t\t\t\t\"DistinctCount\",\r\n\t\t\t\t\"First\",\r\n\t\t\t\t\"Last\",\r\n\t\t\t];\r\n\t\t}\r\n\t\tif (\r\n\t\t\tthis.pivotObj.pivotButtonModule &&\r\n\t\t\tthis.pivotObj.pivotButtonModule.menuOption\r\n\t\t) {\r\n\t\t\t(\r\n\t\t\t\tthis.pivotObj.pivotButtonModule.menuOption as any\r\n\t\t\t).stringAggregateTypes = [\r\n\t\t\t\t\"Count\",\r\n\t\t\t\t\"DistinctCount\",\r\n\t\t\t\t\"First\",\r\n\t\t\t\t\"Last\",\r\n\t\t\t];\r\n\t\t}\r\n\t\tlet allSummaryType = ALL_AGGREGATE_TYPES as any;\r\n\t\tthis.pivotObj.getAllSummaryType = () => allSummaryType;\r\n\t\tif (this.fieldlistObj) {\r\n\t\t\tthis.fieldlistObj.aggregateTypes = allSummaryType;\r\n\t\t\tthis.fieldlistObj.getAllSummaryType = () => allSummaryType;\r\n\t\t}\r\n\t}\r\n\r\n\tprivate calculatedCellSets(args, curFields) {\r\n\t\tlet matchFields = curFields[\"matchFields\"];\r\n\t\tlet formula = curFields[\"formula\"];\r\n\t\tlet value = 0;\r\n\t\tlet rows = this.pivotObj.dataSourceSettings.rows;\r\n\t\tlet invalidTypes = [\"string\", \"nvarchar\", \"date\", \"datetime\"];\r\n\t\tlet isInvalid = matchFields.some((f) =>\r\n\t\t\tinvalidTypes.includes(\r\n\t\t\t\tthis.configFields.filter((el) => el.colName === f.matchWord)[0][\r\n\t\t\t\t\t\"dataType\"\r\n\t\t\t\t]\r\n\t\t\t)\r\n\t\t);\r\n\t\tlet currentrowCellType = args.rowCellType;\r\n\t\tif (isInvalid) return \"-\";\r\n\t\tif (\r\n\t\t\targs.rowCellType === \"subTotal\" ||\r\n\t\t\targs.rowCellType === \"grandTotal\"\r\n\t\t) {\r\n\t\t\tlet childHeaders = [];\r\n\t\t\tlet sum = 0;\r\n\t\t\tlet cloneCellSets = cloneDeep(args.cellSets);\r\n\t\t\tlet groupNameArrays = [];\r\n\t\t\tfor (let index = args.row.level; index < rows.length; index++) {\r\n\t\t\t\tgroupNameArrays.push(rows[index].name);\r\n\t\t\t}\r\n\t\t\tfor (let i = 0; i < cloneCellSets.length; i++) {\r\n\t\t\t\tlet values = [];\r\n\t\t\t\tlet header = groupNameArrays\r\n\t\t\t\t\t.map((name) => {\r\n\t\t\t\t\t\tvalues.push(cloneCellSets[i][name]);\r\n\t\t\t\t\t\treturn cloneCellSets[i][name];\r\n\t\t\t\t\t})\r\n\t\t\t\t\t.join(\"-\");\r\n\t\t\t\tif (!(childHeaders as any).includes(header)) {\r\n\t\t\t\t\tchildHeaders.push(header);\r\n\t\t\t\t\tlet filterObj: any = {};\r\n\t\t\t\t\tgroupNameArrays.map(\r\n\t\t\t\t\t\t(name, i) => (filterObj[name] = values[i])\r\n\t\t\t\t\t);\r\n\t\t\t\t\targs.cellSets = _filter(cloneCellSets, filterObj);\r\n\t\t\t\t\targs.rowCellType = \"value\";\r\n\t\t\t\t\tsum += this.calculatedValues(args, matchFields, formula);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\targs.rowCellType = currentrowCellType;\r\n\r\n\t\t\t// 暂存当前SubTotal， 用于收缩时读取\r\n\t\t\tlet prefixHeader = this.getCalcHeader(args, formula);\r\n\t\t\tthis.updateTempSubtotals(prefixHeader, sum);\r\n\t\t\treturn sum;\r\n\t\t} else if (args.rowCellType === \"value\") {\r\n\t\t\tif (args.row.hasChild) {\r\n\t\t\t\t// collapse 读取SubTotal\r\n\t\t\t\tlet header = this.getCalcHeader(args, formula);\r\n\t\t\t\tlet index = this.tempSubtotals.findIndex(\r\n\t\t\t\t\t(item) => item.rowName === header\r\n\t\t\t\t);\r\n\t\t\t\tif (index > -1) {\r\n\t\t\t\t\tvalue = this.tempSubtotals[index].rowValue;\r\n\t\t\t\t}\r\n\t\t\t} else {\r\n\t\t\t\t// expand\r\n\t\t\t\tvalue = this.calculatedValues(args, matchFields, formula);\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn value;\r\n\t}\r\n\r\n\tactionFailure(args: PivotActionFailureEventArgs): void {\r\n\t\tif (args.actionName == \"Drill down\" || args.actionName == \"Drill up\") {\r\n\t\t\t// Triggers when the current UI action fails to achieve the desired result.\r\n\t\t}\r\n\t}\r\n\r\n\tprivate getCalcHeader(args, formula?) {\r\n\t\tlet header = \"\";\r\n\t\tlet rows = this.pivotObj.dataSourceSettings.rows;\r\n\t\tlet groupNameArrays = [];\r\n\t\tfor (let index = 0; index < args.row.level; index++) {\r\n\t\t\tgroupNameArrays.push(rows[index].name);\r\n\t\t}\r\n\t\theader = groupNameArrays.length\r\n\t\t\t? groupNameArrays\r\n\t\t\t\t\t.map((name) => {\r\n\t\t\t\t\t\treturn args.cellSets[0][name];\r\n\t\t\t\t\t})\r\n\t\t\t\t\t.join(\"-\") +\r\n\t\t\t  \"-\" +\r\n\t\t\t  args.row.actualText\r\n\t\t\t: args.row.actualText;\r\n\t\tif (formula) header += \"___\" + formula;\r\n\t\treturn header;\r\n\t}\r\n\r\n\tprivate updateTempSubtotals(rowName, rowValue) {\r\n\t\tlet index = this.tempSubtotals.findIndex(\r\n\t\t\t(item) => item.rowName === rowName\r\n\t\t);\r\n\t\tlet temp: any = {};\r\n\t\ttemp.rowName = rowName;\r\n\t\ttemp.rowValue = rowValue;\r\n\t\tif (index > -1) {\r\n\t\t\tthis.tempSubtotals.splice(index, 1, temp);\r\n\t\t} else {\r\n\t\t\tthis.tempSubtotals.push(temp);\r\n\t\t}\r\n\t}\r\n\r\n\tprivate calculatedValues(args, matchFields, formula) {\r\n\t\tif (matchFields.length) {\r\n\t\t\tlet calculedMatchFields = matchFields.map((f) => {\r\n\t\t\t\tswitch (f.matchMethod) {\r\n\t\t\t\t\tcase \"First\":\r\n\t\t\t\t\tcase \"Last\":\r\n\t\t\t\t\t\tf.replaceValue = this.calculatedFistLast(\r\n\t\t\t\t\t\t\targs,\r\n\t\t\t\t\t\t\tf.matchMethod,\r\n\t\t\t\t\t\t\tf.matchWord\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t\tcase \"Max\":\r\n\t\t\t\t\t\tf.replaceValue = maxBy(args.cellSets, (o) =>\r\n\t\t\t\t\t\t\tNumber(o[f.matchWord])\r\n\t\t\t\t\t\t)[f.matchWord];\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t\tcase \"Min\":\r\n\t\t\t\t\t\tf.replaceValue = minBy(args.cellSets, (o) =>\r\n\t\t\t\t\t\t\tNumber(o[f.matchWord])\r\n\t\t\t\t\t\t)[f.matchWord];\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t\tcase \"Sum\":\r\n\t\t\t\t\t\tf.replaceValue = sumBy(args.cellSets, (o) =>\r\n\t\t\t\t\t\t\tNumber(o[f.matchWord])\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t\t// SMP2-4094 Unicorn - L3 Adjusted NAV value issues\r\n\t\t\t\t\t\tf.replaceValue =\r\n\t\t\t\t\t\t\tf.replaceValue && f.replaceValue.toFixed(10);\r\n\t\t\t\t\t\tbreak;\r\n\t\t\t\t\tcase \"Avg\":\r\n\t\t\t\t\t\tf.replaceValue = meanBy(args.cellSets, (o) =>\r\n\t\t\t\t\t\t\tNumber(o[f.matchWord])\r\n\t\t\t\t\t\t);\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\treturn f;\r\n\t\t\t});\r\n\t\t\tlet resultFormula = formula;\r\n\t\t\tif (calculedMatchFields.length) {\r\n\t\t\t\tfor (let i = 0; i < calculedMatchFields.length; i++) {\r\n\t\t\t\t\tresultFormula = resultFormula.replace(\r\n\t\t\t\t\t\tcalculedMatchFields[i].matchStr,\r\n\t\t\t\t\t\t\"(\" + calculedMatchFields[i].replaceValue + \")\"\r\n\t\t\t\t\t);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\ttry {\r\n\t\t\t\tlet result = new Function(\r\n\t\t\t\t\t\"return \" + resultFormula.replace(/[^-<>?:()\\d/*+.]/g, \"\")\r\n\t\t\t\t)();\r\n\t\t\t\tif (isNaN(result) || !isFinite(result)) {\r\n\t\t\t\t\treturn 0;\r\n\t\t\t\t} else {\r\n\t\t\t\t\treturn result;\r\n\t\t\t\t}\r\n\t\t\t} catch (error) {\r\n\t\t\t\treturn NaN;\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn 0;\r\n\t}\r\n\r\n\tprivate getIrrHeader(level, ele, type) {\r\n\t\tif (type === \"row\") {\r\n\t\t\tlet curRows = this.getDataSourceSettingsProp(\r\n\t\t\t\tthis.fieldlistObj,\r\n\t\t\t\t\"rows\"\r\n\t\t\t);\r\n\t\t\tlet rowsArr = curRows.map((item) => item.name);\r\n\r\n\t\t\tlet headerArr = [];\r\n\t\t\tlet rowLevel = level;\r\n\t\t\tfor (let index = 0; index <= rowLevel; index++) {\r\n\t\t\t\theaderArr.push(ele.Row[rowsArr[index]]);\r\n\t\t\t}\r\n\t\t\treturn headerArr.join(\".\");\r\n\t\t} else if (type === \"col\") {\r\n\t\t\tlet curCloumns = this.getDataSourceSettingsProp(\r\n\t\t\t\tthis.fieldlistObj,\r\n\t\t\t\t\"columns\"\r\n\t\t\t);\r\n\t\t\tlet colsArr = curCloumns.map((item) => item.name);\r\n\r\n\t\t\tlet headerArr = [];\r\n\t\t\tlet colLevel = level;\r\n\t\t\tfor (let index = 0; index <= colLevel; index++) {\r\n\t\t\t\theaderArr.push(ele.Col[colsArr[index]]);\r\n\t\t\t}\r\n\t\t\treturn headerArr.join(\".\");\r\n\t\t}\r\n\t}\r\n\r\n\ttotalFormatted = {};\r\n\tpublic aggregateCellInfo(args) {\r\n\t\tlet asOfDate = this.pbf.time(this.dashboard.asOfDate);\r\n\t\t// if calculated field\r\n\t\tif (args.aggregateType == \"CalculatedField\") {\r\n\t\t\tfor (let i = 0; i < this.customCalculatedFields.length; i++) {\r\n\t\t\t\tif (args.fieldName == this.customCalculatedFields[i].name) {\r\n\t\t\t\t\targs.value = this.calculatedCellSets(\r\n\t\t\t\t\t\targs,\r\n\t\t\t\t\t\tthis.customCalculatedFields[i]\r\n\t\t\t\t\t);\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\t[\r\n\t\t\t\t\"CalculateIRR\",\r\n\t\t\t\t\"CalculateIRRBeforeCarried\",\r\n\t\t\t\t\"CalculateIRRIRRDate\",\r\n\t\t\t\t\"CalculateIRRMTD\",\r\n\t\t\t\t\"CalculateIRRQTD\",\r\n\t\t\t\t\"CalculateIRRYTD\",\r\n\t\t\t].includes(args.aggregateType)\r\n\t\t) {\r\n\t\t\tlet valueField;\r\n\t\t\tlet dateField;\r\n\t\t\tlet startDate;\r\n\t\t\tlet endDate;\r\n\t\t\tswitch (args.aggregateType) {\r\n\t\t\t\tcase \"CalculateIRR\":\r\n\t\t\t\t\tvalueField = \"IRRAdjValue\";\r\n\t\t\t\t\tdateField = \"IRRDate\";\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tcase \"CalculateIRRMTD\":\r\n\t\t\t\t\tstartDate = moment(asOfDate)\r\n\t\t\t\t\t\t.startOf(\"month\")\r\n\t\t\t\t\t\t.format(\"YYYY-MM-DD\");\r\n\t\t\t\t\tendDate = moment(asOfDate).format(\"YYYY-MM-DD\");\r\n\t\t\t\t\tvalueField = \"IRRAdjValue\";\r\n\t\t\t\t\tdateField = \"IRRDate\";\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tcase \"CalculateIRRQTD\":\r\n\t\t\t\t\tstartDate = moment(asOfDate)\r\n\t\t\t\t\t\t.startOf(\"quarter\")\r\n\t\t\t\t\t\t.format(\"YYYY-MM-DD\");\r\n\t\t\t\t\tendDate = moment(asOfDate).format(\"YYYY-MM-DD\");\r\n\t\t\t\t\tvalueField = \"IRRAdjValue\";\r\n\t\t\t\t\tdateField = \"IRRDate\";\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tcase \"CalculateIRRYTD\":\r\n\t\t\t\t\tstartDate = moment(asOfDate)\r\n\t\t\t\t\t\t.startOf(\"year\")\r\n\t\t\t\t\t\t.format(\"YYYY-MM-DD\");\r\n\t\t\t\t\tendDate = moment(asOfDate).format(\"YYYY-MM-DD\");\r\n\t\t\t\t\tvalueField = \"IRRAdjValue\";\r\n\t\t\t\t\tdateField = \"IRRDate\";\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tcase \"CalculateIRRIRRDate\":\r\n\t\t\t\t\tvalueField = \"IRRAdjValue\";\r\n\t\t\t\t\tdateField = \"CalculateIRRDate\";\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tcase \"CalculateIRRBeforeCarried\":\r\n\t\t\t\t\tvalueField = \"IRRAdjValueBeforeCarry\";\r\n\t\t\t\t\tdateField = \"IRRDate\";\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tdefault:\r\n\t\t\t\t\tbreak;\r\n\t\t\t}\r\n\t\t\tlet NAVAdj = 0;\r\n\t\t\tlet values = [];\r\n\t\t\tlet beforeStartNAVAdj = 0; // 存储上一个阶段的NAVAdj总和\r\n\t\t\tlet beforeStartValues = []; // 存储上一个阶段的累计集合 (只是为了打印，没有实际用途)\r\n\t\t\tlet field = this.configFields.filter(\r\n\t\t\t\t(el) =>\r\n\t\t\t\t\tel.colName ===\r\n\t\t\t\t\tthis.dashboardPorletsService.getAggregateType(\r\n\t\t\t\t\t\targs.aggregateType\r\n\t\t\t\t\t)\r\n\t\t\t);\r\n\t\t\tfor (let i = 0; i < args.cellSets.length; i++) {\r\n\t\t\t\tconst data = {\r\n\t\t\t\t\tamount: args.cellSets[i][\"IRRAmount\"],\r\n\t\t\t\t\tdate:\r\n\t\t\t\t\t\tthis.pbf.time(args.cellSets[i][dateField]) ===\r\n\t\t\t\t\t\t\"Invalid date\"\r\n\t\t\t\t\t\t\t? asOfDate\r\n\t\t\t\t\t\t\t: this.pbf.time(args.cellSets[i][dateField]),\r\n\t\t\t\t};\r\n\t\t\t\t// SMP2-16920\r\n\t\t\t\t// If IRR Date > Dashboard report date = Takes as of dashboard report date\r\n\t\t\t\tif (\r\n\t\t\t\t\targs.aggregateType === \"CalculateIRRIRRDate\" &&\r\n\t\t\t\t\tasOfDate < this.pbf.time(args.cellSets[i][dateField])\r\n\t\t\t\t) {\r\n\t\t\t\t\tdata.date = asOfDate;\r\n\t\t\t\t}\r\n\t\t\t\tNAVAdj += args.cellSets[i][valueField];\r\n\t\t\t\t// SMP2-17219 MTD QTD YTD IRR\r\n\t\t\t\tif (startDate && endDate) {\r\n\t\t\t\t\tif (moment(data.date).isBefore(startDate)) {\r\n\t\t\t\t\t\tdata[valueField] = args.cellSets[i][valueField];\r\n\t\t\t\t\t\tbeforeStartValues.push(data);\r\n\t\t\t\t\t\tbeforeStartNAVAdj += data[valueField];\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif (\r\n\t\t\t\t\t\t!moment(data.date).isBetween(\r\n\t\t\t\t\t\t\tstartDate,\r\n\t\t\t\t\t\t\tendDate,\r\n\t\t\t\t\t\t\tnull,\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\tcontinue;\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\tif (data.amount != 0) {\r\n\t\t\t\t\tvalues.push(data);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tif (NAVAdj > 0.0001 || NAVAdj < -0.0001) {\r\n\t\t\t\tvalues.push({\r\n\t\t\t\t\tamount: NAVAdj,\r\n\t\t\t\t\tdate: asOfDate,\r\n\t\t\t\t});\r\n\t\t\t}\r\n\t\t\tvalues = sortBy(values, \"date\");\r\n\t\t\t// 如果是MTD,QTD,YTD 则需要把当前阶段以前的所有数据进行汇总，加入计算\r\n\t\t\tif (startDate && endDate) {\r\n\t\t\t\tvalues.unshift({\r\n\t\t\t\t\tamount: -beforeStartNAVAdj, // 开始的数据需要取反\r\n\t\t\t\t\tdate: this.pbf.time(startDate),\r\n\t\t\t\t});\r\n\t\t\t}\r\n\t\t\t// console.log(\"beforeStartValues:\", beforeStartValues);\r\n\t\t\t// console.log(\"values:\", values);\r\n\t\t\tif (values.length > 0) {\r\n\t\t\t\tlet guess = 0.1;\r\n\t\t\t\tconst sumAmount = values\r\n\t\t\t\t\t.map((item) => item.amount)\r\n\t\t\t\t\t.reduce((prev, curr) => prev + curr, 0);\r\n\t\t\t\tif (sumAmount < 0) {\r\n\t\t\t\t\tguess = -0.1;\r\n\t\t\t\t}\r\n\t\t\t\t//SMP2-2249 fixed the big irr issue\r\n\t\t\t\tif (sumAmount === 0) {\r\n\t\t\t\t\targs.value = 0;\r\n\t\t\t\t} else {\r\n\t\t\t\t\tconst valueItems = values.slice(0, values.length - 1);\r\n\t\t\t\t\tconst valueList = valueItems.map((item) => item.amount);\r\n\t\t\t\t\tconst dateList = valueItems.map((item) => item.date);\r\n\t\t\t\t\tconst lastItem = values[values.length - 1];\r\n\t\t\t\t\tconst navAdjust = lastItem.amount;\r\n\t\t\t\t\tconst latestDate = lastItem.date;\r\n\t\t\t\t\tlet irr =\r\n\t\t\t\t\t\tthis.dashboardPorletsService.ExcelFormulas._CalculateXirr(\r\n\t\t\t\t\t\t\tvalueList,\r\n\t\t\t\t\t\t\tdateList,\r\n\t\t\t\t\t\t\tnavAdjust,\r\n\t\t\t\t\t\t\tlatestDate\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\targs.value = irr === null ? \"\" : irr;\r\n\t\t\t\t}\r\n\t\t\t} else {\r\n\t\t\t\targs.value = \"\";\r\n\t\t\t}\r\n\t\t\tif (\r\n\t\t\t\tthis.pivotObj.engineModule &&\r\n\t\t\t\tthis.pivotObj.engineModule.formatFields[args.fieldName]\r\n\t\t\t) {\r\n\t\t\t\tdelete this.pivotObj.engineModule.formatFields[args.fieldName];\r\n\t\t\t\tthis.pivotObj.engineModule.formatFields[args.fieldName] = {\r\n\t\t\t\t\tname: args.fieldName,\r\n\t\t\t\t\tformat:\r\n\t\t\t\t\t\tfield.length > 0\r\n\t\t\t\t\t\t\t? field[0].format &&\r\n\t\t\t\t\t\t\t  field[0].format.length &&\r\n\t\t\t\t\t\t\t  field[0].format[0].formatChecked\r\n\t\t\t\t\t\t\t\t? this.dashboardPorletsService.pivotTableformatPercent(\r\n\t\t\t\t\t\t\t\t\t\tfield[0].format[0].selectedFormat\r\n\t\t\t\t\t\t\t\t  )\r\n\t\t\t\t\t\t\t\t: this.dashboardPorletsService.formatPercent(\r\n\t\t\t\t\t\t\t\t\t\tfield[0].dp\r\n\t\t\t\t\t\t\t\t  )\r\n\t\t\t\t\t\t\t: \"P2\",\r\n\t\t\t\t};\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t//  SMP2-16520 TWR 月/季/年 && SMP2-16683 VAR\r\n\t\tif (\r\n\t\t\t[\r\n\t\t\t\t\"CalculateTWRMTD\",\r\n\t\t\t\t\"CalculateTWRQTD\",\r\n\t\t\t\t\"CalculateTWRYTD\",\r\n\t\t\t\t\"CalculateVARMTD_99\",\r\n\t\t\t\t\"CalculateVARQTD_99\",\r\n\t\t\t\t\"CalculateVARYTD_99\",\r\n\t\t\t\t\"CalculateVARMTD_95\",\r\n\t\t\t\t\"CalculateVARQTD_95\",\r\n\t\t\t\t\"CalculateVARYTD_95\",\r\n\t\t\t].includes(args.aggregateType)\r\n\t\t) {\r\n\t\t\t// console.log(\"==========================\");\r\n\t\t\t// console.log(\"args:\", args);\r\n\t\t\tlet valueField = \"IRRAdjValue\";\r\n\t\t\tlet dateField = \"IRRDate\";\r\n\t\t\tlet timeRange;\r\n\t\t\tswitch (args.aggregateType) {\r\n\t\t\t\tcase \"CalculateTWRMTD\":\r\n\t\t\t\tcase \"CalculateVARMTD_99\":\r\n\t\t\t\tcase \"CalculateVARMTD_95\":\r\n\t\t\t\t\ttimeRange = \"month\";\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tcase \"CalculateTWRQTD\":\r\n\t\t\t\tcase \"CalculateVARQTD_99\":\r\n\t\t\t\tcase \"CalculateVARQTD_95\":\r\n\t\t\t\t\ttimeRange = \"quarter\";\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tcase \"CalculateTWRYTD\":\r\n\t\t\t\tcase \"CalculateVARYTD_99\":\r\n\t\t\t\tcase \"CalculateVARYTD_95\":\r\n\t\t\t\t\ttimeRange = \"year\";\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tdefault:\r\n\t\t\t\t\tbreak;\r\n\t\t\t}\r\n\t\t\tlet values = []; // 这个阶段的累计集合\r\n\t\t\tlet field = this.configFields.filter(\r\n\t\t\t\t(el) =>\r\n\t\t\t\t\tel.colName ===\r\n\t\t\t\t\tthis.dashboardPorletsService.getAggregateType(\r\n\t\t\t\t\t\targs.aggregateType\r\n\t\t\t\t\t)\r\n\t\t\t);\r\n\t\t\tfor (let i = 0; i < args.cellSets.length; i++) {\r\n\t\t\t\tconst data = {\r\n\t\t\t\t\t[valueField]: args.cellSets[i][valueField],\r\n\t\t\t\t\tdate:\r\n\t\t\t\t\t\tthis.pbf.time(args.cellSets[i][dateField]) ===\r\n\t\t\t\t\t\t\"Invalid date\"\r\n\t\t\t\t\t\t\t? asOfDate\r\n\t\t\t\t\t\t\t: this.pbf.time(args.cellSets[i][dateField]),\r\n\t\t\t\t};\r\n\t\t\t\tvalues.push(data);\r\n\t\t\t}\r\n\r\n\t\t\t// 如果asOfDate不是 本月/季度/年 的最后一天，都是截至 上个月/季度/年 的最后一天的数据去计算\r\n\t\t\tlet _asOfDate = moment(asOfDate);\r\n\t\t\t// console.log(\"_asOfDate:\", _asOfDate);\r\n\t\t\tlet isEndOfPeriod = (unit) => {\r\n\t\t\t\treturn (\r\n\t\t\t\t\t_asOfDate.format(\"YYYY-MM-DD\") ===\r\n\t\t\t\t\t_asOfDate.endOf(unit).format(\"YYYY-MM-DD\")\r\n\t\t\t\t);\r\n\t\t\t};\r\n\t\t\tlet endDate = isEndOfPeriod(timeRange)\r\n\t\t\t\t? moment(asOfDate).format(\"YYYY-MM-DD\")\r\n\t\t\t\t: moment(asOfDate)\r\n\t\t\t\t\t\t.subtract(1, timeRange)\r\n\t\t\t\t\t\t.endOf(timeRange)\r\n\t\t\t\t\t\t.format(\"YYYY-MM-DD\");\r\n\r\n\t\t\t// console.log(\"endDate:\", endDate);\r\n\t\t\tvalues = values.filter((item) =>\r\n\t\t\t\tmoment(item.date).isSameOrBefore(endDate)\r\n\t\t\t);\r\n\t\t\tvalues = sortBy(values, \"date\");\r\n\t\t\t// console.log(\"values:\", values);\r\n\r\n\t\t\tif (values.length > 0) {\r\n\t\t\t\tlet result = this.getTimeRanges(\r\n\t\t\t\t\tvalues,\r\n\t\t\t\t\tendDate,\r\n\t\t\t\t\ttimeRange,\r\n\t\t\t\t\t\"date\"\r\n\t\t\t\t); // 各个阶段的数据\r\n\t\t\t\tlet resultTotal = {}; // 各个阶段总和\r\n\t\t\t\tfor (const prop in result) {\r\n\t\t\t\t\tresultTotal[prop] = result[prop].reduce((acc, cur) => {\r\n\t\t\t\t\t\treturn acc + (cur[valueField] || 0);\r\n\t\t\t\t\t}, 0);\r\n\t\t\t\t}\r\n\t\t\t\t// console.log(\"result:\", result);\r\n\t\t\t\t// console.log(\"resultTotal:\", resultTotal);\r\n\r\n\t\t\t\tconst cumulativeSum = {}; // 各个阶段累计和\r\n\t\t\t\tlet sum = 0;\r\n\t\t\t\tfor (const key of Object.keys(resultTotal)) {\r\n\t\t\t\t\tsum += resultTotal[key];\r\n\t\t\t\t\tcumulativeSum[`${key}`] = sum;\r\n\t\t\t\t}\r\n\t\t\t\t// console.log(\"cumulativeSum:\", cumulativeSum);\r\n\r\n\t\t\t\tconst keys = Object.keys(cumulativeSum);\r\n\t\t\t\tlet twrList = [];\r\n\t\t\t\t// 遍历每两个阶段 计算TWR\r\n\t\t\t\tfor (let i = 0; i < keys.length - 1; i++) {\r\n\t\t\t\t\tconst key1 = keys[i];\r\n\t\t\t\t\tconst key2 = keys[i + 1];\r\n\r\n\t\t\t\t\t// 计算两个阶段之间的递增量, 出数不能为0\r\n\t\t\t\t\tif (cumulativeSum[key1] != 0) {\r\n\t\t\t\t\t\tconst increment =\r\n\t\t\t\t\t\t\tcumulativeSum[key2] - cumulativeSum[key1];\r\n\t\t\t\t\t\tlet twr = increment / cumulativeSum[key1];\r\n\t\t\t\t\t\ttwrList.push({\r\n\t\t\t\t\t\t\tdate: key2,\r\n\t\t\t\t\t\t\ttwr: twr,\r\n\t\t\t\t\t\t});\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\t// 计算Average TWR\r\n\t\t\t\t// console.log(\"twrList:\", twrList);\r\n\t\t\t\tlet averageTWR = this.calculateGrowthRate(\r\n\t\t\t\t\ttwrList.map((x) => x.twr)\r\n\t\t\t\t);\r\n\t\t\t\t// console.log(\"计算Average TWR:\", averageTWR);\r\n\t\t\t\tif (\r\n\t\t\t\t\t[\r\n\t\t\t\t\t\t\"CalculateTWRMTD\",\r\n\t\t\t\t\t\t\"CalculateTWRQTD\",\r\n\t\t\t\t\t\t\"CalculateTWRYTD\",\r\n\t\t\t\t\t].includes(args.aggregateType)\r\n\t\t\t\t) {\r\n\t\t\t\t\t// SMP2-16520 TWR 月/季/年\r\n\t\t\t\t\targs.value =\r\n\t\t\t\t\t\tisNaN(averageTWR) || averageTWR == null\r\n\t\t\t\t\t\t\t? \"\"\r\n\t\t\t\t\t\t\t: averageTWR.toFixed(4);\r\n\t\t\t\t} else {\r\n\t\t\t\t\tif (isNaN(averageTWR) || averageTWR == null) {\r\n\t\t\t\t\t\targs.value = \"\";\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\t// SMP2-16683 VAR 区分99%和95%\r\n\t\t\t\t\t\tlet ZScore = [\r\n\t\t\t\t\t\t\t\"CalculateVARMTD_99\",\r\n\t\t\t\t\t\t\t\"CalculateVARQTD_99\",\r\n\t\t\t\t\t\t\t\"CalculateVARYTD_99\",\r\n\t\t\t\t\t\t].includes(args.aggregateType)\r\n\t\t\t\t\t\t\t? 2.33\r\n\t\t\t\t\t\t\t: 1.65;\r\n\t\t\t\t\t\tif (twrList.length < 2) {\r\n\t\t\t\t\t\t\targs.value = \"\";\r\n\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\tlet SD = this.calculateStandardDeviation(\r\n\t\t\t\t\t\t\t\ttwrList.map((x) => x.twr)\r\n\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\t// console.log(\"calculateStandardDeviation:\", SD);\r\n\t\t\t\t\t\t\tlet VAR = averageTWR - SD * ZScore;\r\n\t\t\t\t\t\t\targs.value = VAR.toFixed(4);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\t// console.log(\"args.value:\", args.value);\r\n\t\t\t}\r\n\r\n\t\t\tif (\r\n\t\t\t\tthis.pivotObj.engineModule &&\r\n\t\t\t\tthis.pivotObj.engineModule.formatFields[args.fieldName]\r\n\t\t\t) {\r\n\t\t\t\tdelete this.pivotObj.engineModule.formatFields[args.fieldName];\r\n\t\t\t\tthis.pivotObj.engineModule.formatFields[args.fieldName] = {\r\n\t\t\t\t\tname: args.fieldName,\r\n\t\t\t\t\tformat:\r\n\t\t\t\t\t\tfield.length > 0\r\n\t\t\t\t\t\t\t? field[0].format &&\r\n\t\t\t\t\t\t\t  field[0].format.length &&\r\n\t\t\t\t\t\t\t  field[0].format[0].formatChecked\r\n\t\t\t\t\t\t\t\t? this.dashboardPorletsService.pivotTableformatPercent(\r\n\t\t\t\t\t\t\t\t\t\tfield[0].format[0].selectedFormat\r\n\t\t\t\t\t\t\t\t  )\r\n\t\t\t\t\t\t\t\t: this.dashboardPorletsService.formatPercent(\r\n\t\t\t\t\t\t\t\t\t\tfield[0].dp\r\n\t\t\t\t\t\t\t\t  )\r\n\t\t\t\t\t\t\t: \"P2\",\r\n\t\t\t\t};\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t//SMP2-2701\r\n\t\tif (args.aggregateType === \"CalculateIRRActualAudited\") {\r\n\t\t\tlet NAVAdj = 0;\r\n\t\t\tlet values = [];\r\n\t\t\tlet field = this.configFields.filter(\r\n\t\t\t\t(el) =>\r\n\t\t\t\t\tel.colName ===\r\n\t\t\t\t\tthis.dashboardPorletsService.getAggregateType(\r\n\t\t\t\t\t\targs.aggregateType\r\n\t\t\t\t\t)\r\n\t\t\t);\r\n\t\t\t//SMP2-2713 only judge for this dataMart(GrossNet)\r\n\t\t\tif (\r\n\t\t\t\tthis.portlet.figureCode === \"GrossNet\" ||\r\n\t\t\t\tthis.portlet.figureCode ===\r\n\t\t\t\t\t\"CombinedInvestmentFundNCompanyCashflow\"\r\n\t\t\t) {\r\n\t\t\t\tfor (let i = 0; i < args.cellSets.length; i++) {\r\n\t\t\t\t\tconst data = {\r\n\t\t\t\t\t\tamount: args.cellSets[i][\"IRRAmount\"],\r\n\t\t\t\t\t\tdate:\r\n\t\t\t\t\t\t\tthis.pbf.time(args.cellSets[i][\"IRRDate\"]) ===\r\n\t\t\t\t\t\t\t\"Invalid date\"\r\n\t\t\t\t\t\t\t\t? asOfDate\r\n\t\t\t\t\t\t\t\t: this.pbf.time(args.cellSets[i][\"IRRDate\"]),\r\n\t\t\t\t\t};\r\n\t\t\t\t\tNAVAdj += args.cellSets[i][\"ActualAuditedNAV\"];\r\n\t\t\t\t\tif (data.amount != 0) {\r\n\t\t\t\t\t\tvalues.push(data);\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\t//filter the data by the DataType(Actual Reported Audited)\r\n\t\t\telse {\r\n\t\t\t\tlet argsdata = args.cellSets.filter(\r\n\t\t\t\t\t(el) =>\r\n\t\t\t\t\t\tel.DataType === \"ACTUAL_AUDITED\" ||\r\n\t\t\t\t\t\tel.DataType === \"REPORTED\"\r\n\t\t\t\t);\r\n\t\t\t\tfor (let i = 0; i < argsdata.length; i++) {\r\n\t\t\t\t\tconst data = {\r\n\t\t\t\t\t\tamount: argsdata[i][\"IRRAmount\"],\r\n\t\t\t\t\t\tdate:\r\n\t\t\t\t\t\t\tthis.pbf.time(argsdata[i][\"IRRDate\"]) ===\r\n\t\t\t\t\t\t\t\"Invalid date\"\r\n\t\t\t\t\t\t\t\t? asOfDate\r\n\t\t\t\t\t\t\t\t: this.pbf.time(argsdata[i][\"IRRDate\"]),\r\n\t\t\t\t\t};\r\n\t\t\t\t\tNAVAdj += argsdata[i][\"IRRAdjValue\"];\r\n\t\t\t\t\tif (data.amount != 0) {\r\n\t\t\t\t\t\tvalues.push(data);\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tif (NAVAdj > 0.0001 || NAVAdj < -0.0001) {\r\n\t\t\t\tvalues.push({\r\n\t\t\t\t\tamount: NAVAdj,\r\n\t\t\t\t\tdate: asOfDate,\r\n\t\t\t\t});\r\n\t\t\t}\r\n\t\t\tvalues = sortBy(values, \"date\");\r\n\t\t\tif (values.length > 0) {\r\n\t\t\t\tlet guess = 0.1;\r\n\t\t\t\tconst sumAmount = values\r\n\t\t\t\t\t.map((item) => item.amount)\r\n\t\t\t\t\t.reduce((prev, curr) => prev + curr, 0);\r\n\t\t\t\tif (sumAmount < 0) {\r\n\t\t\t\t\tguess = -0.1;\r\n\t\t\t\t}\r\n\t\t\t\t//SMP2-2249 fixed the big irr issue\r\n\t\t\t\tif (sumAmount === 0) {\r\n\t\t\t\t\targs.value = 0;\r\n\t\t\t\t} else {\r\n\t\t\t\t\tconst valueItems = values.slice(0, values.length - 1);\r\n\t\t\t\t\tconst valueList = valueItems.map((item) => item.amount);\r\n\t\t\t\t\tconst dateList = valueItems.map((item) => item.date);\r\n\t\t\t\t\tconst lastItem = values[values.length - 1];\r\n\t\t\t\t\tconst navAdjust = lastItem.amount;\r\n\t\t\t\t\tconst latestDate = lastItem.date;\r\n\t\t\t\t\tlet irr =\r\n\t\t\t\t\t\tthis.dashboardPorletsService.ExcelFormulas._CalculateXirr(\r\n\t\t\t\t\t\t\tvalueList,\r\n\t\t\t\t\t\t\tdateList,\r\n\t\t\t\t\t\t\tnavAdjust,\r\n\t\t\t\t\t\t\tlatestDate\r\n\t\t\t\t\t\t);\r\n\r\n\t\t\t\t\targs.value = irr === null ? 0 : irr;\r\n\t\t\t\t}\r\n\t\t\t} else {\r\n\t\t\t\targs.value = 0;\r\n\t\t\t}\r\n\t\t\tif (\r\n\t\t\t\tthis.pivotObj.engineModule &&\r\n\t\t\t\tthis.pivotObj.engineModule.formatFields[args.fieldName]\r\n\t\t\t) {\r\n\t\t\t\tdelete this.pivotObj.engineModule.formatFields[args.fieldName];\r\n\t\t\t\tthis.pivotObj.engineModule.formatFields[args.fieldName] = {\r\n\t\t\t\t\tname: args.fieldName,\r\n\t\t\t\t\tformat:\r\n\t\t\t\t\t\tfield.length > 0\r\n\t\t\t\t\t\t\t? field[0].format &&\r\n\t\t\t\t\t\t\t  field[0].format.length &&\r\n\t\t\t\t\t\t\t  field[0].format[0].formatChecked\r\n\t\t\t\t\t\t\t\t? this.dashboardPorletsService.pivotTableformatPercent(\r\n\t\t\t\t\t\t\t\t\t\tfield[0].format[0].selectedFormat\r\n\t\t\t\t\t\t\t\t  )\r\n\t\t\t\t\t\t\t\t: this.dashboardPorletsService.formatPercent(\r\n\t\t\t\t\t\t\t\t\t\tfield[0].dp\r\n\t\t\t\t\t\t\t\t  )\r\n\t\t\t\t\t\t\t: \"P2\",\r\n\t\t\t\t};\r\n\t\t\t}\r\n\t\t}\r\n\t\t//SMP2-3411\r\n\t\tif (args.aggregateType === \"CalculateIRRReported\") {\r\n\t\t\tlet NAVAdj = 0;\r\n\t\t\tlet values = [];\r\n\t\t\tlet field = this.configFields.filter(\r\n\t\t\t\t(el) =>\r\n\t\t\t\t\tel.colName ===\r\n\t\t\t\t\tthis.dashboardPorletsService.getAggregateType(\r\n\t\t\t\t\t\targs.aggregateType\r\n\t\t\t\t\t)\r\n\t\t\t);\r\n\t\t\tif (\r\n\t\t\t\tthis.portlet.figureCode === \"GrossNet\" ||\r\n\t\t\t\tthis.portlet.figureCode ===\r\n\t\t\t\t\t\"CombinedInvestmentFundNCompanyCashflow\"\r\n\t\t\t) {\r\n\t\t\t\tfor (let i = 0; i < args.cellSets.length; i++) {\r\n\t\t\t\t\tconst data = {\r\n\t\t\t\t\t\tamount: args.cellSets[i][\"IRRAmount\"],\r\n\t\t\t\t\t\tdate:\r\n\t\t\t\t\t\t\tthis.pbf.time(args.cellSets[i][\"IRRDate\"]) ===\r\n\t\t\t\t\t\t\t\"Invalid date\"\r\n\t\t\t\t\t\t\t\t? asOfDate\r\n\t\t\t\t\t\t\t\t: this.pbf.time(args.cellSets[i][\"IRRDate\"]),\r\n\t\t\t\t\t};\r\n\t\t\t\t\tNAVAdj += args.cellSets[i][\"ReportedNAV\"];\r\n\t\t\t\t\tif (data.amount != 0) {\r\n\t\t\t\t\t\tvalues.push(data);\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t} else {\r\n\t\t\t\tfor (let i = 0; i < args.cellSets.length; i++) {\r\n\t\t\t\t\tconst data = {\r\n\t\t\t\t\t\tamount: args.cellSets[i][\"IRRAmount\"],\r\n\t\t\t\t\t\tdate:\r\n\t\t\t\t\t\t\tthis.pbf.time(args.cellSets[i][\"IRRDate\"]) ===\r\n\t\t\t\t\t\t\t\"Invalid date\"\r\n\t\t\t\t\t\t\t\t? asOfDate\r\n\t\t\t\t\t\t\t\t: this.pbf.time(args.cellSets[i][\"IRRDate\"]),\r\n\t\t\t\t\t};\r\n\t\t\t\t\tNAVAdj += args.cellSets[i][\"IRRAdjValue\"];\r\n\t\t\t\t\tif (data.amount != 0) {\r\n\t\t\t\t\t\tvalues.push(data);\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tif (NAVAdj > 0.0001 || NAVAdj < -0.0001) {\r\n\t\t\t\tvalues.push({\r\n\t\t\t\t\tamount: NAVAdj,\r\n\t\t\t\t\tdate: asOfDate,\r\n\t\t\t\t});\r\n\t\t\t}\r\n\t\t\tvalues = sortBy(values, \"date\");\r\n\t\t\tif (values.length > 0) {\r\n\t\t\t\tlet guess = 0.1;\r\n\t\t\t\tconst sumAmount = values\r\n\t\t\t\t\t.map((item) => item.amount)\r\n\t\t\t\t\t.reduce((prev, curr) => prev + curr, 0);\r\n\t\t\t\tif (sumAmount < 0) {\r\n\t\t\t\t\tguess = -0.1;\r\n\t\t\t\t}\r\n\t\t\t\t//SMP2-2249 fixed the big irr issue\r\n\t\t\t\tif (sumAmount === 0) {\r\n\t\t\t\t\targs.value = 0;\r\n\t\t\t\t} else {\r\n\t\t\t\t\tconst valueItems = values.slice(0, values.length - 1);\r\n\t\t\t\t\tconst valueList = valueItems.map((item) => item.amount);\r\n\t\t\t\t\tconst dateList = valueItems.map((item) => item.date);\r\n\t\t\t\t\tconst lastItem = values[values.length - 1];\r\n\t\t\t\t\tconst navAdjust = lastItem.amount;\r\n\t\t\t\t\tconst latestDate = lastItem.date;\r\n\t\t\t\t\tlet irr =\r\n\t\t\t\t\t\tthis.dashboardPorletsService.ExcelFormulas._CalculateXirr(\r\n\t\t\t\t\t\t\tvalueList,\r\n\t\t\t\t\t\t\tdateList,\r\n\t\t\t\t\t\t\tnavAdjust,\r\n\t\t\t\t\t\t\tlatestDate\r\n\t\t\t\t\t\t);\r\n\r\n\t\t\t\t\targs.value = irr === null ? 0 : irr;\r\n\t\t\t\t}\r\n\t\t\t} else {\r\n\t\t\t\targs.value = 0;\r\n\t\t\t}\r\n\t\t\tif (\r\n\t\t\t\tthis.pivotObj.engineModule &&\r\n\t\t\t\tthis.pivotObj.engineModule.formatFields[args.fieldName]\r\n\t\t\t) {\r\n\t\t\t\tdelete this.pivotObj.engineModule.formatFields[args.fieldName];\r\n\t\t\t\tthis.pivotObj.engineModule.formatFields[args.fieldName] = {\r\n\t\t\t\t\tname: args.fieldName,\r\n\t\t\t\t\tformat:\r\n\t\t\t\t\t\tfield.length > 0\r\n\t\t\t\t\t\t\t? field[0].format &&\r\n\t\t\t\t\t\t\t  field[0].format.length &&\r\n\t\t\t\t\t\t\t  field[0].format[0].formatChecked\r\n\t\t\t\t\t\t\t\t? this.dashboardPorletsService.pivotTableformatPercent(\r\n\t\t\t\t\t\t\t\t\t\tfield[0].format[0].selectedFormat\r\n\t\t\t\t\t\t\t\t  )\r\n\t\t\t\t\t\t\t\t: this.dashboardPorletsService.formatPercent(\r\n\t\t\t\t\t\t\t\t\t\tfield[0].dp\r\n\t\t\t\t\t\t\t\t  )\r\n\t\t\t\t\t\t\t: \"P2\",\r\n\t\t\t\t};\r\n\t\t\t}\r\n\t\t}\r\n\t\tif (\r\n\t\t\targs.aggregateType === \"CalculateMultiple\" ||\r\n\t\t\targs.aggregateType === \"CalculatePIC\" ||\r\n\t\t\targs.aggregateType === \"CalculateDPI\" ||\r\n\t\t\targs.aggregateType === \"CalculateTVPI\" ||\r\n\t\t\targs.aggregateType === \"CalculateRVPI\" ||\r\n\t\t\targs.aggregateType === \"CalculateMActualAudited\" ||\r\n\t\t\targs.aggregateType === \"CalculateMReported\"\r\n\t\t) {\r\n\t\t\tlet totalNumerator = 0;\r\n\t\t\tlet totalDenominator = 0;\r\n\t\t\tlet numeratorName;\r\n\t\t\tlet denominatorName;\r\n\t\t\tlet field = this.configFields.filter(\r\n\t\t\t\t(el) =>\r\n\t\t\t\t\tel.colName ===\r\n\t\t\t\t\tthis.dashboardPorletsService.getAggregateType(\r\n\t\t\t\t\t\targs.aggregateType\r\n\t\t\t\t\t)\r\n\t\t\t);\r\n\t\t\tif (field.length > 0) {\r\n\t\t\t\tconst formulaArray = field[0].formula.split(\"/\");\r\n\t\t\t\tnumeratorName = formulaArray[0];\r\n\t\t\t\tdenominatorName = formulaArray[1];\r\n\t\t\t}\r\n\t\t\tfor (let j = 0; j < args.cellSets.length; j++) {\r\n\t\t\t\ttotalNumerator += args.cellSets[j][numeratorName];\r\n\t\t\t\ttotalDenominator += args.cellSets[j][denominatorName];\r\n\t\t\t}\r\n\t\t\tif (totalDenominator !== 0) {\r\n\t\t\t\targs.value = totalNumerator / totalDenominator;\r\n\t\t\t\tif (\r\n\t\t\t\t\tthis.pivotObj.engineModule &&\r\n\t\t\t\t\tthis.pivotObj.engineModule.formatFields[args.fieldName]\r\n\t\t\t\t) {\r\n\t\t\t\t\tdelete this.pivotObj.engineModule.formatFields[\r\n\t\t\t\t\t\targs.fieldName\r\n\t\t\t\t\t];\r\n\t\t\t\t\tthis.pivotObj.engineModule.formatFields[args.fieldName] = {\r\n\t\t\t\t\t\tname: args.fieldName,\r\n\t\t\t\t\t\tformat:\r\n\t\t\t\t\t\t\tfield.length > 0\r\n\t\t\t\t\t\t\t\t? field[0].format &&\r\n\t\t\t\t\t\t\t\t  field[0].format.length &&\r\n\t\t\t\t\t\t\t\t  field[0].format[0].formatChecked\r\n\t\t\t\t\t\t\t\t\t? this.dashboardPorletsService.pivotTableformatMultiple(\r\n\t\t\t\t\t\t\t\t\t\t\tfield[0].format[0].selectedFormat\r\n\t\t\t\t\t\t\t\t\t  )\r\n\t\t\t\t\t\t\t\t\t: this.dashboardPorletsService.formatMultiple(\r\n\t\t\t\t\t\t\t\t\t\t\tfield[0].dp\r\n\t\t\t\t\t\t\t\t\t  )\r\n\t\t\t\t\t\t\t\t: \"###0.00'x'\",\r\n\t\t\t\t\t};\r\n\t\t\t\t}\r\n\t\t\t} else {\r\n\t\t\t\targs.value = \"\";\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tif (args.aggregateType === \"First\" || args.aggregateType === \"Last\") {\r\n\t\t\targs.value = this.calculatedFistLast(\r\n\t\t\t\targs,\r\n\t\t\t\targs.aggregateType,\r\n\t\t\t\targs.fieldName\r\n\t\t\t);\r\n\t\t}\r\n\r\n\t\tif (\r\n\t\t\targs.aggregateType === \"Count\" ||\r\n\t\t\targs.aggregateType === \"DistinctCount\"\r\n\t\t) {\r\n\t\t\tif (args.value) {\r\n\t\t\t\targs.value = args.value.toFixed(2);\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tif (\r\n\t\t\t!args.value &&\r\n\t\t\targs.value !== 0 &&\r\n\t\t\targs.value !== false &&\r\n\t\t\targs.value !== \"false\"\r\n\t\t) {\r\n\t\t\targs.skipFormatting = true;\r\n\t\t\targs.value = \"\";\r\n\t\t}\r\n\t\t// 新建pivot table, 还没有设置row, 选了column之后grandtotal会有值\r\n\t\tif (\r\n\t\t\targs.rowCellType === \"grandTotal\" &&\r\n\t\t\t!this.pivotObj.dataSourceSettings.rows.length\r\n\t\t) {\r\n\t\t\targs.value = \"\";\r\n\t\t}\r\n\t\t//SMP2-2889\r\n\t\tif (args.rowCellType === \"subTotal\") {\r\n\t\t\tconst valueField_data = this.config.yaxis.series.filter(\r\n\t\t\t\t(el) => el.colName === args.fieldName\r\n\t\t\t);\r\n\t\t\tif (valueField_data.length > 0) {\r\n\t\t\t\tif (valueField_data[0].showSubTotals === false) {\r\n\t\t\t\t\targs.value = \"\";\r\n\t\t\t\t\targs.skipFormatting = true;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t\tif (args.rowCellType === \"grandTotal\") {\r\n\t\t\tconst valueField_data = this.config.yaxis.series.filter(\r\n\t\t\t\t(el) => el.colName === args.fieldName\r\n\t\t\t);\r\n\t\t\tif (valueField_data.length > 0) {\r\n\t\t\t\tif (valueField_data[0].showGrandTotals === false) {\r\n\t\t\t\t\targs.value = \"\";\r\n\t\t\t\t\targs.skipFormatting = true;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t\t// SMP2-3416 start\r\n\t\tif (\r\n\t\t\tthis.zeroFormatData.hgList.includes(args.fieldName) &&\r\n\t\t\targs.value === 0\r\n\t\t) {\r\n\t\t\targs.value = \"-\";\r\n\t\t\targs.skipFormatting = true;\r\n\t\t}\r\n\t\tif (\r\n\t\t\tthis.zeroFormatData.emptyList.includes(args.fieldName) &&\r\n\t\t\targs.value === 0\r\n\t\t) {\r\n\t\t\targs.value = \"\";\r\n\t\t\targs.skipFormatting = true;\r\n\t\t}\r\n\t\tif (\r\n\t\t\tthis.millionFields.includes(args.fieldName) &&\r\n\t\t\t!isNaN(Number(args.value)) &&\r\n\t\t\targs.value !== 0 &&\r\n\t\t\targs.value !== \"\" &&\r\n\t\t\targs.value !== null\r\n\t\t) {\r\n\t\t\tif (\r\n\t\t\t\targs.columnCellType == \"grandTotal\" &&\r\n\t\t\t\targs.rowCellType == \"grandTotal\"\r\n\t\t\t) {\r\n\t\t\t\tif (!this.totalFormatted[args.fieldName]) {\r\n\t\t\t\t\tthis.totalFormatted[args.fieldName] = true;\r\n\t\t\t\t\targs.value = args.value / 1000000;\r\n\t\t\t\t}\r\n\t\t\t} else {\r\n\t\t\t\targs.value = args.value / 1000000;\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\t// SMP2-2486 & percentNum的format问题\r\n\t\tif (\r\n\t\t\tthis.percentNumFields.length &&\r\n\t\t\tthis.percentNumFields.includes(args.fieldName) &&\r\n\t\t\t!isNaN(Number(args.value)) &&\r\n\t\t\targs.value !== 0 &&\r\n\t\t\targs.value !== \"\" &&\r\n\t\t\targs.value !== null\r\n\t\t) {\r\n\t\t\tif (\r\n\t\t\t\targs.columnCellType == \"grandTotal\" &&\r\n\t\t\t\targs.rowCellType == \"grandTotal\"\r\n\t\t\t) {\r\n\t\t\t\tif (!this.totalFormatted[args.fieldName]) {\r\n\t\t\t\t\tthis.totalFormatted[args.fieldName] = true;\r\n\t\t\t\t\targs.value = args.value / 100;\r\n\t\t\t\t}\r\n\t\t\t} else {\r\n\t\t\t\targs.value = args.value / 100;\r\n\t\t\t}\r\n\t\t}\r\n\t\tif (\r\n\t\t\targs.aggregateType == \"CalculatedField\" &&\r\n\t\t\t!Number.isNaN(args.value)\r\n\t\t) {\r\n\t\t\targs.value = Number(args.value).toFixed(2);\r\n\t\t}\r\n\t\t// SMP2-3416 end\r\n\t\tthis.ref.markForCheck();\r\n\t\tthis.ref.detectChanges();\r\n\t}\r\n\r\n\tprivate calculatedFistLast(args, aggregateType, fieldName) {\r\n\t\tif (!args.row.actualText) args.row.actualText = args.row.formattedText;\r\n\t\tif (!args.column.actualText)\r\n\t\t\targs.column.actualText = args.column.formattedText;\r\n\t\tlet field = this.configFields.filter(\r\n\t\t\t(el) => el.colName === fieldName\r\n\t\t)[0];\r\n\r\n\t\tif (args.rowCellType === \"value\" && !args.row.hasChild) {\r\n\t\t\tif (args.cellSets[0]) {\r\n\t\t\t\tif (aggregateType === \"First\") {\r\n\t\t\t\t\tfor (\r\n\t\t\t\t\t\tlet firstIndex = 0;\r\n\t\t\t\t\t\tfirstIndex < args.cellSets.length;\r\n\t\t\t\t\t\tfirstIndex++\r\n\t\t\t\t\t) {\r\n\t\t\t\t\t\tif (\r\n\t\t\t\t\t\t\tthis.pivotObj.dataSourceSettings.columns.length ==\r\n\t\t\t\t\t\t\t\t1 &&\r\n\t\t\t\t\t\t\targs.columnCellType == \"grandTotal\"\r\n\t\t\t\t\t\t) {\r\n\t\t\t\t\t\t\tif (\r\n\t\t\t\t\t\t\t\tfield.dataType == \"string\" ||\r\n\t\t\t\t\t\t\t\tfield.dataType == \"nvarchar\" ||\r\n\t\t\t\t\t\t\t\tfield.dataType == \"date\" ||\r\n\t\t\t\t\t\t\t\tfield.dataType == \"datetime\"\r\n\t\t\t\t\t\t\t) {\r\n\t\t\t\t\t\t\t\targs.value = \"\";\r\n\t\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\t\tif (\r\n\t\t\t\t\t\t\t\t\tthis.allDataValue &&\r\n\t\t\t\t\t\t\t\t\tthis.allDataValue.length\r\n\t\t\t\t\t\t\t\t) {\r\n\t\t\t\t\t\t\t\t\tlet rowObjs =\r\n\t\t\t\t\t\t\t\t\t\tthis.allDataValue[args.row.rowIndex];\r\n\t\t\t\t\t\t\t\t\tif (rowObjs) {\r\n\t\t\t\t\t\t\t\t\t\tlet rowObjsArr = JSON.parse(\r\n\t\t\t\t\t\t\t\t\t\t\tJSON.stringify(rowObjs)\r\n\t\t\t\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\t\t\t\tlet obj = rowObjsArr.filter(\r\n\t\t\t\t\t\t\t\t\t\t\t(el) =>\r\n\t\t\t\t\t\t\t\t\t\t\t\tel.actualText == fieldName &&\r\n\t\t\t\t\t\t\t\t\t\t\t\tel.isGrandSum\r\n\t\t\t\t\t\t\t\t\t\t)[0];\r\n\t\t\t\t\t\t\t\t\t\tif (obj) args.value = obj.value;\r\n\t\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\t\t\targs.value = isNaN(\r\n\t\t\t\t\t\t\t\t\t\tNumber(\r\n\t\t\t\t\t\t\t\t\t\t\tthis.grandTotals[\r\n\t\t\t\t\t\t\t\t\t\t\t\t\"row\" +\r\n\t\t\t\t\t\t\t\t\t\t\t\t\targs.row.actualText +\r\n\t\t\t\t\t\t\t\t\t\t\t\t\tfieldName\r\n\t\t\t\t\t\t\t\t\t\t\t]\r\n\t\t\t\t\t\t\t\t\t\t)\r\n\t\t\t\t\t\t\t\t\t)\r\n\t\t\t\t\t\t\t\t\t\t? null\r\n\t\t\t\t\t\t\t\t\t\t: Number(\r\n\t\t\t\t\t\t\t\t\t\t\t\tthis.grandTotals[\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\"row\" +\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\targs.row.actualText +\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\tfieldName\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}\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\targs.value = args.cellSets[firstIndex][fieldName];\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\tif (\r\n\t\t\t\t\t\t\tfield.dataType == \"number\" ||\r\n\t\t\t\t\t\t\tfield.dataType == \"multiple\" ||\r\n\t\t\t\t\t\t\tfield.dataType == \"percent\" ||\r\n\t\t\t\t\t\t\tfield.dataType == \"percentNum\"\r\n\t\t\t\t\t\t) {\r\n\t\t\t\t\t\t\tif (args.value != null) break;\r\n\t\t\t\t\t\t} else if (\r\n\t\t\t\t\t\t\tfield.dataType == \"date\" ||\r\n\t\t\t\t\t\t\tfield.dataType == \"datetime\"\r\n\t\t\t\t\t\t) {\r\n\t\t\t\t\t\t\tif (this.pbf.time(args.value) > \"1900-01-01\") break;\r\n\t\t\t\t\t\t} else if (args.value) break;\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\tif (aggregateType === \"Last\") {\r\n\t\t\t\t\tfor (\r\n\t\t\t\t\t\tlet lastIndex = args.cellSets.length - 1;\r\n\t\t\t\t\t\tlastIndex >= 0;\r\n\t\t\t\t\t\tlastIndex--\r\n\t\t\t\t\t) {\r\n\t\t\t\t\t\tif (\r\n\t\t\t\t\t\t\tthis.pivotObj.dataSourceSettings.columns.length ==\r\n\t\t\t\t\t\t\t\t1 &&\r\n\t\t\t\t\t\t\targs.columnCellType == \"grandTotal\"\r\n\t\t\t\t\t\t) {\r\n\t\t\t\t\t\t\tif (\r\n\t\t\t\t\t\t\t\tfield.dataType == \"string\" ||\r\n\t\t\t\t\t\t\t\tfield.dataType == \"nvarchar\" ||\r\n\t\t\t\t\t\t\t\tfield.dataType == \"date\" ||\r\n\t\t\t\t\t\t\t\tfield.dataType == \"datetime\"\r\n\t\t\t\t\t\t\t) {\r\n\t\t\t\t\t\t\t\targs.value = \"\";\r\n\t\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\t\tif (\r\n\t\t\t\t\t\t\t\t\tthis.allDataValue &&\r\n\t\t\t\t\t\t\t\t\tthis.allDataValue.length\r\n\t\t\t\t\t\t\t\t) {\r\n\t\t\t\t\t\t\t\t\tlet rowObjs =\r\n\t\t\t\t\t\t\t\t\t\tthis.allDataValue[args.row.rowIndex];\r\n\t\t\t\t\t\t\t\t\tif (rowObjs) {\r\n\t\t\t\t\t\t\t\t\t\tlet rowObjsArr = JSON.parse(\r\n\t\t\t\t\t\t\t\t\t\t\tJSON.stringify(rowObjs)\r\n\t\t\t\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\t\t\t\tlet obj = rowObjsArr.filter(\r\n\t\t\t\t\t\t\t\t\t\t\t(el) =>\r\n\t\t\t\t\t\t\t\t\t\t\t\tel.actualText == fieldName &&\r\n\t\t\t\t\t\t\t\t\t\t\t\tel.isGrandSum\r\n\t\t\t\t\t\t\t\t\t\t)[0];\r\n\t\t\t\t\t\t\t\t\t\tif (obj) args.value = obj.value;\r\n\t\t\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\t\t\targs.value = isNaN(\r\n\t\t\t\t\t\t\t\t\t\tNumber(\r\n\t\t\t\t\t\t\t\t\t\t\tthis.grandTotals[\r\n\t\t\t\t\t\t\t\t\t\t\t\t\"row\" +\r\n\t\t\t\t\t\t\t\t\t\t\t\t\targs.row.actualText +\r\n\t\t\t\t\t\t\t\t\t\t\t\t\tfieldName\r\n\t\t\t\t\t\t\t\t\t\t\t]\r\n\t\t\t\t\t\t\t\t\t\t)\r\n\t\t\t\t\t\t\t\t\t)\r\n\t\t\t\t\t\t\t\t\t\t? null\r\n\t\t\t\t\t\t\t\t\t\t: Number(\r\n\t\t\t\t\t\t\t\t\t\t\t\tthis.grandTotals[\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\"row\" +\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\targs.row.actualText +\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\tfieldName\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}\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\t\targs.value = args.cellSets[lastIndex][fieldName];\r\n\t\t\t\t\t\t}\r\n\r\n\t\t\t\t\t\tif (\r\n\t\t\t\t\t\t\tfield.dataType == \"number\" ||\r\n\t\t\t\t\t\t\tfield.dataType == \"multiple\" ||\r\n\t\t\t\t\t\t\tfield.dataType == \"percent\" ||\r\n\t\t\t\t\t\t\tfield.dataType == \"percentNum\"\r\n\t\t\t\t\t\t) {\r\n\t\t\t\t\t\t\tif (args.value != null) break;\r\n\t\t\t\t\t\t} else if (\r\n\t\t\t\t\t\t\tfield.dataType == \"date\" ||\r\n\t\t\t\t\t\t\tfield.dataType == \"datetime\"\r\n\t\t\t\t\t\t) {\r\n\t\t\t\t\t\t\tif (this.pbf.time(args.value) > \"1900-01-01\") break;\r\n\t\t\t\t\t\t} else if (args.value) break;\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\r\n\t\t\t\tif (\r\n\t\t\t\t\tfield.dataType == \"number\" ||\r\n\t\t\t\t\tfield.dataType == \"multiple\" ||\r\n\t\t\t\t\tfield.dataType == \"percent\" ||\r\n\t\t\t\t\tfield.dataType == \"percentNum\"\r\n\t\t\t\t) {\r\n\t\t\t\t\tif (this.pivotObj.dataSourceSettings.rows.length) {\r\n\t\t\t\t\t\tif (!this.pivotObj.dataSourceSettings.columns.length) {\r\n\t\t\t\t\t\t\tif (\r\n\t\t\t\t\t\t\t\t!Number(this.grandTotals[fieldName]) ||\r\n\t\t\t\t\t\t\t\tisNaN(Number(this.grandTotals[fieldName]))\r\n\t\t\t\t\t\t\t) {\r\n\t\t\t\t\t\t\t\tthis.grandTotals[fieldName] = 0;\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\tif (args.aggregateType !== \"CalculatedField\") {\r\n\t\t\t\t\t\t\t\tthis.grandTotals[fieldName] += Number(\r\n\t\t\t\t\t\t\t\t\targs.value\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} else if (\r\n\t\t\t\t\t\t\tthis.pivotObj.dataSourceSettings.columns.length == 1\r\n\t\t\t\t\t\t) {\r\n\t\t\t\t\t\t\t// \"row\" + args.row.actualText + fieldName 表示(cell: args.rowCellType === \"value\" && args.columnCellType === \"grandTotal\")\r\n\t\t\t\t\t\t\tif (\r\n\t\t\t\t\t\t\t\t!Number(\r\n\t\t\t\t\t\t\t\t\tthis.grandTotals[\r\n\t\t\t\t\t\t\t\t\t\t\"row\" + args.row.actualText + fieldName\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\tisNaN(\r\n\t\t\t\t\t\t\t\t\tNumber(\r\n\t\t\t\t\t\t\t\t\t\tthis.grandTotals[\r\n\t\t\t\t\t\t\t\t\t\t\t\"row\" +\r\n\t\t\t\t\t\t\t\t\t\t\t\targs.row.actualText +\r\n\t\t\t\t\t\t\t\t\t\t\t\tfieldName\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)\r\n\t\t\t\t\t\t\t) {\r\n\t\t\t\t\t\t\t\tthis.grandTotals[\r\n\t\t\t\t\t\t\t\t\t\"row\" + args.row.actualText + fieldName\r\n\t\t\t\t\t\t\t\t] = 0;\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\tthis.grandTotals[\r\n\t\t\t\t\t\t\t\t\"row\" + args.row.actualText + fieldName\r\n\t\t\t\t\t\t\t] += Number(args.value);\r\n\r\n\t\t\t\t\t\t\t// \"col\" + args.column.actualText + fieldName 表示(cell: args.rowCellType === \"grandTotal\" && args.columnCellType === \"value\")\r\n\t\t\t\t\t\t\tif (\r\n\t\t\t\t\t\t\t\t!Number(\r\n\t\t\t\t\t\t\t\t\tthis.grandTotals[\r\n\t\t\t\t\t\t\t\t\t\t\"col\" +\r\n\t\t\t\t\t\t\t\t\t\t\targs.column.actualText +\r\n\t\t\t\t\t\t\t\t\t\t\tfieldName\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\tisNaN(\r\n\t\t\t\t\t\t\t\t\tNumber(\r\n\t\t\t\t\t\t\t\t\t\tthis.grandTotals[\r\n\t\t\t\t\t\t\t\t\t\t\t\"col\" +\r\n\t\t\t\t\t\t\t\t\t\t\t\targs.column.actualText +\r\n\t\t\t\t\t\t\t\t\t\t\t\tfieldName\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)\r\n\t\t\t\t\t\t\t) {\r\n\t\t\t\t\t\t\t\tthis.grandTotals[\r\n\t\t\t\t\t\t\t\t\t\"col\" + args.column.actualText + fieldName\r\n\t\t\t\t\t\t\t\t] = 0;\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\tthis.grandTotals[\r\n\t\t\t\t\t\t\t\t\"col\" + args.column.actualText + fieldName\r\n\t\t\t\t\t\t\t] += Number(args.value);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t} else if (args.rowCellType === \"subTotal\" || args.row.hasChild) {\r\n\t\t\tconst dataType = field.dataType;\r\n\t\t\tif (\r\n\t\t\t\tdataType === \"string\" ||\r\n\t\t\t\tdataType === \"nvarchar\" ||\r\n\t\t\t\tdataType == \"date\" ||\r\n\t\t\t\tdataType == \"datetime\"\r\n\t\t\t) {\r\n\t\t\t\targs.value = \"\";\r\n\t\t\t} else {\r\n\t\t\t\tlet value = 0;\r\n\t\t\t\tlet childHeaders = [];\r\n\t\t\t\tif (aggregateType === \"First\") {\r\n\t\t\t\t\tlet groupNameArrays = [];\r\n\t\t\t\t\tlet rows = this.pivotObj.dataSourceSettings.rows;\r\n\t\t\t\t\tfor (\r\n\t\t\t\t\t\tlet index = args.row.level;\r\n\t\t\t\t\t\tindex < rows.length;\r\n\t\t\t\t\t\tindex++\r\n\t\t\t\t\t) {\r\n\t\t\t\t\t\tgroupNameArrays.push(rows[index].name);\r\n\t\t\t\t\t}\r\n\t\t\t\t\tfor (let i = 0; i < args.cellSets.length; i++) {\r\n\t\t\t\t\t\tlet values = [];\r\n\t\t\t\t\t\tlet header = groupNameArrays\r\n\t\t\t\t\t\t\t.map((name) => {\r\n\t\t\t\t\t\t\t\tvalues.push(args.cellSets[i][name]);\r\n\t\t\t\t\t\t\t\treturn args.cellSets[i][name];\r\n\t\t\t\t\t\t\t})\r\n\t\t\t\t\t\t\t.join(\"-\");\r\n\t\t\t\t\t\tif (!(childHeaders as any).includes(header)) {\r\n\t\t\t\t\t\t\tlet filterObj: any = {};\r\n\t\t\t\t\t\t\tgroupNameArrays.map(\r\n\t\t\t\t\t\t\t\t(name, x) => (filterObj[name] = values[x])\r\n\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\tlet _CellSets = _filter(args.cellSets, filterObj);\r\n\t\t\t\t\t\t\tchildHeaders.push(header);\r\n\t\t\t\t\t\t\tvalue += Number(_CellSets[0][fieldName]) || 0;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\tif (aggregateType === \"Last\") {\r\n\t\t\t\t\tlet groupNameArrays = [];\r\n\t\t\t\t\tlet rows = this.pivotObj.dataSourceSettings.rows;\r\n\t\t\t\t\tfor (\r\n\t\t\t\t\t\tlet index = args.row.level;\r\n\t\t\t\t\t\tindex < rows.length;\r\n\t\t\t\t\t\tindex++\r\n\t\t\t\t\t) {\r\n\t\t\t\t\t\tgroupNameArrays.push(rows[index].name);\r\n\t\t\t\t\t}\r\n\t\t\t\t\tfor (let i = args.cellSets.length - 1; i >= 0; i--) {\r\n\t\t\t\t\t\tlet values = [];\r\n\t\t\t\t\t\tlet header = groupNameArrays\r\n\t\t\t\t\t\t\t.map((name) => {\r\n\t\t\t\t\t\t\t\tvalues.push(args.cellSets[i][name]);\r\n\t\t\t\t\t\t\t\treturn args.cellSets[i][name];\r\n\t\t\t\t\t\t\t})\r\n\t\t\t\t\t\t\t.join(\"-\");\r\n\t\t\t\t\t\tif (!(childHeaders as any).includes(header)) {\r\n\t\t\t\t\t\t\tlet filterObj: any = {};\r\n\t\t\t\t\t\t\tgroupNameArrays.map(\r\n\t\t\t\t\t\t\t\t(name, x) => (filterObj[name] = values[x])\r\n\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\tlet _CellSets = _filter(args.cellSets, filterObj);\r\n\t\t\t\t\t\t\tchildHeaders.push(header);\r\n\t\t\t\t\t\t\tvalue +=\r\n\t\t\t\t\t\t\t\tNumber(\r\n\t\t\t\t\t\t\t\t\t_CellSets[_CellSets.length - 1][fieldName]\r\n\t\t\t\t\t\t\t\t) || 0;\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\tif (args.column.actualText !== \"Grand Total\")\r\n\t\t\t\t\tthis.columnTexts.push(args.column.actualText);\r\n\r\n\t\t\t\tif (!this.pivotObj.dataSourceSettings.columns.length) {\r\n\t\t\t\t\tif (\r\n\t\t\t\t\t\t!Number(this.subTotals[fieldName]) ||\r\n\t\t\t\t\t\tisNaN(Number(this.subTotals[fieldName]))\r\n\t\t\t\t\t) {\r\n\t\t\t\t\t\tthis.subTotals[fieldName] = 0;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tthis.subTotals[fieldName] += Number(value);\r\n\t\t\t\t} else if (\r\n\t\t\t\t\tthis.pivotObj.dataSourceSettings.columns.length == 1\r\n\t\t\t\t) {\r\n\t\t\t\t\t// \"row\" + args.row.actualText + fieldName 表示(cell: args.rowCellType === \"value\" && args.columnCellType === \"grandTotal\")\r\n\t\t\t\t\tif (\r\n\t\t\t\t\t\t!Number(\r\n\t\t\t\t\t\t\tthis.subTotals[\r\n\t\t\t\t\t\t\t\targs.row.actualText +\r\n\t\t\t\t\t\t\t\t\targs.column.actualText +\r\n\t\t\t\t\t\t\t\t\tfieldName\r\n\t\t\t\t\t\t\t]\r\n\t\t\t\t\t\t) ||\r\n\t\t\t\t\t\tisNaN(\r\n\t\t\t\t\t\t\tNumber(\r\n\t\t\t\t\t\t\t\tthis.subTotals[\r\n\t\t\t\t\t\t\t\t\targs.row.actualText +\r\n\t\t\t\t\t\t\t\t\t\targs.column.actualText +\r\n\t\t\t\t\t\t\t\t\t\tfieldName\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\tthis.subTotals[\r\n\t\t\t\t\t\t\targs.row.actualText +\r\n\t\t\t\t\t\t\t\targs.column.actualText +\r\n\t\t\t\t\t\t\t\tfieldName\r\n\t\t\t\t\t\t] = 0;\r\n\t\t\t\t\t}\r\n\t\t\t\t\tthis.subTotals[\r\n\t\t\t\t\t\targs.row.actualText + args.column.actualText + fieldName\r\n\t\t\t\t\t] += Number(value);\r\n\t\t\t\t}\r\n\t\t\t\t// ---> allDataValue中这个单元格的值不正确\r\n\t\t\t\tif (\r\n\t\t\t\t\targs.columnCellType === \"grandTotal\" &&\r\n\t\t\t\t\tthis.pivotObj.dataSourceSettings.columns.length == 1\r\n\t\t\t\t) {\r\n\t\t\t\t\tif (this.allDataValue && this.allDataValue.length) {\r\n\t\t\t\t\t\targs.value =\r\n\t\t\t\t\t\t\tthis.subTotals[\r\n\t\t\t\t\t\t\t\targs.row.actualText + \"Grand Total\" + fieldName\r\n\t\t\t\t\t\t\t];\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\t// 把前边这个field的几列subtotal加起来\r\n\t\t\t\t\t\tthis.columnTexts = uniqBy(this.columnTexts, (el) => el);\r\n\t\t\t\t\t\tlet val = 0;\r\n\t\t\t\t\t\tfor (let i = 0; i < this.columnTexts.length; i++) {\r\n\t\t\t\t\t\t\tconst element = this.columnTexts[i];\r\n\t\t\t\t\t\t\tval +=\r\n\t\t\t\t\t\t\t\tthis.subTotals[\r\n\t\t\t\t\t\t\t\t\targs.row.actualText + element + fieldName\r\n\t\t\t\t\t\t\t\t];\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t\targs.value = val;\r\n\t\t\t\t\t}\r\n\t\t\t\t} else {\r\n\t\t\t\t\targs.value = value;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t} else if (args.rowCellType === \"grandTotal\") {\r\n\t\t\tconst dataType = field.dataType;\r\n\t\t\tif (\r\n\t\t\t\tdataType == \"string\" ||\r\n\t\t\t\tdataType == \"nvarchar\" ||\r\n\t\t\t\tdataType == \"date\" ||\r\n\t\t\t\tdataType == \"datetime\"\r\n\t\t\t) {\r\n\t\t\t\targs.value = \"\";\r\n\t\t\t} else {\r\n\t\t\t\tif (!this.pivotObj.dataSourceSettings.columns.length) {\r\n\t\t\t\t\tif (this.allDataValue && this.allDataValue.length) {\r\n\t\t\t\t\t\tlet rowObjs =\r\n\t\t\t\t\t\t\tthis.allDataValue[this.allDataValue.length - 1];\r\n\t\t\t\t\t\tif (rowObjs) {\r\n\t\t\t\t\t\t\tlet rowObjsArr = JSON.parse(\r\n\t\t\t\t\t\t\t\tJSON.stringify(rowObjs)\r\n\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\tlet objArr = rowObjsArr.filter(\r\n\t\t\t\t\t\t\t\t(el) =>\r\n\t\t\t\t\t\t\t\t\tel.actualText == fieldName && el.isGrandSum\r\n\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\tif (objArr && objArr.length) {\r\n\t\t\t\t\t\t\t\targs.value = objArr[objArr.length - 1].value;\r\n\t\t\t\t\t\t\t} else if (\r\n\t\t\t\t\t\t\t\tObject.keys(this.grandTotals).includes(\r\n\t\t\t\t\t\t\t\t\tfieldName\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\t\targs.value = this.grandTotals[fieldName];\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\targs.value = this.grandTotals[fieldName];\r\n\t\t\t\t\t}\r\n\t\t\t\t} else {\r\n\t\t\t\t\tif (args.columnCellType === \"grandTotal\") {\r\n\t\t\t\t\t\tif (this.allDataValue && this.allDataValue.length) {\r\n\t\t\t\t\t\t\tlet rowObjs =\r\n\t\t\t\t\t\t\t\tthis.allDataValue[this.allDataValue.length - 1];\r\n\t\t\t\t\t\t\tif (rowObjs) {\r\n\t\t\t\t\t\t\t\tlet rowObjsArr = JSON.parse(\r\n\t\t\t\t\t\t\t\t\tJSON.stringify(rowObjs)\r\n\t\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\t\tlet objArr = rowObjsArr.filter(\r\n\t\t\t\t\t\t\t\t\t(el) =>\r\n\t\t\t\t\t\t\t\t\t\tel.actualText == fieldName &&\r\n\t\t\t\t\t\t\t\t\t\tel.isGrandSum\r\n\t\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\t\tif (objArr && objArr.length) {\r\n\t\t\t\t\t\t\t\t\targs.value =\r\n\t\t\t\t\t\t\t\t\t\tobjArr[objArr.length - 1].value;\r\n\t\t\t\t\t\t\t\t} else if (\r\n\t\t\t\t\t\t\t\t\tObject.keys(this.grandTotals).includes(\r\n\t\t\t\t\t\t\t\t\t\t\"col\" +\r\n\t\t\t\t\t\t\t\t\t\t\targs.column.actualText +\r\n\t\t\t\t\t\t\t\t\t\t\tfieldName\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\targs.value =\r\n\t\t\t\t\t\t\t\t\t\tthis.grandTotals[\r\n\t\t\t\t\t\t\t\t\t\t\t\"col\" +\r\n\t\t\t\t\t\t\t\t\t\t\t\targs.column.actualText +\r\n\t\t\t\t\t\t\t\t\t\t\t\tfieldName\r\n\t\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} else {\r\n\t\t\t\t\t\t\targs.value =\r\n\t\t\t\t\t\t\t\tthis.grandTotals[\r\n\t\t\t\t\t\t\t\t\t\"col\" + args.column.actualText + fieldName\r\n\t\t\t\t\t\t\t\t];\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\t// if (\r\n\t\t\t\t\t\t// \tthis.pivotObj.dataSourceSettings.columns.length == 1\r\n\t\t\t\t\t\t// ) {\r\n\t\t\t\t\t\t// \targs.value = this.grandTotals[\r\n\t\t\t\t\t\t// \t\t\"col\" + args.column.actualText + fieldName\r\n\t\t\t\t\t\t// \t];\r\n\t\t\t\t\t\t// }\r\n\t\t\t\t\t\tif (this.allDataValue && this.allDataValue.length) {\r\n\t\t\t\t\t\t\tlet rowObjs =\r\n\t\t\t\t\t\t\t\tthis.allDataValue[this.allDataValue.length - 1];\r\n\t\t\t\t\t\t\tlet rowObjsArr = JSON.parse(\r\n\t\t\t\t\t\t\t\tJSON.stringify(rowObjs)\r\n\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\tlet objArr = rowObjsArr.filter(\r\n\t\t\t\t\t\t\t\t(el) =>\r\n\t\t\t\t\t\t\t\t\tel.actualText == fieldName &&\r\n\t\t\t\t\t\t\t\t\tel.isGrandSum &&\r\n\t\t\t\t\t\t\t\t\tel.columnHeaders == args.column.actualText\r\n\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\tif (objArr && objArr.length) {\r\n\t\t\t\t\t\t\t\targs.value = objArr[objArr.length - 1].value;\r\n\t\t\t\t\t\t\t} else if (\r\n\t\t\t\t\t\t\t\tObject.keys(this.grandTotals).includes(\r\n\t\t\t\t\t\t\t\t\t\"col\" + args.column.actualText + fieldName\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\t\targs.value =\r\n\t\t\t\t\t\t\t\t\tthis.grandTotals[\r\n\t\t\t\t\t\t\t\t\t\t\"col\" +\r\n\t\t\t\t\t\t\t\t\t\t\targs.column.actualText +\r\n\t\t\t\t\t\t\t\t\t\t\tfieldName\r\n\t\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} else {\r\n\t\t\t\t\t\t\targs.value =\r\n\t\t\t\t\t\t\t\tthis.grandTotals[\r\n\t\t\t\t\t\t\t\t\t\"col\" + args.column.actualText + fieldName\r\n\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\t\t\t}\r\n\t\t}\r\n\t\tthis.formatVal(args, fieldName);\r\n\t\treturn args.value;\r\n\t}\r\n\r\n\tprivate formatVal(args, fieldName) {\r\n\t\tthis.configFields.forEach((field) => {\r\n\t\t\tif (field.colName == fieldName) {\r\n\t\t\t\tswitch (field.dataType) {\r\n\t\t\t\t\tcase \"date\":\r\n\t\t\t\t\tcase \"datetime\":\r\n\t\t\t\t\t\tif (args.value) args.value = new Date(args.value);\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}\r\n\t\t});\r\n\t}\r\n\r\n\tprivate getexcludeFields(fields, data) {\r\n\t\tlet namearray = [];\r\n\t\tlet array = [];\r\n\t\tfor (let prop in data) {\r\n\t\t\tarray.push(prop);\r\n\t\t}\r\n\t\tfor (let item of fields) {\r\n\t\t\tnamearray.push(item.colName);\r\n\t\t}\r\n\t\tthis.excludeFields = differenceWith(array, namearray);\r\n\t\tif (\r\n\t\t\tthis.excludeFields.length &&\r\n\t\t\tthis.config.groupSettings &&\r\n\t\t\tthis.config.groupSettings.length\r\n\t\t) {\r\n\t\t\tfor (let i = 0; i < this.excludeFields.length; i++) {\r\n\t\t\t\tconst el = this.excludeFields[i];\r\n\t\t\t\tif (startsWith(el, this.config.groupSettings[0].name + \"_\")) {\r\n\t\t\t\t\tthis.excludeFields.splice(i, 1);\r\n\t\t\t\t\ti--;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tprivate getInfo() {\r\n\t\tthis.datePipeFormat = localStorage.getItem(\"datePipe\");\r\n\t\tthis.translation = JSON.parse(localStorage.getItem(\"translation\"));\r\n\t\tL10n.load({\r\n\t\t\t\"en-US\": {\r\n\t\t\t\tpivotview: AGGREGATE_TYPES_TEXT,\r\n\t\t\t\tpivotfieldlist: AGGREGATE_TYPES_TEXT,\r\n\t\t\t},\r\n\t\t\tzh: {\r\n\t\t\t\tpivotview: AGGREGATE_TYPES_TEXT,\r\n\t\t\t\tpivotfieldlist: AGGREGATE_TYPES_TEXT,\r\n\t\t\t},\r\n\t\t\t\"zh-Hant-HK\": {\r\n\t\t\t\tpivotview: AGGREGATE_TYPES_TEXT,\r\n\t\t\t\tpivotfieldlist: AGGREGATE_TYPES_TEXT,\r\n\t\t\t},\r\n\t\t\tja: {\r\n\t\t\t\tpivotview: AGGREGATE_TYPES_TEXT,\r\n\t\t\t\tpivotfieldlist: AGGREGATE_TYPES_TEXT,\r\n\t\t\t},\r\n\t\t\tko: {\r\n\t\t\t\tpivotview: AGGREGATE_TYPES_TEXT,\r\n\t\t\t\tpivotfieldlist: AGGREGATE_TYPES_TEXT,\r\n\t\t\t},\r\n\t\t\tfr: {\r\n\t\t\t\tpivotview: AGGREGATE_TYPES_TEXT,\r\n\t\t\t\tpivotfieldlist: AGGREGATE_TYPES_TEXT,\r\n\t\t\t},\r\n\t\t});\r\n\t}\r\n\r\n\tpublic onFieldDrop(args: FieldDropEventArgs) {\r\n\t\t//change the calcualteField method use the corresponding calculate\r\n\t\tconst calcualteField = this.configFields.filter(\r\n\t\t\t(el) => el.colName === args.fieldName && el.isCalculatedField\r\n\t\t);\r\n\t\tif (calcualteField.length > 0) {\r\n\t\t\targs.dropField.type =\r\n\t\t\t\tthis.dashboardPorletsService.getCalculateMethod(\r\n\t\t\t\t\tcalcualteField[0].colName\r\n\t\t\t\t) as any;\r\n\t\t\targs.dropField.caption = args.dropField.caption\r\n\t\t\t\t.replace(\"Calculate\", \"\")\r\n\t\t\t\t.trim();\r\n\t\t}\r\n\t\tfor (\r\n\t\t\tlet i = 0;\r\n\t\t\ti < args.dataSourceSettings.filterSettings.length;\r\n\t\t\ti++\r\n\t\t) {\r\n\t\t\tif (\r\n\t\t\t\targs.dataSourceSettings.filterSettings[i].name ===\r\n\t\t\t\t\targs.fieldName &&\r\n\t\t\t\targs.dropAxis === \"\"\r\n\t\t\t) {\r\n\t\t\t\targs.dataSourceSettings.filterSettings.splice(i, 1);\r\n\t\t\t\tthis.filterSettings = args.dataSourceSettings.filterSettings;\r\n\t\t\t\tbreak;\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tprivate createButtonText(field, i, axis, valuePos) {\r\n\t\tlet buttonText: HTMLElement;\r\n\t\tlet aggregation: string;\r\n\t\tlet filterMem: string;\r\n\t\tif (axis === \"filters\") {\r\n\t\t\tfilterMem = (\r\n\t\t\t\tthis.fieldlistObj.pivotButtonModule as any\r\n\t\t\t).updateButtontext(field[i].name);\r\n\t\t}\r\n\t\tlet engineModule = this.pivotObj.engineModule;\r\n\t\tif (engineModule.fieldList[field[i].name] !== undefined) {\r\n\t\t\taggregation = engineModule.fieldList[field[i].name].aggregateType;\r\n\t\t\taggregation =\r\n\t\t\t\taggregation === \"Sum\"\r\n\t\t\t\t\t? engineModule.fieldList[field[i].name].type !== \"number\"\r\n\t\t\t\t\t\t? \"Count\"\r\n\t\t\t\t\t\t: \"Sum\"\r\n\t\t\t\t\t: aggregation;\r\n\t\t}\r\n\t\tlet text: string = field[i].caption ? field[i].caption : field[i].name;\r\n\t\tbuttonText = createElement(\"span\", {\r\n\t\t\tattrs: {\r\n\t\t\t\ttitle:\r\n\t\t\t\t\taxis === \"filters\"\r\n\t\t\t\t\t\t? text + \" (\" + filterMem + \")\"\r\n\t\t\t\t\t\t: !this.pivotObj.dataSourceSettings\r\n\t\t\t\t\t\t\t\t.showAggregationOnValueField ||\r\n\t\t\t\t\t\t  axis !== \"values\" ||\r\n\t\t\t\t\t\t  aggregation === \"CalculatedField\"\r\n\t\t\t\t\t\t? text\r\n\t\t\t\t\t\t: this.pivotObj.localeObj.getConstant(aggregation) +\r\n\t\t\t\t\t\t  \" \" +\r\n\t\t\t\t\t\t  this.pivotObj.localeObj.getConstant(\"of\") +\r\n\t\t\t\t\t\t  \" \" +\r\n\t\t\t\t\t\t  text,\r\n\t\t\t\ttabindex: \"-1\",\r\n\t\t\t\t\"aria-disabled\": \"false\",\r\n\t\t\t\toncontextmenu: \"return false;\",\r\n\t\t\t\t\"data-type\": valuePos === i ? \"\" : aggregation,\r\n\t\t\t},\r\n\t\t\tclassName:\r\n\t\t\t\t\"e-content\" +\r\n\t\t\t\t\" \" +\r\n\t\t\t\t(this.pivotObj.getModuleName() === \"pivotview\"\r\n\t\t\t\t\t? this.pivotObj.groupingBarSettings.allowDragAndDrop &&\r\n\t\t\t\t\t  field[i].allowDragAndDrop\r\n\t\t\t\t\t\t? \"\"\r\n\t\t\t\t\t\t: \"e-disable-drag\"\r\n\t\t\t\t\t: \"\"),\r\n\t\t\tinnerHTML:\r\n\t\t\t\taxis === \"filters\"\r\n\t\t\t\t\t? text + \" (\" + filterMem + \")\"\r\n\t\t\t\t\t: !this.pivotObj.dataSourceSettings\r\n\t\t\t\t\t\t\t.showAggregationOnValueField ||\r\n\t\t\t\t\t  axis !== \"values\" ||\r\n\t\t\t\t\t  aggregation === \"CalculatedField\"\r\n\t\t\t\t\t? text\r\n\t\t\t\t\t: this.pivotObj.localeObj.getConstant(aggregation) +\r\n\t\t\t\t\t  \" \" +\r\n\t\t\t\t\t  this.pivotObj.localeObj.getConstant(\"of\") +\r\n\t\t\t\t\t  \" \" +\r\n\t\t\t\t\t  text,\r\n\t\t});\r\n\t\treturn buttonText;\r\n\t}\r\n\r\n\t// Calculated field事件：创建\r\n\tpublic calculatedFieldCreate(args: CalculatedFieldCreateEventArgs) {\r\n\t\tif (\r\n\t\t\targs.calculatedField.name !== \"\" &&\r\n\t\t\targs.calculatedField.name.trim() !== \"\"\r\n\t\t) {\r\n\t\t\tlet index =\r\n\t\t\t\tthis.fieldlistObj.dataSourceSettings.calculatedFieldSettings.findIndex(\r\n\t\t\t\t\t(el) => el.name === args.calculatedField.name\r\n\t\t\t\t);\r\n\t\t\tif (index !== -1) {\r\n\t\t\t\tif (args.calculatedField.formatString === \"\") {\r\n\t\t\t\t\tthis.fieldlistObj.dataSourceSettings.calculatedFieldSettings[\r\n\t\t\t\t\t\tindex\r\n\t\t\t\t\t].formatString = \"N2\";\r\n\t\t\t\t} else {\r\n\t\t\t\t\tthis.fieldlistObj.dataSourceSettings.calculatedFieldSettings[\r\n\t\t\t\t\t\tindex\r\n\t\t\t\t\t].formatString = args.calculatedField.formatString;\r\n\t\t\t\t}\r\n\t\t\t} else {\r\n\t\t\t\tif (args.calculatedField.formatString === \"\") {\r\n\t\t\t\t\targs.calculatedField.formatString = \"N2\";\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\t// 移除重复\r\n\t\t\tlet fIndex = this.customCalculatedFields.findIndex(\r\n\t\t\t\t(f) => f.name === args.calculatedField.name\r\n\t\t\t);\r\n\t\t\tif (fIndex > -1) {\r\n\t\t\t\tthis.customCalculatedFields.splice(fIndex, 1);\r\n\t\t\t}\r\n\t\t\t// 匹配运算符 First || Last\r\n\t\t\tlet formulaStr = args.calculatedField.formula;\r\n\t\t\tlet reg1 = /\"First\\((.+?)\\)\"/g;\r\n\t\t\tlet reg2 = /\"Last\\((.+?)\\)\"/g;\r\n\t\t\tif (reg1.test(formulaStr) || reg2.test(formulaStr)) {\r\n\t\t\t\t// 判断是否存在First || Last 表达式\r\n\t\t\t\tlet matchFirstFields = Array.from(\r\n\t\t\t\t\tformulaStr[\"matchAll\"](/\"First\\((.+?)\\)\"/g),\r\n\t\t\t\t\t(m) => {\r\n\t\t\t\t\t\treturn {\r\n\t\t\t\t\t\t\tmatchStr: m[0],\r\n\t\t\t\t\t\t\tmatchWord: m[1],\r\n\t\t\t\t\t\t\treplaceValue: \"\",\r\n\t\t\t\t\t\t\tmatchMethod: \"First\",\r\n\t\t\t\t\t\t};\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t\tlet matchLastFields = Array.from(\r\n\t\t\t\t\tformulaStr[\"matchAll\"](/\"Last\\((.+?)\\)\"/g),\r\n\t\t\t\t\t(m) => {\r\n\t\t\t\t\t\treturn {\r\n\t\t\t\t\t\t\tmatchStr: m[0],\r\n\t\t\t\t\t\t\tmatchWord: m[1],\r\n\t\t\t\t\t\t\treplaceValue: \"\",\r\n\t\t\t\t\t\t\tmatchMethod: \"Last\",\r\n\t\t\t\t\t\t};\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t\tlet matchMaxFields = Array.from(\r\n\t\t\t\t\tformulaStr[\"matchAll\"](/\"Max\\((.+?)\\)\"/g),\r\n\t\t\t\t\t(m) => {\r\n\t\t\t\t\t\treturn {\r\n\t\t\t\t\t\t\tmatchStr: m[0],\r\n\t\t\t\t\t\t\tmatchWord: m[1],\r\n\t\t\t\t\t\t\treplaceValue: \"\",\r\n\t\t\t\t\t\t\tmatchMethod: \"Max\",\r\n\t\t\t\t\t\t};\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t\tlet matchMinFields = Array.from(\r\n\t\t\t\t\tformulaStr[\"matchAll\"](/\"Min\\((.+?)\\)\"/g),\r\n\t\t\t\t\t(m) => {\r\n\t\t\t\t\t\treturn {\r\n\t\t\t\t\t\t\tmatchStr: m[0],\r\n\t\t\t\t\t\t\tmatchWord: m[1],\r\n\t\t\t\t\t\t\treplaceValue: \"\",\r\n\t\t\t\t\t\t\tmatchMethod: \"Min\",\r\n\t\t\t\t\t\t};\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t\tlet matchSumFields = Array.from(\r\n\t\t\t\t\tformulaStr[\"matchAll\"](/\"Sum\\((.+?)\\)\"/g),\r\n\t\t\t\t\t(m) => {\r\n\t\t\t\t\t\treturn {\r\n\t\t\t\t\t\t\tmatchStr: m[0],\r\n\t\t\t\t\t\t\tmatchWord: m[1],\r\n\t\t\t\t\t\t\treplaceValue: \"\",\r\n\t\t\t\t\t\t\tmatchMethod: \"Sum\",\r\n\t\t\t\t\t\t};\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t\tlet matchAvgFields = Array.from(\r\n\t\t\t\t\tformulaStr[\"matchAll\"](/\"Avg\\((.+?)\\)\"/g),\r\n\t\t\t\t\t(m) => {\r\n\t\t\t\t\t\treturn {\r\n\t\t\t\t\t\t\tmatchStr: m[0],\r\n\t\t\t\t\t\t\tmatchWord: m[1],\r\n\t\t\t\t\t\t\treplaceValue: \"\",\r\n\t\t\t\t\t\t\tmatchMethod: \"Avg\",\r\n\t\t\t\t\t\t};\r\n\t\t\t\t\t}\r\n\t\t\t\t);\r\n\t\t\t\tif (\r\n\t\t\t\t\tmatchFirstFields.every((x) =>\r\n\t\t\t\t\t\tthis.allowedCalculatedFields.includes(x.matchWord)\r\n\t\t\t\t\t) &&\r\n\t\t\t\t\tmatchLastFields.every((x) =>\r\n\t\t\t\t\t\tthis.allowedCalculatedFields.includes(x.matchWord)\r\n\t\t\t\t\t)\r\n\t\t\t\t) {\r\n\t\t\t\t\t// 判断First和Last表达式内的字段是否合法\r\n\t\t\t\t\tthis.customCalculatedFields.push({\r\n\t\t\t\t\t\tname: args.calculatedField.name,\r\n\t\t\t\t\t\tformula: args.calculatedField.formula,\r\n\t\t\t\t\t\tmatchFields: [\r\n\t\t\t\t\t\t\t// @ts-ignore\r\n\t\t\t\t\t\t\t...matchFirstFields,\r\n\t\t\t\t\t\t\t...matchLastFields,\r\n\t\t\t\t\t\t\t...matchMaxFields,\r\n\t\t\t\t\t\t\t...matchMinFields,\r\n\t\t\t\t\t\t\t...matchSumFields,\r\n\t\t\t\t\t\t\t...matchAvgFields,\r\n\t\t\t\t\t\t],\r\n\t\t\t\t\t\tgrandTotal: 0,\r\n\t\t\t\t\t});\r\n\t\t\t\t\tlet fieldName = (\r\n\t\t\t\t\t\tformulaStr.split(\"First(\")[1] ||\r\n\t\t\t\t\t\tformulaStr.split(\"Last(\")[1]\r\n\t\t\t\t\t).split(\")\")[0];\r\n\t\t\t\t\targs.calculatedField.formula =\r\n\t\t\t\t\t\t\"'\\\"\" + \"Sum(\" + fieldName + ')\"=' + formulaStr + \"'\";\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\t// Calculated field事件：完成\r\n\tpublic actionComplete(args) {\r\n\t\tif (args.actionName == \"Field removed\") {\r\n\t\t\tif (\r\n\t\t\t\targs.fieldInfo &&\r\n\t\t\t\targs.fieldInfo.fieldItem &&\r\n\t\t\t\targs.fieldInfo.fieldItem.type == \"CalculatedField\"\r\n\t\t\t) {\r\n\t\t\t\tlet field = args.fieldInfo.fieldName;\r\n\t\t\t\t// Remove the deleted calculated field from an stored array.\r\n\t\t\t\tthis.customCalculatedFields =\r\n\t\t\t\t\tthis.customCalculatedFields.filter(function (obj) {\r\n\t\t\t\t\t\treturn obj.name !== field;\r\n\t\t\t\t\t});\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\t// Calculated field事件：开始\r\n\tpublic actionBegin(args) {\r\n\t\tif (args.actionName === \"Edit calculated field\") {\r\n\t\t\tfor (let i = 0; i < this.customCalculatedFields.length; i++) {\r\n\t\t\t\tif (\r\n\t\t\t\t\tthis.customCalculatedFields[i].name &&\r\n\t\t\t\t\tthis.pivotObj.engineModule.fieldList[\r\n\t\t\t\t\t\tthis.customCalculatedFields[i].name\r\n\t\t\t\t\t]\r\n\t\t\t\t) {\r\n\t\t\t\t\tthis.pivotObj.engineModule.fieldList[\r\n\t\t\t\t\t\tthis.customCalculatedFields[i].name\r\n\t\t\t\t\t].formula = this.customCalculatedFields[i].formula;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tprivate resizeStop(args) {\r\n\t\tif (this.config.columnsWidth) {\r\n\t\t\tconst header_field = this.config.columnsWidth.filter(\r\n\t\t\t\t(el) => el.headerText === args.column.headerText\r\n\t\t\t);\r\n\t\t\tif (header_field.length > 0) {\r\n\t\t\t\theader_field[0].width = parseInt(args.column.width);\r\n\t\t\t} else {\r\n\t\t\t\tthis.config.columnsWidth.push({\r\n\t\t\t\t\theaderText: args.column.headerText,\r\n\t\t\t\t\twidth: parseInt(args.column.width),\r\n\t\t\t\t});\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tthis.config.columnsWidth = [];\r\n\t\t\tthis.config.columnsWidth.push({\r\n\t\t\t\theaderText: args.column.headerText,\r\n\t\t\t\twidth: parseInt(args.column.width),\r\n\t\t\t});\r\n\t\t}\r\n\t\tconst portlet = this.portlet;\r\n\t\tportlet.config = JSON.stringify(this.config);\r\n\t\tconst index = this.portlets.findIndex((x) => x.newId === portlet.newId);\r\n\t\tif (index > -1) this.portlets[index] = portlet;\r\n\t}\r\n\r\n\tpublic onLoad(): void {}\r\n\r\n\tprivate enginePopulated(args) {\r\n\t\tlet clonedValues: IPivotValues;\r\n\t\tlet currentPivotValues: any = this.getClonedPivotValues(\r\n\t\t\tthis.pivotObj.engineModule.pivotValues\r\n\t\t);\r\n\t\tlet pageSettings: IPageSettings =\r\n\t\t\tthis.pivotObj.engineModule.pageSettings;\r\n\r\n\t\t// this.pivotObj.engineModule.pageSettings = null;\r\n\t\tif (this.pivotObj.engineModule.generateGridData) {\r\n\t\t\tthis.pivotObj.engineModule.generateGridData(\r\n\t\t\t\tthis.pivotObj.dataSourceSettings,\r\n\t\t\t\ttrue\r\n\t\t\t);\r\n\t\t\tclonedValues = this.getClonedPivotValues(\r\n\t\t\t\tthis.pivotObj.engineModule.pivotValues\r\n\t\t\t);\r\n\r\n\t\t\tthis.pivotObj.engineModule.pivotValues = currentPivotValues;\r\n\r\n\t\t\tthis.pivotObj.engineModule.pageSettings = pageSettings;\r\n\r\n\t\t\t// Here \"clonedValues\" contains the whole pivot values.\r\n\t\t\tthis.allDataValue = clonedValues;\r\n\t\t}\r\n\t}\r\n\r\n\tprivate getClonedPivotValues(pivotValues: IPivotValues): IPivotValues {\r\n\t\tlet clonedSets: IPivotValues = [];\r\n\t\tif (pivotValues && pivotValues.length) {\r\n\t\t\tfor (let i: number = 0; i < pivotValues.length; i++) {\r\n\t\t\t\tif (pivotValues[i]) {\r\n\t\t\t\t\tclonedSets[i] = [];\r\n\t\t\t\t\tfor (let j: number = 0; j < pivotValues[i].length; j++) {\r\n\t\t\t\t\t\tif (pivotValues[i][j]) {\r\n\t\t\t\t\t\t\t/* eslint-disable */\r\n\t\t\t\t\t\t\tclonedSets[i][j] = this.getClonedPivotValueObj(\r\n\t\t\t\t\t\t\t\tpivotValues[i][j] as { [key: string]: Object }\r\n\t\t\t\t\t\t\t);\r\n\t\t\t\t\t\t\t/* eslint-enable */\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn clonedSets;\r\n\t}\r\n\r\n\tprivate getClonedPivotValueObj(data: { [key: string]: Object }): {\r\n\t\t[key: string]: Object;\r\n\t} {\r\n\t\tlet keyPos: number = 0;\r\n\t\tlet framedSet: any = {};\r\n\t\tif (!(data === null || data === undefined)) {\r\n\t\t\tlet fields: string[] = Object.keys(data);\r\n\t\t\twhile (keyPos < fields.length) {\r\n\t\t\t\tframedSet[fields[keyPos]] = data[fields[keyPos]];\r\n\t\t\t\tkeyPos++;\r\n\t\t\t}\r\n\t\t} else {\r\n\t\t\tframedSet = data;\r\n\t\t}\r\n\t\treturn framedSet;\r\n\t}\r\n\r\n\t//#region Filtering the TreeNodes\r\n\tprivate searchNodes(args) {\r\n\t\tlet _text = args.maskedValue;\r\n\t\tlet predicats = [],\r\n\t\t\t_array = [],\r\n\t\t\t_filter = [];\r\n\t\tif (_text == \"\") {\r\n\t\t\tthis.changeDataSource(\r\n\t\t\t\t((this as any).fieldlistObj.treeViewModule as any).getTreeData()\r\n\t\t\t);\r\n\t\t} else {\r\n\t\t\tlet predicate = new Predicate(\"caption\", \"contains\", _text, true);\r\n\t\t\tlet filteredList = new DataManager(\r\n\t\t\t\t((this as any).fieldlistObj.treeViewModule as any).getTreeData()\r\n\t\t\t).executeLocal(new Query().where(predicate));\r\n\t\t\tfor (let j = 0; j < filteredList.length; j++) {\r\n\t\t\t\t_filter.push(filteredList[j][\"id\"]);\r\n\t\t\t\tlet filters = this.getFilterItems(\r\n\t\t\t\t\tfilteredList[j],\r\n\t\t\t\t\t(\r\n\t\t\t\t\t\t(this as any).fieldlistObj.treeViewModule as any\r\n\t\t\t\t\t).getTreeData()\r\n\t\t\t\t);\r\n\t\t\t\tfor (let i = 0; i < filters.length; i++) {\r\n\t\t\t\t\tif (\r\n\t\t\t\t\t\t_array.indexOf(filters[i]) == -1 &&\r\n\t\t\t\t\t\tfilters[i] != null\r\n\t\t\t\t\t) {\r\n\t\t\t\t\t\t_array.push(filters[i]);\r\n\t\t\t\t\t\tpredicats.push(\r\n\t\t\t\t\t\t\tnew Predicate(\"id\", \"equal\", filters[i], false)\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tif (predicats.length == 0) {\r\n\t\t\t\tthis.changeDataSource([]);\r\n\t\t\t} else {\r\n\t\t\t\tlet query = new Query().where(Predicate.or(predicats));\r\n\t\t\t\tlet newList = new DataManager(\r\n\t\t\t\t\t(\r\n\t\t\t\t\t\t(this as any).fieldlistObj.treeViewModule as any\r\n\t\t\t\t\t).getTreeData()\r\n\t\t\t\t).executeLocal(query);\r\n\t\t\t\tthis.changeDataSource(newList);\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\t//Find the Parent Nodes for corresponding childs\r\n\tpublic getFilterItems(fList, list) {\r\n\t\tlet nodes = [];\r\n\t\tnodes.push(fList[\"id\"]);\r\n\t\tlet query2 = new Query().where(\"id\", \"equal\", fList[\"pid\"], false);\r\n\t\tlet fList1 = new DataManager(list).executeLocal(query2);\r\n\t\tif (fList1.length != 0) {\r\n\t\t\tlet pNode = this.getFilterItems(fList1[0], list);\r\n\t\t\tfor (let i = 0; i < pNode.length; i++) {\r\n\t\t\t\tif (nodes.indexOf(pNode[i]) == -1 && pNode[i] != null)\r\n\t\t\t\t\tnodes.push(pNode[i]);\r\n\t\t\t}\r\n\t\t\treturn nodes;\r\n\t\t}\r\n\t\treturn nodes;\r\n\t}\r\n\r\n\tpublic created(args: any) {\r\n\t\tif (this.fieldlistObj && !this.fieldlistObj.engineModule.fields) {\r\n\t\t\tthis.fieldlistObj.engineModule.fields = [];\r\n\t\t}\r\n\t\tlet search = document.createElement(\"input\");\r\n\t\tsearch.id = \"pivotSearchBox\" + this.fieldlistObj.element.id;\r\n\t\tlet el = document.querySelector(\r\n\t\t\t\"#\" + this.fieldlistObj.element.id + \"_Container .e-field-table\"\r\n\t\t);\r\n\t\tif (el) el.prepend(search);\r\n\t\tthis.pivotSearchBox = new MaskedTextBox({\r\n\t\t\tplaceholder: this.translation.SEARCH || \".SEARCH\",\r\n\t\t\tcssClass: \"pivot-search\",\r\n\t\t\tchange: this.searchNodes.bind(this),\r\n\t\t});\r\n\t\tthis.pivotSearchBox.appendTo(\r\n\t\t\t\"#pivotSearchBox\" + this.fieldlistObj.element.id\r\n\t\t);\r\n\r\n\t\t// NEW Dashboard 点击\"apply\"时，请求新数据\r\n\t\tlet applyBtn = document.getElementById(\r\n\t\t\tthis.fieldlistObj.element.id + \"_DeferUpdateButton1\"\r\n\t\t);\r\n\t\tapplyBtn &&\r\n\t\t\tapplyBtn.addEventListener(\"click\", () => {\r\n\t\t\t\tthis.pbf.pageLoading = true;\r\n\t\t\t\tthis.dashboardPorletsService.getDataByPortletsNew(\r\n\t\t\t\t\t[this.portlet],\r\n\t\t\t\t\t() => {\r\n\t\t\t\t\t\tthis.getData();\r\n\t\t\t\t\t\tsetTimeout(() => {\r\n\t\t\t\t\t\t\tthis.pbf.pageLoading = false;\r\n\t\t\t\t\t\t});\r\n\t\t\t\t\t},\r\n\t\t\t\t\tnull,\r\n\t\t\t\t\tfalse,\r\n\t\t\t\t\tthis.dashboard,\r\n\t\t\t\t\tfalse\r\n\t\t\t\t);\r\n\t\t\t});\r\n\t}\r\n\r\n\tpublic fieldListRefreshed(args) {\r\n\t\tif (this.pivotSearchBox) {\r\n\t\t\tthis.pivotSearchBox.value = \"\";\r\n\t\t\tthis.changeDataSource(\r\n\t\t\t\t(this.fieldlistObj.treeViewModule as any).getTreeData()\r\n\t\t\t);\r\n\t\t}\r\n\t}\r\n\r\n\tprivate changeDataSource(data) {\r\n\t\tlet fieldTable = (this as any).fieldlistObj.treeViewModule.fieldTable;\r\n\t\tif (fieldTable) {\r\n\t\t\tfieldTable.fields = {\r\n\t\t\t\tdataSource: data,\r\n\t\t\t\tid: \"id\",\r\n\t\t\t\ttext: \"caption\",\r\n\t\t\t\tisChecked: \"isSelected\",\r\n\t\t\t\tparentID: \"pid\",\r\n\t\t\t\ticonCss: \"spriteCssClass\",\r\n\t\t\t};\r\n\t\t}\r\n\t}\r\n\r\n\t//SMP2-2957 fix the date issue on the raw data\r\n\tpublic drillThrough(args: DrillThroughEventArgs) {\r\n\t\tfor (let i = 0; i < args.gridColumns.length; i++) {\r\n\t\t\tconst data = this.configFields.filter(\r\n\t\t\t\t(el) => el.colName === args.gridColumns[i].field\r\n\t\t\t);\r\n\t\t\tif (data && data.length > 0) {\r\n\t\t\t\tif (\r\n\t\t\t\t\tdata[0].dataType === \"date\" ||\r\n\t\t\t\t\tdata[0].dataType === \"datetime\"\r\n\t\t\t\t) {\r\n\t\t\t\t\targs.gridColumns[i].type = \"date\";\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\t//#endregion\r\n\r\n\tprivate setFontSettingConditional(obj, data, code) {\r\n\t\tif (code === -1) {\r\n\t\t\tobj.style.color = data.negaFontColor;\r\n\t\t\tobj.style.fontFamily = data.negaFontFamilyValue;\r\n\t\t\tobj.style.fontSize = data.negaFontSizeValue;\r\n\t\t\tobj.style.backgroundColor = data.negaBackgroundColor;\r\n\t\t} else {\r\n\t\t\tobj.style.color = data.fontColor;\r\n\t\t\tobj.style.fontFamily = data.fontFamilyValue;\r\n\t\t\tobj.style.fontSize = data.fontSizeValue;\r\n\t\t\tobj.style.backgroundColor = data.backgroundColor;\r\n\t\t}\r\n\t}\r\n\r\n\tprivate setCompareConditional(\r\n\t\tnegaConditionalFormatObj,\r\n\t\tconditionalFormatObj,\r\n\t\tdata\r\n\t) {\r\n\t\tif (Math.sign(data.compareValue1) == 0) {\r\n\t\t\tswitch (data.compareSelect) {\r\n\t\t\t\tcase \"LessThan\": // 小于\r\n\t\t\t\tcase \"LessThanOrEqualTo\": // 小于等于\r\n\t\t\t\t\tnegaConditionalFormatObj.value1 = 0;\r\n\t\t\t\t\tnegaConditionalFormatObj.conditions = \"LessThan\";\r\n\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\tnegaConditionalFormatObj,\r\n\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t-1\r\n\t\t\t\t\t);\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tcase \"GreaterThan\": // 大于\r\n\t\t\t\tcase \"GreaterThanOrEqualTo\": // 大于等于\r\n\t\t\t\t\tconditionalFormatObj.value1 = 0;\r\n\t\t\t\t\tconditionalFormatObj.conditions = \"GreaterThan\";\r\n\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\tconditionalFormatObj,\r\n\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t1\r\n\t\t\t\t\t);\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tcase \"NotEquals\": // 不等于\r\n\t\t\t\t\tnegaConditionalFormatObj.value1 = 0;\r\n\t\t\t\t\tnegaConditionalFormatObj.conditions = \"LessThan\";\r\n\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\tnegaConditionalFormatObj,\r\n\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t-1\r\n\t\t\t\t\t);\r\n\t\t\t\t\tconditionalFormatObj.value1 = 0;\r\n\t\t\t\t\tconditionalFormatObj.conditions = \"GreaterThan\";\r\n\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\tconditionalFormatObj,\r\n\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t1\r\n\t\t\t\t\t);\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tcase \"Between\": // value1<= val <=value2\r\n\t\t\t\t\tif (Math.sign(data.compareValue2) === 1) {\r\n\t\t\t\t\t\tconditionalFormatObj.value1 = 0;\r\n\t\t\t\t\t\tconditionalFormatObj.value2 = Number(\r\n\t\t\t\t\t\t\tdata.compareValue2\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t\tconditionalFormatObj.conditions = \"Between\";\r\n\t\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\t\tconditionalFormatObj,\r\n\t\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t\t1\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t}\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tcase \"NotBetween\": // val >= value2, val <= value1\r\n\t\t\t\t\tif (Math.sign(data.compareValue2) === 1) {\r\n\t\t\t\t\t\tconditionalFormatObj.value1 = Number(\r\n\t\t\t\t\t\t\tdata.compareValue2\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t\tconditionalFormatObj.conditions = \"GreaterThan\";\r\n\t\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\t\tconditionalFormatObj,\r\n\t\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t\t1\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t\tnegaConditionalFormatObj.value1 = 0;\r\n\t\t\t\t\t\tnegaConditionalFormatObj.conditions = \"LessThan\";\r\n\t\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\t\tnegaConditionalFormatObj,\r\n\t\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t\t-1\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t}\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tdefault:\r\n\t\t\t\t\tbreak;\r\n\t\t\t}\r\n\t\t} else if (Math.sign(data.compareValue1) === 1) {\r\n\t\t\tswitch (data.compareSelect) {\r\n\t\t\t\tcase \"LessThan\": // 小于\r\n\t\t\t\tcase \"LessThanOrEqualTo\": // 小于等于\r\n\t\t\t\t\tconditionalFormatObj.value1 = 0;\r\n\t\t\t\t\tconditionalFormatObj.value2 = Number(data.compareValue1);\r\n\t\t\t\t\tconditionalFormatObj.conditions = \"Between\";\r\n\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\tconditionalFormatObj,\r\n\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t1\r\n\t\t\t\t\t);\r\n\t\t\t\t\tnegaConditionalFormatObj.value1 = 0;\r\n\t\t\t\t\tnegaConditionalFormatObj.conditions = \"LessThan\";\r\n\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\tnegaConditionalFormatObj,\r\n\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t-1\r\n\t\t\t\t\t);\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tcase \"GreaterThan\": // 大于\r\n\t\t\t\tcase \"GreaterThanOrEqualTo\": // 大于等于\r\n\t\t\t\t\tconditionalFormatObj.value1 = Number(data.compareValue1);\r\n\t\t\t\t\tconditionalFormatObj.conditions = \"GreaterThan\";\r\n\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\tconditionalFormatObj,\r\n\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t1\r\n\t\t\t\t\t);\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tcase \"Equals\": // 等于\r\n\t\t\t\t\tconditionalFormatObj.value1 = Number(data.compareValue1);\r\n\t\t\t\t\tconditionalFormatObj.conditions = \"Equals\";\r\n\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\tconditionalFormatObj,\r\n\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t1\r\n\t\t\t\t\t);\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tcase \"NotEquals\": // 不等于\r\n\t\t\t\t\tconditionalFormatObj.value1 = 0;\r\n\t\t\t\t\tconditionalFormatObj.value2 = Number(data.compareValue1);\r\n\t\t\t\t\tconditionalFormatObj.conditions = \"Between\";\r\n\t\t\t\t\t// push进数组\r\n\t\t\t\t\tconditionalFormatObj.value1 = Number(data.compareValue1);\r\n\t\t\t\t\tconditionalFormatObj.conditions = \"GreaterThan\";\r\n\t\t\t\t\t// push进数组\r\n\r\n\t\t\t\t\tnegaConditionalFormatObj.value1 = 0;\r\n\t\t\t\t\tnegaConditionalFormatObj.conditions = \"LessThanOrEqualTo\";\r\n\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\tnegaConditionalFormatObj,\r\n\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t-1\r\n\t\t\t\t\t);\r\n\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\tconditionalFormatObj,\r\n\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t1\r\n\t\t\t\t\t);\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tcase \"Between\": // value1<= val <=value2\r\n\t\t\t\t\tif (Math.sign(data.compareValue2) === 1) {\r\n\t\t\t\t\t\tconditionalFormatObj.value1 = Number(\r\n\t\t\t\t\t\t\tdata.compareValue1\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t\tconditionalFormatObj.value2 = Number(\r\n\t\t\t\t\t\t\tdata.compareValue2\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t\tconditionalFormatObj.conditions = \"Between\";\r\n\t\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\t\tconditionalFormatObj,\r\n\t\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t\t1\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t}\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tcase \"NotBetween\": // val >= value2, val <= value1\r\n\t\t\t\t\tif (Math.sign(data.compareValue2) === 1) {\r\n\t\t\t\t\t\tconditionalFormatObj.value1 = 0;\r\n\t\t\t\t\t\tconditionalFormatObj.value2 = Number(\r\n\t\t\t\t\t\t\tdata.compareValue1\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t\tconditionalFormatObj.conditions = \"Between\";\r\n\t\t\t\t\t\t// push进数组\r\n\t\t\t\t\t\tconditionalFormatObj.value1 = Number(\r\n\t\t\t\t\t\t\tdata.compareValue2\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t\tconditionalFormatObj.conditions = \"GreaterThan\";\r\n\t\t\t\t\t\t// push进数组\r\n\t\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\t\tconditionalFormatObj,\r\n\t\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t\t1\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t}\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tdefault:\r\n\t\t\t\t\tbreak;\r\n\t\t\t}\r\n\t\t} else if (Math.sign(data.compareValue1) === -1) {\r\n\t\t\tswitch (data.compareSelect) {\r\n\t\t\t\tcase \"LessThan\": // 小于\r\n\t\t\t\tcase \"LessThanOrEqualTo\": // 小于等于\r\n\t\t\t\t\tnegaConditionalFormatObj.value1 = data.compareValue1;\r\n\t\t\t\t\tnegaConditionalFormatObj.conditions = data.compareSelect;\r\n\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\tnegaConditionalFormatObj,\r\n\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t-1\r\n\t\t\t\t\t);\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tcase \"GreaterThan\": // 大于\r\n\t\t\t\tcase \"GreaterThanOrEqualTo\": // 大于等于\r\n\t\t\t\t\tconditionalFormatObj.value1 = 0;\r\n\t\t\t\t\tconditionalFormatObj.conditions = \"GreaterThanOrEqualTo\";\r\n\t\t\t\t\tnegaConditionalFormatObj.value1 = 0;\r\n\t\t\t\t\tnegaConditionalFormatObj.value2 = data.compareValue1;\r\n\t\t\t\t\tnegaConditionalFormatObj.conditions = \"Between\";\r\n\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\tconditionalFormatObj,\r\n\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t1\r\n\t\t\t\t\t);\r\n\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\tnegaConditionalFormatObj,\r\n\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t-1\r\n\t\t\t\t\t);\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tcase \"Equals\": // 等于\r\n\t\t\t\t\tnegaConditionalFormatObj.value1 = data.compareValue1;\r\n\t\t\t\t\tnegaConditionalFormatObj.conditions = \"Equals\";\r\n\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\tnegaConditionalFormatObj,\r\n\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t-1\r\n\t\t\t\t\t);\r\n\t\t\t\tcase \"NotEquals\": // 不等于\r\n\t\t\t\t\tnegaConditionalFormatObj.value1 = data.compareValue1;\r\n\t\t\t\t\tnegaConditionalFormatObj.conditions = \"NotEquals\";\r\n\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\tnegaConditionalFormatObj,\r\n\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t-1\r\n\t\t\t\t\t);\r\n\t\t\t\t\tconditionalFormatObj.value1 = 0;\r\n\t\t\t\t\tconditionalFormatObj.conditions = \"GreaterThan\";\r\n\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\tconditionalFormatObj,\r\n\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t1\r\n\t\t\t\t\t);\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tcase \"Between\": // value1<= val <=value2\r\n\t\t\t\t\tif (Math.sign(data.compareValue2)) {\r\n\t\t\t\t\t\tnegaConditionalFormatObj.value1 = 0;\r\n\t\t\t\t\t\tnegaConditionalFormatObj.value2 = data.compareValue1;\r\n\t\t\t\t\t\tnegaConditionalFormatObj.conditions = \"Between\";\r\n\t\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\t\tnegaConditionalFormatObj,\r\n\t\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t\t-1\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t\tconditionalFormatObj.value1 = 0;\r\n\t\t\t\t\t\tconditionalFormatObj.value2 = data.compareValue2;\r\n\t\t\t\t\t\tconditionalFormatObj.conditions = \"Between\";\r\n\t\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\t\tconditionalFormatObj,\r\n\t\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t\t1\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tnegaConditionalFormatObj.value1 = data.compareValue1;\r\n\t\t\t\t\t\tnegaConditionalFormatObj.value2 = data.compareValue2;\r\n\t\t\t\t\t\tnegaConditionalFormatObj.conditions = \"Between\";\r\n\t\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\t\tnegaConditionalFormatObj,\r\n\t\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t\t-1\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t}\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tcase \"NotBetween\": // val >= value2, val <= value1\r\n\t\t\t\t\tif (Math.sign(data.compareValue2)) {\r\n\t\t\t\t\t\tnegaConditionalFormatObj.value1 = data.compareValue1;\r\n\t\t\t\t\t\tnegaConditionalFormatObj.conditions = \"LessThan\";\r\n\t\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\t\tnegaConditionalFormatObj,\r\n\t\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t\t-1\r\n\t\t\t\t\t\t);\r\n\r\n\t\t\t\t\t\tconditionalFormatObj.value1 = data.compareValue2;\r\n\t\t\t\t\t\tconditionalFormatObj.conditions = \"GreaterThan\";\r\n\t\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\t\tconditionalFormatObj,\r\n\t\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t\t1\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t} else {\r\n\t\t\t\t\t\tnegaConditionalFormatObj.value1 = data.compareValue1;\r\n\t\t\t\t\t\tnegaConditionalFormatObj.value2 = data.compareValue2;\r\n\t\t\t\t\t\tnegaConditionalFormatObj.conditions = \"NotBetween\";\r\n\t\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\t\tnegaConditionalFormatObj,\r\n\t\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t\t-1\r\n\t\t\t\t\t\t);\r\n\r\n\t\t\t\t\t\tconditionalFormatObj.value1 = 0;\r\n\t\t\t\t\t\tconditionalFormatObj.conditions = \"GreaterThan\";\r\n\t\t\t\t\t\tthis.setFontSettingConditional(\r\n\t\t\t\t\t\t\tconditionalFormatObj,\r\n\t\t\t\t\t\t\tdata,\r\n\t\t\t\t\t\t\t1\r\n\t\t\t\t\t\t);\r\n\t\t\t\t\t}\r\n\t\t\t\t\tbreak;\r\n\t\t\t\tdefault:\r\n\t\t\t\t\tbreak;\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\t/**\r\n\t * @param timeArray 数组对象 [{\"date\":\"2021-01-01\"},{\"date\":\"2021-02-01\"}]\r\n\t * @param endDate 截至时间\r\n\t * @param interval 时间间隔 year / quarter / month\r\n\t * @param timeKey 时间字段名 date\r\n\t * @returns 划分后的时间分组对象\r\n\t */\r\n\tgetTimeRanges(timeArray, endDate, interval, timeKey) {\r\n\t\t// 将时间字符串转换为 moment 对象\r\n\t\tconst dates = timeArray.map((item) => moment(item[timeKey || \"date\"]));\r\n\r\n\t\t// 分隔符\r\n\t\tconst delimiter = \"-\";\r\n\r\n\t\t// 找到最小时间和最大时间\r\n\t\tconst minDate = moment.min(dates);\r\n\t\tconst maxDate = moment(endDate);\r\n\r\n\t\t// 初始化结果对象\r\n\t\tconst result = {};\r\n\r\n\t\t// 根据入参进行划分\r\n\t\tif (interval === \"year\") {\r\n\t\t\tconst startYear = minDate.year();\r\n\t\t\tconst endYear = maxDate.year();\r\n\r\n\t\t\tfor (let year = startYear; year <= endYear; year++) {\r\n\t\t\t\tresult[year] = [];\r\n\t\t\t}\r\n\r\n\t\t\tdates.forEach((date, index) => {\r\n\t\t\t\tconst year = date.year();\r\n\t\t\t\tresult[year].push(timeArray[index]);\r\n\t\t\t});\r\n\t\t} else if (interval === \"quarter\") {\r\n\t\t\t// 存储季度字符串\r\n\t\t\tconst quarters = [];\r\n\r\n\t\t\t// 逐一遍历每个季度\r\n\t\t\tfor (\r\n\t\t\t\tlet currentDate = minDate.clone();\r\n\t\t\t\tcurrentDate.isSameOrBefore(maxDate);\r\n\t\t\t\tcurrentDate.add(3, \"months\")\r\n\t\t\t) {\r\n\t\t\t\tconst year = currentDate.year();\r\n\t\t\t\tconst quarter = Math.ceil((currentDate.month() + 1) / 3); // 计算季度\r\n\t\t\t\tquarters.push(`${year}${delimiter}Q${quarter}`); // 格式化并添加到数组\r\n\t\t\t}\r\n\r\n\t\t\t// 输出所有季度\r\n\t\t\tquarters.forEach((quarter, index) => {\r\n\t\t\t\tresult[quarter] = [];\r\n\t\t\t});\r\n\r\n\t\t\tdates.forEach((date, index) => {\r\n\t\t\t\tconst year = date.year();\r\n\t\t\t\tconst quarter = date.quarter(); // 获取季度\r\n\t\t\t\tif (quarter === 1)\r\n\t\t\t\t\tresult[year + delimiter + \"Q1\"].push(timeArray[index]);\r\n\t\t\t\telse if (quarter === 2)\r\n\t\t\t\t\tresult[year + delimiter + \"Q2\"].push(timeArray[index]);\r\n\t\t\t\telse if (quarter === 3)\r\n\t\t\t\t\tresult[year + delimiter + \"Q3\"].push(timeArray[index]);\r\n\t\t\t\telse if (quarter === 4)\r\n\t\t\t\t\tresult[year + delimiter + \"Q4\"].push(timeArray[index]);\r\n\t\t\t});\r\n\t\t} else if (interval === \"month\") {\r\n\t\t\t// 存储月份字符串\r\n\t\t\tconst months = [];\r\n\r\n\t\t\t// 逐一遍历每个月\r\n\t\t\tfor (\r\n\t\t\t\tlet currentDate = minDate.clone();\r\n\t\t\t\tcurrentDate.isSameOrBefore(maxDate);\r\n\t\t\t\tcurrentDate.add(1, \"months\")\r\n\t\t\t) {\r\n\t\t\t\tmonths.push(currentDate.format(`YYYY${delimiter}MM`)); // 格式化并添加到数组\r\n\t\t\t}\r\n\r\n\t\t\t// 输出所有月份\r\n\t\t\tmonths.forEach((month, index) => {\r\n\t\t\t\tresult[month] = [];\r\n\t\t\t});\r\n\r\n\t\t\tdates.forEach((date, index) => {\r\n\t\t\t\tconst year = date.year();\r\n\t\t\t\tconst month = (date.month() + 1).toString().padStart(2, \"0\"); // 0-11\r\n\t\t\t\tresult[year + delimiter + month].push(timeArray[index]);\r\n\t\t\t});\r\n\t\t}\r\n\r\n\t\treturn result;\r\n\t}\r\n\r\n\t/**\r\n\t * 计算几何算数平方更\r\n\t * @param values 数组 [0, 0, 0.2575]\r\n\t * @returns\r\n\t */\r\n\tcalculateGrowthRate(values) {\r\n\t\tconst product = values.reduce((acc, val) => acc * (1 + val), 1);\r\n\t\tif (product >= 0) {\r\n\t\t\treturn Math.pow(product, 1 / values.length) - 1;\r\n\t\t} else if (product < 0) {\r\n\t\t\tif (values.length % 2 == 0) {\r\n\t\t\t\treturn null;\r\n\t\t\t} else {\r\n\t\t\t\treturn this.nthroot(product, values.length) - 1;\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\tnthroot(x, n) {\r\n\t\tlet ng = n % 2;\r\n\t\tif (ng == 1 || x < 0) x = -x;\r\n\t\tvar r = Math.pow(x, 1 / n);\r\n\t\tn = Math.pow(r, n);\r\n\r\n\t\tif (Math.abs(x - n) < 1 && x > 0 === n > 0) return ng ? -r : r;\r\n\t}\r\n\r\n\t/**\r\n\t * 标准偏差\r\n\t * @param values 数组 [0, 0, -0.4775]\r\n\t * @returns 0.2756847535380463\r\n\t */\r\n\tcalculateStandardDeviation(values) {\r\n\t\tconst n = values.length;\r\n\r\n\t\t// 检查数据点数量\r\n\t\tif (n < 2) {\r\n\t\t\tthrow new Error(\"至少需要两个数据点来计算样本标准偏差\");\r\n\t\t}\r\n\r\n\t\t// 计算均值\r\n\t\tconst mean = values.reduce((acc, val) => acc + val, 0) / n;\r\n\r\n\t\t// 计算方差\r\n\t\tconst variance =\r\n\t\t\tvalues.reduce((acc, val) => acc + Math.pow(val - mean, 2), 0) /\r\n\t\t\t(n - 1);\r\n\r\n\t\t// 返回标准偏差\r\n\t\treturn Math.sqrt(variance);\r\n\t}\r\n}\r\n","<div class=\"control-section\" style=\"overflow: hidden; height: 100%\">\r\n\t<ejs-pivotview\r\n\t\twidth=\"100%\"\r\n\t\theight=\"100%\"\r\n\t\tstyle=\"display: block\"\r\n\t\t[dataSourceSettings]=\"dataSourceSettings\"\r\n\t\t#pivotview\r\n\t\t(dataBound)=\"dataBound($event)\"\r\n\t\tenableValueSorting=\"true\"\r\n\t\tallowConditionalFormatting=\"true\"\r\n\t\tallowExcelExport=\"true\"\r\n\t\tallowGrouping=\"true\"\r\n\t\t[zoomSettings]=\"zoomSettings\"\r\n\t\tenableVirtualization=\"true\"\r\n\t\t(aggregateCellInfo)=\"aggregateCellInfo($event)\"\r\n\t\t(cellClick)=\"cellClick($event)\"\r\n\t\tallowDrillThrough=\"true\"\r\n\t\t(actionFailure)=\"actionFailure($event)\"\r\n\t\t(fieldListRefreshed)=\"fieldListRefreshed($event)\"\r\n\t\t(drillThrough)=\"drillThrough($event)\"\r\n\t\t[chartSettings]=\"chartSettings\"\r\n\t\t(chartSeriesCreated)=\"chartSeriesCreated($event)\"\r\n\t\t[displayOption]=\"displayOption\"\r\n\t\t[showTooltip]=\"false\"\r\n\t\t(enginePopulated)=\"afterEnginePopulate($event)\"\r\n\t\t(beforeExport)=\"beforeExport($event)\"\r\n\t>\r\n\t</ejs-pivotview>\r\n\r\n\t<div class=\"pivotfieldlist-control\">\r\n\t\t<ejs-pivotfieldlist\r\n\t\t\t[id]=\"portlet.newId\"\r\n\t\t\t#pivotfieldlist\r\n\t\t\thidden=\"true\"\r\n\t\t\tenableValueSorting=\"true\"\r\n\t\t\tshowFieldList=\"true\"\r\n\t\t\tallowCalculatedField=\"true\"\r\n\t\t\tallowDeferLayoutUpdate=\"true\"\r\n\t\t\trenderMode=\"Popup\"\r\n\t\t\t(enginePopulated)=\"afterPopulate($event)\"\r\n\t\t\t(memberEditorOpen)=\"onMemberEditorOpen($event)\"\r\n\t\t\t(enginePopulating)=\"enginePopulating($event)\"\r\n\t\t\t(aggregateCellInfo)=\"aggregateCellInfo($event)\"\r\n\t\t\t(fieldDrop)=\"onFieldDrop($event)\"\r\n\t\t\t(actionComplete)=\"actionComplete($event)\"\r\n\t\t\t(actionBegin)=\"actionBegin($event)\"\r\n\t\t\t(calculatedFieldCreate)=\"calculatedFieldCreate($event)\"\r\n\t\t\t(load)=\"onLoad()\"\r\n\t\t\t(created)=\"created($event)\"\r\n\t\t>\r\n\t\t</ejs-pivotfieldlist>\r\n\t</div>\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"]}