Calculation/app/controller/sub_proj_controller.js

'use strict';

/**
 *
 *
 * @author Mai
 * @date
 * @version
 */
const auditConst = require('../const/audit');
const accountGroup = require('../const/account_group').group;
module.exports = app => {
    class SubProjController extends app.BaseController {

        /**
         * 概算投资
         *
         * @param ctx
         * @returns {Promise<void>}
         */
        async index(ctx) {
            try {
                if (!ctx.session.sessionProject.showSubProj) {
                    throw '该功能已关闭或无法查看';
                }
                const renderData = {
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.subProject.list),
                    auditConst,
                };
                renderData.budgetStd = await ctx.service.budgetStd.getDataByProjectId(ctx.session.sessionProject.id);
                renderData.projectList = await ctx.service.subProject.getSubProject(ctx.session.sessionProject.id, ctx.session.sessionUser.accountId, ctx.session.sessionUser.is_admin);
                renderData.tenderList = await ctx.service.tender.getList4Select('stage');
                const accountList = await ctx.service.projectAccount.getAllDataByCondition({
                    where: { project_id: ctx.session.sessionProject.id, enable: 1 },
                    columns: ['id', 'name', 'company', 'role', 'enable', 'is_admin', 'account_group', 'mobile'],
                });
                renderData.accountList = accountList;
                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 };
                });
                renderData.permissionConst = ctx.service.subProjPermission.PermissionConst;
                renderData.categoryData = await this.ctx.service.category.getAllCategory(this.ctx.session.sessionProject.id);
                renderData.companys = await this.ctx.service.constructionUnit.getAllDataByCondition({ where: { pid: ctx.session.sessionProject.id } });
                await this.layout('sub_proj/index.ejs', renderData, 'sub_proj/modal.ejs');
            } catch (err) {
                ctx.log(err);
                ctx.session.postError = err.toString();
                ctx.redirect(this.menu.menu.dashboard.url);
            }
        }

        async addFolder(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                if (!data.name || data.name.length > 100) throw '文件夹名称有误';
                const result = await ctx.service.subProject.addFolder(data);
                ctx.body = { err: 0, msg: '', data: result };
            } catch (err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '新建文件夹失败');
            }
        }

        async addProj(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                if (!data.name || data.name.length > 100) throw '项目名称有误';
                const result = await ctx.service.subProject.addSubProject(data);
                ctx.body = { err: 0, msg: '', data: result };
            } catch (err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '新建项目失败');
            }
        }

        async dragTo(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                if (!data.drag_id || !data.drop_id) throw '提交数据错误';
                const result = await ctx.service.subProject.dragTo(data);
                ctx.body = { err: 0, msg: '', data: result };
            } catch (err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '调整所属文件夹失败');
            }
        }

        async move(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                if (!data.id || !data.type) throw '提交数据错误';
                const result = await ctx.service.subProject.move(data);
                ctx.body = { err: 0, msg: '', data: result };
            } catch (err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '调整所属文件夹失败');
            }
        }

        async del(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                if (!data.id) throw '参数有误';
                const result = await ctx.service.subProject.del(data.id);
                ctx.body = { err: 0, msg: '', data: result };
            } catch(err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '删除项目失败');
            }
        }

        async save(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                if (!data.id) throw '参数有误';
                let result = null;
                if (data.name !== undefined) {
                    if (!data.name || data.name.length > 100) throw '项目名称有误';
                    result = await ctx.service.subProject.save({ id: data.id, name: data.name });
                } else if (data.rela_tender !== undefined) {
                    result = await ctx.service.subProject.setRelaTender({ id: data.id, rela_tender: data.rela_tender });
                } else if (data.std_id !== undefined) {
                    result = await ctx.service.subProject.setBudgetStd({ id: data.id, std_id: data.std_id });
                } else if (data.management !== undefined) {
                    result = await ctx.service.subProject.setManagement({ id: data.id, management: data.management });
                }
                ctx.body = { err: 0, msg: '', data: { update: [result] } };
            } catch(err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '保存数据失败');
            }
        }

        async refresh(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                if (!data.id) throw '参数有误';
                const result = await ctx.service.subProject.refreshManagementPermission({ id: data.id });
                ctx.body = { err: 0, msg: '', data: result };
            } catch(err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '保存数据失败');
            }
        }

        async rela(ctx) {
            try {
                const id = ctx.query.id;
                const projectList = await ctx.service.subProject.getSubProject(this.ctx.session.sessionProject.id, this.ctx.session.sessionUser.accountId, true);
                const otherProj = projectList.filter(x => { return x.id !== id || !x.rela_tender || x.is_folder });
                const _ = ctx.helper._;
                const otherRela = _.map(_.map(otherProj, 'rela_tender').join(',').split(','), _.toInteger);
                const tenderList = await ctx.service.tender.getList4Select('stage');
                ctx.body = {
                    err: 0,
                    msg: '',
                    data: tenderList.filter(x => { return otherRela.indexOf(x.id) === -1})
                        .map(y => { return {id: y.id, name: y.name, lastStageOrder: y.lastStage.order, lastStageStatus: auditConst.stage.statusString[y.lastStage.status], category: y.category}}),
                };
            } catch (err) {
                ctx.log(err);
                ctx.postError(err, '获取数据失败');
            }
        }

        async saveRela(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                if (!data.id || !data.rela_tender) throw '参数有误';
                const permission = ctx.session.sessionUser.is_admin
                    ? ctx.service.subProjPermission.adminPermission
                    : await ctx.service.subProjPermission.getSubProjectUserPermission(data.id, ctx.session.sessionUser.accountId);
                if (!permission || permission.manage_permission.indexOf(ctx.service.subProjPermission.PermissionConst.manage.rela.value) < 0) throw '您无权进行该操作';
                const result = await ctx.service.subProject.setRelaTender({ id: data.id, rela_tender: data.rela_tender });
                ctx.body = { err: 0, msg: '', data: { update: [result] } };
            } catch(err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '保存数据失败');
            }
        }

        async member(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                const member = await ctx.service.subProjPermission.getPermission(data.id);
                ctx.body = { err: 0, msg: '', data: member };
            } catch (err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '查询项目成员失败');
            }
        }

        async memberSave(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                if (!data.id) throw '参数有误';
                await ctx.service.subProjPermission.savePermission(data.id, data.member);
                ctx.body = { err: 0, msg: '', data: '' };
            } catch (err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '保存数据失败');
            }
        }

        async info(ctx) {
            try {
                const info = await this.ctx.service.subProjInfo.getInfo(ctx.subProject.id);
                const renderData = {
                    info,
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.subProject.info),
                };
                await this.layout('sub_proj/info.ejs', renderData);
            } catch (err) {
                ctx.log(err);
            }
        }

        async dataIndex(ctx) {
            try {
                const info = await this.ctx.service.subProjInfo.getInfo(ctx.subProject.id);
                const renderData = {
                    info,
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.subProject.data),
                };
                await this.layout('sub_proj/data_index.ejs', renderData);
            } catch (err) {
                ctx.log(err);
            }
        }

        async saveInfo(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                const result = await ctx.service.subProjInfo.saveInfo(ctx.subProject.id, data);
                ctx.body = { err: 0, msg: '', data: result };
            } catch(err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '保存数据失败');
            }
        }
    }

    return SubProjController;
};