Calculation/app/controller/settle_controller.js

'use strict';

/**
 * 过程结算 控制器
 *
 * @author Mai
 * @date 2023/10/27
 * @version
 */

const auditConst = require('../const/audit');
const shenpiConst = require('../const/shenpi');

const tenderConst = require('../const/tender');
const measureType = tenderConst.measureType;

const spreadConst = require('../const/spread');
const spreadSetting = require('../lib/spread_setting');

const path = require('path');
const sendToWormhole = require('stream-wormhole');

module.exports = app => {

    class SettleController extends app.BaseController {

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

        /**
         * 期列表(Get)
         * @param ctx
         * @return {Promise<void>}
         */
        async list(ctx) {
            try {
                const renderData = {
                    tender: ctx.tender.data,
                    preUrl: `/tender/${ctx.tender.id}/measure/stage`,
                    auditConst: auditConst.settle,
                    auditType: auditConst.auditType,
                };
                renderData.jsFiles = this.app.jsFiles.common.concat(this.app.jsFiles.settle.list);
                renderData.settles = await ctx.service.settle.getValidSettles(ctx.tender.id);
                for (const s of renderData.settles) {
                    if (s.audit_status === auditConst.settle.status.uncheck) {
                        s.curAuditors = [];
                    } else if (s.audit_status === auditConst.settle.status.checkNo) {
                        s.curAuditors = await ctx.service.settleAudit.getAuditorsByStatus(s.id, s.audit_status, s.audit_times - 1);
                    } else {
                        s.curAuditors = await ctx.service.settleAudit.getAuditorsByStatus(s.id, s.audit_status, s.audit_times);
                    }
                    if (s.audit_status === auditConst.settle.status.checkNoPre) {
                        s.curAuditorsPre = await ctx.service.settleAudit.getAuditorsByStatus(s.id, auditConst.settle.status.checking, s.audit_times);
                    }
                    s.end_tp = ctx.helper.add(s.tp, s.pre_tp);
                }
                renderData.checkedStageCount = await ctx.service.stage.count({ tid: ctx.tender.id, status: auditConst.stage.status.checked });
                await this.layout('settle/list.ejs', renderData, 'settle/list_modal.ejs');
            } catch (err) {
                ctx.log(err);
                ctx.redirect(this.menu.menu.dashboard.url);
            }
        }

        /**
         * 期审批流程(Get)
         * @param ctx
         * @return {Promise<void>}
         */
        async loadAuditors(ctx) {
            try {
                const order = JSON.parse(ctx.request.body.data).order;
                const tenderId = ctx.params.id;
                const settle = await ctx.service.settle.getDataByCondition({ tid: tenderId, settle_order: order });
                await ctx.service.settle.loadRelaUser(settle);
                await ctx.service.settle.loadAuditViewData(settle);
                ctx.body = { err: 0, msg: '', data: settle };
            } catch (error) {
                ctx.log(error);
                ctx.body = { err: 1, msg: error.toString(), data: null };
            }
        }

        async add(ctx) {
            try {
                if (ctx.session.sessionUser.accountId !== ctx.tender.data.user_id) throw '您无权创建结算期';

                const date = ctx.request.body.date;
                const period = ctx.request.body.period;
                if (!date || !period) throw '请选择结算年月和结算周期';

                const newSettle = await ctx.service.settle.addSettle(ctx.tender.id, date, period);
                ctx.redirect('/tender/' + ctx.tender.id + '/settle/' + newSettle.settle_order);
            } catch (err) {
                ctx.log(err);
                ctx.postError(err, '新增结算期失败，请重试');
                ctx.redirect('/tender/' + ctx.tender.id + '/settle');
            }
        }

        async save(ctx) {
            try {
                const data = {
                    order: ctx.request.body.order,
                    date: ctx.request.body.date,
                    period: ctx.request.body.period,
                };
                const settle = await ctx.service.settle.getDataByCondition({ tid: ctx.tender.id, settle_order: data.order });
                if (!settle) throw '修改的结算期不存在';

                if (ctx.session.sessionUser.accountId !== settle.user_id) throw '您无权修改该数据';

                await this.ctx.service.settle.saveSettle(ctx.tender.id, data.order, data.date, data.period);
                ctx.redirect('/tender/' + ctx.tender.id + '/settle');
            } catch (err) {
                ctx.log(err);
                ctx.postError(err, '保存结算期数据失败，请重试');
                ctx.redirect('/tender/' + ctx.tender.id + '/settle');
            }
        }

        async delete(ctx) {
            try {
                if (ctx.request.body.confirm !== undefined && ctx.request.body.confirm !== '确认删除本期') {
                    throw '请输入正确的文本信息';
                }

                const sid = ctx.request.body.settle_id;
                const settle = await ctx.service.settle.getDataById(sid);
                const settleCount = await ctx.service.settle.count({ tid: ctx.tender.id });
                if (!settle || settle.tid !== ctx.tender.id) throw '选择的结算期已不存在';
                if (settleCount !== settle.settle_order) throw '选择的结算期无法删除';

                if (ctx.session.sessionUser.accountId !== settle.user_id && !ctx.session.sessionUser.is_admin) throw '您无权删除结算期';

                await ctx.service.settle.deleteSettle(sid);
                ctx.redirect('/tender/' + ctx.tender.id + '/settle/');
            } catch (err) {
                ctx.log(err);
                ctx.postError(err, '删除结算期数据失败，请重试');
                ctx.redirect('/tender/' + ctx.tender.id + '/settle/');
            }
        }

        async _getDefaultRenderData(ctx) {
            const data = {
                settleStatusHint: ctx.service.settle.statusArray,
                settleStatusColor: ctx.service.settle.statusColor,
                settleStatus: ctx.service.settle.settleStatus,
                tender: ctx.tender.data,
                auditConst: auditConst.settle,
                measureType,
                preUrl: '/tender/' + ctx.tender.id + '/settle/' + ctx.params.sorder,
                settle: ctx.settle,
                shenpiConst,
                auditType: auditConst.auditType,
                thirdParty: {
                    gxby: ctx.session.sessionProject.gxby_status,
                    dagl: ctx.session.sessionProject.dagl_status,
                },
            };
            // 是否已验证手机短信
            const pa = await ctx.service.projectAccount.getDataById(ctx.session.sessionUser.accountId);
            data.authMobile = pa.auth_mobile;

            // 获取所有项目参与者
            const accountList = await ctx.service.projectAccount.getAllDataByCondition({
                where: { project_id: ctx.session.sessionProject.id, enable: 1 },
                columns: ['id', 'name', 'company', 'role', 'enable', 'is_admin', 'account_group', 'mobile'],
            });
            data.accountList = accountList;
            const unitList = await ctx.service.constructionUnit.getAllDataByCondition({ where: { pid: ctx.session.sessionProject.id } });
            data.accountGroup = unitList.map(item => {
                const groupList = accountList.filter(item1 => item1.company === item.name);
                return { groupName: item.name, groupList };
            });
            return data;
        }

        async index(ctx) {
            const status = auditConst.settle.status;
            let url = (ctx.settle.audit_status === status.uncheck || ctx.settle.audit_status === status.checkNo) && (ctx.session.sessionUser.is_admin || ctx.session.sessionUser.accountId === ctx.settle.user_id) ? 'select' : 'ledger';
            ctx.redirect(ctx.url + '/' + url);
        }
        async select(ctx) {
            try {
                await ctx.service.settle.loadAuditViewData(ctx.settle);
                const renderData = await this._getDefaultRenderData(ctx);
                renderData.jsFiles = this.app.jsFiles.common.concat(this.app.jsFiles.settle.select);

                renderData.whiteList = this.ctx.app.config.multipart.whitelist;
                await this.layout('settle/select.ejs', renderData, 'settle/select_modal.ejs');
            } catch(err) {
                ctx.log(err);
                ctx.redirect('/tender/' + ctx.tender.id + '/settle');
            }
        }
        async ledger(ctx) {
            try {
                await ctx.service.settle.loadAuditViewData(ctx.settle);
                const renderData = await this._getDefaultRenderData(ctx);
                renderData.jsFiles = this.app.jsFiles.common.concat(this.app.jsFiles.settle.ledger);

                renderData.whiteList = this.ctx.app.config.multipart.whitelist;
                await this.layout('settle/index.ejs', renderData, 'settle/modal.ejs');
            } catch(err) {
                ctx.log(err);
                ctx.redirect('/tender/' + ctx.tender.id + '/settle');
            }
        }

        checkNeedPretreadData(ctx) {
            return ctx.settle.audit_status === auditConst.settle.status.uncheck || (ctx.settle.audit_status === auditConst.settle.status.checkNo && !ctx.settle.readOnly);
        }

        async _loadLatestStage(ctx) {
            if (ctx.settle.latestStage) return;
            ctx.settle.latestStage = ctx.settle.final_sid
                ? await this.ctx.service.stage.getDataById(ctx.settle.final_sid)
                : await this.ctx.service.stage.getLastestCompleteStage(ctx.tender.id);
        }
        async _getStageBillsData(ctx) {
            this.ledgerColumn = [
                'id', 'tender_id', 'ledger_id', 'ledger_pid', 'level', 'order', 'full_path', 'is_leaf',
                'code', 'b_code', 'name', 'unit', 'unit_price',
                'quantity', 'total_price', 'memo', 'drawing_code', 'node_type'];
            this.ledgerExtraColumn = [];
            if (this.ctx.session.sessionProject.gxby) this.ledgerExtraColumn.push('gxby_status', 'gxby_url', 'gxby_limit');
            if (this.ctx.session.sessionProject.dagl) this.ledgerExtraColumn.push('dagl_status', 'dagl_url', 'dagl_limit');
            const ledgerData = await ctx.service.ledger.getAllDataByCondition({ columns: this.ledgerColumn, where: { tender_id: ctx.tender.id } });
            const endStageData = await ctx.service.stageBillsFinal.getAllDataByCondition({ where: { sid: ctx.settle.latestStage.id } });
            const extraData = this.ledgerExtraColumn.length > 0 ? await ctx.service.ledgerExtra.getData(ctx.tender.id, this.ledgerExtraColumn) : [];
            const settleStatus = ctx.settle.settle_order > 1
                ? await ctx.service.settleBills.getAllDataByCondition({ column: ['lid', 'settle_status'], where: { settle_order: ctx.settle.settle_order - 1, settle_status: [1, 2]} })
                : [];
            this.ctx.helper.assignRelaData(ledgerData, [
                { data: endStageData, fields: ['contract_qty', 'contract_tp', 'qc_qty', 'qc_tp', 'qc_minus_qty'], prefix: 'end_', relaId: 'lid' },
                { data: extraData, fields: this.ledgerExtraColumn, prefix: '', relaId: 'id' },
                { data: settleStatus, fields: ['settle_status'], prefix: '', relaId: 'lid' },
            ]);
            return ledgerData;
        }
        async _getStagePosData(ctx) {
            this.posColumn = ['id', 'tid', 'lid', 'name', 'position', 'porder', 'quantity', 'add_stage_order', 'drawing_code'];
            this.posExtraColumn = [];
            if (this.ctx.session.sessionProject.gxby) this.posExtraColumn.push('gxby_status', 'gxby_url', 'gxby_limit');
            if (this.ctx.session.sessionProject.dagl) this.posExtraColumn.push('dagl_status', 'dagl_url', 'dagl_limit');
            const posData = await ctx.service.pos.getAllDataByCondition({ columns: this.posColumn, where: { tid: ctx.tender.id } });
            const endStageData = await ctx.service.stagePosFinal.getAllDataByCondition({ where: { sid: ctx.settle.latestStage.id } });
            const extraData = this.posExtraColumn.length > 0 ? await ctx.service.posExtra.getData(ctx.tender.id, this.posExtraColumn) : [];
            const settleStatus = ctx.settle.settle_order > 1
                ? await ctx.service.settlePos.getAllDataByCondition({ column: ['pid', 'settle_status'], where: { settle_order: ctx.settle.settle_order - 1, settle_status: [1, 2]} })
                : [];
            this.ctx.helper.assignRelaData(posData, [
                { data: endStageData, fields: ['contract_qty', 'qc_qty', 'qc_minus_qty'], prefix: 'end_', relaId: 'pid' },
                { data: extraData, fields: this.posExtraColumn, prefix: '', relaId: 'id'},
                { data: settleStatus, fields: ['settle_status'], prefix: '', relaId: 'pid' },
            ]);
            return posData;
        }
        async _loadPretreatSettleData(ctx) {
            if (this.checkNeedPretreadData(ctx)) {
                this.pretreadSettle = {};
                const Pretreat = require('../lib/settle');
                const pretreadObj = new Pretreat(ctx);
                [this.pretreadSettle.settleBills, this.pretreadSettle.settlePos] = await pretreadObj.doSettle(this.ctx.settle);
            }
        }
        async _loadSettleBills(ctx) {
            const billsData = this.checkNeedPretreadData(ctx)
                ? this.pretreadSettle.settleBills
                : await ctx.service.settleBills.getAllDataByCondition({ where: { settle_id: ctx.settle.id } });

            this.ledgerExtraColumn = [];
            if (this.ctx.session.sessionProject.gxby) this.ledgerExtraColumn.push('gxby_status', 'gxby_url', 'gxby_limit');
            if (this.ctx.session.sessionProject.dagl) this.ledgerExtraColumn.push('dagl_status', 'dagl_url', 'dagl_limit');
            const extraData = this.ledgerExtraColumn.length > 0 ? await ctx.service.ledgerExtra.getData(ctx.tender.id, this.ledgerExtraColumn) : [];
            this.ctx.helper.assignRelaData(billsData, [
                { data: extraData, fields: this.ledgerExtraColumn, prefix: '', relaId: 'id'},
            ], 'lid');
            return billsData;
        }
        async _loadSettlePos(ctx) {
            const posData = this.checkNeedPretreadData(ctx)
                ? this.pretreadSettle.settlePos
                : await ctx.service.settlePos.getAllDataByCondition({ where: { settle_id: ctx.settle.id } });
            this.posExtraColumn = [];
            if (this.ctx.session.sessionProject.gxby) this.posExtraColumn.push('gxby_status', 'gxby_url', 'gxby_limit');
            if (this.ctx.session.sessionProject.dagl) this.posExtraColumn.push('dagl_status', 'dagl_url', 'dagl_limit');
            const extraData = this.posExtraColumn.length > 0 ? await ctx.service.posExtra.getData(ctx.tender.id, this.posExtraColumn) : [];
            this.ctx.helper.assignRelaData(posData, [
                { data: extraData, fields: this.posExtraColumn, prefix: '', relaId: 'id'},
            ], 'pid');
            return posData;
        }
        async _loadSettleDataByKey(ctx, key, hpack) {
            switch (key) {
                case 'stageBills':
                    await this._loadLatestStage(ctx);
                    const bills = await this._getStageBillsData(ctx);
                    return hpack ? [ctx.helper.hpackArr(bills), 'stageBills'] : [bills, ''];
                case 'stagePos':
                    await this._loadLatestStage(ctx);
                    const pos = await this._getStagePosData(ctx);
                    return hpack ? [ctx.helper.hpackArr(pos), 'stagePos'] : [pos, ''];
                case 'settleChange':
                    await this._loadLatestStage(ctx);
                    const settleChange = await ctx.service.stageChangeFinal.getUnSettleChangeData(ctx.settle.latestStage);
                    return hpack ? [ctx.helper.hpackArr(settleChange), key] : [settleChange, ''];
                case 'settleBills':
                    await this._loadPretreatSettleData(ctx);
                    const settleBills = await this._loadSettleBills(ctx);
                    return hpack ? [ctx.helper.hpackArr(settleBills), 'settleBills'] : [settleBills, ''];
                case 'settlePos':
                    await this._loadPretreatSettleData(ctx);
                    const settlePos = await this._loadSettlePos(ctx);
                    return hpack ? [ctx.helper.hpackArr(settlePos), 'settlePos'] : [settlePos, ''];
                case 'settleSelect':
                    const settleSelect = await ctx.service.settleSelect.getAllDataByCondition({ where: { settle_id: ctx.settle.id } });
                    return [settleSelect, ''];
                case 'tag':
                    const tag = await ctx.service.ledgerTag.getDatas(ctx.tender.id, -1, ctx.settle.id);
                    return [tag, ''];
                case 'att':
                    const att = await ctx.service.ledgerAtt.getViewData(ctx.tender.id, ctx.settle.id);
                    return [att, ''];
                default:
                    return [null, ''];
            }
        }
        async loadSettleData(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                const filter = data.filter.split(';');
                const responseData = { err: 0, msg: '', data: {}, hpack: [] };
                const hpack = true;
                for (const f of filter) {
                    const [relaData, hpackKey] = await this._loadSettleDataByKey(ctx, f, hpack);
                    responseData.data[f] = relaData;
                    if (hpackKey) responseData.hpack.push(hpackKey);
                }

                ctx.body = responseData;
            } catch (err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '获取结算数据出错');
            }
        }

        _checkSettleCanModify(ctx, isCheck = false) {
            // 检查登录用户，是否可操作
            if (ctx.settle.readOnly) {
                if (!isCheck || !ctx.settle.canCheck) throw '该结算期当前您无权操作';
            }
            // if (ctx.settle.assist && ctx.settle.assist.confirm) {
            //     throw '协同数据已确认，如需修改，请撤销上报或重新审批';
            // }
        }
        async updateSelect(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                if (!data.add && !data.del) throw '提交数据错误';
                const result = await ctx.service.settleSelect.updateData(data);
                ctx.body = { err: 0, msg: '', data: result };
            } catch (err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '提交结算数据出错');
            }
        }

        async uploadFile(ctx) {
            let stream;
            try {
                const parts = ctx.multipart({ autoFields: true });
                const files = [];
                let index = 0;
                const extra_upload = ctx.settle.audit_status === auditConst.settle.status.checked;
                stream = await parts();
                while (stream) {
                    // 判断用户是否选择上传文件
                    if (!stream.filename) {
                        throw '请选择上传的文件!';
                    }
                    const fileInfo = path.parse(stream.filename);
                    const create_time = Date.parse(new Date()) / 1000;
                    const filepath = `${ctx.session.sessionProject.id}/${ctx.tender.id}/settle/${ctx.settle.settle_order}/att_${create_time + index.toString() + fileInfo.ext}`;

                    await ctx.app.fujianOss.put(ctx.app.config.fujianOssFolder + filepath, stream);

                    if (stream) await sendToWormhole(stream);

                    // 保存数据到att表
                    const fileData = {
                        tid: ctx.tender.id,
                        settle_id: ctx.settle.id,
                        settle_order: ctx.settle.settle_order,
                        in_time: create_time,
                        filename: fileInfo.name,
                        fileext: fileInfo.ext,
                        filesize: Array.isArray(parts.field.size) ? parts.field.size[index] : parts.field.size,
                        filepath,
                        extra_upload,
                    };
                    const result = await ctx.service.ledgerAtt.save(parts.field, fileData, ctx.session.sessionUser.accountId);
                    if (!result) throw '保存数据失败';
                    const attData = await ctx.service.ledgerAtt.getViewDataByFid(result.insertId);
                    files.length !== 0 ? files.unshift(attData) : files.push(attData);
                    ++index;
                    if (Array.isArray(parts.field.size) && index < parts.field.size.length) {
                        stream = await parts();
                    } else {
                        stream = undefined;
                    }
                }
                ctx.body = { err: 0, msg: '', data: files };
            } catch (err) {
                ctx.log(err);
                // 失败需要消耗掉stream 以防卡死
                if (stream) await sendToWormhole(stream);
                ctx.ajaxErrorBody(err, '上传文件失败');
            }
        }
        async deleteFile(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                const fileInfo = await ctx.service.ledgerAtt.getDataById(data.id);
                if (!fileInfo || !Object.keys(fileInfo).length) throw '该文件不存在';
                if (!fileInfo.extra_upload && ctx.settle.status === auditConst.settle.status.checked) throw '无权限删除';

                if (fileInfo !== undefined && fileInfo !== '') {
                    // 先删除文件
                    await ctx.app.fujianOss.delete(ctx.app.config.fujianOssFolder + fileInfo.filepath);
                    // 再删除数据库
                    await ctx.service.ledgerAtt.deleteById(data.id);
                } else {
                    throw '不存在该文件';
                }
                ctx.body = { err: 0, msg: '', data: null}
            } catch (err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '删除文件失败');
            }
        }
        async saveFile(ctx) {
            let stream;
            try {
                stream = await ctx.getFileStream({ requireFile: false });
                let fileData = {};
                if (stream.filename !== undefined) {
                    const create_time = Date.parse(new Date()) / 1000;
                    const fileInfo = path.parse(stream.filename);
                    const filepath = `${ctx.session.sessionProject.id}/${ctx.tender.id}/settle/${ctx.settle.settle_order}/att_${create_time + fileInfo.ext}`;

                    // 保存文件
                    await ctx.oss.put(ctx.app.config.fujianOssFolder + filepath, stream);
                    // 保存数据到att表
                    fileData = {
                        filesize: stream.fields.size,
                        filepath,
                    };
                }
                const org = await ctx.service.ledgerAtt.getDataById(stream.fields.id);
                const result = await ctx.service.ledgerAtt.updateByID(stream.fields, fileData);
                if (!result) throw '保存数据失败';
                // 删除原附件
                await ctx.app.fujianOss.delete(ctx.app.config.fujianOssFolder + org.filepath);
                const attData = await ctx.service.ledgerAtt.getViewDataByFid(stream.fields.id);
                ctx.body = { err: 0, msg: '', data: attData };
                responseData.data = attData;
            } catch (err) {
                ctx.log(err);
                // 失败需要消耗掉stream 以防卡死
                if (stream) await sendToWormhole(stream);
                ctx.ajaxErrorBody(err, '保存数据失败');
            }
        }

        /**
         * 添加审批人
         * @param ctx
         * @return {Promise<void>}
         */
        async addAudit(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                const id = this.app._.toInteger(data.auditorId);
                if (isNaN(id) || id <= 0) throw '参数错误';

                // 检查权限等
                if (ctx.settle.user_id !== ctx.session.sessionUser.accountId) throw '您无权添加审核人';
                if (ctx.settle.audit_status !== auditConst.settle.status.uncheck && ctx.settle.audit_status !== auditConst.settle.status.checkNo) {
                    throw '当前不允许添加审核人';
                }

                // 检查审核人是否已存在
                const exist = await ctx.service.settleAudit.getDataByCondition({ settle_id: ctx.settle.id, audit_times: ctx.settle.audit_times, audit_id: id });
                if (exist) throw '该审核人已存在，请勿重复添加';

                const auditorInfo = await this.ctx.service.projectAccount.getDataById(id);
                if (!auditorInfo) throw '添加的审批人不存在';

                const shenpiInfo = await ctx.service.shenpiAudit.getDataByCondition({ tid: ctx.tender.id, sp_type: shenpiConst.sp_type.settle, sp_status: shenpiConst.sp_status.gdzs });
                const is_gdzs = shenpiInfo && ctx.tender.info.shenpi.settle === shenpiConst.sp_status.gdzs ? 1 : 0;
                const result = await ctx.service.settleAudit.addAuditor(ctx.settle.id, auditorInfo, ctx.settle.audit_times, is_gdzs);
                if (!result) throw '添加审核人失败';

                const auditors = await ctx.service.settleAudit.getAuditorGroup(ctx.settle.id, ctx.settle.audit_times);
                ctx.body = { err: 0, msg: '', data: auditors };
            } catch (err) {
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }
        /**
         * 移除审批人
         * @param ctx
         * @return {Promise<void>}
         */
        async deleteAudit(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                const id = data.auditorId instanceof Number ? data.auditorId : this.app._.toNumber(data.auditorId);
                if (isNaN(id) || id <= 0) throw '参数错误';

                const result = await ctx.service.settleAudit.deleteAuditor(ctx.settle.id, id, ctx.settle.audit_times);
                if (!result) throw '移除审核人失败';

                const auditors = await ctx.service.settleAudit.getAuditors(ctx.settle.id, ctx.settle.audit_times);
                ctx.body = { err: 0, msg: '', data: auditors };
            } catch (err) {
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }
        async _checkSettleSelect(ctx) {
            const Check = require('../lib/settle');
            const checkObj = new Check(ctx);
            const result = await checkObj.checkSettle(ctx.settle);
            if (!result) throw '您勾选了不可结算的数据，请检查后再上报';
        }
        async auditStart(ctx) {
            try {
                if (ctx.settle.user_id !== ctx.session.sessionUser.accountId) throw '您无权上报该期数据';
                if (ctx.settle.revising) throw '台账修订中，不可上报';
                if (ctx.settle.audit_status !== auditConst.settle.status.uncheck && ctx.settle.audit_status !== auditConst.settle.status.checkNo) throw '该期数据当前无法上报';
                await this._checkSettleSelect(ctx);

                await ctx.service.settleAudit.start(ctx.settle);
                //ctx.redirect('/tender/' + ctx.tender.id + '/settle/' + newSettle.settle_order);
                ctx.redirect(ctx.request.header.referer);
            } catch (err) {
                ctx.log(err);
                ctx.postError(err, '上报失败');
                ctx.redirect(`/tender/${ctx.settle.tid}/settle/${ctx.settle.settle_order}/select`);
            }
        }
        async auditCheck(ctx) {
            try {
                if (!ctx.settle || (ctx.settle.audit_status !== auditConst.settle.status.checking && ctx.settle.audit_status !== auditConst.settle.status.checkNoPre)) {
                    throw '当前期数据有误';
                }
                if (ctx.settle.curAuditorIds.indexOf(ctx.session.sessionUser.accountId) < 0) {
                    throw '您无权进行该操作';
                }
                if (ctx.settle.revising) throw '台账修订中，不可审批';

                const checkType = parseInt(ctx.request.body.checkType);
                const opinion = ctx.request.body.opinion.replace(/\r\n/g, '<br/>').replace(/\n/g, '<br/>').replace(/\s/g, ' ');
                await ctx.service.settleAudit.check(ctx.settle, checkType, opinion);
            } catch (err) {
                ctx.log(err);
                ctx.postError(err, '审批失败');
            }
            ctx.redirect(ctx.request.header.referer);
        }
        async auditCheckAgain(ctx) {
            try {
                if (ctx.settle.settle_order !== ctx.settle.highOrder) throw '非最新一期，不可重新审批';
                if (ctx.settle.audit_status !== auditConst.settle.status.checked) throw '未审批完成，不可重新审批';
                if (ctx.settle.revising) throw '台账修订中，不可重审';

                if (ctx.session.sessionUser.loginStatus === 0) {
                    const user = await ctx.service.projectAccount.getDataById(ctx.session.sessionUser.accountId);
                    if (!user.auth_mobile) throw '未绑定手机号';

                    const code = ctx.request.body.code;
                    const cacheKey = 'smsCode:' + ctx.session.sessionUser.accountId;
                    const cacheCode = await app.redis.get(cacheKey);
                    if (cacheCode === null || code === undefined || cacheCode !== (code + pa.auth_mobile)) {
                        throw '验证码不正确！';
                    }
                }

                const adminCheckAgain = ctx.request.body.confirm === '确认设置终审审批' && ctx.session.sessionUser.is_admin;
                if (ctx.settle.finalAuditorIds.indexOf(ctx.session.sessionUser.accountId) < 0 && !adminCheckAgain) throw '您无权重新审批';

                await ctx.service.settleAudit.checkAgain(ctx.settle, adminCheckAgain);
            } catch (err) {
                this.log(err);
                ctx.postError(err, '重新审批失败');
            }
            ctx.redirect(ctx.request.header.referer);
        }
        async auditCheckCancel(ctx) {
            try {
                if (ctx.settle.revising) throw '台账修订中，不可撤回';
                if (!ctx.settle.cancancel) throw '您无权进行该操作';

                await ctx.service.settleAudit.checkCancel(ctx.settle);
            } catch (err) {
                this.log(err);
                ctx.postError(err, '撤回失败');
            }
            ctx.redirect(ctx.request.header.referer);
        }

        async loadGatherData(ctx) {
            try {
                const settle = await this.ctx.service.settle.getLatestCompleteSettle(ctx.tender.id);
                const bills = await this.ctx.service.settleBills.getAllDataByCondition({ where: { settle_id: settle.id }});
                const pos = await this.ctx.service.settlePos.getAllDataByCondition({ where: { settle_id: settle.id }});
                ctx.body = { err: 0, msg: '', data: { bills, pos } };
            } catch(err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '获取结算汇总数据错误');
            }
        }
        async gather(ctx) {
            try {
                const renderData = {
                    settleStatusHint: ctx.service.settle.statusArray,
                    settleStatusColor: ctx.service.settle.statusColor,
                    settleStatus: ctx.service.settle.settleStatus,
                    measureType,
                    settle: ctx.settle,
                    thirdParty: {
                        gxby: ctx.session.sessionProject.gxby_status,
                        dagl: ctx.session.sessionProject.dagl_status,
                    },
                    tender: ctx.tender.data,
                    preUrl: `/tender/${ctx.tender.id}/settle`,
                };
                renderData.jsFiles = this.app.jsFiles.common.concat(this.app.jsFiles.settle.gather);
                await this.layout('settle/gather.ejs', renderData);
            } catch (err) {
                ctx.log(err);
                ctx.redirect(this.menu.menu.dashboard.url);
            }
        }
    }

    return SettleController;
};