Calculation/app/controller/payment_controller.js

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

module.exports = app => {

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

                const renderData = {
                    auditPermission,
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.payment.index),
                };
                if (ctx.session.sessionUser.is_admin) {
                    const projectId = ctx.session.sessionProject.id;
                    const permissionAudits = await ctx.service.paymentPermissionAudit.getList(projectId);
                    // 获取所有项目参与者
                    const accountList = await ctx.service.projectAccount.getAllDataByCondition({
                        where: { project_id: ctx.session.sessionProject.id, enable: 1 },
                        columns: ['id', 'name', 'company', 'role', 'enable', 'is_admin', 'account_group', 'mobile'],
                    });
                    const accountGroupList = accountGroup.map((item, idx) => {
                        const groupList = accountList.filter(item => item.account_group === idx);
                        return { groupName: item, groupList };
                    });
                    renderData.permissionAudits = permissionAudits;
                    renderData.accountList = accountList;
                    renderData.accountGroup = accountGroupList;
                }
                await this.layout('payment/index.ejs', renderData, 'payment/modal.ejs');
            } catch (err) {
                console.log(err);
                this.log(err);
                ctx.redirect(this.menu.menu.dashboard.url);
            }
        }

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

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

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

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

                const data = JSON.parse(ctx.request.body.data);
                if (!data.type) {
                    throw '提交数据错误';
                }
                let type = '';
                switch (data.type) {
                    case 'add-folder':
                        if (!auditPermission.folder) {
                            throw '没有权限新建目录';
                        }
                        await ctx.service.paymentFolder.addFolder(projectId, ctx.session.sessionUser.accountId, data.parentId, data.name);
                        break;
                    case 'add-tender':
                        if (!auditPermission.tender) {
                            throw '没有权限新建标段';
                        }
                        await ctx.service.paymentTender.addTender(projectId, ctx.session.sessionUser.accountId, data.folderId, data.name);
                        break;
                    case 'edit-name':
                        type = data.postData.type;
                        const updateData = {
                            name: data.postData.name,
                        };
                        const conditionData = {
                            id: data.postData.id,
                        };
                        if (type === 'tender') {
                            await ctx.service.paymentTender.update(updateData, conditionData);
                        } else {
                            await ctx.service.paymentFolder.update(updateData, conditionData);
                        }
                        break;
                    case 'del':
                        type = data.postData.type;
                        if (type === 'tender') {
                            await ctx.service.paymentTender.deleteTender(data.postData.id);
                        } else {
                            await ctx.service.paymentFolder.deleteFolder(data.postData.id);
                        }
                        break;
                    default: throw '参数有误';
                }
                // 先获取你创建的标段及参与的标段
                const tenderList = await ctx.service.paymentTender.getList(ctx.session.sessionUser.accountId);
                // 获取你创建的目录及对应目录下的所有目录
                const folderList = await ctx.service.paymentFolder.getList(ctx.session.sessionUser.accountId, tenderList);
                responseData.data.folderList = folderList;
                responseData.data.tenderList = tenderList;
                ctx.body = responseData;
            } catch (err) {
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }
        /**
         * 支付表单页面
         *
         * @param {Object} ctx - egg全局页面
         * @return {void}
         */
        async detail(ctx) {
            try {
                const id = parseInt(ctx.params.did);
                if (!id) throw '参数错误';
                const info = await ctx.service.paymentDetail.getDataById(id);
                const rptTpl = await ctx.service.rptTpl.getDataById(3029);
                const pageRst = ctx.service.jpcReport.getAllPreviewPagesCommon(rptTpl, 'A4');
                const renderData = {
                    info,
                    pageRst,
                };
                await this.layout('payment/detail.ejs', renderData);
            } catch (err) {
                console.log(err);
                this.log(err);
                ctx.redirect(this.menu.menu.dashboard.url);
            }
        }

        async process(ctx) {
            try {
                const auditPermission = await this.ctx.service.paymentPermissionAudit.getOnePermission(ctx.session.sessionUser.is_admin, ctx.session.sessionUser.accountId);
                if (!auditPermission || !auditPermission.process) {
                    throw '权限不足';
                }
                // 获取报表表单列表
                const rptProject = await ctx.service.rptTreeNode.getDataByCondition({ name: '01.支付审批报表' });
                let rptProjectList = rptProject.items ? JSON.parse(rptProject.items) : [];
                // const rptTplList = [];
                // if (rptProjectList.length > 0) {
                //     const params = { tender_id: id };
                //     for (const rpt of rptProjectList) {
                //         const rptTpl = await ctx.service.rptTpl.getDataById(rpt.ID);
                //         // 根据模板ID获取报表JSON
                //         const pageRst = ctx.service.jpcReport.getAllPreviewPagesCommon(rptTpl, 'A4');
                //         console.log(pageRst.items[0]);
                //         // return;
                //         rptTplList.push(pageRst.items[0]);
                //     }
                // }
                let tenderRptList = await ctx.service.paymentTenderRpt.getProcessList(ctx.tender.id, rptProjectList);
                [tenderRptList, rptProjectList] = await ctx.service.paymentTenderRpt.checkAndUpdateList(tenderRptList, rptProjectList);
                // for (const tr of tenderRptList) {
                //     if (tr.status === shenpiConst.sp_status.gdspl) {
                //         tr.auditList = await ctx.service.paymentShenpiAudit.getAuditList(ctx.tender.id, tr.id, tr.sp_status);
                //     } else if (tr.status === shenpiConst.sp_status.gdzs) {
                //         tr.audit = await ctx.service.paymentShenpiAudit.getAudit(ctx.tender.id, tr.id, tr.sp_status);
                //     }
                // }
                // 获取所有项目参与者
                const accountList = await ctx.service.projectAccount.getAllDataByCondition({
                    where: { project_id: ctx.session.sessionProject.id, enable: 1 },
                    columns: ['id', 'name', 'company', 'role', 'enable', 'is_admin', 'account_group', 'mobile'],
                });
                const accountGroupList = accountGroup.map((item, idx) => {
                    const groupList = accountList.filter(item => item.account_group === idx);
                    return { groupName: item, groupList };
                });
                const renderData = {
                    tender: ctx.tender,
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.payment.process),
                    rptProjectList,
                    tenderRptList,
                    shenpi: shenpiConst,
                    accountList,
                    accountGroup: accountGroupList,
                };
                await this.layout('payment/process.ejs', renderData, 'payment/process_modal.ejs');
            } catch (err) {
                console.log(err);
                this.log(err);
                ctx.redirect(this.request.headers.referer ? this.request.headers.referer : this.menu.menu.dashboard.url);
            }
        }

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

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

        async rptList(ctx) {

        }
    }

    return PaymentController;
};