ConstructionCost/modules/reports/util/rpt_construct_data_util.js

/**
 * Created by Tony on 2017/7/14.
 * 报表数据提取class，是协助报表模板里指标字段自主提取数据的工具类
 */
let JV = require('../rpt_component/jpc_value_define');
let $JE = require('../rpt_component/jpc_rte');
let consts = require('../../../modules/main/models/project_consts');

let fsUtil = require("../../../public/fsUtil");

let treeUtil = require('../../../public/treeUtil');
let projectConst = consts.projectConst;
let projectConstList = consts.projectConstList;

const GLJ_TYPE = {
    Labour: 1,
    Material: 2,
    Machine: 3,
    Main_Material: 4,
    Equipment: 5
};

class Rpt_Common{
    initialize(rpt_tpl, currentDataObj) {
        this.template = rpt_tpl;
        this.currentDataObj = currentDataObj;
    };
    Multiply(val1, val2, fixFormat) {
        let rst = [], maxLen = val1.length, minLen = val2.length;
        if (minLen > maxLen) {
            maxLen = maxLen + minLen; minLen = maxLen - minLen; maxLen = maxLen - minLen;
        }
        for (let i = 0; i < maxLen; i++) {
            let value = ((i < val1.length)?val1[i]:val1[minLen - 1]) * ((i < val2.length)?val2[i]:val2[minLen - 1]);
            if (fixFormat) value = value.toFixed(fixFormat);
            rst.push(value);
        }
        return rst;
    };
    Divide(val1, val2, fixFormat) {
        let rst = [], maxLen = val1.length, minLen = val2.length;
        if (minLen > maxLen) {
            maxLen = maxLen + minLen; minLen = maxLen - minLen; maxLen = maxLen - minLen;
        }
        for (let i = 0; i < maxLen; i++) {
            let value = ((i < val1.length)?val1[i]:val1[minLen - 1]) / ((i < val2.length)?val2[i]:val2[minLen - 1]);
            if (fixFormat) value = value.toFixed(fixFormat);
            rst.push(value);
        }
        return rst;
    };
    Plus(val1, val2, fixFormat) {
        let rst = [], maxLen = val1.length, minLen = val2.length;
        if (minLen > maxLen) {
            maxLen = maxLen + minLen; minLen = maxLen - minLen; maxLen = maxLen - minLen;
        }
        for (let i = 0; i < maxLen; i++) {
            let value = ((i < val1.length)?val1[i]:val1[minLen - 1]) + ((i < val2.length)?val2[i]:val2[minLen - 1]);
            if (fixFormat) value = value.toFixed(fixFormat);
            rst.push(value);
        }
        return rst;
    };
    MultiPlus(arrVal, fixFormat) {
        let rst = [];
        for (let i = 0; i < arrVal.length; i++) {
            let valItem = arrVal[i];
            if (i === 0) {
                for (let dtl of valItem) {
                    let value = parseFloat(dtl);
                    if (fixFormat) value = value.toFixed(fixFormat);
                    rst.push(value);
                }
            } else {
                for (let j = 0; j < valItem.length; j++) {
                    if (j < rst.length) {
                        let value = rst[j] + valItem[j];
                        if (fixFormat) value = value.toFixed(fixFormat);
                        rst[j] = value;
                    } else {
                        let value = parseFloat(valItem[j]);
                        if (fixFormat) value = value.toFixed(fixFormat);
                        rst.push(value);
                    }
                }
            }
        }
        return rst;
    };
    Minus(val1, val2, fixFormat) {
        let rst = [], maxLen = val1.length, minLen = val2.length;
        if (minLen > maxLen) {
            maxLen = maxLen + minLen; minLen = maxLen - minLen; maxLen = maxLen - minLen;
        }
        for (let i = 0; i < maxLen; i++) {
            let value = ((i < val1.length)?val1[i]:val1[minLen - 1]) - ((i < val2.length)?val2[i]:val2[minLen - 1]);
            if (fixFormat) value = value.toFixed(fixFormat);
            rst.push(value);
        }
        return rst;
    };
}

class Rpt_Data_Extractor {
    constructor () {
        this.COMMON = new Rpt_Common();
    };

    initialize(tpl) {
        this.rptTpl = tpl;
    };

    //-- 根据报表模板映射指标(非离散指标)的定义，罗列出所有需要用到的data对象key，作为数据请求的过滤依据
    getDataRequestFilter() {
        let rst = [];
        let tpl = this.rptTpl;
        let pri_func_chk_filter = function (field) {
            for (let key of projectConstList) {
                if (rst.indexOf(key) < 0) {
                    if (field[JV.PROP_FIELD_EXP_MAP]) {
                        if (field[JV.PROP_FIELD_EXP_MAP].indexOf('.' + key + '.') >= 0) {
                            rst.push(key);
                            if (key === projectConst.RATION_GLJ && (rst.indexOf(projectConst.PROJECTGLJ) < 0)) {
                                rst.push(projectConst.PROJECTGLJ);
                            }
                            if (key === projectConst.PROJECTGLJ && (rst.indexOf(projectConst.RATION_GLJ) < 0)) {
                                rst.push(projectConst.RATION_GLJ);
                            }
                        }
                    }
                }
            }
        };
        let pri_setup_filter = function (FIELD_LIST_KEY) {
            if (tpl[JV.NODE_FIELD_MAP][FIELD_LIST_KEY]) {
                for (let field of tpl[JV.NODE_FIELD_MAP][FIELD_LIST_KEY]) {
                    pri_func_chk_filter(field);
                }
            }
        };
        pri_setup_filter(JV.NODE_DISCRETE_FIELDS);
        pri_setup_filter(JV.NODE_MASTER_FIELDS);
        pri_setup_filter(JV.NODE_DETAIL_FIELDS);
        pri_setup_filter(JV.NODE_MASTER_FIELDS_EX);
        pri_setup_filter(JV.NODE_DETAIL_FIELDS_EX);
        if (rst.length === 0) {
            rst.push(projectConst.RATION_ASS);
        }
        return rst;
    };

    //--- 装配数据(把收集到的数据，依据报表模板的指示，预处理(如：排序、过滤、合计)及装配到相关指标) ---//
    assembleData(rawDataObj) {
        let $PROJECT = {"COMMON": null, "MAIN": {}, "DETAIL": {}};
        let tpl = this.rptTpl;
        this.COMMON.initialize(tpl, rawDataObj);
        $PROJECT.COMMON = this.COMMON;
        $PROJECT.MAIN["myOwnRawDataObj"] = rawDataObj.prj._doc;
        $PROJECT.MAIN.getProperty = ext_mainGetPropety;
        $PROJECT.MAIN.getFee = ext_mainGetFee;
        if (tpl[JV.NODE_MAP_DATA_HANDLE_INFO]) {
            for (let preHandle of tpl[JV.NODE_MAP_DATA_HANDLE_INFO]) {
                let srcData = getModuleDataByKey(rawDataObj.prjData, preHandle[JV.PROP_DATA_KEY]);
                switch(preHandle[JV.PROP_HANDLE_TYPE]) {
                    case JV.PROP_HANDLE_TYPE_SORT:
                        sortData(srcData, preHandle, rawDataObj.prjData);
                        break;
                    case JV.PROP_HANDLE_TYPE_FILTER:
                        filterData(srcData, preHandle, rawDataObj.prjData);
                        break;
                    case JV.PROP_HANDLE_TYPE_SUM:
                        summaryData(srcData, preHandle, rawDataObj.prjData);
                        break;
                    case JV.PROP_HANDLE_TYPE_ADD_DUMMY:
                        addDummyData(srcData, preHandle);
                        break;
                    case JV.PROP_HANDLE_TYPE_ADJUST:
                        adjustData(srcData, preHandle);
                        break;
                    default:
                        break;
                }
            }
        }
        for (let item of rawDataObj.prjData) {
            setupFunc($PROJECT.DETAIL, item.moduleName, item);
        }
        let rptDataObj = {};
        rptDataObj[JV.DATA_DISCRETE_DATA] = [];
        rptDataObj[JV.DATA_MASTER_DATA] = [];
        rptDataObj[JV.DATA_DETAIL_DATA] = [];
        rptDataObj[JV.DATA_MASTER_DATA_EX] = [];
        rptDataObj[JV.DATA_DETAIL_DATA_EX] = [];
        assembleFields(tpl[JV.NODE_FIELD_MAP][JV.NODE_DISCRETE_FIELDS], rptDataObj[JV.DATA_DISCRETE_DATA], $PROJECT);
        // console.log(JV.DATA_DISCRETE_DATA);
        // console.log(rptDataObj[JV.DATA_DISCRETE_DATA]);
        assembleFields(tpl[JV.NODE_FIELD_MAP][JV.NODE_MASTER_FIELDS], rptDataObj[JV.DATA_MASTER_DATA], $PROJECT);
        // console.log(JV.DATA_MASTER_DATA);
        // console.log(rptDataObj[JV.DATA_MASTER_DATA]);
        assembleFields(tpl[JV.NODE_FIELD_MAP][JV.NODE_DETAIL_FIELDS], rptDataObj[JV.DATA_DETAIL_DATA], $PROJECT);
        // console.log(JV.DATA_DETAIL_DATA);
        // console.log(rptDataObj[JV.DATA_DETAIL_DATA]);
        assembleFields(tpl[JV.NODE_FIELD_MAP][JV.NODE_MASTER_FIELDS_EX], rptDataObj[JV.DATA_MASTER_DATA_EX], $PROJECT);
        // console.log(JV.DATA_MASTER_DATA_EX);
        // console.log(rptDataObj[JV.DATA_MASTER_DATA_EX]);
        assembleFields(tpl[JV.NODE_FIELD_MAP][JV.NODE_DETAIL_FIELDS_EX], rptDataObj[JV.DATA_DETAIL_DATA_EX], $PROJECT);
        // console.log(JV.DATA_DETAIL_DATA_EX);
        // console.log(rptDataObj[JV.DATA_DETAIL_DATA_EX]);
        return rptDataObj;
    };

}

function getModuleDataByKey(prjData, key) {
    let rst = null;
    for (let item of prjData) {
        if (item.moduleName === key) {
            rst = item;
            break;
        }
    }
    return rst;
}

function summaryData(sourceData, handleCfg, prjData){
    let rstArr = [], tempRstArr = [];
    let curParentPrjData = {};
    for (let item of sourceData.data) {
        if (item._doc) {
            tempRstArr.push(item._doc);
        } else {
            tempRstArr.push(item);
        }
    }
    let private_get_grp_key = function (item) {
        let keys = [];
        for (let cfg of handleCfg[JV.PROP_SUM_GROUP_KEYS]) {
            if (typeof cfg === "string") {
                keys.push(item[cfg]);
            } else {
                if (!curParentPrjData[cfg["seeking_parent"]]) curParentPrjData[cfg["seeking_parent"]] = getModuleDataByKey(prjData, cfg["seeking_parent"]);
                for (let pDataItem of curParentPrjData[cfg["seeking_parent"]].data) {
                    let data = (pDataItem._doc)?pDataItem._doc:pDataItem;
                    if (item[cfg["seeking_key"]] === data[cfg["parent_key"]]) {
                        keys.push(data[cfg["parent_grp_key"]]);
                        break;
                    }
                }
            }
        }
        return ( "grp_key_" + keys.join('_'));
    };
    let sumObj = {};
    for (let dtl of tempRstArr) {
        let grpKey = private_get_grp_key(dtl);
        if (sumObj[grpKey] === null || sumObj[grpKey] === undefined) {
            sumObj[grpKey] = dtl;
            rstArr.push(dtl);
        } else {
            for (let sumKey of handleCfg[JV.PROP_SUM_SUM_KEYS]) {
                if (dtl[sumKey]) {
                    // sumObj[grpKey][sumKey] += dtl[sumKey];
                    sumObj[grpKey][sumKey] = parseFloat(sumObj[grpKey][sumKey]) + parseFloat(dtl[sumKey]);
                }
            }
        }
    }
    delete sourceData.data;
    sourceData.data = rstArr;
    // fsUtil.writeObjToFile(sourceData.data, "D:/GitHome/ConstructionCost/tmp/sumRst.js");
}

function filterData(sourceData, handleCfg, prjData) {
    let rstArr = [], tempRstArr = [];
    for (let item of sourceData.data) {
        if (item._doc) {
            tempRstArr.push(item._doc);
        } else {
            tempRstArr.push(item);
        }
    }
    let private_chkVal = function (src, dest, compStr) {
        let rst = true;
        switch (compStr) {
            case "==" :
                rst = (src == dest);
                break;
            case "===" :
                rst = (src === dest);
                break;
            case ">" :
                rst = (src > dest);
                break;
            case ">=" :
                rst = (src >= dest);
                break;
            case "<" :
                rst = (src < dest);
                break;
            case "<=" :
                rst = (src <= dest);
                break;
            case "!=" :
                rst = (src != dest);
                break;
            case "!==" :
                rst = (src !== dest);
                break;
            default:
                rst = true;
        }
        return rst;
    };
    for (let item of tempRstArr) {
        let compRst = true;
        let curComparePrjData = null;
        for (let cfg of handleCfg[JV.PROP_FILTER_KEY]) {
            if (cfg[JV.PROP_FILTER_COMPARE_VAL]) {
                //比较key值
                compRst = private_chkVal(item[cfg.key], cfg[JV.PROP_FILTER_COMPARE_VAL], cfg[JV.PROP_FILTER_CONDITION]);
            } else if (cfg[JV.PROP_FILTER_COMPARE_OBJ] && cfg[JV.PROP_FILTER_COMPARE_OBJ_KEY]){
                //通过其他对象来过滤
                if (!curComparePrjData) {
                    curComparePrjData = getModuleDataByKey(prjData, cfg[JV.PROP_FILTER_COMPARE_OBJ]);
                }
                for (let data of curComparePrjData.data) {
                    compRst = private_chkVal(item[cfg.key], data[cfg[JV.PROP_FILTER_COMPARE_OBJ_KEY]], cfg[JV.PROP_FILTER_CONDITION]);
                    if (compRst) break;
                }
            }
        }
        if (compRst) {
            rstArr.push(item);
        }
    }
    delete sourceData.data;
    sourceData.data = rstArr;
    // fsUtil.writeObjToFile(sourceData.data, "D:/GitHome/ConstructionCost/tmp/filteredRst.js");
}

function adjustData(sourceData, adjustCfg) {
    let rstArr = [];
    for (let item of sourceData.data) {
        if (item._doc) {
            rstArr.push(item._doc);
        } else {
            rstArr.push(item);
        }
    }
    for (let item of adjustCfg[JV.PROP_ADJUST_COLLECTION]) {
        for (let rec of rstArr) {
            if (item[JV.PROP_ADJUST_ACTION] === "prefix") {
                rec[item.key] = item[JV.PROP_ADJUST_ACTION_VAL] + rec[item.key];
            } else if (item[JV.PROP_ADJUST_ACTION] === "suffix") {
                rec[item.key] = rec[item.key] + item[JV.PROP_ADJUST_ACTION_VAL];
            }
        }
    }
    delete sourceData.data;
    sourceData.data = rstArr;
}

function getDupGrpKeyVals(sourceData, segKeys) {
    let rst = [];
    function pushKeyVal(item) {
        let tr = {};
        for (let i = 0; i < segKeys.length; i++) {
            tr[segKeys[i]] = item[segKeys[i]];
        }
        rst.push(tr);
    }
    for (let idx = 0; idx < sourceData.length; idx++) {
        let itemRec = sourceData[idx];
        if (idx === 0) {
            pushKeyVal(itemRec);
            continue;
        }
        let hasDiff = false;
        for (let i = 0; i < segKeys.length; i++) {
            if (itemRec[segKeys[i]] !== sourceData[idx - 1][segKeys[i]]) {
                hasDiff = true;
                break;
            }
        }
        if (hasDiff) {
            pushKeyVal(itemRec);
        }
    }
    return rst;
}

function addDummyData(sourceData, addCfg) {
    let rstArr = [], tempRstArr = [];
    for (let item of sourceData.data) {
        if (item._doc) {
            tempRstArr.push(item._doc);
        } else {
            tempRstArr.push(item);
        }
    }
    for (let item of addCfg[JV.PROP_DUMMY_COLLECTION]) {
        let newRecStr = JSON.stringify(item[JV.PROP_DUMMY_VAL]), cacheGrpKeyRecs = null;
        if (item[JV.PROP_FREQUENCY] === "OncePerGrp") {
            if (!cacheGrpKeyRecs) {
                cacheGrpKeyRecs = {};
            }
            let cacheKey = "";
            for (let key of item[JV.PROP_GRP_KEYS]) {
                cacheKey += "_" + key;
            }
            if (!cacheGrpKeyRecs[cacheKey]) {
                cacheGrpKeyRecs[cacheKey] = getDupGrpKeyVals(tempRstArr, item[JV.PROP_GRP_KEYS]);
            }
            for (let kv of cacheGrpKeyRecs[cacheKey]) {
                let rec = JSON.parse(newRecStr);
                for (let key of item[JV.PROP_GRP_KEYS]) {
                    rec[key] = kv[key];
                }
                rstArr.push(rec);
            }

        } else if (item[JV.PROP_FREQUENCY] === "Once") {
            rstArr.push(JSON.parse(newRecStr));
        }
    }
    rstArr = rstArr.concat(tempRstArr);
    delete sourceData.data;
    sourceData.data = rstArr;
}

function getGLJBizType(orgType, orgCode, orgName) {
    let rst = orgType;
    if (orgName.indexOf("其他材料费") >= 0) {
        rst = 299;
    } else if (orgType === GLJ_TYPE.Labour) {
        rst = 11;
        if (orgCode === "000000") rst = 10;
    } else if (orgType === GLJ_TYPE.Main_Material || orgType === GLJ_TYPE.Equipment) {
        //未计价材料(主材 + 设备)
        rst = 30 + orgType;
    } else if (orgType === GLJ_TYPE.Material || (orgType >= 200 && orgType < 300)) {
        //材料
        if (orgCode === "000000") {
            rst = 20; //2.材料
        } else if (orgCode === "000000_1") {
            rst = 30; //(1) 未计价材料
        } else if (orgCode === "000000_2") {
            rst = 40; //(2) 辅助材料
        } else if (orgCode === "000000_3") {
            rst = 50; //(3) 其他材料费
        } else {
            rst = 45; //到这里就只有辅助材料没有预处理了
        }
    } else if (orgType === GLJ_TYPE.Machine || (orgType >= 300 && orgType < 400)) {
        //机械
        if (orgCode === "000000") {
            rst = 300; //3.机械
        } else if (orgType === GLJ_TYPE.Machine) {
            rst = 300.5;
        } else {
            rst = orgType;
        }
    }
    return rst;
}

function sortData(sourceData, sortCfg, prjData) {
    let rst = sourceData.data, tempRstArr = [];
    let sortType = sortCfg[JV.PROP_SORT_TYPE];
    for (let item of sourceData.data) {
        if (item._doc) {
            tempRstArr.push(item._doc);
        } else {
            tempRstArr.push(item);
        }
    }
    function private_normal_sort(destArr, sortKeys) {
        destArr.sort(function(a, b){
            let compRst = 0;
            for (let comp of sortKeys) {
                let reverse = (comp.order === 'ascend')?1:(-1);
                //
                if (a[comp.key] > b[comp.key]) {
                    compRst = reverse;
                    break;
                } else if (a[comp.key] < b[comp.key]) {
                    compRst = -reverse;
                    break;
                }
            }
            return compRst;
        });
    }
    function private_parent_sort(parentArr, parentKeys, childArr, childKeys) {
        let tmpRst = {}, rst = [];
        for (let pItem of parentArr) {
            let pKey = "key";
            for (let key of parentKeys) {
                pKey += "_" + pItem[key];
            }
            tmpRst[pKey] = [];
        }
        for (let cItem of childArr) {
            let cKey = "key";
            for (let key of childKeys) {
                cKey += "_" + cItem[key];
            }
            if (tmpRst[cKey]) {
                tmpRst[cKey].push(cItem);
            } else {
                //unknown child value! should be filtered!
            }
        }
        // childArr.splice(0);
        for (let pItem of parentArr) {
            let pKey = "key";
            for (let key of parentKeys) {
                pKey += "_" + pItem[key];
            }
            rst.push(tmpRst[pKey]);
            // for (let rItem of tmpRst[pKey]) {
            //     childArr.push(rItem);
            // }
        }
        return rst;
    }
    switch (sortType) {
        case "tree":
            rst = treeUtil.buildTreeNodeDirectly(tempRstArr);
            let destArr = [];
            treeUtil.getFlatArray(rst, destArr);
            delete sourceData.data;
            sourceData.data = destArr;
            // fsUtil.writeObjToFile(sourceData.data, "D:/GitHome/ConstructionCost/tmp/sortedAndFlattedRst.js");
            break;
        case "normal":
            private_normal_sort(tempRstArr, sortCfg[JV.PROP_SORT_KEYS]);
            delete sourceData.data;
            sourceData.data = tempRstArr;
            // fsUtil.writeObjToFile(sourceData.data, "D:/GitHome/ConstructionCost/tmp/normalSortedRst.js");
            break;
        case "accord_to_parent":
            let pcKey = sortCfg[JV.PROP_PARENT_CHILD_SORT_KEY];
            let parentSrcData = getModuleDataByKey(prjData, pcKey[JV.PROP_PARENT_DATA_KEY]);
            if (parentSrcData) {
                let tempParentArr = [];
                for (let item of parentSrcData.data) {
                    if (item._doc) {
                        tempParentArr.push(item._doc);
                    } else {
                        tempParentArr.push(item);
                    }
                }
                let sortedRstArr = private_parent_sort(tempParentArr, pcKey[JV.PROP_PARENT_SORT_KEYS], tempRstArr, pcKey[JV.PROP_CHILD_SORT_KEYS]);
                if (sortCfg[JV.PROP_OTHER_SUB_SORT] && sortCfg[JV.PROP_OTHER_SUB_SORT].length > 0) {
                    for (let sort of sortCfg[JV.PROP_OTHER_SUB_SORT]) {
                        if (sort[JV.PROP_SORT_TYPE] === 'normal') {
                            for (let subArr of sortedRstArr) {
                                private_normal_sort(subArr, sort[JV.PROP_SORT_KEYS]);
                            }
                        } else if (sort[JV.PROP_SORT_TYPE] === 'self_define') {
                            for (let subArr of sortedRstArr) {
                                // console.log(subArr);
                                let selfDefFunc = null;
                                eval('selfDefFunc = ' + sort[JV.PROP_SORT_TYPE_SELF_DEFINE_LOGIC]);
                                subArr.sort(selfDefFunc);
                                // console.log(subArr);
                            }
                        }
                    }
                }
                tempRstArr.splice(0);
                for (let item of sortedRstArr) {
                    for (let subItem of item) {
                        tempRstArr.push(subItem);
                    }
                }
            }
            delete sourceData.data;
            sourceData.data = tempRstArr;
            break;
        case "self_define":
            if (sortCfg[JV.PROP_SORT_TYPE_SELF_DEFINE_LOGIC]) {
                let selfDefFunc = null;
                eval('selfDefFunc = ' + sortCfg[JV.PROP_SORT_TYPE_SELF_DEFINE_LOGIC]);
                tempRstArr.sort(selfDefFunc);
            }
            delete sourceData.data;
            sourceData.data = tempRstArr;
            break;
        default:
            //
    }
    return rst;
}

function setupFunc(obj, prop, ownRawObj) {
    obj[prop] = {};
    obj[prop]["myOwnRawDataObj"] = ownRawObj;
    obj[prop].getProperty = ext_getPropety;
    obj[prop].getFee = ext_getFee;
    obj[prop].getPropertyByForeignId = ext_getPropertyByForeignId;
    obj[prop].getArrayItemByKey = ext_getArrayItemByKey;
    if (prop === projectConst.CALC_PROGRAM) obj[prop].getCalcProperty = ext_getCalcProperty;
    if (prop === projectConst.FEERATE) obj[prop].getFeeRate = ext_getFeeRate;
}

function assembleFields(fieldList, rstDataArr, $PROJECT) {
    if (fieldList) {
        for (let field of fieldList) {
            shielded_exec_env($PROJECT, field, rstDataArr);
        }
    }
}

function shielded_exec_env($PROJECT, $ME, rptDataItemObj) {
    if ($ME[JV.PROP_FIELD_EXP_MAP]) {
        rptDataItemObj.push(eval($ME[JV.PROP_FIELD_EXP_MAP]));
    }
}

function getActPropertyVal(firstPropKey, secPropKey, orgObj) {
    let rst = null;
    if (orgObj[firstPropKey]) {
        rst = orgObj[firstPropKey];
    } else if (orgObj[secPropKey]){
        rst = orgObj[secPropKey];
    }
    return rst;
}

function getDeepProperty(propKey, orgObj, destArr) {
    let keys = propKey.split(".");
    let dftPropKey = "key", dftPropVal = "value", secDftPropVal = "items";
    let parent = orgObj, lastVal = null;
    for (let key of keys) {
        if (parent instanceof Array) {
            for (let item of parent) {
                if (item[dftPropKey] === key) {
                    lastVal = getActPropertyVal(dftPropVal, secDftPropVal, item);
                    break;
                }
            }
        } else {
            lastVal = null;
            if (parent[key] !== undefined) {
                lastVal = parent[key];
            } else if (parent[secDftPropVal]){
                for (let item of parent[secDftPropVal]) {
                    if (item[dftPropKey] === key) {
                        // lastVal = item[dftPropVal];
                        lastVal = getActPropertyVal(dftPropVal, secDftPropVal, item);
                        break;
                    }
                }
            }
        }
        parent = lastVal;
        if (parent === null) break;
    }
    if (destArr && destArr instanceof Array) {
        destArr.push(lastVal);
    }
}

function ext_mainGetPropety(propKey) {
    let rst = [], parentObj = this;
    let dtObj = parentObj["myOwnRawDataObj"];
    if (propKey && dtObj) {
        if (dtObj.hasOwnProperty("property")) {
            if (!dtObj["property"][propKey] && dtObj[propKey]) {
                rst.push(dtObj[propKey]);
            } else {
                getDeepProperty(propKey, dtObj["property"], rst);
            }
        } else  {
            // rst.push(dtObj[propKey]);
            getDeepProperty(propKey, dtObj, rst);
        }
    }
    return rst;
}

function ext_getPropety(propKey) {
    let rst = [], parentObj = this;
    let dtObj = parentObj["myOwnRawDataObj"];
    if (propKey && dtObj) {
        for (let dItem of dtObj.data) {
            let doc = (dItem._doc === null || dItem._doc === undefined)?dItem:dItem._doc;
            if (doc.hasOwnProperty("property")) {
                // if (!doc["property"][propKey] && doc[propKey]) {
                //     rst.push(doc[propKey]);
                // } else {
                //     getDeepProperty(propKey, doc["property"], rst);
                // }
                rst.push(doc["property"][propKey]);
            } else if (doc.hasOwnProperty(propKey)) {
                rst.push(doc[propKey]);
            } else {
                rst.push('');
            }
        }
    }
    return rst;
}

function ext_mainGetFee(feeKey, dtlFeeKey) {
    let rst = [];
    let parentObj = this;
    let dtObj = parentObj["myOwnRawDataObj"];
    if ((dtObj) && (feeKey)) {
        if (dtObj.hasOwnProperty("fees")) {
            for (let fee of dtObj["fees"]) {
                if (fee["fieldName"] === feeKey) {
                    if (dtlFeeKey) {
                        rst.push(fee[dtlFeeKey]);
                    } else {
                        rst.push(fee["unitFee"]);
                    }
                    break;
                }
            }
        } else if (dtObj.hasOwnProperty(feeKey)) {
            rst.push(dtObj[feeKey]);
        } else {
            //
        }
    }
    return rst;
}

function ext_getFee(feeKey, dtlFeeKey) {
    let rst = [], parentObj = this;
    let dtObj = parentObj["myOwnRawDataObj"];
    if (feeKey && dtObj) {
        for (let dItem of dtObj.data) {
            let hasValue = false;
            if (dItem.hasOwnProperty("fees")) {
                for (let fee of dItem["fees"]) {
                    if (fee["fieldName"] === feeKey) {
                        if (dtlFeeKey) {
                            rst.push(fee[dtlFeeKey]);
                        } else {
                            rst.push(fee["unitFee"]);
                        }
                        hasValue = true;
                        break;
                    }
                }
            } else if (dItem.hasOwnProperty(feeKey)) {
                hasValue = true;
                rst.push(dItem[feeKey]);
            } else {
                hasValue = true;
                rst.push(0);
            }
            if (!hasValue) {
                rst.push(0);
            }
        }
    }
    for (let i = 0; i < rst.length; i++) {
        rst[i] = parseFloat(rst[i]);
    }
    return rst;
}

function ext_getCalcProperty(templateIDs, calcItemKey, calcItemKeyVal, calcItemRstKey){
    let rst = [], parentObj = this; //this should be "calc_program" object
    let dtObj = parentObj["myOwnRawDataObj"];
    let optimizeObj = {};
    let private_getProperty = function (cId) {
        let calcTplObj = optimizeObj["calc_program_" + cId];
        if (!calcTplObj) {
            let templates = (dtObj.data._doc)?dtObj.data._doc.templates:dtObj.data.templates;
            for (let tpl of templates) {
                if (cId === tpl.ID) {
                    optimizeObj["calc_program_" + cId] = tpl;
                    calcTplObj = tpl;
                    break;
                }
            }
        }
        if (calcTplObj) {
            for (let calcItem of calcTplObj.calcItems) {
                if (calcItem[calcItemKey] === calcItemKeyVal) {
                    rst.push(calcItem[calcItemRstKey]);
                    break;
                }
            }
        }
    };
    if (templateIDs instanceof Array) {
        for (let tplId of templateIDs) {
            private_getProperty(tplId);
        }
    } else {
        private_getProperty(templateIDs);
    }
    optimizeObj = null;
    return rst;
}

function ext_getFeeRate(fee_Ids){
    let rst = [], parentObj = this; //this should be "feeRate" object
    let dtObj = parentObj["myOwnRawDataObj"];
    let optimizeObj = {};
    let private_getFeeRate = function (fId) {
        let feeRateItemObj = optimizeObj["fee_rates_" + fId];
        if (!feeRateItemObj) {
            let rates = (dtObj.data._doc)?dtObj.data._doc.rates:dtObj.data.rates;
            for (let feeItem of rates) {
                if (fId === feeItem.ID) {
                    optimizeObj["fee_rates_" + fId] = feeItem;
                    feeRateItemObj = feeItem;
                    break;
                }
            }
        }
        if (feeRateItemObj) {
            rst.push(feeRateItemObj.rate);
        } else {
            rst.push(0);
        }
    };
    if (fee_Ids instanceof Array) {
        for (let fId of fee_Ids) {
            private_getFeeRate(fId);
        }
    } else {
        private_getFeeRate(fee_Ids);
    }
    optimizeObj = null;
    return rst;
}

function ext_getArrayItemByKey(arrayKey, itemKey, itemKeyValue, itemRstKey){
    let rst = [], parentObj = this;
    let dtObj = parentObj["myOwnRawDataObj"];
    let private_getItemValue = function (arr, dtlItKV) {
        for (let item of arr) {
            if (item[itemKey] === dtlItKV) {
                if (itemRstKey) {
                    rst.push(item[itemRstKey]);
                } else {
                    rst.push(item);
                }
                break;
            }
        }
    };
    let arr = dtObj[arrayKey];
    if (arr && arr instanceof Array) {
        if (itemKeyValue instanceof Array) {
            for (let dtlItemKeyVal of itemKeyValue) {
                private_getItemValue(arr, dtlItemKeyVal);
            }
        } else {
            private_getItemValue(arr, itemKeyValue);
        }
    }

}

function ext_getPropertyByForeignId(foreignIdVal, adHocIdKey, propKey, dftValIfNotFound) {
    let rst = [], parentObj = this;
    let IdKey = (adHocIdKey)?adHocIdKey:"ID";
    let dtObj = parentObj["myOwnRawDataObj"];
    if (foreignIdVal !== null && foreignIdVal !== undefined) {
        let isFound = false;
        if (foreignIdVal instanceof Array) {
            for (let idVal of foreignIdVal) {
                isFound = false;
                for (let i = 0; i < dtObj.data.length; i++) {
                    let item = (dtObj.data[i]._doc)?dtObj.data[i]._doc:dtObj.data[i];
                    if (item[IdKey] === idVal) {
                        let splitPKey = propKey.split(".");
                        if (splitPKey.length > 1) {
                            let rstP = null;
                            for (let i = 0; i < splitPKey.length; i++) {
                                if (i === 0) {
                                    rstP = item[splitPKey[i]];
                                } else {
                                    if (splitPKey[i].indexOf("[") === 0 && splitPKey[i].indexOf("]") === (splitPKey[i].length - 1)) {
                                        //考虑数组情况^_^!!!
                                    } else {
                                        //
                                    }
                                    rstP = rstP[splitPKey[i]];
                                }
                            }
                            rst.push(rstP);
                        } else {
                            rst.push(item[propKey]);
                        }
                        isFound = true;
                        break;
                    }
                }
                if (!isFound) {
                    rst.push(dftValIfNotFound);
                }
            }
        } else {
            for (let item of dtObj.data) {
                if (item[IdKey] === foreignIdVal) {
                    rst.push(item[propKey]);
                    isFound = true;
                    break;
                }
            }
            if (!isFound) {
                rst.push(dftValIfNotFound);
            }
        }
    }
    return rst;
}

export default Rpt_Data_Extractor;