Calculation/app/public/js/gcl_gather.js

'use strict';

/**
 *
 * 清单汇总（需使用 decimal.min.js, zh_calc.js, path_tree.js, lodash.js）
 *
 * @author Mai
 * @date
 * @version
 */

const gclGatherModel = (function () {
    // 需要汇总计算的字段
    let ledgerGatherFields = ['quantity', 'total_price', 'deal_qty', 'deal_tp',
        'contract_qty', 'contract_tp', 'qc_qty', 'qc_tp', 'qc_minus_qty',
        'pre_contract_qty', 'pre_contract_tp', 'pre_qc_qty', 'pre_qc_tp', 'pre_qc_minus_qty',
        'end_contract_qty', 'end_contract_tp', 'end_qc_qty', 'end_qc_tp', 'end_qc_minus_qty'];
    let posGatherFields = ['quantity', 'contract_qty', 'qc_qty', 'gather_qty','qc_minus_qty',
        'pre_contract_qty', 'pre_qc_qty', 'pre_gather_qty', 'pre_qc_minus_qty',
        'end_contract_qty', 'end_qc_qty', 'end_gather_qty', 'end_qc_minus_qty'];
    // 初始化 清单树
    const gsTreeSetting = {
        id: 'ledger_id',
        pid: 'ledger_pid',
        order: 'order',
        level: 'level',
        rootId: -1,
        keys: ['id', 'tender_id', 'ledger_id'],
        stageId: 'id',
    };
    gsTreeSetting.updateFields = ['contract_qty', 'contract_tp', 'qc_qty', 'qc_tp', 'qc_minus_qty'];
    const gsTree = createNewPathTree('stage', gsTreeSetting);
    // 初始化 部位明细
    const posSetting = {
        id: 'id', ledgerId: 'lid',
        updateFields: ['contract_qty', 'qc_qty', 'qc_minus_qty'],
    };
    const gsPos = new StagePosData(posSetting);
    let deal = [], change;

    const gclList = [], leafXmjs = [];
    const mergeChar = ';';
    let tpDecimal = 0;

    function loadDecimal(decimal) {
        tpDecimal = decimal.tp;
    }

    function loadGatherField(ledger, pos) {
        if (ledger) ledgerGatherFields = ledger;
        if (pos) posGatherFields = pos;
    }

    /**
     * 将所有数据加载至树结构
     *
     * @param ledger - 台账数据
     * @param curStage - 当期计量数据
     * @param preStage - 截止上期计量数据
     * @param bgl - 变更令数据
     */
    function loadLedgerData (ledger, curStage, preStage) {
        // 加载树结构数据
        gsTree.loadDatas(ledger);
        // 加载本期计量数据
        if (curStage) {
            gsTree.loadCurStageData(curStage);
        }
        if (preStage) {
            gsTree.loadPreStageData(preStage);
        }
    }

    function loadPosData(pos, curPos, prePos) {
        gsPos.loadDatas(pos);
        gsPos.loadCurStageData(curPos);
        gsPos.loadPreStageData(prePos);
    }

    function loadDealBillsData(dealBills) {
        deal = dealBills;
    }

    function loadChangeBillsData(data) {
        change = data;
    }

    function gatherfields(obj, src, fields) {
        if (obj && src) {
            if (fields instanceof Array) {
                for (const f of fields) {
                    obj[f] = ZhCalc.add(obj[f], src[f]);
                }
            } else if (typeof fields === "function") {
                for (const prop in src) {
                    if (fields(prop)) {
                        obj[prop] = ZhCalc.add(obj[prop], src[prop]);
                    }
                }
            }
        }
    }

    /**
     * 新建 清单汇总节点
     * @param node - 最底层 工程量清单节点
     * @returns {{b_code: *|string[], name, unit, unit_price: *|string[], leafXmjs: Array}}
     */
    function newGclNode(node) {
        const gcl = {
            b_code: node.b_code,
            name: node.name,
            unit: node.unit,
            unit_price: node.unit_price,
            leafXmjs: [],
        };
        gclList.push(gcl);
        return gcl;
    }

    /**
     * 获取清单汇总节点
     *
     * @param node - 最底层清单节点
     * @returns {*}
     */
    function getGclNode(node) {
        const gcl = gclList.find(function (g) {
            return g.b_code === node.b_code &&
                (g.name || node.name ? g.name === node.name : true) &&
                (g.unit || node.unit ? g.unit === node.unit : true) &&
                checkZero(ZhCalc.sub(g.unit_price, node.unit_price));
        });
        if (gcl) {
            return gcl
        } else {
            return newGclNode(node);
        }
    }

    /**
     * 检查 text 是否是Peg
     * e.g. K123+000(true) Kab+123(false) K123.234+234(false) K12+324.234(true)
     *
     * @param text
     * @returns {*}
     * @constructor
     */
    function CheckPeg(text) {
        const pegReg = /[a-zA-Z]*[kK][0-9]+[+＋][0-9]{3}([.][0-9]+)?/;
        return pegReg.test(text);
    }

    /**
     * 获取 桩号节点
     * @param node - 检索起始节点
     * @returns {*}
     */
    function getPegNode (node) {
        if (node) {
            if (CheckPeg(node.name)) {
                return node;
            } else {
                const parent = gsTree.getParent(node);
                return parent ? getPegNode(parent) : null;
            }
        }
    }

    /**
     * 获取节点的第N层父节点
     *
     * @param node - 节点(检索起点)
     * @param level - 第N层
     * @returns {*}
     */
    function getNodeByLevel(node, level) {
        let cur = node;
        while (cur && cur.level > level) {
            cur = gsTree.getParent(cur);
        }
        return cur;
    }

    /**
     * 获取 单位工程
     *
     * @param xmj - 计量单元(最底层项目节)
     * @returns {string}
     */
    function getDwgc(peg, xmj) {
        if (peg) {
            return peg.name;
        } else {
            const node = getNodeByLevel(xmj, 2);
            return node ? node.name : '';
        }
    }

    /**
     * 获取 分部工程
     *
     * @param peg - 桩号节点
     * @param xmj - 计量单元(最底层项目节)
     * @returns {string}
     */
    function getFbgc(peg, xmj) {
        if (peg && peg.id !== xmj.id) {
            const node = getNodeByLevel(xmj, peg.level + 1);
            return node ? node.name : '';
        } else {
            const node = getNodeByLevel(xmj, 3);
            return node ? node.name : '';
        }
    }

    /**
     * 获取 分项工程
     *
     * @param peg - 桩号节点
     * @param xmj - 计量单元(最底层项目节)
     * @returns {string}
     */
    function getFxgc(peg, xmj) {
        if (!peg) {
            const node = getNodeByLevel(xmj, 4);
            return node ? node.name : '';
        } else if (peg.id === xmj.id) {
            if (xmj.level > 4) {
                let value = '';
                for (let level = 4; level < xmj.level; level++) {
                    const node = getNodeByLevel(xmj, level);
                    value = value === '' ? node.name : value + mergeChar + node.name;
                }
                return value;
            } else {
                return '';
            }
        } else {
            if (peg.level + 2 < xmj.level) {
                let value = '';
                for (let level = peg.level + 2; level < xmj.level; level++) {
                    const node = getNodeByLevel(xmj, level);
                    value = value === '' ? node.name : value + mergeChar + node.name;
                }
                return value;
            } else {
                return '';
            }
        }
    }

    /**
     * 新建 最底层项目节 缓存数据
     * @param leafXmj
     * @returns {{id, code: *|string[], jldy, fbgc: string, fxgc: string, dwgc: string, bwmx: string, drawing_code: string}}
     */
    function newCacheLeafXmj(leafXmj) {
        const peg = getPegNode(leafXmj);
        const cacheLX = {
            id: leafXmj.id,
            code: leafXmj.code,
            jldy: leafXmj.name,
            fbgc: getFbgc(peg, leafXmj),
            fxgc: getFxgc(peg, leafXmj),
            dwgc: getDwgc(peg, leafXmj),
            drawing_code: leafXmj.drawing_code,
        };
        leafXmjs.push(cacheLX);
        return cacheLX;
    }

    /**
     * 获取缓存的最底层项目节数据
     *
     * @param leafXmj - 最底层项目节
     * @returns {*}
     */
    function getCacheLeafXmj(leafXmj) {
        const cacheLX = leafXmjs.find(function (lx) {
            return lx.id === leafXmj.id;
        });
        if (!cacheLX) {
            return newCacheLeafXmj(leafXmj);
        } else {
            return cacheLX;
        }
    }

    /**
     * 汇总节点
     * @param node - 最底层 工程量清单 节点
     * @param leafXmj - 所属 最底层 项目节
     */
    function loadGatherGclNode(node, leafXmj) {
        const gcl = getGclNode(node);
        gatherfields(gcl, node, ledgerGatherFields);
        const cacheLeafXmj = getCacheLeafXmj(leafXmj);
        const posRange = gsPos.getLedgerPos(node.id);
        const detail = posRange && posRange.length > 0 ? posRange : [node];
        for (const d of detail) {
            const dx = _.assign({}, cacheLeafXmj);
            gatherfields(dx, d, posGatherFields);
            dx.gcl_id = node.id;
            if (d.name !== node.name) {
                dx.bwmx = d.name;
                dx.mx_id = d.id;
            }
            if (d.drawing_code) {
                dx.drawing_code = d.drawing_code;
            }
            gcl.leafXmjs.push(dx);
        }
    }

    /**
     * （递归）汇总树节点
     * @param nodes - 汇总节点列表
     * @param leafXmj - 汇总节点所属的底层项目节
     */
    function recursiveGatherGclData(nodes, leafXmj) {
        for (const node of nodes) {
            if (node.b_code) {
                if (node.children.length > 0) {
                    const gcl = getGclNode(node);
                    recursiveGatherGclData(node.children, leafXmj);
                } else {
                    loadGatherGclNode(node, leafXmj);
                }
            } else if (node.children.length > 0) {
                recursiveGatherGclData(node.children, node);
            }
        }
    }

    function gatherDealBillsData() {
        if (deal && deal.length > 0) {
            for (const node of deal) {
                node.b_code = node.code;
                const gcl = getGclNode(node);
                if (!node.quantity || !node.unit_price) continue;
                gcl.deal_bills_qty = ZhCalc.add(gcl.deal_bills_qty, node.quantity);
                gcl.deal_bills_tp = ZhCalc.add(gcl.deal_bills_tp, node.total_price);
            }
        }
    }

    function gatherChangeBillsData() {
        if (change && change.length > 0) {
            for (const node of change) {
                node.b_code = node.code;
                node.quantity = parseFloat(node.samount);
                node.total_price = ZhCalc.mul(node.quantity, node.unit_price, node.tp_decimal || tpDecimal);
                const gcl = getGclNode(node);
                gcl.change_bills_qty = ZhCalc.add(gcl.change_bills_qty, node.quantity);
                gcl.change_bills_tp = ZhCalc.add(gcl.change_bills_tp, node.total_price);
            }
        }
    }

    function calculateGatherData() {
        for (const gcl of gclList) {
            gcl.pre_gather_qty = ZhCalc.add(gcl.pre_contract_qty, gcl.pre_qc_qty);
            gcl.pre_gather_tp = ZhCalc.add(gcl.pre_contract_tp, gcl.pre_qc_tp);
            gcl.gather_qty = ZhCalc.add(gcl.contract_qty, gcl.qc_qty);
            gcl.end_contract_qty = ZhCalc.add(gcl.pre_contract_qty, gcl.contract_qty);
            gcl.end_qc_qty = ZhCalc.add(gcl.pre_qc_qty, gcl.qc_qty);
            gcl.end_gather_qty = ZhCalc.add(gcl.pre_gather_qty, gcl.gather_qty);
            gcl.gather_tp = ZhCalc.add(gcl.contract_tp, gcl.qc_tp);
            gcl.end_qc_minus_qty = ZhCalc.add(gcl.pre_qc_minus_qty, gcl.qc_minus_qty);

            gcl.end_contract_tp = ZhCalc.add(gcl.pre_contract_tp, gcl.contract_tp);
            gcl.end_qc_tp = ZhCalc.add(gcl.pre_qc_tp, gcl.qc_tp);
            gcl.end_gather_tp = ZhCalc.add(gcl.pre_gather_tp, gcl.gather_tp);
            gcl.dgn_price = ZhCalc.round(ZhCalc.div(gcl.total_price, gcl.dgn_qty1), 2);
            gcl.end_final_qty = ZhCalc.add(gcl.end_qc_qty, gcl.quantity);
            gcl.end_final_tp = ZhCalc.add(gcl.end_qc_tp, gcl.total_price);
            gcl.final_qty = ZhCalc.add(gcl.quantity, gcl.change_bills_qty);
            gcl.final_tp = ZhCalc.add(gcl.total_price, gcl.change_bills_tp);
            gcl.deal_final_qty = ZhCalc.add(gcl.deal_bills_qty, gcl.change_bills_qty);
            gcl.deal_final_tp = ZhCalc.add(gcl.deal_bills_tp, gcl.change_bills_tp);
            gcl.final_1_qty = ZhCalc.add(gcl.quantity, gcl.end_qc_minus_qty);
            gcl.final_1_tp = ZhCalc.mul(gcl.unit_price, gcl.final_1_qty, tpDecimal);
            gcl.deal_final_1_qty = ZhCalc.add(gcl.deal_bills_qty, gcl.end_qc_minus_qty);
            gcl.deal_final_1_tp = ZhCalc.add(gcl.unit_price, gcl.deal_final_1_qty, tpDecimal);
            gcl.end_final_1_qty = ZhCalc.add(gcl.final_1_qty, gcl.end_qc_qty);
            gcl.end_final_1_tp = ZhCalc.add(gcl.final_1_tp, gcl.end_qc_tp);

            gcl.end_gather_percent = gcl.end_gather_qty && gcl.end_final_qty
                ? ZhCalc.mul(ZhCalc.div(gcl.end_gather_qty, gcl.end_final_qty), 100, 2)
                : ZhCalc.mul(ZhCalc.div(gcl.end_gather_tp, gcl.end_final_tp), 100, 2);
            gcl.end_final_1_percent = gcl.end_gather_qty && gcl.end_final_1_qty
                ? ZhCalc.mul(ZhCalc.div(gcl.end_gather_qty, gcl.end_final_1_qty), 100, 2)
                : ZhCalc.mul(ZhCalc.div(gcl.end_gather_tp, gcl.end_final_1_tp), 100, 2);
            gcl.final_percent = gcl.final_qty && gcl.end_gather_qty
                ? ZhCalc.mul(ZhCalc.div(gcl.end_gather_qty, gcl.final_qty), 100, 2)
                : ZhCalc.mul(ZhCalc.div(gcl.end_gather_tp, gcl.final_tp), 100, 2);
            for (const xmj of gcl.leafXmjs) {
                xmj.pre_gather_qty = ZhCalc.add(xmj.pre_contract_qty, xmj.pre_qc_qty);
                xmj.gather_qty = ZhCalc.add(xmj.contract_qty, xmj.qc_qty);
                xmj.end_contract_qty = ZhCalc.add(xmj.pre_contract_qty, xmj.contract_qty);
                xmj.end_qc_qty = ZhCalc.add(xmj.pre_qc_qty, xmj.qc_qty);
                xmj.end_gather_qty = ZhCalc.add(xmj.pre_gather_qty, xmj.gather_qty);
                xmj.end_final_qty = ZhCalc.add(xmj.end_qc_qty, xmj.quantity);
                xmj.end_qc_minus_qty = ZhCalc.add(xmj.pre_qc_minus_qty, xmj.qc_minus_qty);
                xmj.final_1_qty = ZhCalc.add(xmj.quantity, xmj.end_qc_minus_qty);
                xmj.end_final_1_qty = ZhCalc.add(xmj.final_1_qty, xmj.end_qc_qty);
                xmj.end_gather_percent = ZhCalc.mul(ZhCalc.div(xmj.end_gather_qty, xmj.end_final_qty), 100, 2);
                xmj.end_final_1_percent = ZhCalc.mul(ZhCalc.div(xmj.end_gather_qty, xmj.end_final_1_qty), 100, 2);
            }
        }
    }

    function compareCode(str1, str2, symbol = '-') {
        if (!str1) {
            return 1;
        } else if (!str2) {
            return -1;
        }

        function compareSubCode(code1, code2) {
            if (numReg.test(code1)) {
                if (numReg.test(code2)) {
                    return parseInt(code1) - parseInt(code2);
                } else {
                    return -1
                }
            } else {
                if (numReg.test(code2)) {
                    return 1;
                } else {
                    return code1 === code2 ? 0 : (code1 < code2 ? -1 : 1); //code1.localeCompare(code2);
                }
            }
        }
        const numReg = /^[0-9]+$/;
        const aCodes = str1.split(symbol), bCodes = str2.split(symbol);
        for (let i = 0, iLength = Math.min(aCodes.length, bCodes.length); i < iLength; ++i) {
            const iCompare = compareSubCode(aCodes[i], bCodes[i]);
            if (iCompare !== 0) {
                return iCompare;
            }
        }
        return aCodes.length - bCodes.length;
    }

    /**
     * 根据树结构 清单汇总
     */
    function gatherGclData() {
        // 清空旧数据
        if (gclList.length > 0) {
            gclList.length = 0; //splice(0, gclList.length);
        }
        recursiveGatherGclData(gsTree.children, null);
        gatherDealBillsData();
        gatherChangeBillsData();
        calculateGatherData();
        gclList.sort(function (a, b) {
            return compareCode(a.b_code, b.b_code) || ZhCalc.sub(a.unit_price, b.unit_price);
        });

        return gclList;
    }

    function checkDiffer(gclList) {
        for (const gcl of gclList) {
            gcl.differ = false;
        }
        for (const [i, gcl] of gclList.entries()) {
            if (i === gclList.length - 1) continue;
            const next = gclList[i+1];
            if (gcl.b_code === next.b_code) {
                if (gcl.name !== next.name || gcl.unit !== next.unit || !checkZero(gcl.unit_price - next.unit_price)) {
                    gcl.differ = true;
                    next.differ = true;
                }
            }
        }
    }

    function _getCalcChapter(chapter, option) {
        const gclChapter = [], otherChapter = {}, gclChapterFilter = [];
        let serialNo = 1;
        for (const c of chapter) {
            const cc = { code: c.code, name: c.name, cType: 1 };
            cc.serialNo = serialNo++;
            cc.filter = '^[^0-9]*' + c.code.substr(0, c.code.length - 2) + '[0-9]{2}(-|$)';
            gclChapter.push(cc);
        }
        gclChapter.push({ name: '未计入章节清单合计', cType: 21, serialNo: serialNo+1 });

        otherChapter.hj = { name: '合计(C=A+B+Z)', cType: 41, serialNo: serialNo+5, deal_bills_tp: option.zlj.deal_bills_tp };
        gclChapterFilter.push({node_type: option.jrg.value});
        gclChapterFilter.push({field: 'name', part: option.jrg.text});
        const zlChapter = {
            name: '暂列金额(Z)', cType: 32, serialNo: serialNo+4,
            deal_bills_tp: option.zlj.deal_bills_tp, match: [], matchPath: []
        };
        zlChapter.match.push({node_type: option.zlj.value});
        zlChapter.match.push({field: 'name', part: option.zlj.text});
        otherChapter.zlj = zlChapter;

        otherChapter.qd = { name: '清单小计(A)', cType: 11, serialNo: serialNo+2 };
        otherChapter.fqd = { name: '非清单项费用(B)', cType: 31, serialNo: serialNo+3 };

        return [gclChapter, otherChapter, gclChapterFilter];
    }

    function _gatherChapterFields(chapter, data, fields) {
        for (const f of fields) {
            chapter[f] = ZhCalc.add(chapter[f], data[f]);
        }
    }

    function _getGclChapter(chapter, data) {
        for (const c of chapter) {
            if (c.filter) {
                const reg = new RegExp(c.filter);
                if (reg.test(data.b_code)) {
                    return c;
                }
            } else {
                return c;
            }
        }
    }

    function _checkFilter(d, filter) {
        for (const f of filter) {
            if (f.node_type && f.node_type === d.node_type) return true;
            if (f.field) {
                if (f.part && d[f.field] && d[f.field].indexOf(f.part) >= 0) return true;
                if (f.all && d[f.all] && d[f.all] === f.all) return true;
            }
        }
        return false;
    }

    function gatherChapterData(chapter, option, fields) {
        const chapterFilterPath = [];
        const checkFilterPath = function (data, filterPath) {
            for (const fp of filterPath) {
                if (data.full_path.indexOf(fp + '-') === 0 || data.full_path === fp) return true;
            }
            return false;
        };

        const [gclChapter, otherChapter, gclChapterFilter] = _getCalcChapter(chapter, option);
        for (const d of gsTree.nodes) {
            if (_checkFilter(d, gclChapterFilter)) chapterFilterPath.push(d.full_path);
            if (_checkFilter(d, otherChapter.zlj.match)) otherChapter.zlj.matchPath.push(d.full_path);
            if (d.children && d.children.length > 0) continue;

            if (checkFilterPath(d,otherChapter.zlj.matchPath)) {
                gatherfields(otherChapter.zlj, d, fields);
                gatherfields(otherChapter.hj, d, fields);
            } else {
                gatherfields(otherChapter.hj, d, fields);
                if (d.b_code) {
                    gatherfields(otherChapter.qd, d, fields);
                }
                if (!d.b_code || d.b_code === '') {
                    gatherfields(otherChapter.fqd, d, fields);
                }

                if (d.b_code) {
                    const c = checkFilterPath(d, chapterFilterPath)
                        ? gclChapter.find(x => { return x.cType === 21})
                        : _getGclChapter(gclChapter, d);
                    gatherfields(c, d, fields);
                }
            }
        }
        for (const d of deal) {
            if (!d.quantity || !d.unit_price) continue;
            otherChapter.hj.deal_bills_tp = ZhCalc.add(otherChapter.hj.deal_bills_tp, d.total_price);
            otherChapter.qd.deal_bills_tp = ZhCalc.add(otherChapter.qd.deal_bills_tp, d.total_price);
            const c = _getGclChapter(gclChapter, d);
            c.deal_bills_tp = ZhCalc.add(c.deal_bills_tp, d.total_price);
        }

        const result = gclChapter.concat([otherChapter.hj, otherChapter.zlj, otherChapter.qd, otherChapter.fqd]);
        result.sort((x, y) => {return x.serialNo - y.serialNo});
        return result;
    }

    return {
        loadGatherField,
        loadDecimal,
        loadLedgerData,
        loadPosData,
        loadDealBillsData,
        loadChangeBillsData,
        gatherGclData,
        checkDiffer,
        gatherChapterData,
    };
})();