raise-common-lib 0.0.206 → 0.0.208

package/esm2015/lib/dashboard/dashboardPorlets.service.js

@@ -0,0 +1,3107 @@
+/**
+ * @fileoverview added by tsickle
+ * Generated from: lib/dashboard/dashboardPorlets.service.ts
+ * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { Inject, Injectable, Optional } from "@angular/core";
+import { ApiList } from "./api";
+import { MatDialog } from "@angular/material";
+import { DashboardService } from "./dashboard.service";
+import { forEach } from "lodash";
+import moment from "moment";
+import { HttpClient, HttpHeaders } from "@angular/common/http";
+import { API_SERVICE_TOKEN, PBF_TOKEN } from "../service/InjectionToken";
+import { DialogService } from "../service/dialog.service";
+import * as i0 from "@angular/core";
+import * as i1 from "./api";
+import * as i2 from "@angular/material/dialog";
+import * as i3 from "../service/dialog.service";
+import * as i4 from "./dashboard.service";
+import * as i5 from "@angular/common/http";
+import * as i6 from "../service/InjectionToken";
+export class DashboardPorletsService {
+    /**
+     * @param {?} api
+     * @param {?} dialog
+     * @param {?} dialogService
+     * @param {?} DashboardService
+     * @param {?} httpClient
+     * @param {?} pbf
+     * @param {?} http
+     */
+    constructor(api, dialog, dialogService, DashboardService, httpClient, pbf, http) {
+        this.api = api;
+        this.dialog = dialog;
+        this.dialogService = dialogService;
+        this.DashboardService = DashboardService;
+        this.httpClient = httpClient;
+        this.pbf = pbf;
+        this.http = http;
+        // public config;
+        this.companyDropdownList = [];
+        this.currencyDropdownList = [];
+        this.currencyList = [];
+        this.portlets = [];
+        this.portletsCopy = [];
+        this.companyCharts = [];
+        this.colorsTotal = [
+            "#0b5496",
+            "#0081ff",
+            "#22cce2",
+            "#606ede",
+            "#8598f7",
+            "#00a744",
+            "#12c177",
+            "#fdbf5e",
+            "#ff8a48",
+            "#ea4258",
+        ];
+        this.fetch_disabled = true;
+        this.update_loading = false;
+        this.loading_show = false;
+        this.sortingPortlet = [];
+        this.pagingChanging = [];
+        this.selected_enyity_fileds = [];
+        this.checkedAll = false;
+        this.updated = false;
+        this.dataMartTables = {};
+        this.length = 0;
+        this.templateList = [];
+        this.fieldsArr = {};
+        this.sourcesData = {};
+        // newDashboard
+        this.portletResults_New = {}; // 以DataTable为单位 存储新数据
+        // 以DataTable为单位 存储新数据
+        this.portletData_New = {}; // 以portlet为单位 存储新数据
+        // 以portlet为单位 存储新数据
+        this.portletFields_Temp = {}; // 存储当前portlet所用到的字段
+        // 存储当前portlet所用到的字段
+        this.dashboardConfig = {}; // 当前Dashboard的config, 用于获取orderByColumns
+        // 当前Dashboard的config, 用于获取orderByColumns
+        this.entityIds = [];
+        this.entityIdObj = {};
+        this.allFieldsObj = {};
+        this.GetDataTypes = (/**
+         * @return {?}
+         */
+        function () {
+            return [
+                { key: "budget", val: this.translation.BUDGET },
+                { key: "actual", val: this.translation.ACTUAL },
+                { key: "forecast", val: this.translation.FORECAST },
+                { key: "rolling", val: "Rolling" },
+            ];
+        });
+        this.ExcelFormulas = {
+            DaysBetween: (/**
+             * @param {?} date1
+             * @param {?} date2
+             * @return {?}
+             */
+            function (date1, date2) {
+                /** @type {?} */
+                var oneDay = 24 * 60 * 60 * 1000;
+                return Math.round(Math.abs((date1.getTime() - date2.getTime()) / oneDay));
+            }),
+            XNPV: (/**
+             * @param {?} rate
+             * @param {?} values
+             * @return {?}
+             */
+            function (rate, values) {
+                /** @type {?} */
+                var xnpv = 0.0;
+                /** @type {?} */
+                var firstDate = new Date(values[0].date);
+                for (var key in values) {
+                    /** @type {?} */
+                    var tmp = values[key];
+                    /** @type {?} */
+                    var value = tmp.amount;
+                    /** @type {?} */
+                    var date = new Date(tmp.date);
+                    xnpv +=
+                        value / Math.pow(1 + rate, this.DaysBetween(firstDate, date) / 365);
+                }
+                return xnpv;
+            }),
+            XIRR: (/**
+             * @param {?} values
+             * @param {?} guess
+             * @return {?}
+             */
+            function (values, guess) {
+                /** @type {?} */
+                var x1 = 0.0;
+                /** @type {?} */
+                var x2 = guess;
+                /** @type {?} */
+                var f1 = this.XNPV(x1, values);
+                /** @type {?} */
+                var f2 = this.XNPV(x2, values);
+                for (var i = 0; i < 100; i++) {
+                    if (f1 * f2 < 0.0)
+                        break;
+                    if (Math.abs(f1) < Math.abs(f2)) {
+                        f1 = this.XNPV((x1 += 1.6 * (x1 - x2)), values);
+                    }
+                    else {
+                        f2 = this.XNPV((x2 += 1.6 * (x2 - x1)), values);
+                    }
+                }
+                if (f1 * f2 > 0.0)
+                    return null;
+                /** @type {?} */
+                var f = this.XNPV(x1, values);
+                if (f < 0.0) {
+                    /** @type {?} */
+                    var rtb = x1;
+                    /** @type {?} */
+                    var dx = x2 - x1;
+                }
+                else {
+                    /** @type {?} */
+                    var rtb = x2;
+                    /** @type {?} */
+                    var dx = x1 - x2;
+                }
+                for (var i = 0; i < 100; i++) {
+                    dx *= 0.5;
+                    /** @type {?} */
+                    var x_mid = rtb + dx;
+                    /** @type {?} */
+                    var f_mid = this.XNPV(x_mid, values);
+                    if (f_mid <= 0.0)
+                        rtb = x_mid;
+                    if (Math.abs(f_mid) < 1.0e-6 || Math.abs(dx) < 1.0e-6)
+                        return x_mid;
+                }
+                return null;
+            }),
+            _DaysBetween: (/**
+             * @param {?} date1
+             * @param {?} date2
+             * @return {?}
+             */
+            function (date1, date2) {
+                //const time1 =new Date(Date.UTC(date1.getUTCFullYear(), date1.getUTCMonth(), date1.getUTCDate(), date1.getUTCHours(), date1.getUTCMinutes(), date1.getUTCSeconds())).getTime();
+                //const time2 =new Date(Date.UTC(date2.getUTCFullYear(), date2.getUTCMonth(), date2.getUTCDate(), date2.getUTCHours(), date2.getUTCMinutes(), date2.getUTCSeconds())).getTime();
+                /** @type {?} */
+                const oneDay = 24 * 60 * 60 * 1000;
+                // 一天的毫秒数
+                //const time1 = date1.getTime(); // date1的毫秒表示
+                //const time2 = date2.getTime(); // date2的毫秒表示
+                /** @type {?} */
+                const firstDate = new Date(date1);
+                /** @type {?} */
+                const secondDate = new Date(date2);
+                /** @type {?} */
+                const diffDays = Math.round(
+                // @ts-ignore
+                Math.abs((firstDate - secondDate) / oneDay));
+                return diffDays;
+            }),
+            _lcl_sca_XirrResult: (/**
+             * @param {?} values
+             * @param {?} dates
+             * @param {?} fRate
+             * @return {?}
+             */
+            function (values, dates, fRate) {
+                /** @type {?} */
+                var D_0 = dates[0];
+                /** @type {?} */
+                let r = fRate + 1.0;
+                /** @type {?} */
+                var fResult = values[0];
+                for (var i = 1, nCount = values.length; i < nCount; ++i) {
+                    /** @type {?} */
+                    var temp = Math.pow(r, this._DaysBetween(dates[i], D_0) / 365.0);
+                    fResult += values[i] / temp;
+                }
+                return fResult;
+            }),
+            _lcl_sca_XirrResult_Deriv1: (/**
+             * @param {?} values
+             * @param {?} dates
+             * @param {?} fRate
+             * @return {?}
+             */
+            function (values, dates, fRate) {
+                /** @type {?} */
+                var D_0 = dates[0];
+                /** @type {?} */
+                var r = fRate + 1.0;
+                /** @type {?} */
+                var fResult = 0.0;
+                for (var i = 1, nCount = values.length; i < nCount; ++i) {
+                    /** @type {?} */
+                    var E_i = this._DaysBetween(dates[i], D_0) / 365.0;
+                    fResult -= (E_i * values[i]) / Math.pow(r, E_i + 1.0);
+                }
+                return fResult;
+            }),
+            _CalculateXirrOpenOffice: (/**
+             * @param {?} values
+             * @param {?} dates
+             * @param {?} guess
+             * @return {?}
+             */
+            function (values, dates, guess) {
+                if (values.length < 2 || values.length != dates.length) {
+                    return null;
+                }
+                /** @type {?} */
+                var fResultRate = guess;
+                if (fResultRate <= -1) {
+                    return null;
+                }
+                /** @type {?} */
+                var fMaxEps = 0.00000001;
+                /** @type {?} */
+                var nMaxIter = 50;
+                /** @type {?} */
+                var fNewRate;
+                /** @type {?} */
+                var fRateEps;
+                /** @type {?} */
+                var fResultValue;
+                /** @type {?} */
+                var nIter = 0;
+                /** @type {?} */
+                var nIterScan = 0;
+                /** @type {?} */
+                var bContLoop = false;
+                /** @type {?} */
+                var bResultRateScanEnd = false;
+                do {
+                    if (nIterScan >= 1) {
+                        fResultRate = -0.99 + (nIterScan - 1) * 0.01;
+                    }
+                    do {
+                        fResultValue = this._lcl_sca_XirrResult(values, dates, fResultRate);
+                        fNewRate =
+                            fResultRate -
+                                fResultValue /
+                                    this._lcl_sca_XirrResult_Deriv1(values, dates, fResultRate);
+                        fRateEps = Math.abs(fNewRate - fResultRate);
+                        fResultRate = fNewRate;
+                        bContLoop = fRateEps > fMaxEps && Math.abs(fResultValue) > fMaxEps;
+                    } while (bContLoop && ++nIter < nMaxIter);
+                    nIter = 0;
+                    if (isNaN(fResultRate) ||
+                        !isFinite(fResultRate) ||
+                        isNaN(fResultValue) ||
+                        !isFinite(fResultValue)) {
+                        bContLoop = true;
+                    }
+                    ++nIterScan;
+                    bResultRateScanEnd = nIterScan >= 100;
+                } while (bContLoop && !bResultRateScanEnd);
+                if (bContLoop) {
+                    return null;
+                }
+                return fResultRate;
+            }),
+            _CalculateXirr: (/**
+             * @param {?} valueList
+             * @param {?} dateList
+             * @param {?} navAdjust
+             * @param {?} latestDate
+             * @return {?}
+             */
+            function (valueList, dateList, navAdjust, latestDate) {
+                /** @type {?} */
+                var positiveCashflow = valueList.some((/**
+                 * @param {?} v
+                 * @return {?}
+                 */
+                function (v) {
+                    return v > 0;
+                }))
+                    ? true
+                    : navAdjust > 0
+                        ? true
+                        : false;
+                /** @type {?} */
+                var negativeCashflow = valueList.some((/**
+                 * @param {?} v
+                 * @return {?}
+                 */
+                function (v) {
+                    return v < 0;
+                }))
+                    ? true
+                    : navAdjust < 0
+                        ? true
+                        : false;
+                if (positiveCashflow == false || negativeCashflow == false) {
+                    return null;
+                }
+                if (navAdjust != null) {
+                    valueList.push(navAdjust);
+                    dateList.push(latestDate);
+                }
+                /** @type {?} */
+                var xirrResult = null;
+                try {
+                    /** @type {?} */
+                    var excelGuess = valueList.reduce((/**
+                     * @param {?} sum
+                     * @param {?} value
+                     * @return {?}
+                     */
+                    function (sum, value) {
+                        return sum + value;
+                    }), 0) < 0
+                        ? -0.1
+                        : 0.1;
+                    xirrResult = this._CalculateXirrOpenOffice(valueList, dateList, excelGuess);
+                }
+                catch (error) {
+                    return null;
+                }
+                return xirrResult;
+            }),
+        };
+    }
+    /**
+     * @private
+     * @param {?} res
+     * @return {?}
+     */
+    setEntityType(res) {
+        if (res && res.entityList && res.entityList.length) {
+            /** @type {?} */
+            const entityData = res.entityList[0];
+            if (!entityData) {
+                return res;
+            }
+            const { linkedType = "" } = entityData;
+            if (!linkedType) {
+                return res;
+            }
+            this.entityType =
+                linkedType === "PropertyId"
+                    ? "Property"
+                    : linkedType === "portfolioCompId" ||
+                        linkedType === "assetCompId" ||
+                        linkedType === "otherCompId"
+                        ? "Company"
+                        : linkedType === "portfolioFundId" || linkedType === "assetFundId"
+                            ? "Fund"
+                            : "AssetPortfolio";
+            res.entityType = this.entityType;
+        }
+        return res;
+    }
+    /**
+     * @param {?} dashboardId
+     * @param {?} roGet
+     * @param {?} callback
+     * @param {?=} isRefresh
+     * @param {?=} callbackForDashboard
+     * @return {?}
+     */
+    GetDashboardV1(dashboardId, roGet, callback, isRefresh = false, callbackForDashboard) {
+        if (!isRefresh) {
+            this.portlets = [];
+        }
+        this.getInfo();
+        /** @type {?} */
+        const dataObj = { dashboardId, language: this.lang };
+        this.http.post(this.api.urlList.GetDashboardV2, dataObj, (/**
+         * @param {?} res
+         * @return {?}
+         */
+        (res) => {
+            res = this.pbf.convertKeysToLowerCase(res);
+            if (!res) {
+                callback(null);
+                return;
+            }
+            res = this.setEntityType(res);
+            // 初始化fromDate
+            if (res.fromDate === "1900-01-01T00:00:00Z") {
+                res.fromDate = "";
+            }
+            if (callbackForDashboard) {
+                callbackForDashboard(res);
+            }
+            this.entityIds =
+                res.entityList && res.entityList.length > 0
+                    ? res.entityList.map((/**
+                     * @param {?} e
+                     * @return {?}
+                     */
+                    (e) => {
+                        return e["linkedGuid"];
+                    }))
+                    : [];
+            if (res.entityList)
+                this.entityList = [...res.entityList];
+            this.entityIdObj = {
+                id: JSON.stringify(this.entityIds),
+            };
+            this.portletResults_New[res.id] = {};
+            this.portletData_New[res.id] = {};
+            this.DashboardService.dashboardGroupId[res.id] = res.dashboardGroupId;
+            this.DashboardService.dashboardGroupName[res.id] = res.dashboardGroupName;
+            this.DashboardService.RegionDataSetId[res.id] = res.RegionDataSetId;
+            this.DashboardService.dashboardName[res.id] = res.name;
+            this.DashboardService.shareUsers[res.id] = res.sharedUsers;
+            this.dashboardConfig[res.id] = res.config && JSON.parse(res.config);
+            if (res) {
+                // this.dataMartTables[res.id] = uniqBy(
+                // 	res.dataMartTables,
+                // 	"langCode"
+                // );
+                this.dataMartTables[res.id] = [...res.dataMartTables];
+                this.sortDataMartTables(this.dataMartTables[res.id]);
+                this.DashboardService.dashboardDescription = res.description;
+                this.img = res.img;
+                // 如果可选开始日期，屏蔽默认的1900-01-01
+                this.currencyCode = res.currencyCode;
+                //@ts-ignore
+                this.columnCount = res.columnCount ? res.columnCount : 4;
+                if (res.portlets) {
+                    if (!isRefresh) {
+                        this.portlets = JSON.parse(JSON.stringify(res.portlets));
+                    }
+                    this.rowCount =
+                        res.portlets.length > 0
+                            ? Math.max.apply(Math, res.portlets.map((/**
+                             * @param {?} o
+                             * @return {?}
+                             */
+                            function (o) {
+                                return o.posY;
+                            }))) + 2
+                            : 2;
+                    // new Dashboard
+                    if (this.portlets && this.portlets.length) {
+                        this.fieldsArr[res.id] = {};
+                        this.portlets.forEach((/**
+                         * @param {?} el
+                         * @return {?}
+                         */
+                        (el) => {
+                            if (!Object.keys(this.fieldsArr[res.id]).includes(el.figureCode)) {
+                                this.fieldsArr[res.id][el.figureCode] = JSON.parse(el.config).fields;
+                            }
+                        }));
+                        this.portlets = this.portlets.filter((/**
+                         * @param {?} item
+                         * @return {?}
+                         */
+                        (item) => item.figureCode));
+                        this.getDataByPortletsNew(this.portlets, (/**
+                         * @param {?} _res
+                         * @return {?}
+                         */
+                        (_res) => {
+                            callback(res, this.portlets);
+                        }), null, isRefresh, res, roGet);
+                    }
+                    else {
+                        callback(res, this.portlets);
+                    }
+                }
+                else {
+                    this.portlets = [];
+                    this.columnCount = 4;
+                    this.rowCount = 2;
+                    callback(res, this.portlets);
+                }
+            }
+        }));
+    }
+    /**
+     * @param {?} portlet
+     * @param {?} filterSettings
+     * @param {?} dashboard
+     * @param {?} callback
+     * @return {?}
+     */
+    filterTriggerGetData(portlet, filterSettings, dashboard, callback) {
+        /** @type {?} */
+        const config = portlet.config && JSON.parse(portlet.config);
+        /** @type {?} */
+        let id = portlet.id === "00000000-0000-0000-0000-000000000000"
+            ? portlet.newId
+            : portlet.id;
+        /** @type {?} */
+        let params = this.getParamsByPortlet(portlet, null, null, dashboard);
+        /** @type {?} */
+        let initFieldsArr;
+        /** @type {?} */
+        let curFieldsArr;
+        if (!params.isTable) {
+            // 赋值portletFields_Temp
+            initFieldsArr = this.portletFields_Temp[id];
+            curFieldsArr = params.displayColumnFilter.split(",");
+            if (!initFieldsArr ||
+                this.needGetPortletData(initFieldsArr, curFieldsArr)) {
+                this.portletFields_Temp[id] = curFieldsArr;
+            }
+        }
+        if (filterSettings && filterSettings.length) {
+            if (!params.columnFilter) {
+                params.columnFilter = [];
+            }
+            config.filterSettings = filterSettings;
+            filterSettings.forEach((/**
+             * @param {?} setting
+             * @return {?}
+             */
+            (setting) => {
+                if (config.portletType === "pivot") {
+                    return;
+                }
+                /** @type {?} */
+                const _field = config.fields.find((/**
+                 * @param {?} item
+                 * @return {?}
+                 */
+                (item) => item.colName === setting.name));
+                /** @type {?} */
+                const Type = _field && _field.dataType;
+                if (setting.items) {
+                    setting.items.forEach((/**
+                     * @param {?} item
+                     * @return {?}
+                     */
+                    (item) => {
+                        params.columnFilter.push({
+                            Field: setting.name,
+                            Operator: "equal",
+                            Type,
+                            Value: Type === "date"
+                                ? moment(item).format("yyyy-MM-DD")
+                                : Type === "datetime"
+                                    ? moment(item).format("yyyy-MM-DD hh:mm:ss")
+                                    : item,
+                        });
+                    }));
+                }
+                else if (setting.operator) {
+                    params.columnFilter.push({
+                        Field: setting.field,
+                        Operator: "equal",
+                        Type: setting.type,
+                        Value: setting.type === "date"
+                            ? moment(setting.value).format("yyyy-MM-DD")
+                            : setting.type === "datetime"
+                                ? moment(setting.value).format("yyyy-MM-DD hh:mm:ss")
+                                : setting.value,
+                    });
+                }
+            }));
+        }
+        else {
+            config.filterSettings = [];
+        }
+        if (params.columnFilter instanceof Array) {
+            params.columnFilter = params.columnFilter.filter((/**
+             * @param {?} item
+             * @return {?}
+             */
+            (item) => item.Field));
+        }
+        // json buffer
+        params["dashboardVersion"] = 2;
+        // json buffer
+        this.httpClient
+            .post(this.api.baseurl + this.api.urlList.GetPortletDataOrCreate, params, {
+            headers: new HttpHeaders({
+                Authorization: `Bearer`,
+            }),
+        })
+            .subscribe((/**
+         * @param {?} result
+         * @return {?}
+         */
+        (result) => {
+            result["data"].forEach((/**
+             * @param {?} item
+             * @return {?}
+             */
+            (item) => {
+                item.Sector = this.translation[item.Sector] || item.Sector;
+            }));
+            this.portletData_New[dashboard.id][id] = result;
+            this.pbf.triggerDashboardFilterChange.next({
+                id: dashboard.id,
+                newId: portlet.newId,
+            });
+            callback({ newId: portlet && portlet.newId, config });
+        }));
+    }
+    /**
+     * @param {?} str
+     * @return {?}
+     */
+    removeParentheses(str) {
+        return str.split("(").join("").split(")").join("").split('"').join("");
+    }
+    /**
+     * @return {?}
+     */
+    getInfo() {
+        this.translation = JSON.parse(localStorage.getItem("translation"));
+        this.userInfo = JSON.parse(localStorage.getItem("userInfo"));
+        this.lang = this.pbf.getLanguageParams();
+        this.translation.DASHBOARD_ROLLING = this.translation.DASHBOARD_ROLLING
+            ? this.translation.DASHBOARD_ROLLING
+            : "DASHBOARD_ROLLING";
+    }
+    /*     Financial Analysis I      get select Dropdown */
+    /**
+     * @return {?}
+     */
+    GetChartTypes() {
+        // Chart Type
+        return [
+            {
+                val: "mscombi2d",
+                displayVal: this.translation.SINGLEY2D,
+                hasSecondaryYAxis: false,
+                canSelectStyle: true,
+            },
+            {
+                val: "mscombi3d",
+                displayVal: this.translation.SINGLEY3D,
+                hasSecondaryYAxis: false,
+                canSelectStyle: true,
+            },
+            {
+                val: "mscombidy2d",
+                displayVal: this.translation.DUALY2D,
+                hasSecondaryYAxis: true,
+                canSelectStyle: true,
+            },
+            {
+                val: "msbar2d",
+                displayVal: this.translation.BAR2D,
+                hasSecondaryYAxis: false,
+                canSelectStyle: false,
+            },
+            {
+                val: "msbar3d",
+                displayVal: this.translation.BAR3D,
+                hasSecondaryYAxis: false,
+                canSelectStyle: false,
+            },
+            {
+                val: "stackedcolumn2dline",
+                displayVal: this.translation.STACKEDBAR2D,
+                hasSecondaryYAxis: false,
+                canSelectStyle: true,
+            },
+            {
+                val: "stackedcolumn3dline",
+                displayVal: this.translation.STACKEDBAR3D,
+                hasSecondaryYAxis: false,
+                canSelectStyle: true,
+            },
+        ];
+    }
+    /**
+     * @return {?}
+     */
+    getCompanyDropdown() {
+        // company
+        /** @type {?} */
+        let data = {
+            accountId: this.userInfo.accountId,
+            username: this.userInfo.username,
+            language: this.lang,
+            companyType: "portfolio",
+        };
+        this.http.post(this.api.urlList.GetAllCompanyByAccount, data, (/**
+         * @param {?} res
+         * @return {?}
+         */
+        (res) => {
+            if (res) {
+                this.companyDropdownList = res;
+                // return res;
+            }
+        }));
+    }
+    /**
+     * @return {?}
+     */
+    getCurrencyDropdown() {
+        // Currency
+        /** @type {?} */
+        let data = {
+            accountId: this.userInfo.accountId,
+            username: this.userInfo.username,
+            language: this.lang,
+            alias: "Currency",
+        };
+        this.http.post(this.api.urlList.GetDropdown, data, (/**
+         * @param {?} res
+         * @return {?}
+         */
+        (res) => {
+            if (res) {
+                this.currencyDropdownList = res;
+                // return res;
+            }
+        }));
+    }
+    /**
+     * @return {?}
+     */
+    GetTimeMeasure() {
+        // Time Measure
+        return [
+            {
+                key: "MTD",
+                // 月度
+                val: this.translation.MONTHLY,
+            },
+            {
+                key: "QTD",
+                // 季度
+                val: this.translation.QUARTERLY,
+            },
+            {
+                key: "SYTD",
+                // 半年度
+                val: this.translation.SEMIANNUALLY,
+            },
+            {
+                key: "YTD",
+                // 年度
+                val: this.translation.ANNUALLY,
+            },
+            {
+                key: "FYTD",
+                // 年度（财政年度）
+                val: this.translation.ANNUALLYFY,
+            },
+            {
+                key: "LTM",
+                // 最近十二个月
+                val: this.translation.LAST12MONTH,
+            },
+        ];
+    }
+    /**
+     * @return {?}
+     */
+    GetPeriods() {
+        // Previous Period
+        return [
+            {
+                val: 2,
+                displayVal: this.translation.LAST2DATA,
+            },
+            {
+                val: 3,
+                displayVal: this.translation.LAST3DATA,
+            },
+            {
+                val: 4,
+                displayVal: this.translation.LAST4DATA,
+            },
+            {
+                val: 5,
+                displayVal: this.translation.LAST5DATA,
+            },
+            {
+                val: 6,
+                displayVal: this.translation.LAST6DATA,
+            },
+            {
+                val: 7,
+                displayVal: this.translation.LAST7DATA,
+            },
+            {
+                val: 8,
+                displayVal: this.translation.LAST8DATA,
+            },
+            {
+                val: 9,
+                displayVal: this.translation.LAST9DATA,
+            },
+            {
+                val: 10,
+                displayVal: this.translation.LAST10DATA,
+            },
+            {
+                val: 11,
+                displayVal: this.translation.LAST11DATA,
+            },
+            {
+                val: 12,
+                displayVal: this.translation.LAST12DATA,
+            },
+            {
+                val: 13,
+                displayVal: this.translation.LAST13DATA,
+            },
+            {
+                val: 14,
+                displayVal: this.translation.LAST14DATA,
+            },
+            {
+                val: 15,
+                displayVal: this.translation.LAST15DATA,
+            },
+            {
+                val: 16,
+                displayVal: this.translation.LAST16DATA,
+            },
+            {
+                val: 17,
+                displayVal: this.translation.LAST17DATA,
+            },
+            {
+                val: 18,
+                displayVal: this.translation.LAST18DATA,
+            },
+            {
+                val: 19,
+                displayVal: this.translation.LAST19DATA,
+            },
+            {
+                val: 20,
+                displayVal: this.translation.LAST20DATA,
+            },
+            {
+                val: 21,
+                displayVal: this.translation.LAST21DATA,
+            },
+            {
+                val: 22,
+                displayVal: this.translation.LAST22DATA,
+            },
+            {
+                val: 23,
+                displayVal: this.translation.LAST23DATA,
+            },
+            {
+                val: 24,
+                displayVal: this.translation.LAST24DATA,
+            },
+        ];
+    }
+    /**
+     * @return {?}
+     */
+    GetFollowingPeriods() {
+        // Following Period
+        return [
+            {
+                val: 0,
+                displayVal: this.translation.NONEXTDATA,
+            },
+            {
+                val: 3,
+                displayVal: this.translation.NEXT3DATA,
+            },
+            {
+                val: 4,
+                displayVal: this.translation.NEXT4DATA,
+            },
+            {
+                val: 5,
+                displayVal: this.translation.NEXT5DATA,
+            },
+            {
+                val: 6,
+                displayVal: this.translation.NEXT6DATA,
+            },
+            {
+                val: 7,
+                displayVal: this.translation.NEXT7DATA,
+            },
+            {
+                val: 8,
+                displayVal: this.translation.NEXT8DATA,
+            },
+            {
+                val: 9,
+                displayVal: this.translation.NEXT9DATA,
+            },
+            {
+                val: 10,
+                displayVal: this.translation.NEXT10DATA,
+            },
+            {
+                val: 11,
+                displayVal: this.translation.NEXT11DATA,
+            },
+            {
+                val: 12,
+                displayVal: this.translation.NEXT12DATA,
+            },
+        ];
+    }
+    /**
+     * @return {?}
+     */
+    GetFinancialFigureCodes() {
+        // Financial Type
+        return [
+            {
+                key: "accountAssetFigure",
+                val: this.translation.DASHD_ACCOUNTASSETFIGURE,
+            },
+            {
+                key: "accountEquityFigure",
+                val: this.translation.DASHD_ACCOUNTEQUITYFIGURE,
+            },
+            {
+                key: "accountLiabilityFigure",
+                val: this.translation.DASHD_ACCOUNTLIABILITYFIGURE,
+            },
+            {
+                key: "accountPLFigure",
+                val: this.translation.DASHD_ACCOUNTPLFIGURE,
+            },
+            {
+                key: "accountCashflowFigure",
+                val: this.translation.DASHD_ACCOUNTCASHFLOWFIGURE,
+            },
+            {
+                key: "accountOperationKPIFigure",
+                val: this.translation.DASHD_ACCOUNTOPERATIONKPIFIGURE,
+            },
+            {
+                key: "accountRATIOFigure",
+                val: this.translation.DASHD_ACCOUNTRATIOFIGURE,
+            },
+        ];
+    }
+    /**
+     * @param {?} financials
+     * @return {?}
+     */
+    GetFinancialSubType(financials) {
+        /** @type {?} */
+        var financialTypes = [];
+        for (var item in financials) {
+            financialTypes.push({
+                subType: item["subType"],
+                subTypeCode: item["subTypeCode"],
+            });
+        }
+        return financialTypes;
+    }
+    /**
+     * @param {?} id
+     * @param {?} key
+     * @return {?}
+     */
+    GetFinancialItems(id, key) {
+        /** @type {?} */
+        let data = {
+            username: this.userInfo.username,
+            accountId: this.userInfo.accountId,
+            investeeIds: [id],
+            figureCode: key,
+            language: this.lang,
+        };
+        this.http.post(this.api.urlList.GetFinancialItems, data, (/**
+         * @param {?} res
+         * @return {?}
+         */
+        (res) => {
+            if (res) {
+                return res;
+            }
+        }));
+    }
+    /* get toggle */
+    /**
+     * @return {?}
+     */
+    GetTheme() {
+        return [
+            { key: "zune", val: this.translation.CHARTTHEME_ZUNE },
+            { key: "ocean", val: this.translation.CHARTTHEME_OCEAN },
+            { key: "carbon", val: this.translation.CHARTTHEME_CARBON },
+        ];
+    }
+    /**
+     * @return {?}
+     */
+    GetFollowingDataType() {
+        return [
+            { key: "budget", val: this.translation.BUDGET },
+            { key: "forecast", val: this.translation.FORECAST },
+            // { key: 'rolling', val: this.translation.DASHBOARD_ROLLING },
+            { key: "rolling", val: "Rolling" },
+        ];
+    }
+    /**
+     * @return {?}
+     */
+    GetFormat() {
+        return [
+            { key: "number", val: this.translation.NUMBER },
+            { key: "percentage", val: this.translation.PERCENTAGE },
+        ];
+    }
+    /**
+     * @return {?}
+     */
+    GetChartStyle() {
+        return [
+            { key: "bar", val: this.translation.BAR },
+            { key: "line", val: this.translation.LINE },
+            { key: "area", val: this.translation.AREA },
+        ];
+    }
+    /*     Fund Operation Summary       */
+    /**
+     * @return {?}
+     */
+    getFundDropdown() {
+        /** @type {?} */
+        let data = {
+            username: this.userInfo.username,
+            accountId: this.userInfo.accountId,
+            investorId: this.userInfo.accountId,
+            language: this.lang,
+        };
+        this.http.post(this.api.urlList.GetFundListByInvestorId, data, (/**
+         * @param {?} res
+         * @return {?}
+         */
+        (res) => {
+            if (res) {
+                this.fundDropdownList = res;
+                // return res;
+            }
+        }));
+    }
+    /*     Fund performance       */
+    /**
+     * @return {?}
+     */
+    GetGrouping() {
+        return [
+            { key: "null", val: "" },
+            { key: "investor", val: this.translation.DASHD_GP_INVESTOR },
+            { key: "fund", val: this.translation.DASHD_GP_FUND },
+        ];
+    }
+    /*     Fund Operation Summary       */
+    /**
+     * @param {?} callbake
+     * @return {?}
+     */
+    getFundDropdown_(callbake) {
+        /** @type {?} */
+        let data = {
+            username: this.userInfo.username,
+            accountId: this.userInfo.accountId,
+            investorId: this.userInfo.accountId,
+            language: this.lang,
+        };
+        this.http.post(this.api.urlList.GetFundListByInvestorId, data, (/**
+         * @param {?} res
+         * @return {?}
+         */
+        (res) => {
+            if (res) {
+                this.fundDropdownList = res;
+                // this.GetAllInvestee(res => {
+                callbake();
+                // });
+            }
+        }));
+    }
+    /*     Investor position       */
+    /**
+     * @param {?} callbake
+     * @return {?}
+     */
+    GetAllInvestee(callbake) {
+        /** @type {?} */
+        let data = {
+            username: this.userInfo.username,
+            accountId: this.userInfo.accountId,
+            language: this.lang,
+        };
+        this.http.post(this.api.urlList.GetAllInvestee, data, (/**
+         * @param {?} res
+         * @return {?}
+         */
+        (res) => {
+            if (res) {
+                this.allInvesteeList = res;
+                callbake();
+            }
+        }));
+    }
+    /**
+     * @param {?} num
+     * @return {?}
+     */
+    pivotTableformatNumber(num) {
+        switch (num) {
+            case 1:
+            case 2:
+            case 3:
+                return "#,###;(#,###)";
+            case 4:
+            case 5:
+            case 6:
+                return "#,###.0;(#,###.0)";
+            case 7:
+            case 8:
+            case 9:
+                return "#,###.00;(#,###.00)";
+            case 10:
+            case 11:
+            case 12:
+                return "#,###,,;(#,###,,)";
+            case 13:
+            case 14:
+            case 15:
+                return "#,###,,.0;(#,###,,.0)";
+            case 16:
+            case 17:
+            case 18:
+                return "#,###,,.00;(#,###,,.00)";
+            default:
+                return "#,###.00;-#,###.00";
+        }
+    }
+    /**
+     * @param {?} num
+     * @return {?}
+     */
+    pivotTableformatInteger(num) {
+        switch (num) {
+            case 1:
+            case 3:
+            case 4:
+                return "#,###;(#,###)";
+            case 4:
+            case 5:
+            case 6:
+                return "#,###,,;(#,###,,)";
+            default:
+                return "#,###;(#,###)";
+        }
+    }
+    /**
+     * @param {?} num
+     * @return {?}
+     */
+    pivotTableformatPercent(num) {
+        switch (num) {
+            case 1:
+            case 2:
+            case 3:
+                return "P";
+            case 4:
+            case 5:
+            case 6:
+                return "P1";
+            case 7:
+            case 8:
+            case 9:
+                return "P2";
+            case 10:
+            case 11:
+            case 12:
+                return "#,###0.00'x';(#,###0.00'x')";
+            default:
+                return "P2";
+        }
+    }
+    /**
+     * @param {?} num
+     * @return {?}
+     */
+    pivotTableformatPercentNum(num) {
+        switch (num) {
+            case 1:
+                return "####'%'";
+            case 2:
+                return "####.0'%'";
+            case 3:
+                return "####.00'%'";
+            default:
+                return "####.00'%'";
+        }
+    }
+    /**
+     * @param {?} num
+     * @return {?}
+     */
+    pivotTableformatMultiple(num) {
+        switch (num) {
+            case 1:
+                return "####'x'";
+            case 2:
+                return "###0.0'x'";
+            case 3:
+                return "###0.00'x'";
+            default:
+                return "###0.00'x'";
+        }
+    }
+    /**
+     * @param {?} num
+     * @return {?}
+     */
+    formatNumber(num) {
+        switch (num) {
+            case 0:
+                return "N";
+            case 1:
+                return "N1";
+            case 2:
+                return "N2";
+            case 3:
+                return "N3";
+            case 4:
+                return "N4";
+            case 5:
+                return "N5";
+            case 6:
+                return "N6";
+            default:
+                return "N2";
+        }
+    }
+    /**
+     * @param {?} num
+     * @return {?}
+     */
+    formatPercent(num) {
+        switch (num) {
+            case 0:
+                return "P";
+            case 1:
+                return "P1";
+            case 2:
+                return "P2";
+            case 3:
+                return "P3";
+            case 4:
+                return "P4";
+            case 5:
+                return "P5";
+            case 6:
+                return "P6";
+            default:
+                return "P2";
+        }
+    }
+    /**
+     * @param {?} num
+     * @return {?}
+     */
+    formatPercentNum(num) {
+        switch (num) {
+            case 0:
+                return "####'%'";
+            case 1:
+                return "###0.0'%'";
+            case 2:
+                return "###0.00'%'";
+            default:
+                return "###0.00'%'";
+        }
+    }
+    /**
+     * @param {?} num
+     * @return {?}
+     */
+    formatMultiple(num) {
+        switch (num) {
+            case 0:
+                return "####'x'";
+            case 1:
+                return "###0.0'x'";
+            case 2:
+                return "###0.00'x'";
+            default:
+                return "###0.00'x'";
+        }
+    }
+    /**
+     * @return {?}
+     */
+    GetFigureFormat() {
+        // return [
+        // 	{ key1: "1,234,567", key2: "(1,234,567)", key3: "-", val: 1 }, //
+        // 	{ key1: "1,234,567", key2: "(1,234,567)", key3: "-", val: 2 }, //
+        // 	{ key1: "1,234,567.00", key2: "(1,234,567.00)", key3: "-", val: 3 }, //
+        // 	{ key1: "1,234,567.00", key2: "(1,234,567.00)", key3: "-", val: 4 }, //
+        // 	{ key1: "1", key2: "(1)", key3: "-", val: 5 }, //
+        // 	{ key1: "1", key2: "(1)", key3: "-", val: 6 }, //
+        // 	{ key1: "1.2", key2: "(1.2)", key3: "0.0", val: 7 }, //
+        // 	{ key1: "1.2", key2: "(1.2)", key3: "0.0", val: 8 }, //
+        // 	{ key1: "1.23", key2: "(1.23)", key3: "0.00", val: 9 }, //
+        // 	{ key1: "1.23", key2: "(1.23)", key3: "0.00", val: 10 }, //
+        // ];
+        return [
+            { key: "1,234,567;(1,234,567);0", val: 1 },
+            { key: "1,234,567;(1,234,567);-", val: 2 },
+            { key: "1,234,567;(1,234,567);", val: 3 },
+            { key: "1,234,567.0;(1,234,567.0);0.0", val: 4 },
+            { key: "1,234,567.0;(1,234,567.0);-", val: 5 },
+            { key: "1,234,567.0;(1,234,567.0);", val: 6 },
+            { key: "1,234,567.00;(1,234,567.00);0.00", val: 7 },
+            { key: "1,234,567.00;(1,234,567.00);-", val: 8 },
+            { key: "1,234,567.00;(1,234,567.00);", val: 9 },
+            { key: "1;(1);0", val: 10 },
+            { key: "1;(1);-", val: 11 },
+            { key: "1;(1);", val: 12 },
+            { key: "1.2;(1.2);0.0", val: 13 },
+            { key: "1.2;(1.2);-", val: 14 },
+            { key: "1.2;(1.2);", val: 15 },
+            { key: "1.23;(1.23);0.00", val: 16 },
+            { key: "1.23;(1.23);-", val: 17 },
+            { key: "1.23;(1.23);", val: 18 },
+        ];
+    }
+    // public GetFigureFormat2() {
+    // 	return [
+    // 		// 1234567
+    // 		{ key: "1,234,567", val: 11 },
+    // 		{ key: "1,234,567.00", val: 12 },
+    // 		{ key: "1", val: 13 },
+    // 		{ key: "1.2", val: 14 },
+    // 		{ key: "1.23", val: 15 },
+    // 	];
+    // };
+    /**
+     * @return {?}
+     */
+    GetFigureFormat3() {
+        // return [
+        // 	{ key1: "1,234,567", key2: "(1,234,567)", key3: "-", val: 1 }, //
+        // 	{ key1: "1,234,567", key2: "(1,234,567)", key3: "-", val: 2 }, //
+        // 	{ key1: "1", key2: "(1)", key3: "-", val: 3 }, //
+        // 	{ key1: "1", key2: "(1)", key3: "-", val: 4 }, //
+        // 	{ key: "1", val: 5 },
+        // ];
+        return [
+            { key: "1,234,567;(1,234,567);0", val: 1 },
+            { key: "1,234,567;(1,234,567);-", val: 2 },
+            { key: "1,234,567;(1,234,567);", val: 3 },
+            { key: "1;(1);0", val: 4 },
+            { key: "1;(1);-", val: 5 },
+            { key: "1;(1);", val: 6 },
+        ];
+    }
+    /**
+     * @return {?}
+     */
+    GetPercentFormats() {
+        // return [
+        // 	{ key1: "0%", key2: "0%", key3: "-", val: 1 },
+        // 	{ key1: "0%", key2: "(0%)", key3: "-", val: 2 },
+        // 	{ key1: "0.0%", key2: "0.0%", key3: "-", val: 3 },
+        // 	{ key1: "0.0%", key2: "(0.0%)", key3: "-", val: 4 },
+        // 	{ key1: "0.00%", key2: "0.00%", key3: "-", val: 5 },
+        // 	{ key1: "0.00%", key2: "(0.00%)", key3: "-", val: 6 },
+        // ];
+        return [
+            { key: "1%;(1%);0%", val: 1 },
+            { key: "1%;(1%);-", val: 2 },
+            { key: "1%;(1%);", val: 3 },
+            { key: "1.2%;(1.2%);0.0%", val: 4 },
+            { key: "1.2%;(1.2%);-", val: 5 },
+            { key: "1.2%;(1.2%);", val: 6 },
+            { key: "1.23%;(1.23%);0.00%", val: 7 },
+            { key: "1.23%;(1.23%);-", val: 8 },
+            { key: "1.23%;(1.23%);", val: 9 },
+            { key: "1.23x;(1.23x);0.00x", val: 10 },
+            { key: "1.23x;(1.23x);-", val: 11 },
+            { key: "1.23x;(1.23x);", val: 12 },
+        ];
+    }
+    /**
+     * @return {?}
+     */
+    GetMultipleFormats() {
+        return [
+            { key: "0x", val: 1 },
+            { key: "0.0x", val: 2 },
+            { key: "0.00x", val: 3 },
+        ];
+    }
+    /**
+     * @param {?} aggregateType
+     * @return {?}
+     */
+    getAggregateType(aggregateType) {
+        switch (aggregateType) {
+            case "CalculateIRR":
+                return "CI";
+            case "CalculateIRRIRRDate":
+                return "CI_IRR";
+            case "CalculateIRRBeforeCarried":
+                return "CI_BEFORE_CARRY";
+            case "CalculateIRRReported":
+                return "CI_REPORTED";
+            case "CalculateIRRActualAudited":
+                return "CI_ACTUAL_AUDITED";
+            case "CalculateIRRMTD":
+                return "CI_MTD";
+            case "CalculateIRRQTD":
+                return "CI_QTD";
+            case "CalculateIRRYTD":
+                return "CI_YTD";
+            case "CalculateTWRMTD":
+                return "CTWR_MTD";
+            case "CalculateTWRQTD":
+                return "CTWR_QTD";
+            case "CalculateTWRYTD":
+                return "CTWR_YTD";
+            case "CalculateVARMTD_99":
+                return "CVAR_MTD_99";
+            case "CalculateVARQTD_99":
+                return "CVAR_QTD_99";
+            case "CalculateVARYTD_99":
+                return "CVAR_YTD_99";
+            case "CalculateVARMTD_95":
+                return "CVAR_MTD_95";
+            case "CalculateVARQTD_95":
+                return "CVAR_QTD_95";
+            case "CalculateVARYTD_95":
+                return "CVAR_YTD_95";
+            case "CalculateMultiple":
+                return "CM";
+            case "CalculatePIC":
+                return "CP";
+            case "CalculateDPI":
+                return "CD";
+            case "CalculateTVPI":
+                return "CT";
+            case "CalculateRVPI":
+                return "CR";
+            case "CalculateMActualAudited":
+                return "CM_ACTUAL_AUDITED";
+            case "CalculateMReported":
+                return "CM_REPORTED";
+        }
+    }
+    /**
+     * @param {?} colName
+     * @return {?}
+     */
+    getCalculateMethod(colName) {
+        switch (colName) {
+            case "CI":
+                return "CalculateIRR";
+            case "CI_IRR":
+                return "CalculateIRRIRRDate";
+            case "CI_BEFORE_CARRY":
+                return "CalculateIRRBeforeCarried";
+            case "CI_REPORTED":
+                return "CalculateIRRReported";
+            case "CI_ACTUAL_AUDITED":
+                return "CalculateIRRActualAudited";
+            case "CI_MTD":
+                return "CalculateIRRMTD";
+            case "CI_QTD":
+                return "CalculateIRRQTD";
+            case "CI_YTD":
+                return "CalculateIRRYTD";
+            case "CTWR_MTD":
+                return "CalculateTWRMTD";
+            case "CTWR_QTD":
+                return "CalculateTWRQTD";
+            case "CTWR_YTD":
+                return "CalculateTWRYTD";
+            case "CVAR_MTD_99":
+                return "CalculateVARMTD_99";
+            case "CVAR_QTD_99":
+                return "CalculateVARQTD_99";
+            case "CVAR_YTD_99":
+                return "CalculateVARYTD_99";
+            case "CVAR_MTD_95":
+                return "CalculateVARMTD_95";
+            case "CVAR_QTD_95":
+                return "CalculateVARQTD_95";
+            case "CVAR_YTD_95":
+                return "CalculateVARYTD_95";
+            case "CM":
+                return "CalculateMultiple";
+            case "CP":
+                return "CalculatePIC";
+            case "CD":
+                return "CalculateDPI";
+            case "CT":
+                return "CalculateTVPI";
+            case "CR":
+                return "CalculateRVPI";
+            case "CM_ACTUAL_AUDITED":
+                return "CalculateMActualAudited";
+            case "CM_REPORTED":
+                return "CalculateMReported";
+        }
+    }
+    // 格式化数字
+    /**
+     * @param {?} number
+     * @param {?} decimals
+     * @param {?} dec_point
+     * @param {?} thousands_sep
+     * @param {?} roundtag
+     * @return {?}
+     */
+    number_format(number, decimals, dec_point, thousands_sep, roundtag) {
+        /*
+         * 参数说明：
+         * number：要格式化的数字
+         * decimals：保留几位小数
+         * dec_point：小数点符号
+         * thousands_sep：千分位符号
+         * roundtag:舍入参数，默认 "ceil" 向上取,"floor"向下取,"round" 四舍五入
+         * */
+        number = (number + "").replace(/[^0-9+-Ee.]/g, "");
+        roundtag = roundtag || "ceil"; //"ceil","floor","round"
+        //"ceil","floor","round"
+        /** @type {?} */
+        let n = !isFinite(+number) ? 0 : +number;
+        /** @type {?} */
+        let prec = !isFinite(+decimals) ? 0 : Math.abs(decimals);
+        /** @type {?} */
+        let sep = typeof thousands_sep === "undefined" ? "," : thousands_sep;
+        /** @type {?} */
+        let dec = typeof dec_point === "undefined" ? "." : dec_point;
+        // let  s = '';
+        /** @type {?} */
+        let s = (prec
+            ? this.toFixedFix(n, prec, roundtag)
+            : "" + this.pbf.tofixedNum(n, decimals)).split(".");
+        //this.pbf.tofixedNum(Math.abs(value), decimal)
+        /** @type {?} */
+        var re = /(-?\d+)(\d{3})/;
+        while (re.test(s[0])) {
+            s[0] = s[0].replace(re, "$1" + sep + "$2");
+        }
+        if ((s[1] || "").length < prec) {
+            s[1] = s[1] || "";
+            s[1] += new Array(prec - s[1].length + 1).join("0");
+        }
+        return s.join(dec);
+    }
+    /**
+     * @private
+     * @param {?} n
+     * @param {?} prec
+     * @param {?} roundtag
+     * @return {?}
+     */
+    toFixedFix(n, prec, roundtag) {
+        /** @type {?} */
+        var k = Math.pow(10, prec);
+        return ("" +
+            parseFloat(Math[roundtag](parseFloat((n * k).toFixed(prec * 2))).toFixed(prec * 2)) /
+                k);
+    }
+    /**
+     * @param {?} portlet
+     * @param {?=} isGetTotal
+     * @param {?=} copyId
+     * @param {?=} id
+     * @return {?}
+     */
+    getResultByDataTable(portlet, isGetTotal = false, copyId = false, id) {
+        /** @type {?} */
+        let result = [];
+        /** @type {?} */
+        let datamartCode = portlet.figureCode;
+        /** @type {?} */
+        let identifier = portlet.id === "00000000-0000-0000-0000-000000000000"
+            ? portlet.newId
+            : portlet.id;
+        if (portlet.copyId) {
+            identifier = portlet.copyId;
+        }
+        if (this.portletData_New[id][identifier]) {
+            result = isGetTotal
+                ? this.portletData_New[id][identifier] &&
+                    this.portletData_New[id][identifier].total
+                : this.portletData_New[id][identifier] &&
+                    this.portletData_New[id][identifier].data;
+        }
+        else {
+            result = isGetTotal
+                ? this.portletResults_New[id][datamartCode] &&
+                    this.portletResults_New[id][datamartCode].total
+                : this.portletResults_New[id][datamartCode] &&
+                    this.portletResults_New[id][datamartCode].data;
+        }
+        return result;
+    }
+    // SMP2-3708 END
+    /**
+     * @param {?} datamartCode
+     * @param {?} dashboard
+     * @return {?}
+     */
+    getOrderByColumnsNew(datamartCode, dashboard) {
+        return new Promise((/**
+         * @param {?} resolve
+         * @return {?}
+         */
+        (resolve) => {
+            if (this.sourcesData[dashboard.id] && dashboard) {
+                /** @type {?} */
+                const outputRes = [];
+                if (this.sourcesData[dashboard.id].length) {
+                    /** @type {?} */
+                    let config = JSON.parse(dashboard.config);
+                    /** @type {?} */
+                    const dataViews = config.views;
+                    if (dashboard && dashboard.config) {
+                        /** @type {?} */
+                        const dataMart = this.sourcesData[dashboard.id].filter((/**
+                         * @param {?} item
+                         * @return {?}
+                         */
+                        (item) => item.entityType === dashboard.entityType));
+                        dataMart.forEach((/**
+                         * @param {?} _data
+                         * @return {?}
+                         */
+                        (_data) => {
+                            _data.views.forEach((/**
+                             * @param {?} view
+                             * @return {?}
+                             */
+                            (view) => {
+                                if (dataViews.find((/**
+                                 * @param {?} item
+                                 * @return {?}
+                                 */
+                                (item) => item.datamartViewId === view.id))) {
+                                    view.tables.forEach((/**
+                                     * @param {?} table
+                                     * @return {?}
+                                     */
+                                    (table) => {
+                                        outputRes.push(table);
+                                    }));
+                                }
+                            }));
+                        }));
+                    }
+                }
+                resolve(outputRes);
+            }
+            else {
+                // 处理 this.sourcesData 没有值
+                /** @type {?} */
+                let data = {
+                    accountId: this.userInfo.accountId,
+                    language: this.lang,
+                    dashboardVersion: 2,
+                };
+                this.http.post(this.api.urlList.GetSources, data, (/**
+                 * @param {?} res
+                 * @return {?}
+                 */
+                (res) => {
+                    /** @type {?} */
+                    const outputRes = [];
+                    if (res && res.length) {
+                        this.sourcesData[dashboard.id] = res;
+                        /** @type {?} */
+                        let config = JSON.parse(dashboard.config);
+                        /** @type {?} */
+                        const dataViews = config.views;
+                        if (dashboard && dashboard.config) {
+                            /** @type {?} */
+                            const dataMart = res.filter((/**
+                             * @param {?} item
+                             * @return {?}
+                             */
+                            (item) => item.entityType === dashboard.entityType));
+                            dataMart.forEach((/**
+                             * @param {?} _data
+                             * @return {?}
+                             */
+                            (_data) => {
+                                _data.views.forEach((/**
+                                 * @param {?} view
+                                 * @return {?}
+                                 */
+                                (view) => {
+                                    if (dataViews.find((/**
+                                     * @param {?} item
+                                     * @return {?}
+                                     */
+                                    (item) => item.datamartViewId === view.id))) {
+                                        view.tables.forEach((/**
+                                         * @param {?} table
+                                         * @return {?}
+                                         */
+                                        (table) => {
+                                            outputRes.push(table);
+                                        }));
+                                    }
+                                }));
+                            }));
+                        }
+                    }
+                    resolve(outputRes);
+                }));
+            }
+        }));
+    }
+    /**
+     * @param {?} input
+     * @return {?}
+     */
+    decompressArrayBuffer(input) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            //create the stream
+            /** @type {?} */
+            const ds = new ((/** @type {?} */ (window))).DecompressionStream("deflate-raw");
+            //create the writer
+            /** @type {?} */
+            const writer = ds.writable.getWriter();
+            //write the buffer to the writer thus decompressing it
+            writer.write(input);
+            writer.close();
+            //create the output
+            /** @type {?} */
+            const output = [];
+            //create the reader
+            /** @type {?} */
+            const reader = ds.readable.getReader();
+            /** @type {?} */
+            let totalSize = 0;
+            //go through each chunk and add it to the output
+            while (true) {
+                const { value, done } = yield reader.read();
+                if (done)
+                    break;
+                output.push(value);
+                totalSize += value.byteLength;
+            }
+            /** @type {?} */
+            const concatenated = new Uint8Array(totalSize);
+            /** @type {?} */
+            let offset = 0;
+            //finally build the compressed array and return it
+            for (const array of output) {
+                concatenated.set(array, offset);
+                offset += array.byteLength;
+            }
+            return concatenated;
+        });
+    }
+    /**
+     * @private
+     * @param {?} item
+     * @param {?} dashboard
+     * @return {?}
+     */
+    getAllFields(item, dashboard) {
+        /** @type {?} */
+        const lang = this.pbf.getLanguageParams();
+        return new Promise((/**
+         * @param {?} resolve
+         * @param {?} reject
+         * @return {?}
+         */
+        (resolve, reject) => {
+            /** @type {?} */
+            const dataMartCode = item.figureCode;
+            /** @type {?} */
+            const dataObj = {
+                language: lang,
+                dataMartCode,
+            };
+            this.setSchemaParams(dataObj, dataMartCode, dashboard);
+            this.http.post(this.api.urlList.GetSchema, dataObj, (/**
+             * @param {?} res
+             * @return {?}
+             */
+            (res) => {
+                resolve(res);
+            }));
+        }));
+    }
+    /**
+     * @param {?} dataObj
+     * @param {?} figureCode
+     * @param {?} dashboard
+     * @return {?}
+     */
+    setSchemaParams(dataObj, figureCode, dashboard) {
+        if (this.checkIsQ2Q(dashboard.dataMartTables)) {
+            dataObj["fromDate"] = dashboard.fromDate;
+            dataObj["asOfDate"] = dashboard.asOfDate;
+        }
+        else if (figureCode.indexOf("FinancialFigure") !== -1) {
+            dataObj["entityType"] = dashboard.entityList.map((/**
+             * @param {?} item
+             * @return {?}
+             */
+            (item) => item.linkedType));
+            dataObj["fromDate"] = dashboard.fromDate || "";
+            dataObj["asOfDate"] = dashboard.asOfDate;
+        }
+        if (dashboard &&
+            (figureCode === "FundOperations" ||
+                figureCode === "FundOperationTableSequoia" ||
+                figureCode.indexOf("FinancialFigure") !== -1)) {
+            dataObj["entityIds"] = dashboard.entityList.map((/**
+             * @param {?} item
+             * @return {?}
+             */
+            (item) => item.linkedGuid));
+        }
+    }
+    // 判断是否可选开始日期
+    /**
+     * @param {?} dataMart
+     * @return {?}
+     */
+    checkHasFromDate(dataMart) {
+        /** @type {?} */
+        const has = dataMart.find((/**
+         * @param {?} item
+         * @return {?}
+         */
+        (item) => !item.isHide && item.datamartCode === "FundOperationTableSequoia"));
+        return !!has;
+    }
+    // 判断Q2Q，控制顶部日期选择类型
+    /**
+     * @param {?} dataMart
+     * @return {?}
+     */
+    checkIsQ2Q(dataMart) {
+        return false;
+        /** @type {?} */
+        const Q2QPatchList = [
+            "SeeThroughHisPosition",
+            "SeeThroughHisPositionByInvestor",
+        ];
+        /** @type {?} */
+        const has = dataMart.find((/**
+         * @param {?} it
+         * @return {?}
+         */
+        (it) => {
+            return !it.isHide && Q2QPatchList.includes(it.datamartCode);
+        }));
+        return !!has;
+    }
+    /**
+     * 使用自定义保存的列数据，覆盖通用列配置数据
+     * @param {?} allFields 自定义数据
+     * @param {?} fields 通用列配置数据
+     * @return {?}
+     */
+    setConfigFields(allFields, fields) {
+        allFields.forEach((/**
+         * @param {?} _field
+         * @return {?}
+         */
+        (_field) => {
+            fields.forEach((/**
+             * @param {?} field
+             * @return {?}
+             */
+            (field) => {
+                if (_field.colName === field.colName) {
+                    _field.isHidden = field.isHidden;
+                    _field.visible = field.visible;
+                    _field.format = field.format;
+                    _field.formula = field.formula;
+                    if (field.showGrandTotals !== undefined) {
+                        _field.showGrandTotals = field.showGrandTotals;
+                    }
+                    if (field.showSubTotals !== undefined) {
+                        _field.showSubTotals = field.showSubTotals;
+                    }
+                }
+            }));
+        }));
+        fields.forEach((/**
+         * @param {?} field
+         * @return {?}
+         */
+        (field) => {
+            if (field.isCalculatedField) {
+                allFields.push(field);
+            }
+        }));
+        /** @type {?} */
+        const fieldsName = [];
+        /** @type {?} */
+        const outputFields = [];
+        allFields.forEach((/**
+         * @param {?} field
+         * @return {?}
+         */
+        (field) => {
+            // q2q当中langCode很多相同，去重要多判断一下addtionName
+            // if (!fieldsName.includes(field.langCode) || !!field.addtionName) {
+            if (!fieldsName.includes(field.langCode) &&
+                !fieldsName.includes(field.langValue)) {
+                /** @type {?} */
+                const value = field.langCode || field.langValue;
+                fieldsName.push(value);
+                outputFields.push(field);
+            }
+        }));
+        return outputFields.sort((/**
+         * @param {?} a
+         * @param {?} b
+         * @return {?}
+         */
+        (a, b) => (a.seq >= b.seq ? 1 : -1)));
+    }
+    /**
+     * @param {?} portlets
+     * @param {?} callback
+     * @param {?=} pageSetting
+     * @param {?=} isRefresh
+     * @param {?=} dashboard
+     * @param {?=} roGet
+     * @return {?}
+     */
+    getDataByPortletsNew(portlets, callback, pageSetting, isRefresh = false, dashboard, roGet = false) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            /** @type {?} */
+            let length = 0;
+            if (portlets && portlets.length) {
+                for (let portlet of portlets) {
+                    /** @type {?} */
+                    let id = portlet.id === "00000000-0000-0000-0000-000000000000"
+                        ? portlet.newId
+                        : portlet.id;
+                    /** @type {?} */
+                    const allFields = yield this.getAllFields(portlet, dashboard);
+                    /** @type {?} */
+                    let params = this.getParamsByPortlet(portlet, pageSetting, allFields, dashboard);
+                    /** @type {?} */
+                    let initFieldsArr;
+                    /** @type {?} */
+                    let curFieldsArr;
+                    if (!params.isTable && !roGet) {
+                        // 赋值portletFields_Temp
+                        initFieldsArr = this.portletFields_Temp[id];
+                        curFieldsArr = params.displayColumnFilter.split(",");
+                        if (!initFieldsArr ||
+                            this.needGetPortletData(initFieldsArr, curFieldsArr)) {
+                            this.portletFields_Temp[id] = curFieldsArr;
+                        }
+                        else {
+                            length++;
+                            if (portlets.length === length) {
+                                callback();
+                            }
+                            continue;
+                        }
+                    }
+                    /** @type {?} */
+                    const config = portlet.config && JSON.parse(portlet.config);
+                    if (config.filterSettings && config.filterSettings.length) {
+                        if (!params.columnFilter) {
+                            params.columnFilter = [];
+                        }
+                        config.filterSettings.forEach((/**
+                         * @param {?} setting
+                         * @return {?}
+                         */
+                        (setting) => {
+                            if (config.portletType === "pivot") {
+                                return;
+                            }
+                            /** @type {?} */
+                            const _field = config.fields.find((/**
+                             * @param {?} item
+                             * @return {?}
+                             */
+                            (item) => item.colName === setting.name));
+                            /** @type {?} */
+                            const Type = _field && _field.dataType;
+                            if (setting.items) {
+                                setting.items.forEach((/**
+                                 * @param {?} item
+                                 * @return {?}
+                                 */
+                                (item) => {
+                                    params.columnFilter.push({
+                                        Field: setting.name,
+                                        Operator: "equal",
+                                        Type,
+                                        Value: Type === "date"
+                                            ? moment(item).format("yyyy-MM-DD")
+                                            : Type === "datetime"
+                                                ? moment(item).format("yyyy-MM-DD hh:mm:ss")
+                                                : item,
+                                    });
+                                }));
+                            }
+                            else if (setting.operator) {
+                                params.columnFilter.push({
+                                    Field: setting.field,
+                                    Operator: "equal",
+                                    Type: setting.type,
+                                    Value: setting.type === "date"
+                                        ? moment(setting.value).format("yyyy-MM-DD")
+                                        : setting.type === "datetime"
+                                            ? moment(setting.value).format("yyyy-MM-DD hh:mm:ss")
+                                            : setting.value,
+                                });
+                            }
+                        }));
+                    }
+                    if (params.columnFilter instanceof Array) {
+                        params.columnFilter = params.columnFilter.filter((/**
+                         * @param {?} item
+                         * @return {?}
+                         */
+                        (item) => item.Field));
+                    }
+                    // json buffer
+                    params["dashboardVersion"] = 2;
+                    this.httpClient
+                        .post(this.api.baseurl + this.api.urlList.GetPortletDataOrCreate, params, {
+                        headers: new HttpHeaders({
+                            Authorization: `Bearer`,
+                        }),
+                    })
+                        .subscribe((/**
+                     * @param {?} result
+                     * @return {?}
+                     */
+                    (result) => {
+                        if (!result) {
+                            this.portletData_New[dashboard.id][id] = {
+                                total: 0,
+                                data: [],
+                            };
+                            if (isRefresh) {
+                                this.DashboardService.refreshGadget.next({
+                                    newId: id,
+                                });
+                            }
+                            length++;
+                            if (isRefresh) {
+                                this.DashboardService.refreshGadget.next({
+                                    newId: id,
+                                });
+                            }
+                            if (portlets.length === length) {
+                                if (isRefresh) {
+                                    this.DashboardService.startRefresh.next(false);
+                                }
+                                callback();
+                            }
+                        }
+                        else {
+                            result["data"].forEach((/**
+                             * @param {?} item
+                             * @return {?}
+                             */
+                            (item) => {
+                                item.Sector = this.translation[item.Sector] || item.Sector;
+                            }));
+                            this.portletData_New[dashboard.id][id] = result;
+                            if (isRefresh) {
+                                this.DashboardService.refreshGadget.next({
+                                    newId: id,
+                                });
+                            }
+                            length++;
+                            if (portlets.length === length) {
+                                if (isRefresh) {
+                                    this.DashboardService.startRefresh.next(false);
+                                }
+                                callback();
+                            }
+                        }
+                    }), (/**
+                     * @param {?} response
+                     * @return {?}
+                     */
+                    (response) => {
+                        this.portletFields_Temp[id] = initFieldsArr;
+                        length++;
+                        if (portlets.length === length) {
+                            callback();
+                        }
+                    }), (/**
+                     * @return {?}
+                     */
+                    () => { }));
+                }
+            }
+            else {
+                callback();
+            }
+        });
+    }
+    /**
+     * @param {?} portlet
+     * @return {?}
+     */
+    clearFieldsObj(portlet) {
+        Reflect.deleteProperty(this.allFieldsObj, portlet.id);
+    }
+    // 根据portlet 解析params
+    /**
+     * @param {?} portlet
+     * @param {?=} pageSetting
+     * @param {?=} allFields
+     * @param {?=} dashboard
+     * @return {?}
+     */
+    getParamsByPortlet(portlet, pageSetting, allFields, dashboard) {
+        /** @type {?} */
+        let dashboardDataTableId = portlet.dashboardDataTableId;
+        //SMP2-7731 get the dashboardDataTableid from dataMartTables arrary
+        /** @type {?} */
+        let curDataMart = this.dataMartTables[dashboard.id].find((/**
+         * @param {?} d
+         * @return {?}
+         */
+        (d) => d.datamartCode === portlet.figureCode));
+        if (curDataMart) {
+            dashboardDataTableId = curDataMart.id;
+        }
+        /** @type {?} */
+        let config = portlet.config && JSON.parse(portlet.config);
+        if (portlet.id !== "00000000-0000-0000-0000-000000000000") {
+            this.allFieldsObj[portlet.id] = allFields;
+        }
+        /** @type {?} */
+        let fields = allFields
+            ? this.setConfigFields(allFields, config.fields)
+            : config.fields;
+        if (allFields) {
+            config.fields = fields;
+            portlet.config = JSON.stringify(config);
+        }
+        /** @type {?} */
+        let calculatedFields = config.calculatedFieldSettings;
+        /** @type {?} */
+        let needFields = [];
+        /** @type {?} */
+        let params = {};
+        /** @type {?} */
+        const portletType = config.portletType === "historicalIRR"
+            ? config.selectedVisualType
+            : config.portletType;
+        if (portletType === "table") {
+            fields &&
+                fields.forEach((/**
+                 * @param {?} x
+                 * @return {?}
+                 */
+                (x) => {
+                    needFields.push(x.colName);
+                }));
+            params.startIndex = 0;
+            params.pageSize = 10;
+            if (pageSetting && pageSetting.currentPage) {
+                params.startIndex =
+                    (pageSetting.currentPage - 1) * pageSetting.pageSize;
+                params.pageSize = pageSetting.pageSize;
+            }
+            // 处理 sort
+            if (pageSetting && pageSetting.sortedColumn) {
+                params.sortedColumn = pageSetting.sortedColumn;
+                params.sort = pageSetting.sort;
+            }
+            // 处理 filter
+            if (config.filterSettings.length) {
+                /** @type {?} */
+                let filterSettings = JSON.parse(JSON.stringify(config.filterSettings));
+                params.columnFilter = filterSettings.map((/**
+                 * @param {?} x
+                 * @return {?}
+                 */
+                (x) => {
+                    if (x.type === "date") {
+                        /** @type {?} */
+                        const date = new Date(x.value);
+                        /** @type {?} */
+                        const year = date.getFullYear();
+                        /** @type {?} */
+                        const month = String(date.getMonth() + 1).padStart(2, "0");
+                        /** @type {?} */
+                        const day = String(date.getDate()).padStart(2, "0");
+                        /** @type {?} */
+                        const formattedDate = `${year}-${month}-${day}`;
+                        x.value = formattedDate;
+                    }
+                    return x;
+                }));
+            }
+            params.isTable = true;
+        }
+        else if (portletType === "transpose") {
+            fields &&
+                fields.forEach((/**
+                 * @param {?} x
+                 * @return {?}
+                 */
+                (x) => {
+                    if (!x.isHidden) {
+                        needFields.push(x.colName);
+                    }
+                }));
+        }
+        else if (["newcolumn", "newline", "newcolumnline"].includes(portletType)) {
+            if (config.selectedY && config.selectedY.length > 0) {
+                config.selectedY.forEach((/**
+                 * @param {?} e
+                 * @return {?}
+                 */
+                (e) => {
+                    needFields.push(e);
+                }));
+            }
+            if (config.selectedSecondY && config.selectedSecondY.length > 0) {
+                config.selectedSecondY.forEach((/**
+                 * @param {?} e
+                 * @return {?}
+                 */
+                (e) => {
+                    needFields.push(e);
+                }));
+            }
+        }
+        else {
+            // 处理 filters
+            /** @type {?} */
+            let filters = config.filters;
+            if (filters && filters.length) {
+                for (let item of filters) {
+                    needFields.push(item.name);
+                }
+            }
+            // 处理 values
+            /** @type {?} */
+            let series = config.yaxis.series;
+            if (series && series.length) {
+                for (let item of series) {
+                    if ([
+                        "CalculateIRR",
+                        "CalculateIRRMTD",
+                        "CalculateIRRQTD",
+                        "CalculateIRRYTD",
+                        "CalculateTWRMTD",
+                        "CalculateTWRQTD",
+                        "CalculateTWRYTD",
+                        "CalculateVARMTD_99",
+                        "CalculateVARQTD_99",
+                        "CalculateVARYTD_99",
+                        "CalculateVARMTD_95",
+                        "CalculateVARQTD_95",
+                        "CalculateVARYTD_95",
+                    ].includes(item.calMethod)) {
+                        needFields.push("IRRAmount", "IRRDate", "IRRAdjValue");
+                    }
+                    else if (item.calMethod === "CalculateIRRBeforeCarried") {
+                        needFields.push("IRRAmount", "IRRDate", "IRRAdjValueBeforeCarry");
+                    }
+                    else if (item.calMethod === "CalculateIRRIRRDate") {
+                        needFields.push("IRRAmount", "CalculateIRRDate", "IRRAdjValue");
+                    }
+                    else if (item.calMethod === "CalculateIRRActualAudited") {
+                        portlet.figureCode === "GrossNet" ||
+                            portlet.figureCode === "CombinedInvestmentFundNCompanyCashflow"
+                            ? needFields.push("IRRAmount", "IRRDate", "ActualAuditedNAV")
+                            : needFields.push("IRRAmount", "IRRDate", "IRRAdjValue");
+                    }
+                    else if (item.calMethod === "CalculateIRRReported") {
+                        portlet.figureCode === "GrossNet" ||
+                            portlet.figureCode === "CombinedInvestmentFundNCompanyCashflow"
+                            ? needFields.push("IRRAmount", "IRRDate", "ReportedNAV")
+                            : needFields.push("IRRAmount", "IRRDate", "IRRAdjValue");
+                    }
+                    else if (item.calMethod === "CalculatedField") {
+                    }
+                    else {
+                        /** @type {?} */
+                        let colName = this.getAggregateType(item.calMethod);
+                        if (colName) {
+                            /** @type {?} */
+                            let curField = fields.find((/**
+                             * @param {?} f
+                             * @return {?}
+                             */
+                            (f) => f.colName === colName));
+                            if (curField && curField.formula) {
+                                /** @type {?} */
+                                let fs = curField.formula.split("/");
+                                fs && fs.map((/**
+                                 * @param {?} f
+                                 * @return {?}
+                                 */
+                                (f) => needFields.push(f)));
+                            }
+                        }
+                        else {
+                            needFields.push(item.colName);
+                        }
+                    }
+                }
+            }
+            // 处理 rows
+            /** @type {?} */
+            let groups = config.xaxis.groups;
+            if (groups && groups.length) {
+                for (let gitem of groups) {
+                    needFields.push(gitem.name);
+                }
+            }
+            // 处理 colunms
+            /** @type {?} */
+            let columnGroup = config.columnGroup;
+            if (columnGroup && columnGroup.length) {
+                for (let item of columnGroup) {
+                    needFields.push(item.name);
+                }
+            }
+            // 处理 calculatedField
+            if (calculatedFields && calculatedFields.length) {
+                calculatedFields.map((/**
+                 * @param {?} f
+                 * @return {?}
+                 */
+                (f) => {
+                    /** @type {?} */
+                    let string = f.formula;
+                    /** @type {?} */
+                    const regex = /\((.*?)\)/g;
+                    /** @type {?} */
+                    const matches = string
+                        .match(regex)
+                        .map((/**
+                     * @param {?} match
+                     * @return {?}
+                     */
+                    (match) => match.slice(1, -1)));
+                    needFields.push(...matches);
+                }));
+            }
+            // 处理 orderByColumns
+            if (this.dashboardConfig && this.dashboardConfig[dashboard.id]) {
+                params.datamartViewId =
+                    this.dashboardConfig[dashboard.id].datamartViewId;
+                params.datamartId = this.dashboardConfig[dashboard.id].datamartId;
+                params.datamartCode = portlet.figureCode;
+            }
+            // 处理config.fields里的sortColumn
+            /** @type {?} */
+            let fieldSortColumns = [];
+            fields.map((/**
+             * @param {?} x
+             * @return {?}
+             */
+            (x) => {
+                if (x.sortColumn && !fieldSortColumns.includes(x.sortColumn)) {
+                    fieldSortColumns.push(x.sortColumn);
+                }
+            }));
+            if (fieldSortColumns.length) {
+                needFields.push(...fieldSortColumns);
+            }
+        }
+        needFields = Array.from(new Set(needFields));
+        // 去除非法字段
+        /** @type {?} */
+        let legalFields = fields.map((/**
+         * @param {?} x
+         * @return {?}
+         */
+        (x) => x.colName));
+        needFields.map((/**
+         * @param {?} x
+         * @param {?} i
+         * @return {?}
+         */
+        (x, i) => {
+            if (!legalFields.includes(x)) {
+                needFields.splice(i, 1);
+            }
+        }));
+        if (needFields.length === 0) {
+            if (legalFields[0]) {
+                needFields.push(legalFields[0]);
+            }
+        }
+        // 默认获取Seq字段 SMP2-4582 AGIC - Dashboard item sequence
+        needFields.push("Seq");
+        // "newcolumn", "newline", "newcolumnline" 如果是这三种类型默认加 OperationDate 字段
+        if (["newcolumn", "newline", "newcolumnline"].includes(portletType)) {
+            needFields.push(config.selectedX);
+            params["IsOnlyShowDisplayColum"] = true;
+        }
+        if (config.portletType === "historicalIRR") {
+            if (!params.columnFilter) {
+                params.columnFilter = [];
+            }
+            params.columnFilter.push({
+                Field: "Frequencys",
+                Operator: "equal",
+                Type: "string",
+                Value: config.selectedMultiples,
+            }, {
+                Field: "InvestorType",
+                Operator: "equal",
+                Type: "string",
+                Value: config.selectedInvestor,
+            });
+        }
+        params.dashboardDataTableId = dashboardDataTableId;
+        params.displayColumnFilter = needFields.join(",");
+        params.responseType = "json";
+        return params;
+    }
+    // 是否需要重新发起请求
+    /**
+     * @param {?=} origin
+     * @param {?=} compare
+     * @return {?}
+     */
+    needGetPortletData(origin = [], compare = []) {
+        return compare.some((/**
+         * @param {?} c
+         * @return {?}
+         */
+        (c) => !origin.includes(c)));
+    }
+    /**
+     * @param {?} figureCodes
+     * @param {?} callback
+     * @param {?=} portletTypes
+     * @param {?=} dashboardId
+     * @param {?=} portlet
+     * @return {?}
+     */
+    setDataManager(figureCodes, callback, portletTypes = [], dashboardId, portlet) {
+        /** @type {?} */
+        let length = 0;
+        if (!this.fieldsArr[dashboardId]) {
+            this.fieldsArr[dashboardId] = {};
+        }
+        if (this.dataMartTables[dashboardId] &&
+            this.dataMartTables[dashboardId].length) {
+            this.pbf.pageLoading = true;
+            this.pbf.pageLoading_.next(true);
+            /** @type {?} */
+            let dataMartTables = this.dataMartTables[dashboardId].filter((/**
+             * @param {?} el
+             * @return {?}
+             */
+            (el) => figureCodes.includes(el.datamartCode)));
+            if (dataMartTables.length) {
+                forEach(dataMartTables, (/**
+                 * @param {?} item
+                 * @param {?} index
+                 * @return {?}
+                 */
+                (item, index) => {
+                    /** @type {?} */
+                    let allFields;
+                    /** @type {?} */
+                    let config;
+                    if (portlet) {
+                        config = JSON.parse(portlet.config);
+                    }
+                    if (["newcolumn", "newline", "newcolumnline"].includes(portletTypes[0])) {
+                        allFields = config.selectedY
+                            .concat(config.selectedSecondY)
+                            .concat([config.selectedX])
+                            .map((/**
+                         * @param {?} e
+                         * @return {?}
+                         */
+                        (e) => {
+                            return {
+                                colName: e,
+                            };
+                        }));
+                    }
+                    else {
+                        allFields =
+                            this.fieldsArr[dashboardId] &&
+                                this.fieldsArr[dashboardId][item.datamartCode]
+                                ? this.fieldsArr[dashboardId][item.datamartCode]
+                                : [];
+                    }
+                    /** @type {?} */
+                    let displayColumnFilter = allFields && allFields.map((/**
+                     * @param {?} x
+                     * @return {?}
+                     */
+                    (x) => x.colName)).join(",");
+                    /** @type {?} */
+                    let params = {
+                        dashboardDataTableId: item.id,
+                        displayColumnFilter: displayColumnFilter,
+                        responseType: "json",
+                        dashboardVersion: 2,
+                    };
+                    params.startIndex = 0;
+                    params.pageSize = 10;
+                    if (portletTypes &&
+                        portletTypes.length > 0 &&
+                        (portletTypes.includes("newcolumn") ||
+                            portletTypes.includes("newline") ||
+                            portletTypes.includes("newcolumnline"))) {
+                        params.pageSize = 1000000;
+                        params["IsOnlyShowDisplayColum"] = true;
+                    }
+                    if (config) {
+                        /** @type {?} */
+                        const filterSettings = config.filterSettings;
+                        if (filterSettings && filterSettings.length) {
+                            if (!params.columnFilter) {
+                                params.columnFilter = [];
+                            }
+                            filterSettings.forEach((/**
+                             * @param {?} setting
+                             * @return {?}
+                             */
+                            (setting) => {
+                                if (config.portletType === "pivot") {
+                                    return;
+                                }
+                                /** @type {?} */
+                                const _field = config.fields.find((/**
+                                 * @param {?} item
+                                 * @return {?}
+                                 */
+                                (item) => item.colName === setting.name));
+                                /** @type {?} */
+                                const Type = _field && _field.dataType;
+                                if (setting.items) {
+                                    setting.items.forEach((/**
+                                     * @param {?} item
+                                     * @return {?}
+                                     */
+                                    (item) => {
+                                        params.columnFilter.push({
+                                            Field: setting.name,
+                                            Operator: "equal",
+                                            Type,
+                                            Value: Type === "date"
+                                                ? moment(item).format("yyyy-MM-DD")
+                                                : Type === "datetime"
+                                                    ? moment(item).format("yyyy-MM-DD hh:mm:ss")
+                                                    : item,
+                                        });
+                                    }));
+                                }
+                                else if (setting.operator) {
+                                    params.columnFilter.push({
+                                        Field: setting.field,
+                                        Operator: "equal",
+                                        Type: setting.type,
+                                        Value: setting.type === "date"
+                                            ? moment(setting.value).format("yyyy-MM-DD")
+                                            : setting.type === "datetime"
+                                                ? moment(setting.value).format("yyyy-MM-DD hh:mm:ss")
+                                                : setting.value,
+                                    });
+                                }
+                            }));
+                        }
+                        if (config.portletType === "historicalIRR") {
+                            if (!params.columnFilter) {
+                                params.columnFilter = [];
+                            }
+                            params.columnFilter.push({
+                                Field: "Frequencys",
+                                Operator: "equal",
+                                Type: "string",
+                                Value: config.selectedMultiples,
+                            }, {
+                                Field: "InvestorType",
+                                Operator: "equal",
+                                Type: "string",
+                                Value: config.selectedInvestor,
+                            });
+                        }
+                    }
+                    if (params.columnFilter instanceof Array) {
+                        params.columnFilter = params.columnFilter.filter((/**
+                         * @param {?} item
+                         * @return {?}
+                         */
+                        (item) => item.Field));
+                    }
+                    // json buffer
+                    this.httpClient
+                        .post(this.api.baseurl + this.api.urlList.GetPortletDataOrCreate, params, {
+                        headers: new HttpHeaders({
+                            Authorization: `Bearer`,
+                        }),
+                    })
+                        .subscribe((/**
+                     * @param {?} result
+                     * @return {?}
+                     */
+                    (result) => {
+                        /** @type {?} */
+                        let identifier = portlet.id === "00000000-0000-0000-0000-000000000000"
+                            ? portlet.newId
+                            : portlet.id;
+                        if (!result) {
+                            this.portletResults_New[dashboardId][item.datamartCode] = [];
+                            if (portlet) {
+                                this.portletData_New[dashboardId][identifier] = {
+                                    total: 0,
+                                    data: [],
+                                };
+                            }
+                            /** @type {?} */
+                            let message = this.translation.NO_DATA
+                                ? this.translation.NO_DATA
+                                : ".No data, please choose another data type";
+                            this.dialogService.showNotification(message, {
+                                status: "Error",
+                            });
+                            length++;
+                            if (dataMartTables.length === length) {
+                                callback();
+                            }
+                        }
+                        else {
+                            result["data"].forEach((/**
+                             * @param {?} item
+                             * @return {?}
+                             */
+                            (item) => {
+                                item.Sector = this.translation[item.Sector] || item.Sector;
+                            }));
+                            if (this.fieldsArr[dashboardId] &&
+                                Object.keys(this.fieldsArr[dashboardId]).length) {
+                                this.portletResults_New[dashboardId][item.datamartCode] =
+                                    result;
+                            }
+                            if (portlet) {
+                                this.portletData_New[dashboardId][identifier] = result;
+                            }
+                            length++;
+                            if (dataMartTables.length === length) {
+                                callback();
+                            }
+                        }
+                    }), (/**
+                     * @param {?} response
+                     * @return {?}
+                     */
+                    (response) => {
+                        length++;
+                        if (dataMartTables.length === length) {
+                            callback();
+                        }
+                    }), (/**
+                     * @return {?}
+                     */
+                    () => { }));
+                }));
+            }
+            else {
+                callback();
+            }
+        }
+    }
+    // 拿到数据后，先遍历config.filterSettings,如果在数据中不存在，就删除这一项
+    /**
+     * @param {?} config
+     * @param {?} fields
+     * @param {?} data
+     * @return {?}
+     */
+    checkFilterSettings(config, fields, data) {
+        /** @type {?} */
+        let filterSettings = config.filterSettings;
+        if (filterSettings && filterSettings.length) {
+            for (let i = 0; i < filterSettings.length; i++) {
+                /** @type {?} */
+                const element = filterSettings[i];
+                /** @type {?} */
+                let __field = fields.filter((/**
+                 * @param {?} field
+                 * @return {?}
+                 */
+                (field) => field.colName == element.name))[0];
+                if (!__field) {
+                    // 处理自定义 Group的Filter
+                    continue;
+                }
+                /** @type {?} */
+                const dataType = __field.dataType;
+                if (element.items && element.items.length) {
+                    for (let r = 0; r < element.items.length; r++) {
+                        /** @type {?} */
+                        const item = element.items[r];
+                        /** @type {?} */
+                        let res = [];
+                        if (dataType !== "date" &&
+                            dataType !== "datetime" &&
+                            data &&
+                            data.length) {
+                            if (dataType == "string") {
+                                res = data.filter((/**
+                                 * @param {?} obj
+                                 * @return {?}
+                                 */
+                                (obj) => obj[element.name] === item));
+                            }
+                            else {
+                                res = data.filter((/**
+                                 * @param {?} obj
+                                 * @return {?}
+                                 */
+                                (obj) => Number(obj[element.name]) === Number(item)));
+                            }
+                        }
+                        if (dataType == "date" || dataType == "datetime") {
+                            res = data.filter((/**
+                             * @param {?} obj
+                             * @return {?}
+                             */
+                            (obj) => moment(obj[element.name]).format("YYYY-MM-DD") ==
+                                moment(item).format("YYYY-MM-DD")));
+                        }
+                        if (!res.length) {
+                            element.items.splice(r, 1);
+                            r--;
+                        }
+                    }
+                    if (!element.items.length) {
+                        filterSettings.splice(i, 1);
+                        i--;
+                    }
+                }
+            }
+            return filterSettings;
+        }
+        else {
+            return [];
+        }
+        // callback(filterSettings);
+    }
+    /**
+     * @param {?} data
+     * @return {?}
+     */
+    sortDataMartTables(data) {
+        data.sort((/**
+         * @param {?} a
+         * @param {?} b
+         * @return {?}
+         */
+        (a, b) => {
+            /** @type {?} */
+            const langValueA = a.langValue.toLowerCase();
+            /** @type {?} */
+            const langValueB = b.langValue.toLowerCase();
+            if (langValueA < langValueB) {
+                return -1;
+            }
+            if (langValueA > langValueB) {
+                return 1;
+            }
+            return 0;
+        }));
+    }
+    /**
+     * @param {?} data
+     * @param {?} id
+     * @param {?} entityType
+     * @return {?}
+     */
+    renameDataMartTables(data, id, entityType) {
+        if (this.sourcesData[id]) {
+            this.sourcesData[id].forEach((/**
+             * @param {?} sources
+             * @return {?}
+             */
+            (sources) => {
+                if (sources.entityType === entityType) {
+                    data.forEach((/**
+                     * @param {?} _data
+                     * @return {?}
+                     */
+                    (_data) => {
+                        sources.views.forEach((/**
+                         * @param {?} view
+                         * @return {?}
+                         */
+                        (view) => {
+                            view.tables.forEach((/**
+                             * @param {?} table
+                             * @return {?}
+                             */
+                            (table) => {
+                                if (table.datamartCode === _data.datamartCode) {
+                                    _data.langValue = table.langValue;
+                                    _data.langCode = table.langCode;
+                                }
+                            }));
+                        }));
+                    }));
+                }
+            }));
+        }
+        else {
+            return data;
+        }
+    }
+}
+DashboardPorletsService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root",
+            },] }
+];
+/** @nocollapse */
+DashboardPorletsService.ctorParameters = () => [
+    { type: ApiList },
+    { type: MatDialog },
+    { type: DialogService },
+    { type: DashboardService },
+    { type: HttpClient },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [PBF_TOKEN,] }] },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [API_SERVICE_TOKEN,] }] }
+];
+/** @nocollapse */ DashboardPorletsService.ngInjectableDef = i0.ɵɵdefineInjectable({ factory: function DashboardPorletsService_Factory() { return new DashboardPorletsService(i0.ɵɵinject(i1.ApiList), i0.ɵɵinject(i2.MatDialog), i0.ɵɵinject(i3.DialogService), i0.ɵɵinject(i4.DashboardService), i0.ɵɵinject(i5.HttpClient), i0.ɵɵinject(i6.PBF_TOKEN, 8), i0.ɵɵinject(i6.API_SERVICE_TOKEN, 8)); }, token: DashboardPorletsService, providedIn: "root" });
+if (false) {
+    /** @type {?} */
+    DashboardPorletsService.prototype.translation;
+    /**
+     * @type {?}
+     * @private
+     */
+    DashboardPorletsService.prototype.userInfo;
+    /**
+     * @type {?}
+     * @private
+     */
+    DashboardPorletsService.prototype.lang;
+    /** @type {?} */
+    DashboardPorletsService.prototype.companyDropdownList;
+    /** @type {?} */
+    DashboardPorletsService.prototype.currencyDropdownList;
+    /** @type {?} */
+    DashboardPorletsService.prototype.currencyList;
+    /** @type {?} */
+    DashboardPorletsService.prototype.portlets;
+    /** @type {?} */
+    DashboardPorletsService.prototype.portletsCopy;
+    /** @type {?} */
+    DashboardPorletsService.prototype.columnCount;
+    /** @type {?} */
+    DashboardPorletsService.prototype.rowCount;
+    /** @type {?} */
+    DashboardPorletsService.prototype.companyCharts;
+    /** @type {?} */
+    DashboardPorletsService.prototype.portletData;
+    /** @type {?} */
+    DashboardPorletsService.prototype.fundDropdownList;
+    /** @type {?} */
+    DashboardPorletsService.prototype.allInvesteeList;
+    /** @type {?} */
+    DashboardPorletsService.prototype.fundInvesteeList;
+    /** @type {?} */
+    DashboardPorletsService.prototype.seletedAllInvestee;
+    /** @type {?} */
+    DashboardPorletsService.prototype.colorsTotal;
+    /** @type {?} */
+    DashboardPorletsService.prototype.fetch_disabled;
+    /** @type {?} */
+    DashboardPorletsService.prototype.update_loading;
+    /** @type {?} */
+    DashboardPorletsService.prototype.currencyCode;
+    /** @type {?} */
+    DashboardPorletsService.prototype.update_config;
+    /** @type {?} */
+    DashboardPorletsService.prototype.loading_show;
+    /** @type {?} */
+    DashboardPorletsService.prototype.img;
+    /** @type {?} */
+    DashboardPorletsService.prototype.sortingPortlet;
+    /** @type {?} */
+    DashboardPorletsService.prototype.pagingChanging;
+    /** @type {?} */
+    DashboardPorletsService.prototype.timeMeasure;
+    /** @type {?} */
+    DashboardPorletsService.prototype.entityList;
+    /** @type {?} */
+    DashboardPorletsService.prototype.entityType;
+    /** @type {?} */
+    DashboardPorletsService.prototype.selected_enyity_fileds;
+    /** @type {?} */
+    DashboardPorletsService.prototype.isEntitySelectAll;
+    /** @type {?} */
+    DashboardPorletsService.prototype.checkedAll;
+    /** @type {?} */
+    DashboardPorletsService.prototype.selectedNum;
+    /** @type {?} */
+    DashboardPorletsService.prototype.updated;
+    /** @type {?} */
+    DashboardPorletsService.prototype.dataMartTables;
+    /** @type {?} */
+    DashboardPorletsService.prototype.length;
+    /** @type {?} */
+    DashboardPorletsService.prototype.GetSourcesRes;
+    /** @type {?} */
+    DashboardPorletsService.prototype.ListEntitiesRes;
+    /** @type {?} */
+    DashboardPorletsService.prototype.templateList;
+    /** @type {?} */
+    DashboardPorletsService.prototype.fieldsArr;
+    /** @type {?} */
+    DashboardPorletsService.prototype.sourcesData;
+    /** @type {?} */
+    DashboardPorletsService.prototype.portletResults_New;
+    /** @type {?} */
+    DashboardPorletsService.prototype.portletData_New;
+    /** @type {?} */
+    DashboardPorletsService.prototype.portletFields_Temp;
+    /** @type {?} */
+    DashboardPorletsService.prototype.dashboardConfig;
+    /** @type {?} */
+    DashboardPorletsService.prototype.entityIds;
+    /** @type {?} */
+    DashboardPorletsService.prototype.entityIdObj;
+    /** @type {?} */
+    DashboardPorletsService.prototype.allFieldsObj;
+    /** @type {?} */
+    DashboardPorletsService.prototype.GetDataTypes;
+    /** @type {?} */
+    DashboardPorletsService.prototype.ExcelFormulas;
+    /**
+     * @type {?}
+     * @private
+     */
+    DashboardPorletsService.prototype.api;
+    /** @type {?} */
+    DashboardPorletsService.prototype.dialog;
+    /**
+     * @type {?}
+     * @private
+     */
+    DashboardPorletsService.prototype.dialogService;
+    /**
+     * @type {?}
+     * @private
+     */
+    DashboardPorletsService.prototype.DashboardService;
+    /**
+     * @type {?}
+     * @private
+     */
+    DashboardPorletsService.prototype.httpClient;
+    /**
+     * @type {?}
+     * @private
+     */
+    DashboardPorletsService.prototype.pbf;
+    /**
+     * @type {?}
+     * @private
+     */
+    DashboardPorletsService.prototype.http;
+}
+/** @type {?} */
+export const ALL_AGGREGATE_TYPES = [
+    "Sum",
+    "First",
+    "Last",
+    "CalculateIRR",
+    "CalculateIRRIRRDate",
+    "CalculateIRRBeforeCarried",
+    "CalculateIRRActualAudited",
+    "CalculateIRRReported",
+    "CalculateIRRMTD",
+    "CalculateIRRQTD",
+    "CalculateIRRYTD",
+    "CalculateTWRMTD",
+    "CalculateTWRQTD",
+    "CalculateTWRYTD",
+    "CalculateVARMTD_99",
+    "CalculateVARQTD_99",
+    "CalculateVARYTD_99",
+    "CalculateVARMTD_95",
+    "CalculateVARQTD_95",
+    "CalculateVARYTD_95",
+    "CalculateMultiple",
+    "CalculatePIC",
+    "CalculateDPI",
+    "CalculateTVPI",
+    "CalculateRVPI",
+    "CalculateMActualAudited",
+    "CalculateMReported",
+    "Count",
+    "DistinctCount",
+    "Product",
+    "Min",
+    "Max",
+    "Avg",
+    "Median",
+    "Index",
+    "PopulationVar",
+    "SampleVar",
+    "PopulationStDev",
+    "SampleStDev",
+    "RunningTotals",
+    "PercentageOfGrandTotal",
+    "PercentageOfColumnTotal",
+    "PercentageOfRowTotal",
+    "PercentageOfParentColumnTotal",
+    "PercentageOfParentRowTotal",
+    "DifferenceFrom",
+    "PercentageOfDifferenceFrom",
+    "PercentageOfParentTotal",
+];
+/** @type {?} */
+let translation = JSON.parse(localStorage.getItem("translation") || "{}");
+/** @type {?} */
+export const AGGREGATE_TYPES_TEXT = {
+    CalculateIRR: translation.CALCULATE_IRR || "Calculate IRR",
+    CalculateIRRIRRDate: translation.CALCULATE_IRR_IRR_DATE || "Calculate IRR (IRR Date)",
+    CalculateIRRBeforeCarried: translation.CALCULATE_IRR_BEFORE_CARRY || "Calculate IRR Before Carried",
+    CalculateIRRActualAudited: translation.CALCULATE_IRR_ACTUAL_AUDITED || "Calculate IRR Actual/Audited",
+    CalculateIRRReported: translation.CI_REPORTED || "Calculate IRR Reported",
+    CalculateIRRMTD: translation.CALCULATE_IRR_MTD || "Calculate IRR (MTD)",
+    CalculateIRRQTD: translation.CALCULATE_IRR_QTD || "Calculate IRR (QTD)",
+    CalculateIRRYTD: translation.CALCULATE_IRR_YTD || "Calculate IRR (YTD)",
+    CalculateTWRMTD: translation.CALCULATE_TWR_MTD || "Calculate TWR (M)",
+    CalculateTWRQTD: translation.CALCULATE_TWR_QTD || "Calculate TWR (Q)",
+    CalculateTWRYTD: translation.CALCULATE_TWR_YTD || "Calculate TWR (Y)",
+    CalculateVARMTD_99: translation.CALCULATE_VAR_MTD_99 || "Calculate VAR (M 99%)",
+    CalculateVARQTD_99: translation.CALCULATE_VAR_QTD_99 || "Calculate VAR (Q 99%)",
+    CalculateVARYTD_99: translation.CALCULATE_VAR_YTD_99 || "Calculate VAR (Y 99%)",
+    CalculateVARMTD_95: translation.CALCULATE_VAR_MTD_95 || "Calculate VAR (M 95%)",
+    CalculateVARQTD_95: translation.CALCULATE_VAR_QTD_95 || "Calculate VAR (Q 95%)",
+    CalculateVARYTD_95: translation.CALCULATE_VAR_YTD_95 || "Calculate VAR (Y 95%)",
+    CalculateMultiple: translation.CALCULATE_MULTIPLE || "Calculate Multiple",
+    CalculatePIC: translation.CALCULATE_PIC || "Calculate PIC",
+    CalculateDPI: translation.CALCULATE_DPI || "Calculate DPI",
+    CalculateTVPI: translation.CALCULATE_TVPI || "Calculate TVPI",
+    CalculateRVPI: translation.CALCULATE_RVPI || "Calculate RVPI",
+    CalculateMActualAudited: translation.CALCULATE_MULTIPLE_ACTUAL_AUDITED ||
+        "Calculate Multiple Actual/Audited",
+    CalculateMReported: translation.CALCULATE_MULTIPLE_REPORTED || "Calculate Multiple Reported",
+    First: translation.FIRST || "First",
+    Last: translation.LAST || "Last",
+    Median: translation.MEDIAN || "Median",
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dashboardPorlets.service.js","sourceRoot":"ng://raise-common-lib/","sources":["lib/dashboard/dashboardPorlets.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from \"@angular/core\";\r\nimport { ApiList } from \"./api\";\r\nimport { MatDialog } from \"@angular/material\";\r\nimport { DashboardService } from \"./dashboard.service\";\r\nimport { forEach } from \"lodash\";\r\nimport moment from \"moment\";\r\nimport { HttpClient, HttpHeaders } from \"@angular/common/http\";\r\nimport { API_SERVICE_TOKEN, PBF_TOKEN } from \"../service/InjectionToken\";\r\nimport { DialogService } from \"../service/dialog.service\";\r\n\r\n@Injectable({\r\n  providedIn: \"root\",\r\n})\r\nexport class DashboardPorletsService {\r\n  public translation;\r\n  private userInfo;\r\n  private lang;\r\n  // public config;\r\n  public companyDropdownList = [];\r\n  public currencyDropdownList = [];\r\n  public currencyList = [];\r\n  public portlets = [];\r\n  public portletsCopy = [];\r\n  public columnCount;\r\n  public rowCount;\r\n  public companyCharts = [];\r\n  public portletData;\r\n  public fundDropdownList;\r\n  public allInvesteeList;\r\n  public fundInvesteeList;\r\n  public seletedAllInvestee: boolean;\r\n  public colorsTotal = [\r\n    \"#0b5496\",\r\n    \"#0081ff\",\r\n    \"#22cce2\",\r\n    \"#606ede\",\r\n    \"#8598f7\",\r\n    \"#00a744\",\r\n    \"#12c177\",\r\n    \"#fdbf5e\",\r\n    \"#ff8a48\",\r\n    \"#ea4258\",\r\n  ];\r\n  public fetch_disabled: boolean = true;\r\n  public update_loading: boolean = false;\r\n  public currencyCode;\r\n  public update_config;\r\n  public loading_show: boolean = false;\r\n  public img;\r\n  public sortingPortlet = [];\r\n  public pagingChanging = [];\r\n  public timeMeasure;\r\n  public entityList;\r\n  public entityType;\r\n  public selected_enyity_fileds = [];\r\n  public isEntitySelectAll;\r\n  public checkedAll: boolean = false;\r\n  public selectedNum;\r\n  public updated = false;\r\n  public dataMartTables = {};\r\n  public length = 0;\r\n  public GetSourcesRes;\r\n  public ListEntitiesRes;\r\n  public templateList = [];\r\n  public fieldsArr = {};\r\n  public sourcesData = {};\r\n  // newDashboard\r\n  public portletResults_New = {}; // 以DataTable为单位 存储新数据\r\n  public portletData_New = {}; // 以portlet为单位 存储新数据\r\n  public portletFields_Temp = {}; // 存储当前portlet所用到的字段\r\n  public dashboardConfig: any = {}; // 当前Dashboard的config, 用于获取orderByColumns\r\n  public entityIds: any = [];\r\n  public entityIdObj: any = {};\r\n  public allFieldsObj = {};\r\n\r\n  constructor(\r\n    private api: ApiList,\r\n    public dialog: MatDialog,\r\n    private dialogService: DialogService,\r\n    private DashboardService: DashboardService,\r\n    private httpClient: HttpClient,\r\n    @Optional() @Inject(PBF_TOKEN) private pbf: any,\r\n    @Optional() @Inject(API_SERVICE_TOKEN) private http: any\r\n  ) {}\r\n\r\n  private setEntityType(res) {\r\n    if (res && res.entityList && res.entityList.length) {\r\n      const entityData = res.entityList[0];\r\n      if (!entityData) {\r\n        return res;\r\n      }\r\n      const { linkedType = \"\" } = entityData;\r\n      if (!linkedType) {\r\n        return res;\r\n      }\r\n      this.entityType =\r\n        linkedType === \"PropertyId\"\r\n          ? \"Property\"\r\n          : linkedType === \"portfolioCompId\" ||\r\n            linkedType === \"assetCompId\" ||\r\n            linkedType === \"otherCompId\"\r\n          ? \"Company\"\r\n          : linkedType === \"portfolioFundId\" || linkedType === \"assetFundId\"\r\n          ? \"Fund\"\r\n          : \"AssetPortfolio\";\r\n      res.entityType = this.entityType;\r\n    }\r\n    return res;\r\n  }\r\n\r\n  public GetDashboardV1(\r\n    dashboardId: string,\r\n    roGet,\r\n    callback: Function,\r\n    isRefresh = false,\r\n    callbackForDashboard?: Function\r\n  ) {\r\n    if (!isRefresh) {\r\n      this.portlets = [];\r\n    }\r\n    this.getInfo();\r\n    const dataObj = { dashboardId, language: this.lang };\r\n    this.http.post(this.api.urlList.GetDashboardV2, dataObj, (res) => {\r\n      res = this.pbf.convertKeysToLowerCase(res);\r\n      if (!res) {\r\n        callback(null);\r\n        return;\r\n      }\r\n      res = this.setEntityType(res);\r\n      // 初始化fromDate\r\n      if (res.fromDate === \"1900-01-01T00:00:00Z\") {\r\n        res.fromDate = \"\";\r\n      }\r\n      if (callbackForDashboard) {\r\n        callbackForDashboard(res);\r\n      }\r\n      this.entityIds =\r\n        res.entityList && res.entityList.length > 0\r\n          ? res.entityList.map((e) => {\r\n              return e[\"linkedGuid\"];\r\n            })\r\n          : [];\r\n      if (res.entityList) this.entityList = [...res.entityList];\r\n      this.entityIdObj = {\r\n        id: JSON.stringify(this.entityIds),\r\n      };\r\n      this.portletResults_New[res.id] = {};\r\n      this.portletData_New[res.id] = {};\r\n      this.DashboardService.dashboardGroupId[res.id] = res.dashboardGroupId;\r\n      this.DashboardService.dashboardGroupName[res.id] = res.dashboardGroupName;\r\n      this.DashboardService.RegionDataSetId[res.id] = res.RegionDataSetId;\r\n      this.DashboardService.dashboardName[res.id] = res.name;\r\n      this.DashboardService.shareUsers[res.id] = res.sharedUsers;\r\n      this.dashboardConfig[res.id] = res.config && JSON.parse(res.config);\r\n      if (res) {\r\n        // this.dataMartTables[res.id] = uniqBy(\r\n        // \tres.dataMartTables,\r\n        // \t\"langCode\"\r\n        // );\r\n        this.dataMartTables[res.id] = [...res.dataMartTables];\r\n        this.sortDataMartTables(this.dataMartTables[res.id]);\r\n        this.DashboardService.dashboardDescription = res.description;\r\n        this.img = res.img;\r\n        // 如果可选开始日期，屏蔽默认的1900-01-01\r\n        this.currencyCode = res.currencyCode;\r\n        //@ts-ignore\r\n        this.columnCount = res.columnCount ? res.columnCount : 4;\r\n        if (res.portlets) {\r\n          if (!isRefresh) {\r\n            this.portlets = JSON.parse(JSON.stringify(res.portlets));\r\n          }\r\n          this.rowCount =\r\n            res.portlets.length > 0\r\n              ? Math.max.apply(\r\n                  Math,\r\n                  res.portlets.map(function (o) {\r\n                    return o.posY;\r\n                  })\r\n                ) + 2\r\n              : 2;\r\n\r\n          // new Dashboard\r\n          if (this.portlets && this.portlets.length) {\r\n            this.fieldsArr[res.id] = {};\r\n            this.portlets.forEach((el) => {\r\n              if (\r\n                !Object.keys(this.fieldsArr[res.id]).includes(el.figureCode)\r\n              ) {\r\n                this.fieldsArr[res.id][el.figureCode] = JSON.parse(\r\n                  el.config\r\n                ).fields;\r\n              }\r\n            });\r\n\r\n            this.portlets = this.portlets.filter((item) => item.figureCode);\r\n            this.getDataByPortletsNew(\r\n              this.portlets,\r\n              (_res) => {\r\n                callback(res, this.portlets);\r\n              },\r\n              null,\r\n              isRefresh,\r\n              res,\r\n              roGet\r\n            );\r\n          } else {\r\n            callback(res, this.portlets);\r\n          }\r\n        } else {\r\n          this.portlets = [];\r\n          this.columnCount = 4;\r\n          this.rowCount = 2;\r\n          callback(res, this.portlets);\r\n        }\r\n      }\r\n    });\r\n  }\r\n\r\n  public filterTriggerGetData(portlet, filterSettings, dashboard, callback) {\r\n    const config = portlet.config && JSON.parse(portlet.config);\r\n    let id =\r\n      portlet.id === \"00000000-0000-0000-0000-000000000000\"\r\n        ? portlet.newId\r\n        : portlet.id;\r\n    let params = this.getParamsByPortlet(portlet, null, null, dashboard);\r\n    let initFieldsArr;\r\n    let curFieldsArr;\r\n    if (!params.isTable) {\r\n      // 赋值portletFields_Temp\r\n      initFieldsArr = this.portletFields_Temp[id];\r\n      curFieldsArr = params.displayColumnFilter.split(\",\");\r\n      if (\r\n        !initFieldsArr ||\r\n        this.needGetPortletData(initFieldsArr, curFieldsArr)\r\n      ) {\r\n        this.portletFields_Temp[id] = curFieldsArr;\r\n      }\r\n    }\r\n    if (filterSettings && filterSettings.length) {\r\n      if (!params.columnFilter) {\r\n        params.columnFilter = [];\r\n      }\r\n      config.filterSettings = filterSettings;\r\n\r\n      filterSettings.forEach((setting) => {\r\n        if (config.portletType === \"pivot\") {\r\n          return;\r\n        }\r\n        const _field = config.fields.find(\r\n          (item) => item.colName === setting.name\r\n        );\r\n        const Type = _field && _field.dataType;\r\n        if (setting.items) {\r\n          setting.items.forEach((item) => {\r\n            params.columnFilter.push({\r\n              Field: setting.name,\r\n              Operator: \"equal\",\r\n              Type,\r\n              Value:\r\n                Type === \"date\"\r\n                  ? moment(item).format(\"yyyy-MM-DD\")\r\n                  : Type === \"datetime\"\r\n                  ? moment(item).format(\"yyyy-MM-DD hh:mm:ss\")\r\n                  : item,\r\n            });\r\n          });\r\n        } else if (setting.operator) {\r\n          params.columnFilter.push({\r\n            Field: setting.field,\r\n            Operator: \"equal\",\r\n            Type: setting.type,\r\n            Value:\r\n              setting.type === \"date\"\r\n                ? moment(setting.value).format(\"yyyy-MM-DD\")\r\n                : setting.type === \"datetime\"\r\n                ? moment(setting.value).format(\"yyyy-MM-DD hh:mm:ss\")\r\n                : setting.value,\r\n          });\r\n        }\r\n      });\r\n    } else {\r\n      config.filterSettings = [];\r\n    }\r\n    if (params.columnFilter instanceof Array) {\r\n      params.columnFilter = params.columnFilter.filter((item) => item.Field);\r\n    }\r\n    // json buffer\r\n    params[\"dashboardVersion\"] = 2;\r\n    // json buffer\r\n    this.httpClient\r\n      .post(\r\n        this.api.baseurl + this.api.urlList.GetPortletDataOrCreate,\r\n        params,\r\n        {\r\n          headers: new HttpHeaders({\r\n            Authorization: `Bearer`,\r\n          }),\r\n        }\r\n      )\r\n      .subscribe((result) => {\r\n        result[\"data\"].forEach((item) => {\r\n          item.Sector = this.translation[item.Sector] || item.Sector;\r\n        });\r\n        this.portletData_New[dashboard.id][id] = result;\r\n        this.pbf.triggerDashboardFilterChange.next({\r\n          id: dashboard.id,\r\n          newId: portlet.newId,\r\n        });\r\n        callback({ newId: portlet && portlet.newId, config });\r\n      });\r\n  }\r\n\r\n  public removeParentheses(str) {\r\n    return str.split(\"(\").join(\"\").split(\")\").join(\"\").split('\"').join(\"\");\r\n  }\r\n\r\n  public getInfo() {\r\n    this.translation = JSON.parse(localStorage.getItem(\"translation\"));\r\n    this.userInfo = JSON.parse(localStorage.getItem(\"userInfo\"));\r\n    this.lang = this.pbf.getLanguageParams();\r\n    this.translation.DASHBOARD_ROLLING = this.translation.DASHBOARD_ROLLING\r\n      ? this.translation.DASHBOARD_ROLLING\r\n      : \"DASHBOARD_ROLLING\";\r\n  }\r\n\r\n  /*     Financial Analysis I      get select Dropdown */\r\n  public GetChartTypes() {\r\n    // Chart Type\r\n    return [\r\n      {\r\n        val: \"mscombi2d\",\r\n        displayVal: this.translation.SINGLEY2D,\r\n        hasSecondaryYAxis: false,\r\n        canSelectStyle: true,\r\n      },\r\n      {\r\n        val: \"mscombi3d\",\r\n        displayVal: this.translation.SINGLEY3D,\r\n        hasSecondaryYAxis: false,\r\n        canSelectStyle: true,\r\n      },\r\n      {\r\n        val: \"mscombidy2d\",\r\n        displayVal: this.translation.DUALY2D,\r\n        hasSecondaryYAxis: true,\r\n        canSelectStyle: true,\r\n      },\r\n      {\r\n        val: \"msbar2d\",\r\n        displayVal: this.translation.BAR2D,\r\n        hasSecondaryYAxis: false,\r\n        canSelectStyle: false,\r\n      },\r\n      {\r\n        val: \"msbar3d\",\r\n        displayVal: this.translation.BAR3D,\r\n        hasSecondaryYAxis: false,\r\n        canSelectStyle: false,\r\n      },\r\n      {\r\n        val: \"stackedcolumn2dline\",\r\n        displayVal: this.translation.STACKEDBAR2D,\r\n        hasSecondaryYAxis: false,\r\n        canSelectStyle: true,\r\n      },\r\n      {\r\n        val: \"stackedcolumn3dline\",\r\n        displayVal: this.translation.STACKEDBAR3D,\r\n        hasSecondaryYAxis: false,\r\n        canSelectStyle: true,\r\n      },\r\n    ];\r\n  }\r\n  public getCompanyDropdown() {\r\n    // company\r\n    let data = {\r\n      accountId: this.userInfo.accountId,\r\n      username: this.userInfo.username,\r\n      language: this.lang,\r\n      companyType: \"portfolio\",\r\n    };\r\n    this.http.post(this.api.urlList.GetAllCompanyByAccount, data, (res) => {\r\n      if (res) {\r\n        this.companyDropdownList = res;\r\n        // return res;\r\n      }\r\n    });\r\n  }\r\n  public getCurrencyDropdown() {\r\n    // Currency\r\n    let data = {\r\n      accountId: this.userInfo.accountId,\r\n      username: this.userInfo.username,\r\n      language: this.lang,\r\n      alias: \"Currency\",\r\n    };\r\n    this.http.post(this.api.urlList.GetDropdown, data, (res) => {\r\n      if (res) {\r\n        this.currencyDropdownList = res;\r\n        // return res;\r\n      }\r\n    });\r\n  }\r\n  public GetTimeMeasure() {\r\n    // Time Measure\r\n    return [\r\n      {\r\n        key: \"MTD\", // 月度\r\n        val: this.translation.MONTHLY,\r\n      },\r\n      {\r\n        key: \"QTD\", // 季度\r\n        val: this.translation.QUARTERLY,\r\n      },\r\n      {\r\n        key: \"SYTD\", // 半年度\r\n        val: this.translation.SEMIANNUALLY,\r\n      },\r\n      {\r\n        key: \"YTD\", // 年度\r\n        val: this.translation.ANNUALLY,\r\n      },\r\n      {\r\n        key: \"FYTD\", // 年度（财政年度）\r\n        val: this.translation.ANNUALLYFY,\r\n      },\r\n      {\r\n        key: \"LTM\", // 最近十二个月\r\n        val: this.translation.LAST12MONTH,\r\n      },\r\n    ];\r\n  }\r\n  public GetPeriods() {\r\n    // Previous Period\r\n    return [\r\n      {\r\n        val: 2,\r\n        displayVal: this.translation.LAST2DATA,\r\n      },\r\n      {\r\n        val: 3,\r\n        displayVal: this.translation.LAST3DATA,\r\n      },\r\n      {\r\n        val: 4,\r\n        displayVal: this.translation.LAST4DATA,\r\n      },\r\n      {\r\n        val: 5,\r\n        displayVal: this.translation.LAST5DATA,\r\n      },\r\n      {\r\n        val: 6,\r\n        displayVal: this.translation.LAST6DATA,\r\n      },\r\n      {\r\n        val: 7,\r\n        displayVal: this.translation.LAST7DATA,\r\n      },\r\n      {\r\n        val: 8,\r\n        displayVal: this.translation.LAST8DATA,\r\n      },\r\n      {\r\n        val: 9,\r\n        displayVal: this.translation.LAST9DATA,\r\n      },\r\n      {\r\n        val: 10,\r\n        displayVal: this.translation.LAST10DATA,\r\n      },\r\n      {\r\n        val: 11,\r\n        displayVal: this.translation.LAST11DATA,\r\n      },\r\n      {\r\n        val: 12,\r\n        displayVal: this.translation.LAST12DATA,\r\n      },\r\n      {\r\n        val: 13,\r\n        displayVal: this.translation.LAST13DATA,\r\n      },\r\n      {\r\n        val: 14,\r\n        displayVal: this.translation.LAST14DATA,\r\n      },\r\n      {\r\n        val: 15,\r\n        displayVal: this.translation.LAST15DATA,\r\n      },\r\n      {\r\n        val: 16,\r\n        displayVal: this.translation.LAST16DATA,\r\n      },\r\n      {\r\n        val: 17,\r\n        displayVal: this.translation.LAST17DATA,\r\n      },\r\n      {\r\n        val: 18,\r\n        displayVal: this.translation.LAST18DATA,\r\n      },\r\n      {\r\n        val: 19,\r\n        displayVal: this.translation.LAST19DATA,\r\n      },\r\n      {\r\n        val: 20,\r\n        displayVal: this.translation.LAST20DATA,\r\n      },\r\n      {\r\n        val: 21,\r\n        displayVal: this.translation.LAST21DATA,\r\n      },\r\n      {\r\n        val: 22,\r\n        displayVal: this.translation.LAST22DATA,\r\n      },\r\n      {\r\n        val: 23,\r\n        displayVal: this.translation.LAST23DATA,\r\n      },\r\n      {\r\n        val: 24,\r\n        displayVal: this.translation.LAST24DATA,\r\n      },\r\n    ];\r\n  }\r\n  public GetFollowingPeriods() {\r\n    // Following Period\r\n    return [\r\n      {\r\n        val: 0,\r\n        displayVal: this.translation.NONEXTDATA,\r\n      },\r\n      {\r\n        val: 3,\r\n        displayVal: this.translation.NEXT3DATA,\r\n      },\r\n      {\r\n        val: 4,\r\n        displayVal: this.translation.NEXT4DATA,\r\n      },\r\n      {\r\n        val: 5,\r\n        displayVal: this.translation.NEXT5DATA,\r\n      },\r\n      {\r\n        val: 6,\r\n        displayVal: this.translation.NEXT6DATA,\r\n      },\r\n      {\r\n        val: 7,\r\n        displayVal: this.translation.NEXT7DATA,\r\n      },\r\n      {\r\n        val: 8,\r\n        displayVal: this.translation.NEXT8DATA,\r\n      },\r\n      {\r\n        val: 9,\r\n        displayVal: this.translation.NEXT9DATA,\r\n      },\r\n      {\r\n        val: 10,\r\n        displayVal: this.translation.NEXT10DATA,\r\n      },\r\n      {\r\n        val: 11,\r\n        displayVal: this.translation.NEXT11DATA,\r\n      },\r\n      {\r\n        val: 12,\r\n        displayVal: this.translation.NEXT12DATA,\r\n      },\r\n    ];\r\n  }\r\n  public GetFinancialFigureCodes() {\r\n    // Financial Type\r\n    return [\r\n      {\r\n        key: \"accountAssetFigure\",\r\n        val: this.translation.DASHD_ACCOUNTASSETFIGURE,\r\n      },\r\n      {\r\n        key: \"accountEquityFigure\",\r\n        val: this.translation.DASHD_ACCOUNTEQUITYFIGURE,\r\n      },\r\n      {\r\n        key: \"accountLiabilityFigure\",\r\n        val: this.translation.DASHD_ACCOUNTLIABILITYFIGURE,\r\n      },\r\n      {\r\n        key: \"accountPLFigure\",\r\n        val: this.translation.DASHD_ACCOUNTPLFIGURE,\r\n      },\r\n      {\r\n        key: \"accountCashflowFigure\",\r\n        val: this.translation.DASHD_ACCOUNTCASHFLOWFIGURE,\r\n      },\r\n      {\r\n        key: \"accountOperationKPIFigure\",\r\n        val: this.translation.DASHD_ACCOUNTOPERATIONKPIFIGURE,\r\n      },\r\n      {\r\n        key: \"accountRATIOFigure\",\r\n        val: this.translation.DASHD_ACCOUNTRATIOFIGURE,\r\n      },\r\n    ];\r\n  }\r\n  public GetFinancialSubType(financials) {\r\n    var financialTypes = [];\r\n    for (var item in financials) {\r\n      financialTypes.push({\r\n        subType: item[\"subType\"],\r\n        subTypeCode: item[\"subTypeCode\"],\r\n      });\r\n    }\r\n\r\n    return financialTypes;\r\n  }\r\n  public GetFinancialItems(id, key) {\r\n    let data = {\r\n      username: this.userInfo.username,\r\n      accountId: this.userInfo.accountId,\r\n      investeeIds: [id],\r\n      figureCode: key,\r\n      language: this.lang,\r\n    };\r\n    this.http.post(this.api.urlList.GetFinancialItems, data, (res) => {\r\n      if (res) {\r\n        return res;\r\n      }\r\n    });\r\n  }\r\n  /* get toggle */\r\n  public GetTheme() {\r\n    return [\r\n      { key: \"zune\", val: this.translation.CHARTTHEME_ZUNE },\r\n      { key: \"ocean\", val: this.translation.CHARTTHEME_OCEAN },\r\n      { key: \"carbon\", val: this.translation.CHARTTHEME_CARBON },\r\n    ];\r\n  }\r\n  public GetFollowingDataType() {\r\n    return [\r\n      { key: \"budget\", val: this.translation.BUDGET },\r\n      { key: \"forecast\", val: this.translation.FORECAST },\r\n      // { key: 'rolling', val: this.translation.DASHBOARD_ROLLING },\r\n      { key: \"rolling\", val: \"Rolling\" },\r\n    ];\r\n  }\r\n  public GetFormat() {\r\n    return [\r\n      { key: \"number\", val: this.translation.NUMBER },\r\n      { key: \"percentage\", val: this.translation.PERCENTAGE },\r\n    ];\r\n  }\r\n  public GetChartStyle() {\r\n    return [\r\n      { key: \"bar\", val: this.translation.BAR },\r\n      { key: \"line\", val: this.translation.LINE },\r\n      { key: \"area\", val: this.translation.AREA },\r\n    ];\r\n  }\r\n  public GetDataTypes = function () {\r\n    return [\r\n      { key: \"budget\", val: this.translation.BUDGET },\r\n      { key: \"actual\", val: this.translation.ACTUAL },\r\n      { key: \"forecast\", val: this.translation.FORECAST },\r\n      { key: \"rolling\", val: \"Rolling\" },\r\n    ];\r\n  };\r\n  /*     Fund Operation Summary       */\r\n  public getFundDropdown() {\r\n    let data = {\r\n      username: this.userInfo.username,\r\n      accountId: this.userInfo.accountId,\r\n      investorId: this.userInfo.accountId,\r\n      language: this.lang,\r\n    };\r\n    this.http.post(this.api.urlList.GetFundListByInvestorId, data, (res) => {\r\n      if (res) {\r\n        this.fundDropdownList = res;\r\n        // return res;\r\n      }\r\n    });\r\n  }\r\n  /*     Fund performance       */\r\n  public GetGrouping() {\r\n    return [\r\n      { key: \"null\", val: \"\" },\r\n      { key: \"investor\", val: this.translation.DASHD_GP_INVESTOR },\r\n      { key: \"fund\", val: this.translation.DASHD_GP_FUND },\r\n    ];\r\n  }\r\n  /*     Fund Operation Summary       */\r\n  public getFundDropdown_(callbake: Function) {\r\n    let data = {\r\n      username: this.userInfo.username,\r\n      accountId: this.userInfo.accountId,\r\n      investorId: this.userInfo.accountId,\r\n      language: this.lang,\r\n    };\r\n    this.http.post(this.api.urlList.GetFundListByInvestorId, data, (res) => {\r\n      if (res) {\r\n        this.fundDropdownList = res;\r\n        // this.GetAllInvestee(res => {\r\n        callbake();\r\n        // });\r\n      }\r\n    });\r\n  }\r\n  /*     Investor position       */\r\n  public GetAllInvestee(callbake: Function) {\r\n    let data = {\r\n      username: this.userInfo.username,\r\n      accountId: this.userInfo.accountId,\r\n      language: this.lang,\r\n    };\r\n    this.http.post(this.api.urlList.GetAllInvestee, data, (res) => {\r\n      if (res) {\r\n        this.allInvesteeList = res;\r\n        callbake();\r\n      }\r\n    });\r\n  }\r\n  public pivotTableformatNumber(num) {\r\n    switch (num) {\r\n      case 1:\r\n      case 2:\r\n      case 3:\r\n        return \"#,###;(#,###)\";\r\n      case 4:\r\n      case 5:\r\n      case 6:\r\n        return \"#,###.0;(#,###.0)\";\r\n      case 7:\r\n      case 8:\r\n      case 9:\r\n        return \"#,###.00;(#,###.00)\";\r\n      case 10:\r\n      case 11:\r\n      case 12:\r\n        return \"#,###,,;(#,###,,)\";\r\n      case 13:\r\n      case 14:\r\n      case 15:\r\n        return \"#,###,,.0;(#,###,,.0)\";\r\n      case 16:\r\n      case 17:\r\n      case 18:\r\n        return \"#,###,,.00;(#,###,,.00)\";\r\n      default:\r\n        return \"#,###.00;-#,###.00\";\r\n    }\r\n  }\r\n\r\n  public pivotTableformatInteger(num) {\r\n    switch (num) {\r\n      case 1:\r\n      case 3:\r\n      case 4:\r\n        return \"#,###;(#,###)\";\r\n      case 4:\r\n      case 5:\r\n      case 6:\r\n        return \"#,###,,;(#,###,,)\";\r\n      default:\r\n        return \"#,###;(#,###)\";\r\n    }\r\n  }\r\n\r\n  public pivotTableformatPercent(num) {\r\n    switch (num) {\r\n      case 1:\r\n      case 2:\r\n      case 3:\r\n        return \"P\";\r\n      case 4:\r\n      case 5:\r\n      case 6:\r\n        return \"P1\";\r\n      case 7:\r\n      case 8:\r\n      case 9:\r\n        return \"P2\";\r\n      case 10:\r\n      case 11:\r\n      case 12:\r\n        return \"#,###0.00'x';(#,###0.00'x')\";\r\n      default:\r\n        return \"P2\";\r\n    }\r\n  }\r\n\r\n  public pivotTableformatPercentNum(num) {\r\n    switch (num) {\r\n      case 1:\r\n        return \"####'%'\";\r\n      case 2:\r\n        return \"####.0'%'\";\r\n      case 3:\r\n        return \"####.00'%'\";\r\n      default:\r\n        return \"####.00'%'\";\r\n    }\r\n  }\r\n\r\n  public pivotTableformatMultiple(num) {\r\n    switch (num) {\r\n      case 1:\r\n        return \"####'x'\";\r\n      case 2:\r\n        return \"###0.0'x'\";\r\n      case 3:\r\n        return \"###0.00'x'\";\r\n      default:\r\n        return \"###0.00'x'\";\r\n    }\r\n  }\r\n\r\n  public formatNumber(num) {\r\n    switch (num) {\r\n      case 0:\r\n        return \"N\";\r\n      case 1:\r\n        return \"N1\";\r\n      case 2:\r\n        return \"N2\";\r\n      case 3:\r\n        return \"N3\";\r\n      case 4:\r\n        return \"N4\";\r\n      case 5:\r\n        return \"N5\";\r\n      case 6:\r\n        return \"N6\";\r\n      default:\r\n        return \"N2\";\r\n    }\r\n  }\r\n\r\n  public formatPercent(num) {\r\n    switch (num) {\r\n      case 0:\r\n        return \"P\";\r\n      case 1:\r\n        return \"P1\";\r\n      case 2:\r\n        return \"P2\";\r\n      case 3:\r\n        return \"P3\";\r\n      case 4:\r\n        return \"P4\";\r\n      case 5:\r\n        return \"P5\";\r\n      case 6:\r\n        return \"P6\";\r\n      default:\r\n        return \"P2\";\r\n    }\r\n  }\r\n\r\n  public formatPercentNum(num) {\r\n    switch (num) {\r\n      case 0:\r\n        return \"####'%'\";\r\n      case 1:\r\n        return \"###0.0'%'\";\r\n      case 2:\r\n        return \"###0.00'%'\";\r\n      default:\r\n        return \"###0.00'%'\";\r\n    }\r\n  }\r\n\r\n  public formatMultiple(num) {\r\n    switch (num) {\r\n      case 0:\r\n        return \"####'x'\";\r\n      case 1:\r\n        return \"###0.0'x'\";\r\n      case 2:\r\n        return \"###0.00'x'\";\r\n      default:\r\n        return \"###0.00'x'\";\r\n    }\r\n  }\r\n\r\n  public GetFigureFormat() {\r\n    // return [\r\n    // \t{ key1: \"1,234,567\", key2: \"(1,234,567)\", key3: \"-\", val: 1 }, //\r\n    // \t{ key1: \"1,234,567\", key2: \"(1,234,567)\", key3: \"-\", val: 2 }, //\r\n    // \t{ key1: \"1,234,567.00\", key2: \"(1,234,567.00)\", key3: \"-\", val: 3 }, //\r\n    // \t{ key1: \"1,234,567.00\", key2: \"(1,234,567.00)\", key3: \"-\", val: 4 }, //\r\n    // \t{ key1: \"1\", key2: \"(1)\", key3: \"-\", val: 5 }, //\r\n    // \t{ key1: \"1\", key2: \"(1)\", key3: \"-\", val: 6 }, //\r\n    // \t{ key1: \"1.2\", key2: \"(1.2)\", key3: \"0.0\", val: 7 }, //\r\n    // \t{ key1: \"1.2\", key2: \"(1.2)\", key3: \"0.0\", val: 8 }, //\r\n    // \t{ key1: \"1.23\", key2: \"(1.23)\", key3: \"0.00\", val: 9 }, //\r\n    // \t{ key1: \"1.23\", key2: \"(1.23)\", key3: \"0.00\", val: 10 }, //\r\n    // ];\r\n    return [\r\n      { key: \"1,234,567;(1,234,567);0\", val: 1 },\r\n      { key: \"1,234,567;(1,234,567);-\", val: 2 },\r\n      { key: \"1,234,567;(1,234,567);\", val: 3 },\r\n\r\n      { key: \"1,234,567.0;(1,234,567.0);0.0\", val: 4 },\r\n      { key: \"1,234,567.0;(1,234,567.0);-\", val: 5 },\r\n      { key: \"1,234,567.0;(1,234,567.0);\", val: 6 },\r\n\r\n      { key: \"1,234,567.00;(1,234,567.00);0.00\", val: 7 },\r\n      { key: \"1,234,567.00;(1,234,567.00);-\", val: 8 },\r\n      { key: \"1,234,567.00;(1,234,567.00);\", val: 9 },\r\n\r\n      { key: \"1;(1);0\", val: 10 },\r\n      { key: \"1;(1);-\", val: 11 },\r\n      { key: \"1;(1);\", val: 12 },\r\n\r\n      { key: \"1.2;(1.2);0.0\", val: 13 },\r\n      { key: \"1.2;(1.2);-\", val: 14 },\r\n      { key: \"1.2;(1.2);\", val: 15 },\r\n\r\n      { key: \"1.23;(1.23);0.00\", val: 16 },\r\n      { key: \"1.23;(1.23);-\", val: 17 },\r\n      { key: \"1.23;(1.23);\", val: 18 },\r\n    ];\r\n  }\r\n\r\n  // public GetFigureFormat2() {\r\n  // \treturn [\r\n  // \t\t// 1234567\r\n  // \t\t{ key: \"1,234,567\", val: 11 },\r\n  // \t\t{ key: \"1,234,567.00\", val: 12 },\r\n  // \t\t{ key: \"1\", val: 13 },\r\n  // \t\t{ key: \"1.2\", val: 14 },\r\n  // \t\t{ key: \"1.23\", val: 15 },\r\n  // \t];\r\n  // };\r\n\r\n  public GetFigureFormat3() {\r\n    // return [\r\n    // \t{ key1: \"1,234,567\", key2: \"(1,234,567)\", key3: \"-\", val: 1 }, //\r\n    // \t{ key1: \"1,234,567\", key2: \"(1,234,567)\", key3: \"-\", val: 2 }, //\r\n    // \t{ key1: \"1\", key2: \"(1)\", key3: \"-\", val: 3 }, //\r\n    // \t{ key1: \"1\", key2: \"(1)\", key3: \"-\", val: 4 }, //\r\n    // \t{ key: \"1\", val: 5 },\r\n    // ];\r\n    return [\r\n      { key: \"1,234,567;(1,234,567);0\", val: 1 },\r\n      { key: \"1,234,567;(1,234,567);-\", val: 2 },\r\n      { key: \"1,234,567;(1,234,567);\", val: 3 },\r\n      { key: \"1;(1);0\", val: 4 },\r\n      { key: \"1;(1);-\", val: 5 },\r\n      { key: \"1;(1);\", val: 6 },\r\n    ];\r\n  }\r\n\r\n  public GetPercentFormats() {\r\n    // return [\r\n    // \t{ key1: \"0%\", key2: \"0%\", key3: \"-\", val: 1 },\r\n    // \t{ key1: \"0%\", key2: \"(0%)\", key3: \"-\", val: 2 },\r\n    // \t{ key1: \"0.0%\", key2: \"0.0%\", key3: \"-\", val: 3 },\r\n    // \t{ key1: \"0.0%\", key2: \"(0.0%)\", key3: \"-\", val: 4 },\r\n    // \t{ key1: \"0.00%\", key2: \"0.00%\", key3: \"-\", val: 5 },\r\n    // \t{ key1: \"0.00%\", key2: \"(0.00%)\", key3: \"-\", val: 6 },\r\n    // ];\r\n\r\n    return [\r\n      { key: \"1%;(1%);0%\", val: 1 },\r\n      { key: \"1%;(1%);-\", val: 2 },\r\n      { key: \"1%;(1%);\", val: 3 },\r\n\r\n      { key: \"1.2%;(1.2%);0.0%\", val: 4 },\r\n      { key: \"1.2%;(1.2%);-\", val: 5 },\r\n      { key: \"1.2%;(1.2%);\", val: 6 },\r\n\r\n      { key: \"1.23%;(1.23%);0.00%\", val: 7 },\r\n      { key: \"1.23%;(1.23%);-\", val: 8 },\r\n      { key: \"1.23%;(1.23%);\", val: 9 },\r\n\r\n      { key: \"1.23x;(1.23x);0.00x\", val: 10 },\r\n      { key: \"1.23x;(1.23x);-\", val: 11 },\r\n      { key: \"1.23x;(1.23x);\", val: 12 },\r\n    ];\r\n  }\r\n\r\n  public GetMultipleFormats() {\r\n    return [\r\n      { key: \"0x\", val: 1 },\r\n      { key: \"0.0x\", val: 2 },\r\n      { key: \"0.00x\", val: 3 },\r\n    ];\r\n  }\r\n\r\n  public getAggregateType(aggregateType) {\r\n    switch (aggregateType) {\r\n      case \"CalculateIRR\":\r\n        return \"CI\";\r\n      case \"CalculateIRRIRRDate\":\r\n        return \"CI_IRR\";\r\n      case \"CalculateIRRBeforeCarried\":\r\n        return \"CI_BEFORE_CARRY\";\r\n      case \"CalculateIRRReported\":\r\n        return \"CI_REPORTED\";\r\n      case \"CalculateIRRActualAudited\":\r\n        return \"CI_ACTUAL_AUDITED\";\r\n      case \"CalculateIRRMTD\":\r\n        return \"CI_MTD\";\r\n      case \"CalculateIRRQTD\":\r\n        return \"CI_QTD\";\r\n      case \"CalculateIRRYTD\":\r\n        return \"CI_YTD\";\r\n      case \"CalculateTWRMTD\":\r\n        return \"CTWR_MTD\";\r\n      case \"CalculateTWRQTD\":\r\n        return \"CTWR_QTD\";\r\n      case \"CalculateTWRYTD\":\r\n        return \"CTWR_YTD\";\r\n      case \"CalculateVARMTD_99\":\r\n        return \"CVAR_MTD_99\";\r\n      case \"CalculateVARQTD_99\":\r\n        return \"CVAR_QTD_99\";\r\n      case \"CalculateVARYTD_99\":\r\n        return \"CVAR_YTD_99\";\r\n      case \"CalculateVARMTD_95\":\r\n        return \"CVAR_MTD_95\";\r\n      case \"CalculateVARQTD_95\":\r\n        return \"CVAR_QTD_95\";\r\n      case \"CalculateVARYTD_95\":\r\n        return \"CVAR_YTD_95\";\r\n      case \"CalculateMultiple\":\r\n        return \"CM\";\r\n      case \"CalculatePIC\":\r\n        return \"CP\";\r\n      case \"CalculateDPI\":\r\n        return \"CD\";\r\n      case \"CalculateTVPI\":\r\n        return \"CT\";\r\n      case \"CalculateRVPI\":\r\n        return \"CR\";\r\n      case \"CalculateMActualAudited\":\r\n        return \"CM_ACTUAL_AUDITED\";\r\n      case \"CalculateMReported\":\r\n        return \"CM_REPORTED\";\r\n    }\r\n  }\r\n\r\n  public getCalculateMethod(colName) {\r\n    switch (colName) {\r\n      case \"CI\":\r\n        return \"CalculateIRR\";\r\n      case \"CI_IRR\":\r\n        return \"CalculateIRRIRRDate\";\r\n      case \"CI_BEFORE_CARRY\":\r\n        return \"CalculateIRRBeforeCarried\";\r\n      case \"CI_REPORTED\":\r\n        return \"CalculateIRRReported\";\r\n      case \"CI_ACTUAL_AUDITED\":\r\n        return \"CalculateIRRActualAudited\";\r\n      case \"CI_MTD\":\r\n        return \"CalculateIRRMTD\";\r\n      case \"CI_QTD\":\r\n        return \"CalculateIRRQTD\";\r\n      case \"CI_YTD\":\r\n        return \"CalculateIRRYTD\";\r\n      case \"CTWR_MTD\":\r\n        return \"CalculateTWRMTD\";\r\n      case \"CTWR_QTD\":\r\n        return \"CalculateTWRQTD\";\r\n      case \"CTWR_YTD\":\r\n        return \"CalculateTWRYTD\";\r\n      case \"CVAR_MTD_99\":\r\n        return \"CalculateVARMTD_99\";\r\n      case \"CVAR_QTD_99\":\r\n        return \"CalculateVARQTD_99\";\r\n      case \"CVAR_YTD_99\":\r\n        return \"CalculateVARYTD_99\";\r\n      case \"CVAR_MTD_95\":\r\n        return \"CalculateVARMTD_95\";\r\n      case \"CVAR_QTD_95\":\r\n        return \"CalculateVARQTD_95\";\r\n      case \"CVAR_YTD_95\":\r\n        return \"CalculateVARYTD_95\";\r\n      case \"CM\":\r\n        return \"CalculateMultiple\";\r\n      case \"CP\":\r\n        return \"CalculatePIC\";\r\n      case \"CD\":\r\n        return \"CalculateDPI\";\r\n      case \"CT\":\r\n        return \"CalculateTVPI\";\r\n      case \"CR\":\r\n        return \"CalculateRVPI\";\r\n      case \"CM_ACTUAL_AUDITED\":\r\n        return \"CalculateMActualAudited\";\r\n      case \"CM_REPORTED\":\r\n        return \"CalculateMReported\";\r\n    }\r\n  }\r\n\r\n  // 格式化数字\r\n  public number_format(number, decimals, dec_point, thousands_sep, roundtag) {\r\n    /*\r\n     * 参数说明：\r\n     * number：要格式化的数字\r\n     * decimals：保留几位小数\r\n     * dec_point：小数点符号\r\n     * thousands_sep：千分位符号\r\n     * roundtag:舍入参数，默认 \"ceil\" 向上取,\"floor\"向下取,\"round\" 四舍五入\r\n     * */\r\n    number = (number + \"\").replace(/[^0-9+-Ee.]/g, \"\");\r\n    roundtag = roundtag || \"ceil\"; //\"ceil\",\"floor\",\"round\"\r\n    let n = !isFinite(+number) ? 0 : +number;\r\n    let prec = !isFinite(+decimals) ? 0 : Math.abs(decimals);\r\n    let sep = typeof thousands_sep === \"undefined\" ? \",\" : thousands_sep;\r\n    let dec = typeof dec_point === \"undefined\" ? \".\" : dec_point;\r\n    // let  s = '';\r\n    let s = (\r\n      prec\r\n        ? this.toFixedFix(n, prec, roundtag)\r\n        : \"\" + this.pbf.tofixedNum(n, decimals)\r\n    ).split(\".\"); //this.pbf.tofixedNum(Math.abs(value), decimal)\r\n    var re = /(-?\\d+)(\\d{3})/;\r\n    while (re.test(s[0])) {\r\n      s[0] = s[0].replace(re, \"$1\" + sep + \"$2\");\r\n    }\r\n\r\n    if ((s[1] || \"\").length < prec) {\r\n      s[1] = s[1] || \"\";\r\n      s[1] += new Array(prec - s[1].length + 1).join(\"0\");\r\n    }\r\n    return s.join(dec);\r\n  }\r\n\r\n  private toFixedFix(n, prec, roundtag) {\r\n    var k = Math.pow(10, prec);\r\n    return (\r\n      \"\" +\r\n      parseFloat(\r\n        Math[roundtag](parseFloat((n * k).toFixed(prec * 2))).toFixed(prec * 2)\r\n      ) /\r\n        k\r\n    );\r\n  }\r\n\r\n  public getResultByDataTable(\r\n    portlet,\r\n    isGetTotal = false,\r\n    copyId = false,\r\n    id: string\r\n  ) {\r\n    let result = [];\r\n    let datamartCode = portlet.figureCode;\r\n    let identifier =\r\n      portlet.id === \"00000000-0000-0000-0000-000000000000\"\r\n        ? portlet.newId\r\n        : portlet.id;\r\n    if (portlet.copyId) {\r\n      identifier = portlet.copyId;\r\n    }\r\n    if (this.portletData_New[id][identifier]) {\r\n      result = isGetTotal\r\n        ? this.portletData_New[id][identifier] &&\r\n          this.portletData_New[id][identifier].total\r\n        : this.portletData_New[id][identifier] &&\r\n          this.portletData_New[id][identifier].data;\r\n    } else {\r\n      result = isGetTotal\r\n        ? this.portletResults_New[id][datamartCode] &&\r\n          this.portletResults_New[id][datamartCode].total\r\n        : this.portletResults_New[id][datamartCode] &&\r\n          this.portletResults_New[id][datamartCode].data;\r\n    }\r\n    return result;\r\n  }\r\n\r\n  // SMP2-3708 END\r\n\r\n  public getOrderByColumnsNew(datamartCode, dashboard): Promise<any[]> {\r\n    return new Promise((resolve) => {\r\n      if (this.sourcesData[dashboard.id] && dashboard) {\r\n        const outputRes = [];\r\n        if (this.sourcesData[dashboard.id].length) {\r\n          let config = JSON.parse(dashboard.config);\r\n          const dataViews = config.views;\r\n          if (dashboard && dashboard.config) {\r\n            const dataMart = this.sourcesData[dashboard.id].filter(\r\n              (item) => item.entityType === dashboard.entityType\r\n            );\r\n            dataMart.forEach((_data) => {\r\n              _data.views.forEach((view) => {\r\n                if (dataViews.find((item) => item.datamartViewId === view.id)) {\r\n                  view.tables.forEach((table) => {\r\n                    outputRes.push(table);\r\n                  });\r\n                }\r\n              });\r\n            });\r\n          }\r\n        }\r\n        resolve(outputRes);\r\n      } else {\r\n        // 处理 this.sourcesData 没有值\r\n        let data = {\r\n          accountId: this.userInfo.accountId,\r\n          language: this.lang,\r\n          dashboardVersion: 2,\r\n        };\r\n        this.http.post(this.api.urlList.GetSources, data, (res) => {\r\n          const outputRes = [];\r\n          if (res && res.length) {\r\n            this.sourcesData[dashboard.id] = res;\r\n            let config = JSON.parse(dashboard.config);\r\n            const dataViews = config.views;\r\n            if (dashboard && dashboard.config) {\r\n              const dataMart = res.filter(\r\n                (item) => item.entityType === dashboard.entityType\r\n              );\r\n              dataMart.forEach((_data) => {\r\n                _data.views.forEach((view) => {\r\n                  if (\r\n                    dataViews.find((item) => item.datamartViewId === view.id)\r\n                  ) {\r\n                    view.tables.forEach((table) => {\r\n                      outputRes.push(table);\r\n                    });\r\n                  }\r\n                });\r\n              });\r\n            }\r\n          }\r\n          resolve(outputRes);\r\n        });\r\n      }\r\n    });\r\n  }\r\n\r\n  public async decompressArrayBuffer(input: ArrayBuffer): Promise<Uint8Array> {\r\n    //create the stream\r\n    const ds = new (window as any).DecompressionStream(\"deflate-raw\");\r\n    //create the writer\r\n    const writer = ds.writable.getWriter();\r\n    //write the buffer to the writer thus decompressing it\r\n    writer.write(input);\r\n    writer.close();\r\n    //create the output\r\n    const output: Uint8Array[] = [];\r\n    //create the reader\r\n    const reader = ds.readable.getReader();\r\n    let totalSize = 0;\r\n    //go through each chunk and add it to the output\r\n    while (true) {\r\n      const { value, done } = await reader.read();\r\n      if (done) break;\r\n      output.push(value);\r\n      totalSize += value.byteLength;\r\n    }\r\n    const concatenated = new Uint8Array(totalSize);\r\n    let offset = 0;\r\n    //finally build the compressed array and return it\r\n    for (const array of output) {\r\n      concatenated.set(array, offset);\r\n      offset += array.byteLength;\r\n    }\r\n    return concatenated;\r\n  }\r\n\r\n  private getAllFields(item, dashboard): Promise<any[]> {\r\n    const lang = this.pbf.getLanguageParams();\r\n    return new Promise((resolve, reject) => {\r\n      const dataMartCode = item.figureCode;\r\n      const dataObj = {\r\n        language: lang,\r\n        dataMartCode,\r\n      };\r\n      this.setSchemaParams(dataObj, dataMartCode, dashboard);\r\n      this.http.post(this.api.urlList.GetSchema, dataObj, (res) => {\r\n        resolve(res);\r\n      });\r\n    });\r\n  }\r\n\r\n  public setSchemaParams(dataObj, figureCode, dashboard) {\r\n    if (this.checkIsQ2Q(dashboard.dataMartTables)) {\r\n      dataObj[\"fromDate\"] = dashboard.fromDate;\r\n      dataObj[\"asOfDate\"] = dashboard.asOfDate;\r\n    } else if (figureCode.indexOf(\"FinancialFigure\") !== -1) {\r\n      dataObj[\"entityType\"] = dashboard.entityList.map(\r\n        (item) => item.linkedType\r\n      );\r\n      dataObj[\"fromDate\"] = dashboard.fromDate || \"\";\r\n      dataObj[\"asOfDate\"] = dashboard.asOfDate;\r\n    }\r\n    if (\r\n      dashboard &&\r\n      (figureCode === \"FundOperations\" ||\r\n        figureCode === \"FundOperationTableSequoia\" ||\r\n        figureCode.indexOf(\"FinancialFigure\") !== -1)\r\n    ) {\r\n      dataObj[\"entityIds\"] = dashboard.entityList.map(\r\n        (item) => item.linkedGuid\r\n      );\r\n    }\r\n  }\r\n\r\n  // 判断是否可选开始日期\r\n  public checkHasFromDate(dataMart) {\r\n    const has = dataMart.find(\r\n      (item) =>\r\n        !item.isHide && item.datamartCode === \"FundOperationTableSequoia\"\r\n    );\r\n    return !!has;\r\n  }\r\n\r\n  // 判断Q2Q，控制顶部日期选择类型\r\n  public checkIsQ2Q(dataMart) {\r\n    return false;\r\n    const Q2QPatchList = [\r\n      \"SeeThroughHisPosition\",\r\n      \"SeeThroughHisPositionByInvestor\",\r\n    ];\r\n    const has = dataMart.find((it) => {\r\n      return !it.isHide && Q2QPatchList.includes(it.datamartCode);\r\n    });\r\n    return !!has;\r\n  }\r\n\r\n  /**\r\n   * 使用自定义保存的列数据，覆盖通用列配置数据\r\n   * @param allFields 自定义数据\r\n   * @param fields 通用列配置数据\r\n   * @returns\r\n   */\r\n  public setConfigFields(allFields, fields) {\r\n    allFields.forEach((_field) => {\r\n      fields.forEach((field) => {\r\n        if (_field.colName === field.colName) {\r\n          _field.isHidden = field.isHidden;\r\n          _field.visible = field.visible;\r\n          _field.format = field.format;\r\n          _field.formula = field.formula;\r\n          if (field.showGrandTotals !== undefined) {\r\n            _field.showGrandTotals = field.showGrandTotals;\r\n          }\r\n          if (field.showSubTotals !== undefined) {\r\n            _field.showSubTotals = field.showSubTotals;\r\n          }\r\n        }\r\n      });\r\n    });\r\n    fields.forEach((field) => {\r\n      if (field.isCalculatedField) {\r\n        allFields.push(field);\r\n      }\r\n    });\r\n    const fieldsName = [];\r\n    const outputFields = [];\r\n    allFields.forEach((field) => {\r\n      // q2q当中langCode很多相同，去重要多判断一下addtionName\r\n      // if (!fieldsName.includes(field.langCode) || !!field.addtionName) {\r\n      if (\r\n        !fieldsName.includes(field.langCode) &&\r\n        !fieldsName.includes(field.langValue)\r\n      ) {\r\n        const value = field.langCode || field.langValue;\r\n        fieldsName.push(value);\r\n        outputFields.push(field);\r\n      }\r\n    });\r\n    return outputFields.sort((a, b) => (a.seq >= b.seq ? 1 : -1));\r\n  }\r\n\r\n  public async getDataByPortletsNew(\r\n    portlets,\r\n    callback,\r\n    pageSetting?,\r\n    isRefresh = false,\r\n    dashboard?: any,\r\n    roGet = false\r\n  ) {\r\n    let length = 0;\r\n    if (portlets && portlets.length) {\r\n      for (let portlet of portlets) {\r\n        let id =\r\n          portlet.id === \"00000000-0000-0000-0000-000000000000\"\r\n            ? portlet.newId\r\n            : portlet.id;\r\n        const allFields = await this.getAllFields(portlet, dashboard);\r\n        let params = this.getParamsByPortlet(\r\n          portlet,\r\n          pageSetting,\r\n          allFields,\r\n          dashboard\r\n        );\r\n        let initFieldsArr;\r\n        let curFieldsArr;\r\n        if (!params.isTable && !roGet) {\r\n          // 赋值portletFields_Temp\r\n          initFieldsArr = this.portletFields_Temp[id];\r\n          curFieldsArr = params.displayColumnFilter.split(\",\");\r\n          if (\r\n            !initFieldsArr ||\r\n            this.needGetPortletData(initFieldsArr, curFieldsArr)\r\n          ) {\r\n            this.portletFields_Temp[id] = curFieldsArr;\r\n          } else {\r\n            length++;\r\n            if (portlets.length === length) {\r\n              callback();\r\n            }\r\n            continue;\r\n          }\r\n        }\r\n        const config = portlet.config && JSON.parse(portlet.config);\r\n        if (config.filterSettings && config.filterSettings.length) {\r\n          if (!params.columnFilter) {\r\n            params.columnFilter = [];\r\n          }\r\n          config.filterSettings.forEach((setting) => {\r\n            if (config.portletType === \"pivot\") {\r\n              return;\r\n            }\r\n            const _field = config.fields.find(\r\n              (item) => item.colName === setting.name\r\n            );\r\n            const Type = _field && _field.dataType;\r\n            if (setting.items) {\r\n              setting.items.forEach((item) => {\r\n                params.columnFilter.push({\r\n                  Field: setting.name,\r\n                  Operator: \"equal\",\r\n                  Type,\r\n                  Value:\r\n                    Type === \"date\"\r\n                      ? moment(item).format(\"yyyy-MM-DD\")\r\n                      : Type === \"datetime\"\r\n                      ? moment(item).format(\"yyyy-MM-DD hh:mm:ss\")\r\n                      : item,\r\n                });\r\n              });\r\n            } else if (setting.operator) {\r\n              params.columnFilter.push({\r\n                Field: setting.field,\r\n                Operator: \"equal\",\r\n                Type: setting.type,\r\n                Value:\r\n                  setting.type === \"date\"\r\n                    ? moment(setting.value).format(\"yyyy-MM-DD\")\r\n                    : setting.type === \"datetime\"\r\n                    ? moment(setting.value).format(\"yyyy-MM-DD hh:mm:ss\")\r\n                    : setting.value,\r\n              });\r\n            }\r\n          });\r\n        }\r\n        if (params.columnFilter instanceof Array) {\r\n          params.columnFilter = params.columnFilter.filter(\r\n            (item) => item.Field\r\n          );\r\n        }\r\n\r\n        // json buffer\r\n        params[\"dashboardVersion\"] = 2;\r\n        this.httpClient\r\n          .post(\r\n            this.api.baseurl + this.api.urlList.GetPortletDataOrCreate,\r\n            params,\r\n            {\r\n              headers: new HttpHeaders({\r\n                Authorization: `Bearer`,\r\n              }),\r\n            }\r\n          )\r\n          .subscribe(\r\n            (result) => {\r\n              if (!result) {\r\n                this.portletData_New[dashboard.id][id] = {\r\n                  total: 0,\r\n                  data: [],\r\n                };\r\n                if (isRefresh) {\r\n                  this.DashboardService.refreshGadget.next({\r\n                    newId: id,\r\n                  });\r\n                }\r\n                length++;\r\n                if (isRefresh) {\r\n                  this.DashboardService.refreshGadget.next({\r\n                    newId: id,\r\n                  });\r\n                }\r\n                if (portlets.length === length) {\r\n                  if (isRefresh) {\r\n                    this.DashboardService.startRefresh.next(false);\r\n                  }\r\n                  callback();\r\n                }\r\n              } else {\r\n                result[\"data\"].forEach((item) => {\r\n                  item.Sector = this.translation[item.Sector] || item.Sector;\r\n                });\r\n                this.portletData_New[dashboard.id][id] = result;\r\n                if (isRefresh) {\r\n                  this.DashboardService.refreshGadget.next({\r\n                    newId: id,\r\n                  });\r\n                }\r\n                length++;\r\n                if (portlets.length === length) {\r\n                  if (isRefresh) {\r\n                    this.DashboardService.startRefresh.next(false);\r\n                  }\r\n                  callback();\r\n                }\r\n              }\r\n            },\r\n            (response) => {\r\n              this.portletFields_Temp[id] = initFieldsArr;\r\n              length++;\r\n              if (portlets.length === length) {\r\n                callback();\r\n              }\r\n            },\r\n            () => {}\r\n          );\r\n      }\r\n    } else {\r\n      callback();\r\n    }\r\n  }\r\n\r\n  public clearFieldsObj(portlet) {\r\n    Reflect.deleteProperty(this.allFieldsObj, portlet.id);\r\n  }\r\n\r\n  // 根据portlet 解析params\r\n  public getParamsByPortlet(\r\n    portlet,\r\n    pageSetting?,\r\n    allFields?: any[],\r\n    dashboard?: any\r\n  ) {\r\n    let dashboardDataTableId = portlet.dashboardDataTableId;\r\n    //SMP2-7731 get the dashboardDataTableid from dataMartTables arrary\r\n    let curDataMart = this.dataMartTables[dashboard.id].find(\r\n      (d) => d.datamartCode === portlet.figureCode\r\n    );\r\n    if (curDataMart) {\r\n      dashboardDataTableId = curDataMart.id;\r\n    }\r\n\r\n    let config = portlet.config && JSON.parse(portlet.config);\r\n    if (portlet.id !== \"00000000-0000-0000-0000-000000000000\") {\r\n      this.allFieldsObj[portlet.id] = allFields;\r\n    }\r\n    let fields = allFields\r\n      ? this.setConfigFields(allFields, config.fields)\r\n      : config.fields;\r\n    if (allFields) {\r\n      config.fields = fields;\r\n      portlet.config = JSON.stringify(config);\r\n    }\r\n    let calculatedFields = config.calculatedFieldSettings;\r\n    let needFields = [];\r\n    let params: any = {};\r\n    const portletType =\r\n      config.portletType === \"historicalIRR\"\r\n        ? config.selectedVisualType\r\n        : config.portletType;\r\n    if (portletType === \"table\") {\r\n      fields &&\r\n        fields.forEach((x) => {\r\n          needFields.push(x.colName);\r\n        });\r\n\r\n      params.startIndex = 0;\r\n      params.pageSize = 10;\r\n      if (pageSetting && pageSetting.currentPage) {\r\n        params.startIndex =\r\n          (pageSetting.currentPage - 1) * pageSetting.pageSize;\r\n        params.pageSize = pageSetting.pageSize;\r\n      }\r\n      // 处理 sort\r\n      if (pageSetting && pageSetting.sortedColumn) {\r\n        params.sortedColumn = pageSetting.sortedColumn;\r\n        params.sort = pageSetting.sort;\r\n      }\r\n      // 处理 filter\r\n      if (config.filterSettings.length) {\r\n        let filterSettings = JSON.parse(JSON.stringify(config.filterSettings));\r\n        params.columnFilter = filterSettings.map((x) => {\r\n          if (x.type === \"date\") {\r\n            const date = new Date(x.value);\r\n            const year = date.getFullYear();\r\n            const month = String(date.getMonth() + 1).padStart(2, \"0\");\r\n            const day = String(date.getDate()).padStart(2, \"0\");\r\n            const formattedDate = `${year}-${month}-${day}`;\r\n            x.value = formattedDate;\r\n          }\r\n          return x;\r\n        });\r\n      }\r\n      params.isTable = true;\r\n    } else if (portletType === \"transpose\") {\r\n      fields &&\r\n        fields.forEach((x) => {\r\n          if (!x.isHidden) {\r\n            needFields.push(x.colName);\r\n          }\r\n        });\r\n    } else if (\r\n      [\"newcolumn\", \"newline\", \"newcolumnline\"].includes(portletType)\r\n    ) {\r\n      if (config.selectedY && config.selectedY.length > 0) {\r\n        config.selectedY.forEach((e) => {\r\n          needFields.push(e);\r\n        });\r\n      }\r\n      if (config.selectedSecondY && config.selectedSecondY.length > 0) {\r\n        config.selectedSecondY.forEach((e) => {\r\n          needFields.push(e);\r\n        });\r\n      }\r\n    } else {\r\n      // 处理 filters\r\n      let filters = config.filters;\r\n      if (filters && filters.length) {\r\n        for (let item of filters) {\r\n          needFields.push(item.name);\r\n        }\r\n      }\r\n\r\n      // 处理 values\r\n      let series = config.yaxis.series;\r\n      if (series && series.length) {\r\n        for (let item of series) {\r\n          if (\r\n            [\r\n              \"CalculateIRR\",\r\n              \"CalculateIRRMTD\",\r\n              \"CalculateIRRQTD\",\r\n              \"CalculateIRRYTD\",\r\n              \"CalculateTWRMTD\",\r\n              \"CalculateTWRQTD\",\r\n              \"CalculateTWRYTD\",\r\n              \"CalculateVARMTD_99\",\r\n              \"CalculateVARQTD_99\",\r\n              \"CalculateVARYTD_99\",\r\n              \"CalculateVARMTD_95\",\r\n              \"CalculateVARQTD_95\",\r\n              \"CalculateVARYTD_95\",\r\n            ].includes(item.calMethod)\r\n          ) {\r\n            needFields.push(\"IRRAmount\", \"IRRDate\", \"IRRAdjValue\");\r\n          } else if (item.calMethod === \"CalculateIRRBeforeCarried\") {\r\n            needFields.push(\"IRRAmount\", \"IRRDate\", \"IRRAdjValueBeforeCarry\");\r\n          } else if (item.calMethod === \"CalculateIRRIRRDate\") {\r\n            needFields.push(\"IRRAmount\", \"CalculateIRRDate\", \"IRRAdjValue\");\r\n          } else if (item.calMethod === \"CalculateIRRActualAudited\") {\r\n            portlet.figureCode === \"GrossNet\" ||\r\n            portlet.figureCode === \"CombinedInvestmentFundNCompanyCashflow\"\r\n              ? needFields.push(\"IRRAmount\", \"IRRDate\", \"ActualAuditedNAV\")\r\n              : needFields.push(\"IRRAmount\", \"IRRDate\", \"IRRAdjValue\");\r\n          } else if (item.calMethod === \"CalculateIRRReported\") {\r\n            portlet.figureCode === \"GrossNet\" ||\r\n            portlet.figureCode === \"CombinedInvestmentFundNCompanyCashflow\"\r\n              ? needFields.push(\"IRRAmount\", \"IRRDate\", \"ReportedNAV\")\r\n              : needFields.push(\"IRRAmount\", \"IRRDate\", \"IRRAdjValue\");\r\n          } else if (item.calMethod === \"CalculatedField\") {\r\n          } else {\r\n            let colName = this.getAggregateType(item.calMethod);\r\n            if (colName) {\r\n              let curField = fields.find((f) => f.colName === colName);\r\n              if (curField && curField.formula) {\r\n                let fs = curField.formula.split(\"/\");\r\n                fs && fs.map((f) => needFields.push(f));\r\n              }\r\n            } else {\r\n              needFields.push(item.colName);\r\n            }\r\n          }\r\n        }\r\n      }\r\n      // 处理 rows\r\n      let groups = config.xaxis.groups;\r\n      if (groups && groups.length) {\r\n        for (let gitem of groups) {\r\n          needFields.push(gitem.name);\r\n        }\r\n      }\r\n      // 处理 colunms\r\n      let columnGroup = config.columnGroup;\r\n      if (columnGroup && columnGroup.length) {\r\n        for (let item of columnGroup) {\r\n          needFields.push(item.name);\r\n        }\r\n      }\r\n      // 处理 calculatedField\r\n      if (calculatedFields && calculatedFields.length) {\r\n        calculatedFields.map((f) => {\r\n          let string = f.formula;\r\n          const regex = /\\((.*?)\\)/g;\r\n          const matches = string\r\n            .match(regex)\r\n            .map((match) => match.slice(1, -1));\r\n          needFields.push(...matches);\r\n        });\r\n      }\r\n      // 处理 orderByColumns\r\n      if (this.dashboardConfig && this.dashboardConfig[dashboard.id]) {\r\n        params.datamartViewId =\r\n          this.dashboardConfig[dashboard.id].datamartViewId;\r\n        params.datamartId = this.dashboardConfig[dashboard.id].datamartId;\r\n        params.datamartCode = portlet.figureCode;\r\n      }\r\n      // 处理config.fields里的sortColumn\r\n      let fieldSortColumns = [];\r\n      fields.map((x) => {\r\n        if (x.sortColumn && !fieldSortColumns.includes(x.sortColumn)) {\r\n          fieldSortColumns.push(x.sortColumn);\r\n        }\r\n      });\r\n      if (fieldSortColumns.length) {\r\n        needFields.push(...fieldSortColumns);\r\n      }\r\n    }\r\n\r\n    needFields = Array.from(new Set(needFields));\r\n    // 去除非法字段\r\n    let legalFields = fields.map((x) => x.colName);\r\n    needFields.map((x, i) => {\r\n      if (!legalFields.includes(x)) {\r\n        needFields.splice(i, 1);\r\n      }\r\n    });\r\n    if (needFields.length === 0) {\r\n      if (legalFields[0]) {\r\n        needFields.push(legalFields[0]);\r\n      }\r\n    }\r\n    // 默认获取Seq字段 SMP2-4582 AGIC - Dashboard item sequence\r\n    needFields.push(\"Seq\");\r\n\r\n    // \"newcolumn\", \"newline\", \"newcolumnline\" 如果是这三种类型默认加 OperationDate 字段\r\n    if ([\"newcolumn\", \"newline\", \"newcolumnline\"].includes(portletType)) {\r\n      needFields.push(config.selectedX);\r\n      params[\"IsOnlyShowDisplayColum\"] = true;\r\n    }\r\n    if (config.portletType === \"historicalIRR\") {\r\n      if (!params.columnFilter) {\r\n        params.columnFilter = [];\r\n      }\r\n      params.columnFilter.push(\r\n        {\r\n          Field: \"Frequencys\",\r\n          Operator: \"equal\",\r\n          Type: \"string\",\r\n          Value: config.selectedMultiples,\r\n        },\r\n        {\r\n          Field: \"InvestorType\",\r\n          Operator: \"equal\",\r\n          Type: \"string\",\r\n          Value: config.selectedInvestor,\r\n        }\r\n      );\r\n    }\r\n    params.dashboardDataTableId = dashboardDataTableId;\r\n    params.displayColumnFilter = needFields.join(\",\");\r\n    params.responseType = \"json\";\r\n    return params;\r\n  }\r\n\r\n  // 是否需要重新发起请求\r\n  public needGetPortletData(origin = [], compare = []) {\r\n    return compare.some((c) => !origin.includes(c));\r\n  }\r\n\r\n  public setDataManager(\r\n    figureCodes,\r\n    callback,\r\n    portletTypes = [],\r\n    dashboardId,\r\n    portlet?: any\r\n  ) {\r\n    let length = 0;\r\n    if (!this.fieldsArr[dashboardId]) {\r\n      this.fieldsArr[dashboardId] = {};\r\n    }\r\n    if (\r\n      this.dataMartTables[dashboardId] &&\r\n      this.dataMartTables[dashboardId].length\r\n    ) {\r\n      this.pbf.pageLoading = true;\r\n      this.pbf.pageLoading_.next(true);\r\n      let dataMartTables = this.dataMartTables[dashboardId].filter((el) =>\r\n        figureCodes.includes(el.datamartCode)\r\n      );\r\n      if (dataMartTables.length) {\r\n        forEach(dataMartTables, (item, index) => {\r\n          let allFields;\r\n          let config;\r\n          if (portlet) {\r\n            config = JSON.parse(portlet.config);\r\n          }\r\n          if (\r\n            [\"newcolumn\", \"newline\", \"newcolumnline\"].includes(portletTypes[0])\r\n          ) {\r\n            allFields = config.selectedY\r\n              .concat(config.selectedSecondY)\r\n              .concat([config.selectedX])\r\n              .map((e) => {\r\n                return {\r\n                  colName: e,\r\n                };\r\n              });\r\n          } else {\r\n            allFields =\r\n              this.fieldsArr[dashboardId] &&\r\n              this.fieldsArr[dashboardId][item.datamartCode]\r\n                ? this.fieldsArr[dashboardId][item.datamartCode]\r\n                : [];\r\n          }\r\n          let displayColumnFilter =\r\n            allFields && allFields.map((x) => x.colName).join(\",\");\r\n          let params: any = {\r\n            dashboardDataTableId: item.id,\r\n            displayColumnFilter: displayColumnFilter,\r\n            responseType: \"json\",\r\n            dashboardVersion: 2,\r\n          };\r\n          params.startIndex = 0;\r\n          params.pageSize = 10;\r\n\r\n          if (\r\n            portletTypes &&\r\n            portletTypes.length > 0 &&\r\n            (portletTypes.includes(\"newcolumn\") ||\r\n              portletTypes.includes(\"newline\") ||\r\n              portletTypes.includes(\"newcolumnline\"))\r\n          ) {\r\n            params.pageSize = 1000000;\r\n            params[\"IsOnlyShowDisplayColum\"] = true;\r\n          }\r\n\r\n          if (config) {\r\n            const filterSettings = config.filterSettings;\r\n\r\n            if (filterSettings && filterSettings.length) {\r\n              if (!params.columnFilter) {\r\n                params.columnFilter = [];\r\n              }\r\n              filterSettings.forEach((setting) => {\r\n                if (config.portletType === \"pivot\") {\r\n                  return;\r\n                }\r\n                const _field = config.fields.find(\r\n                  (item) => item.colName === setting.name\r\n                );\r\n                const Type = _field && _field.dataType;\r\n                if (setting.items) {\r\n                  setting.items.forEach((item) => {\r\n                    params.columnFilter.push({\r\n                      Field: setting.name,\r\n                      Operator: \"equal\",\r\n                      Type,\r\n                      Value:\r\n                        Type === \"date\"\r\n                          ? moment(item).format(\"yyyy-MM-DD\")\r\n                          : Type === \"datetime\"\r\n                          ? moment(item).format(\"yyyy-MM-DD hh:mm:ss\")\r\n                          : item,\r\n                    });\r\n                  });\r\n                } else if (setting.operator) {\r\n                  params.columnFilter.push({\r\n                    Field: setting.field,\r\n                    Operator: \"equal\",\r\n                    Type: setting.type,\r\n                    Value:\r\n                      setting.type === \"date\"\r\n                        ? moment(setting.value).format(\"yyyy-MM-DD\")\r\n                        : setting.type === \"datetime\"\r\n                        ? moment(setting.value).format(\"yyyy-MM-DD hh:mm:ss\")\r\n                        : setting.value,\r\n                  });\r\n                }\r\n              });\r\n            }\r\n            if (config.portletType === \"historicalIRR\") {\r\n              if (!params.columnFilter) {\r\n                params.columnFilter = [];\r\n              }\r\n              params.columnFilter.push(\r\n                {\r\n                  Field: \"Frequencys\",\r\n                  Operator: \"equal\",\r\n                  Type: \"string\",\r\n                  Value: config.selectedMultiples,\r\n                },\r\n                {\r\n                  Field: \"InvestorType\",\r\n                  Operator: \"equal\",\r\n                  Type: \"string\",\r\n                  Value: config.selectedInvestor,\r\n                }\r\n              );\r\n            }\r\n          }\r\n          if (params.columnFilter instanceof Array) {\r\n            params.columnFilter = params.columnFilter.filter(\r\n              (item) => item.Field\r\n            );\r\n          }\r\n\r\n          // json buffer\r\n          this.httpClient\r\n            .post(\r\n              this.api.baseurl + this.api.urlList.GetPortletDataOrCreate,\r\n              params,\r\n              {\r\n                headers: new HttpHeaders({\r\n                  Authorization: `Bearer`,\r\n                }),\r\n              }\r\n            )\r\n            .subscribe(\r\n              (result) => {\r\n                let identifier =\r\n                  portlet.id === \"00000000-0000-0000-0000-000000000000\"\r\n                    ? portlet.newId\r\n                    : portlet.id;\r\n                if (!result) {\r\n                  this.portletResults_New[dashboardId][item.datamartCode] = [];\r\n                  if (portlet) {\r\n                    this.portletData_New[dashboardId][identifier] = {\r\n                      total: 0,\r\n                      data: [],\r\n                    };\r\n                  }\r\n                  let message = this.translation.NO_DATA\r\n                    ? this.translation.NO_DATA\r\n                    : \".No data, please choose another data type\";\r\n                  this.dialogService.showNotification(message, {\r\n                    status: \"Error\",\r\n                  });\r\n                  length++;\r\n                  if (dataMartTables.length === length) {\r\n                    callback();\r\n                  }\r\n                } else {\r\n                  result[\"data\"].forEach((item) => {\r\n                    item.Sector = this.translation[item.Sector] || item.Sector;\r\n                  });\r\n                  if (\r\n                    this.fieldsArr[dashboardId] &&\r\n                    Object.keys(this.fieldsArr[dashboardId]).length\r\n                  ) {\r\n                    this.portletResults_New[dashboardId][item.datamartCode] =\r\n                      result;\r\n                  }\r\n                  if (portlet) {\r\n                    this.portletData_New[dashboardId][identifier] = result;\r\n                  }\r\n                  length++;\r\n                  if (dataMartTables.length === length) {\r\n                    callback();\r\n                  }\r\n                }\r\n              },\r\n              (response) => {\r\n                length++;\r\n                if (dataMartTables.length === length) {\r\n                  callback();\r\n                }\r\n              },\r\n              () => {}\r\n            );\r\n        });\r\n      } else {\r\n        callback();\r\n      }\r\n    }\r\n  }\r\n\r\n  public ExcelFormulas = {\r\n    DaysBetween: function (date1, date2) {\r\n      var oneDay = 24 * 60 * 60 * 1000;\r\n      return Math.round(Math.abs((date1.getTime() - date2.getTime()) / oneDay));\r\n    },\r\n    XNPV: function (rate, values) {\r\n      var xnpv = 0.0;\r\n      var firstDate = new Date(values[0].date);\r\n      for (var key in values) {\r\n        var tmp = values[key];\r\n        var value = tmp.amount;\r\n        var date = new Date(tmp.date);\r\n        xnpv +=\r\n          value / Math.pow(1 + rate, this.DaysBetween(firstDate, date) / 365);\r\n      }\r\n      return xnpv;\r\n    },\r\n    XIRR: function (values, guess) {\r\n      var x1 = 0.0;\r\n      var x2: number = guess;\r\n      var f1 = this.XNPV(x1, values);\r\n      var f2 = this.XNPV(x2, values);\r\n      for (var i = 0; i < 100; i++) {\r\n        if (f1 * f2 < 0.0) break;\r\n        if (Math.abs(f1) < Math.abs(f2)) {\r\n          f1 = this.XNPV((x1 += 1.6 * (x1 - x2)), values);\r\n        } else {\r\n          f2 = this.XNPV((x2 += 1.6 * (x2 - x1)), values);\r\n        }\r\n      }\r\n      if (f1 * f2 > 0.0) return null;\r\n      var f = this.XNPV(x1, values);\r\n      if (f < 0.0) {\r\n        var rtb = x1;\r\n        var dx = x2 - x1;\r\n      } else {\r\n        var rtb = x2;\r\n        var dx = x1 - x2;\r\n      }\r\n      for (var i = 0; i < 100; i++) {\r\n        dx *= 0.5;\r\n        var x_mid = rtb + dx;\r\n        var f_mid = this.XNPV(x_mid, values);\r\n        if (f_mid <= 0.0) rtb = x_mid;\r\n        if (Math.abs(f_mid) < 1.0e-6 || Math.abs(dx) < 1.0e-6) return x_mid;\r\n      }\r\n      return null;\r\n    },\r\n    _DaysBetween: function (date1, date2) {\r\n      //const time1 =new Date(Date.UTC(date1.getUTCFullYear(), date1.getUTCMonth(), date1.getUTCDate(), date1.getUTCHours(), date1.getUTCMinutes(), date1.getUTCSeconds())).getTime();\r\n      //const time2 =new Date(Date.UTC(date2.getUTCFullYear(), date2.getUTCMonth(), date2.getUTCDate(), date2.getUTCHours(), date2.getUTCMinutes(), date2.getUTCSeconds())).getTime();\r\n      const oneDay = 24 * 60 * 60 * 1000; // 一天的毫秒数\r\n      //const time1 = date1.getTime(); // date1的毫秒表示\r\n      //const time2 = date2.getTime(); // date2的毫秒表示\r\n      const firstDate = new Date(date1);\r\n      const secondDate = new Date(date2);\r\n      const diffDays = Math.round(\r\n        // @ts-ignore\r\n        Math.abs((firstDate - secondDate) / oneDay)\r\n      ); // 计算天数差并取整\r\n      return diffDays;\r\n    },\r\n\r\n    _lcl_sca_XirrResult: function (values, dates, fRate) {\r\n      var D_0 = dates[0];\r\n      let r = fRate + 1.0;\r\n      var fResult = values[0];\r\n      for (var i = 1, nCount = values.length; i < nCount; ++i) {\r\n        var temp = Math.pow(r, this._DaysBetween(dates[i], D_0) / 365.0);\r\n        fResult += values[i] / temp;\r\n      }\r\n      return fResult;\r\n    },\r\n\r\n    _lcl_sca_XirrResult_Deriv1: function (values, dates, fRate) {\r\n      var D_0 = dates[0];\r\n      var r = fRate + 1.0;\r\n      var fResult = 0.0;\r\n      for (var i = 1, nCount = values.length; i < nCount; ++i) {\r\n        var E_i = this._DaysBetween(dates[i], D_0) / 365.0;\r\n        fResult -= (E_i * values[i]) / Math.pow(r, E_i + 1.0);\r\n      }\r\n      return fResult;\r\n    },\r\n\r\n    _CalculateXirrOpenOffice: function (values, dates, guess) {\r\n      if (values.length < 2 || values.length != dates.length) {\r\n        return null;\r\n      }\r\n\r\n      var fResultRate = guess;\r\n      if (fResultRate <= -1) {\r\n        return null;\r\n      }\r\n\r\n      var fMaxEps = 0.00000001;\r\n      var nMaxIter = 50;\r\n\r\n      var fNewRate, fRateEps, fResultValue;\r\n      var nIter = 0;\r\n      var nIterScan = 0;\r\n      var bContLoop = false;\r\n      var bResultRateScanEnd = false;\r\n\r\n      do {\r\n        if (nIterScan >= 1) {\r\n          fResultRate = -0.99 + (nIterScan - 1) * 0.01;\r\n        }\r\n        do {\r\n          fResultValue = this._lcl_sca_XirrResult(values, dates, fResultRate);\r\n          fNewRate =\r\n            fResultRate -\r\n            fResultValue /\r\n              this._lcl_sca_XirrResult_Deriv1(values, dates, fResultRate);\r\n          fRateEps = Math.abs(fNewRate - fResultRate);\r\n          fResultRate = fNewRate;\r\n          bContLoop = fRateEps > fMaxEps && Math.abs(fResultValue) > fMaxEps;\r\n        } while (bContLoop && ++nIter < nMaxIter);\r\n        nIter = 0;\r\n        if (\r\n          isNaN(fResultRate) ||\r\n          !isFinite(fResultRate) ||\r\n          isNaN(fResultValue) ||\r\n          !isFinite(fResultValue)\r\n        ) {\r\n          bContLoop = true;\r\n        }\r\n\r\n        ++nIterScan;\r\n        bResultRateScanEnd = nIterScan >= 100;\r\n      } while (bContLoop && !bResultRateScanEnd);\r\n\r\n      if (bContLoop) {\r\n        return null;\r\n      }\r\n      return fResultRate;\r\n    },\r\n\r\n    _CalculateXirr: function (valueList, dateList, navAdjust, latestDate) {\r\n      var positiveCashflow = valueList.some(function (v) {\r\n        return v > 0;\r\n      })\r\n        ? true\r\n        : navAdjust > 0\r\n        ? true\r\n        : false;\r\n      var negativeCashflow = valueList.some(function (v) {\r\n        return v < 0;\r\n      })\r\n        ? true\r\n        : navAdjust < 0\r\n        ? true\r\n        : false;\r\n\r\n      if (positiveCashflow == false || negativeCashflow == false) {\r\n        return null;\r\n      }\r\n\r\n      if (navAdjust != null) {\r\n        valueList.push(navAdjust);\r\n        dateList.push(latestDate);\r\n      }\r\n\r\n      var xirrResult = null;\r\n      try {\r\n        var excelGuess =\r\n          valueList.reduce(function (sum, value) {\r\n            return sum + value;\r\n          }, 0) < 0\r\n            ? -0.1\r\n            : 0.1;\r\n        xirrResult = this._CalculateXirrOpenOffice(\r\n          valueList,\r\n          dateList,\r\n          excelGuess\r\n        );\r\n      } catch (error) {\r\n        return null;\r\n      }\r\n\r\n      return xirrResult;\r\n    },\r\n  };\r\n\r\n  // 拿到数据后，先遍历config.filterSettings,如果在数据中不存在，就删除这一项\r\n  checkFilterSettings(config, fields, data) {\r\n    let filterSettings = config.filterSettings;\r\n    if (filterSettings && filterSettings.length) {\r\n      for (let i = 0; i < filterSettings.length; i++) {\r\n        const element = filterSettings[i];\r\n        let __field = fields.filter(\r\n          (field) => field.colName == element.name\r\n        )[0];\r\n        if (!__field) {\r\n          // 处理自定义 Group的Filter\r\n          continue;\r\n        }\r\n        const dataType = __field.dataType;\r\n        if (element.items && element.items.length) {\r\n          for (let r = 0; r < element.items.length; r++) {\r\n            const item = element.items[r];\r\n            let res = [];\r\n            if (\r\n              dataType !== \"date\" &&\r\n              dataType !== \"datetime\" &&\r\n              data &&\r\n              data.length\r\n            ) {\r\n              if (dataType == \"string\") {\r\n                res = data.filter((obj) => obj[element.name] === item);\r\n              } else {\r\n                res = data.filter(\r\n                  (obj) => Number(obj[element.name]) === Number(item)\r\n                );\r\n              }\r\n            }\r\n            if (dataType == \"date\" || dataType == \"datetime\") {\r\n              res = data.filter(\r\n                (obj) =>\r\n                  moment(obj[element.name]).format(\"YYYY-MM-DD\") ==\r\n                  moment(item).format(\"YYYY-MM-DD\")\r\n              );\r\n            }\r\n            if (!res.length) {\r\n              element.items.splice(r, 1);\r\n              r--;\r\n            }\r\n          }\r\n          if (!element.items.length) {\r\n            filterSettings.splice(i, 1);\r\n            i--;\r\n          }\r\n        }\r\n      }\r\n      return filterSettings;\r\n    } else {\r\n      return [];\r\n    }\r\n    // callback(filterSettings);\r\n  }\r\n\r\n  sortDataMartTables(data) {\r\n    data.sort((a, b) => {\r\n      const langValueA = a.langValue.toLowerCase();\r\n      const langValueB = b.langValue.toLowerCase();\r\n\r\n      if (langValueA < langValueB) {\r\n        return -1;\r\n      }\r\n      if (langValueA > langValueB) {\r\n        return 1;\r\n      }\r\n      return 0;\r\n    });\r\n  }\r\n\r\n  renameDataMartTables(data, id, entityType) {\r\n    if (this.sourcesData[id]) {\r\n      this.sourcesData[id].forEach((sources) => {\r\n        if (sources.entityType === entityType) {\r\n          data.forEach((_data) => {\r\n            sources.views.forEach((view) => {\r\n              view.tables.forEach((table) => {\r\n                if (table.datamartCode === _data.datamartCode) {\r\n                  _data.langValue = table.langValue;\r\n                  _data.langCode = table.langCode;\r\n                }\r\n              });\r\n            });\r\n          });\r\n        }\r\n      });\r\n    } else {\r\n      return data;\r\n    }\r\n  }\r\n}\r\nexport const ALL_AGGREGATE_TYPES = [\r\n  \"Sum\",\r\n  \"First\",\r\n  \"Last\",\r\n  \"CalculateIRR\",\r\n  \"CalculateIRRIRRDate\",\r\n  \"CalculateIRRBeforeCarried\",\r\n  \"CalculateIRRActualAudited\",\r\n  \"CalculateIRRReported\",\r\n  \"CalculateIRRMTD\",\r\n  \"CalculateIRRQTD\",\r\n  \"CalculateIRRYTD\",\r\n  \"CalculateTWRMTD\",\r\n  \"CalculateTWRQTD\",\r\n  \"CalculateTWRYTD\",\r\n  \"CalculateVARMTD_99\",\r\n  \"CalculateVARQTD_99\",\r\n  \"CalculateVARYTD_99\",\r\n  \"CalculateVARMTD_95\",\r\n  \"CalculateVARQTD_95\",\r\n  \"CalculateVARYTD_95\",\r\n  \"CalculateMultiple\",\r\n  \"CalculatePIC\",\r\n  \"CalculateDPI\",\r\n  \"CalculateTVPI\",\r\n  \"CalculateRVPI\",\r\n  \"CalculateMActualAudited\",\r\n  \"CalculateMReported\",\r\n  \"Count\",\r\n  \"DistinctCount\",\r\n  \"Product\",\r\n  \"Min\",\r\n  \"Max\",\r\n  \"Avg\",\r\n  \"Median\",\r\n  \"Index\",\r\n  \"PopulationVar\",\r\n  \"SampleVar\",\r\n  \"PopulationStDev\",\r\n  \"SampleStDev\",\r\n  \"RunningTotals\",\r\n  \"PercentageOfGrandTotal\",\r\n  \"PercentageOfColumnTotal\",\r\n  \"PercentageOfRowTotal\",\r\n  \"PercentageOfParentColumnTotal\",\r\n  \"PercentageOfParentRowTotal\",\r\n  \"DifferenceFrom\",\r\n  \"PercentageOfDifferenceFrom\",\r\n  \"PercentageOfParentTotal\",\r\n];\r\n\r\nlet translation = JSON.parse(localStorage.getItem(\"translation\") || \"{}\");\r\nexport const AGGREGATE_TYPES_TEXT = {\r\n  CalculateIRR: translation.CALCULATE_IRR || \"Calculate IRR\",\r\n  CalculateIRRIRRDate:\r\n    translation.CALCULATE_IRR_IRR_DATE || \"Calculate IRR (IRR Date)\",\r\n  CalculateIRRBeforeCarried:\r\n    translation.CALCULATE_IRR_BEFORE_CARRY || \"Calculate IRR Before Carried\",\r\n  CalculateIRRActualAudited:\r\n    translation.CALCULATE_IRR_ACTUAL_AUDITED || \"Calculate IRR Actual/Audited\",\r\n  CalculateIRRReported: translation.CI_REPORTED || \"Calculate IRR Reported\",\r\n  CalculateIRRMTD: translation.CALCULATE_IRR_MTD || \"Calculate IRR (MTD)\",\r\n  CalculateIRRQTD: translation.CALCULATE_IRR_QTD || \"Calculate IRR (QTD)\",\r\n  CalculateIRRYTD: translation.CALCULATE_IRR_YTD || \"Calculate IRR (YTD)\",\r\n  CalculateTWRMTD: translation.CALCULATE_TWR_MTD || \"Calculate TWR (M)\",\r\n  CalculateTWRQTD: translation.CALCULATE_TWR_QTD || \"Calculate TWR (Q)\",\r\n  CalculateTWRYTD: translation.CALCULATE_TWR_YTD || \"Calculate TWR (Y)\",\r\n  CalculateVARMTD_99:\r\n    translation.CALCULATE_VAR_MTD_99 || \"Calculate VAR (M 99%)\",\r\n  CalculateVARQTD_99:\r\n    translation.CALCULATE_VAR_QTD_99 || \"Calculate VAR (Q 99%)\",\r\n  CalculateVARYTD_99:\r\n    translation.CALCULATE_VAR_YTD_99 || \"Calculate VAR (Y 99%)\",\r\n  CalculateVARMTD_95:\r\n    translation.CALCULATE_VAR_MTD_95 || \"Calculate VAR (M 95%)\",\r\n  CalculateVARQTD_95:\r\n    translation.CALCULATE_VAR_QTD_95 || \"Calculate VAR (Q 95%)\",\r\n  CalculateVARYTD_95:\r\n    translation.CALCULATE_VAR_YTD_95 || \"Calculate VAR (Y 95%)\",\r\n  CalculateMultiple: translation.CALCULATE_MULTIPLE || \"Calculate Multiple\",\r\n  CalculatePIC: translation.CALCULATE_PIC || \"Calculate PIC\",\r\n  CalculateDPI: translation.CALCULATE_DPI || \"Calculate DPI\",\r\n  CalculateTVPI: translation.CALCULATE_TVPI || \"Calculate TVPI\",\r\n  CalculateRVPI: translation.CALCULATE_RVPI || \"Calculate RVPI\",\r\n  CalculateMActualAudited:\r\n    translation.CALCULATE_MULTIPLE_ACTUAL_AUDITED ||\r\n    \"Calculate Multiple Actual/Audited\",\r\n  CalculateMReported:\r\n    translation.CALCULATE_MULTIPLE_REPORTED || \"Calculate Multiple Reported\",\r\n  First: translation.FIRST || \"First\",\r\n  Last: translation.LAST || \"Last\",\r\n  Median: translation.MEDIAN || \"Median\",\r\n};\r\n"]}