Calculation/app/controller/setting_controller.js

 'use strict';

/**
 *
 *
 * @author Mai
 * @date
 * @version
 */

const officeList = require('../const/cld_office').list;
const settingConst = require('../const/setting.js');
const settingMenu = require('../../config/menu').settingMenu;
const accountGroup = require('../const/account_group').group;
const permission = require('../const/account_permission').permission;
const projectLog = require('../const/project_log');
const imType = require('../const/tender').imType;
const S2b = require('../lib/s2b');
const measureType = require('../const/tender').measureType;
const sendToWormhole = require('stream-wormhole');
const path = require('path');
const funSet = require('../const/fun_set');

module.exports = app => {

    class SettingController extends app.BaseController {

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

        async _checkMenu(pid) {
            const ctx = this.ctx;
            await this.ctx.service.s2bProj.refreshSessionS2b(pid);
            ctx.subMenu.s2b.display = !!ctx.session.sessionProject.gxby || !!ctx.session.sessionProject.dagl;
            // this.ctx.subMenu.s2b.display = false;
        }

        /**
         * 项目信息页面(Get)
         *
         * @param {Object} ctx - egg全局变量
         * @return {void}
         */
        async info(ctx) {
            try {
                // 获取项目数据
                const projectId = ctx.session.sessionProject.id;
                await this._checkMenu(projectId);
                const projectData = await ctx.service.project.getDataById(projectId);
                if (projectData === null) {
                    throw '没有对应的项目数据';
                }

                // 获取销售人员数据
                const salesmanData = await ctx.service.manager.getDataById(projectData.manager_id);

                // 数据规则
                const rule = ctx.service.project.rule('saveInfo');
                const jsValidator = await this.jsValidator.convert(rule).build();
                const officeName = officeList[salesmanData.office];
                const date = new Date(projectData.create_time * 1000);// 如果date为10位不需要乘1000
                const Y = date.getFullYear() + '-';
                const M = (date.getMonth() + 1 < 10 ? '0' + (date.getMonth() + 1) : date.getMonth() + 1) + '-';
                const D = (date.getDate() < 10 ? '0' + (date.getDate()) : date.getDate()) + ' ';
                const h = (date.getHours() < 10 ? '0' + date.getHours() : date.getHours()) + ':';
                const m = (date.getMinutes() < 10 ? '0' + date.getMinutes() : date.getMinutes()) + ':';
                const s = (date.getSeconds() < 10 ? '0' + date.getSeconds() : date.getSeconds());
                const dateStr = Y + M + D + h + m + s;
                const renderData = {
                    projectData,
                    salesmanData,
                    officeName,
                    officeList,
                    jsValidator,
                    dateStr,
                };
                await this.layout('setting/info.ejs', renderData);
            } catch (error) {
                console.log(error);
                ctx.redirect('/dashboard');
            }
        }

        /**
         * 项目设置 -- 账号设置(Get)
         * @param ctx
         * @return {Promise<void>}
         */
        async user(ctx) {
            try {
                // 获取项目数据
                const projectId = ctx.session.sessionProject.id;
                await this._checkMenu(projectId);
                const projectData = await ctx.service.project.getDataById(projectId);
                if (projectData === null) {
                    throw '没有对应的项目数据';
                }
                if (ctx.session.sessionUser.is_admin === 0) {
                    throw '没有访问权限';
                }
                let keyword = '';
                if (ctx.query.keyword) {
                    keyword = ctx.query.keyword;
                }
                let company = '';
                if (ctx.query.company) {
                    company = ctx.query.company;
                }

                const page = ctx.page;
                const pageSize = ctx.pageSize;

                // 过滤数据
                ctx.service.projectAccount.searchFilter(ctx.request.query, projectId);
                ctx.sort = ['id', 'desc'];
                const total = await ctx.service.projectAccount.getCountWithBuilder();

                // 获取数据规则
                // const rule = ctx.service.projectAccount.rule('updateUser');
                // const frontRule = ctx.helper.validateConvert(rule);

                // const total = await ctx.service.projectAccount.count({ project_id: projectId });

                // 获取项目用户列表
                // const accountData = await ctx.service.projectAccount.getAllDataByCondition({
                //     where: { project_id: projectId },
                //     columns: ['id', 'account', 'name', 'company', 'role', 'mobile', 'auth_mobile', 'telephone', 'enable', 'is_admin', 'account_group'],
                //     limit: (app.config.pageSize * (page - 1)),
                //     offset: app.config.pageSize,
                // });
                // const columns = ['id', 'account', 'name', 'company', 'role', 'mobile', 'auth_mobile', 'telephone', 'enable', 'is_admin', 'account_group', 'bind'];
                // const accountData = await ctx.service.projectAccount.getListByProjectId(columns, projectId);
                const accountData = await ctx.service.projectAccount.getListWithBuilder();

                // 获取账号个数
                const user_total = await ctx.service.projectAccount.count({ project_id: projectId });

                // 分页相关
                const pageInfo = {
                    page,
                    pageSizeSelect: 1,
                    pageSize,
                    total_num: total,
                    total: Math.ceil(total / pageSize),
                    queryData: JSON.stringify(ctx.urlInfo.query),
                };

                const unitList = await ctx.service.constructionUnit.getAllDataByCondition({ where: { pid: projectId } });

                const renderData = {
                    projectData,
                    accountData,
                    accountGroup,
                    permission,
                    pageInfo,
                    keyword,
                    user_total,
                    unitList,
                    company,
                    // rule: JSON.stringify(frontRule),
                };
                await this.layout('setting/user.ejs', renderData, 'setting/user_modal.ejs');
            } catch (error) {
                console.log(error);
                ctx.redirect('/dashboard');
            }
        }

        /**
         * 项目设置 -- 账号解绑设置(Post)
         * @param ctx
         * @return {Promise<void>}
         */
        async userUnbind(ctx) {
            const projectData = ctx.session.sessionProject;

            try {
                if (projectData.id === undefined) {
                    throw '不存在对应的项目数据';
                }
                if (ctx.session.sessionUser.is_admin === 0) {
                    throw '非管理员无权解绑账号';
                }
                const accountId = parseInt(ctx.request.body.id);
                const result = await ctx.service.projectAccount.update({ bind: 0 }, { id: accountId });
                if (!result) {
                    throw '解绑失败';
                }

                this.setMessage('解绑成功', this.messageType.SUCCESS);
            } catch (error) {
                console.log(error);
                this.setMessage(error.toString(), this.messageType.ERROR);
            }
            ctx.redirect(ctx.request.header.referer);
        }

        /**
         * 项目权限 -- 账号设置(Get)
         * @param ctx
         * @return {Promise<void>}
         */
        async userPermissionSet(ctx) {
            try {
                // 获取项目数据
                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 '没有访问权限';
                }

                let keyword = '';
                if (ctx.query.keyword) {
                    keyword = ctx.query.keyword;
                }

                let company = '';
                if (ctx.query.company) {
                    company = ctx.query.company;
                }

                // 获取数据规则
                const page = ctx.page;
                const pageSize = ctx.pageSize;
                const columns = ['id', 'account', 'name', 'company', 'role', 'mobile', 'auth_mobile', 'telephone', 'enable', 'is_admin', 'bind', 'account_group', 'permission', 'cooperation'];
                // 过滤数据
                ctx.service.projectAccount.searchFilter(ctx.request.query, projectId, columns);
                ctx.sort = ['id', 'desc'];
                const total = await ctx.service.projectAccount.getCountWithBuilder();

                const accountData = await ctx.service.projectAccount.getListWithBuilder();

                // 获取账号个数
                const user_total = await ctx.service.projectAccount.count({ project_id: projectId });

                // 分页相关
                const pageInfo = {
                    page,
                    pageSizeSelect: 1,
                    pageSize,
                    total_num: total,
                    total: Math.ceil(total / pageSize),
                    queryData: JSON.stringify(ctx.urlInfo.query),
                };

                const unitList = await ctx.service.constructionUnit.getAllDataByCondition({ where: { pid: projectId } });

                const renderData = {
                    projectData,
                    accountData,
                    accountGroup,
                    permission,
                    keyword,
                    permissionStr: JSON.stringify(permission),
                    pageInfo,
                    user_total,
                    unitList,
                    company,
                    // rule: JSON.stringify(frontRule),
                };
                await this.layout('setting/user_permission.ejs', renderData, 'setting/user_permission_modal.ejs');
            } catch (error) {
                console.log(error);
                ctx.redirect('/dashboard');
            }
        }

        /**
         * 项目权限 -- 参建单位(Get)
         * @param ctx
         * @return {Promise<void>}
         */
        async userUnit(ctx) {
            try {
                // 获取项目数据
                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 unitList = await ctx.service.constructionUnit.getAllDataByCondition({ where: { pid: projectId } });
                for (const u of unitList) {
                    const accountList = await ctx.service.projectAccount.getAllDataByCondition({ where: { project_id: projectId, company: u.name } });
                    u.account_num = accountList.length;
                }

                // 获取账号个数
                const user_total = await ctx.service.projectAccount.count({ project_id: projectId });

                const renderData = {
                    projectData,
                    accountGroup,
                    unitList,
                    user_total,
                    fujianOssPath: ctx.app.config.fujianOssPath,
                };
                await this.layout('setting/user_unit.ejs', renderData, 'setting/user_unit_modal.ejs');
            } catch (error) {
                console.log(error);
                ctx.redirect('/dashboard');
            }
        }

        /**
         * 项目设置 -- 单位新增设置(Post)
         * @param ctx
         * @return {Promise<void>}
         */
        async userUnitAdd(ctx) {
            const projectData = ctx.session.sessionProject;
            try {
                // 验证数据
                if (projectData.id === undefined) {
                    throw '不存在对应的项目数据';
                }

                // 获取验证规则
                const rule = ctx.service.constructionUnit.rule('add');
                ctx.validate(rule);
                ctx.request.body.pid = projectData.id;
                const result = await ctx.service.constructionUnit.save(ctx.request.body);
                if (!result) {
                    throw '保存单位失败';
                }

                this.setMessage('保存单位成功', this.messageType.SUCCESS);
                ctx.redirect('/' + ctx.controllerName + '/user/unit');
            } catch (error) {
                console.log(error);
                this.setMessage(error.toString(), this.messageType.ERROR);
                ctx.redirect(ctx.request.header.referer);
            }
        }

        /**
         * 项目设置 -- 单位编辑(Post)
         * @param ctx
         * @return {Promise<void>}
         */
        async userUnitSave(ctx) {
            const projectData = ctx.session.sessionProject;
            const responseData = {
                err: 0, msg: '', data: null,
            };
            try {
                // 验证数据
                if (projectData.id === undefined) {
                    throw '不存在对应的项目数据';
                }
                const data = JSON.parse(ctx.request.body.data);
                switch (data.type) {
                    case 'update':
                        const post_data = {
                            pid: projectData.id,
                            id: data.id,
                        };
                        post_data[data.val_name] = data.val;
                        if (data.name) post_data.name = data.name;
                        const result = await ctx.service.constructionUnit.save(post_data);
                        if (!result) {
                            throw '保存单位失败';
                        }
                        if (post_data.name) {
                            const accountList = await ctx.service.projectAccount.getAllDataByCondition({ where: { project_id: projectData.id, company: post_data.name } });
                            responseData.data = { account_num: accountList.length };
                        }
                        break;
                    case 'delete':
                        const accountList = await ctx.service.projectAccount.getAllDataByCondition({ where: { project_id: projectData.id, company: data.name } });
                        if (accountList.length > 0) {
                            throw '该单位下还存在账号，无法删除';
                        }
                        await ctx.service.constructionUnit.del(data.id);
                        break;
                    case 'del-sign':
                        const info = await ctx.service.constructionUnit.getDataById(data.id);
                        if (info.sign_path) {
                            await ctx.app.fujianOss.delete(ctx.app.config.fujianOssFolder + info.sign_path);
                        }
                        await ctx.service.constructionUnit.update({ sign_path: null }, { id: info.id });
                        break;
                    default:
                        break;
                }
                ctx.body = responseData;
            } catch (err) {
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }

        async userUnitUpload(ctx) {
            const responseData = {
                err: 0, msg: '', data: null,
            };
            try {
                const stream = await ctx.getFileStream();
                const create_time = Date.parse(new Date()) / 1000;
                const fileInfo = path.parse(stream.filename);
                const filepath = `app/public/upload/sign/unit/qianzhang_${create_time + fileInfo.ext}`;
                await ctx.app.fujianOss.put(ctx.app.config.fujianOssFolder + filepath, stream);
                await sendToWormhole(stream);
                const result = await ctx.service.constructionUnit.update({ sign_path: filepath }, { id: stream.fields.id });
                if (result) {
                    responseData.data = { sign_path: filepath };
                } else {
                    throw '添加数据库失败';
                }
            } catch (err) {
                this.log(err);
                responseData.err = 1;
                responseData.msg = err;
            }
            ctx.body = responseData;
        }

        /**
         * 项目设置 -- 账号启用和停用设置(Post)
         * @param ctx
         * @return {Promise<void>}
         */
        async userSwitch(ctx) {
            const responseData = {
                err: 0, msg: '', data: null,
            };
            try {
                // 获取项目数据
                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 data = JSON.parse(ctx.request.body.data);
                const result = await ctx.service.projectAccount.update(data, { id: data.id });
                if (!result) {
                    throw '提交数据失败';
                }
            } catch (err) {
                this.log(err);
                responseData.err = 1;
                responseData.msg = err;
            }
            ctx.body = responseData;
        }

        /**
         * 项目设置 -- 账号添加(Post)
         * @param ctx
         * @return {Promise<void>}
         */
        async addUser(ctx) {
            const projectData = ctx.session.sessionProject;
            try {
                // 验证数据
                if (projectData.id === undefined) {
                    throw '不存在对应的项目数据';
                }

                // 获取验证规则
                const rule = ctx.service.projectAccount.rule('add');
                ctx.validate(rule);
                // 判断新密码的强度
                const reg = /^(?![0-9]+$)(?![a-zA-Z]+$).{6,16}$/;
                if (!reg.test(ctx.request.body.password)) {
                    throw '请设置至少包含数字和字母的密码';
                }
                ctx.request.body.project_id = projectData.id;
                const result = await ctx.service.projectAccount.save(ctx.request.body);
                if (!result) {
                    throw '保存账号数据失败';
                }

                this.setMessage('保存账号数据成功', this.messageType.SUCCESS);
                ctx.redirect('/' + ctx.controllerName + '/user');
            } catch (error) {
                console.log(error);
                ctx.session.postError = error.toString();
                this.setMessage(error.toString(), this.messageType.ERROR);
                ctx.redirect(ctx.request.header.referer);
            }
        }

        /**
         * 项目设置 -- 账号编辑(Post)
         * @param ctx
         * @return {Promise<void>}
         */
        async updateUser(ctx) {
            const projectData = ctx.session.sessionProject;
            try {
                // 验证数据
                if (projectData.id === undefined) {
                    throw '不存在对应的项目数据';
                }

                // 获取验证规则
                const rule = ctx.service.projectAccount.rule('modify');
                ctx.validate(rule);

                const result = await ctx.service.projectAccount.save(ctx.request.body);
                if (!result) {
                    throw '保存账号数据失败';
                }

                this.setMessage('保存账号数据成功', this.messageType.SUCCESS);
                ctx.redirect(ctx.request.header.referer);
            } catch (error) {
                console.log(error);
                this.setMessage(error.toString(), this.messageType.ERROR);
                ctx.redirect(ctx.request.header.referer);
            }
        }

        async resetUserPassword(ctx) {
            try {
                // 获取项目数据
                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 accountId = parseInt(ctx.request.body.id);
                let password = ctx.request.body.reset_password;
                password = password.toString();
                const account = ctx.request.body.account !== undefined ? ctx.request.body.account : '';
                if (isNaN(accountId) || accountId <= 0 || password.length < 6) {
                    throw '参数错误';
                }
                // 判断新密码的强度
                const reg = /^(?![0-9]+$)(?![a-zA-Z]+$).{6,16}$/;
                if (!reg.test(password)) {
                    throw '请设置至少包含数字和字母的密码';
                }
                const result = await ctx.service.projectAccount.resetPassword(accountId, password, account);
                if (!result) {
                    throw '重置密码失败!';
                }
                this.setMessage('保存账号数据成功', this.messageType.SUCCESS);
                ctx.redirect(ctx.request.header.referer);
            } catch (error) {
                console.log(error);
                this.setMessage(error.toString(), this.messageType.ERROR);
                ctx.redirect(ctx.request.header.referer);
            }
        }

        /**
         * 项目设置 -- 账号权限编辑(Post)
         * @param ctx
         * @return {Promise<void>}
         */
        async permission(ctx) {
            const projectData = ctx.session.sessionProject;
            try {
                // 验证数据
                if (projectData.id === undefined) {
                    throw '不存在对应的项目数据';
                }

                const accountId = parseInt(ctx.request.body.id);
                const accountInfo = await ctx.service.projectAccount.getDataById(accountId);
                if (accountInfo === null) {
                    throw '不存在该客户';
                }

                const result = await ctx.service.projectAccount.permissionSave(accountId, ctx.request.body);
                if (!result) {
                    throw '修改权限失败!';
                }

                this.setMessage('保存账号数据成功', this.messageType.SUCCESS);
                ctx.redirect(ctx.request.header.referer);
            } catch (error) {
                console.log(error);
                this.setMessage(error.toString(), this.messageType.ERROR);
                ctx.redirect(ctx.request.header.referer);
            }
        }

        /**
         * 项目设置 -- 自定义标段分类(Get)
         *
         * @param ctx
         * @return {Promise<void>}
         */
        async category(ctx) {
            try {
                // 获取项目数据
                const projectId = ctx.session.sessionProject.id;
                await this._checkMenu(projectId);
                const projectData = await ctx.service.project.getDataById(projectId);
                if (projectData === null) {
                    throw '没有对应的项目数据';
                }
                if (ctx.session.sessionUser.is_admin === 0) {
                    throw '没有访问权限';
                }

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

        /**
         * 新增分类(Ajax)
         *
         * @param ctx
         * @return {Promise<void>}
         */
        async addCategory(ctx) {
            try {
                const projectId = ctx.session.sessionProject.id;
                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(projectId, 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 projectId = ctx.session.sessionProject.id;
                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({ pid: projectId, 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(data.id, data.updateValue);

                responseData.data.category = await ctx.service.category.getCategory(data.id);
                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 projectId = ctx.session.sessionProject.id;
                const responseData = {
                    err: 0, msg: '', data: null,
                };

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

                await ctx.service.category.deleteCategory(projectId, 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 projectId = ctx.session.sessionProject.id;
                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(projectId);
                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.projectAccount.defaultUpdate({id: ctx.session.sessionUser.accountId, self_category_level: data.self_category_level || ''});
                ctx.body = {
                    err: 0, msg: '', data: null,
                };
            } catch (err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '保存自定义分类失败');
            }
        }

        /** update porject info
         * @author wangfeng
         * @date 2018-10-12 15:48:05
         * @param ctx
         * @return {Promise<void>}
         */
        async updateinfo(ctx) {
            try {
                const projectId = ctx.params.id;
                const responseData = {
                    err: 0, msg: '', data: null,
                };
                const conditionData = {
                    id: projectId,
                };
                const data = ctx.request.body;
                const result = await ctx.service.project.update(data, conditionData);
                if (!result) {
                    throw '提交数据失败';
                }

                ctx.redirect('/setting/info');
            } catch (err) {
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }

        /**
         * 检测账户是否存在
         *
         * @param {Object} ctx -egg全局变量
         * @return {void}
         */
        async accountExist(ctx) {
            const projectData = ctx.session.sessionProject;
            const responseData = {
                err: 0, msg: '', data: null,
            };
            try {
                const data = JSON.parse(ctx.request.body.data);
                const account = data.account;
                if (projectData.id === undefined) {
                    throw '不存在对应项目';
                }
                responseData.data = await ctx.service.projectAccount.isAccountExist(account, projectData.id);
                ctx.body = responseData;
            } catch (error) {
                ctx.body = { err: 1, msg: error.toString(), data: null };
            }
        }

        /**
         * 显示设置(Get)
         * @param {Object} ctx -egg全局变量
         * @return {void}
         */
        async show(ctx) {
            try {
                // 获取项目数据
                const projectId = ctx.session.sessionProject.id;
                await this._checkMenu(projectId);
                const projectData = await ctx.service.project.getDataById(projectId);
                if (!projectData) {
                    throw '没有对应的项目数据';
                }
                if (ctx.session.sessionUser.is_admin === 0) {
                    throw '没有访问权限';
                }
                const showList = await ctx.service.settingShow.getList(projectData.page_path);
                const sjsRela = await ctx.service.project.getSjsRela(projectId);
                const renderData = { projectData, showList, sjsRela };
                await this.layout('setting/show.ejs', renderData);
            } catch (error) {
                this.log(error);
                ctx.redirect('/dashboard');
            }
        }

        /**
         * 更新显示设置列表
         * @param {Object} ctx -egg全局变量
         * @return {void}
         */
        async showListUpdate(ctx) {
            try {
                // 获取项目id
                const projectId = ctx.session.sessionProject.id;
                const { data } = ctx.request.body;
                const { id } = JSON.parse(data);
                const result = await ctx.service.settingShow.setDefaultLabel(id, projectId);
                const responseData = { err: 0, msg: '', data: result };
                ctx.body = responseData;
            } catch (error) {
                this.log(error);
                ctx.body = { err: 1, msg: error.toString(), data: null };
            }
        }

        async showSjsUpdate(ctx) {
            try {
                const projectId = ctx.session.sessionProject.id;
                const data = JSON.parse(ctx.request.body.data);
                const result = await ctx.service.project.updateSjsRela(projectId, data.sub, data.field, data.key, data.value);
                ctx.body = { err: 0, msg: '', data: result };
            } catch (err) {
                this.log(err);
                this.ajaxErrorBody(error, '保存数据失败');
            }
        }

        async logs(ctx) {
            try {
                // 获取项目数据
                const projectId = ctx.session.sessionProject.id;
                await this._checkMenu(projectId);
                const projectData = await ctx.service.project.getDataById(projectId);
                if (projectData === null) {
                    throw '没有对应的项目数据';
                }
                if (ctx.session.sessionUser.is_admin === 0) {
                    throw '没有访问权限';
                }
                const settingType = ctx.params.type ? parseInt(ctx.params.type) : 0;
                const logs = await ctx.service.projectLog.getLogs(projectId, settingType);
                const renderData = {
                    projectData,
                    officeList,
                    projectLog,
                    settingType,
                    logs,
                };
                await this.layout('setting/logs.ejs', renderData);
            } catch (error) {
                console.log(error);
                ctx.redirect('/dashboard');
            }
        }

        async fun(ctx) {
            try {
                const projectId = ctx.session.sessionProject.id;
                await this._checkMenu(projectId);
                const projectData = await ctx.service.project.getDataById(projectId);
                const funRela = await ctx.service.project.getFunRela(projectId);
                if (projectData === null) {
                    throw '没有对应的项目数据';
                }
                if (ctx.session.sessionUser.is_admin === 0) {
                    throw '没有访问权限';
                }
                const fun_set = await ctx.service.project.getFunSet(projectData.fun_set);
                console.log(fun_set);
                await this.layout('setting/fun.ejs', {
                    projectData,
                    funRela,
                    imType,
                    endMonth: funSet.endMonth,
                    funSet: fun_set,
                });
            } catch (error) {
                ctx.helper.log(error);
                ctx.redirect('/dashboard');
            }
        }

        /**
         * 保存功能设置相关
         * @param ctx
         * @returns {Promise<void>}
         */
        async updateFun(ctx) {
            try {
                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 data = JSON.parse(ctx.request.body.data);
                if (data) ctx.request.body = data;
                const rule = ctx.service.project.rule('fun');
                ctx.validate(rule);

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

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

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

                const tenders = await ctx.service.tender.getAllDataByCondition({ where: { project_id: projectId } });
                for (const t of tenders) {
                    t.measure_type_str = t.measure_type === measureType.tz.value ? measureType.tz.title : measureType.gcl.title;
                    const stages = await ctx.service.stage.getAllDataByCondition({ where: { tid: t.id } });
                    t.stage_count_str = `第${stages.length || 0}期`;
                    const user = await ctx.service.projectAccount.getAccountInfoById(t.user_id);
                    t.user_str = user.name + '-' + user.company;
                    t.show_time = stages.length > 0 ? stages[stages.length - 1].cache_time_r || stages[stages.length - 1].in_time : t.create_time;
                }
                await this.layout('setting/s2b.ejs', {
                    projectData,
                    tenders,
                })
            } catch (error) {
                ctx.helper.log(error);
                ctx.redirect('/dashboard');
            }
        }

        async s2bUpdate(ctx) {
            try {
                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 data = JSON.parse(ctx.request.body.data);
                if (!data.tid) throw '提交数据错误';

                const updateData = {};
                if (data.gxby_limit !== undefined) updateData.s2b_gxby_limit = data.gxby_limit;
                if (data.gxby_check !== undefined) updateData.s2b_gxby_check = data.gxby_check;
                if (data.dagl_limit !== undefined) updateData.s2b_dagl_limit = data.dagl_limit;
                if (data.dagl_check !== undefined) updateData.s2b_dagl_check = data.dagl_check;
                await ctx.service.tender.saveApiRela(data.tid, updateData);
                ctx.body = { err: 0, msg: '', data: null };
            } catch (error) {
                ctx.helper.log(error);
                this.ajaxErrorBody(error, '保存数据失败');
            }
        }

        async s2bUpdateStatus(ctx) {
            try {
                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 data = JSON.parse(ctx.request.body.data);
                if (!data.type || data.status === undefined) throw '提交数据错误';

                const responseData = { err: 0, msg: '', data: null };
                switch (data.type) {
                    case 'gxby':
                        responseData.data = await this.ctx.service.s2bProj.updateGxbyStatus(projectId, data.status, data.limit, data.ratio);
                        break;
                    case 'dagl':
                        responseData.data = await this.ctx.service.s2bProj.updateDaglStatus(projectId, data.status, data.limit, data.ratio);
                        break;
                    default: throw '提交数据错误';
                }
                ctx.body = responseData;
            } catch (error) {
                console.log(error);
                ctx.helper.log(error);
                this.ajaxErrorBody(error, '保存数据失败');
            }
        }

        async dataCollect(ctx) {
            try {
                const projectId = ctx.session.sessionProject.id;
                await this._checkMenu(projectId);
                const projectData = await ctx.service.project.getDataById(projectId);
                if (projectData === null) throw '没有对应的项目数据';
                projectData.data_collect_pages = projectData.data_collect_pages ? projectData.data_collect_pages.split(',') : [];
                if (ctx.session.sessionUser.is_admin === 0) throw '没有访问权限';
                const dataCollectAudits = await ctx.service.datacollectAudit.getList(projectId);
                // 获取所有项目参与者
                const accountList = await ctx.service.projectAccount.getAllDataByCondition({
                    where: { project_id: ctx.session.sessionProject.id, enable: 1 },
                    columns: ['id', 'name', 'company', 'role', 'enable', 'is_admin', 'account_group', 'mobile'],
                });
                const accountGroupList = accountGroup.map((item, idx) => {
                    const groupList = accountList.filter(item => item.account_group === idx);
                    return { groupName: item, groupList };
                });
                const categoryData = await ctx.service.category.getAllCategory(ctx.session.sessionProject.id);
                const tenders = await ctx.service.tender.getList('', null, 1);
                const dcTenders = await ctx.service.datacollectTender.getList(projectId);
                await this.layout('setting/datacollect.ejs', {
                    projectData,
                    dataCollectAudits,
                    accountList,
                    accountGroup: accountGroupList,
                    categoryData,
                    tenders,
                    dcTenders,
                }, 'setting/datacollect_modal.ejs');
            } catch (error) {
                ctx.helper.log(error);
                ctx.redirect('/dashboard');
            }
        }

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

                const data = JSON.parse(ctx.request.body.data);
                if (!data.type) {
                    throw '提交数据错误';
                }
                switch (data.type) {
                    case 'show':
                        responseData.data = await ctx.service.project.update({ data_collect: data.data_collect, data_collect_pages: data.data_collect_pages.join(',') }, { id: projectId });
                        ctx.session.sessionProject.dataCollect = data.data_collect;
                        ctx.session.sessionProject.showDataCollect = data.data_collect ? 1 : 0;
                        break;
                    case 'add-audit':
                        // 判断该用户的组是否已加入到表中，已加入则提示无需添加
                        const auditInfo = await ctx.service.datacollectAudit.getDataByCondition({ pid: projectId, uid: data.id });
                        if (auditInfo) {
                            throw '该用户已存在权限中，无需重复添加';
                        }
                        const accountInfo = await ctx.service.projectAccount.getDataById(data.id);
                        const groupInfo = await ctx.service.datacollectAudit.getGroupInfo(projectId, accountInfo.account_group);
                        if (groupInfo) {
                            throw '该用户所在单位已存在权限中，无需单独添加';
                        }
                        await ctx.service.datacollectAudit.saveAudit(projectId, accountInfo.account_group, data.id);
                        responseData.data = await ctx.service.datacollectAudit.getList(projectId);
                        break;
                    case 'add-group':
                        const groupInfo2 = await ctx.service.datacollectAudit.getGroupInfo(projectId, data.id);
                        if (groupInfo2) {
                            throw '该单位已存在权限中，无需重复添加';
                        }
                        await ctx.service.datacollectAudit.saveGroup(projectId, data.id);
                        responseData.data = await ctx.service.datacollectAudit.getList(projectId);
                        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(projectId);
                        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(projectId);
                        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(projectId);
                        }
                        await ctx.service.datacollectTender.updateList(projectId, data.tids);
                        responseData.data = {
                            dcTenders: await ctx.service.datacollectTender.getList(projectId),
                            addDatacollect: ctx.session.sessionProject.page_show.addDataCollect,
                        };
                        break;
                    default: throw '参数有误';
                }
                ctx.body = responseData;
            } catch (err) {
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }
    }

    return SettingController;
};