ConstructionOperation/modules/users/controllers/compilation_controller.js

/**
 * 编办控制控制器
 *
 * @author CaiAoLin
 * @date 2017/7/28
 * @compilation
 */
import BaseController from "../../common/base/base_controller";
import CompilationModel from "../models/compilation_model";
import STDRationLibMapModel from "../../common/std/std_ration_lib_map_model";
import STDBillLibListsModel from "../../common/std/std_bills_lib_lists_model";
import STDGLJLibMapModel from "../../common/std/std_glj_lib_map_model";
import STDFeeRateLibsModel from "../../common/std/std_fee_rate_libs_model";
import {default as EngineeringConst, List as EngineeringList} from "../../common/const/engineering";
import BillsTemplateModel from "../models/bills_template_model";
import {default as BillsFixedFlagConst, List as BillsFixedFlagList} from "../../common/const/bills_fixed.js";
import EngineeringLibModel from "../models/engineering_lib_model";

class CompilationController extends BaseController {

    /**
     * 编办管理控制页面
     *
     * @param {object} request
     * @param {object} response
     * @return {void}
     */
    async index(request, response) {
        let id = request.query.id;

        let compilationList = [];
        let selectedCompilation = {};
        try {
            let compilationModel = new CompilationModel();
            compilationList = await compilationModel.getCompilationList();

            if (compilationList.length <= 0) {
                throw '没有数据';
            }
            // 循环查找数据
            for (let tmp of compilationList) {
                if (tmp._id.toString() === id) {
                    selectedCompilation = tmp;
                    break;
                }
            }

            selectedCompilation = Object.keys(selectedCompilation).length <= 0 ? compilationList[0] : selectedCompilation;
            request.session.selectedCompilation = selectedCompilation;

        } catch (error) {
            console.log(error);
        }

        let renderData = {
            id: id,
            compilationList: compilationList,
            selectedCompilation: selectedCompilation,
            layout: 'users/views/layout/layout'
        };

        response.render('users/views/compilation/index', renderData);
    }

    /**
     * 新增计价页面
     *
     * @param {object} request
     * @param {object} response
     * @return {void}
     */
    async addValuation(request, response) {
        let name = request.body.name;
        let id = request.body.id;
        let section = request.body.section;

        let responseData = {
            err: 0,
            msg: ''
        };
        try {
            if (id === undefined || id === '') {
                throw '参数错误';
            }

            let insertData = {
                name: name,
            };

            let compilationModel = new CompilationModel();
            let result = await compilationModel.addValuation(id, section, insertData);

            if (!result) {
                throw '新增计价规则失败';
            }
        } catch (error) {
            console.log(error);
            responseData.err = 1;
            responseData.msg = error;
        }

        response.json(responseData);
    }

    /**
     * 修改计价规则页面
     *
     * @param {object} request
     * @param {object} response
     * @return {void}
     */
    async editValuation(request, response) {
        let selectedCompilation = request.session.selectedCompilation;
        let valuationId = request.params.id;
        let section = request.params.section;

        let compilationList = [];
        let valuationData = {};
        let valuationList = {};
        try {
            let compilationModel = new CompilationModel();
            compilationList = await compilationModel.getCompilationList();

            // 获取对应的计价规则数据
            [valuationData, valuationList] = await compilationModel.getValuation(selectedCompilation._id, valuationId, section);
            if (Object.keys(valuationData).length <= 0) {
                throw '不存在数据';
            }

        } catch (error) {
            console.log(error);
        }

        let renderData = {
            compilationList: compilationList,
            engineeringList: EngineeringList,
            selectedCompilation: selectedCompilation,
            valuationData: valuationData,
            valuationList: valuationList,
            valuationId: valuationId,
            section: section,
            layout: 'users/views/layout/layout'
        };
        response.render('users/views/compilation/add', renderData);
    }

    /**
     * 编辑工程专业页面
     *
     * @param {object} request
     * @param {object} response
     * @return {void}
     */
    async editEngineering(request, response) {
        let engineering = parseInt(request.params.engineering);
        let valuationId = request.params.id;
        let section = request.params.section;
        let selectedCompilation = request.session.selectedCompilation;

        // 获取当前工程专业名称
        let engineeringInfo = {
            id: engineering,
            name: ''
        };
        for(let tmp of EngineeringList) {
            if (tmp.value === engineering) {
                engineeringInfo.name = tmp.name;
                break;
            }
        }

        let compilationList = [];
        let billList = [];
        let rationList = [];
        let gljList = [];
        let feeRateList = [];
        let libData = {};
        let billsTemplateData = [];
        let valuationData = {};
        let valuationList = {};
        try {
            let compilationModel = new CompilationModel();
            compilationList = await compilationModel.getCompilationList();

            // 获取标准清单
            let stdBillLibListsModel = new STDBillLibListsModel();
            billList = await stdBillLibListsModel.getBillList(selectedCompilation._id);

            // 获取定额库
            let stdRationLibMapModel = new STDRationLibMapModel();
            rationList = await stdRationLibMapModel.getRationLib(selectedCompilation._id);

            // 获取工料机库
            let stdGLJLibMapModel = new STDGLJLibMapModel();
            gljList = await stdGLJLibMapModel.getGLJLibList(selectedCompilation._id);

            // 获取费率库
            let stdFeeRateLibsModel = new STDFeeRateLibsModel();
            feeRateList = await stdFeeRateLibsModel.getFeeRateList();

            // 获取对应的计价规则数据
            [valuationData, valuationList] = await compilationModel.getValuation(selectedCompilation._id, valuationId, section);
            if (Object.keys(valuationData).length <= 0) {
                throw '不存在数据';
            }

            // 获取对应专业工程下的标准库数据
            let engineeringLibModel = new EngineeringLibModel();
            libData = await engineeringLibModel.getLib(valuationData.engineering_list, engineering);

            // 获取清单模板数据
            let billsTemplateModel = new BillsTemplateModel();
            billsTemplateData = await billsTemplateModel.getTemplateData(valuationId);

        } catch (error) {
            console.log(error);
        }

        let renderData = {
            section: section,
            valuationId: valuationId,
            engineeringInfo: engineeringInfo,
            compilationList: compilationList,
            selectedCompilation: selectedCompilation,
            libData: libData,
            billList: JSON.stringify(billList),
            rationList: JSON.stringify(rationList),
            gljList: JSON.stringify(gljList),
            feeRateList: JSON.stringify(feeRateList),
            billsTemplateData: JSON.stringify(billsTemplateData),
            mainTreeCol: JSON.stringify(valuationData.main_tree_col),
            layout: 'users/views/layout/layout'
        };
        response.render('users/views/compilation/engineering', renderData);
    }

    /**
     * 保存工程专业标准库
     *
     * @param {object} request
     * @param {object} response
     * @return {void}
     */
    async saveEngineering(request, response) {
        let valuationId = request.body.id;

        try {
            if (valuationId === '') {
                throw 'id参数错误';
            }

            // 先存入工程专业标准库表
            let engineeringLibModel = new EngineeringLibModel();
            let result = engineeringLibModel.addLib(valuationId, request.body);

            if (!result) {
                throw '保存失败';
            }

        } catch (error) {
            console.log(error);
        }

        response.redirect(request.headers.referer);
    }

    /**
     * 保存计价规则
     *
     * @param {object} request
     * @param {object} response
     * @return {void}
     */
    async saveValuation(request, response) {
        let valuationId = request.body.id;
        try {
            if (valuationId === '') {
                throw 'id参数错误';
            }

            let compilationModel = new CompilationModel();
            let result = await compilationModel.saveValuation(valuationId, request.body);

            if (!result) {
                throw '保存失败';
            }

        } catch (error) {
            console.log(error);
        }

        response.redirect(request.headers.referer);
    }

    /**
     * 删除计价规则
     *
     * @param {object} request
     * @param {object} response
     * @return {void}
     */
    async deleteValuation(request, response) {
        let id = request.params.id;
        let section = request.params.section;
        let selectedCompilation = request.session.selectedCompilation;

        try {
            if (id === undefined || id === '' || section === undefined || section === '') {
                throw '参数错误';
            }

            let compilationModel = new CompilationModel();
            let result = compilationModel.deleteValuation(selectedCompilation._id, id, section);

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

        } catch (error) {
            console.log(error);
        }

        response.redirect(request.headers.referer);
    }

    /**
     * 快速切换启用/禁用
     *
     * @param {object} request
     * @param {object} response
     * @return {void}
     */
    async enableSwitch(request, response) {
        let id = request.body.id;
        let section = request.params.section;
        let enable = request.body.enable;

        let responseData = {
            err: 0,
            msg: ''
        };
        try {
            let compilationModel = new CompilationModel();
            let result = await compilationModel.switchEnable(id, section, enable);

            if (!result) {
                throw '新增编办失败';
            }
        } catch (error) {
            console.log(error);
            responseData.err = 1;
            responseData.msg = error;
        }

        response.json(responseData);
    }

    /**
     * 发布/取消编办
     *
     * @param {object} request
     * @param {object} response
     * @return {void}
     */
    async release(request, response) {
        let id = request.body.id;
        let release = request.body.status;
        release = parseInt(release);

        let responseData = {
            err: 0,
            msg: ''
        };
        try {
            let compilationModel = new CompilationModel();
            let result = await compilationModel.release(id, release);

            if (!result) {
                throw '发布编办失败';
            }
        } catch (error) {
            console.log(error);
            responseData.err = 1;
            responseData.msg = error;
        }

        response.json(responseData);
    }

    /**
     * 新增编办操作
     *
     * @param {object} request
     * @param {object} response
     * @return {void}
     */
    async addCompilation(request, response) {
        let name = request.body.name;
        let responseData = {
            err: 0,
            msg: ''
        };
        try {
            let sessionManager = request.session.managerData;
            let insertData = {
                name: name,
                creator: sessionManager.userID
            };

            let compilationModel = new CompilationModel();
            let result = await compilationModel.add(insertData);

            if (!result) {
                throw '新增编办失败';
            }
        } catch (error) {
            console.log(error);
            responseData.err = 1;
            responseData.msg = error;
        }

        response.json(responseData);
    }

    /**
     * 模板设置页面
     *
     * @param {object} request
     * @param {object} response
     * @return {void}
     */
    async billsTemplate(request, response) {
        let billList = {};
        let valuationList = {};
        let valuationData = {};
        let compilationList = [];
        let billsTemplateData = [];

        let selectedCompilation = request.session.selectedCompilation;
        let engineering = request.params.engineering;
        let valuationId = request.params.id;
        let section = request.params.section;

        try {
            let compilationModel = new CompilationModel;
            // 获取对应的计价规则数据
            [valuationData, valuationList] = await compilationModel.getValuation(selectedCompilation._id, valuationId, section);
            compilationList = await compilationModel.getCompilationList();

            // 获取标准清单
            let stdBillLibListsModel = new STDBillLibListsModel();
            billList = await stdBillLibListsModel.getBillList(selectedCompilation._id);

            // 获取清单模板数据
            let billsTemplateModel = new BillsTemplateModel();
            billsTemplateData = await billsTemplateModel.getTemplateData(valuationId);
        } catch (error) {
            console.log(error);
        }

        let renderData = {
            engineering: engineering,
            billList: JSON.stringify(billList),
            billsTemplateData: JSON.stringify(billsTemplateData),
            billsFixedFlagList: JSON.stringify(BillsFixedFlagList),
            valuationData: valuationData,
            valuationList: valuationList,
            selectedCompilation: selectedCompilation,
            compilationList: compilationList,
            valuationId: valuationId,
            section: section,
            layout: 'users/views/layout/layout'
        };
        response.render('users/views/compilation/template', renderData);
    }

    /**
     * 清单模板，更新数据操作
     *
     * @param request
     * @param response
     */
    async updateBillsTemplate(request, response) {
        let engineering = request.params.engineering;
        let valuationId = request.params.id;
        let section = request.params.section;
        let data = JSON.parse(request.body.data);

        let billsTemplateModel = new BillsTemplateModel();
        let result = await billsTemplateModel.updateTemplate(valuationId, engineering, data);

        if (result) {
            response.json({error: 0, message: '', data: data});
        } else {
            response.json({error: 1, message: '更新数据错误', data: null});
        }
    }

}

export default CompilationController;