Calculation/app/controller/contract_controller.js

'use strict';
const stdDataAddType = {
    withParent: 1,
    child: 2,
    next: 3,
};
const auditConst = require('../const/audit');
const shenpiConst = require('../const/sp_shenpi');
const contractConst = require('../const/contract');
const moment = require('moment');
const sendToWormhole = require('stream-wormhole');
const fs = require('fs');
const path = require('path');
const AiDify = require('../lib/ai_dify');
module.exports = app => {

    class ContractController 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 {
                if (!ctx.subProject.page_show.openContract) {
                    throw '该功能已关闭或无法查看';
                }
                const renderData = {
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.contract.index),
                    auditConst,
                    isTender: false,
                };
                // renderData.budgetStd = await ctx.service.budgetStd.getDataByProjectId(ctx.session.sessionProject.id);
                renderData.projectList = await ctx.service.subProject.getSubProjectByContract(ctx.session.sessionProject.id, ctx.session.sessionUser.accountId, ctx.session.sessionUser.is_admin);
                for (const t of renderData.projectList) {
                    if (!t.is_folder) {
                        const expensesList = await ctx.service.contract.getListByUsers({ spid: t.id, contract_type: contractConst.type.expenses }, ctx.session.sessionUser);
                        t.expenses_count = expensesList.length;
                        t.expenses_total_price = expensesList.reduce((total, item) => ctx.helper.add(total, item.total_price), 0);
                        t.expenses_yf_price = expensesList.reduce((total, item) => ctx.helper.add(total, item.yf_price), 0);
                        const incomeList = await ctx.service.contract.getListByUsers({ spid: t.id, contract_type: contractConst.type.income }, ctx.session.sessionUser);
                        t.income_count = incomeList.length;
                        t.income_total_price = incomeList.reduce((total, item) => ctx.helper.add(total, item.total_price), 0);
                        t.income_yf_price = incomeList.reduce((total, item) => ctx.helper.add(total, item.yf_price), 0);
                    }
                }
                const accountList = await ctx.service.projectAccount.getAllSubProjectAccount(ctx.subProject);
                renderData.accountList = accountList;
                const unitList = await ctx.service.constructionUnit.getAllDataByCondition({ where: { pid: ctx.session.sessionProject.id } });
                renderData.accountGroup = unitList.map(item => {
                    const groupList = accountList.filter(item1 => item1.company === item.name);
                    return { groupName: item.name, groupList };
                }).filter(x => { return x.groupList.length > 0; });
                // renderData.permissionConst = ctx.service.subProjPermission.PermissionConst;
                renderData.categoryData = await this.ctx.service.category.getAllCategory(ctx.subProject);
                renderData.companys = await this.ctx.service.constructionUnit.getAllDataByCondition({ where: { pid: ctx.session.sessionProject.id } });
                // renderData.templates = await this.ctx.service.filingTemplateList.getAllTemplate(ctx.session.sessionProject.id);
                await this.layout('contract/index.ejs', renderData, 'contract/modal.ejs');
            } catch (err) {
                ctx.log(err);
                ctx.session.postError = err.toString();
                ctx.redirect(this.menu.menu.dashboard.url);
            }
        }

        /**
         * 标段合同列表页
         *
         * @param {Object} ctx - egg全局页面
         * @return {void}
         */
        async tender(ctx) {
            try {
                if (!ctx.subProject.page_show.openTenderContract) {
                    throw '该功能已关闭或无法查看';
                }
                // 获取用户新建标段权利
                const accountInfo = await this.ctx.service.projectAccount.getDataById(ctx.session.sessionUser.accountId);
                const userPermission = accountInfo !== undefined && accountInfo.permission !== ''
                    ? JSON.parse(accountInfo.permission) : null;
                let tenderList = await ctx.service.tender.getContractList('', userPermission, ctx.session.sessionUser.is_admin);
                const projectList = await ctx.service.subProject.getSubProjectByTender(ctx.session.sessionProject.id, tenderList);
                const removeTidList = [];
                for (const t of tenderList) {
                    const spInfo = ctx.helper._.find(projectList, { id: t.spid });
                    if (!spInfo) {
                        removeTidList.push(t.id);
                        continue;
                    }
                    spInfo.child_order = spInfo.child_order ? spInfo.child_order : 0;
                    spInfo.is_folder = 1;
                    t.tree_pid = spInfo.id;
                    t.tree_level = spInfo.tree_level + 1;
                    t.tree_order = spInfo.child_order + 1;
                    spInfo.child_order++;
                    const expensesList = await ctx.service.contract.getListByUsers({ tid: t.id, contract_type: contractConst.type.expenses }, ctx.session.sessionUser);
                    t.expenses_count = expensesList.length;
                    t.expenses_total_price = expensesList.reduce((total, item) => ctx.helper.add(total, item.total_price), 0);
                    t.expenses_yf_price = expensesList.reduce((total, item) => ctx.helper.add(total, item.yf_price), 0);
                    const incomeList = await ctx.service.contract.getListByUsers({ tid: t.id, contract_type: contractConst.type.income }, ctx.session.sessionUser);
                    t.income_count = incomeList.length;
                    t.income_total_price = incomeList.reduce((total, item) => ctx.helper.add(total, item.total_price), 0);
                    t.income_yf_price = incomeList.reduce((total, item) => ctx.helper.add(total, item.yf_price), 0);
                }
                if (removeTidList.length > 0) {
                    tenderList = tenderList.filter(item => !removeTidList.includes(item.id));
                }
                const categoryData = await ctx.service.category.getAllCategory(ctx.subProject);
                const renderData = {
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.contract.tender),
                    // jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.contract.index),
                    auditConst,
                    tenderList,
                    projectList: projectList.concat(tenderList),
                    categoryData,
                    isTender: true,
                    selfCategoryLevel: accountInfo ? accountInfo.self_category_level : '',
                    // selfCategoryLevel: '',
                    pid: ctx.session.sessionProject.id,
                    uid: ctx.session.sessionUser.accountId,
                };
                if (ctx.session.sessionUser.is_admin) {
                    const projectId = ctx.session.sessionProject.id;
                    // 获取所有项目参与者
                    const accountList = await ctx.service.projectAccount.getAllSubProjectAccount(ctx.subProject);
                    const unitList = await ctx.service.constructionUnit.getAllDataByCondition({ where: { pid: projectId } });
                    const accountGroupList = unitList.map(item => {
                        const groupList = accountList.filter(item1 => item1.company === item.name);
                        return { groupName: item.name, groupList };
                    }).filter(x => { return x.groupList.length > 0; });
                    renderData.accountList = accountList;
                    renderData.accountGroup = accountGroupList;
                }
                await this.layout('contract/tender.ejs', renderData, 'contract/modal.ejs');
                // await this.layout('contract/index.ejs', renderData, 'contract/modal.ejs');
            } catch (err) {
                ctx.log(err);
                ctx.session.postError = err.toString();
                ctx.redirect(`/sp/${ctx.subProject.id}/dashboard`);
            }
        }

        async auditSave(ctx) {
            try {
                if (ctx.session.sessionUser.is_admin === 0) throw '没有设置权限';
                const responseData = {
                    err: 0, msg: '', data: null,
                };
                const data = JSON.parse(ctx.request.body.data);
                if (!data.type) {
                    throw '提交数据错误';
                }
                const info = ctx.contract;
                const options = ctx.contractOptions;
                let uids;
                let result = false;
                let auditList = [];
                switch (data.type) {
                    case 'check':
                        await ctx.service.contractTree.insertTree(options, info);
                        // 新建合同信息
                        break;
                    case 'add-audit':
                        // 判断用户是单个还是数组
                        uids = data.id instanceof Array ? data.id : [data.id];
                        // 判断该用户的组是否已加入到表中，已加入则提示无需添加
                        auditList = await ctx.service.contractAudit.getList(options);
                        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.contractAudit.saveAudits(options, accountList);
                        responseData.data = await ctx.service.contractAudit.getList(options);
                        break;
                    case 'del-audit':
                        uids = data.id instanceof Array ? data.id : [data.id];
                        const cloneOptions = ctx.helper._.cloneDeep(options);
                        cloneOptions.uid = uids;
                        auditList = options.spid ? await ctx.service.subProjPermission.getContractAuditList(options.spid, uids) : await ctx.service.contractAudit.getAllDataByCondition({ where: cloneOptions });
                        if (auditList.length !== uids.length) {
                            throw '该用户已不存在成员管理中，移除失败';
                        }
                        await ctx.service.contractAudit.delAudit(options, ctx.helper._.map(auditList, 'id'));
                        responseData.data = await ctx.service.contractAudit.getList(options);
                        break;
                    case 'save-permission':
                        result = await ctx.service.contractAudit.updatePermission(options, data.updateData);
                        if (!result) {
                            throw '修改权限失败';
                        }
                        break;
                    case 'list':
                        responseData.data = await ctx.service.contractAudit.getList(options);
                        break;
                    case 'get-contract-type':
                        const commonJson = ctx.subProject.common_json ? JSON.parse(ctx.subProject.common_json) : null;
                        responseData.data = commonJson && commonJson[(data.is_tender ? 'tender_' : '') + 'contract_type'] ? commonJson[(data.is_tender ? 'tender_' : '') + 'contract_type'] : [];
                        break;
                    case 'set-contract-type':
                        result = await ctx.service.subProject.saveCommonJsons(ctx.subProject.id, ['contract_type', 'tender_contract_type'], data.contract_type);
                        break;
                    case 'get-contract-used':
                        const commonJson2 = ctx.subProject.common_json ? JSON.parse(ctx.subProject.common_json) : null;
                        responseData.data = commonJson2 && commonJson2[(data.is_tender ? 'tender_' : '') + 'contract_used'] ? commonJson2[(data.is_tender ? 'tender_' : '') + 'contract_used'] : [];
                        break;
                    case 'set-contract-used':
                        result = await ctx.service.subProject.saveCommonJsons(ctx.subProject.id, ['contract_used', 'tender_contract_used'], data.contract_used);
                        break;
                    default: throw '参数有误';
                }
                ctx.body = responseData;
            } catch (err) {
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }

        async panel(ctx) {
            try {
                const whiteList = ctx.app.config.multipart.whitelist;
                const contractOptions = ctx.helper._.cloneDeep(ctx.contractOptions);
                contractOptions.contract_type = ctx.contract_type;
                const contractTreeAudits = await ctx.service.contractTreeAudit.getAllDataByCondition({ where: contractOptions });
                const expensesOptions = ctx.helper._.cloneDeep(ctx.contractOptions);
                expensesOptions.contract_type = contractConst.type.expenses;
                const expensesList = await ctx.service.contract.getListByUsers(expensesOptions, ctx.session.sessionUser);
                const expensesPayList = expensesList.length > 0 ? await ctx.service.contractPay.getAllDataByCondition({ where: { cid: ctx.helper._.map(expensesList, 'id') } }) : [];
                const expenses_total_price = expensesList.reduce((total, item) => ctx.helper.add(total, item.total_price), 0);
                const expenses_yf_price = expensesList.reduce((total, item) => ctx.helper.add(total, item.yf_price), 0);
                const incomeOptions = ctx.helper._.cloneDeep(ctx.contractOptions);
                incomeOptions.contract_type = contractConst.type.income;
                const incomeList = await ctx.service.contract.getListByUsers(incomeOptions, ctx.session.sessionUser);
                const incomePayList = incomeList.length > 0 ? await ctx.service.contractPay.getAllDataByCondition({ where: { cid: ctx.helper._.map(incomeList, 'id') } }) : [];
                const income_total_price = incomeList.reduce((total, item) => ctx.helper.add(total, item.total_price), 0);
                const income_yf_price = incomeList.reduce((total, item) => ctx.helper.add(total, item.yf_price), 0);
                const prices = {
                    expenses_total_price,
                    expenses_yf_price,
                    expenses_rate: ctx.helper.div(expenses_yf_price, expenses_total_price) * 100,
                    income_total_price,
                    income_yf_price,
                    income_rate: ctx.helper.div(income_yf_price, income_total_price) * 100,
                };
                const renderData = {
                    contractTreeAudits,
                    audit_permission: ctx.contract_audit_permission,
                    preUrl: `/sp/${ctx.subProject.id}` + (ctx.contractOptions.tid ? '/contract/tender' : '/contract'),
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.contract.panel),
                    contractConst,
                    prices,
                    expensesList,
                    incomeList,
                    expensesPayList,
                    incomePayList,
                    thisUrl: `/sp/${ctx.subProject.id}` + (ctx.contract_tender ? `/contract/tender/${ctx.contract.id}/detail` : '/contract/detail'),
                    is_setting: false,
                };
                await this.layout('contract/panel.ejs', renderData, 'contract/setting_modal.ejs');
            } catch (err) {
                ctx.log(err);
                ctx.session.postError = err.toString();
                ctx.redirect(`/sp/${ctx.subProject.id}` + (ctx.contractOptions.spid ? '/contract/detail' : '/contract/tender'));
            }
        }

        async detail(ctx) {
            try {
                const whiteList = ctx.app.config.multipart.whitelist;
                const contractOptions = ctx.helper._.cloneDeep(ctx.contractOptions);
                contractOptions.contract_type = ctx.contract_type;
                const contractTreeAudits = await ctx.service.contractTreeAudit.getAllDataByCondition({ where: contractOptions });
                const [stdBills, stdChapters] = ctx.contract_tender ? await this.ctx.service.valuation.getValuationStdList(
                    ctx.contract.valuation, ctx.contract.measure_type) : await ctx.service.budgetStd.getStdList(ctx.subProject.std_id, 'yu');
                const commonJson = ctx.subProject.common_json ? JSON.parse(ctx.subProject.common_json) : null;
                const types = commonJson && commonJson[(ctx.contract_tender ? 'tender_' : '') + 'contract_type'] ? commonJson[(ctx.contract_tender ? 'tender_' : '') + 'contract_type'] : [];
                const used = commonJson && commonJson[(ctx.contract_tender ? 'tender_' : '') + 'contract_used'] ? commonJson[(ctx.contract_tender ? 'tender_' : '') + 'contract_used'] : [];
                const shenpi_status = ctx.contract_tender ? ctx.subProject.page_show.openContractTenderShenpi : ctx.subProject.page_show.openContractSubProjectShenpi;
                const pay_shenpi_status = ctx.contract_tender ? ctx.subProject.page_show.openContractPayTenderShenpi : ctx.subProject.page_show.openContractPaySubProjectShenpi;
                const renderData = {
                    contractTreeAudits,
                    audit_permission: ctx.contract_audit_permission,
                    preUrl: `/sp/${ctx.subProject.id}` + (ctx.contractOptions.tid ? '/contract/tender' : '/contract'),
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.contract.detail),
                    contract_type: ctx.contract_type,
                    contractConst,
                    whiteList,
                    types,
                    used,
                    thisUrl: `/sp/${ctx.subProject.id}` + (ctx.contract_tender ? `/contract/tender/${ctx.contract.id}/detail` : '/contract/detail'),
                    stdChapters,
                    is_setting: false,
                    shenpi_status,
                    pay_shenpi_status,
                    auditConst: auditConst.contract,
                    shenpiConst,
                    auditType: auditConst.auditType,
                };
                if (ctx.contract_tender) {
                    const tenderInfo = await ctx.service.tenderInfo.getTenderInfo(ctx.contract.id);
                    if (tenderInfo.shenpi.contract === shenpiConst.sp_status.gdspl) {
                        renderData.spGroupList = await ctx.service.shenpiGroup.getGroupListByChangeType(ctx.contract.id, shenpiConst.sp_type.contract, 'contract');
                        renderData.paySpGroupList = await ctx.service.shenpiGroup.getGroupListByChangeType(ctx.contract.id, shenpiConst.sp_type.contract, contractConst.typeMap[ctx.contract_type]);
                    }
                    renderData.shenpi = tenderInfo.shenpi;
                } else {
                    if (ctx.subProject.shenpi.contract === shenpiConst.sp_status.gdspl) {
                        // 获取固定审批流列表
                        renderData.spGroupList = await ctx.service.shenpiGroup.getGroupListByChangeType(ctx.subProject.id, shenpiConst.sp_type.contract, 'contract');
                        renderData.paySpGroupList = await ctx.service.shenpiGroup.getGroupListByChangeType(ctx.subProject.id, shenpiConst.sp_type.contract, contractConst.typeMap[ctx.contract_type]);
                    }
                    renderData.shenpi = ctx.subProject.shenpi;
                }

                const accountList = await ctx.service.projectAccount.getAllSubProjectAccount(ctx.subProject);
                renderData.accountList = accountList;
                const unitList = await ctx.service.constructionUnit.getAllDataByCondition({ where: { pid: ctx.session.sessionProject.id } });
                renderData.accountGroup = unitList.map(item => {
                    const groupList = accountList.filter(item1 => item1.company === item.name);
                    return { groupName: item.name, groupList };
                }).filter(x => { return x.groupList.length > 0; });
                const contractAttributeSet = commonJson && commonJson.contract_attribute ? commonJson.contract_attribute : contractConst.attributeSet;
                const attributeSet = ctx.service.contractColSet.analysisColSetWithDefine(contractConst.attributeSet, contractAttributeSet, contractConst.defaultAttributeSet);
                renderData.attributeSet = ctx.helper._.filter(attributeSet, { show: 1 });
                const detailColumnSet = contractConst.detailColumnSet.filter(item => {
                    return !item.contractTypes || item.contractTypes.indexOf(ctx.contract_type) >= 0;
                }).map(item => {
                    const result = Object.assign({ source: 'detail' }, item);
                    if (item.field === 'pay_price') {
                        result.name = ctx.contract_type === contractConst.type.income ? '累计回款(P)' : '累计付款(P)';
                    } else if (item.field === 'df_price') {
                        result.name = ctx.contract_type === contractConst.type.income ? '待回款' : '待支付';
                    }
                    return result;
                });
                const attributeColumnSet = renderData.attributeSet.map(item => {
                    return Object.assign({}, item, {
                        name: item.alias || item.name,
                        source: 'attribute',
                        fixed: ['alias'],
                        removable: true,
                    });
                });
                const contractColumnDefine = contractConst.colSet[ctx.contract_type]
                    .concat(detailColumnSet, attributeColumnSet);
                const contractColSet = await ctx.service.contractColSet.getContractColSet(ctx.subProject.id, ctx.contractOptions.tid, ctx.contract_type);
                renderData.colSet = ctx.service.contractColSet.analysisColSetWithDefine(
                    contractColumnDefine,
                    contractColSet.info,
                    contractConst.defaultColSet[ctx.contract_type]
                );
                renderData.contractColumnOptions = {
                    detail: contractConst.colSet[ctx.contract_type]
                        .filter(item => { return item.removable; })
                        .map(item => { return Object.assign({ source: 'detail' }, item); })
                        .concat(detailColumnSet),
                    attribute: attributeColumnSet,
                };
                if (ctx.contractOptions.tid) {
                    const tenders = await ctx.service.tender.getAllDataByCondition({
                        where: { spid: ctx.subProject.id },
                        columns: ['id', 'name'],
                    });
                    renderData.contractColCopyScope = 'tender';
                    renderData.contractColCopyTargets = [{
                        id: 'sub-project-root', name: ctx.subProject.name, tree_level: 1, is_folder: true,
                    }].concat(tenders.filter(item => {
                        return Number(item.id) !== Number(ctx.contractOptions.tid);
                    }).map(item => {
                        return { id: item.id, name: item.name, tree_level: 2, is_folder: false };
                    }));
                } else {
                    const subProjects = await ctx.service.subProject.getSubProjectTreeNodes(
                        ctx.session.sessionProject.id,
                        ctx.session.sessionUser.accountId,
                        true
                    );
                    renderData.contractColCopyScope = 'project';
                    renderData.contractColCopyTargets = subProjects.map(item => {
                        return Object.assign({}, item, {
                            current: String(item.id) === String(ctx.subProject.id),
                        });
                    });
                }
                await this.layout('contract/detail.ejs', renderData, 'contract/detail_modal.ejs');
            } catch (err) {
                ctx.log(err);
                ctx.session.postError = err.toString();
                ctx.redirect(`/sp/${ctx.subProject.id}` + (ctx.contractOptions.spid ? '/contract/detail' : '/contract/tender'));
            }
        }

        /**
         * 保存列设置
         * @param ctx
         * @return {Promise<void>}
         */
        async colSet(ctx) {
            try {
                if (!ctx.session.sessionUser.is_admin) throw '无权进行列设置';
                const colType = ctx.request.body.col_type;
                const colSet = JSON.parse(ctx.request.body.col_set);
                const contractType = ctx.request.body.type;
                if ([contractConst.type.expenses, contractConst.type.income].indexOf(contractType) < 0) throw '合同类型错误';
                await ctx.service.contractColSet.setContractColSet(ctx.subProject.id, ctx.contractOptions.tid, contractType, colType, colSet);
                ctx.redirect(ctx.request.header.referer);
            } catch (err) {
                ctx.log(err);
                ctx.redirect(ctx.request.header.referer);
            }
        }

        async copyColSet(ctx) {
            try {
                if (!ctx.session.sessionUser.is_admin) throw '无权进行列设置';
                const data = JSON.parse(ctx.request.body.data);
                const contractType = Number(data.type);
                if ([contractConst.type.expenses, contractConst.type.income].indexOf(contractType) < 0) throw '合同类型错误';
                if (!Array.isArray(data.col_set) || !Array.isArray(data.target_ids)) throw '列设置参数错误';
                const targetIds = Array.from(new Set(data.target_ids.map(String)));
                if (!targetIds.length) throw '请选择需要设置的目标';

                let targets = [];
                if (ctx.contractOptions.tid) {
                    const tenders = await ctx.service.tender.getAllDataByCondition({
                        where: { spid: ctx.subProject.id },
                        columns: ['id'],
                    });
                    const validIds = new Set(tenders.map(item => String(item.id)));
                    targets = targetIds.filter(id => validIds.has(id) && id !== String(ctx.contractOptions.tid))
                        .map(id => { return { spid: ctx.subProject.id, tid: Number(id) }; });
                } else {
                    const subProjects = await ctx.service.subProject.getSubProject(
                        ctx.session.sessionProject.id,
                        ctx.session.sessionUser.accountId,
                        true
                    );
                    const validIds = new Set(subProjects.filter(item => !item.is_folder).map(item => String(item.id)));
                    targets = targetIds.filter(id => validIds.has(id) && id !== String(ctx.subProject.id))
                        .map(id => { return { spid: id, tid: null }; });
                }
                if (targets.length !== targetIds.length) throw '选择的目标不存在或不属于当前范围';
                await ctx.service.contractColSet.copyContractColSet(targets, contractType, 'info', data.col_set);
                ctx.body = { err: 0, msg: '列设置复制成功', data: { count: targets.length } };
            } catch (err) {
                ctx.log(err);
                ctx.body = this.ajaxErrorBody(err, '复制列设置失败');
            }
        }

        async loadDetail(ctx) {
            try {
                const responseData = {
                    err: 0, msg: '', data: {},
                };
                const contractOptions = ctx.helper._.cloneDeep(ctx.contractOptions);
                contractOptions.contract_type = ctx.contract_type;
                // const data = JSON.parse(ctx.request.body.data);
                // ctx.contractOptions.contract_type = ctx.contract_type;
                responseData.data.contractTree = await ctx.service.contractTree.getAllDataByCondition({ where: contractOptions });
                // 获取权限并展示对应合同
                responseData.data.contractList = await ctx.service.contract.getListByUsers(contractOptions, ctx.session.sessionUser);
                // responseData.data.contractList = await ctx.service.contract.getAllDataByCondition({ where: contractOptions });
                // const userOptions = ctx.helper._.cloneDeep(ctx.contractOptions);
                // // userOptions.uid = ctx.session.sessionUser.id;
                // const permissionEdit = ctx.session.sessionUser.is_admin ? true : await ctx.service.contractAudit.getUserPermissionEdit(userOptions);
                // responseData.data.auditContractTreePermission = permissionEdit ? [] : await ctx.service.contractTreeAudit.getAllDataByCondition({ where: contractOptions });
                // responseData.data.contractAttList = await ctx.service.contractAtt.getAllDataByCondition({ where: ctx.contractOptions });
                if (ctx.session.sessionUser.is_admin) {
                    const contractAudits = await ctx.service.contractAudit.getList(ctx.contractOptions);
                    const unitList = await ctx.service.constructionUnit.getAllDataByCondition({ where: { pid: ctx.session.sessionProject.id } });
                    const accountGroup = unitList.map(item => {
                        const groupList = contractAudits.filter(item1 => item1.company === item.name);
                        return { groupName: item.name, groupList };
                    }).filter(x => { return x.groupList.length > 0; });
                    responseData.data.contractAudits = contractAudits;
                    responseData.data.accountGroup = ctx.helper._.filter(accountGroup, function(item) {
                        return item.groupList.length > 0;
                    });
                }
                ctx.body = responseData;
            } catch (err) {
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }

        /**
         * 审批及上报和审批人员增删改，切换审批组等
         * @param ctx
         * @return {Promise<void>}
         */
        async checkAudit(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                if (!data.postType || !data.id || !data.type) throw '数据错误';
                const responseData = {
                    err: 0, msg: '', data: {},
                };
                const contract = await this._getContractByType(ctx, data);
                if (!contract) {
                    throw '未找到合同相关数据';
                }
                let tip = '';
                // 判断功能是否已关闭
                const shenpi_status = ctx.contract_tender ? ctx.subProject.page_show.openContractTenderShenpi : ctx.subProject.page_show.openContractSubProjectShenpi;
                const pay_shenpi_status = ctx.contract_tender ? ctx.subProject.page_show.openContractPayTenderShenpi : ctx.subProject.page_show.openContractPaySubProjectShenpi;
                switch (data.type) {
                    case 'contract':
                        if (!shenpi_status) {
                            throw '合同审批功能已关闭, 无法进行审批操作, 请刷新页面';
                        }
                        break;
                    case 'pay':
                        if (!pay_shenpi_status) {
                            throw '合同' + tip + '审批功能已关闭, 无法进行审批操作, 请刷新页面';
                        }
                        tip = contractConst.typeName[contract.contract_type];
                        break;
                    case 'supplement':
                        if (!shenpi_status) {
                            throw '合同审批功能已关闭, 无法进行审批操作, 请刷新页面';
                        }
                        break;
                    default: throw '数据错误';
                }
                let shenpi = '';
                if (ctx.contract_tender) {
                    const tenderInfo = await ctx.service.tenderInfo.getTenderInfo(ctx.contract.id);
                    shenpi = tenderInfo ? tenderInfo.shenpi : '';
                } else {
                    shenpi = ctx.subProject.shenpi;
                }
                await ctx.service.contractSpAudit.loadUser(contract, data.type);
                await ctx.service.contractSpAudit.loadAuditViewData(contract, data.type);
                switch (data.postType) {
                    case 'start':
                        if (contract.status !== auditConst.contract.status.uncheck && contract.status !== auditConst.contract.status.checkNo) {
                            throw '该合同' + tip + '当前无法上报';
                        }
                        await ctx.service.contractSpAudit.start(ctx.contractOptions, shenpi, contract, data.type, contract.times);
                        break;
                    case 'check':
                        if (contract.status !== auditConst.contract.status.checking && contract.status !== auditConst.contract.status.checkNoPre) {
                            throw '当前合同' + tip + '数据有误';
                        }
                        if (contract.curAuditorIds.length === 0 || contract.curAuditorIds.indexOf(ctx.session.sessionUser.accountId) === -1) {
                            throw '您无权进行该操作';
                        }
                        const checkData = {
                            checkType: parseInt(data.checkType),
                            opinion: data.opinion,
                        };
                        if (!checkData.checkType || isNaN(checkData.checkType)) {
                            throw '提交数据错误';
                        }
                        await ctx.service.contractSpAudit.check(contract, data.type, checkData);
                        break;
                    case 'add-audit':
                        if (shenpi.contract === shenpiConst.sp_status.gdspl) {
                            throw '固定审批流程不允许添加人员，请刷新页面';
                        }
                        const add_id = this.app._.toInteger(data.auditorId);
                        if (isNaN(add_id) || add_id <= 0) {
                            throw '参数错误';
                        }
                        // 检查权限等
                        if (!(contract.uid === ctx.session.sessionUser.accountId || ctx.contract_audit_permission.permission_edit_contract)) {
                            throw '您无权添加审核人';
                        }
                        if (contract.status !== auditConst.contract.status.uncheck && contract.status !== auditConst.contract.status.checkNo) {
                            throw '当前不允许添加审核人';
                        }

                        const auditorList = await ctx.service.contractSpAudit.getAuditors(contract, data.type, contract.times, 'asc', true);
                        // 检查审核人是否已存在
                        const exist = this.app._.find(auditorList, { aid: add_id });
                        if (exist) {
                            throw '该审核人已存在，请勿重复添加';
                        }
                        const shenpiCondition = ctx.helper._.assign({ sp_type: shenpiConst.sp_type.contract, sp_status: shenpiConst.sp_status.gdzs }, ctx.contractOptions);
                        const shenpiInfo = await ctx.service.shenpiAudit.getDataByCondition(shenpiCondition);
                        const is_gdzs = shenpiInfo && shenpi.contract === shenpiConst.sp_status.gdzs ? 1 : 0;
                        const add_result = await ctx.service.contractSpAudit.addAuditor(ctx.contractOptions, contract, data.type, add_id, contract.times, is_gdzs);
                        if (!add_result) {
                            throw '添加审核人失败';
                        }
                        break;
                    case 'del-audit':
                        if (shenpi.contract === shenpiConst.sp_status.gdspl) {
                            throw '固定审批流程不允许删除人员，请刷新页面';
                        }
                        const del_id = data.auditorId instanceof Number ? data.auditorId : this.app._.toNumber(data.auditorId);
                        if (isNaN(del_id) || del_id <= 0) {
                            throw '参数错误';
                        }
                        // 检查权限等
                        if (!(contract.uid === ctx.session.sessionUser.accountId || ctx.contract_audit_permission.permission_edit_contract)) {
                            throw '您无权移除审核人';
                        }
                        if (contract.status !== auditConst.contract.status.uncheck && contract.status !== auditConst.contract.status.checkNo) {
                            throw '当前不允许移除审核人';
                        }

                        const del_result = await ctx.service.contractSpAudit.deleteAuditor(contract, data.type, del_id, contract.times);
                        if (!del_result) {
                            throw '移除审核人失败';
                        }
                        break;
                    case 'change-sp':
                        if (shenpi.contract !== shenpiConst.sp_status.gdspl) {
                            throw '非固定审批流程不允许切换审批组，请刷新页面';
                        }
                        if (contract.status !== auditConst.contract.status.uncheck && contract.status !== auditConst.contract.status.checkNo) {
                            throw '当前状态不允许切换审批组';
                        }
                        const chagne_result = await ctx.service.contractSpAudit.changeSpGroup(contract, data.type, data.sp_group);
                        if (!chagne_result) {
                            throw '切换审批组失败';
                        }
                        break;
                    default:
                        throw '参数错误';
                }
                const newContract = await this._getContractByType(ctx, data);
                await ctx.service.contractSpAudit.loadUser(newContract, data.type);
                await ctx.service.contractSpAudit.loadAuditViewData(newContract, data.type);
                responseData.data = newContract;
                ctx.body = responseData;
            } catch (err) {
                console.log(err);
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }

        async _getContractByType(ctx, data) {
            let contract = null;
            switch (data.type) {
                case 'contract':
                    contract = await ctx.service.contract.getDataById(data.id);
                    break;
                case 'pay':
                    contract = await ctx.service.contractPay.getDataById(data.id);
                    break;
                case 'supplement':
                    contract = await ctx.service.contractSupplement.getDataById(data.id);
                    break;
                default: throw '数据错误';
            }
            return contract;
        }

        async updateBills(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                if (!data.postType || !data.postData) throw '数据错误';
                const responseData = { err: 0, msg: '', data: {} };
                const options = ctx.helper._.cloneDeep(ctx.contractOptions);
                options.contract_type = ctx.contract_type;
                switch (data.postType) {
                    case 'add':
                    case 'add-child':
                    case 'delete':
                    case 'up-move':
                    case 'down-move':
                    case 'up-level':
                    case 'down-level':
                        responseData.data = await this._billsBase(ctx, data.postType, data.postData, options);
                        break;
                    case 'update':
                        responseData.data = await ctx.service.contractTree.updateCalc(options, data.postData, data.updateAll || false);
                        break;
                    case 'update-contract':
                        responseData.data = await ctx.service.contract.updateCalc(options, data.postData);
                        break;
                    case 'paste-block':
                        responseData.data = await this._pasteBlock(ctx, data.postData, options);
                        break;
                    case 'add-std':
                        responseData.data = await this._addStd(ctx, data.postData, options);
                        break;
                    case 'add-contract':
                        responseData.data = await ctx.service.contract.add(options, data.postData.select, data.postData.contract);
                        break;
                    case 'add-tree-audit':
                        responseData.data = await ctx.service.contractTreeAudit.add(options, data.postData.select, data.postData.auditId);
                        break;
                    case 'del-tree-audit':
                        responseData.data = await ctx.service.contractTreeAudit.dels(options, data.postData.select, data.postData.auditIds);
                        break;
                    case 'get-contract':
                        const contract = await ctx.service.contract.getDataById(data.postData);
                        const shenpi_status = ctx.contract_tender ? ctx.subProject.page_show.openContractTenderShenpi : ctx.subProject.page_show.openContractSubProjectShenpi;
                        if (shenpi_status) {
                            await ctx.service.contractSpAudit.loadUser(contract);
                            await ctx.service.contractSpAudit.loadAuditViewData(contract);
                            await ctx.service.contractSpAudit.checkShenpi(contract);
                        }
                        responseData.data.contract = contract;
                        responseData.data.pays = await ctx.service.contractPay.getPays(options, data.postData);
                        responseData.data.files = await ctx.service.contractAtt.getAtt(data.postData);
                        responseData.data.supplements = await ctx.service.contractSupplement.getSupplements(options, data.postData);
                        break;
                    case 'add-contract-pay':
                        responseData.data = await ctx.service.contractPay.add(options, data.postData.select, data.postData.pay);
                        break;
                    case 'save-contract-pay':
                        responseData.data = await ctx.service.contractPay.save(options, data.postData.select, data.postData.pay);
                        break;
                    case 'del-contract-pay':
                        responseData.data = await ctx.service.contractPay.del(options, data.postData.select, data.postData.pay);
                        break;
                    case 'add-contract-supplement':
                        responseData.data = await ctx.service.contractSupplement.add(options, data.postData.select, data.postData.supplement);
                        break;
                    case 'save-contract-supplement':
                        responseData.data = await ctx.service.contractSupplement.save(options, data.postData.select, data.postData.supplement);
                        break;
                    case 'del-contract-supplement':
                        responseData.data = await ctx.service.contractSupplement.del(options, data.postData.select, data.postData.supplement);
                        break;
                    case 'get-tenders':
                        // 获取用户新建标段权利
                        const accountInfo = await ctx.service.projectAccount.getDataById(ctx.session.sessionUser.accountId);
                        const userPermission = accountInfo !== undefined && accountInfo.permission !== ''
                            ? JSON.parse(accountInfo.permission) : null;
                        const tenderList = await ctx.service.tender.getBuildList('', userPermission, ctx.session.sessionUser.is_admin);
                        responseData.data.categoryData = await this.ctx.service.category.getAllCategory(ctx.subProject);
                        responseData.data.tenders = tenderList;
                        break;
                    case 'get-tender-pays':
                        responseData.data.tender = await ctx.service.tender.getDataById(data.postData.tid);
                        if (!responseData.data.tender) {
                            throw '关联标段不存在';
                        }
                        // 判断项目开没开启独立支付合同
                        if (ctx.subProject.page_show.phasePay) {
                            // 直接读phasePay表数据并展示
                            responseData.data.stages = await ctx.service.phasePay.getDatasForContract(data.postData.tid);
                        } else {
                            // 读取期支付数据
                            responseData.data.stages = await ctx.service.stagePay.getDatasForContract(data.postData.tid);
                        }
                        break;
                    case 'add-tender-pays':
                        responseData.data = await ctx.service.contractPay.addTenderPays(
                            options,
                            data.postData.select,
                            data.postData.pays
                        );
                        break;
                    default:
                        throw '未知操作';
                }
                ctx.body = responseData;
            } catch (err) {
                console.log(err);
                this.log(err);
                ctx.body = this.ajaxErrorBody(err, '数据错误');
            }
        }

        async _billsBase(ctx, type, data, options) {
            if (isNaN(data.id) || data.id <= 0) throw '数据错误';
            if (type !== 'add') {
                if (isNaN(data.count) || data.count <= 0) data.count = 1;
            }
            switch (type) {
                case 'add':
                    return await ctx.service.contractTree.addNodeBatch(options, data.id, data.count);
                case 'add-child':
                    return await ctx.service.contractTree.addChildNode(options, data.id, data.count);
                case 'delete':
                    return await ctx.service.contractTree.delete(options, data.id, data.count);
                case 'up-move':
                    return await ctx.service.contractTree.upMoveNode(options, data.id, data.count);
                case 'down-move':
                    return await ctx.service.contractTree.downMoveNode(options, data.id, data.count);
                case 'up-level':
                    return await ctx.service.contractTree.upLevelNode(options, data.id, data.count);
                case 'down-level':
                    return await ctx.service.contractTree.downLevelNode(options, data.id, data.count);
                default:
                    throw '未知操作';
            }
        }
        /**
         * 复制粘贴整块
         *
         * @param ctx
         * @return {Promise<void>}
         */
        async _pasteBlock(ctx, data, options) {
            if ((isNaN(data.id) || data.id <= 0) ||
                (!data.block || data.block.length <= 0)) throw '参数错误';
            return await ctx.service.contractTree.pasteBlockData(options, data.id, data.block);
        }
        /**
         * 从标准项目表添加数据
         * @param ctx
         * @return {Promise<void>}
         */
        async _addStd(ctx, data, options) {
            if ((isNaN(data.id) || data.id <= 0) || !data.stdType || !data.stdNode) throw '参数错误';
            // todo 校验项目是否使用该库的权限
            if (!(ctx.session.sessionUser.is_admin || ctx.contract_audit_permission.permission_edit)) {
                throw '没有操作权限';
            }
            let stdLib,
                addType;
            switch (data.stdType) {
                case 'xmj':
                    stdLib = ctx.service.stdXmj;
                    addType = stdDataAddType.withParent;
                    break;
                default:
                    throw '未知标准库';
            }
            const stdData = await stdLib.getDataByDataId(data.stdLibId, data.stdNode);
            switch (addType) {
                // case stdDataAddType.child:
                //     return await ctx.service.contractTree.addStdNodeAsChild(options, data.id, stdData);
                // case stdDataAddType.next:
                //     return await ctx.service.contractTree.addStdNode(options, data.id, stdData);
                case stdDataAddType.withParent:
                    return await ctx.service.contractTree.addStdNodeWithParent(options, data.id, stdData, stdLib);
                default:
                    throw '未知添加方式';
            }
        }

        /**
         * 上传附件
         * @param {*} ctx 上下文
         */
        async uploadFile(ctx) {
            let stream;
            try {
                const responseData = { err: 0, msg: '', data: {} };
                const cid = ctx.params.cid;
                if (!cid) throw '参数有误';
                const cpid = parseInt(ctx.params.cpid);
                const csid = parseInt(ctx.params.csid);
                const parts = this.ctx.multipart({
                    autoFields: true,
                });
                const files = [];
                const create_time = Date.parse(new Date()) / 1000;
                let idx = 0;
                while ((stream = await parts()) !== undefined) {
                    if (!stream.filename) {
                        // 如果没有传入直接返回
                        return;
                    }
                    const fileInfo = path.parse(stream.filename);
                    const headpath = ctx.contractOptions.spid ? `sp/contract/${ctx.contractOptions.spid}` : `app/public/upload/${ctx.contractOptions.tid}`;
                    const filepath = `${headpath}/contract/${cid}${cpid ? '/pay/' + cpid : (csid ? '/supplement/' + csid : '')}/fujian_${create_time + idx.toString() + fileInfo.ext}`;
                    // await ctx.helper.saveStreamFile(stream, path.resolve(this.app.baseDir, 'app', filepath));
                    await ctx.app.fujianOss.put(ctx.app.config.fujianOssFolder + filepath, stream);
                    files.push({ filepath, name: stream.filename, ext: fileInfo.ext });
                    ++idx;
                    stream && (await sendToWormhole(stream));
                }
                const in_time = new Date();
                const payload = files.map(file => {
                    let idx;
                    if (Array.isArray(parts.field.name)) {
                        idx = parts.field.name.findIndex(name => name === file.name);
                    } else {
                        idx = 'isString';
                    }
                    const newFile = {
                        spid: ctx.contractOptions.spid || null,
                        tid: ctx.contractOptions.tid || null,
                        contract_type: ctx.contract_type,
                        cid,
                        uid: ctx.session.sessionUser.accountId,
                        filename: file.name,
                        fileext: file.ext,
                        filesize: ctx.helper.bytesToSize(idx === 'isString' ? parts.field.size : parts.field.size[idx]),
                        filepath: file.filepath,
                        upload_time: in_time,
                    };
                    if (cpid) {
                        newFile.cpid = cpid;
                    }
                    if (csid) {
                        newFile.csid = csid;
                    }
                    return newFile;
                });
                if (cpid) {
                    // 执行文件信息写入数据库
                    await ctx.service.contractPayAtt.saveFileMsgToDb(payload);
                    // 将最新的当前标段的所有文件信息返回
                    responseData.data = await ctx.service.contractPayAtt.getAtt(cpid);
                } else if (csid) {
                    // 执行文件信息写入数据库
                    await ctx.service.contractSupplementAtt.saveFileMsgToDb(payload);
                    // 将最新的当前标段的所有文件信息返回
                    responseData.data = await ctx.service.contractSupplementAtt.getAtt(csid);
                } else {
                    // 执行文件信息写入数据库
                    await ctx.service.contractAtt.saveFileMsgToDb(payload);
                    // 将最新的当前标段的所有文件信息返回
                    responseData.data = await ctx.service.contractAtt.getAtt(cid);
                }
                ctx.body = responseData;
            } catch (err) {
                stream && (await sendToWormhole(stream));
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }

        /**
         * 删除附件
         * @param {Ojbect} ctx 上下文
         */
        async deleteFile(ctx) {
            try {
                const cpid = ctx.params.cpid;
                const csid = ctx.params.csid;
                const cid = ctx.params.cid;
                const responseData = { err: 0, msg: '', data: {} };
                const data = JSON.parse(ctx.request.body.data);
                let fileInfo = null;
                if (cpid) {
                    fileInfo = await ctx.service.contractPayAtt.getDataById(data.id);
                } else if (csid) {
                    fileInfo = await ctx.service.contractSupplementAtt.getDataById(data.id);
                } else if (cid) {
                    fileInfo = await ctx.service.contractAtt.getDataById(data.id);
                } else {
                    throw '参数错误';
                }
                if (fileInfo || Object.keys(fileInfo).length) {
                    // 先删除文件
                    // await fs.unlinkSync(path.resolve(this.app.baseDir, './app', fileInfo.filepath));
                    await ctx.app.fujianOss.delete(ctx.app.config.fujianOssFolder + fileInfo.filepath);
                    // 再删除数据库
                    if (cpid) {
                        await ctx.service.contractPayAtt.delete(data.id);
                    } else if (csid) {
                        await ctx.service.contractSupplementAtt.delete(data.id);
                    } else {
                        await ctx.service.contractAtt.delete(data.id);
                    }
                } else {
                    throw '不存在该文件';
                }
                if (cpid) {
                    responseData.data = await ctx.service.contractPayAtt.getAtt(cpid);
                } else if (csid) {
                    responseData.data = await ctx.service.contractSupplementAtt.getAtt(csid);
                } else {
                    responseData.data = await ctx.service.contractAtt.getAtt(cid);
                }
                ctx.body = responseData;
            } catch (err) {
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }

        /**
         * 下载附件
         * @param {Object} ctx - egg全局变量
         * @return {void}
         */
        async downloadFile(ctx) {
            const id = ctx.params.fid;
            if (id) {
                try {
                    const cpid = ctx.params.cpid;
                    const csid = ctx.params.csid;
                    const cid = ctx.params.cid;
                    let fileInfo = null;
                    if (cpid) {
                        fileInfo = await ctx.service.contractPayAtt.getDataById(id);
                    } else if (csid) {
                        fileInfo = await ctx.service.contractSupplementAtt.getDataById(id);
                    } else if (cid) {
                        fileInfo = await ctx.service.contractAtt.getDataById(id);
                    } else {
                        throw '参数错误';
                    }
                    if (fileInfo || Object.keys(fileInfo).length) {
                        // const fileName = path.join(__dirname, '../', fileInfo.filepath);
                        // 解决中文无法下载问题
                        const userAgent = (ctx.request.header['user-agent'] || '').toLowerCase();
                        let disposition = '';
                        if (userAgent.indexOf('msie') >= 0 || userAgent.indexOf('chrome') >= 0) {
                            disposition = 'attachment; filename=' + encodeURIComponent(fileInfo.filename);
                        } else if (userAgent.indexOf('firefox') >= 0) {
                            disposition = 'attachment; filename*="utf8\'\'' + encodeURIComponent(fileInfo.filename) + '"';
                        } else {
                            /* safari等其他非主流浏览器只能自求多福了 */
                            disposition = 'attachment; filename=' + new Buffer(fileInfo.filename).toString('binary');
                        }
                        ctx.response.set({
                            'Content-Type': 'application/octet-stream',
                            'Content-Disposition': disposition,
                            'Content-Length': fileInfo.filesize,
                        });
                        // ctx.body = await fs.createReadStream(fileName);
                        ctx.body = await ctx.helper.ossFileGet(fileInfo.filepath);
                    } else {
                        throw '不存在该文件';
                    }
                } catch (err) {
                    this.log(err);
                    this.setMessage(err.toString(), this.messageType.ERROR);
                }
            }
        }

        async setting(ctx) {
            try {
                if (!ctx.subProject.page_show.openTenderContract && !ctx.subProject.page_show.openContract) {
                    throw '该功能已关闭或无法查看';
                }
                if (!ctx.session.sessionUser.is_admin) {
                    throw '您没有权限查看该页面';
                }
                // url是否包含tender
                const types_from = ctx.url.indexOf('tender') > -1 ? 'tender' : 'subProject';
                const commonJson = ctx.subProject.common_json ? JSON.parse(ctx.subProject.common_json) : null;
                const types = commonJson && commonJson.contract_type ? commonJson.contract_type : [];
                const tender_types = commonJson && commonJson.tender_contract_type ? commonJson.tender_contract_type : [];
                const used = commonJson && commonJson.contract_used ? commonJson.contract_used : [];
                const tender_used = commonJson && commonJson.tender_contract_used ? commonJson.tender_contract_used : [];
                const renderData = {
                    types_from,
                    types,
                    tender_types,
                    used,
                    tender_used,
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.contract.setting),
                    thisUrl: `/sp/${ctx.subProject.id}/contract${types_from === 'tender' ? '/tender' : ''}/setting`,
                    is_setting: true,
                };
                const attributeSet = commonJson && commonJson.contract_attribute ? commonJson.contract_attribute : contractConst.attributeSet;
                renderData.attributeSet = ctx.service.contractColSet.analysisColSetWithDefine(contractConst.attributeSet, attributeSet, contractConst.defaultAttributeSet);
                await this.layout('contract/setting.ejs', renderData);
            } catch (err) {
                ctx.log(err);
                ctx.session.postError = err.toString();
                ctx.redirect(`/sp/${ctx.subProject.id}/dashboard`);
            }
        }

        /**
         * 保存功能设置相关
         * @param ctx
         * @return {Promise<void>}
         */
        async updateSetting(ctx) {
            try {
                const responseData = { err: 0, msg: '', data: null };
                if (!ctx.subProject) throw '没有对应的项目数据';
                if (ctx.session.sessionUser.is_admin === 0) throw '没有访问权限';

                const data = JSON.parse(ctx.request.body.data);
                if (data) ctx.request.body = data;

                switch (data.type) {
                    case 'page_show':
                        this.ctx.subProject.page_show.openContractSubProjectShenpi = data.openContractSubProjectShenpi ? 1 : 0;
                        this.ctx.subProject.page_show.openContractPaySubProjectShenpi = data.openContractPaySubProjectShenpi ? 1 : 0;
                        this.ctx.subProject.page_show.openContractTenderShenpi = data.openContractTenderShenpi ? 1 : 0;
                        this.ctx.subProject.page_show.openContractPayTenderShenpi = data.openContractPayTenderShenpi ? 1 : 0;
                        const result = await ctx.service.contract.savePageShow(ctx.subProject.id, ctx.subProject.page_show);
                        if (!result) throw '保存数据失败';
                        break;
                    case 'attribute_set':
                        const result2 = await ctx.service.subProject.saveCommonJson(ctx.subProject.id, 'contract_attribute', data.attribute_set);
                        if (!result2) throw '保存数据失败';
                        responseData.data = ctx.service.contractColSet.analysisColSetWithDefine(contractConst.attributeSet, data.attribute_set, contractConst.defaultAttributeSet);
                        break;
                    default:
                        throw '参数有误';
                }
                ctx.body = responseData;
            } catch (error) {
                ctx.log(error);
                this.ajaxErrorBody(error, '保存数据失败');
            }
        }

        async shenpiSet(ctx) {
            try {
                if (!ctx.subProject) throw '没有对应的项目数据';
                if (ctx.session.sessionUser.is_admin === 0) throw '没有访问权限';
                // 获取所有项目参与者
                const accountList = await ctx.service.projectAccount.getAllSubProjectAccount(ctx.subProject);
                const unitList = await ctx.service.constructionUnit.getAllDataByCondition({ where: { pid: ctx.session.sessionProject.id } });
                const accountGroupList = unitList.map(item => {
                    const groupList = accountList.filter(item1 => item1.company === item.name);
                    return { groupName: item.name, groupList };
                }).filter(x => { return x.groupList.length > 0; });
                // 获取固定审批流 or 固定终审
                const spConst = ctx.helper._.cloneDeep(shenpiConst);
                for (const sp of spConst.sp_lc) {
                    sp.status = ctx.subProject.shenpi ? ctx.subProject.shenpi[sp.code] : spConst.sp_status.sqspr;
                    if (sp.status === shenpiConst.sp_status.gdspl) {
                        sp.groupList = await ctx.service.shenpiGroup.getGroupList(ctx.subProject.id, sp.type) || [];
                        if (sp.groupList && sp.groupList.length > 0) {
                            for (const group of sp.groupList) {
                                if (group.change_type) group.change_type = JSON.parse(group.change_type);
                                group.auditGroupList = await ctx.service.shenpiAudit.getAuditGroupList(ctx.subProject.id, sp.type, sp.status, group.id);
                                if (group.is_select) sp.auditGroupList = group.auditGroupList;
                            }
                        } else {
                            sp.auditGroupList = await ctx.service.shenpiAudit.getAuditGroupList(ctx.subProject.id, sp.type, sp.status);
                        }
                    } else if (sp.status === shenpiConst.sp_status.gdzs) {
                        sp.audit = await ctx.service.shenpiAudit.getAudit(ctx.subProject.id, sp.type, sp.status);
                    }
                }
                const renderData = {
                    shenpi: spConst,
                    accountList,
                    accountGroup: accountGroupList,
                    auditConst,
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.contract.shenpi),
                    auditType: auditConst.auditType,
                    types_from: 'subProject',
                    thisUrl: `/sp/${ctx.subProject.id}/contract/setting`,
                    contract_type_list: shenpiConst.contract_type_list,
                    is_setting: true,
                };
                await this.layout('contract/shenpi.ejs', renderData, 'contract/shenpi_modal.ejs');
            } catch (err) {
                ctx.log(err);
                ctx.session.postError = err.toString();
                ctx.redirect(`/sp/${ctx.subProject.id}/dashboard`);
            }
        }

        async editAndAi(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                if (!data.id || !data.fid) throw '数据错误';
                const contract = await ctx.service.contract.getDataById(data.id);
                if (!contract) {
                    throw '未找到合同相关数据';
                }
                const att = await ctx.service.contractAtt.getDataById(data.fid);
                if (!att) {
                    throw '未找到合同文件';
                }
                att.viewpath = ctx.app.config.fujianOssPath + att.filepath;
                const aiDify = new AiDify({ apiKey: ctx.difyInfo.apiKey.contract });
                const transResult = await aiDify.contractTrans(att);
                transResult.res = JSON.parse(transResult.res);
                const responseData = {
                    ...transResult,
                    cid: contract.id,
                    attached: false,
                };
                ctx.body = { err: 0, msg: '', data: responseData };
            } catch (err) {
                console.log(err);
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }

        async uploadAndAi(ctx) {
            const stream = await ctx.getFileStream();
            try {
                const hasExistingCid = !!stream.fields.cid;
                const cid = stream.fields.cid || this.ctx.app.uuid.v4();
                if (!cid) throw '参数有误';

                const attachToContract = stream.fields.attachToContract === 'true' || stream.fields.attachToContract === '1';
                const create_time = Date.parse(new Date()) / 1000;
                const parsedPath = path.parse(stream.filename);
                const headpath = ctx.contractOptions.spid
                    ? `sp/contract/${ctx.contractOptions.spid}`
                    : `app/public/upload/${ctx.contractOptions.tid}`;
                const filepath = `${headpath}/contract/${cid}/fujian_${create_time}${parsedPath.ext}`;

                await ctx.app.fujianOss.put(ctx.app.config.fujianOssFolder + filepath, stream);
                const fileInfo = { filepath, name: stream.filename, ext: parsedPath.ext };
                if (stream) await sendToWormhole(stream);

                if (!fileInfo) {
                    throw '请上传文件';
                }

                const newFile = {
                    spid: ctx.contractOptions.spid || null,
                    tid: ctx.contractOptions.tid || null,
                    contract_type: ctx.contract_type,
                    cid,
                    uid: ctx.session.sessionUser.accountId,
                    filename: fileInfo.name,
                    fileext: fileInfo.ext,
                    filesize: stream.fields.size,
                    filepath: fileInfo.filepath,
                    upload_time: new Date(),
                };

                // 写入数据库（只有这一条记录）
                if (!hasExistingCid || attachToContract) {
                    const fileResult = await ctx.service.contractAtt.saveFileMsgToDb([newFile]);
                    newFile.id = fileResult.insertId;
                    newFile.username = ctx.session.sessionUser.name;
                }

                // 重新查出该cid下的附件，按filepath精确匹配出刚上传的这一份（避免拿到该cid下其他历史文件）
                newFile.viewpath = ctx.app.config.fujianOssPath + newFile.filepath;
                const aiDify = new AiDify({ apiKey: ctx.difyInfo.apiKey.contract });
                const transResult = await aiDify.contractTrans(newFile);
                transResult.res = JSON.parse(transResult.res);
                // 如果不勾选"附加到合同"并且没有cid，则要删除oss文件
                if (!attachToContract && hasExistingCid) {
                    await ctx.app.fujianOss.delete(ctx.app.config.fujianOssFolder + newFile.filepath);
                }
                const responseData = {
                    ...transResult,
                    cid,
                    attached: attachToContract,
                };
                if ((!hasExistingCid || attachToContract) && newFile.id) responseData.file = newFile;
                ctx.body = { err: 0, msg: '', data: responseData };
            } catch (err) {
                stream && (await sendToWormhole(stream));
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }
    }

    return ContractController;
};