Calculation/app/controller/spss_controller.js

'use strict';

/**
 * 标段对比 控制器
 *
 * @author Mai
 * @date 2020/2/21
 * @version
 */

const measureType = require('../const/tender').measureType;
const status = require('../const/audit').stage.status;
const moment = require('moment');
const stashCtrl = {
    first: true,
};

module.exports = app => {

    class SpssController extends app.BaseController {

        /**
         * 构造函数
         *
         * @param {Object} ctx - egg全局context
         * @return {void}
         */
        constructor(ctx) {
            super(ctx);
            ctx.showProject = true;
        }

        async info(ctx) {
            try {
                const categoryData = await this.ctx.service.category.getAllCategory(this.ctx.subProject);
                const stashList = await this.ctx.service.spssStash.getSpssStashList(this.ctx.subProject.id, 'gather_info');
                const renderData = {
                    categoryData,
                    stashList,
                    stashCtrl,
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.spss.gatherInfo)
                };
                await this.layout('spss/gather_info.ejs', renderData, 'spss/gather_info_modal.ejs');
            } catch (err) {
                ctx.helper.log(err);
            }
        }

        async gatherLedger(ctx) {
            try {
                const categoryData = await this.ctx.service.category.getAllCategory(this.ctx.subProject);
                const stashList = await this.ctx.service.spssStash.getSpssStashList(this.ctx.subProject.id, 'gather_ledger');
                const renderData = {
                    categoryData,
                    stashList,
                    stashCtrl,
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.spss.gatherLedger)
                };
                await this.layout('spss/gather_ledger.ejs', renderData, 'spss/spss_modal.ejs');
            } catch (err) {
                ctx.helper.log(err);
            }
        }

        async gatherStage(ctx) {
            try {
                const categoryData = await this.ctx.service.category.getAllCategory(this.ctx.subProject);
                const stashList = await this.ctx.service.spssStash.getSpssStashList(this.ctx.subProject.id, 'gather_stage');
                const renderData = {
                    categoryData,
                    stashList,
                    stashCtrl,
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.spss.gatherStage)
                };
                await this.layout('spss/gather_stage.ejs', renderData, 'spss/spss_modal.ejs');
            } catch (err) {
                ctx.helper.log(err);
            }
        }

        async gatherStageExtra(ctx) {
            try {
                const categoryData = await this.ctx.service.category.getAllCategory(this.ctx.subProject);
                const stashList = await this.ctx.service.spssStash.getSpssStashList(this.ctx.subProject.id, 'gather_stage_extra');
                const renderData = {
                    categoryData,
                    stashList,
                    stashCtrl,
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.spss.gatherStageExtra)
                };
                await this.layout('spss/gather_stage_extra.ejs', renderData, 'spss/spss_modal.ejs');
            } catch (err) {
                ctx.helper.log(err);
            }
        }

        async gatherStagePay(ctx) {
            try {
                const categoryData = await this.ctx.service.category.getAllCategory(this.ctx.subProject);
                const stashList = await this.ctx.service.spssStash.getSpssStashList(this.ctx.subProject.id, 'gather_stage_pay');
                const renderData = {
                    categoryData,
                    stashList,
                    stashCtrl,
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.spss.gatherStagePay)
                };
                await this.layout('spss/gather_stage_pay.ejs', renderData, 'spss/spss_modal.ejs');
            } catch(err) {
                ctx.log(err);
            }
        }

        async compareLedger(ctx) {
            try {
                const categoryData = await this.ctx.service.category.getAllCategory(this.ctx.subProject);
                const stashList = await this.ctx.service.spssStash.getSpssStashList(this.ctx.subProject.id, 'compare_ledger');
                const renderData = {
                    categoryData,
                    stashList,
                    stashCtrl,
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.spss.compareLedger)
                };
                await this.layout('spss/compare_ledger.ejs', renderData, 'spss/spss_modal.ejs');
            } catch (err) {
                ctx.helper.log(err);
            }
        }

        async compareStage(ctx) {
            try {
                const categoryData = await this.ctx.service.category.getAllCategory(this.ctx.subProject);
                const stashList = await this.ctx.service.spssStash.getSpssStashList(this.ctx.subProject.id, 'compare_stage');
                const renderData = {
                    categoryData,
                    stashList,
                    stashCtrl,
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.spss.compareStage),
                };
                await this.layout('spss/compare_stage.ejs', renderData, 'spss/spss_modal.ejs');
            } catch (err) {
                ctx.helper.log(err);
            }
        }

        async _loadStageTpData(info, tender, stage, loadPre = true) {
            if (!stage) return;
            if (stage.readOnly && stage.status === status.uncheck) return;
            if (loadPre) {
                info.pre_contract_tp = stage.pre_contract_tp;
                info.pre_qc_tp = stage.pre_qc_tp;
                info.pre_yf_tp = stage.pre_yf_tp;
                info.pre_sf_tp = stage.pre_sf_tp;
            }
            if (!stage.readOnly) await this.ctx.service.stage.checkStageGatherData(stage, this.ctx.session.sessionUser.is_admin);

            info.contract_tp = this.ctx.helper.add(stage.contract_tp, info.contract_tp);
            info.qc_tp = this.ctx.helper.add(stage.qc_tp, info.qc_tp);
            info.contract_pc_tp = this.ctx.helper.add(stage.contract_pc_tp, info.contract_pc_tp);
            info.qc_pc_tp = this.ctx.helper.add(stage.qc_pc_tp, info.qc_pc_tp);
            info.pc_tp = this.ctx.helper.add(stage.pc_tp, info.pc_tp);
            info.yf_tp = this.ctx.helper.add(stage.yf_tp, info.yf_tp);
            info.sf_tp = this.ctx.helper.add(stage.sf_tp, info.sf_tp);
        }
        async _loadStagesTpData(info, tender, stages, preStage, endStage) {
            if (preStage) {
                info.pre_contract_tp = this.ctx.helper.sum([preStage.contract_tp, preStage.pre_contract_tp, preStage.contract_pc_tp]);
                info.pre_contract_tp = this.ctx.helper.sum([preStage.qc_tp, preStage.pre_qc_tp, preStage.qc_pc_tp]);
                info.pre_yf_tp = this.ctx.helper.add(preStage.yf_tp, preStage.pre_yf_tp);
                info.pre_sf_tp = this.ctx.helper.add(preStage.sf_tp, preStage.pre_sf_tp);
            }
            for (const stage of stages) {
                await this.ctx.service.stage.doCheckStage(stage);
                await this._loadStageTpData(info, tender, stage, false);
            }
        }
        async _loadInfoData(tender, filter) {
            const info = { measure_type_str: '', total_price: tender.total_price };
            if (tender.measure_type === measureType.tz.value) info.measure_type_str = measureType.tz.title;
            if (tender.measure_type === measureType.gcl.value) info.measure_type_str = measureType.gcl.title;
            await this.ctx.service.tenderCache.loadTenderCache(tender, this.ctx.session.sessionUser.accountId);
            info.contract_price = tender.contract_price;
            info.advance_tp = tender.advance_tp;
            info.change_tp = tender.change_tp;
            info.progress = tender.progress;
            if (filter.type === 'stage') {
                await this._loadStageTpData(info, tender, filter.stage);
            } else {
                await this._loadStagesTpData(info, tender, filter.stages, filter.preStage, filter.endStage);
            }
            info.pre_gather_tp = this.ctx.helper.add(info.pre_contract_tp, info.pre_qc_tp);
            info.gather_tp = this.ctx.helper.sum([info.contract_tp, info.qc_tp, info.pc_tp]);
            info.end_contract_tp = this.ctx.helper.sum([info.contract_tp, info.contract_pc_tp, info.pre_contract_tp]);
            info.end_qc_tp = this.ctx.helper.sum([info.qc_tp, info.qc_pc_tp, info.pre_qc_tp]);
            info.end_gather_tp = this.ctx.helper.add(info.gather_tp, info.pre_gather_tp);
            info.end_sf_tp = this.ctx.helper.add(info.sf_tp, info.pre_sf_tp);
            info.end_yf_tp = this.ctx.helper.add(info.yf_tp, info.pre_yf_tp);
            return info;
        }
        async _loadLedgerData(tender) {
            const bills = await this.ctx.service.ledger.getAllDataByCondition({
                columns: ['id', 'ledger_id', 'ledger_pid', 'level', 'full_path', 'is_leaf', 'order', 'code', 'b_code', 'name', 'unit', 'unit_price', 'quantity', 'total_price'],
                where: { tender_id: tender.id },
            });
            const pos = await this.ctx.service.pos.getAllDataByCondition({
                columns: ['id', 'lid', 'name', 'quantity', 'porder'],
                where: { tid: tender.id },
            });
            return [bills, pos];
        }
        async _loadDealBillsData(tender) {

        }
        async _getValidStages(tenderId, sort = 'desc', checked = false) {
            const accountId = this.ctx.session.sessionUser.accountId;
            const condition = { tid: tenderId };
            if (checked) condition.status = status.checked;
            const stages = await this.ctx.service.stage.getAllDataByCondition({ where: condition, orders: [['order', sort]] });
            return stages.filter(s => { return s.status !== status.uncheck || s.user_id === accountId; });
        }
        async _filterOrder(tender, order, checked) {
            const stages = await this._getValidStages(tender.id, 'desc', checked);
            const stage = this.ctx.helper._.find(stages, { order });
            if (stage) await this.ctx.service.stage.doCheckStage(stage);
            return { type: 'stage', stage, filter: `第${order}期` };
        }
        async _filterMonth(tender, month, checked) {
            const stages = await this._getValidStages(tender.id, 'desc', checked);
            const stage = this.ctx.helper._.find(stages, { s_time: month });
            if (stage) await this.ctx.service.stage.doCheckStage(stage);
            return { type: 'stage', stage, filter: month };
        }
        async _filterUnderMonth(tender, month, checked) {
            const stages = await this._getValidStages(tender.id, 'desc', checked);
            let stage = this.ctx.helper._.find(stages, { s_time: month });
            if (!stage) {
                const checkTime = moment(month);
                for (const s of stages) {
                    const rela_time = moment(s.s_time);
                    if (rela_time.isBefore(checkTime)) {
                        stage = s;
                        break;
                    }
                }
            }
            if (stage) await this.ctx.service.stage.doCheckStage(stage);
            return { type: 'stage', stage, filter: stage ? stage.s_time : month };
        }
        async _filterFinal(tender, checked) {
            const stages = await this._getValidStages(tender.id, 'desc', checked);
            const stage = stages[0];
            if (stage) await this.ctx.service.stage.doCheckStage(stage);
            return { type: 'stage', stage, filter: `第${stage.order}期` };
        }
        async _filterCheckedFinal(tender, checked) {
            const stages = await this._getValidStages(tender.id, 'desc', checked);
            const checkedStages = stages.filter(x => { return x.status === status.checked; });
            const stage = checkedStages[0];
            if (stage) await this.ctx.service.stage.doCheckStage(stage);
            return { type: 'stage', stage, filter: `第${stage.order}期` };
        }
        async _filterOrderZone(tender, zone, checked) {
            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', checked), 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 { type: 'stages', stages: validStages, preStage, endStage, filter: `第${iBegin}期 ~ 第${iEnd}期` };
        }
        async _filterTimeZone(tender, zone, checked) {
            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', checked), 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 { type: 'stages', stages: validStages, preStage, endStage, filter: zone };
        }
        async _filterStages(tender, stageInfo) {
            switch (stageInfo.type) {
                case 'stage':
                    return await this._filterOrder(tender, stageInfo.stage, stageInfo.checked);
                case 'month':
                    return await this._filterMonth(tender, stageInfo.month, stageInfo.checked);
                case 'final':
                    return await this._filterFinal(tender, stageInfo.checked);
                case 'checked-final':
                    return await this._filterCheckedFinal(tender, stageInfo.checked);
                case 'zone':
                    return await this._filterTimeZone(tender, stageInfo.zone, stageInfo.checked);
                case 'stage-zone':
                    return await this._filterOrderZone(tender, stageInfo.stage_zone, stageInfo.checked);
                case 'under-month':
                    return await this._filterUnderMonth(tender, stageInfo.month, stageInfo.checked);
                default:
                    return;
            }
        }

        async _loadStageData(tender, stage) {
            const bills = await this.ctx.service.ledger.getAllDataByCondition({
                columns: ['id', 'ledger_id', 'ledger_pid', 'level', 'full_path', 'is_leaf', 'order', 'code', 'b_code', 'name', 'unit', 'unit_price', 'quantity', 'total_price'],
                where: { tender_id: tender.id },
            });
            const pos = await this.ctx.service.pos.getAllDataByCondition({
                columns: ['id', 'lid', 'name', 'quantity', 'porder'],
                where: { tid: tender.id },
            });
            if (!stage) return [bills, pos];

            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 = stage.preCheckedStage ? await this.ctx.service.stageBillsFinal.getFinalData(tender, stage.preCheckedStage.order) : [];
            const bpcStage = await this.ctx.service.stageBillsPc.getAllDataByCondition({ where: { sid: stage.id } });
            this.ctx.helper.assignRelaData(bills, [
                { 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 = stage.preCheckedStage ? await this.ctx.service.stagePosFinal.getFinalData(tender, stage.preCheckedStage.order) : [];
            this.ctx.helper.assignRelaData(pos, [
                { data: curStagePos, fields: ['contract_qty', 'qc_qty'], prefix: '', relaId: 'pid' },
                { data: preStagePos, fields: ['contract_qty', 'qc_qty'], prefix: 'pre_', relaId: 'pid' },
            ]);
            return [bills, pos];
        }
        async _loadStagesData(tender, stages, preStage, endStage) {
            const indexPre = 'id_', helper = this.ctx.helper;
            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 bills = await this.ctx.service.ledger.getAllDataByCondition({
                columns: ['id', 'ledger_id', 'ledger_pid', 'level', 'full_path', 'is_leaf', 'order', 'code', 'b_code', 'name', 'unit', 'unit_price', 'quantity', 'total_price'],
                where: { tender_id: tender.id },
            });
            const pos = await this.ctx.service.pos.getAllDataByCondition({
                columns: ['id', 'lid', 'name', 'quantity', 'porder'],
                where: { tid: tender.id },
            });

            let billsIndexData = {};
            for (const bd of bills) {
                billsIndexData[indexPre + bd.id] = bd;
            }
            let posIndexData = {};
            for (const p of pos) {
                posIndexData[indexPre + p.id] = p;
            }

            if (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'},
                ]);
            }
            return [bills, pos];
        }
        async _loadStageLedgerData(tender, filter) {
            return filter.type === 'stage'
                ? await this._loadStageData(tender, filter.stage)
                : await this._loadStagesData(tender, filter.stages, filter.preStage, filter.endStage);
        }

        async _loadStagePayData(tender, stage) {
            if (!stage) return [];

            const dealPay = await this.ctx.service.stagePay.getStagePays(stage);
            if (!stage.readOnly) {
                // 计算 本期金额
                const PayCalculator = require('../lib/pay_calc');
                const payCalculator = new PayCalculator(this.ctx, stage, tender.info);
                await payCalculator.calculateAll(dealPay);
            }
            return dealPay;
        }
        async _loadStagesPayData(tender, stages, preStage, endStage) {
            // todo
            return [];
        }
        async _loadPayData(tender, filter) {
            return filter.type === 'stage'
                ? await this._loadStagePayData(tender, filter.stage)
                : await this._loadStagesPayData(tender, filter.stage, filter.preStage, filter.endStage);
        }

        async _loadStageJgclData(tender, stage) {
            if (!stage) return [];

            const data = await this.ctx.service.stageJgcl.getStageData(stage);
            const preData = stage.preCheckedStage ? await this.ctx.service.stageJgcl.getEndStageData(stage.tid, stage.preCheckedStage.order) : [];
            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);
            }
            return data;
        }
        async _loadStagesJgclData(tender, stages, preStage, endStage) {
            // todo
            return [];
        }
        async _loadJgclData(tender, filter) {
            return filter.type === 'stage'
                ? await this._loadStageJgclData(tender, filter.stage)
                : await this._loadStagesJgclData(tender, filter.stages, filter.preStage, filter.endStage);
        };

        async _loadStageYgclData(tender, stage) {
            if (!stage) return [];

            const data = await this.ctx.service.stageYjcl.getStageData(stage);
            for (const d of data) {
                d.end_qty = this.ctx.helper.add(d.pre_qty, d.qty);
                d.end_tp = this.ctx.helper.add(d.pre_tp, d.tp);
            }
            return data;
        }
        async _loadStagesYgclData(tender, stages, preStage, endStage) {
            // todo
            return [];
        }
        async _loadYjclData(tender, filter) {
            return filter.type === 'stage'
                ? await this._loadStageYgclData(tender, filter.stage)
                : await this._loadStagesYgclData(tender, filter.stages, filter.preStage, filter.endStage);
        };

        async _loadStageBonusData(tender, stage) {
            if (!stage) return [];

            const data = await this.ctx.service.stageBonus.getEndStageData(tender.id, stage.order);
            return data;
        }
        async _loadStagesBonusData(tender, stages, preStage, endStage) {
            // todo
            return [];
        }
        async _loadBonusData(tender, filter) {
            return filter.type === 'stage'
                ? await this._loadStageBonusData(tender, filter.stage)
                : await this._loadStagesBonusData(tender, filter.stages, filter.preStage, filter.endStage);
        };

        async _loadStageSafeProdData(tender, stage) {
            if (!stage) return [];

            const data = await this.ctx.service.stageSafeProd.getStageData(stage);
            const preData = stage.preCheckedStage ? await this.ctx.service.stageSafeProd.getEndStageData(stage.tid, stage.preCheckedStage.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);
            }
            return data;
        }
        async _loadStagesSafeProdData(tender, stages, preStage, endStage) {
            // todo
            return [];
        }
        async _loadSafeProdData(tender, filter) {
            return filter.type === 'stage'
                ? await this._loadStageSafeProdData(tender, filter.stage)
                : await this._loadStagesSafeProdData(tender, filter.stages, filter.preStage, filter.endStage);
        };

        async _loadStageTempLandData(tender, stage) {
            if (!stage) return [];

            const data = await this.ctx.service.stageTempLand.getStageData(stage);
            const preData = stage.preCheckedStage ? await this.ctx.service.stageTempLand.getEndStageData(stage.tid, stage.preCheckedStage.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);
            }
            return data;
        }
        async _loadStagesTempLandData(tender, stages, preStage, endStage) {
            // todo
            return [];
        }
        async _loadTempLandData(tender, filter) {
            return filter.type === 'stage'
                ? await this._loadStageTempLandData(tender, filter.stage)
                : await this._loadStagesTempLandData(tender, filter.stages, filter.preStage, filter.endStage);
        };

        async _loadStageOtherData(tender, stage) {
            if (!stage) return [];

            const data = await this.ctx.service.stageOther.getStageData(stage);
            const preData = stage.preCheckedStage ? await this.ctx.service.stageOther.getEndStageData(stage.tid, stage.preCheckedStage.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);
            }
            return data;
        }
        async _loadStagesOtherData(tender, stages, preStage, endStage) {
            // todo
            return [];
        }
        async _loadOtherData(tender, filter) {
            return filter.type === 'stage'
                ? await this._loadStageOtherData(tender, filter.stage)
                : await this._loadStagesOtherData(tender, filter.stages, filter.preStage, filter.endStage);
        };
        async _loadTenderData(tid, filter, stageInfo) {
            this.ctx.tender = null;
            const tender = await this.ctx.service.tender.checkTender(tid);
            const result = { id: tender.id, name: tender.name, category: tender.category };
            let stageFilter = null;
            for (const f of filter) {
                switch (f) {
                    case 'info':
                        if (!stageFilter) {
                            stageFilter = await this._filterStages(tender, stageInfo);
                            result.stage_filter = stageFilter.filter;
                        }
                        result.info = await this._loadInfoData(tender, stageFilter);
                        break;
                    case 'ledger':
                        if (filter.indexOf('stage') < 0) [result.bills, result.pos] = await this._loadLedgerData(tender);
                        break;
                    case 'stage':
                        if (!stageFilter) {
                            stageFilter = await this._filterStages(tender, stageInfo);
                            result.stage_filter = stageFilter.filter;
                        }
                        [result.bills, result.pos] = await this._loadStageLedgerData(tender, stageFilter);
                        break;
                    case 'pay':
                        if (!stageFilter) {
                            stageFilter = await this._filterStages(tender, stageInfo);
                            result.stage_filter = stageFilter.filter;
                        }
                        result.pay = await this._loadPayData(tender, stageFilter);
                        break;
                    case 'jgcl':
                        if (!stageFilter) {
                            stageFilter = await this._filterStages(tender, stageInfo);
                            result.stage_filter = stageFilter.filter;
                        }
                        result.jgcl = await this._loadJgclData(tender, stageFilter);
                        break;
                    case 'yjcl':
                        if (!stageFilter) {
                            stageFilter = await this._filterStages(tender, stageInfo);
                            result.stage_filter = stageFilter.filter;
                        }
                        result.yjcl = await this._loadYjclData(tender, stageFilter);
                        break;
                    case 'bonus':
                        if (!stageFilter) {
                            stageFilter = await this._filterStages(tender, stageInfo);
                            result.stage_filter = stageFilter.filter;
                        }
                        result.bonus = await this._loadBonusData(tender, stageFilter);
                        break;
                    case 'safeProd':
                        if (!stageFilter) {
                            stageFilter = await this._filterStages(tender, stageInfo);
                            result.stage_filter = stageFilter.filter;
                        }
                        result.safeProd = await this._loadSafeProdData(tender, stageFilter);
                        break;
                    case 'tempLand':
                        if (!stageFilter) {
                            stageFilter = await this._filterStages(tender, stageInfo);
                            result.stage_filter = stageFilter.filter;
                        }
                        result.tempLand = await this._loadTempLandData(tender, stageFilter);
                        break;
                    case 'other':
                        if (!stageFilter) {
                            stageFilter = await this._filterStages(tender, stageInfo);
                            result.stage_filter = stageFilter.filter;
                        }
                        result.other = await this._loadOtherData(tender, stageFilter);
                        break;
                    default:
                        throw '查询的数据类型未定义';
                }
            }
            return result;
        }

        async load(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                const filter = data.filter.split(';');
                const result = [];
                for (const t of data.tender) {
                    result.push(await this._loadTenderData(t.tid, filter, t.stageInfo));
                }
                ctx.body = { err: 0, msg: '', data: result };
            } catch (err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '加载数据错误');
            }
        }

        async _getTzData(tid, includePos = false) {
            const tender = await this.ctx.service.tender.getTender(tid);
            if (!tender || tender.project_id !== this.ctx.session.sessionProject.id) {
                throw '不存在该标段';
            }
            const bills = await this.ctx.service.ledger.getData(tid);
            const pos = tender.measure_type === measureType.tz.value || includePos
                ? await this.ctx.service.pos.getPosData({tid: tid})
                : [];

            return { id: tid, name: tender.name, bills: bills, pos: pos };
        }

        async _checkStage(tid, sorder) {
            const stage = await this.service.stage.getDataByCondition({ tid: tid, order: sorder });
            if (!stage) throw '期数据错误';
            await this.service.stage.doCheckStage(stage);
            return stage;
        }

        async _getStageData(tid, sorder) {
            const data = await this._getTzData(tid, true);
            const stage = await this._checkStage(tid, sorder);
            const bills = await this.ctx.service.stageBills.getAuditorStageData2(tid, stage.id, stage.curTimes, stage.curOrder);
            const pos = await this.ctx.service.stagePos.getAuditorStageData2(tid, stage.id, stage.curTimes, stage.curOrder);
            data.stage = {
                sid: stage.id, sorder: stage.order, curTimes: stage.curTimes, curOrder: stage.curOrder,
                bills: bills, pos: pos
            };
            return data;
        }

        /**
         * 检测台账 页面
         *
         * @param {Object} ctx - egg全局变量
         * @return {void}
         */
        async checkTz(ctx) {
            try {
                const renderData = {
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.tools.checkTz)
                };
                await this.layout('spss/check_tz.ejs', renderData);
            } catch (err) {
                ctx.helper.log(err);
            }
        }
        /**
         * 获取 期计量 汇总 数据(Ajax)
         * @param ctx
         * @returns {Promise<void>}
         */
        async loadBaseData(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                const responseData = {err: 0, msg: '', data: []};

                responseData.data = await this._getTzData(data.id);
                ctx.body = responseData;
            } catch (err) {
                ctx.helper.log(err);
                ctx.body = this.ajaxErrorBody(err, '查询数据错误');
            }
        }

        async stash(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                const responseData = { err: 0, msg: '', data: [] };
                if (!data.type || !data.action) throw '参数错误';

                switch (data.action) {
                    case 'load':
                        responseData.data = await this.ctx.service.spssStash.getSpssStash(data.id);
                        break;
                    case 'list':
                        responseData.data = await this.ctx.service.spssStash.getSpssStashList(this.ctx.subProject.id, data.type);
                        break;
                    case 'add':
                        await this.ctx.service.spssStash.addSpssStash(data.type, data.select, data.result);
                        responseData.data = await this.ctx.service.spssStash.getSpssStashList(this.ctx.subProject.id, data.type);
                        break;
                    case 'first':
                        await this.ctx.service.spssStash.firstSpssStash(this.ctx.subProject.id, data.type, data.id);
                        responseData.data = await this.ctx.service.spssStash.getSpssStashList(this.ctx.subProject.id, data.type);
                        break;
                    default: throw '未知操作';
                }
                ctx.body = responseData;
            } catch (err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '暂存数据错误');
            }
        }

        async test(ctx) {
            try {
                const sourceType = require('../const/source_type');
                await this.layout('spss/dev_test.ejs', { sourceType });
            } catch (err) {
                ctx.helper.log(err);
            }
        }

        async _testLoadReport(data) {
            const reportData = await this.ctx.service.report.getReportData(data.source_type, data.params, data.source_filters);
            this.ctx.body = { err: 0, msg: '', data: reportData };
        }
        async testLoad(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                if (!data.type && !data.detail) throw '参数错误';
                switch(data.type) {
                    case 'report':
                        await this._testLoadReport(data.detail);
                        break;
                    default: throw '未知参数';
                }
            } catch (err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '查询数据错误');
            }
        }
    }

    return SpssController;
};