Calculation/app/service/rpt_gather_memory.js

'use strict';

/**
 *
 *
 * @author Mai
 * @date
 * @version
 */

const Ledger = require('../lib/ledger');
const PayCalculator = require('../lib/pay_calc');

const auditConst = require('../const/audit');
const payConst = require('../const/deal_pay');
const changeConst = require('../const/change');

const moment = require('moment');

const indexPre = 'id_';
const normalPrefix = 't_', sumPrefix = 's_', specPrefix = 'ts_';

const gatherUtils = {
    completeGatherData: function (datas, completeDatas) {
        for (const data of datas) {
            for (const cd of completeDatas) {
                data[cd.prefix + 'id'] = cd.id;
                data[cd.prefix + 'name'] = cd.name;
                data[cd.prefix + 'category'] = cd.category;
            }
        }
    },
    gatherStage: function (tender, gatherNode, sourceNode, prefix, helper) {
        gatherNode[prefix + 'id'] = tender.id;
        gatherNode[prefix + 'name'] = tender.name;
        gatherNode[prefix + 'category'] = tender.category;

        gatherNode[prefix + "qty"] = helper.add(gatherNode[prefix + "qty"], sourceNode.quantity);
        gatherNode[prefix + "tp"] = helper.add(gatherNode[prefix + "tp"], sourceNode.total_price);

        gatherNode[prefix + "dgn_qty1"] = helper.add(gatherNode[prefix + "dgn_qty1"], sourceNode.dgn_qty1);
        gatherNode[prefix + "dgn_qty2"] = helper.add(gatherNode[prefix + "dgn_qty2"], sourceNode.dgn_qty2);

        gatherNode[prefix + "contract_qty"] = helper.add(gatherNode[prefix + "contract_qty"], sourceNode.contract_qty);
        gatherNode[prefix + "contract_tp"] = helper.add(gatherNode[prefix + "contract_tp"], sourceNode.contract_tp);
        gatherNode[prefix + "qc_qty"] = helper.add(gatherNode[prefix + "qc_qty"], sourceNode.qc_qty);
        gatherNode[prefix + "qc_tp"] = helper.add(gatherNode[prefix + "qc_tp"], sourceNode.qc_tp);
        gatherNode[prefix + "gather_qty"] = helper.add(gatherNode[prefix + "gather_qty"], sourceNode.gather_qty);
        gatherNode[prefix + "gather_tp"] = helper.add(gatherNode[prefix + "gather_tp"], sourceNode.gather_tp);
        gatherNode[prefix + 'pc_tp'] = helper.add(gatherNode[prefix + 'pc_tp'], sourceNode.pc_tp);

        gatherNode[prefix + "pre_contract_qty"] = helper.add(gatherNode[prefix + "pre_contract_qty"], sourceNode.pre_contract_qty);
        gatherNode[prefix + "pre_contract_tp"] = helper.add(gatherNode[prefix + "pre_contract_tp"], sourceNode.pre_contract_tp);
        gatherNode[prefix + "pre_qc_qty"] = helper.add(gatherNode[prefix + "pre_qc_qty"], sourceNode.pre_qc_qty);
        gatherNode[prefix + "pre_qc_tp"] = helper.add(gatherNode[prefix + "pre_qc_tp"], sourceNode.pre_qc_tp);
        gatherNode[prefix + "pre_gather_qty"] = helper.add(gatherNode[prefix + "pre_gather_qty"], sourceNode.pre_gather_qty);
        gatherNode[prefix + "pre_gather_tp"] = helper.add(gatherNode[prefix + "pre_gather_tp"], sourceNode.pre_gather_tp);

        gatherNode[prefix + "end_contract_qty"] = helper.add(gatherNode[prefix + "end_contract_qty"], sourceNode.end_contract_qty);
        gatherNode[prefix + "end_contract_tp"] = helper.add(gatherNode[prefix + "end_contract_tp"], sourceNode.end_contract_tp);
        gatherNode[prefix + "end_qc_qty"] = helper.add(gatherNode[prefix + "end_qc_qty"], sourceNode.end_qc_qty);
        gatherNode[prefix + "end_qc_tp"] = helper.add(gatherNode[prefix + "end_qc_tp"], sourceNode.end_qc_tp);
        gatherNode[prefix + "end_gather_qty"] = helper.add(gatherNode[prefix + "end_gather_qty"], sourceNode.end_gather_qty);
        gatherNode[prefix + "end_gather_tp"] = helper.add(gatherNode[prefix + "end_gather_tp"], sourceNode.end_gather_tp);

        gatherNode[prefix + "deal_dgn_qty1"] = helper.add(gatherNode[prefix + "deal_dgn_qty1"], sourceNode.deal_dgn_qty1);
        gatherNode[prefix + "deal_dgn_qty2"] = helper.add(gatherNode[prefix + "deal_dgn_qty2"], sourceNode.deal_dgn_qty2);
        gatherNode[prefix + "c_dgn_qty1"] = helper.add(gatherNode[prefix + "c_dgn_qty1"], sourceNode.c_dgn_qty1);
        gatherNode[prefix + "c_dgn_qty2"] = helper.add(gatherNode[prefix + "c_dgn_qty2"], sourceNode.c_dgn_qty2);

        gatherNode.s_qty = helper.add(gatherNode.s_qty, sourceNode.quantity);
        gatherNode.s_tp = helper.add(gatherNode.s_tp, sourceNode.total_price);

        gatherNode.s_dgn_qty1 = helper.add(gatherNode.s_dgn_qty1, sourceNode.dgn_qty1);
        gatherNode.s_dgn_qty2 = helper.add(gatherNode.s_dgn_qty2, sourceNode.dgn_qty2);

        gatherNode.s_contract_qty = helper.add(gatherNode.s_contract_qty, sourceNode.contract_qty);
        gatherNode.s_contract_tp = helper.add(gatherNode.s_contract_tp, sourceNode.contract_tp);
        gatherNode.s_qc_qty = helper.add(gatherNode.s_qc_qty, sourceNode.qc_qty);
        gatherNode.s_qc_tp = helper.add(gatherNode.s_qc_tp, sourceNode.qc_tp);
        gatherNode.s_gather_qty = helper.add(gatherNode.s_gather_qty, sourceNode.gather_qty);
        gatherNode.s_gather_tp = helper.add(gatherNode.s_gather_tp, sourceNode.gather_tp);
        gatherNode.s_pc_tp = helper.add(gatherNode.s_pc_tp, sourceNode.pc_tp);

        gatherNode.s_pre_contract_qty = helper.add(gatherNode.s_pre_contract_qty, sourceNode.pre_contract_qty);
        gatherNode.s_pre_contract_tp = helper.add(gatherNode.s_pre_contract_tp, sourceNode.pre_contract_tp);
        gatherNode.s_pre_qc_qty = helper.add(gatherNode.s_pre_qc_qty, sourceNode.pre_qc_qty);
        gatherNode.s_pre_qc_tp = helper.add(gatherNode.s_pre_qc_tp, sourceNode.pre_qc_tp);
        gatherNode.s_pre_gather_qty = helper.add(gatherNode.s_pre_gather_qty, sourceNode.pre_gather_qty);
        gatherNode.s_pre_gather_tp = helper.add(gatherNode.s_pre_gather_tp, sourceNode.pre_gather_tp);

        gatherNode.s_end_contract_qty = helper.add(gatherNode.s_end_contract_qty, sourceNode.end_contract_qty);
        gatherNode.s_end_contract_tp = helper.add(gatherNode.s_end_contract_tp, sourceNode.end_contract_tp);
        gatherNode.s_end_qc_qty = helper.add(gatherNode.s_end_qc_qty, sourceNode.end_qc_qty);
        gatherNode.s_end_qc_tp = helper.add(gatherNode.s_end_qc_tp, sourceNode.end_qc_tp);
        gatherNode.s_end_gather_qty = helper.add(gatherNode.s_end_gather_qty, sourceNode.end_gather_qty);
        gatherNode.s_end_gather_tp = helper.add(gatherNode.s_end_gather_tp, sourceNode.end_gather_tp);

        gatherNode.s_deal_dgn_qty1 = helper.add(gatherNode.s_deal_dgn_qty1, sourceNode.deal_dgn_qty1);
        gatherNode.s_deal_dgn_qty2 = helper.add(gatherNode.s_deal_dgn_qty2, sourceNode.deal_dgn_qty2);
        gatherNode.s_c_dgn_qty1 = helper.add(gatherNode.s_c_dgn_qty1, sourceNode.c_dgn_qty1);
        gatherNode.s_c_dgn_qty2 = helper.add(gatherNode.s_c_dgn_qty2, sourceNode.c_dgn_qty2);
    },
    gatherZone: function (tender, gatherNode, sourceNode, prefix, helper) {
        gatherNode[prefix + 'id'] = tender.id;
        gatherNode[prefix + 'name'] = tender.name;
        gatherNode[prefix + 'category'] = tender.category;

        gatherNode[prefix + "qty"] = helper.add(gatherNode[prefix + "qty"], sourceNode.quantity);
        gatherNode[prefix + "tp"] = helper.add(gatherNode[prefix + "tp"], sourceNode.total_price);

        gatherNode[prefix + "dgn_qty1"] = helper.add(gatherNode[prefix + "dgn_qty1"], sourceNode.dgn_qty1);
        gatherNode[prefix + "dgn_qty2"] = helper.add(gatherNode[prefix + "dgn_qty2"], sourceNode.dgn_qty2);

        gatherNode[prefix + "contract_qty"] = helper.add(gatherNode[prefix + "contract_qty"], sourceNode.contract_qty);
        gatherNode[prefix + "contract_tp"] = helper.add(gatherNode[prefix + "contract_tp"], sourceNode.contract_tp);
        gatherNode[prefix + "qc_qty"] = helper.add(gatherNode[prefix + "qc_qty"], sourceNode.qc_qty);
        gatherNode[prefix + "qc_tp"] = helper.add(gatherNode[prefix + "qc_tp"], sourceNode.qc_tp);
        gatherNode[prefix + "gather_qty"] = helper.add(gatherNode[prefix + "gather_qty"], sourceNode.gather_qty);
        gatherNode[prefix + "gather_tp"] = helper.add(gatherNode[prefix + "gather_tp"], sourceNode.gather_tp);
        gatherNode[prefix + 'pc_tp'] = helper.add(gatherNode[prefix + 'pc_tp'], sourceNode.pc_tp);

        gatherNode[prefix + "deal_dgn_qty1"] = helper.add(gatherNode[prefix + "deal_dgn_qty1"], sourceNode.deal_dgn_qty1);
        gatherNode[prefix + "deal_dgn_qty2"] = helper.add(gatherNode[prefix + "deal_dgn_qty2"], sourceNode.deal_dgn_qty2);
        gatherNode[prefix + "c_dgn_qty1"] = helper.add(gatherNode[prefix + "c_dgn_qty1"], sourceNode.c_dgn_qty1);
        gatherNode[prefix + "c_dgn_qty2"] = helper.add(gatherNode[prefix + "c_dgn_qty2"], sourceNode.c_dgn_qty2);

        gatherNode.s_qty = helper.add(gatherNode.s_qty, sourceNode.quantity);
        gatherNode.s_tp = helper.add(gatherNode.s_tp, sourceNode.total_price);

        gatherNode.s_contract_qty = helper.add(gatherNode.s_contract_qty, sourceNode.contract_qty);
        gatherNode.s_contract_tp = helper.add(gatherNode.s_contract_tp, sourceNode.contract_tp);
        gatherNode.s_qc_qty = helper.add(gatherNode.s_qc_qty, sourceNode.qc_qty);
        gatherNode.s_qc_tp = helper.add(gatherNode.s_qc_tp, sourceNode.qc_tp);
        gatherNode.s_gather_qty = helper.add(gatherNode.s_gather_qty, sourceNode.gather_qty);
        gatherNode.s_gather_tp = helper.add(gatherNode.s_gather_tp, sourceNode.gather_tp);
        gatherNode.s_pc_tp = helper.add(gatherNode.s_pc_tp, sourceNode.pc_tp);
    },
    gatherLedger: function (tender, gatherNode, sourceNode, prefix, helper) {
        gatherNode[prefix + 'id'] = tender.id;
        gatherNode[prefix + 'name'] = tender.name;
        gatherNode[prefix + 'category'] = tender.category;

        gatherNode[prefix + "qty"] = helper.add(gatherNode[prefix + "qty"], sourceNode.quantity);
        gatherNode[prefix + "tp"] = helper.add(gatherNode[prefix + "tp"], sourceNode.total_price);

        gatherNode[prefix + "dgn_qty1"] = helper.add(gatherNode[prefix + "dgn_qty1"], sourceNode.dgn_qty1);
        gatherNode[prefix + "dgn_qty2"] = helper.add(gatherNode[prefix + "dgn_qty2"], sourceNode.dgn_qty2);

        gatherNode.s_qty = helper.add(gatherNode.s_qty, sourceNode.quantity);
        gatherNode.s_tp = helper.add(gatherNode.s_tp, sourceNode.total_price);
    },
    gatherSpecial: function (gatherNode, sourceNode, prefix, helper) {
        gatherNode[prefix + "qty"] = helper.add(gatherNode[prefix + "qty"], sourceNode.quantity);
        gatherNode[prefix + "tp"] = helper.add(gatherNode[prefix + "tp"], sourceNode.total_price);

        gatherNode[prefix + "dgn_qty1"] = helper.add(gatherNode[prefix + "dgn_qty1"], sourceNode.dgn_qty1);
        gatherNode[prefix + "dgn_qty2"] = helper.add(gatherNode[prefix + "dgn_qty2"], sourceNode.dgn_qty2);
    },
    gatherStagePos: function (tender, gatherNode, sourceNode, prefix, helper) {
        gatherNode[prefix + 'id'] = tender.id;
        gatherNode[prefix + 'name'] = tender.name;
        gatherNode[prefix + 'category'] = tender.category;

        gatherNode[prefix + "qty"] = helper.add(gatherNode[prefix + "qty"], sourceNode.quantity);

        gatherNode[prefix + "contract_qty"] = helper.add(gatherNode[prefix + "contract_qty"], sourceNode.contract_qty);
        gatherNode[prefix + "qc_qty"] = helper.add(gatherNode[prefix + "qc_qty"], sourceNode.qc_qty);
        gatherNode[prefix + "gather_qty"] = helper.add(gatherNode[prefix + "gather_qty"], sourceNode.gather_qty);

        gatherNode[prefix + "pre_contract_qty"] = helper.add(gatherNode[prefix + "pre_contract_qty"], sourceNode.pre_contract_qty);
        gatherNode[prefix + "pre_qc_qty"] = helper.add(gatherNode[prefix + "pre_qc_qty"], sourceNode.pre_qc_qty);
        gatherNode[prefix + "pre_gather_qty"] = helper.add(gatherNode[prefix + "pre_gather_qty"], sourceNode.pre_gather_qty);

        gatherNode[prefix + "end_contract_qty"] = helper.add(gatherNode[prefix + "end_contract_qty"], sourceNode.end_contract_qty);
        gatherNode[prefix + "end_qc_qty"] = helper.add(gatherNode[prefix + "end_qc_qty"], sourceNode.end_qc_qty);
        gatherNode[prefix + "end_gather_qty"] = helper.add(gatherNode[prefix + "end_gather_qty"], sourceNode.end_gather_qty);

        gatherNode.s_qty = helper.add(gatherNode.s_qty, sourceNode.quantity);

        gatherNode.s_contract_qty = helper.add(gatherNode.s_contract_qty, sourceNode.contract_qty);
        gatherNode.s_qc_qty = helper.add(gatherNode.s_qc_qty, sourceNode.qc_qty);
        gatherNode.s_gather_qty = helper.add(gatherNode.s_gather_qty, sourceNode.gather_qty);

        gatherNode.s_pre_contract_qty = helper.add(gatherNode.s_pre_contract_qty, sourceNode.pre_contract_qty);
        gatherNode.s_pre_qc_qty = helper.add(gatherNode.s_pre_qc_qty, sourceNode.pre_qc_qty);
        gatherNode.s_pre_gather_qty = helper.add(gatherNode.s_pre_gather_qty, sourceNode.pre_gather_qty);

        gatherNode.s_end_contract_qty = helper.add(gatherNode.s_end_contract_qty, sourceNode.end_contract_qty);
        gatherNode.s_end_qc_qty = helper.add(gatherNode.s_end_qc_qty, sourceNode.end_qc_qty);
        gatherNode.s_end_gather_qty = helper.add(gatherNode.s_end_gather_qty, sourceNode.end_gather_qty);
    },
    gatherZonePos: function (tender, gatherNode, sourceNode, prefix, helper) {
        gatherNode[prefix + 'id'] = tender.id;
        gatherNode[prefix + 'name'] = tender.name;
        gatherNode[prefix + 'category'] = tender.category;

        gatherNode[prefix + "qty"] = helper.add(gatherNode[prefix + "qty"], sourceNode.quantity);

        gatherNode[prefix + "contract_qty"] = helper.add(gatherNode[prefix + "contract_qty"], sourceNode.contract_qty);
        gatherNode[prefix + "qc_qty"] = helper.add(gatherNode[prefix + "qc_qty"], sourceNode.qc_qty);
        gatherNode[prefix + "gather_qty"] = helper.add(gatherNode[prefix + "gather_qty"], sourceNode.gather_qty);

        gatherNode.s_qty = helper.add(gatherNode.s_qty, sourceNode.quantity);

        gatherNode.s_contract_qty = helper.add(gatherNode.s_contract_qty, sourceNode.contract_qty);
        gatherNode.s_qc_qty = helper.add(gatherNode.s_qc_qty, sourceNode.qc_qty);
        gatherNode.s_gather_qty = helper.add(gatherNode.s_gather_qty, sourceNode.gather_qty);
    },
    gatherPos: function (tender, gatherNode, sourceNode, prefix, helper) {
        gatherNode[prefix + 'id'] = tender.id;
        gatherNode[prefix + 'name'] = tender.name;
        gatherNode[prefix + 'category'] = tender.category;

        gatherNode[prefix + "qty"] = helper.add(gatherNode[prefix + "qty"], sourceNode.quantity);

        gatherNode.s_qty = helper.add(gatherNode.s_qty, sourceNode.quantity);
    },
    gatherSpecialPos: function (gatherNode, sourceNode, prefix, helper) {
        gatherNode[prefix + "qty"] = helper.add(gatherNode[prefix + "qty"], sourceNode.quantity);
    },
};
const rmUtils = require('../lib/rm/rm_utils');

module.exports = app => {
    class RptGatherMemory extends app.BaseService {

        /**
         * 构造函数
         *
         * @param {Object} ctx - egg全局context
         * @return {void}
         */
        constructor(ctx) {
            super(ctx);
            this.resultTree = null;
            this.resultPos = null;
            this.resultTenderInfo = [];
            this.resultDealPay = [];
            this.resultDealBills = [];
        }

        async _getValidStages(tenderId, sort = 'desc') {
            const stages = await this.db.select(this.ctx.service.stage.tableName, {
                where: { tid: tenderId },
                orders: [['order', sort]],
            });
            if (stages.length !== 0) {
                const lastStage = stages[0];
                if (lastStage.status === auditConst.stage.status.uncheck && lastStage.user_id !== this.ctx.session.sessionUser.accountId) {
                    stages.splice(0, 1);
                }
            }
            return stages;
        }

        async _getCheckedStages(tenderId) {
            const stages = await this.db.select(this.ctx.service.stage.tableName, {
                where: { tid: tenderId },
                orders: [['order', 'desc']],
            });
            if (stages.length !== 0) {
                const lastStage = stages[0];
                if (lastStage.status !== auditConst.stage.status.checked) {
                    stages.splice(0, 1);
                }
            }
            return stages;
        }

        _checkSpecialTender(tender, special) {
            if (special) {
                for (const spec of special) {
                    if (tender[spec.key] === true) return spec.key;
                }
            }
            return '';
        }

        async _getTimeZoneStages(tender, zone) {
            const times = zone.split(' - ');
            if (times.length !== 2) throw '选择的汇总周期无效';
            const beginTime = moment(times[0], 'YYYY-MM');
            const endTime = moment(times[1], 'YYYY-MM');

            const stages = await this._getValidStages(tender.id, 'asc'), validStages = [];
            let preStage, endStage;
            for (const stage of stages) {
                const sTime = moment(stage.s_time, 'YYYY-MM');
                if (sTime.isBetween(beginTime, endTime, null, '[]')) {
                    validStages.push(stage);
                } else if (sTime.isBefore(beginTime)) {
                    if (!preStage || moment(preStage.s_time, 'YYYY-MM').isBefore(sTime)) preStage = stage;
                } else if (sTime.isAfter(endTime)) {
                    if (!endStage || moment(endStage.s_time, 'YYYY-MM').isAfter(sTime)) endStage = stage;
                }
            }
            return [validStages, preStage, endStage];
        }
        async _getOrderZoneStages (tender, zone) {
            let [iBegin, iEnd] = zone.split(':');
            iBegin = this.ctx.helper._.toInteger(iBegin) || 0;
            iEnd = this.ctx.helper._.toInteger(iEnd) || 0;
            const stages = await this._getValidStages(tender.id, 'asc'), validStages = [];
            let preStage, endStage;
            for (const stage of stages) {
                if (stage.order < iBegin) {
                    if (!preStage || preStage.order < stage.order) preStage = stage;
                } else if (stage.order > iEnd) {
                    if (!endStage || endStage.order > stage.order) endStage = stage;
                } else {
                    validStages.push(stage);
                }
            }
            return [validStages, preStage, endStage];
        }
        async _getCheckedZoneStages(tender, zone) {
            const times = zone.split(' - ');
            if (times.length !== 2) throw '选择的汇总周期无效';
            const beginTime = moment(times[0], 'YYYY-MM-DD');
            const endTime = moment(times[1], 'YYYY-MM-DD');

            const stages = await this._getValidStages(tender.id, 'asc'), validStages = [];
            let preStage, endStage;
            for (const stage of stages) {
                if (stage.status !== auditConst.stage.status.checked) continue;

                const finalAudit = await this.ctx.service.stageAudit.getLastestAuditor(stage.id, stage.times, stage.status);
                if (!finalAudit) continue;

                const sTime = moment(moment(finalAudit.end_time).format('YYYY-MM-DD'), 'YYYY-MM-DD');
                stage.checked_day = sTime;
                stage.checked_time = moment(finalAudit.end_time);
                if (sTime.isBetween(beginTime, endTime, null, '[]')) {
                    validStages.push(stage);
                } else if (sTime.isBefore(beginTime)) {
                    if (!preStage || preStage.checked_time.isBefore(stage.checked_time)) preStage = stage;
                } else if (sTime.isAfter(endTime)) {
                    if (!endStage || endStage.checked_time.isAfter(stage.checked_time)) endStage = stage;
                }
            }
            return [validStages, preStage, endStage];
        }
        async _getMonthStages(tender, month) {
            const stages = await this._getValidStages(tender.id, 'asc'), validStages = [];
            for (const stage of stages) {
                if (stage.s_time === month) validStages.push(stage);
            }
            const preStage = stages.length > 0 ? stages.find(x => { return x.order === stages[0].order - 1; }) : null;
            const endStage = stages.length > 0 ? stages.find(x => { return x.order === stages[stages.length - 1].order + 1; }) : null;
            return [validStages, preStage, endStage];
        }

        /**
         * 台账数据
         */

        async _gatherStagesData(completeData, tender, stages, preStage) {
            const resultPos = this.resultPos;
            const helper = this.ctx.helper;
            completeData.id = tender.id;
            completeData.name = tender.name;
            /**
             * 汇总并合并 相关数据
             * @param {Array} index - 主数据
             * @param {Array[]}rela - 相关数据 {data, fields, prefix, relaId}
             */
            const sumAssignRelaData = function (index, rela) {
                const loadFields = function (datas, fields, prefix, relaId) {
                    for (const d of datas) {
                        const key = indexPre + d[relaId];
                        const m = index[key];
                        if (m) {
                            for (const f of fields) {
                                if (d[f] !== undefined) {
                                    m[prefix + f] = helper.add(m[prefix + f], d[f]);
                                }
                            }
                        }
                    }
                };
                for (const r of rela) {
                    loadFields(r.data, r.fields, r.prefix, r.relaId);
                }
            };
            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',
                calcFields: ['deal_tp', 'total_price', 'contract_tp', 'qc_tp', 'gather_tp', 'contract_pc_tp', 'qc_pc_tp', 'pc_tp', 'pre_contract_tp', 'pre_qc_tp', 'pre_gather_tp'],
                calc: function (node) {
                    if (node.children && node.children.length === 0) {
                        node.pre_gather_qty = helper.add(node.pre_contract_qty, node.pre_qc_qty);
                        node.gather_qty = helper.add(node.contract_qty, node.qc_qty);
                        node.end_contract_qty = helper.add(node.pre_contract_qty, node.contract_qty);
                        node.end_qc_qty = helper.add(node.pre_qc_qty, node.qc_qty);
                        node.end_gather_qty = helper.add(node.pre_gather_qty, node.gather_qty);
                    }
                    node.pre_gather_tp = helper.add(node.pre_contract_tp, node.pre_qc_tp);
                    node.gather_tp = helper.add(node.contract_tp, node.qc_tp);
                    node.end_contract_tp = helper.add(node.pre_contract_tp, node.contract_tp);
                    node.end_qc_tp = helper.add(node.pre_qc_tp, node.qc_tp);
                    node.end_gather_tp = helper.add(node.pre_gather_tp, node.gather_tp);
                }
            });
            const billsData = await this.ctx.service.ledger.getData(tender.id);
            const dgnData = await this.ctx.service.stageBillsDgn.getDgnData(tender.id);
            for (const d of dgnData) {
                const l = this.ctx.helper._.find(billsData, {id: d.id});
                this.ctx.helper._.assignIn(l, d);
            }
            const pos = new Ledger.pos({
                id: 'id', ledgerId: 'lid',
                calc: function (node) {
                    node.pre_gather_qty = helper.add(node.pre_contract_qty, node.pre_qc_qty);
                    node.gather_tp = helper.sum([node.contract_tp, node.qc_tp, node.pc_tp]);
                    node.end_contract_tp = helper.sum([node.pre_contract_tp, node.contract_tp, node.contract_pc_tp]);
                    node.end_qc_tp = helper.sum([node.pre_qc_tp, node.qc_tp, node.qc_pc_tp]);
                    node.end_gather_qty = helper.add(node.pre_gather_qty, node.gather_qty);
                },
            });
            const posData = await this.ctx.service.pos.getAllDataByCondition({ where: { tid: tender.id} });
            let billsIndexData = {};
            for (const bd of billsData) {
                billsIndexData[indexPre + bd.id] = bd;
            }
            let posIndexData = {};
            for (const p of posData) {
                posIndexData[indexPre + p.id] = p;
            }

            if (preStage) {
                await this.ctx.service.stage.doCheckStage(preStage);
                const endStage = await this.ctx.service.stageBillsFinal.getFinalData(tender, preStage.order);
                sumAssignRelaData(billsIndexData, [
                    { data: endStage, fields: ['contract_qty', 'contract_tp', 'qc_qty', 'qc_tp'], prefix: 'pre_', relaId: 'lid' },
                ]);
                const endStagePos = await this.ctx.service.stagePosFinal.getFinalData(tender, preStage.order);
                sumAssignRelaData(posIndexData, [
                    {data: endStagePos, fields: ['contract_qty', 'qc_qty'], prefix: 'pre_', relaId: 'lid'},
                ]);
            }

            for (const stage of stages) {
                await this.ctx.service.stage.doCheckStage(stage);
                const curStage = stage.readOnly
                    ? await this.ctx.service.stageBills.getAuditorStageData2(tender.id, stage.id, stage.curTimes, stage.curOrder)
                    : await this.ctx.service.stageBills.getLastestStageData2(tender.id, stage.id);
                const bpcStage = await this.ctx.service.stageBillsPc.getAllDataByCondition({ where: { sid: stage.id } });
                sumAssignRelaData(billsIndexData, [
                    {data: curStage, fields: ['contract_qty', 'contract_tp', 'qc_qty', 'qc_tp'], prefix: '', relaId: 'lid'},
                    { data: bpcStage, fields: ['contract_pc_tp', 'qc_pc_tp', 'pc_tp'], prefix: '', relaId: 'lid' },
                ]);
                const curStagePos = stage.readOnly
                    ? await this.ctx.service.stagePos.getAuditorStageData2(tender.id, stage.id, stage.curTimes, stage.curOrder)
                    : await this.ctx.service.stagePos.getLastestStageData2(tender.id, stage.id);
                sumAssignRelaData(posIndexData, [
                    {data: curStagePos, fields: ['contract_qty', 'qc_qty'], prefix: '', relaId: 'pid'},
                ]);
            }

            billsTree.loadDatas(billsData);
            billsTree.calculateAll();
            pos.loadDatas(posData);
            pos.calculateAll();
            this.resultTree.loadGatherTree(billsTree, function (gatherNode, sourceNode) {
                gatherUtils.gatherStage(tender, gatherNode, sourceNode, completeData.prefix, helper);
            }, function (gatherNode, sourceNode) {
                const posRange = pos.getLedgerPos(sourceNode.id);
                if (!posRange || posRange.length === 0) return;
                resultPos.loadGatherPos(gatherNode.id, posRange, (gatherPos, sourcePos) => {
                    gatherUtils.gatherStagePos(tender, gatherPos, sourcePos, completeData.prefix, helper);
                });
            });
        }
        async _gatherZoneData(tender, completeData, zone) {
            const [stages, preStage, endStage] = await this._getTimeZoneStages(tender, zone);
            await this._gatherStagesData(completeData, tender, stages, preStage);
        }
        async _gatherIndexZoneData(tender, completeData, stageZone) {
            const [stages, preStage, endStage] = await this._getOrderZoneStages(tender, stageZone);
            await this._gatherStagesData(completeData, tender, stages, preStage);
        }
        async _gatherCheckedZoneData(tender, completeData, zone) {
            const [stages, preStage, endStage] = await this._getCheckedZoneStages(tender, zone);
            await this._gatherStagesData(completeData, tender, stages, preStage);
        }
        async _gatherMonthsData(tender, completeData, month) {
            const [stages, preStage, endStage] = await this._getMonthStages(tender, month);
            await this._gatherStagesData(completeData, tender, stages, preStage);
        }

        async _gatherStageData(completeData, tender, stage, hasPre) {
            const helper = this.ctx.helper;
            const resultPos = this.resultPos;
            completeData.id = tender.id;
            completeData.name = tender.name;

            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',
                calcFields: ['deal_tp', 'total_price', 'contract_tp', 'qc_tp', 'contract_pc_tp', 'qc_pc_tp', 'pc_tp', 'gather_tp', 'pre_contract_tp', 'pre_qc_tp', 'pre_gather_tp'],
                calc: function (node) {
                    if (node.children && node.children.length === 0) {
                        node.pre_gather_qty = helper.add(node.pre_contract_qty, node.pre_qc_qty);
                        node.gather_qty = helper.add(node.contract_qty, node.qc_qty);
                        node.end_contract_qty = helper.add(node.pre_contract_qty, node.contract_qty);
                        node.end_qc_qty = helper.add(node.pre_qc_qty, node.qc_qty);
                        node.end_gather_qty = helper.add(node.pre_gather_qty, node.gather_qty);
                    }
                    node.pre_gather_tp = helper.add(node.pre_contract_tp, node.pre_qc_tp);
                    node.gather_tp = helper.sum([node.contract_tp, node.qc_tp, node.pc_tp]);
                    node.end_contract_tp = helper.sum([node.pre_contract_tp, node.contract_tp, node.contract_pc_tp]);
                    node.end_qc_tp = helper.sum([node.pre_qc_tp, node.qc_tp, node.qc_pc_tp]);
                    node.end_gather_tp = helper.add(node.pre_gather_tp, node.gather_tp);
                }
            });
            const billsData = await this.ctx.service.ledger.getData(tender.id);
            const dgnData = await this.ctx.service.stageBillsDgn.getDgnData(tender.id);
            for (const d of dgnData) {
                const l = this.ctx.helper._.find(billsData, {id: d.id});
                this.ctx.helper._.assignIn(l, d);
            }
            const pos = new Ledger.pos({
                id: 'id', ledgerId: 'lid',
                calc: function (node) {
                    node.pre_gather_qty = helper.add(node.pre_contract_qty, node.pre_qc_qty);
                    node.gather_qty = helper.add(node.contract_qty, node.qc_qty);
                    node.end_contract_qty = helper.add(node.pre_contract_qty, node.contract_qty);
                    node.end_qc_qty = helper.add(node.pre_qc_qty, node.qc_qty);
                    node.end_gather_qty = helper.add(node.pre_gather_qty, node.gather_qty);
                },
            });
            const posData = await this.ctx.service.pos.getPosData({ tid: tender.id });
            if (stage) {
                await this.ctx.service.stage.doCheckStage(stage);
                const curStage = stage.readOnly
                    ? await this.ctx.service.stageBills.getAuditorStageData2(tender.id, stage.id, stage.curTimes, stage.curOrder)
                    : await this.ctx.service.stageBills.getLastestStageData2(tender.id, stage.id);
                const preStage = hasPre && stage.order > 1 ? await this.ctx.service.stageBillsFinal.getFinalData(tender, stage.order - 1) : [];
                const bpcStage = await this.ctx.service.stageBillsPc.getAllDataByCondition({ where: { sid: stage.id } });
                this.ctx.helper.assignRelaData(billsData, [
                    { data: curStage, fields: ['contract_qty', 'contract_tp', 'qc_qty', 'qc_tp'], prefix: '', relaId: 'lid' },
                    { data: preStage, fields: ['contract_qty', 'contract_tp', 'qc_qty', 'qc_tp'], prefix: 'pre_', relaId: 'lid' },
                    { data: bpcStage, fields: ['contract_pc_tp', 'qc_pc_tp', 'pc_tp'], prefix: '', relaId: 'lid' },
                ]);

                const curStagePos = stage.readOnly
                    ? await this.ctx.service.stagePos.getAuditorStageData2(tender.id, stage.id, stage.curTimes, stage.curOrder)
                    : await this.ctx.service.stagePos.getLastestStageData2(tender.id, stage.id);
                const preStagePos = hasPre && stage.order > 1 ? await this.ctx.service.stagePosFinal.getFinalData(tender, stage.order - 1) : [];
                this.ctx.helper.assignRelaData(posData, [
                    { data: curStagePos, fields: ['contract_qty', 'qc_qty'], prefix: '', relaId: 'pid' },
                    { data: preStagePos, fields: ['contract_qty', 'qc_qty'], prefix: 'pre_', relaId: 'pid' },
                ]);
            }
            billsTree.loadDatas(billsData);
            billsTree.calculateAll();
            pos.loadDatas(posData);
            pos.calculateAll();

            this.resultTree.loadGatherTree(billsTree, function (gatherNode, sourceNode) {
                gatherUtils.gatherStage(tender, gatherNode, sourceNode, completeData.prefix, helper);
            }, function (gatherNode, sourceNode) {
                const posRange = pos.getLedgerPos(sourceNode.id);
                if (!posRange || posRange.length === 0) return;
                resultPos.loadGatherPos(gatherNode.id, posRange, (gatherPos, sourcePos) => {
                    gatherUtils.gatherStagePos(tender, gatherPos, sourcePos, completeData.prefix, helper);
                });
            });
        }
        async _gatherMonthData(tender, completeData, month, hasPre) {
            const stages = await this._getValidStages(tender.id);
            const stage = this.ctx.helper._.find(stages, {s_time: month});
            await this._gatherStageData(completeData, tender, stage, hasPre);
        }
        async _gatherIndexData(tender, completeData, index, hasPre) {
            const stages = await this._getValidStages(tender.id);
            const stage = this.ctx.helper._.find(stages, {order: index});
            await this._gatherStageData(completeData, tender, stage, hasPre);
        }
        async _gatherFinalData(tender, completeData, hasPre) {
            const stages = await this._getValidStages(tender.id);
            await this._gatherStageData(completeData, tender, stages[0], hasPre);
        }
        async _gatherCheckedFinalData(tender, completeData, hasPre) {
            const stages = await this._getCheckedStages(tender.id);
            await this._gatherStageData(completeData, tender, stages[0], hasPre);
        }

        async _loadGatherLedger(tender) {
            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',
                calcFields: ['deal_tp', 'total_price'],
            });
            const billsData = await this.ctx.service.ledger.getData(tender.id);
            billsTree.loadDatas(billsData);
            billsTree.calculateAll();
            return billsTree;
        }
        async _loadGatherPos(tender) {
            const pos = new Ledger.pos({ id: 'id', ledgerId: 'lid' });
            const posData = await this.ctx.service.pos.getAllDataByCondition({ where: { tid: tender.id } });
            pos.loadDatas(posData);
            return pos;
        }
        async _gatherLedgerData(tender, completeData) {
            const resultPos = this.resultPos;
            const helper = this.ctx.helper;
            const billsTree = await this._loadGatherLedger(tender);
            const pos = await this._loadGatherPos(tender);
            this.resultTree.loadGatherTree(billsTree, function (gatherNode, sourceNode) {
                gatherUtils.gatherLedger(tender, gatherNode, sourceNode, completeData.prefix, helper);
            }, function (gatherNode, sourceNode) {
                const posRange = pos.getLedgerPos(sourceNode.id);
                if (!posRange || posRange.length === 0) return;
                resultPos.loadGatherPos(posRange, (gatherPos, sourcePos) => {
                    gatherUtils.gatherPos(gatherPos, sourcePos, completeData.prefix, helper);
                });
            });
        }
        async _gatherSpecialData(tender, sKey) {
            const resultPos = this.resultPos;
            const helper = this.ctx.helper;
            const billsTree = await this._loadGatherLedger(tender);
            const pos = await this._loadGatherPos(tender);
            this.resultTree.loadGatherTree(billsTree, function (gatherNode, sourceNode) {
                gatherUtils.gatherSpecial(gatherNode, sourceNode, 'ts_' + sKey + '_', helper);
            }, function (gatherNode, sourceNode) {
                const posRange = pos.getLedgerPos(sourceNode.id);
                if (!posRange || posRange.length === 0) return;
                resultPos.loadGatherPos(gatherNode.id, posRange, (gatherPos, sourcePos) => {
                    gatherUtils.gatherSpecialPos(gatherPos, sourcePos, 'ts_' + sKey + '_', helper);
                });
            });
        }

        async _doGatherStageData(memFieldKeys, gsDefine, gsCustom) {
            if (this.resultTree || this.resultPos) return;
            if (!gsDefine || !gsDefine.enable) return;
            if (!gsCustom || !gsCustom.tenders || gsCustom.tenders.length === 0) return;

            this.resultTree = new Ledger.gatherTree(this.ctx, {
                id: 'id',
                pid: 'pid',
                order: 'order',
                level: 'level',
                rootId: -1
            });
            this.resultPos = new Ledger.gatherPos({ id: 'id', ledgerId: 'lid' });

            const gsSetting = JSON.parse(gsDefine.setting);
            let commonIndex = 0;
            const completeDatas = [];
            for (const t of gsCustom.tenders) {
                const specialKey = this._checkSpecialTender(t, gsSetting.special);
                const tender = await this.ctx.service.tender.getCheckTender(t.tid);
                if (specialKey === '') {
                    const completeData = {
                        prefix: 't_' + commonIndex + '_',
                    };
                    completeDatas.push(completeData);
                    switch (gsSetting.type) {
                        case 'month':
                            await this._gatherMonthData(tender, completeData, gsCustom.month, gsSetting.hasPre);
                            break;
                        case 'months':
                            await this._gatherMonthsData(tender, completeData, gsCustom.months);
                            break;
                        case 'zone':
                            await this._gatherZoneData(tender, completeData, gsCustom.zone);
                            break;
                        case 'final':
                            await this._gatherFinalData(tender, completeData, gsSetting.hasPre);
                            break;
                        case 'checked-final':
                            await this._gatherCheckedFinalData(tender, completeData, gsSetting.hasPre);
                            break;
                        case 'ledger':
                            await this._gatherLedgerData(tender, completeData);
                            break;
                        case 'stage':
                            await this._gatherIndexData(tender, completeData, gsCustom.stage, gsSetting.hasPre);
                            break;
                        case 'stage-zone':
                            await this._gatherIndexZoneData(tender, completeData, gsCustom.stage_zone);
                            break;
                        case 'checked-zone':
                            await this._gatherCheckedZoneData(tender, completeData, gsCustom.checked_zone);
                            break;
                    }
                    commonIndex++;
                } else {
                    await this._gatherSpecialData(tender, specialKey);
                }
            }

            this.resultTree.resortChildrenDefault();
            gatherUtils.completeGatherData(this.resultTree.nodes, completeDatas);
            gatherUtils.completeGatherData(this.resultPos.datas, completeDatas);
        }

        async getGatherStageBills(memFieldKeys, gsDefine, gsCustom, showLevel) {
            await this._doGatherStageData(memFieldKeys, gsDefine, gsCustom);
            return this.resultTree
                ? (showLevel ? this.resultTree.getDefaultDatasByLevel(this.ctx.tender.rpt_show_level) : this.resultTree.getDefaultDatas())
                : [];
        }
        async getGatherStagePos(memFieldKeys, gsDefine, gsCustom) {
            await this._doGatherStageData(memFieldKeys, gsDefine, gsCustom);
            return this.resultPos ? this.resultPos.getDatas() : [];
        }

        /**
         * 标段信息
         */
        async _getBaseTenderInfo(tender) {
            const info = {
                id: tender.id,
                name: tender.name,

                deal_tp: tender.deal_tp,
                tp: tender.total_price
            };
            const deal_bills_sum = await this.ctx.service.dealBills.getSum(tender.id);
            info.deal_bills_tp = deal_bills_sum ? deal_bills_sum.total_price : 0;
            if (tender.ledger_status === auditConst.ledger.status.uncheck || tender.ledger_status === auditConst.ledger.status.checkNo) {
                const sum = await this.ctx.service.ledger.addUp({tender_id: tender.id/*, is_leaf: true*/});
                info.tp = sum.total_price;
                info.deal_tp = sum.deal_tp;
            }
            info.deal_info = tender.info.deal_info;
            info.construction_unit = tender.info.construction_unit;
            info.tech_param = tender.info.tech_param;
            info.deal_param = tender.info.deal_param;
            info.pay_account = tender.info.pay_account;
            info.deal_param.contractPriceWithoutZL = this.ctx.helper.sub(info.deal_param.contractPrice,
                info.deal_param.zanLiePrice);
            info.bid_info = tender.info.bid_info;
            return info;
        }
        async _getStageTenderInfo(stage, info) {
            if (stage) {
                const helper = this.ctx.helper;
                await this.ctx.service.stage.doCheckStage(stage);
                await this.ctx.service.stage.checkStageGatherData(stage, this.ctx.session.sessionUser.is_admin);

                info.pre_contract_tp = stage.pre_contract_tp;
                info.pre_qc_tp = stage.pre_qc_tp;
                info.pre_gather_tp = helper.add(info.pre_contract_tp, info.pre_qc_tp);

                info.contract_tp = stage.contract_tp;
                info.qc_tp = stage.qc_tp;
                info.gather_tp = helper.add(info.contract_tp, info.qc_tp);

                info.end_contract_tp = helper.add(info.pre_contract_tp, info.contract_tp);
                info.end_qc_tp = helper.add(info.pre_qc_tp, info.qc_tp);
                info.end_gather_tp = helper.add(info.pre_gather_tp, info.gather_tp);

                info.yf_tp = stage.yf_tp;
                info.pre_yf_tp = stage.pre_yf_tp;
                info.end_yf_tp = helper.add(stage.yf_tp, stage.pre_yf_tp);

                info.sf_tp = stage.sf_tp;
                info.pre_sf_tp = stage.pre_sf_tp;
                info.end_sf_tp = helper.add(stage.sf_tp, stage.pre_sf_tp);
            }
        }
        async _getStagesTenderInfo(stages, info, preStage) {
            const helper = this.ctx.helper;
            if (preStage) {
                info.pre_contract_tp = helper.add(preStage.contract_tp, preStage.pre_contract_tp);
                info.pre_qc_tp = helper.add(preStage.qc_tp, preStage.pre_qc_tp);
                info.pre_gather_tp = helper.add(info.pre_contract_tp, info.pre_qc_tp);
                info.pre_yf_tp = helper.add(preStage.yf_tp, preStage.pre_yf_tp);
            }

            for (const stage of stages) {
                await this.ctx.service.stage.doCheckStage(stage);
                await this.ctx.service.stage.checkStageGatherData(stage, this.ctx.session.sessionUser.is_admin);


                info.contract_tp = helper.add(info.contract_tp, stage.contract_tp);
                info.qc_tp = helper.add(info.qc_tp, stage.qc_tp);

                info.yf_tp = helper.add(info.yf_tp, stage.yf_tp);
            }
            info.gather_tp = helper.add(info.contract_tp, info.qc_tp);
            info.end_contract_tp = helper.add(info.pre_contract_tp, info.contract_tp);
            info.end_qc_tp = helper.add(info.pre_qc_tp, info.qc_tp);
            info.end_gather_tp = helper.add(info.pre_gather_tp, info.gather_tp);
            info.end_yf_tp = helper.add(info.pre_yf_tp, info.yf_tp);
        }
        async _gatherZoneTenderInfo(tender, index, zone) {
            const info = await this._getBaseTenderInfo(tender);
            const [stages, preStage, endStage] = await this._getTimeZoneStages(tender, zone);
            await this._getStagesTenderInfo(stages, info, preStage);
            this.resultTenderInfo.push(info);
        }
        async _gatherOrderZoneTenderInfo(tender, index, stageZone) {
            const info = await this._getBaseTenderInfo(tender);
            const [stages, preStage, endStage] = await this._getOrderZoneStages(tender, stageZone);
            await this._getStagesTenderInfo(stages, info, preStage);
            this.resultTenderInfo.push(info);
        }
        async _gatherCheckedZoneTenderInfo(tender, index, zone) {
            const info = await this._getBaseTenderInfo(tender);
            const [stages, preStage, endStage] = await this._getCheckedZoneStages(tender, zone);
            await this._getStagesTenderInfo(stages, info, preStage);
            this.resultTenderInfo.push(info);
        }

        async _gatherMonthTenderInfo(tender, index, month, hasPre) {
            const info = await this._getBaseTenderInfo(tender);
            const stages = await this._getValidStages(tender.id);
            const stage = this.ctx.helper._.find(stages, {s_time: month});
            await this._getStageTenderInfo(stage, info);
            this.resultTenderInfo.push(info);
        }
        async _gatherOrderTenderInfo(tender, index, order, hasPre) {
            const info = await this._getBaseTenderInfo(tender);
            const stages = await this._getValidStages(tender.id);
            const stage = this.ctx.helper._.find(stages, {order: order});
            await this._getStageTenderInfo(stage, info);
            this.resultTenderInfo.push(info);
        }
        async _gatherFinalTenderInfo(tender, index, hasPre) {
            const info = await this._getBaseTenderInfo(tender);
            const stages = await this._getValidStages(tender.id);
            await this._getStageTenderInfo(stages[0], info);
            this.resultTenderInfo.push(info);
        }
        async _gatherCheckedFinalTenderInfo(tender, index, hasPre) {
            const info = await this._getBaseTenderInfo(tender);
            const stages = await this._getCheckedStages(tender.id);
            await this._getStageTenderInfo(stages[0], info);
            this.resultTenderInfo.push(info);
        }
        async _gatherLedgerTenderInfo(tender, index) {
            const info = await this._getBaseTenderInfo(tender);
            this.resultTenderInfo.push(info);
        }
        async _gatherSpecialTenderInfo(tender, sKey) {
            const info = await this._getBaseTenderInfo(tender);
            info.spec = sKey;
            this.resultTenderInfo.push(info);
        }
        async getGatherTenderInfo(memFieldKeys, gsDefine, gsCustom) {
            if (!gsDefine || !gsDefine.enable) return [];
            if (!gsCustom || !gsCustom.tenders || gsCustom.tenders.length === 0) return [];

            this.resultTenderInfo = [];
            const gsSetting = JSON.parse(gsDefine.setting);
            let commonIndex = 0;
            for (const t of gsCustom.tenders) {
                const specialKey = this._checkSpecialTender(t, gsSetting.special);
                const tender = await this.ctx.service.tender.getCheckTender(t.tid);
                if (specialKey === '') {
                    switch (gsSetting.type) {
                        case 'month':
                            await this._gatherMonthTenderInfo(tender, commonIndex, gsCustom.month, gsSetting.hasPre);
                            break;
                        case 'zone':
                            await this._gatherZoneTenderInfo(tender, commonIndex, gsCustom.zone);
                            break;
                        case 'final':
                            await this._gatherFinalTenderInfo(tender, commonIndex, gsSetting.hasPre);
                            break;
                        case 'checked-final':
                            await this._gatherCheckedFinalTenderInfo(tender, commonIndex, gsSetting.hasPre);
                            break;
                        case 'ledger':
                            await this._gatherLedgerTenderInfo(tender, commonIndex);
                            break;
                        case 'stage':
                            await this._gatherOrderTenderInfo(tender, commonIndex, gsCustom.stage, gsSetting.hasPre);
                            break;
                        case 'stage-zone':
                            await this._gatherOrderZoneTenderInfo(tender, commonIndex, gsCustom.stage_zone);
                            break;
                        case 'checked-zone':
                            await this._gatherCheckedZoneTenderInfo(tender, commonIndex, gsCustom.checked_zone);
                            break;
                    }
                    commonIndex++;
                } else {
                    await this._gatherSpecialTenderInfo(tender, specialKey);
                }
            }
            return this.resultTenderInfo;
        }

        /**
         * 合同支付
         */
        _gatherPayRecord(dealPay, fun) {
            let rdp;
            if (dealPay.ptype !== payConst.payType.normal) {
                rdp = this.ctx.helper._.find(this.resultDealPay, {ptype: dealPay.ptype});
            } else {
                rdp = this.ctx.helper._.find(this.resultDealPay, {
                    name: dealPay.name,
                    minus: dealPay.minus ? true : false,
                    is_yf: dealPay.is_yf ? true : false,
                });
            }
            if (!rdp) {
                rdp = {
                    ptype: dealPay.ptype,
                    name: dealPay.name,
                    minus: dealPay.minus ? true : false,
                    is_yf: dealPay.is_yf ? true : false,
                };
                this.resultDealPay.push(rdp);
            }
            if (fun) fun(rdp, dealPay);
        }
        async _checkStagePayCalc(tender, stage, dealPay) {
            if (!stage.readOnly) {
                // 计算 本期金额
                const payCalculator = new PayCalculator(this.ctx, stage, tender.info);
                await payCalculator.calculateAll(dealPay);
            }
        }
        async _gatherStagePay(completeData, tender, stage, hasPre) {
            if (stage) {
                completeData.id = tender.id;
                completeData.name = tender.name;
                const helper = this.ctx.helper;
                await this.ctx.service.stage.doCheckStage(stage);

                const dealPay = await this.ctx.service.stagePay.getStagePays(stage);
                await this._checkStagePayCalc(tender, stage, dealPay);
                for (const dp of dealPay) {
                    dp.end_tp = helper.add(dp.pre_tp, dp.tp);
                    this._gatherPayRecord(dp, function (gatherData, sourceData) {
                        gatherData[completeData.prefix + 'id'] = tender.id;
                        gatherData[completeData.prefix + 'name'] = tender.name;

                        gatherData[completeData.prefix + 'tp'] = helper.add(gatherData[completeData.prefix + 'tp'], sourceData.tp);
                        gatherData[completeData.prefix + 'pre_tp'] = helper.add(gatherData[completeData.prefix + 'pre_tp'], sourceData.pre_tp);
                        gatherData[completeData.prefix + 'end_tp'] = helper.add(gatherData[completeData.prefix + 'end_tp'], sourceData.end_tp);

                        gatherData['s_' + 'tp'] = helper.add(gatherData['s_' + 'tp'], sourceData.tp);
                        gatherData['s_' + 'pre_tp'] = helper.add(gatherData['s_' + 'pre_tp'], sourceData.pre_tp);
                        gatherData['s_' + 'end_tp'] = helper.add(gatherData['s_' + 'end_tp'], sourceData.end_tp);
                    });
                }
            }
        }
        async _gatherStagesPay(completeData, tender, stages, preStage) {
            const helper = this.ctx.helper;
            completeData.id = tender.id;
            completeData.name = tender.name;

            if (preStage) await this.ctx.service.stage.doCheckStage(preStage);
            const preDealPay = preStage ? await this.ctx.service.stagePay.getStagePays(preStage) : [];
            for (const dp of preDealPay) {
                dp.end_tp = helper.add(dp.pre_tp, dp.tp);
                this._gatherPayRecord(dp, function (gatherData, sourceData) {
                    gatherData[completeData.prefix + 'id'] = tender.id;
                    gatherData[completeData.prefix + 'name'] = tender.name;

                    gatherData[completeData.prefix + 'pre_tp'] = sourceData.end_tp;
                    gatherData.s_pre_tp = helper.add(gatherData.s_pre_tp, sourceData.end_tp);

                    gatherData[completeData.prefix + 'end_tp'] = sourceData.end_tp;
                    gatherData.s_end_tp = helper.add(gatherData.s_end_tp, sourceData.end_tp);
                });
            }

            for (const stage of stages) {
                await this.ctx.service.stage.doCheckStage(stage);

                const dealPay = await this.ctx.service.stagePay.getStagePays(stage);
                await this._checkStagePayCalc(tender, stage, dealPay);
                for (const dp of dealPay) {
                    dp.end_tp = helper.add(dp.pre_tp, dp.tp);
                    this._gatherPayRecord(dp, function (gatherData, sourceData) {
                        gatherData[completeData.prefix + 'id'] = tender.id;
                        gatherData[completeData.prefix + 'name'] = tender.name;

                        gatherData[completeData.prefix + 'tp'] = helper.add(gatherData[completeData.prefix + 'tp'], sourceData.tp);
                        gatherData['s_' + 'tp'] = helper.add(gatherData['s_' + 'tp'], sourceData.tp);

                        gatherData[completeData.prefix + 'end_tp'] = helper.add(gatherData[completeData.prefix + 'end_tp'], sourceData.tp);
                        gatherData['s_' + 'end_tp'] = helper.add(gatherData['s_' + 'end_tp'], sourceData.tp);
                    });
                }
            }
        }

        async _gatherZoneStagePay(sTender, completeData, zone) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const [stages, preStage, endStage] = await this._getTimeZoneStages(tender, zone);
            await this._gatherStagesPay(completeData, tender, stages, preStage);
        }
        async _gatherOrderZoneStagePay(sTender, completeData, stageZone) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const [stages, preStage, endStage] = await this._getOrderZoneStages(tender, stageZone);
            await this._gatherStagesPay(completeData, tender, stages, preStage);
        }
        async _gatherCheckedZoneStagePay(sTender, completeData, zone) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const [stages, preStage, endStage] = await this._getCheckedZoneStages(tender, zone);
            await this._gatherStagesPay(completeData, tender, stages, preStage);
        }

        async _gatherMonthStagePay(sTender, completeData, month, hasPre) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const stages = await this._getValidStages(tender.id);
            const stage = this.ctx.helper._.find(stages, {s_time: month});
            await this._gatherStagePay(completeData, tender, stage, hasPre);
        }
        async _gatherOrderStagePay(sTender, completeData, order, hasPre) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const stages = await this._getValidStages(tender.id);
            const stage = this.ctx.helper._.find(stages, {order: order});
            await this._gatherStagePay(completeData, tender, stage, hasPre);
        }
        async _gatherFinalStagePay(sTender, completeData, hasPre) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const stages = await this._getValidStages(tender.id);
            await this._gatherStagePay(completeData, tender, stages[0], hasPre);
        }
        async _gatherCheckedFinalStagePay(sTender, completeData, hasPre) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const stages = await this._getCheckedStages(tender.id);
            await this._gatherStagePay(completeData, tender, stages[0], hasPre);
        }
        async getGatherStagePay(memFieldKeys, gsDefine, gsCustom) {
            if (!gsDefine || !gsDefine.enable) return [];
            if (!gsCustom || !gsCustom.tenders || gsCustom.tenders.length === 0) return [];

            this.resultDealPay = [];
            const gsSetting = JSON.parse(gsDefine.setting);
            let commonIndex = 0;
            const completeDatas = [];
            for (const tender of gsCustom.tenders) {
                const specialKey = this._checkSpecialTender(tender, gsSetting.special);
                if (specialKey === '') {
                    const completeData = {
                        prefix: 't_' + commonIndex + '_',
                    };
                    completeDatas.push(completeData);
                    switch (gsSetting.type) {
                        case 'month':
                            await this._gatherMonthStagePay(tender, completeData, gsCustom.month, gsSetting.hasPre);
                            break;
                        case 'zone':
                            await this._gatherZoneStagePay(tender, completeData, gsCustom.zone);
                            break;
                        case 'final':
                            await this._gatherFinalStagePay(tender, completeData, gsSetting.hasPre);
                            break;
                        case 'checked-final':
                            await this._gatherCheckedFinalStagePay(tender, completeData, gsSetting.hasPre);
                            break;
                        case 'stage':
                            await this._gatherOrderStagePay(tender, completeData, gsCustom.stage, gsSetting.hasPre);
                            break;
                        case 'stage-zone':
                            await this._gatherOrderZoneStagePay(tender, completeData, gsCustom.stage_zone);
                            break;
                        case 'checked-zone':
                            await this._gatherCheckedZoneStagePay(tender, completeData, gsCustom.checked_zone);
                            break;
                    }
                    commonIndex++;
                }
                // 合同支付，只有在每一期中有数据，故特殊标段直接不汇总合同支付
            }
            gatherUtils.completeGatherData(this.resultDealPay, completeDatas);
            return this.resultDealPay;
        }

        /**
         * 签约清单
         */
        async _gatherDealBills(tender, fun) {
            const dealBills = await this.ctx.service.dealBills.getAllDataByCondition({
                where: { tender_id: tender.id }
            });
            for (const db of dealBills) {
                let rdb = this.ctx.helper._.find(this.resultDealBills, {
                    code: db.code,
                    name: db.name,
                    unit: db.unit,
                    unit_price: db.unit_price ? db.unit_price: 0,
                });
                if (!rdb) {
                    rdb = {
                        code: db.code,
                        name: db.name,
                        unit: db.unit,
                        unit_price: db.unit_price ? db.unit_price: 0,
                    };
                    this.resultDealBills.push(rdb);
                }
                if (fun) fun(rdb, db);
            }
        }
        async _gatherCommonDealBills(sTender, completeData) {
            const self = this;
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            completeData.id = tender.id;
            completeData.name = tender.name;
            await this._gatherDealBills(tender, function (gatherData, sourceData) {
                gatherData[completeData.prefix + 'id'] = tender.id;
                gatherData[completeData.prefix + 'name'] = tender.name;

                gatherData[completeData.prefix + 'qty'] = sourceData.quantity;
                gatherData[completeData.prefix + 'tp'] = sourceData.total_price;

                gatherData['s_' + 'qty'] = self.ctx.helper.add(gatherData['s_' + 'qty'], sourceData.quantity);
                gatherData['s_' + 'tp'] = self.ctx.helper.add(gatherData['s_' + 'tp'], sourceData.total_price);
            });
        }
        async _gatherSpecialDealBills(sTender, sKey) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            await this._gatherDealBills(tender, function (gatherData, sourceData) {
                const prefix = 'ts_' + sKey + '_';

                gatherData[prefix + 'qty'] = sourceData.quantity;
                gatherData[prefix + 'tp'] = sourceData.total_price;
            });
        }
        async getGatherDealBills(memFieldKeys, gsDefine, gsCustom) {
            if (!gsDefine || !gsDefine.enable) return [];
            if (!gsCustom || !gsCustom.tenders || gsCustom.tenders.length === 0) return [];

            this.resultTenderInfo = [];
            const gsSetting = JSON.parse(gsDefine.setting);
            let commonIndex = 0;
            const completeDatas = [];
            for (const tender of gsCustom.tenders) {
                const specialKey = this._checkSpecialTender(tender, gsSetting.special);
                if (specialKey === '') {
                    const completeData = {
                        prefix: 't_' + commonIndex + '_',
                    };
                    completeDatas.push(completeData);
                    await this._gatherCommonDealBills(tender, completeData);
                    commonIndex++;
                } else {
                    await this._gatherSpecialDealBills(tender, specialKey);
                }
            }
            gatherUtils.completeGatherData(this.resultDealBills, completeDatas);
            return this.resultDealBills;
        }

        _getChangeConstName(define, value) {
            for (const prop in define) {
                if (define[prop].value === value) {
                    return define[prop].name;
                }
            }
            return '';
        }
        async _gatherChange(tender, hasUsed) {
            const self = this;
            try {
                const info = await this.ctx.service.tenderInfo.getTenderInfo(tender.id);
                const decimal = info.decimal, ctx = this.ctx;
                const where = { tid: tender.id, valid: 1 };
                if (this.ctx.session.sessionProject.page_show.isOnlyChecked) where.status = auditConst.flow.status.checked;
                const change = await this.ctx.service.change.getAllDataByCondition({ where, orders: [['in_time', 'desc']] });
                for (const c of change) {
                    c.tender_name = tender.name;
                    const types = ctx.helper._.map(c.type.split(','), function (t) {
                        return self._getChangeConstName(changeConst.type, ctx.helper._.toInteger(t));
                    });
                    c.type = types.join(';');
                    c.class = this._getChangeConstName(changeConst.class, c.class);
                    c.quality = this._getChangeConstName(changeConst.quality, c.quality);
                    c.charge = this._getChangeConstName(changeConst.charge, c.charge);
                    c.attachments = await ctx.service.changeAtt.getChangeAttachment(c.cid);
                    const names = ctx.helper._.map(c.attachments, function (x) {
                        return x.filename + x.fileext;
                    });
                    c.attNames = names.join('\n');
                }
                const changeBills = hasUsed
                    ? await this.ctx.service.stageChangeFinal.getChangeBillsWithUsedQty(tender.id, this.ctx.session.sessionProject.page_show.isOnlyChecked)
                    : await this.ctx.service.changeAuditList.getChangeAuditBills(tender.id, this.ctx.session.sessionProject.page_show.isOnlyChecked);
                for (const d of changeBills) {
                    d.tender_name = tender.name;
                    d.o_qty = d.oamount;
                    d.o_tp = this.ctx.helper.mul(d.o_qty, d.unit_price, decimal.tp);
                    d.c_qty = d.camount;
                    d.c_tp = this.ctx.helper.mul(d.c_qty, d.unit_price, decimal.tp);
                    d.s_qty = d.samount ? parseFloat(d.samount) : 0;
                    d.s_tp = this.ctx.helper.mul(d.s_qty, d.unit_price, decimal.tp);
                    d.sp_qty = d.spamount;
                    d.sp_tp = this.ctx.helper.mul(d.sp_qty, d.unit_price, decimal.tp);

                    d.used_tp = this.ctx.helper.mul(d.used_qty, d.unit_price, decimal.tp);
                    d.is_used = !!d.used_qty;

                    const auditAmount = d.audit_amount ? d.audit_amount.split(',') : [];
                    const relaChange = ctx.helper._.find(change, {cid: d.cid});
                    d.relaChange = relaChange;
                    if (relaChange) {
                        if (d.is_used) relaChange.is_used = true;
                        relaChange.used_tp = ctx.helper.add(relaChange.used_tp, d.used_tp);
                    }
                    for (const [i, aa] of auditAmount.entries()) {
                        const amountField = 'qty_' + (i+1), tpField = 'tp_' + (i+1);
                        d[amountField] = aa ? parseFloat(aa) : 0;
                        d[tpField] = ctx.helper.mul(d[amountField], d.unit_price, decimal.tp);
                        if (relaChange) {
                            relaChange[tpField] = ctx.helper.add(relaChange[tpField], d[tpField]);
                        }
                    }
                }
                for (const c of change) {
                    c.is_used = !!c.is_used;
                    c.used_ratio = c.total_price ? ctx.helper.mul(ctx.helper.div(c.used_tp, c.total_price), 100) : 0;
                }
                for (const cb of changeBills) {
                    cb.is_used_bgl = cb.relaChange ? cb.relaChange.is_used : cb.is_used;
                    delete cb.relaChange;
                }

                change.sort(function (a, b) {
                    return a.code.localeCompare(b.code);
                });
                changeBills.sort(function (a, b) {
                    const aCIndex = change.findIndex(function (c) {
                        return c.cid === a.cid;
                    });
                    const bCIndex = change.findIndex(function (c) {
                        return c.cid === b.cid;
                    });
                    return aCIndex === bCIndex
                        ? ctx.helper.compareCode(a.code, b.code)
                        : aCIndex - bCIndex;
                });
                return [change, changeBills];
            } catch(err) {
                this.ctx.helper.log(err);
                throw err;
                return [[], []];
            }
        }
        async getGatherChange(memFieldKeys, gsDefine, gsCustom) {
            if (!gsDefine || !gsDefine.enable) return [];
            if (!gsCustom || !gsCustom.tenders || gsCustom.tenders.length === 0) return [];

            const result = { mem_gather_change: [], mem_gather_change_bills: [] };
            const hasUsed = rmUtils.checkFieldsExist(memFieldKeys, ['used_qty', 'is_used_bgl', 'is_used', 'used_ratio']);
            for (const t of gsCustom.tenders) {
                const tender = await this.ctx.service.tender.getCheckTender(t.tid);
                const [change, changeBills] = await this._gatherChange(tender, hasUsed);
                result.mem_gather_change.push(...change);
                result.mem_gather_change_bills.push(...changeBills);
            }
            return result
        }

        async _gatherStageJgcl(tender, stage) {
            const data = await this.ctx.service.stageJgcl.getStageData(stage);
            const preData = stage.order > 1 ? await this.ctx.service.stageJgcl.getPreStageData(stage.tid, stage.order) : 0;
            for (const d of data) {
                const pd = this.ctx.helper._.find(preData, {uuid: d.uuid});
                if (pd) {
                    d.pre_arrive_qty = pd.arrive_qty;
                    d.pre_arrive_tp = pd.arrive_tp;
                    d.pre_deduct_qty = pd.deduct_qty;
                    d.pre_deduct_tp = pd.deduct_tp;
                }
                d.end_arrive_qty = this.ctx.helper.add(d.pre_arrive_qty, d.arrive_qty);
                d.end_arrive_tp = this.ctx.helper.add(d.pre_arrive_tp, d.arrive_tp);
                d.end_deduct_qty = this.ctx.helper.add(d.pre_deduct_qty, d.deduct_qty);
                d.end_deduct_tp = this.ctx.helper.add(d.pre_deduct_tp, d.deduct_tp);
                d.tender_name = tender.name;
            }
            this.resultStageJgcl.push(...data);
        }
        async _gatherMonthStageJgcl(sTender, month) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const stages = await this._getValidStages(tender.id);
            const stage = this.ctx.helper._.find(stages, {s_time: month});
            await this._gatherStageJgcl(tender, stage);
        }
        async _gatherOrderStageJgcl(sTender, order) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const stages = await this._getValidStages(tender.id);
            const stage = this.ctx.helper._.find(stages, {order: order});
            await this._gatherStageJgcl(tender, stage);
        }
        async _gatherFinalStageJgcl(sTender) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const stages = await this._getValidStages(tender.id);
            await this._gatherStageJgcl(tender, stages[0]);
        }
        async _gatherCheckedFinalStageJgcl(sTender) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const stages = await this._getCheckedStages(tender.id);
            await this._gatherStageJgcl(tender, stages[0]);
        }
        async getGatherStageJgcl(memFieldKeys, gsDefine, gsCustom) {
            if (!gsDefine || !gsDefine.enable) return [];
            if (!gsCustom || !gsCustom.tenders || gsCustom.tenders.length === 0) return [];

            this.resultStageJgcl = [];
            const gsSetting = JSON.parse(gsDefine.setting);
            for (const tender of gsCustom.tenders) {
                switch (gsSetting.type) {
                    case 'month':
                        await this._gatherMonthStageJgcl(tender, gsCustom.month);
                        break;
                    case 'final':
                        await this._gatherFinalStageJgcl(tender);
                        break;
                    case 'checked-final':
                        await this._gatherCheckedFinalStageJgcl(tender);
                        break;
                    case 'stage':
                        await this._gatherOrderStageJgcl(tender, gsCustom.stage);
                        break;
                }
            }

            return this.resultStageJgcl;
        }

        async _gatherStageBonus(tender, stage) {
            const data = await this.ctx.service.stageBonus.getEndStageData(tender.id, stage.order);
            for (const d of data) {
                const names = this.ctx.helper._.map(d.proof_file, function (x) {
                    return x.filename + x.fileext;
                });
                d.proof = names.join('\n');
                d.tender_name = tender.name;
            }
            this.resultStageBonus.push(...data);
        }
        async _gatherMonthStageBonus(sTender, month) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const stages = await this._getValidStages(tender.id);
            const stage = this.ctx.helper._.find(stages, {s_time: month});
            await this._gatherStageBonus(tender, stage);
        }
        async _gatherOrderStageBonus(sTender, order) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const stages = await this._getValidStages(tender.id);
            const stage = this.ctx.helper._.find(stages, {order: order});
            await this._gatherStageBonus(tender, stage);
        }
        async _gatherFinalStageBonus(sTender) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const stages = await this._getValidStages(tender.id);
            await this._gatherStageBonus(tender, stages[0]);
        }
        async _gatherCheckedFinalStageBonus(sTender) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const stages = await this._getCheckedStages(tender.id);
            await this._gatherStageBonus(tender, stages[0]);
        }
        async getGatherStageBonus(memFieldKeys, gsDefine, gsCustom) {
            if (!gsDefine || !gsDefine.enable) return [];
            if (!gsCustom || !gsCustom.tenders || gsCustom.tenders.length === 0) return [];

            this.resultStageBonus = [];
            const gsSetting = JSON.parse(gsDefine.setting);
            for (const tender of gsCustom.tenders) {
                console.log(tender, gsSetting.type);
                switch (gsSetting.type) {
                    case 'month':
                        await this._gatherMonthStageBonus(tender, gsCustom.month);
                        break;
                    case 'final':
                        await this._gatherFinalStageBonus(tender);
                        break;
                    case 'checked-final':
                        await this._gatherCheckedFinalStageBonus(tender);
                        break;
                    case 'stage':
                        await this._gatherOrderStageBonus(tender, gsCustom.stage);
                        break;
                }
            }
            return this.resultStageBonus;
        }

        async _gatherStageOther(tender, stage) {
            const data = await this.ctx.service.stageOther.getStageData(stage);
            const preData = stage.order > 1 ? await this.ctx.service.stageOther.getPreStageData(stage.tid, stage.order) : [];
            for (const d of data) {
                const pd = this.ctx.helper._.find(preData, {uuid: d.uuid});
                if (pd) {
                    d.pre_tp = pd.tp;
                }
                d.end_tp = this.ctx.helper.add(d.pre_tp, d.tp);
                d.tender_name = tender.name;
            }
            this.resultStageOther.push(...data);
        }
        async _gatherMonthStageOther(sTender, month) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const stages = await this._getValidStages(tender.id);
            const stage = this.ctx.helper._.find(stages, {s_time: month});
            await this._gatherStageOther(tender, stage);
        }
        async _gatherOrderStageOther(sTender, order) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const stages = await this._getValidStages(tender.id);
            const stage = this.ctx.helper._.find(stages, {order: order});
            await this._gatherStageOther(tender, stage);
        }
        async _gatherFinalStageOther(sTender) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const stages = await this._getValidStages(tender.id);
            await this._gatherStageOther(tender, stages[0]);
        }
        async _gatherCheckedFinalStageOther(sTender) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const stages = await this._getCheckedStages(tender.id);
            await this._gatherStageOther(tender, stages[0]);
        }
        async getGatherStageOther(memFieldKeys, gsDefine, gsCustom) {
            if (!gsDefine || !gsDefine.enable) return [];
            if (!gsCustom || !gsCustom.tenders || gsCustom.tenders.length === 0) return [];

            this.resultStageOther = [];
            const gsSetting = JSON.parse(gsDefine.setting);
            for (const tender of gsCustom.tenders) {
                switch (gsSetting.type) {
                    case 'month':
                        await this._gatherMonthStageOther(tender, gsCustom.month);
                        break;
                    case 'final':
                        await this._gatherFinalStageOther(tender);
                        break;
                    case 'checked-final':
                        await this._gatherCheckedFinalStageOther(tender);
                        break;
                    case 'stage':
                        await this._gatherOrderStageOther(tender, gsCustom.stage);
                        break;
                }
            }
            return this.resultStageOther;
        }

        async _gatherStageSafeProd(tender, stage) {
            const data = await this.ctx.service.stageSafeProd.getStageData(stage);
            const preData = stage.order > 1 ? await this.ctx.service.stageSafeProd.getPreStageData(stage.tid, stage.order) : [];
            for (const d of data) {
                const pd = this.ctx.helper._.find(preData, {uuid: d.uuid});
                if (pd) {
                    d.pre_qty = pd.qty;
                    d.pre_tp = pd.tp;
                }
                d.end_qty = this.ctx.helper.add(d.pre_qty, d.qty);
                d.end_tp = this.ctx.helper.add(d.pre_tp, d.tp);
            }
            const helper = this.ctx.helper;
            for (const d of data) {
                let gd = this.resultStageSafeProd.find(x => {
                    return x.name === d.name && x.unit === d.unit && helper.numEqual(x.unit_price, d.unit_price);
                });
                if (!gd) {
                    gd = { name: d.name, unit: d.unit, unit_price: d.unit_price };
                    this.resultStageSafeProd.push(gd);
                }
                gd.s_quantity = helper.add(gd.s_quantity, d.quantity);
                gd.s_total_price = helper.add(gd.s_total_price, d.total_price);
                gd.s_qty = helper.add(gd.s_qty, d.qty);
                gd.s_tp = helper.add(gd.s_tp, d.tp);
                gd.s_pre_qty = helper.add(gd.s_pre_qty, d.pre_qty);
                gd.s_pre_tp = helper.add(gd.s_pre_tp, d.pre_tp);
                gd.s_end_qty = helper.add(gd.s_end_qty, d.end_qty);
                gd.s_end_tp = helper.add(gd.s_end_tp, d.end_tp);
            }
        }
        async _gatherMonthStageSafeProd(sTender, month) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const stages = await this._getValidStages(tender.id);
            const stage = this.ctx.helper._.find(stages, {s_time: month});
            await this._gatherStageSafeProd(tender, stage);
        }
        async _gatherOrderStageSafeProd(sTender, order) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const stages = await this._getValidStages(tender.id);
            const stage = this.ctx.helper._.find(stages, {order: order});
            await this._gatherStageSafeProd(tender, stage);
        }
        async _gatherFinalStageSafeProd(sTender) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const stages = await this._getValidStages(tender.id);
            await this._gatherStageSafeProd(tender, stages[0]);
        }
        async _gatherCheckedFinalStageSafeProd(sTender) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const stages = await this._getCheckedStages(tender.id);
            await this._gatherStageSafeProd(tender, stages[0]);
        }
        async getGatherStageSafeProd(memFieldKeys, gsDefine, gsCustom) {
            if (!gsDefine || !gsDefine.enable) return [];
            if (!gsCustom || !gsCustom.tenders || gsCustom.tenders.length === 0) return [];

            this.resultStageSafeProd = [];
            const gsSetting = JSON.parse(gsDefine.setting);
            for (const tender of gsCustom.tenders) {
                switch (gsSetting.type) {
                    case 'month':
                        await this._gatherMonthStageSafeProd(tender, gsCustom.month);
                        break;
                    case 'final':
                        await this._gatherFinalStageSafeProd(tender);
                        break;
                    case 'checked-final':
                        await this._gatherCheckedFinalStageSafeProd(tender);
                        break;
                    case 'stage':
                        await this._gatherOrderStageSafeProd(tender, gsCustom.stage);
                        break;
                }
            }

            return this.resultStageSafeProd;
        }

        async _gatherStageTempLand(tender, stage) {
            const data = await this.ctx.service.stageTempLand.getStageData(stage);
            const preData = stage.order > 1 ? await this.ctx.service.stageTempLand.getPreStageData(stage.tid, stage.order) : [];
            for (const d of data) {
                const pd = this.ctx.helper._.find(preData, {uuid: d.uuid});
                if (pd) {
                    d.pre_qty = pd.qty;
                    d.pre_tp = pd.tp;
                }
                d.end_qty = this.ctx.helper.add(d.pre_qty, d.qty);
                d.end_tp = this.ctx.helper.add(d.pre_tp, d.tp);
            }

            const helper = this.ctx.helper;
            for (const d of data) {
                let gd = this.resultStageTempLand.find(x => {
                    return x.name === d.name && x.unit === d.unit && helper.numEqual(x.unit_price, d.unit_price);
                });
                if (!gd) {
                    gd = { name: d.name, unit: d.unit, unit_price: d.unit_price };
                    this.resultStageTempLand.push(gd);
                }
                gd.s_qty = helper.add(gd.s_qty, d.qty);
                gd.s_tp = helper.add(gd.s_tp, d.tp);
                gd.s_pre_qty = helper.add(gd.s_pre_qty, d.pre_qty);
                gd.s_pre_tp = helper.add(gd.s_pre_tp, d.pre_tp);
                gd.s_end_qty = helper.add(gd.s_end_qty, d.end_qty);
                gd.s_end_tp = helper.add(gd.s_end_tp, d.end_tp);
            }
        }
        async _gatherMonthStageTempLand(sTender, month) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const stages = await this._getValidStages(tender.id);
            const stage = this.ctx.helper._.find(stages, {s_time: month});
            await this._gatherStageTempLand(tender, stage);
        }
        async _gatherOrderStageTempLand(sTender, order) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const stages = await this._getValidStages(tender.id);
            const stage = this.ctx.helper._.find(stages, {order: order});
            await this._gatherStageTempLand(tender, stage);
        }
        async _gatherFinalStageTempLand(sTender) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const stages = await this._getValidStages(tender.id);
            await this._gatherStageTempLand(tender, stages[0]);
        }
        async _gatherCheckedFinalStageTempLand(sTender) {
            const tender = await this.ctx.service.tender.getCheckTender(sTender.tid);
            const stages = await this._getCheckedStages(tender.id);
            await this._gatherStageTempLand(tender, stages[0]);
        }
        async getGatherStageTempLand(memFieldKeys, gsDefine, gsCustom) {
            if (!gsDefine || !gsDefine.enable) return [];
            if (!gsCustom || !gsCustom.tenders || gsCustom.tenders.length === 0) return [];

            this.resultStageTempLand = [];
            const gsSetting = JSON.parse(gsDefine.setting);
            for (const tender of gsCustom.tenders) {
                switch (gsSetting.type) {
                    case 'month':
                        await this._gatherMonthStageTempLand(tender, gsCustom.month);
                        break;
                    case 'final':
                        await this._gatherFinalStageTempLand(tender);
                        break;
                    case 'checked-final':
                        await this._gatherCheckedFinalStageTempLand(tender);
                        break;
                    case 'stage':
                        await this._gatherOrderStageTempLand(tender, gsCustom.stage);
                        break;
                }
            }

            return this.resultStageTempLand;
        }
    }

    return RptGatherMemory;
};