Calculation/app/service/ledger.js

'use strict';

/**
 * 标段--台账 数据模型
 *
 * @author CaiAoLin
 * @date 2017/12/1
 * @version
 */

const needField = {
    id: 'ledger_id',
    pid: 'ledger_pid',
    order: 'order',
    level: 'level',
    fullPath: 'full_path',
    isLeaf: 'is_leaf',
};
const keyFields = {
    table: ['id'],
    index: ['tender_id', 'ledger_id'],
};
// 以下字段仅可通过树结构操作改变，不可直接通过update方式从接口提交，发现时过滤
const readOnlyFields = ['id', 'tender_id', 'ledger_id', 'ledger_pid', 'order', 'level', 'full_path', 'is_leaf'];
const calcFields = ['unit_price', 'sgfh_qty', 'sgfh_tp', 'sjcl_qty', 'sjcl_tp', 'qtcl_qty', 'qtcl_tp', 'deal_qty', 'deal_tp', 'dgn_qty1', 'dgn_qty2'];
const upFields = ['unit_price'];
const qtyFields = ['sgfh_qty', 'sjcl_qty', 'qtcl_qty', 'quantity', 'deal_qty'];
const tpFields = ['sgfh_tp', 'sjcl_tp', 'qtcl_tp', 'total_price', 'deal_tp'];
const rootId = -1;
const keyPre = 'tender_node_maxId:';
const measureType = require('../const/tender').measureType;
const SumLoad = require('../lib/sum_load');

module.exports = app => {

    class Ledger extends app.BaseBillsService {

        /**
         * 构造函数
         *
         * @param {Object} ctx - egg全局变量
         * @return {void}
         */
        constructor(ctx) {
            super(ctx, {
                mid: 'tender_id',
                kid: 'ledger_id',
                pid: 'ledger_pid',
                order: 'order',
                level: 'level',
                isLeaf: 'is_leaf',
                fullPath: 'full_path',
                keyPre: 'ledger_bills_maxLid:',
                uuid: true,
            }, 'pos', 'ancillaryGcl');
            this.depart = ctx.app.config.table_depart.heavy;
            this.tableName = 'ledger';
        }

        /**
         * 新增数据(供内部或其他service类调用, controller不可直接使用)
         * @param {Array|Object} data - 新增数据
         * @param {Number} tenderId - 标段id
         * @param {Object} transaction - 新增事务
         * @return {Promise<boolean>} - {Promise<是否正确新增成功>}
         */
        async innerAdd(data, tenderId, transaction) {
            const datas = data instanceof Array ? data : [data];
            if (tenderId <= 0) {
                throw '标段id错误';
            }
            if (datas.length <= 0) {
                throw '插入数据为空';
            }
            if (!transaction) {
                throw '内部错误';
            }
            // 整理数据
            const insertData = [];
            for (const tmp of datas) {
                tmp.ledger_id = tmp.template_id;
                tmp.ledger_pid = tmp.pid;
                tmp.tender_id = tenderId;
                delete tmp.template_id;
                delete tmp.pid;
                tmp.id = this.uuid.v4();
                insertData.push(tmp);
            }
            const operate = await transaction.insert(this.tableName, insertData);
            return operate.affectedRows === datas.length;
        }
        /**
         * 新增数据
         *
         * @param {Object} data - 新增的数据(可批量)
         * @param {Number} tenderId - 标段id
         * @return {Boolean} - 返回新增的结果
         */
        async add(data, tenderId) {
            this.transaction = await this.db.beginTransaction();
            let result = false;
            try {
                result = await this.innerAdd(data, tenderId, this.transaction);
                if (!result) {
                    throw '新增数据错误';
                }
                await this.transaction.commit();
            } catch (error) {
                await this.transaction.rollback();
                result = false;
            }

            return result;
        }

        /**
         * 根据节点Id获取数据
         *
         * @param {Number} tenderId - 标段id
         * @param {Number} nodeId - 项目节/工程量清单节点id
         * @return {Object} - 返回查询到的节点数据
         */
        async getDataByNodeId(tenderId, nodeId) {
            if ((nodeId <= 0) || (tenderId <= 0)) {
                return undefined;
            }

            this.initSqlBuilder();
            this.sqlBuilder.setAndWhere('tender_id', {
                value: tenderId,
                operate: '=',
            });
            this.sqlBuilder.setAndWhere('ledger_id', {
                value: nodeId,
                operate: '=',
            });

            const [sql, sqlParam] = this.sqlBuilder.build(this.tableName);
            const data = await this.db.queryOne(sql, sqlParam);

            return data;
        }
        /**
         * 根据节点Id获取数据
         * @param {Number} tenderId - 标段Id
         * @param {Array} nodesIds - 节点Id
         * @return {Array}
         */
        async getDataByNodeIds(tenderId, nodesIds) {
            if (tenderId <= 0) {
                return [];
            }

            this.initSqlBuilder();
            this.sqlBuilder.setAndWhere('tender_id', {
                value: tenderId,
                operate: '=',
            });
            this.sqlBuilder.setAndWhere('ledger_id', {
                value: nodesIds,
                operate: 'in',
            });

            const [sql, sqlParam] = this.sqlBuilder.build(this.tableName);
            const data = await this.db.query(sql, sqlParam);

            return this._.sortBy(data, function(d) {
                return nodesIds.indexOf(d.ledger_id);
            });
        }
        /**
         * 根据主键id获取数据
         * @param {Array|Number} id - 主键id
         * @return {Promise<*>}
         */
        async getDataByIds(id) {
            if (!id) {
                return;
            }
            const ids = id instanceof Array ? id : [id];
            if (ids.length === 0) {
                return;
            }
            this.initSqlBuilder();
            this.sqlBuilder.setAndWhere('id', {
                value: ids,
                operate: 'in',
            });

            const [sql, sqlParam] = this.sqlBuilder.build(this.tableName);
            const data = await this.db.query(sql, sqlParam);

            return data;
        }

        /**
         * 根据 父节点id 获取子节点
         * @param tenderId
         * @param nodeId
         * @return {Promise<*>}
         */
        async getChildrenByParentId(tenderId, nodeId) {
            if (tenderId <= 0 || !nodeId) {
                return undefined;
            }
            const nodeIds = nodeId instanceof Array ? nodeId : [nodeId];
            if (nodeIds.length === 0) {
                return [];
            }

            this.initSqlBuilder();
            this.sqlBuilder.setAndWhere('tender_id', {
                value: tenderId,
                operate: '=',
            });
            this.sqlBuilder.setAndWhere('ledger_pid', {
                value: nodeIds,
                operate: 'in',
            });
            this.sqlBuilder.orderBy = [['order', 'ASC']];

            const [sql, sqlParam] = this.sqlBuilder.build(this.tableName);
            const data = await this.db.query(sql, sqlParam);

            return data;
        }

        /**
         * 获取项目工程量
         * @param tenderId
         * @return {Promise<*>}
         */
        async getGatherGclBills(tenderId) {
            const sql = 'SELECT `b_code`, `name`, `unit`, `unit_price`, ' +
                        '    Sum(`quantity`) As `quantity`, Sum(`total_price`) As `total_price`, ' +
                        '    Sum(`deal_qty`) As `deal_qty`, Sum(`deal_tp`) As `deal_tp` ' +
                        '  From ?? ' +
                        '  WHERE `tender_id` = ? And `b_code` And `is_leaf` ' +
                        '  GROUP BY `b_code`, `name`, `unit`, `unit_price`';
            const sqlParam = [this.tableName, tenderId];
            return await this.db.query(sql, sqlParam);
        }

        async getTenderUsedUnits(tenderId) {
            const sql = 'SELECT unit ' +
                '  FROM ' + this.tableName +
                '  WHERE tender_id = ? and is_leaf = true' +
                '  GROUP By unit';
            const sqlParam = [tenderId];
            const units = await this.db.query(sql, sqlParam);
            return this._.map(units, 'unit');
        }

        /**
         * 统计子节点total_price
         * @param {Number} tenderId - 标段id
         * @param {Number} pid - 父节点id
         * @param {Number} order - order取值
         * @param {String} orderOperate - order比较操作符
         * @return {Promise<void>}
         */
        async addUpChildren(tenderId, pid, order, orderOperate) {
            this.initSqlBuilder();
            const sql = ['SELECT SUM(??) As value FROM ?? ', ' WHERE '];
            const sqlParam = ['total_price', this.tableName];
            sql.push(' ?? = ' + tenderId);
            sqlParam.push('tender_id');
            sql.push(' And ?? = ' + pid);
            sqlParam.push('ledger_pid');
            sql.push(' And ?? ' + orderOperate + ' ' + order);
            sqlParam.push('order');
            const result = await this.db.queryOne(sql.join(''), sqlParam);

            return result.value;
        }

        /**
         * 删除相关数据 用于继承
         * @param mid
         * @param deleteData
         * @return {Promise<void>}
         * @private
         */
        async _deleteRelaData(mid, deleteData) {
            await this.ctx.service.pos.deletePosData(this.transaction, mid, this._.map(deleteData, 'id'));
            await this.ctx.service.ancillaryGcl.deletePartData(this.transaction, mid, this._.map(deleteData, 'id'));
        }

        _checkField(data, field) {
            const fields = field instanceof Array ? field : [field];
            for (const prop in data) {
                if (fields.indexOf(prop) >= 0) {
                    return true;
                }
            }
            return false;
        }

        /**
         * 复制粘贴整块
         * @param {Number} tenderId - 标段Id
         * @param {Number} selectId - 选中几点Id
         * @param {Array} block - 复制节点Id
         * @return {Object} - 提价后的数据(其中新增粘贴数据，只返回第一层)
         */
        async pasteBlock(tenderId, selectId, paste) {
            if ((tenderId <= 0) || (selectId <= 0)) {
                return [];
            }
            const selectData = await this.getDataByNodeId(this.ctx.tender.id, selectId);
            if (!selectData) {
                throw '位置数据错误';
            }
            const newParentPath = selectData.full_path.replace(selectData.ledger_id, '');

            const copyNodes = await this.getDataByNodeIds(paste.tid, paste.block);
            if (!copyNodes || copyNodes.length <= 0) {
                throw '复制数据错误';
            }
            let bSameParent = true;
            for (const node of copyNodes) {
                if (node.ledger_pid !== copyNodes[0].ledger_pid) {
                    bSameParent = false;
                    break;
                }
            }
            if (!bSameParent) {
                throw '复制数据错误：仅可操作同层节点';
            }

            const pasteBillsData = [],
                pastePosData = [];
            this.transaction = await this.db.beginTransaction();
            try {
                // 选中节点的所有后兄弟节点，order+粘贴节点个数
                await this._updateChildrenOrder(tenderId, selectData.ledger_pid, selectData.order + 1, copyNodes.length);
                // 数据库创建新增节点数据
                const leafBillsId = [];
                let maxId = await this._getMaxLid(this.ctx.tender.id);
                for (let iNode = 0; iNode < copyNodes.length; iNode++) {
                    const node = copyNodes[iNode];
                    let datas = await this.getDataByFullPath(paste.tid, node.full_path + '%');
                    datas = this._.sortBy(datas, 'level');

                    // 计算粘贴数据中需更新部分
                    datas.sort(function(x, y) {
                        return x.level - y.level;
                    });
                    for (const data of datas) {
                        data.children = datas.filter(function(x) {
                            return x.ledger_pid === data.ledger_id;
                        });
                    }
                    for (let index = 0; index < datas.length; index++) {
                        const data = datas[index];
                        const newId = maxId + index + 1;
                        const idChange = {
                            org: data.id,
                        };
                        data.id = this.uuid.v4();
                        idChange.new = data.id;
                        data.tender_id = this.ctx.tender.id;
                        if (data.children && data.children.length > 0) {
                            for (const child of data.children) {
                                child.ledger_pid = newId;
                            }
                        }
                        data.ledger_id = newId;
                        if (data.ledger_pid === node.ledger_pid) {
                            data.ledger_pid = selectData.ledger_pid;
                            data.order = selectData.order + iNode + 1;
                        }
                        data.level = data.level + selectData.level - copyNodes[0].level;
                        if (data.is_leaf) {
                            leafBillsId.push(idChange);
                        }
                    }
                    for (const data of datas) {
                        delete data.children;
                        delete data.crid;
                        delete data.is_tp;
                        const p = datas.find(function(x) {
                            return x.ledger_id === data.ledger_pid;
                        });
                        if (p) {
                            data.full_path = p.full_path + '-' + data.ledger_id;
                        } else {
                            data.full_path = newParentPath + '' + data.ledger_id;
                        }
                        pasteBillsData.push(data);
                    }
                    maxId = maxId + datas.length;
                }
                const newData = await this.transaction.insert(this.tableName, pasteBillsData);
                this._cacheMaxLid(tenderId, maxId);

                for (const id of leafBillsId) {
                    const posData = await this.ctx.service.pos.getAllDataByCondition({ where: { tid: paste.tid, lid: id.org } });
                    if (posData.length > 0) {
                        for (const pd of posData) {
                            delete pd.crid;
                            pd.id = this.uuid.v4();
                            pd.lid = id.new;
                            pd.tid = this.ctx.tender.id;
                            pd.in_time = new Date();
                            pastePosData.push(pd);
                        }
                    }
                }
                await this.transaction.insert(this.ctx.service.pos.tableName, pastePosData);
                await this.transaction.commit();
            } catch (err) {
                await this.transaction.rollback();
                throw err;
            }

            // 查询应返回的结果
            const order = [];
            for (let i = 1; i <= copyNodes.length; i++) {
                order.push(selectData.order + i);
            }
            const updateData = await this.getNextsData(selectData.tender_id, selectData.ledger_pid, selectData.order + copyNodes.length);
            return {
                ledger: { create: pasteBillsData, update: updateData },
                pos: pastePosData,
            };
        }

        /**
         *
         * @param tenderId
         * @param xmj
         * @param order
         * @param parentData
         * @return {Promise<*[]>}
         * @private
         */
        async _sortBatchInsertData(tenderId, xmj, order, parentData) {
            const result = [],
                newIds = [];
            let tp = 0;
            const maxId = await this._getMaxLid(tenderId);
            // 添加xmj数据
            const parent = {
                tender_id: tenderId,
                ledger_id: maxId + 1,
                ledger_pid: parentData.ledger_id,
                is_leaf: xmj.children.length === 0,
                order,
                level: parentData.level + 1,
                name: xmj.name,
            };
            parent.full_path = parentData.full_path + '-' + parent.ledger_id;
            // 添加gcl数据
            for (let i = 0, iLen = xmj.children.length; i < iLen; i++) {
                const gcl = xmj.children[i];
                const child = {
                    tender_id: tenderId,
                    ledger_id: maxId + 1 + i + 1,
                    ledger_pid: parent.ledger_id,
                    is_leaf: true,
                    order: i + 1,
                    level: parent.level + 1,
                    b_code: gcl.b_code,
                    name: gcl.name,
                    unit: gcl.unit,
                    unit_price: gcl.unit_price,
                    quantity: gcl.quantity,
                };
                child.full_path = parent.full_path + '-' + child.ledger_id;
                child.total_price = this.ctx.helper.mul(child.unit_price, child.quantity, this.ctx.tender.info.decimal.tp);
                tp = this.ctx.helper.add(tp, child.total_price);
                result.push(child);
                newIds.push(child.ledger_id);
            }
            parent.total_price = tp;
            result.push(parent);
            newIds.push(parent.ledger_id);
            return [result, tp, newIds];
        }

        /**
         * 批量插入子项
         * @param {Number} tenderId - 标段Id
         * @param {Number} selectId - 选中节点Id
         * @param {Object} data - 批量插入数据
         * @return {Promise<void>}
         */
        async batchInsertChild(tenderId, selectId, data) {
            const result = { ledger: {}, pos: null };
            if ((tenderId <= 0) || (selectId <= 0)) return result;
            const selectData = await this.getDataByNodeId(tenderId, selectId);
            if (!selectData) throw '位置数据错误';

            const info = this.ctx.tender.info;
            this.transaction = await this.db.beginTransaction();
            const lastChild = await this.getLastChildData(tenderId, selectId);
            // 计算id
            const maxId = await this._getMaxLid(tenderId);
            const insertBillsData = [], insertPosData = [], in_time = new Date();
            const order = lastChild ? lastChild.order : 0;
            for (let i = 0, iLen = data.length; i < iLen; i++) {
                // 合并新增数据
                const qd = {
                    id: this.uuid.v4(),
                    tender_id: tenderId,
                    ledger_id: maxId + i + 1,
                    ledger_pid: selectData.ledger_id,
                    is_leaf: true,
                    order: order + i + 1,
                    level: selectData.level + 1,
                    b_code: data[i].b_code,
                    name: data[i].name,
                    unit: data[i].unit,
                    unit_price: this.ctx.helper.round(data[i].price, info.decimal.up),
                };
                qd.full_path = selectData.full_path + '-' + qd.ledger_id;
                insertBillsData.push(qd);
                const precision = this.ctx.helper.findPrecision(info.precision, qd.unit);
                if (data[i].pos.length > 0) {
                    for (const [j, p] of data[i].pos.entries()) {
                        const inD = {
                            id: this.uuid.v4(), tid: tenderId, lid: qd.id,
                            add_stage: 0, add_stage_order: 0, add_times: 0, add_user: this.ctx.session.sessionUser.accountId,
                            in_time, porder: j + 1,
                            name: p.name, drawing_code: p.drawing_code,
                        };
                        if (p.quantity) {
                            inD.sgfh_qty = this.round(p.quantity, precision.value);
                            inD.quantity = inD.sgfh_qty;
                            qd.sgfh_qty = this.ctx.helper.add(qd.sgfh_qty, inD.sgfh_qty);
                        }
                        insertPosData.push(inD);
                    }
                    qd.sgfh_tp = this.ctx.helper.mul(qd.sgfh_qty, qd.unit_price, info.decimal.tp);
                    qd.quantity = qd.sgfh_qty;
                    qd.total_price = qd.sgfh_tp;
                }
            }
            try {
                // 更新父项isLeaf
                if (!lastChild) {
                    await this.transaction.update(this.tableName, {
                        id: selectData.id,
                        is_leaf: false,
                        unit_price: null,
                        sgfh_qty: null, sgfh_tp: null,
                        sjcl_qty: null, sjcl_tp: null,
                        qtcl_qty: null, qtcl_tp: null,
                        quantity: null, total_price: null,
                        deal_qty: null, deal_tp: null,
                    });
                }
                await this.transaction.insert(this.tableName, insertBillsData);
                if (insertPosData.length > 0) await this.transaction.insert(this.ctx.service.pos.tableName, insertPosData);
                this._cacheMaxLid(tenderId, maxId + data.length);
                await this.transaction.commit();
            } catch (err) {
                await this.transaction.rollback();
                throw err;
            }

            // 查询应返回的结果
            result.ledger.create = insertBillsData;
            if (!lastChild) result.ledger.update = await this.getDataByIds([selectData.id]);
            result.pos = insertPosData;
            return result;
        }

        /**
         * 批量插入后项
         * @param {Number} tenderId - 标段Id
         * @param {Number} selectId - 选中节点Id
         * @param {Object} data - 批量插入数据
         * @return {Promise<void>}
         */
        async batchInsertNext(tenderId, selectId, data) {
            const result = { ledger: {}, pos: null };
            if ((tenderId <= 0) || (selectId <= 0)) return result;
            const selectData = await this.getDataByNodeId(tenderId, selectId);
            if (!selectData) throw '位置数据错误';
            const parentData = await this.getDataByNodeId(tenderId, selectData.ledger_pid);
            if (!parentData) throw '位置数据错误';

            const info = this.ctx.tender.info;
            this.transaction = await this.db.beginTransaction();

            const insertBillsData = [], insertPosData = [], in_time = new Date();
            const maxId = await this._getMaxLid(tenderId);
            const order = selectData.order;
            for (let i = 0, iLen = data.length; i < iLen; i++) {
                // 合并新增数据
                const qd = {
                    id: this.uuid.v4(),
                    tender_id: tenderId,
                    ledger_id: maxId + i + 1,
                    ledger_pid: selectData.ledger_pid,
                    is_leaf: true,
                    order: order + i + 1,
                    level: selectData.level,
                    b_code: data[i].b_code,
                    name: data[i].name,
                    unit: data[i].unit,
                    unit_price: this.ctx.helper.round(data[i].price, info.decimal.up),
                };
                qd.full_path = selectData.full_path + '-' + qd.ledger_id;
                insertBillsData.push(qd);
                const precision = this.ctx.helper.findPrecision(info.precision, qd.unit);
                if (data[i].pos.length > 0) {
                    for (const [j, p] of data[i].pos.entries()) {
                        const inD = {
                            id: this.uuid.v4(), tid: tenderId, lid: qd.id,
                            add_stage: 0, add_stage_order: 0, add_times: 0, add_user: this.ctx.session.sessionUser.accountId,
                            in_time, porder: j + 1,
                            name: p.name, drawing_code: p.drawing_code,
                        };
                        if (p.quantity) {
                            inD.sgfh_qty = this.round(p.quantity, precision.value);
                            inD.quantity = inD.sgfh_qty;
                            qd.sgfh_qty = this.ctx.helper.add(qd.sgfh_qty, inD.sgfh_qty);
                        }
                        insertPosData.push(inD);
                    }
                    qd.sgfh_tp = this.ctx.helper.mul(qd.sgfh_qty, qd.unit_price, info.decimal.tp);
                    qd.quantity = qd.sgfh_qty;
                    qd.total_price = qd.sgfh_tp;
                }
            }

            try {
                // 选中节点的所有后兄弟节点，order+粘贴节点个数
                await this._updateChildrenOrder(tenderId, selectData.ledger_pid, selectData.order + 1, data.length);
                await this.transaction.insert(this.tableName, insertBillsData);
                if (insertPosData.length > 0) await this.transaction.insert(this.ctx.service.pos.tableName, insertPosData);
                this._cacheMaxLid(tenderId, maxId + data.length);
                await this.transaction.commit();
            } catch (err) {
                await this.transaction.rollback();
                throw err;
            }

            // 查询应返回的结果
            result.ledger.create = insertBillsData;
            result.ledger.update = await this.getNextsData(selectData.tender_id, selectData.ledger_pid, selectData.order + data.length);
            result.pos = insertPosData;
            return result;
        }

        /**
         * 导入Excel数据
         * @param excelData
         * @return {Promise<void>}
         */
        async importExcel(templateId, excelData, filter) {
            const AnalysisExcel = require('../lib/analysis_excel').AnalysisExcelTree;
            const analysisExcel = new AnalysisExcel(this.ctx, this.setting);
            const tempData = await this.ctx.service.tenderNodeTemplate.getData(templateId, true);
            const cacheTree = analysisExcel.analysisData(excelData, tempData, { filterZeroGcl: filter });
            cacheTree.calculateLeafWithPos();
            const transaction = await this.db.beginTransaction();
            try {
                await transaction.delete(this.tableName, { tender_id: this.ctx.tender.id });
                await transaction.delete(this.ctx.service.pos.tableName, { tid: this.ctx.tender.id });
                const datas = [];
                for (const node of cacheTree.items) {
                    const data = {
                        id: node.id,
                        tender_id: this.ctx.tender.id,
                        ledger_id: node.ledger_id,
                        ledger_pid: node.ledger_pid,
                        level: node.level,
                        order: node.order,
                        is_leaf: !node.children || node.children.length === 0,
                        full_path: node.full_path,
                        code: node.code,
                        b_code: node.b_code,
                        name: node.name,
                        unit: node.unit,
                        unit_price: node.unit_price,
                        dgn_qty1: node.dgn_qty1,
                        dgn_qty2: node.dgn_qty2,
                        memo: node.memo,
                        drawing_code: node.drawing_code,
                        node_type: node.node_type,
                        // 项目节不导入金额
                        // todo 最底层项目节其实应该导入，但是由于目前项目节不能输入金额，也不能计量，导入金额就会有矛盾，故暂时不导入
                        sgfh_qty: node.quantity,
                        sgfh_tp: node.b_code ? node.total_price : 0,
                        quantity: node.quantity,
                        total_price: node.b_code ? node.total_price : 0,
                        deal_qty: node.deal_qty,
                        deal_tp: node.b_code ? node.deal_tp : 0,
                    };
                    datas.push(data);
                }
                await transaction.insert(this.tableName, datas);
                if (this.ctx.tender.data.measure_type === measureType.tz.value
                    && cacheTree.pos && cacheTree.pos.length > 0) {
                    await transaction.insert(this.ctx.service.pos.tableName, cacheTree.pos);
                }
                await transaction.commit();
                this._cacheMaxLid(this.ctx.tender.id, cacheTree.keyNodeId);
                return { bills: datas, pos: cacheTree.pos };
            } catch (err) {
                await transaction.rollback();
                throw err;
            }
        }

        async importYbp(tender, ybp) {
            const YBP = require('../lib/ybp');
            const YbpTrees = require('../lib/ybp_tree');
            const gatherTreeSetting = {
                id: 'ledger_id', pid: 'ledger_pid', order: 'order', full_path: 'full_path', level: 'level', rootId: -1,
                calcFields: [ 'total_price' ],
                calc(node, helper, decimal) {
                    if (!node.children || node.children.length === 0) {
                        node.total_price = helper.mul(node.quantity, node.unit_price, decimal.tp);
                    }
                },
            };
            const ybpTreeSetting = { id: 'ID', pid: 'parentID', order: 'seq', rootId: '-1' };
            const helper = this.ctx.helper;

            const ybpAnalysis = new YBP(this.ctx);
            const ybpData = ybpAnalysis.decryptBuffer(ybp);
            const gatherTree = new YbpTrees.YbpImportTree(gatherTreeSetting, YbpTrees.YbpImportType.flow, helper, tender.info.decimal);
            for (const subject of ybpData.subjects) {
                if (!subject.bills || subject.bills.length === 0) continue;

                const ybpTree = new YbpTrees.YbpTree(ybpTreeSetting);
                ybpTree.loadDatas(subject.bills);
                const loadRelaFun = function (cur, node) {
                    if (node.children && node.children.length > 0) return;

                    const rations = subject.rations.filter(x => { return x.parentID === node.ID; });
                    if (rations.length === 0) return;

                    if (!cur.glj) cur.glj = [];
                    for (const r of rations) {
                        const gljs = r.gljList || r.rationGljList;
                        if (!gljs || gljs.length === 0) continue;
                        for (const g of gljs) {
                            let curGlj = cur.glj.find(x => {
                                if (x.projectGljID && g.projectGljID) return x.projectGljID === g.projectGljID;
                                return x.code === g.code && x.name === g.name && x.unit === g.unit && x.unit_price === g.unit_price;
                            });
                            if (!curGlj) {
                                curGlj = { code: g.code, name: g.name, unit: g.unit, unit_price: g.unit_price, spec: g.specs, projectGljID: g.projectGljID };
                                cur.glj.push(curGlj);
                            }
                            curGlj.quantity = helper.add(curGlj.quantity, g.quantity);
                        }
                    }
                };
                gatherTree.importTree(ybpTree, subject.project.name, loadRelaFun);
            }
            gatherTree.sort();
            gatherTree.calculateAll();

            const bills = [], glj = [];
            for (const n of gatherTree.nodes) {
                const billsId = this.uuid.v4();
                bills.push({
                    id: billsId,
                    tender_id: tender.id,
                    ledger_id: n.ledger_id,
                    ledger_pid: n.ledger_pid,
                    level: n.level,
                    order: n.order,
                    full_path: n.full_path,
                    is_leaf: !n.children || n.children.length === 0,
                    code: n.code,
                    b_code: n.b_code,
                    name: n.name,
                    unit: n.unit,
                    unit_price: n.unit_price || 0,
                    sgfh_qty: n.quantity || 0,
                    sgfh_tp: n.total_price || 0,
                    quantity: n.quantity || 0,
                    total_price: n.total_price || 0,
                    memo: n.source.join(';'),
                });
                if (!n.glj) continue;
                for (const g of n.glj) {
                    glj.push({
                        tid: tender.id,
                        lid: billsId,
                        code: g.code || '',
                        name: g.name || '',
                        unit: g.unit || '',
                        spec: g.spec || '',
                        quantity: helper.div(g.quantity, n.quantity, 4),
                    })
                }
            }
            const conn = await this.db.beginTransaction();
            try {
                await conn.delete(this.ctx.service.ledger.tableName, { tender_id: tender.id });
                await conn.delete(this.ctx.service.pos.tableName, { tid: tender.id });
                await conn.insert(this.ctx.service.ledger.tableName, bills);
                // if (glj.length > 0) await conn.insert(this.ctx.service.ledgerGlj.tableName, glj);
                await conn.commit();
                return bills;
            } catch (err) {
                await conn.rollback();
                throw err;
            }
        }

        async sumLoad(lid, tenders) {
            const maxId = await this._getMaxLid(this.ctx.tender.id);
            const select = await this.getDataById(lid);
            const sumLoad = new SumLoad(this.ctx);
            const loadTree = await sumLoad.loadGatherGcl(select, maxId, tenders, {});
            const result = loadTree.getUpdateData();

            const conn = await this.db.beginTransaction();
            try {
                this._cacheMaxLid(this.ctx.tender.id, loadTree.keyNodeId);
                await this.ctx.service.sumLoadHistory.saveLedgerHistory(this.ctx.tender.id, lid, tenders);
                if (result.update.length > 0) await conn.updateRows(this.tableName, result.update);
                if (result.create.length > 0) await conn.insert(this.tableName, result.create);
                await conn.commit();
                return result;
            } catch (err) {
                await conn.rollback();
                throw (err.stack ? '导入工程量数据出错': err);
            }
        }

        async getMemoData(tid, columns) {
            if (!columns || columns.length === 0) return [];

            return await this.db.select(this.departTableName(tid), {
                where: { tender_id: tid },
                columns: ['id', ...columns],
            });
        }
    }

    return Ledger;
};