Calculation/app/controller/tender_controller.js

'use strict';

/**
 * 标段管理控制器
 *
 * @author CaiAoLin
 * @date 2018/2/5
 * @version
 */

const tenderConst = require('../const/tender');
const codeRuleConst = require('../const/code_rule');
const settingConst = require('../const/setting.js');
const tenderMenu = require('../../config/menu').tenderMenu;

module.exports = app => {

    class TenderController extends app.BaseController {

        /**
         * 构造函数
         *
         * @param {Object} ctx - egg全局变量
         * @return {void}
         */
        constructor(ctx) {
            super(ctx);
            ctx.showProject = true;
            ctx.showTitle = true;
        }

        async _list(view, setting, modal = '') {
            try {
                const tenderList = await this.ctx.service.tender.getList();
                const categoryData = await this.ctx.service.category.getAllCategory(this.ctx.session.sessionProject.id);

                const renderData = {
                    tenderList,
                    tenderConst,
                    settingConst,
                    categoryData,
                    tableColSetting: setting,
                    measureType: tenderConst.measureType,
                };
                await this.layout(view, renderData, modal);
            } catch(err) {
                this.log(err);
                this.ctx.redirect('/dashboard');
            }
        }

        /**
         * 标段概况(Get)
         *
         * @param {object} ctx - egg全局变量
         * @return {void}
         */
        async listInfo(ctx) {
            await this._list('tender/index.ejs', tenderConst.infoTableCol, 'tender/modal.ejs');
        }

        /**
         * 计量进度(Get)
         *
         * @param ctx
         * @returns {Promise<void>}
         */
        async listProgress(ctx) {
            await this._list('tender/progress.ejs', tenderConst.progressTableCol);
        }

        /**
         * 标段管理(Get)
         *
         * @param ctx
         * @returns {Promise<void>}
         */
        async listManage(ctx) {
            await this._list('tender/manage.ejs', tenderConst.manageTableCol, 'tender/manage_modal.ejs');
        }

        /**
         * 新增标段(Ajax)
         *
         * @param ctx
         * @returns {Promise<void>}
         */
        async addTender(ctx) {
            try {
                const responseData = {
                    err: 0, msg: '', data: null,
                };

                const data = JSON.parse(ctx.request.body.data);
                if (!data.name || data.name === '') {
                    throw '标段信息不完整';
                }

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

        /**
         * 编辑标段(Ajax)
         *
         * @param ctx
         * @returns {Promise<void>}
         */
        async updateTender(ctx) {

        }

        /**
         * 删除标段(Ajax)
         *
         * @param ctx
         * @returns {Promise<void>}
         */
        async deleteTender(ctx) {

        }

        /**
         * 标段概况(Get)
         *
         * @param ctx
         * @returns {Promise<void>}
         */
        async tenderInfo(ctx) {
            try {
                const tenderId = ctx.params.id;
                const renderData = await this.getCommonRenderData(ctx);
                if (!renderData.tender.measure_type) {
                    throw '请先选择计量模式';
                }
                renderData.tenderInfo = await ctx.service.tenderInfo.getTenderInfo(tenderId);
                await this.layout('tender/detail.ejs', renderData);
            } catch (error) {
                this.log(error);
                this.ctx.redirect('/list');
            }
        }

        /**
         * 保存标段属性等(Ajax)
         *
         * @param ctx
         * @returns {Promise<void>}
         */
        async saveTenderInfo(ctx) {
            try {
                const tenderId = ctx.params.id;
                const data = JSON.parse(ctx.request.body.data);
                await ctx.service.tenderInfo.saveTenderInfo(tenderId, data);
                ctx.body = {err: 0, msg: '', data: data};
            } catch(err) {
                this.log(err);
                ctx.body = {err: 1, msg: err.toString(), data: null};
            }
        }

        /**
         * 设置标段计量类型并调整到标段概况(Get)
         *
         * @param ctx
         * @returns {Promise<void>}
         */
        async tenderType(ctx) {
            try {
                const tenderId = ctx.params.id, type = ctx.params.type;
                const tender = await ctx.service.tender.getTender(tenderId);
                if (!tender.measure_type) {
                    await ctx.service.tender.update({measure_type: type}, {id: tenderId});
                }
                ctx.redirect('/tender/' + tenderId);
            } catch(error) {
                this.log(error);
                ctx.redirect('/list');
            }
        }

        /**
         * 添加标段操作
         *
         * @param {Object} ctx - egg全局变量
         * @return {void}
         */
        async add(ctx) {
            try {
                const rule = ctx.service.tender.rule('add');
                ctx.helper.validate(rule);

                const result = ctx.service.tender.add(ctx.request.body);
                if (!result) {
                    throw '新增标段失败';
                }
            } catch (error) {
                this.log(error);
                this.setMessage(error.toString(), this.messageType.ERROR);
            }

            ctx.redirect(ctx.request.header.referer);
        }

        /**
         * 切换标段 --》 暂时废弃，不存在此功能
         *
         * @param {Object} ctx - egg全局变量
         * @return {void}
         */
        async switchTender(ctx) {
            let tenderId = ctx.params.tenderId;
            tenderId = parseInt(tenderId);
            try{
                if(isNaN(tenderId) || tenderId <= 0) {
                    throw '参数错误';
                }
                const result = await ctx.service.tender.switchTender(tenderId);
                if (!result) {
                    throw '切换标段失败!';
                }
            } catch (error) {
                this.setMessage(error.toString(), this.messageType.ERROR);
            }
            ctx.redirect(ctx.request.header.referer);
        }

        /**
         * 保存标段操作
         *
         * @param {Object} ctx - egg全局变量
         * @return {void}
         */
        async save(ctx) {
            let id = ctx.request.body.tenderId;
            id = parseInt(id);

            try {
                if (isNaN(id) || id < 0) {
                    throw '参数错误';
                }
                // 获取数据规则
                const rule = ctx.service.tender.rule('save');
                ctx.validate(rule);

                const result = await ctx.service.tender.save(ctx.request.body, id);

                if (!result) {
                    throw '保存标段数据失败';
                }

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

        /**
         * 删除标段
         *
         * @param {Object} ctx -egg全局变量
         * @return {void}
         */
        async delete(ctx) {
            let id = ctx.request.body.tenderId;
            id = parseInt(id);

            try {
                if (isNaN(id) || id <= 0) {
                    throw '参数错误';
                }
                const result = ctx.service.tender.deleteTenderById(id);

                if (!result) {
                    throw '删除标段失败';
                }

                this.setMessage('删除标段成功', this.messageType.SUCCESS);
            } catch (error) {
                this.setMessage(error.toString(), this.messageType.ERROR);
            }

            ctx.redirect(ctx.request.header.referer);
        }

        async rule(ctx) {
            const responseData = {
                err: 0,
                msg: '',
                data: {},
            };
            try {
                const tenderId = ctx.session.sessionUser.tenderId;
                if (!tenderId) {
                    throw '当前未打开标段';
                }
                const data = JSON.parse(ctx.request.body.data);
                if (!data.rule || !codeRuleConst.ruleField[data.rule]) {
                    throw '参数错误';
                }

                const updateData = {
                    id: tenderId,
                };
                updateData[codeRuleConst.ruleField[data.rule]] = data.data;

                const result = await ctx.service.tender.db.update(ctx.service.tender.tableName, updateData);
                if (result.affectedRows !== 1) {
                    throw '更新规则失败';
                }
            } catch (err) {
                this.log(err);
                responseData.err = 1;
                responseData.msg = err.toString();
            }

            ctx.body = responseData;
        }
    }

    return TenderController;
};