Calculation/app/controller/sub_proj_setting_controller.js

 'use strict';

/**
 *
 *
 * @author Mai
 * @date
 * @version
 */
const tenderConst = require('../const/tender');
const auditConst = require('../const/audit');
const officeList = require('../const/cld_office').list;
const settingConst = require('../const/setting.js');
const scheduleConst = require('../const/schedule');
const settingMenu = require('../../config/menu').projectSettingMenu;
const projectLog = require('../const/project_log');
const imType = require('../const/tender').imType;
const path = require('path');
const funSet = require('../const/fun_set');
const projectSettingConst = require('../const/project_setting');
const shenpiConst = require('../const/shenpi');

module.exports = app => {

    class SettingController extends app.BaseController {

        /**
         * 构造函数
         *
         * @param {Object} ctx - egg全局context
         * @return {void}
         */
        constructor(ctx) {
            super(ctx);
            ctx.subMenu = JSON.parse(JSON.stringify(settingMenu));
            for (const index in ctx.subMenu) {
                const menu = ctx.subMenu[index];
                menu.url = `/sp/${ctx.subProject.id}` + menu.url;
            }
        }

        async defaultCheck(ctx) {
            if (!ctx.subProject) throw '没有对应的项目数据';
            if (ctx.session.sessionUser.is_admin === 0) throw '没有访问权限';
        }

        /**
         * 项目设置 -- 自定义标段分类(Get)
         *
         * @param ctx
         * @return {Promise<void>}
         */
        async category(ctx) {
            try {
                this.defaultCheck(ctx);
                // 获取项目数据

                const categoryData = await ctx.service.category.getAllCategory(ctx.subProject);
                const tenderData = await ctx.service.tender.getList('', null, 1);
                const renderData = {
                    categoryType: settingConst.cType,
                    categoryData,
                    tenderData,
                };
                await this.layout('sp_setting/category.ejs', renderData, 'sp_setting/category_modal.ejs');
            } catch (error) {
                console.log(error);
                ctx.redirect(`/sp/${ctx.subProject.id}/dashboard`);
            }
        }

        /**
         * 新增分类(Ajax)
         *
         * @param ctx
         * @return {Promise<void>}
         */
        async addCategory(ctx) {
            try {
                const responseData = {
                    err: 0, msg: '', data: null,
                };

                const data = JSON.parse(ctx.request.body.data);
                if (!data.name) {
                    throw '提交数据错误';
                }

                responseData.data = await ctx.service.category.addCategory(ctx.subProject, data.name, settingConst.cType.key.dropDown);
                ctx.body = responseData;
            } catch (err) {
                this.log(err);
                ctx.body = {err: 1, msg: err.toString(), data: null};
            }
        }

        /**
         * 编辑分类(Ajax)
         *
         * @param ctx
         * @return {Promise<void>}
         */
        async updateCategory(ctx) {
            try {
                const responseData = {err: 0, msg: '', data: null};

                const data = JSON.parse(ctx.request.body.data);
                if (!data.id) {
                    throw '提交数据错误';
                }
                if (data.name) {
                    const count = await ctx.service.category.count({spid: ctx.subProject.id, name: data.name});
                    if (count >= 1) {
                        throw '存在同名类别';
                    }
                }

                const result = await ctx.service.category.update(data, {id: data.id});
                if (!result) {
                    throw '提交数据失败';
                }

                responseData.data = await ctx.service.category.getCategory(data.id);

                ctx.body = responseData;
            } catch (err) {
                this.log(err);
                ctx.body = {err: 1, msg: err.toString(), data: null};
            }
        }

        async setCategoryValue(ctx) {
            try {
                const responseData = {err: 0, msg: '', data: {}};

                const data = JSON.parse(ctx.request.body.data);
                if (!data.id) {
                    throw '提交数据错误';
                }
                await ctx.service.categoryValue.setCategoryValue(ctx.subProject, data.id, data.updateValue);

                responseData.data.category = await ctx.service.category.getCategory(data.id);
                // todo 查询标段
                responseData.data.tenders = await ctx.service.tender.getList('', null, 1);

                ctx.body = responseData;
            } catch (err) {
                this.log(err);
                ctx.body = {err: 1, msg: err instanceof String ? err : '提交数据失败', data: null};
            }
        }

        /**
         * 删除分类(Ajax)
         *
         * @param ctx
         * @return {Promise<void>}
         */
        async deleteCategory(ctx) {
            try {
                const responseData = {
                    err: 0, msg: '', data: null,
                };

                const data = JSON.parse(ctx.request.body.data);
                if (!data.id) {
                    throw '提交数据错误';
                }

                await ctx.service.category.deleteCategory(ctx.subProject, data.id);

                ctx.body = responseData;
            } catch (err) {
                this.log(err);
                ctx.body = {err: 1, msg: err.toString(), data: null};
            }
        }

        /**
         * 调整分类层次排序(Ajax)
         *
         * @param ctx
         * @return {Promise<void>}
         */
        async resetCategoryLevel(ctx) {
            try {
                const responseData = {
                    err: 0, msg: '', data: null,
                };
                const data = JSON.parse(ctx.request.body.data);

                await ctx.service.category.resetCategoryLevel(data);
                responseData.data = await ctx.service.category.getAllCategory(ctx.subProject);
                ctx.body = responseData;
            } catch (err) {
                this.log(err);
                ctx.body = {err: 1, msg: err.toString(), data: null};
            }
        }

        async selfCategoryLevel(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);

                await ctx.service.subProjPermission.defaultUpdate({
                    self_category_level: data.self_category_level || ''
                }, { where: { spid: ctx.subProject.id, uid: ctx.session.sessionUser.accountId}});
                ctx.body = {
                    err: 0, msg: '', data: null,
                };
            } catch (err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '保存自定义分类失败');
            }
        }

        async user(ctx) {
            try {
                this.defaultCheck(ctx);
                const unitList = await ctx.service.constructionUnit.getAllDataByCondition({ where: { pid: ctx.session.sessionProject.id } });
                const filter = {
                    company: ctx.query.company || '',
                    keyword: ctx.query.keyword || '',
                };
                const total = await ctx.service.projectAccount.getSubProjectAccountCount(ctx.subProject, filter);
                const subProjectAccountList = await ctx.service.projectAccount.getSubProjectAccountListWithPermission(ctx.subProject, filter);
                const subProjectAllAccountList = filter.company || filter.keyword ? await ctx.service.projectAccount.getSubProjectAccountListWithPermission(ctx.subProject) : subProjectAccountList;
                const subProjectUnitList = unitList.map(item => {
                    const users = subProjectAllAccountList.filter(item1 => item1.company === item.name);
                    return { name: item.name, users };
                }).filter(x => { return x.users.length > 0; });
                const pageInfo = {
                    page: ctx.page,
                    pageSizeSelect: 1,
                    pageSize: ctx.pageSize,
                    total_num: total,
                    total: Math.ceil(total / ctx.pageSize),
                    queryData: JSON.stringify(ctx.urlInfo.query),
                };

                const accountList = await ctx.service.projectAccount.getAllDataByCondition({
                    columns: ['id', 'name', 'company', 'role', 'enable', 'is_admin', 'account_group', 'mobile', 'company_id'],
                    where: { project_id: ctx.subProject.project_id },
                });
                accountList.forEach(x => {
                    x.sp_exist = subProjectAllAccountList.findIndex(y => { return y.id === x.id; }) >= 0;
                });
                const accountGroup = unitList.map(item => {
                    const groupList = accountList.filter(item1 => item1.company === item.name);
                    return { id: item.id, name: item.name, groupList };
                }).filter(x => { return x.groupList.length > 0; });
                const renderData = {
                    pageInfo,
                    accountGroup,
                    subProjectAccountList,
                    subProjectUnitList,
                    keyword: filter.keyword,
                    company: filter.company,
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.setting.sp_permission),
                    permissionBlock: ctx.service.subProjPermission.PermissionBlock,
                };
                await this.layout('sp_setting/user.ejs', renderData, 'sp_setting/user_modal.ejs');
            } catch (error) {
                console.log(error);
                ctx.redirect(`/sp/${ctx.subProject.id}/dashboard`);
            }
        }

        async permission(ctx) {
            try {
                this.defaultCheck(ctx);
                const unitList = await ctx.service.constructionUnit.getAllDataByCondition({ where: { pid: ctx.session.sessionProject.id } });
                const filter = {
                    keyword: ctx.query.keyword || '',
                };
                const permissionConst = this.service.subProjPermission.PermissionConst;
                const subProjectAccountList = await ctx.service.projectAccount.getSubProjecAllAccountListWithPermission(ctx.subProject, filter);
                const subProjectAllAccountList = await ctx.service.projectAccount.getSubProjecAllAccountListWithPermission(ctx.subProject);
                const subProjectUnitList = unitList.map(item => {
                    const users = subProjectAccountList.filter(item1 => item1.company === item.name);
                    return { name: item.name, users };
                }).filter(x => { return x.users.length > 0; });

                const accountList = await ctx.service.projectAccount.getAllDataByCondition({
                    columns: ['id', 'name', 'company', 'role', 'enable', 'is_admin', 'account_group', 'mobile', 'company_id'],
                    where: { project_id: ctx.subProject.project_id },
                });
                accountList.forEach(x => {
                    x.sp_exist = subProjectAllAccountList.findIndex(y => { return y.id === x.id; }) >= 0;
                });
                const accountGroup = unitList.map(item => {
                    const groupList = accountList.filter(item1 => item1.company === item.name);
                    return { id: item.id, name: item.name, groupList };
                }).filter(x => { return x.groupList.length > 0; });
                const renderData = {
                    ptype: ctx.query.ptype,
                    accountGroup,
                    subProjectAccountList,
                    subProjectAllAccountList,
                    subProjectUnitList,
                    keyword: filter.keyword,
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.setting.sp_permission),
                    permissionBlock: ctx.service.subProjPermission.PermissionBlock,
                    permissionConst: permissionConst[ctx.query.ptype],
                };
                await this.layout('sp_setting/permission.ejs', renderData, 'sp_setting/user_modal.ejs');
            } catch (error) {
                console.log(error);
                ctx.redirect(`/sp/${ctx.subProject.id}/dashboard`);
            }
        }

        async permissionUpdate(ctx) {
            try {
                this.defaultCheck(ctx);
                const data = JSON.parse(ctx.request.body.data);
                const result = await ctx.service.subProjPermission.updatePermission(ctx.subProject, data);
                ctx.body = { err: 0, msg: '', data: result };
            } catch (err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '更新账号权限失败');
            }
        }

        async logs(ctx) {
            try {
                this.defaultCheck(ctx);
                // 获取项目数据
                const settingType = ctx.params.type ? parseInt(ctx.params.type) : 0;
                const logs = await ctx.service.projectLog.getLogs(ctx.subProject.id, settingType);
                const renderData = {
                    officeList,
                    projectLog,
                    settingType,
                    logs,
                };
                await this.layout('sp_setting/logs.ejs', renderData);
            } catch (error) {
                console.log(error);
                ctx.redirect(`/sp/${ctx.subProject.id}/dashboard`);
            }
        }

        async fun(ctx) {
            try {
                this.defaultCheck(ctx);
                const funRela = this.ctx.subProject.fun_rela;
                const fun_set = this.ctx.subProject.fun_set;
                await this.layout('sp_setting/fun.ejs', {
                    funRela,
                    imType,
                    endMonth: funSet.endMonth,
                    funSet: fun_set,
                }, 'sp_setting/fun_modal.ejs');
            } catch (error) {
                ctx.helper.log(error);
                ctx.redirect(`/sp/${ctx.subProject.id}/dashboard`);
            }
        }

        /**
         * 保存功能设置相关
         * @param ctx
         * @returns {Promise<void>}
         */
        async updateFun(ctx) {
            try {
                this.defaultCheck(ctx);

                const data = JSON.parse(ctx.request.body.data);
                if (data) ctx.request.body = data;
                const rule = ctx.service.subProject.rule('fun');
                ctx.validate(rule);

                const result = await ctx.service.subProject.updateFunRela(ctx.subProject.id, ctx.request.body);
                if (!result) throw '保存数据失败';
                this.ctx.subProject.page_show.openChangeProject = data.openChangeProject ? 1 : 0;
                this.ctx.subProject.page_show.openChangeApply = data.openChangeApply ? 1 : 0;
                this.ctx.subProject.page_show.openChangePlan = data.openChangePlan ? 1 : 0;
                this.ctx.subProject.page_show.openChangeWhiteList = data.openChangeWhiteList ? 1 : 0;
                this.ctx.subProject.page_show.openChangeState = data.openChangeState ? 1 : 0;
                this.ctx.subProject.page_show.openMaterialTax = data.openMaterialTax ? 1 : 0;
                this.ctx.subProject.page_show.openMaterialChecklist = data.openMaterialChecklist ? 1 : 0;
                this.ctx.subProject.page_show.openMaterialSelf = data.openMaterialSelf ? 1 : 0;
                this.ctx.subProject.page_show.openMaterialEditForAudit = data.openMaterialEditForAudit ? 1 : 0;
                this.ctx.subProject.page_show.openStageStart = data.openStageStart ? 1 : 0;
                const result2 = await ctx.service.subProject.updatePageshow(ctx.subProject.id);
                if (!result2) throw '保存数据失败';
                if (data.addFunSet) {
                    const funSet = ctx.subProject.fun_set;
                    ctx.helper._.defaultsDeep(data.addFunSet, funSet);
                    const result3 = await ctx.service.subProject.updateFunSet(ctx.subProject.id, data.addFunSet);
                    if (!result3) throw '保存数据失败';
                }

                ctx.body = {err: 0, msg: '', data: null};
            } catch (error) {
                ctx.helper.log(error);
                this.ajaxErrorBody(error, '保存数据失败');
            }
        }

        async dataCollect(ctx) {
            try {
                this.defaultCheck(ctx);
                if (!ctx.session.sessionProject.page_show.openDataCollect) {
                    throw '该功能已关闭或无法查看';
                }
                ctx.subProject.data_collect_pages = ctx.subProject.data_collect_pages ? ctx.subProject.data_collect_pages.split(',') : [];
                ctx.session.sessionProject.dataCollect = ctx.subProject.data_collect;
                if (ctx.session.sessionUser.is_admin === 0) throw '没有访问权限';
                const dataCollectAudits = await ctx.service.datacollectAudit.getList(ctx.subProject.project_id);
                // 获取所有项目参与者
                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, companyId: item.id, groupList};
                });
                const categoryData = await ctx.service.category.getAllCategory(ctx.subProject);
                const tenders = await ctx.service.tender.getList('', null, 1);
                const dcTenders = await ctx.service.datacollectTender.getList(ctx.subProject.project_id);
                const is_dz2 = ['P0505', 'P0506', 'P1201', 'P1202', 'GY18Y', 'GYJJ1', 'P1103'].indexOf(ctx.session.sessionProject.code) !== -1 ? 6 : false;
                const renderData = {
                    dataCollectAudits,
                    accountList,
                    accountGroup: accountGroupList,
                    categoryData,
                    tenders,
                    dcTenders,
                    is_dz1: ['P0505', 'MI22U'].indexOf(ctx.session.sessionProject.code) !== -1 ? 5 : false,
                    is_dz2,
                };
                if (is_dz2) {
                    const projectData = await this.ctx.service.project.getDataById(ctx.subProject.project_id);
                    // 获取分类及对应值
                    const commonJson = projectData.common_json ? JSON.parse(projectData.common_json) : null;
                    renderData.daPing06Set = commonJson && commonJson.daPing06_set ? commonJson.daPing06_set : ctx.helper._.cloneDeep(projectSettingConst.daPing06Set);
                }
                await this.layout('sp_setting/datacollect.ejs', renderData, 'sp_setting/datacollect_modal.ejs');
            } catch (error) {
                ctx.helper.log(error);
                ctx.session.postError = error.toString();
                ctx.redirect(`/sp/${ctx.subProject.id}/dashboard`);
            }
        }

        async dataCollectSave(ctx) {
            try {
                this.defaultCheck(ctx);
                const responseData = {
                    err: 0, msg: '', data: null,
                };

                const data = JSON.parse(ctx.request.body.data);
                if (!data.type) {
                    throw '提交数据错误';
                }
                switch (data.type) {
                    case 'show':
                        responseData.data = await ctx.service.subProject.update({
                            data_collect: data.data_collect,
                            data_collect_pages: data.data_collect_pages.join(','),
                        }, {id: ctx.subProject.id});
                        ctx.subProject.dataCollect = data.data_collect;
                        ctx.subProject.showDataCollect = data.data_collect ? 1 : 0;
                        break;
                    case 'add-audit':
                        // 判断该用户是否已加入到表中，已加入则提示无需添加
                        const auditInfo = await ctx.service.datacollectAudit.getDataByCondition({
                            pid: ctx.subProject.project_id,
                            uid: data.id
                        });
                        if (auditInfo) {
                            throw '该用户已存在权限中，无需重复添加';
                        }
                        await ctx.service.datacollectAudit.saveAudit(ctx.subProject.project_id, data.id);
                        responseData.data = await ctx.service.datacollectAudit.getList(ctx.subProject.project_id);
                        break;
                    case 'add-company':
                        const companyInfo = await ctx.service.datacollectAudit.getCompanyInfo(ctx.subProject.project_id, data.id);
                        if (companyInfo) {
                            throw '该单位已存在权限中，无需重复添加';
                        }
                        await ctx.service.datacollectAudit.saveCompany(ctx.subProject.project_id, data.id);
                        responseData.data = await ctx.service.datacollectAudit.getList(ctx.subProject.project_id);
                        break;
                    case 'del-audit':
                        const auditInfo2 = await ctx.service.datacollectAudit.getDataById(data.id);
                        if (!auditInfo2) {
                            throw '该用户已不存在权限中，移除失败';
                        }
                        await ctx.service.datacollectAudit.delAudit(data.id);
                        responseData.data = await ctx.service.datacollectAudit.getList(ctx.subProject.project_id);
                        break;
                    case 'del-group':
                        const groupInfo3 = await ctx.service.datacollectAudit.getDataById(data.id);
                        if (!groupInfo3) {
                            throw '该单位已不存在权限中，移除失败';
                        }
                        await ctx.service.datacollectAudit.delAudit(data.id);
                        responseData.data = await ctx.service.datacollectAudit.getList(ctx.subProject.project_id);
                        break;
                    case 'del-company':
                        const companyInfo2 = await ctx.service.datacollectAudit.getDataById(data.id);
                        if (!companyInfo2) {
                            throw '该单位已不存在权限中，移除失败';
                        }
                        await ctx.service.datacollectAudit.delAudit(data.id);
                        responseData.data = await ctx.service.datacollectAudit.getList(ctx.subProject.project_id);
                        break;
                    case 'tender':
                        if (ctx.session.sessionProject.page_show.addDataCollect !== parseInt(data.add_datacollect)) {
                            ctx.session.sessionProject.page_show.addDataCollect = parseInt(data.add_datacollect);
                            await ctx.service.project.updatePageshow(ctx.subProject.project_id);
                        }
                        await ctx.service.datacollectTender.updateList(ctx.subProject.project_id, data.tids);
                        responseData.data = {
                            dcTenders: await ctx.service.datacollectTender.getList(ctx.subProject.project_id),
                            addDatacollect: ctx.session.sessionProject.page_show.addDataCollect,
                        };
                        break;
                    case 'save-dp06':
                        responseData.data = await ctx.service.project.saveCommonJson(ctx.subProject.project_id, 'daPing06_set', data.daPing06Set);
                        break;
                    default:
                        throw '参数有误';
                }
                ctx.body = responseData;
            } catch (err) {
                this.log(err);
                ctx.body = {err: 1, msg: err.toString(), data: null};
            }
        }

        async manage(ctx) {
            try {
                this.defaultCheck(ctx);
                const projectId = ctx.session.sessionProject.id;
                const projectData = await ctx.service.project.getDataById(projectId);
                if (projectData === null) throw '没有对应的项目数据';
                if (ctx.session.sessionUser.is_admin === 0) throw '没有访问权限';

                const tenderList = await ctx.service.tender.getList('', null, 1);
                const removeTenders = await ctx.service.shenpiAudit.getRemoveTenders(tenderList);
                if (removeTenders.length > 0) {
                    ctx.helper._.remove(tenderList, function(n) {
                        return removeTenders.indexOf(n.id) !== -1;
                    });
                }
                for (const t of tenderList) {
                    t.visitor = (await this.ctx.service.tenderTourist.getTourists(t.id)).map(x => { return x.user_name; });
                    await this.ctx.service.tenderCache.loadTenderCache(t, this.ctx.session.sessionUser.accountId);
                }
                // todo 自定义分类移动到子项目内部后，在整个项目上没有分类了
                const categoryData = await ctx.service.category.getAllCategory(ctx.subProject);
                // const categoryData = []; // await this.ctx.service.category.getAllCategory(this.ctx.session.sessionProject.id);

                // 获取所有项目参与者
                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};
                });

                // 获取项目列表
                const subProjects = await ctx.service.subProject.getAllDataByCondition({ where: { project_id: projectId, is_delete: 0 } });
                const renderData = {
                    projectData,
                    tenderList,
                    auditConst,
                    auditType: auditConst.auditType,
                    accountList,
                    accountGroup: accountGroupList,
                    categoryData,
                    settingConst,
                    measureType: tenderConst.measureType,
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.setting.manage),
                    uid: this.ctx.session.sessionUser.accountId,
                    pid: this.ctx.session.sessionProject.id,
                    spid: ctx.subProject.id,
                    scPermission: scheduleConst.permission,
                    change_type_list: shenpiConst.change_type_list,
                    subProjects,
                };
                renderData.selfCategoryLevel = await this.ctx.service.projectAccount.getSelfCategoryLevel(this.ctx.session.sessionUser.accountId);
                await this.layout('sp_setting/manage.ejs', renderData, 'sp_setting/manage_modal.ejs');
            } catch (error) {
                ctx.helper.log(error);
                ctx.redirect(`/sp/${ctx.subProject.id}/dashboard`);
            }
        }

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

                const data = JSON.parse(ctx.request.body.data);
                if (!data.type) {
                    throw '提交数据错误';
                }
                // if (!data.tid) {
                //     throw '参数有误';
                // }
                // const tender = await ctx.service.tender.getDataById(data.tid);
                // if (!tender) {
                //     throw '标段不存在';
                // }
                // const tenderInfo = await ctx.service.tenderInfo.getTenderInfo(tender.id);
                switch (data.type) {
                    case 'msg':
                        if (!data.tid) {
                            throw '参数有误';
                        }
                        const tender = await ctx.service.tender.getDataById(data.tid);
                        if (!tender) {
                            throw '标段不存在';
                        }
                        const tenderInfo = await ctx.service.tenderInfo.getTenderInfo(tender.id);
                        const lastRevise = await ctx.service.ledgerRevise.getLastestRevise(tender.id);
                        const revising = (lastRevise && lastRevise.status !== auditConst.revise.status.checked) || false;
                        // 获取审批流，游客账号，及投资进度账号信息
                        responseData.data.tender = tender;
                        responseData.data.revising = revising;
                        responseData.data.shenpi = await ctx.service.shenpiAudit.getShenpi(tender.id, tenderInfo);
                        const tourists = await ctx.service.tenderTourist.getTourists(tender.id);
                        for (const t of tourists) {
                            t.permission = await ctx.service.tenderTourist.getTouristPermission(t);
                        }
                        responseData.data.tourists = tourists;
                        responseData.data.scheduleAuditList = ctx.session.sessionProject.page_show.xxjd ? await ctx.service.scheduleAudit.getAllDataByCondition({ where: { tid: tender.id } }) : [];
                        responseData.data.constructionAuditList = ctx.session.sessionProject.page_show.openConstruction ? await ctx.service.constructionAudit.getList(tender.id) : [];
                        break;
                    case 'copy2otu':
                        if (data.userType === 'tourist') {
                            await ctx.service.tenderTourist.setOtherTender(data.tidList, data.auditList);
                        } else if (data.userType === 'schedule') {
                            await ctx.service.scheduleAudit.setOtherTender(data.tidList, data.auditList);
                        } else if (data.userType === 'construction') {
                            await ctx.service.constructionAudit.setOtherTender(data.tidList, data.auditList);
                        } else {
                            throw '参数有误';
                        }
                        break;
                    case 'noSp-tenders':
                        responseData.data = await ctx.service.tender.getNoSpTenders(projectId);
                        break;
                    case 'bind-sp':
                        if (!data.spid || !data.tidList) {
                            throw '参数有误';
                        }
                        if (data.tidList.split(',').length === 0) {
                            throw '参数有误';
                        }
                        responseData.data = await ctx.service.tender.bindSp(projectId, data.spid, data.tidList.split(','));
                        break;
                    case 'get-category':
                        responseData.data = await ctx.service.category.getAllCategory({ id: data.spid });
                        break;
                    default:
                        throw '参数有误';
                }
                ctx.body = responseData;
            } catch (err) {
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }
    }

    return SettingController;
};