Calculation/app/lib/sum_load.js

'use strict';

/**
 *
 *
 * @author Mai
 * @date
 * @version
 */
const Ledger = require('../lib/ledger');

class loadGclBaseTree {
    /**
     * 构造函数
     * @param {Array} tempData - 清单模板数据
     */
    constructor (ctx, setting) {
        this.ctx = ctx;
        this.parent = setting.parent;
        this.defaultData = setting.defaultData;
        // 常量
        this.splitChar = '-';
        // 索引
        // 以code为索引
        this.items = [];

        // 缓存
        this.keyNodeId = setting.maxId ? setting.maxId + 1 : 1;
    }

    /**
     * 根据 编号 查找 父项项目节
     * @param {String} code - 子项编号
     * @returns {*}
     */
    findNode(node, parent, check) {
        parent = parent || this.parent;
        if (!parent.children) return null;

        for (const child of parent.children) {
            const checkLeaf = (child.is_leaf && node.is_leaf) || (!child.is_leaf && !node.is_leaf);
            if (child.b_code === node.b_code && child.name === node.name && child.unit === node.unit
                && checkLeaf && !child.hasPos && (!check || check(child, node))) {
                return child;
            }
        }
        return null;
    }

    /**
     * 添加 树节点 并完善该节点的树结构
     * @param {Object} node - 添加节点
     * @param {Object} parent - 父项
     * @returns {*}
     */
    addNode(source, parent, check) {
        parent = parent ? parent : this.parent;
        let node = this.findNode(source, parent, check);
        if (!node) {
            if (!parent.children) parent.children = [];
            node = {
                id: this.ctx.app.uuid.v4(),
                tender_id: this.ctx.tender.id,
                ledger_id: this.keyNodeId,
                ledger_pid: parent.ledger_id,
                level: parent.level +1,
                full_path: parent.full_path + '-' + this.keyNodeId,
                order: parent.children.length + 1,
                children: [],
                b_code: source.b_code,
                name: source.name,
                unit: source.unit,
                sgfh_qty: 0,
                qtcl_qty: 0,
                sjcl_qyt: 0,
                quantity: 0,
                is_leaf: source.is_leaf,
                hasPos: false,
            };
            this.keyNodeId += 1;
            parent.children.push(node);
            this.items.push(node);
        }
        return node;
    }

    gather(source, parent) {}
    getUpdateData() {}

    recursiveCalculate(dealBills, node) {
        if (node.children && node.children.length > 0) {
            for (const child of node.children) {
                this.recursiveCalculate(dealBills, child);
            }
        } else {
            const p = this.ctx.helper.findPrecision(this.ctx.tender.info.precision, node.unit);
            node.sgfh_qty = this.ctx.helper.round(node.sgfh_qty, p.value);
            node.sjcl_qty = this.ctx.helper.round(node.sjcl_qty, p.value);
            node.qtcl_qty = this.ctx.helper.round(node.qtcl_qty, p.value);
            node.quantity = this.ctx.helper.round(node.quantity, p.value);

            if (!node.unit_price) {
                const db = dealBills.find(x => { return x.code === node.b_code && x.name === node.name && x.unit === node.unit });
                if (!db) return;
                node.unit_price = db.unit_price;
            }
            node.sgfh_tp = this.ctx.helper.mul(node.sgfh_qty, node.unit_price, this.ctx.tender.info.decimal.tp);
            node.sjcl_tp = this.ctx.helper.mul(node.sjcl_qty, node.unit_price, this.ctx.tender.info.decimal.tp);
            node.qtcl_tp = this.ctx.helper.mul(node.qtcl_qty, node.unit_price, this.ctx.tender.info.decimal.tp);
            node.total_price = this.ctx.helper.mul(node.quantity, node.unit_price, this.ctx.tender.info.decimal.tp);
        }
    }
    calculateAll(dealBills) {
        this.recursiveCalculate(dealBills, this.parent);
    }
}

class loadLedgerGclTree extends loadGclBaseTree {
    gather(source, parent) {
        const node = this.addNode(source, parent);
        node.sgfh_qty = this.ctx.helper.add(node.sgfh_qty, source.sgfh_qty);
        node.qtcl_qty = this.ctx.helper.add(node.qtcl_qty, source.qtcl_qty);
        node.sjcl_qty = this.ctx.helper.add(node.sjcl_qty, source.sjcl_qty);
        node.quantity = this.ctx.helper.add(node.quantity, source.quantity);
        return node;
    }

    getUpdateData() {
        const update = [];
        if (this.items.length > 0) update.push({id: this.parent.id, ledger_id: this.parent.ledger_id, is_leaf: 0});
        const create = [];
        for (const i of this.items) {
            create.push({
                id: i.id, tender_id: i.tender_id, ledger_id: i.ledger_id, ledger_pid: i.ledger_pid,
                level: i.level, order: i.order, full_path: i.full_path, is_leaf: !i.children || i.children.length === 0,
                b_code: i.b_code, name: i.name, unit: i.unit, unit_price: i.unit_price || 0,
                sgfh_qty: i.sgfh_qty, sjcl_qty: i.sjcl_qty, qtcl_qty: i.qtcl_qty, quantity: i.quantity,
                sgfh_tp: i.sgfh_tp || 0, sjcl_tp: i.sjcl_tp || 0, qtcl_tp: i.qtcl_tp || 0, total_price: i.total_price || 0,
            });
        }
        return {update, create};
    }
}

class updateReviseGclTree extends loadGclBaseTree {
    constructor (ctx, setting) {
        super(ctx, setting);
        this.baseNodes = [];
        this.errors = [];
    }
    loadBase(datas, pos) {
        datas.sort((x, y) => { return x.level === y.level ? x.order - y.order : x.level - y.level; });
        const Index = {};
        for (const d of datas) {
            const parent = this.parent.ledger_id === d.ledger_pid ? this.parent : Index[d.ledger_pid];
            if (!parent) continue;

            if (!parent.children) parent.children = [];
            const relaPos = pos.filter(x => {return x.lid === d.id});
            const baseNode = {
                id: d.id,
                ledger_id: d.ledger_id,
                ledger_pid: d.ledger_pid,
                level: d.level,
                is_leaf: d.is_leaf,
                full_path: d.full_path,
                b_code: d.b_code,
                name: d.name,
                unit: d.unit,
                unit_price: d.unit_price,
                org_sgfh_qty: d.sgfh_qty || 0,
                org_sjcl_qty: d.sjcl_qty || 0,
                org_qtcl_qty: d.qtcl_qty || 0,
                org_qty: d.quantity || 0,
                org_order: d.order,
                sgfh_qty: 0,
                sjcl_qty: 0,
                qtcl_qty: 0,
                quantity: 0,
                hasPos: relaPos.length > 0,
            };
            parent.children.push(baseNode);
            Index[baseNode.ledger_id] = baseNode;
            this.baseNodes.push(baseNode);
        }
    }
    gather(source, parent) {
        const node = this.addNode(source, parent);
        node.sgfh_qty = this.ctx.helper.add(node.sgfh_qty, source.sgfh_qty);
        node.qtcl_qty = this.ctx.helper.add(node.qtcl_qty, source.qtcl_qty);
        node.sjcl_qty = this.ctx.helper.add(node.sjcl_qty, source.sjcl_qty);
        node.quantity = this.ctx.helper.add(node.quantity, source.quantity);
        return node;
    }
    getUpdateData() {
        const result = {update: [], errors: [], create: []};
        if (this.baseNodes.length === 0) {
            if (this.items.length > 0) result.update.push({id: this.parent.id, ledger_id: this.parent.ledger_id, is_leaf: 0});
        } else {
            for (const bn of this.baseNodes) {
                if (bn.children && bn.children.length > 0) continue;

                if (bn.sjcl_qty < bn.org_sjcl_qty || bn.qtcl_qty < bn.org_qtcl_qty || bn.sgfh_qty < bn.org_sgfh_qty) {
                    result.errors.push({
                        ledger_id: bn.ledger_id,
                        b_code: bn.b_code, name: bn.name, unit: bn.unit,
                        sgfh_qty: bn.sgfh_qty, sjcl_qty: bn.sjcl_qty, qtcl_qty: bn.qtcl_qty, qty: bn.quantity, type: 'less',
                    });
                } else if (bn.sjcl_qty !== bn.org_sjcl_qty || bn.qtcl_qty !== bn.org_qtcl_qty || bn.sgfh_qty !== bn.org_sgfh_qty) {
                    result.update.push({
                        id: bn.id, ledger_id: bn.ledger_id, unit_price: bn.unit_price || 0,
                        sgfh_qty: bn.sgfh_qty, sjcl_qty: bn.sjcl_qty, qtcl_qty: bn.qtcl_qty, quantity: bn.quantity,
                        sgfh_tp: bn.sgfh_tp || 0, sjcl_tp: bn.sjcl_tp || 0, qtcl_tp: bn.qtcl_tp || 0, total_price: bn.total_price || 0,
                    })
                }
            }
        }
        for (const i of this.items) {
            result.create.push({
                id: i.id, tender_id: i.tender_id, ledger_id: i.ledger_id, ledger_pid: i.ledger_pid,
                level: i.level, order: i.order, full_path: i.full_path, is_leaf: !i.children || i.children.length === 0,
                b_code: i.b_code, name: i.name, unit: i.unit, unit_price: i.unit_price || 0,
                sgfh_qty: i.sgfh_qty, sjcl_qty: i.sjcl_qty, qtcl_qty: i.qtcl_qty, quantity: i.quantity,
                sgfh_tp: i.sgfh_tp || 0, sjcl_tp: i.sjcl_tp || 0, qtcl_tp: i.qtcl_tp || 0, total_price: i.total_price || 0,
            })
        }
        return result;
    }
}

class gatherStageGclTree extends loadGclBaseTree {
    constructor (ctx, setting) {
        super(ctx, setting);
        this.baseNodes = [];
    }
    loadBase(datas, pos) {
        datas.sort((x, y) => { return x.level === y.level ? x.order - y.order : x.level - y.level; });
        const Index = {};
        for (const d of datas) {
            const parent = this.parent.ledger_id === d.ledger_pid ? this.parent : Index[d.ledger_pid];
            if (!parent) continue;

            if (!parent.children) parent.children = [];
            const relaPos = pos.filter(x => {return x.lid === d.id});
            const baseNode = {
                id: d.id,
                ledger_id: d.ledger_id,
                ledger_pid: d.ledger_pid,
                level: d.level,
                is_leaf: d.is_leaf,
                full_path: d.full_path,
                b_code: d.b_code,
                name: d.name,
                unit: d.unit,
                unit_price: d.unit_price,
                org_contract_qty: d.contract_qty || 0,
                org_contract_tp: d.contract_tp || 0,
                org_order: d.order,
                contract_qty: 0,
                contract_tp: 0,
                is_tp: d.is_tp,
                hasPos: relaPos.length > 0,
            };
            parent.children.push(baseNode);
            Index[baseNode.ledger_id] = baseNode;
            this.baseNodes.push(baseNode);
        }
    }
    _gatherChange(node, source) {
        if (!source.change_detail || source.change_detail.length === 0) return;

        if (!node.change_detail) node.change_detail = [];
        for (const cd of source.change_detail) {
            if (!cd.qty) continue;
            let ncd = node.change_detail.find(x => { return x.cid === cd.cid; });
            if (!ncd) {
                ncd = { cid: cd.cid, c_code: cd.c_code };
                node.change_detail.push(ncd);
            }
            ncd.qty = this.ctx.helper.add(ncd.qty, cd.qty);
        }
    }
    gather(source, parent) {
        parent = parent ? parent : this.parent;
        const node = this.addNode(source, parent, function (node, source) {
            return  (source.is_tp && node.is_tp) || (!source.is_tp && !node.is_tp);
        });
        if (node.is_tp) {
            node.contract_tp = this.ctx.helper.add(node.contract_tp, source.contract_tp);
        } else {
            node.contract_qty = this.ctx.helper.add(node.contract_qty, source.contract_qty);
            node.contract_tp = this.ctx.helper.mul(node.unit_price, node.contract_qty, this.ctx.tender.info.decimal.tp);
        }
        this._gatherChange(node, source);
        return node;
    }
    getUpdateData() {
        const result = {update: [], errors: []};
        for (const bn of this.baseNodes) {
            if (bn.contract_qty !== bn.org_contract_qty || bn.contract_tp !== bn.org_contract_tp) {
                result.update.push({lid: bn.id, contract_qty: bn.contract_qty, contract_tp: bn.contract_tp });
            }
            if (bn.change_detail && bn.change_detail.length > 0) {
                for (const cd of bn.change_detail) {
                    result.errors.push({
                        ledger_id: bn.ledger_id,
                        b_code: bn.b_code, name: bn.name, unit: bn.unit,
                        c_code: cd.c_code, qty: cd.qty, type: 'qc',
                    });
                }
            }
        }
        for (const i of this.items) {
            result.errors.push({ b_code: i.b_code, name: i.name, unit: i.unit, qty: i.contract_qty, type: 'miss' });
            if (i.change_detail && i.change_detail.length > 0) {
                for (const cd of i.change_detail) {
                    result.errors.push({
                        b_code: i.b_code, name: i.name, unit: i.unit,
                        c_code: cd.c_code, qty: cd.qty, type: 'miss-qc',
                    });
                }
            }
        }
        return result;
    }
}

class sumLoad {
    constructor (ctx) {
        this.ctx = ctx;
    }

    recusiveLoadGatherGcl(node, parent) {
        const cur = node.b_code ? this.loadTree.gather(node, parent) : parent;
        if (!node.children || node.children.length === 0) return;
        for (const child of node.children) {
            this.recusiveLoadGatherGcl(child, cur);
        }
    }

    async loadGatherGcl(select, maxId, tenders, defaultData) {
        this.loadTree = new loadLedgerGclTree(this.ctx, {
            parent: select, maxId, type: 'ledger', defaultData,
        });
        for (const tender of tenders) {
            const billsData = await this.ctx.service.ledger.getData(tender.tid);
            const billsTree = new Ledger.billsTree(this.ctx, {
                id: 'ledger_id',
                pid: 'ledger_pid',
                order: 'order',
                level: 'level',
                rootId: -1,
                keys: ['id', 'tender_id', 'ledger_id'],
                stageId: 'id',
            });
            billsTree.loadDatas(billsData);
            for (const top of billsTree.children) {
                if ([1].indexOf(top.node_type) < 0) continue;
                this.recusiveLoadGatherGcl(top, null);
            }
        }
        const dealBills = await this.ctx.service.dealBills.getAllDataByCondition({ where: { tender_id: this.ctx.tender.id } });
        this.loadTree.calculateAll(dealBills);
        return this.loadTree;
    }

    async updateGatherGcl(select, maxId, tenders, defaultData) {
        this.loadTree = new updateReviseGclTree(this.ctx, {
            parent: select, maxId, type: 'ledger', defaultData,
        });
        const posterity = await this.ctx.service.reviseBills.getPosterityByParentId(this.ctx.tender.id, select.ledger_id);
        const pos = await this.ctx.service.revisePos.getData(this.ctx.tender.id);
        this.loadTree.loadBase(posterity, pos);

        for (const tender of tenders) {
            const billsData = await this.ctx.service.ledger.getData(tender.tid);
            const billsTree = new Ledger.billsTree(this.ctx, {
                id: 'ledger_id',
                pid: 'ledger_pid',
                order: 'order',
                level: 'level',
                rootId: -1,
                keys: ['id', 'tender_id', 'ledger_id'],
                stageId: 'id',
            });
            billsTree.loadDatas(billsData);
            for (const top of billsTree.children) {
                if ([1].indexOf(top.node_type) < 0) continue;
                this.recusiveLoadGatherGcl(top, null);
            }
        }
        const dealBills = await this.ctx.service.dealBills.getAllDataByCondition({ where: { tender_id: this.ctx.tender.id } });
        this.loadTree.calculateAll(dealBills);
        return this.loadTree;
    }

    _loadCurStageAndChange(billsData, curStageBills, curStageChange) {
        const billsIndex = {};
        for (const b of billsData) {
            billsIndex[b.id] = b;
        }
        for (const csb of curStageBills) {
            const b = billsIndex[csb.lid];
            if (!b) continue;
            b.contract_qty = csb.contract_qty;
            b.contract_tp = csb.contract_tp;
        }
        for (const csc of curStageChange) {
            if (!csc.qty) continue;

            const b = billsIndex[csc.lid];
            if (!b) continue;
            if (!b.change_detail) b.change_detail = [];
            let c = b.change_detail.find(x => { return x.cid === csc.cid });
            if (!c) {
                c = { cid: csc.cid };
                b.change_detail.push(c);
            }
            c.qty = this.ctx.helper.add(c.qty, csc.qty);
        }
    }

    async stageGatherGcl(select, maxId, tenders, defaultData) {
        this.loadTree = new gatherStageGclTree(this.ctx, {
            parent: select, maxId, type: 'ledger', defaultData,
        });
        const posterity = await this.ctx.service.ledger.getPosterityByParentId(this.ctx.tender.id, select.ledger_id);
        const pos = await this.ctx.service.revisePos.getData(this.ctx.tender.id);
        this.loadTree.loadBase(posterity, pos);

        for (const tender of tenders) {
            if (!tender.stage) continue;
            const billsData = await this.ctx.service.ledger.getData(tender.tid);
            const stage = await this.ctx.service.stage.getDataByCondition({tid: tender.tid, order: tender.stage});
            if (!stage) throw '选择的期不存在';
            const curStageData = await this.ctx.service.stageBills.getLastestStageData(tender.tid, stage.id);
            const curStageChange = await this.ctx.service.stageChangeFinal.getSumLoadFinalData(stage.id);
            this._loadCurStageAndChange(billsData, curStageData, curStageChange);
            const billsTree = new Ledger.billsTree(this.ctx, {
                id: 'ledger_id',
                pid: 'ledger_pid',
                order: 'order',
                level: 'level',
                rootId: -1,
                keys: ['id', 'tender_id', 'ledger_id'],
                stageId: 'id',
            });
            billsTree.loadDatas(billsData);
            for (const top of billsTree.children) {
                if ([1].indexOf(top.node_type) < 0) continue;
                this.recusiveLoadGatherGcl(top, null);
            }
        }
        return this.loadTree;
    }
}

module.exports = sumLoad;