Calculation/app/controller/payment_controller.js

'use strict';
const accountGroup = require('../const/account_group').group;
const JV = require('../reports/rpt_component/jpc_value_define');
const shenpiConst = require('../const/shenpi');
const auditConst = require('../const/audit').stage;
const paymentConst = require('../const/payment');

module.exports = app => {

    class PaymentController extends app.BaseController {
        /**
         * 构造函数
         *
         * @param {Object} ctx - egg全局变量
         * @return {void}
         */
        constructor(ctx) {
            super(ctx);
            ctx.showProject = true;
            // ctx.showTitle = true;
        }
        /**
         * 支付审批列表页
         *
         * @param {Object} ctx - egg全局页面
         * @return {void}
         */
        async index(ctx) {
            try {
                const auditPermission = await this.ctx.service.paymentPermissionAudit.getOnePermission(ctx.session.sessionUser.is_admin, ctx.session.sessionUser.accountId);
                if (!auditPermission) {
                    throw '权限不足';
                }
                // 列表读取及目录读取

                const renderData = {
                    auditPermission,
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.payment.index),
                };
                if (ctx.session.sessionUser.is_admin) {
                    const projectId = ctx.session.sessionProject.id;
                    const permissionAudits = await ctx.service.paymentPermissionAudit.getList(projectId);
                    // 获取所有项目参与者
                    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'],
                    });
                    const accountGroupList = accountGroup.map((item, idx) => {
                        const groupList = accountList.filter(item => item.account_group === idx);
                        return { groupName: item, groupList };
                    });
                    renderData.permissionAudits = permissionAudits;
                    renderData.accountList = accountList;
                    renderData.accountGroup = accountGroupList;
                }
                await this.layout('payment/index.ejs', renderData, 'payment/modal.ejs');
            } catch (err) {
                console.log(err);
                this.log(err);
                ctx.redirect(this.menu.menu.dashboard.url);
            }
        }

        async listLoad(ctx) {
            const responseData = {
                err: 0, msg: '', data: {},
            };
            // 先获取你创建的标段及参与的标段
            const tenderList = await ctx.service.paymentTender.getList(ctx.session.sessionUser.accountId);
            // 获取你创建的目录及对应目录下的所有目录
            const folderList = await ctx.service.paymentFolder.getList(ctx.session.sessionUser.accountId, tenderList);
            if (tenderList.length > 0) {
                for (const t of tenderList) {
                    t.have_notice = await ctx.service.paymentDetail.haveNotice2Tender(t.id, ctx.session.sessionUser.accountId);
                    t.have_detail = await ctx.service.paymentDetail.haveDetail2Tender(t.id);
                }
            }
            responseData.data.folderList = folderList;
            responseData.data.tenderList = tenderList;
            ctx.body = responseData;
        }

        async permissionSave(ctx) {
            try {
                if (ctx.session.sessionUser.is_admin === 0) throw '没有设置权限';
                const projectId = ctx.session.sessionProject.id;
                const responseData = {
                    err: 0, msg: '', data: null,
                };

                const data = JSON.parse(ctx.request.body.data);
                if (!data.type) {
                    throw '提交数据错误';
                }
                let uids;
                let result = false;
                let auditList = [];
                switch (data.type) {
                    case 'add-audit':
                        // 判断用户是单个还是数组
                        uids = data.id instanceof Array ? data.id : [data.id];
                        // 判断该用户的组是否已加入到表中，已加入则提示无需添加
                        auditList = await ctx.service.paymentPermissionAudit.getAllDataByCondition({ where: { pid: projectId, uid: uids } });
                        const addAidList = ctx.helper._.difference(uids, ctx.helper._.map(auditList, 'uid'));
                        if (addAidList.length === 0) {
                            throw '用户已存在权限中，无需重复添加';
                        }
                        const accountList = await ctx.service.projectAccount.getAllDataByCondition({ where: { id: addAidList } });
                        await ctx.service.paymentPermissionAudit.saveAudits(projectId, accountList);
                        responseData.data = await ctx.service.paymentPermissionAudit.getList(projectId);
                        break;
                    case 'del-audit':
                        uids = data.id instanceof Array ? data.id : [data.id];
                        auditList = await ctx.service.paymentPermissionAudit.getAllDataByCondition({ where: { id: uids } });
                        if (auditList.length !== uids.length) {
                            throw '该用户已不存在权限中，移除失败';
                        }
                        await ctx.service.paymentPermissionAudit.delAudit(uids);
                        responseData.data = await ctx.service.paymentPermissionAudit.getList(projectId);
                        break;
                    case 'save-permission-one':
                        result = await ctx.service.paymentPermissionAudit.updateOnePermission(data.updateData);
                        if (!result) {
                            throw '修改权限失败';
                        }
                        break;
                    case 'save-permission-all':
                        result = await ctx.service.paymentPermissionAudit.updateAllPermission(projectId, data.permission_type, data.value);
                        if (!result) {
                            throw '修改权限失败';
                        }
                        responseData.data = await ctx.service.paymentPermissionAudit.getList(projectId);
                        break;
                    default: throw '参数有误';
                }
                ctx.body = responseData;
            } catch (err) {
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }

        async save(ctx) {
            try {
                const projectId = ctx.session.sessionProject.id;
                const auditPermission = await this.ctx.service.paymentPermissionAudit.getOnePermission(ctx.session.sessionUser.is_admin, ctx.session.sessionUser.accountId);
                if (!auditPermission) {
                    throw '权限不足';
                }
                const responseData = {
                    err: 0, msg: '', data: {},
                };

                const data = JSON.parse(ctx.request.body.data);
                if (!data.type) {
                    throw '提交数据错误';
                }
                let type = '';
                switch (data.type) {
                    case 'add-folder':
                        if (!auditPermission.folder) {
                            throw '没有权限新建目录';
                        }
                        await ctx.service.paymentFolder.addFolder(projectId, ctx.session.sessionUser.accountId, data.parentId, data.name);
                        break;
                    case 'add-tender':
                        if (!auditPermission.tender) {
                            throw '没有权限新建标段';
                        }
                        await ctx.service.paymentTender.addTender(projectId, ctx.session.sessionUser.accountId, data.folderId, data.name);
                        break;
                    case 'edit-name':
                        type = data.postData.type;
                        const updateData = {
                            name: data.postData.name,
                        };
                        const conditionData = {
                            id: data.postData.id,
                        };
                        if (type === 'tender') {
                            await ctx.service.paymentTender.update(updateData, conditionData);
                        } else {
                            await ctx.service.paymentFolder.update(updateData, conditionData);
                        }
                        break;
                    case 'del':
                        type = data.postData.type;
                        if (type === 'tender') {
                            await ctx.service.paymentTender.deleteTender(data.postData.id);
                        } else {
                            await ctx.service.paymentFolder.deleteFolder(data.postData.id);
                        }
                        break;
                    default: throw '参数有误';
                }
                // 先获取你创建的标段及参与的标段
                const tenderList = await ctx.service.paymentTender.getList(ctx.session.sessionUser.accountId);
                // 获取你创建的目录及对应目录下的所有目录
                const folderList = await ctx.service.paymentFolder.getList(ctx.session.sessionUser.accountId, tenderList);
                responseData.data.folderList = folderList;
                responseData.data.tenderList = tenderList;
                ctx.body = responseData;
            } catch (err) {
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }

        /**
         * 获取审批界面所需的 原报、审批人数据等
         * @param ctx
         * @return {Promise<void>}
         * @private
         */
        async _getDetailAuditViewData(ctx) {
            const times = ctx.detail.status === auditConst.status.checkNo ? ctx.detail.times - 1 : ctx.detail.times;
            ctx.detail.user = await ctx.service.projectAccount.getAccountInfoById(ctx.detail.uid);
            ctx.detail.auditHistory = [];
            if (times >= 1) {
                for (let i = 1; i <= times; i++) {
                    ctx.detail.auditHistory.push(await ctx.service.paymentDetailAudit.getAuditors(ctx.detail.id, i));
                }
            }
            // 获取审批流程中左边列表
            ctx.detail.auditors2 = ctx.detail.status === auditConst.status.checkNo && ctx.detail.uid !== ctx.session.sessionUser.accountId ?
                await ctx.service.paymentDetailAudit.getAuditorsWithOwner(ctx.detail.id, times) :
                await ctx.service.paymentDetailAudit.getAuditorsWithOwner(ctx.detail.id, ctx.detail.times);
            if (ctx.detail.status === auditConst.status.uncheck || ctx.detail.status === auditConst.status.checkNo) {
                ctx.detail.auditorList = await ctx.service.paymentDetailAudit.getAuditors(ctx.detail.id, ctx.detail.times);
            }

            // 是否已验证手机短信
            const pa = await ctx.service.projectAccount.getDataById(ctx.session.sessionUser.accountId);
            ctx.detail.authMobile = pa.auth_mobile;
        }

        /**
         * 支付表单页面
         *
         * @param {Object} ctx - egg全局页面
         * @return {void}
         */
        async detail(ctx) {
            try {
                await this._getDetailAuditViewData(ctx);
                const report_json = JSON.parse(ctx.detail.report_json);
                const content = [];
                // 获取当前报表人
                const rptAudit = await ctx.service.paymentRptAudit.getDataByCondition({ td_id: ctx.detail.id, uid: ctx.session.sessionUser.accountId });
                // 获取个人签字，单位章，个人章地址
                const userInfo = await ctx.service.projectAccount.getDataById(ctx.session.sessionUser.accountId);
                const stampPathList = userInfo.stamp_path ? userInfo.stamp_path.split('!;!') : [];
                const companyInfo = userInfo.company ? await ctx.service.constructionUnit.getDataByCondition({ pid: ctx.session.sessionProject.id, name: userInfo.company }) : {};
                if (report_json.items[0].interact_cells.length > 0) {
                    for (const [i, cell] of report_json.items[0].interact_cells.entries()) {
                        const push_item = {
                            type: paymentConst.rpt_dataType[cell.DataType],
                            value: cell.Prefix ? ctx.helper._.replace(cell.Value, cell.Prefix, '') : cell.Value,
                            label: cell.Label,
                            index: i,
                        };
                        const thisControl = paymentConst.rpt_control[cell.control] ? cell.control : 'content';
                        const oneShowContent = ctx.helper._.find(content, { control: thisControl });
                        if (oneShowContent) {
                            oneShowContent.items.push(push_item);
                        } else {
                            content.push({
                                control: thisControl,
                                title: paymentConst.rpt_control[thisControl],
                                items: [push_item],
                            });
                        }
                    }
                    if (rptAudit.signature_msg) {
                        const sign_msg = JSON.parse(rptAudit.signature_msg);
                        // 签名签章
                        const signCells = ctx.helper._.find(report_json.items[0].signature_cells, { signature_name: rptAudit.signature_name });
                        if (signCells && signCells.Value === '' && (sign_msg.sign_path || sign_msg.company_stamp || sign_msg.stamp_path)) {
                            const signArray = [];
                            if (sign_msg.sign_path) signArray.push(sign_msg.sign_path);
                            if (sign_msg.company_stamp) signArray.push(sign_msg.company_stamp);
                            if (sign_msg.stamp_path) signArray.push(sign_msg.stamp_path);
                            signCells.path = signArray.join('!;!');
                        }
                        // 日期
                        const dateCells = ctx.helper._.find(report_json.items[0].signature_date_cells, { signature_name: rptAudit.signature_name + '_签字日期' });
                        if (dateCells && dateCells.Value === '' && sign_msg.date) {
                            dateCells.Value = sign_msg.date;
                        }
                        // 意见
                        const contentCells = ctx.helper._.find(report_json.items[0].signature_audit_cells, { signature_name: rptAudit.signature_name + '_审核意见' });
                        if (contentCells && contentCells.Value === '' && sign_msg.content) {
                            contentCells.Value = sign_msg.content;
                        }
                        rptAudit.signature_msg = sign_msg;
                    } else {
                        rptAudit.signature_msg = paymentConst.signature_msg;
                        rptAudit.signature_msg.sign_path = userInfo.sign_path ? userInfo.sign_path : '';
                    }
                }
                const renderData = {
                    trInfo: ctx.trInfo,
                    report_json,
                    paymentConst,
                    content,
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.payment.detail),
                    rptAudit,
                    auditConst,
                    shenpiConst,
                    signPath: userInfo.sign_path ? userInfo.sign_path : '',
                    stampPathList,
                    currentStamp: rptAudit && rptAudit.signature_msg.stamp_path ? rptAudit.signature_msg.stamp_path : (stampPathList.length > 0 ? stampPathList[0] : ''),
                    companyStamp: companyInfo && companyInfo.sign_path ? companyInfo.sign_path : '',
                    preUrl: '/payment/' + ctx.tender.id + '/detail/' + ctx.detail.id,
                };
                if ((ctx.detail.status === auditConst.status.uncheck || ctx.detail.status === auditConst.status.checkNo) && ctx.session.sessionUser.accountId === ctx.detail.uid) {
                    // data.accountGroup = accountGroup;
                    // 获取所有项目参与者
                    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'],
                    });
                    renderData.accountList = accountList;
                    renderData.accountGroup = accountGroup.map((item, idx) => {
                        const groupList = accountList.filter(item => item.account_group === idx);
                        return { groupName: item, groupList };
                    });
                }
                await this.layout('payment/detail.ejs', renderData, 'payment/detail_modal.ejs');
            } catch (err) {
                console.log(err);
                this.log(err);
                ctx.redirect(this.menu.menu.dashboard.url);
            }
        }

        async detailSave(ctx) {
            try {
                // 检查权限等
                if (ctx.detail.uid !== ctx.session.sessionUser.accountId) {
                    throw '您无权操作';
                }
                if (ctx.detail.status === auditConst.status.checking || ctx.detail.status === auditConst.status.checked) {
                    throw '您无权操作';
                }
                const responseData = {
                    err: 0, msg: '', data: {},
                };

                const data = JSON.parse(ctx.request.body.data);
                if (!data.type) {
                    throw '提交数据错误';
                }
                switch (data.type) {
                    case 'update_rpt':
                        responseData.data = await ctx.service.paymentDetail.updateReportJson(ctx.detail.id, data.report_json);
                        break;
                    case 'update_sign':
                        responseData.data = await ctx.service.paymentRptAudit.updateSignatureMsg(ctx.detail.id, ctx.session.sessionUser.accountId, data.signature_msg);
                        break;
                    case 'add_audit':
                        const auditorId = this.app._.toInteger(data.auditorId);
                        if (isNaN(auditorId) || auditorId <= 0) {
                            throw '参数错误';
                        }
                        ctx.detail.auditorList = await ctx.service.paymentDetailAudit.getAuditors(ctx.detail.id, ctx.detail.times);
                        // 检查审核人是否已存在
                        const exist = this.app._.find(ctx.detail.auditorList, { aid: auditorId });
                        if (exist) {
                            throw '该审核人已存在，请勿重复添加';
                        }
                        const shenpiInfo = await ctx.service.paymentShenpiAudit.getDataByCondition({ tr_id: ctx.trInfo.id, sp_status: shenpiConst.sp_status.gdzs });
                        const is_gdzs = shenpiInfo && ctx.trinfo.sp_status === shenpiConst.sp_status.gdzs ? 1 : 0;
                        const result = await ctx.service.paymentDetailAudit.addAuditor(ctx.detail.id, auditorId, ctx.detail.times, is_gdzs);
                        if (!result) {
                            throw '添加审核人失败';
                        }
                        responseData.data = await ctx.service.paymentDetailAudit.getAuditorsWithOwner(ctx.detail.id, ctx.detail.times);
                        break;
                    case 'del_audit':
                        const auditorId2 = data.auditorId instanceof Number ? data.auditorId : this.app._.toNumber(data.auditorId);
                        if (isNaN(auditorId2) || auditorId2 <= 0) {
                            throw '参数错误';
                        }
                        const result2 = await ctx.service.paymentDetailAudit.deleteAuditor(ctx.detail.id, auditorId2, ctx.detail.times);
                        if (!result2) {
                            throw '移除审核人失败';
                        }
                        responseData.data = await ctx.service.paymentDetailAudit.getAuditors(ctx.detail.id, ctx.detail.times);
                        break;
                    default: throw '参数有误';
                }
                ctx.body = responseData;
            } catch (err) {
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }

        async deleteDetail(ctx) {
            try {
                const detail_id = ctx.request.body.detail_id;
                const detailInfo = await ctx.service.paymentDetail.getDataById(detail_id);
                if (!detailInfo) {
                    throw '所选报表表单详情已删除';
                }
                // 获取最新的期数
                const detail_highOrder = await ctx.service.paymentDetail.count({
                    tr_id: detailInfo.tr_id,
                });
                if (!(ctx.session.sessionUser.is_admin || ((detailInfo.status === auditConst.status.uncheck || detailInfo.status === auditConst.status.checkNo) && detailInfo.uid === ctx.session.sessionUser.accountId)) || detail_highOrder !== detailInfo.order) {
                    throw '您无权删除所选报表表单详情';
                }
                const result = await ctx.service.paymentDetail.deleteDetail(detail_id);
                if (!result) {
                    throw '删除报表表单详情失败，请重试';
                }
                ctx.redirect('/payment/' + ctx.tender.id + '/list/' + detailInfo.tr_id);
            } catch (err) {
                this.log(err);
                ctx.redirect(ctx.request.header.referer);
            }
        }

        /**
         * 期审批流程(Get)
         * @param ctx
         * @return {Promise<void>}
         */
        async detailAuditors(ctx) {
            try {
                const responseData = {
                    err: 0, msg: '', data: {},
                };
                const order = JSON.parse(ctx.request.body.data).order;
                const tr_id = ctx.params.trid;
                const detailInfo = await ctx.service.paymentDetail.getDataByCondition({ tr_id, order });
                // 获取审批流程中右边列表
                const auditHistory = [];
                const times = detailInfo.status === auditConst.status.checkNo ? detailInfo.times - 1 : detailInfo.times;
                if (times >= 1) {
                    for (let i = 1; i <= times; i++) {
                        auditHistory.push(await ctx.service.paymentDetailAudit.getAuditors(detailInfo.id, i));
                    }
                }
                responseData.data.auditHistory = auditHistory;
                // 获取审批流程中左边列表
                responseData.data.auditors = await ctx.service.paymentDetailAudit.getAuditorsWithOwner(detailInfo.id, times);

                responseData.data.user = await ctx.service.projectAccount.getAccountInfoById(detailInfo.uid);
                ctx.body = responseData;
            } catch (error) {
                this.log(error);
                ctx.body = { err: 1, msg: error.toString(), data: null };
            }
        }

        async _returnRptProjectList(ctx, formProcess = false) {
            // 获取报表表单列表
            if (ctx.tender.uid === ctx.session.sessionUser.accountId || formProcess) {
                const rptProject = await ctx.service.rptTreeNode.getDataByCondition({ name: '01.支付审批报表' });
                const rptProjectList = rptProject.items ? JSON.parse(rptProject.items) : [];
                const tenderRptList = await ctx.service.paymentTenderRpt.getProcessList(ctx.tender.id);
                return await ctx.service.paymentTenderRpt.checkAndUpdateList(tenderRptList, rptProjectList, formProcess);
            }
            return await ctx.service.paymentTenderRpt.getList(ctx.tender.id, ctx.session.sessionUser.accountId);
        }

        async process(ctx) {
            try {
                const auditPermission = await this.ctx.service.paymentPermissionAudit.getOnePermission(ctx.session.sessionUser.is_admin, ctx.session.sessionUser.accountId);
                if (!auditPermission || !auditPermission.process) {
                    throw '权限不足';
                }
                let [tenderRptList, rptProjectList] = await this._returnRptProjectList(ctx);
                tenderRptList = ctx.helper._.filter(tenderRptList, { is_const: 0, is_del: 0 });
                // for (const tr of tenderRptList) {
                //     if (tr.status === shenpiConst.sp_status.gdspl) {
                //         tr.auditList = await ctx.service.paymentShenpiAudit.getAuditList(ctx.tender.id, tr.id, tr.sp_status);
                //     } else if (tr.status === shenpiConst.sp_status.gdzs) {
                //         tr.audit = await ctx.service.paymentShenpiAudit.getAudit(ctx.tender.id, tr.id, tr.sp_status);
                //     }
                // }
                // 获取所有项目参与者
                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'],
                });
                const accountGroupList = accountGroup.map((item, idx) => {
                    const groupList = accountList.filter(item => item.account_group === idx);
                    return { groupName: item, groupList };
                });
                const renderData = {
                    tender: ctx.tender,
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.payment.process),
                    rptProjectList,
                    tenderRptList,
                    shenpi: shenpiConst,
                    accountList,
                    accountGroup: accountGroupList,
                };
                await this.layout('payment/process.ejs', renderData, 'payment/process_modal.ejs');
            } catch (err) {
                console.log(err);
                this.log(err);
                ctx.redirect(this.request.headers.referer ? this.request.headers.referer : this.menu.menu.dashboard.url);
            }
        }

        async processSave(ctx) {
            try {
                const auditPermission = await this.ctx.service.paymentPermissionAudit.getOnePermission(ctx.session.sessionUser.is_admin, ctx.session.sessionUser.accountId);
                if (!auditPermission || !auditPermission.process) {
                    throw '权限不足';
                }
                const responseData = {
                    err: 0, msg: '', data: {},
                };

                const data = JSON.parse(ctx.request.body.data);
                if (!data.type) {
                    throw '提交数据错误';
                }
                switch (data.type) {
                    case 'add-rpt':
                        responseData.data = await ctx.service.paymentTenderRpt.setRpt(ctx.tender.id, data.rpt_list);
                        break;
                    case 'change-status':
                        responseData.data = await ctx.service.paymentTenderRpt.setStatus(data.tr_id, data.status);
                        break;
                    case 'get-audits':
                        responseData.data = await ctx.service.paymentShenpiAudit.getShenpiAudit(data.tr_id, data.status);
                        break;
                    case 'add-audit':
                        responseData.data = await ctx.service.paymentShenpiAudit.addAudit(data);
                        break;
                    case 'del-audit':
                        responseData.data = await ctx.service.paymentShenpiAudit.removeAudit(data);
                        break;
                    default: throw '参数有误';
                }
                ctx.body = responseData;
            } catch (err) {
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }

        async rptList(ctx) {
            try {
                const tenderRptList = await this._returnRptProjectList(ctx);
                if (tenderRptList.length === 0) {
                    throw '当前报表表单您无权打开';
                }
                for (const tr of tenderRptList) {
                    tr.have_notice = await ctx.service.paymentDetail.haveNotice2TenderRpt(tr.id, ctx.session.sessionUser.accountId);
                }
                const trid = ctx.params.trid ? parseInt(ctx.params.trid) : 0;
                const trInfo = trid ? ctx.helper._.find(tenderRptList, { id: trid }) : tenderRptList[0];
                // 获取列表
                const trDetailList = await ctx.service.paymentDetail.getValidDetails(trInfo.id);
                for (const s of trDetailList) {
                    // s.curAuditor = null;
                    // 根据期状态返回展示用户
                    s.curAuditor = await ctx.service.paymentDetailAudit.getAuditorByStatus(s.id, s.status, s.times);
                }
                const renderData = {
                    tender: ctx.tender,
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.payment.list),
                    tenderRptList,
                    trInfo,
                    trDetailList,
                    rptMsg: null,
                    auditConst,
                    accountGroup: [],
                    accountList: [],
                    preUrl: '/payment/' + ctx.tender.id + '/list/' + trInfo.id,
                };
                // 获取报表信息，新增时及设置报表角色时使用
                if (trInfo.uid === ctx.session.sessionUser.accountId && trInfo.is_del === 0 && trInfo.rpt_id) {
                    const rptTpl = await ctx.service.rptTpl.getDataById(trInfo.rpt_id);
                    if (rptTpl) {
                        const pageRst = await ctx.service.jpcReport.getAllPreviewPagesCommon(rptTpl, 'A4');
                        renderData.rptMsg = pageRst.items[0];
                        // 判断与原有的报表审批人列表是否有区别
                        const deffierence = ctx.helper._.differenceWith(renderData.rptMsg.signature_cells, JSON.parse(trInfo.signature_cells), ctx.helper._.isEqual);
                        if (!ctx.helper._.isEmpty(deffierence)) {
                            // 删除rpt_audit重新配置
                            await ctx.service.paymentTenderRpt.defaultUpdate({
                                id: trInfo.id,
                                signature_cells: JSON.stringify(renderData.rptMsg.signature_cells),
                                rpt_audit: null,
                                is_first: 1,
                            });
                            trInfo.rpt_audit = null;
                            trInfo.is_first = 1;
                            trInfo.signature_cells = renderData.rptMsg.signature_cells;
                        }
                        if (trInfo.rpt_audit) {
                            trInfo.rpt_audit = JSON.parse(trInfo.rpt_audit);
                            const prjAccList = await ctx.service.projectAccount.getAllAccountByProjectId(ctx.session.sessionProject.id);
                            for (const audit of trInfo.rpt_audit) {
                                if (audit.uid) {
                                    const info = ctx.helper._.find(prjAccList, { id: audit.uid });
                                    audit.name = info.name;
                                }
                            }
                        } else {
                            trInfo.rpt_audit = [];
                            for (const sc of renderData.rptMsg.signature_cells) {
                                trInfo.rpt_audit.push({
                                    uid: null,
                                    rpt_name: sc.signature_name,
                                });
                            }
                        }
                        renderData.trInfo = trInfo;
                    }
                    if (renderData.rptMsg) {
                        // 获取所有项目参与者
                        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'],
                        });
                        const accountGroupList = accountGroup.map((item, idx) => {
                            const groupList = accountList.filter(item => item.account_group === idx);
                            return { groupName: item, groupList };
                        });
                        renderData.accountList = accountList;
                        renderData.accountGroup = accountGroupList;
                    }
                }
                await this.layout('payment/list.ejs', renderData, 'payment/list_modal.ejs');
            } catch (err) {
                console.log(err);
                this.log(err);
                ctx.redirect(this.request && this.request.headers && this.request.headers.referer ? this.request.headers.referer : this.menu.menu.dashboard.url);
            }
        }

        async rptSave(ctx) {
            try {
                const tr_id = ctx.params.trid;
                if (!tr_id) {
                    throw '参数有误';
                }
                const trInfo = await ctx.service.paymentTenderRpt.getDataById(tr_id);
                if (!trInfo) {
                    throw '标段报表不存在';
                }
                if (ctx.session.sessionUser.accountId !== trInfo.uid) {
                    throw '权限不足';
                }
                const responseData = {
                    err: 0, msg: '', data: {},
                };

                const data = JSON.parse(ctx.request.body.data);
                if (!data.type) {
                    throw '提交数据错误';
                }
                switch (data.type) {
                    case 'rpt_audit':
                        responseData.data = await ctx.service.paymentTenderRpt.updateRptAudit(trInfo.id, data.rpt_audit);
                        break;
                    case 'add-detail':
                        responseData.data = await ctx.service.paymentDetail.addDetail(trInfo, data.code, data.s_time);
                        break;
                    default: throw '参数有误';
                }
                ctx.body = responseData;
            } catch (err) {
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }

        /**
         * 上报和重新上报
         * @param ctx
         * @return {Promise<void>}
         */
        async startAudit(ctx) {
            try {
                if (ctx.detail.uid !== ctx.session.sessionUser.accountId) {
                    throw '您无权上报报表表单详情数据';
                }
                if (ctx.detail.status === auditConst.status.checking || ctx.detail.status === auditConst.status.checked) {
                    throw '该报表表单详情数据当前无法上报';
                }

                await ctx.service.paymentDetailAudit.start(ctx.detail.id, ctx.detail.times);

                ctx.redirect(ctx.request.header.referer);
            } catch (err) {
                this.log(err);
                ctx.session.postError = err.toString();
                ctx.redirect(ctx.request.header.referer);
            }
        }
        /**
         * 审批
         * @param ctx
         * @return {Promise<void>}
         */
        async checkAudit(ctx) {
            try {
                if (!ctx.detail || ctx.detail.status !== auditConst.status.checking) {
                    throw '当前报表表单详情数据有误';
                }
                if (!ctx.detail.curAuditor || ctx.detail.curAuditor.aid !== ctx.session.sessionUser.accountId) {
                    throw '您无权进行该操作';
                }
                const data = {
                    checkType: parseInt(ctx.request.body.checkType),
                    opinion: ctx.request.body.opinion,
                };
                if (!data.checkType || isNaN(data.checkType)) {
                    throw '提交数据错误';
                }
                if (data.checkType === auditConst.status.checkNo) {
                    if (!data.checkType || isNaN(data.checkType)) {
                        throw '提交数据错误';
                    }
                }

                await ctx.service.paymentDetailAudit.check(ctx.detail.id, data, ctx.detail.times);

                ctx.redirect(ctx.request.header.referer);
            } catch (err) {
                this.log(err);
                ctx.session.postError = err.toString();
                ctx.redirect(ctx.request.header.referer);
            }
        }
    }

    return PaymentController;
};