Calculation/app/controller/material_controller.js

'use strict';

/**
 *
 *
 * @author EllisRan
 * @date 2018/6/20
 * @version
 */

const moment = require('moment');
const auditConst = require('../const/audit').material;
const auditStageConst = require('../const/audit').stage;
const tenderConst = require('../const/tender');
const measureType = tenderConst.measureType;
const accountGroup = require('../const/account_group').group;
const materialConst = require('../const/material');
const MaterialCalculator = require('../lib/material_calc');
const sendToWormhole = require('stream-wormhole');
const fs = require('fs');
const path = require('path');
const _ = require('lodash');
const { typeOf } = require('mathjs');

module.exports = app => {
    class MaterialController extends app.BaseController {
        /**
         * 构造函数
         *
         * @param {Object} ctx - egg全局变量
         * @return {void}
         */
        constructor(ctx) {
            super(ctx);
            ctx.showProject = true;
            ctx.showTender = true;
            ctx.showTitle = true;
        }

        /**
         * 期列表(Get)
         * @param ctx
         * @return {Promise<void>}
         */
        async index(ctx) {
            try {
                const renderData = {
                    tender: ctx.tender.data,
                    tenderMenu: this.menu.tenderMenu,
                    preUrl: '/tender/' + ctx.tender.id,
                    auditConst,
                    auditConst2: JSON.stringify(auditConst),
                };
                renderData.materials = await ctx.service.material.getValidMaterials(ctx.tender.id);
                // 获取未选中和已完成的计量期
                const stages = await ctx.service.stage.getAllDataByCondition({ where: { tid: ctx.tender.id, status: auditStageConst.status.checked } });
                for (const s of renderData.materials) {
                    // s.curAuditor = null;
                    // 根据期状态返回展示用户
                    s.curAuditor = await ctx.service.materialAudit.getAuditorByStatus(s.id, s.status, s.times);
                    const materialStageList = s.stage_id.split(',');
                    for (const ms of materialStageList) {
                        const index = stages.findIndex(function(item) {
                            return item.id === parseInt(ms);
                        });
                        stages.splice(index, 1);
                    }
                }
                renderData.stages = stages;
                await this.layout('material/index.ejs', renderData, 'material/modal.ejs');
            } catch (err) {
                this.log(err);
                ctx.redirect(this.menu.menu.dashboard.url);
            }
        }

        /**
         * 期审批流程(Get)
         * @param ctx
         * @return {Promise<void>}
         */
        async materialAuditors(ctx) {
            try {
                const responseData = {
                    err: 0, msg: '', data: {},
                };
                const order = JSON.parse(ctx.request.body.data).order;
                const tenderId = ctx.params.id;
                const materialInfo = await ctx.service.material.getDataByCondition({ tid: tenderId, order });
                // 获取审批流程中右边列表
                const auditHistory = [];
                const times = materialInfo.status === auditConst.status.checkNo ? materialInfo.times - 1 : materialInfo.times;
                if (times >= 1) {
                    for (let i = 1; i <= times; i++) {
                        auditHistory.push(await ctx.service.materialAudit.getAuditors(materialInfo.id, i));
                    }
                }
                responseData.data.auditHistory = auditHistory;
                // 获取审批流程中左边列表
                responseData.data.auditors = await ctx.service.materialAudit.getAuditGroupByList(materialInfo.id, times);

                responseData.data.user = await ctx.service.projectAccount.getAccountInfoById(materialInfo.user_id);
                // 获取原报信息
                // const materialAuditor = await ctx.service.projectAccount.getAccountInfoById(materialInfo.user_id);
                // responseData.data.materialAuditor = materialAuditor;
                ctx.body = responseData;
            } catch (error) {
                this.log(error);
                ctx.body = { err: 1, msg: error.toString(), data: null };
            }
        }

        /**
         * 新增期(Post)
         * @param ctx
         * @return {Promise<void>}
         */
        async add(ctx) {
            try {
                if (ctx.session.sessionUser.accountId !== ctx.tender.data.user_id) {
                    throw '您无权创建材料调差期';
                }
                const data = ctx.request.body;
                if (data.s_order === '') {
                    throw '没有选中计量期';
                }
                const newMaterial = await ctx.service.material.addMaterial(ctx.tender.id, data);
                if (!newMaterial) {
                    throw '新增材料调差期失败，请重试';
                }
                ctx.redirect('/tender/' + ctx.tender.id + '/measure/material/' + newMaterial.order);
            } catch (err) {
                this.log(err);
                ctx.redirect(ctx.request.header.referer);
            }
        }

        /**
         * 删除期(Post)
         * @param ctx
         * @return {Promise<void>}
         */
        async delete(ctx) {
            try {
                const material_id = ctx.request.body.material_id;
                const materialInfo = await ctx.service.material.getDataById(material_id);
                // 获取最新的期数
                const material_highOrder = await ctx.service.material.count({
                    tid: ctx.tender.id,
                });
                if (materialInfo === undefined || ctx.session.sessionUser.accountId !== materialInfo.user_id || material_highOrder !== materialInfo.order) {
                    throw '您无权删除材料调差期';
                }
                const result = await ctx.service.material.deleteMaterial(material_id);
                if (!result) {
                    throw '删除材料调差期失败，请重试';
                }
                ctx.redirect('/tender/' + ctx.tender.id + '/measure/material/');
            } catch (err) {
                this.log(err);
                ctx.redirect(ctx.request.header.referer);
            }
        }

        /**
         * 获取通用的renderData（用于layout, Menu, subMenu部分）
         * @param ctx
         * @return {{tender, tenderMenu, auditConst}}
         * @private
         */
        async _getDefaultRenderData(ctx) {
            const data = {
                tender: ctx.tender.data,
                tenderMenu: JSON.parse(JSON.stringify(this.menu.stageMenu)),
                auditConst,
                measureType,
                preUrl: '/tender/' + ctx.tender.id + '/measure/material/' + ctx.params.order,
                material: ctx.material,
            };
            if ((ctx.material.status === auditConst.status.uncheck || ctx.material.status === auditConst.status.checkNo) && ctx.session.sessionUser.accountId === ctx.material.user_id) {
                // data.accountGroup = accountGroup;
                // 获取所有项目参与者
                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'],
                });
                data.accountList = accountList;
                data.accountGroup = accountGroup.map((item, idx) => {
                    const groupList = accountList.filter(item => item.account_group === idx);
                    return { groupName: item, groupList };
                });
            }
            data.tenderMenu.back.children[0].url = '/tender/' + ctx.tender.id + '/measure/material';
            return data;
        }

        _materialReadOnly(material) {
            return material.status === auditConst.status.checked;
        }

        /**
         * 获取审批界面所需的 原报、审批人数据等
         * @param ctx
         * @return {Promise<void>}
         * @private
         */
        async _getMaterialAuditViewData(ctx) {
            const times = ctx.material.status === auditConst.status.checkNo ? ctx.material.times - 1 : ctx.material.times;
            ctx.material.user = await ctx.service.projectAccount.getAccountInfoById(ctx.material.user_id);
            ctx.material.auditHistory = [];
            if (times >= 1) {
                for (let i = 1; i <= times; i++) {
                    ctx.material.auditHistory.push(await ctx.service.materialAudit.getAuditors(ctx.material.id, i));
                }
            }
            // 获取审批流程中左边列表
            ctx.material.auditors2 = await ctx.service.materialAudit.getAuditorsWithOwner(ctx.material.id, times);
            if (ctx.material.status === auditConst.status.uncheck || ctx.material.status === auditConst.status.checkNo) {
                ctx.material.auditorList = await ctx.service.materialAudit.getAuditors(ctx.material.id, ctx.material.times);
            }
        }

        /**
         * 获取当前期工料列表信息
         * @param ctx
         * @return {Promise<void>}
         * @private
         */
        async _getMaterialBillsData(ctx) {
            // 根据期判断需要获取的工料信息值
            const searchsql = { tid: ctx.tender.id };
            if (ctx.material.highOrder !== ctx.material.order) {
                const midList = await ctx.service.material.getPreMidList(ctx.tender.id, ctx.material.order);
                searchsql.mid = midList;
            }
            // 取所有工料表
            return await ctx.service.materialBills.getAllDataByCondition({ where: searchsql });
        }

        /**
         * 获取当前月信息价列表信息
         * @param ctx
         * @return {Promise<void>}
         * @private
         */
        async _getMaterialMonthsData(ctx, materialBillsData) {
            // 取月信息价表
            const monthsList = [];
            if (ctx.material.months) {
                const material_month = ctx.material.months.split(',');
                material_month.sort();
                const materialMonthList = await ctx.service.materialMonth.getListByMid(ctx.material.id);
                for (const mbd of materialBillsData) {
                    const one_mb = {
                        code: mbd.code,
                        name: mbd.name,
                        unit: mbd.unit,
                        mb_id: mbd.id,
                    };
                    for (const m of material_month) {
                        const mb_id = ctx.material.highOrder !== ctx.material.order ? mbd.mb_id : mbd.id;
                        const one_mm = _.find(materialMonthList, { mb_id, yearmonth: m });
                        one_mb[m] = one_mm.msg_tp;
                    }
                    monthsList.push(one_mb);
                }
            }
            return monthsList;
        }

        /**
         * 检查旧数据是否存在指数法调差数据，没有自动添加定值
         * @param ctx
         * @return {Promise<void>}
         * @private
         */
        async _checkExponentExist(ctx) {
            const material_exponent_constant = await ctx.service.materialExponent.getDataByCondition({
                tid: ctx.tender.id,
                type: materialConst.ex_type[0].value,
            });
            // 不存在则生成指数调差清单表定值和历史期定值（防止变更定值发生变化）
            if (!material_exponent_constant) {
                await ctx.service.materialExponent.addOldData();
            }
        }

        /**
         * 获取当前期指数列表信息
         * @param ctx
         * @return {Promise<void>}
         * @private
         */
        async _getMaterialExponentData(ctx) {
            // 根据期判断需要获取的工料信息值
            const searchsql = { tid: ctx.tender.id };
            if (ctx.material.highOrder !== ctx.material.order) {
                const midList = await ctx.service.material.getPreMidList(ctx.tender.id, ctx.material.order);
                searchsql.mid = midList;
            }
            // 取所有工料表
            return await ctx.service.materialExponent.getAllDataByCondition({ where: searchsql });
        }

        /**
         * 调差工料页面 (Get)
         * @param {Object} ctx - egg全局变量
         * @return {Promise<void>}
         */
        async info(ctx) {
            try {
                await this._getMaterialAuditViewData(ctx);
                const renderData = await this._getDefaultRenderData(ctx);
                renderData.materialBillsData = await this._getMaterialBillsData(ctx);
                // 取对应期的截取上期的调差金额和应耗数量
                if (ctx.material.highOrder !== ctx.material.order) {
                    for (const [mindex, mb] of renderData.materialBillsData.entries()) {
                        const result = await ctx.service.materialBillsHistory.getByMbId(ctx.material.id, ctx.material.order, mb.id);
                        _.forEach(result, function(value, key) {
                            renderData.materialBillsData[mindex][key] = result ? result[key] : null;
                        });
                    }
                }
                // 取所有已被调用的工料清单表
                renderData.materialListData = await ctx.service.materialList.getAllDataByCondition({ tid: ctx.tender.id, mid: ctx.material.id });
                // 基数
                // if (!ctx.material.readOnly) {
                const stage_list = await ctx.service.stage.getStageMsgByStageId(ctx.material.stage_id);
                renderData.calcBase = await ctx.service.stage.getMaterialCalcBase(stage_list, ctx.tender.info);
                // }

                // 取当前期截止上期含税金额
                renderData.pre_tp_hs = await ctx.service.material.getPreTpHs(ctx.tender.id, ctx.material.order);
                renderData.ex_pre_tp_hs = await ctx.service.material.getExPreTpHs(ctx.tender.id, ctx.material.order);

                renderData.months = ctx.material.months ? ctx.material.months.split(',') : [];
                renderData.monthsList = await this._getMaterialMonthsData(ctx, renderData.materialBillsData);

                renderData.materialType = JSON.stringify(materialConst);
                renderData.jsFiles = this.app.jsFiles.common.concat(this.app.jsFiles.material.info);
                await this.layout('material/info.ejs', renderData, 'material/info_modal.ejs');
            } catch (err) {
                this.log(err);
                ctx.redirect('/tender/' + ctx.tender.id + '/measure/material');
            }
        }

        /**
         * 调差清单页面 (Get)
         * @param {Object} ctx - egg全局变量
         * @return {Promise<void>}
         */
        async list(ctx) {
            try {
                await this._getMaterialAuditViewData(ctx);
                const renderData = await this._getDefaultRenderData(ctx);
                // 根据期判断需要获取的工料信息值表
                const searchsql = { tid: ctx.tender.id };
                let midList = [];
                if (ctx.material.highOrder !== ctx.material.order) {
                    midList = await ctx.service.material.getPreMidList(ctx.tender.id, ctx.material.order);
                    searchsql.mid = midList;
                }
                searchsql.t_type = materialConst.t_type[0].value;
                renderData.materialBillsData = await ctx.service.materialBills.getAllDataByCondition({ where: searchsql });
                // 取所有已被调用的工料清单表
                renderData.materialListData = await ctx.service.materialList.getMaterialData(ctx.tender.id, ctx.material.id);
                renderData.materialNotJoinListData = await ctx.service.materialListNotjoin.getAllDataByCondition({ where: { tid: ctx.tender.id, mid: ctx.material.id } });
                renderData.materialType = JSON.stringify(materialConst);
                renderData.jsFiles = this.app.jsFiles.common.concat(this.app.jsFiles.material.list);
                // 获取清单数据
                renderData.ledger = await ctx.service.ledger.getData(ctx.tender.id);
                renderData.pos = await ctx.service.pos.getPosData({ tid: ctx.tender.id });
                // 获取所选期数据并合并相加同类清单项
                renderData.curLedgerData = await ctx.service.stageBills.getStagesData(ctx.tender.id, ctx.material.stage_id);
                renderData.curPosData = await ctx.service.stagePos.getStagesData(ctx.tender.id, ctx.material.stage_id);
                await this.layout('material/list.ejs', renderData, 'material/list_modal.ejs');
            } catch (err) {
                this.log(err);
                ctx.redirect('/tender/' + ctx.tender.id + '/measure/material');
            }
        }

        /**
         * 指数调差页面 (Get)
         * @param {Object} ctx - egg全局变量
         * @return {Promise<void>}
         */
        async exponent(ctx) {
            try {
                await this._checkExponentExist(ctx);
                await this._getMaterialAuditViewData(ctx);
                const renderData = await this._getDefaultRenderData(ctx);
                const stage_list = await ctx.service.stage.getStageMsgByStageId(ctx.material.stage_id);
                renderData.ex_calc = materialConst.ex_calc;
                if (!ctx.material.ex_calc) {
                    const calcBase = await ctx.service.stage.getMaterialCalcBase(stage_list, ctx.tender.info);
                    for (const bq of renderData.ex_calc) {
                        const calc = _.find(calcBase, function(item) {
                            return bq.code === item.code;
                        });
                        bq.value = calc.value;
                    }
                } else {
                    renderData.ex_calc = JSON.parse(ctx.material.ex_calc);
                }

                renderData.materialExponentData = await this._getMaterialExponentData(ctx);
                // 取对应期的截取上期的调差金额和应耗数量
                if (ctx.material.highOrder !== ctx.material.order) {
                    for (const [mindex, me] of renderData.materialExponentData.entries()) {
                        const result = await ctx.service.materialExponentHistory.getByMeId(ctx.material.id, ctx.material.order, me.id);
                        _.forEach(result, function(value, key) {
                            renderData.materialExponentData[mindex][key] = result ? result[key] : null;
                        });
                    }
                }

                // 取当前期截止上期含税金额
                renderData.pre_tp_hs = await ctx.service.material.getPreTpHs(ctx.tender.id, ctx.material.order);
                renderData.ex_pre_tp_hs = await ctx.service.material.getExPreTpHs(ctx.tender.id, ctx.material.order);
                renderData.materialType = materialConst;
                renderData.jsFiles = this.app.jsFiles.common.concat(this.app.jsFiles.material.exponent);
                await this.layout('material/exponent.ejs', renderData, 'material/exponent_modal.ejs');
            } catch (err) {
                this.log(err);
                ctx.redirect('/tender/' + ctx.tender.id + '/measure/material');
            }
        }

        /**
         * 附件页面 (Get)
         * @param {Object} ctx - egg全局变量
         * @return {Promise<void>}
         */
        async file(ctx) {
            try {
                await this._getMaterialAuditViewData(ctx);
                const renderData = await this._getDefaultRenderData(ctx);
                const whiteList = this.ctx.app.config.multipart.whitelist;
                // 获取当前标段所有附件
                // const searchsql = { tid: ctx.tender.id };
                renderData.fileList = await ctx.service.materialFile.getAllMaterialFiles(ctx.tender.id);
                renderData.auditors = ctx.material.auditors.map(audit => audit.aid);
                // renderData.auditors = ctx.material.auditors2.map(audit => audit.aid);
                renderData.report_id = ctx.material.user_id;
                renderData.auditConst = auditConst;
                renderData.whiteList = whiteList;
                renderData.jsFiles = this.app.jsFiles.common.concat(this.app.jsFiles.material.file);
                await this.layout('material/file.ejs', renderData, 'material/file_modal.ejs');
            } catch (err) {
                this.log(err);
                ctx.redirect('/tender/' + ctx.tender.id + '/measure/material');
            }
        }

        /**
         * 调差清单 - 工料操作 (Ajax)
         * @param ctx
         * @return {Promise<void>}
         */
        async saveListsData(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                const responseData = {
                    err: 0,
                    msg: '',
                    data: {},
                };
                switch (data.type) {
                    case 'add':
                        responseData.data = await ctx.service.materialList.add(data.postData);
                        break;
                    case 'del':
                        await ctx.service.materialList.del(data.id, data.mb_id);
                        break;
                    case 'update':
                        if (data.updateData.quantity === '' || data.updateData.quantity === null) {
                            throw '请输入数量';
                        }
                        // 判断数量是否为数字
                        if (isNaN(data.updateData.quantity)) {
                            throw '不能输入其它非数字类型字符';
                        }
                        await ctx.service.materialList.save(data.updateData);
                        break;
                    case 'useOther':
                        responseData.data = await ctx.service.materialList.addOther(data.postData);
                        break;
                    case 'join':
                        await ctx.service.materialListNotjoin.del(data.select.id);
                        break;
                    case 'notjoin':
                        responseData.data = await ctx.service.materialListNotjoin.add(data.select);
                        break;
                    case 'paste':
                        await ctx.service.materialList.saveDatas(data.updateData);
                        // 取所有工料表
                        responseData.data = await ctx.service.materialList.getMaterialData(ctx.tender.id, ctx.material.id);
                        break;
                    default: throw '参数有误';
                }

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

        /**
         * 调差工料 - 编辑工料项 (Ajax)
         * @param ctx
         * @return {Promise<void>}
         */
        async saveBillsData(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                const responseData = {
                    err: 0,
                    msg: '',
                    data: {},
                };
                switch (data.type) {
                    case 'add':
                        responseData.data = await ctx.service.materialBills.add();
                        break;
                    case 'del':
                        responseData.data.m_tp = await ctx.service.materialBills.del(data.id);
                        break;
                    case 'update':
                        if (data.updateData.code === '' || data.updateData.code === null) {
                            throw '请先输入编号';
                        }
                        // 判断编号为纯数字时，不能为小数
                        if (!isNaN(data.updateData.code) && data.updateData.code.toString().indexOf('.') !== -1) {
                            throw '编号为纯数字时，不能为小数';
                        }
                        if (data.updateData.code.length > 15) {
                            throw '长度不超过15个字符';
                        }
                        // 判断编号是否已存在
                        const billData = await ctx.service.materialBills.getAllDataByCondition({ where: { tid: ctx.tender.id, code: data.updateData.code } });
                        if (billData.length > 1 || (billData.length > 0 && billData[0].id !== data.updateData.id)) {
                            throw '该编号已存在，请重新输入。';
                        }
                        responseData.data.m_tp = await ctx.service.materialBills.save(data.updateData);
                        break;
                    case 'rate':
                        // 判断数量是否为数字
                        if (isNaN(data.rate)) {
                            throw '不能输入其它非数字类型字符';
                        }
                        if (ctx.material.readOnly) {
                            throw '无权操作';
                        }
                        await ctx.service.material.changeRate(data.rate);
                        break;
                    case 'expr':
                        const materialCalculator = new MaterialCalculator(ctx, ctx.material.stage_id, ctx.tender.info);
                        const quantity = await materialCalculator.calculateExpr(data.expr);
                        // 更新quantity值并重新返回计算本期金额，截止本期金额
                        const updateData = {
                            id: data.id,
                            quantity: quantity !== 0 ? this.ctx.helper.round(quantity, 3) : null,
                            expr: data.expr,
                        };
                        responseData.data = await ctx.service.materialBills.updateFYQuantity(updateData);
                        break;
                    case 'paste':
                        responseData.data.m_tp = await ctx.service.materialBills.saveDatas(data.updateData);
                        // 根据期判断需要获取的工料信息值
                        const searchsql = { tid: ctx.tender.id };
                        if (ctx.material.highOrder !== ctx.material.order) {
                            const midList = await ctx.service.material.getPreMidList(ctx.tender.id, ctx.material.order);
                            searchsql.mid = midList;
                        }
                        // 取所有工料表
                        responseData.data.info = await ctx.service.materialBills.getAllDataByCondition({ where: searchsql });
                        break;
                    default: throw '参数有误';
                }

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

        /**
         * 调差工料 - 编辑月信息价 (Ajax)
         * @param ctx
         * @return {Promise<void>}
         */
        async saveMonth(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                const responseData = {
                    err: 0,
                    msg: '',
                    data: {},
                };
                const monthList = await ctx.service.materialMonth.getListByMid(ctx.material.id);
                const mbList = await this._getMaterialBillsData(ctx);
                switch (data.type) {
                    case 'add':
                        const tp = await ctx.service.materialMonth.add(data.updateData, monthList, mbList);
                        const materialBillsData = await this._getMaterialBillsData(ctx);
                        const monthsList = await this._getMaterialMonthsData(ctx, materialBillsData);
                        responseData.data = {
                            m_tp: tp,
                            monthsList,
                        };
                        break;
                    case 'del':
                        const tp2 = await ctx.service.materialMonth.del(data.updateData.del_yearmonth, monthList, mbList);
                        const materialBillsData2 = await this._getMaterialBillsData(ctx);
                        const monthsList2 = await this._getMaterialMonthsData(ctx, materialBillsData2);
                        responseData.data = {
                            m_tp: tp2,
                            monthsList: monthsList2,
                        };
                        break;
                    case 'update':
                        const tp3 = await ctx.service.materialMonth.save(data.updateData);
                        responseData.data = {
                            m_tp: tp3,
                        };
                        break;
                    case 'paste':
                        const tp4 = await ctx.service.materialMonth.saveDatas(data.updateData, mbList);
                        responseData.data = {
                            m_tp: tp4,
                        };
                        break;
                    default: throw '参数有误';
                }
                responseData.data.materialBillsData = await this._getMaterialBillsData(ctx);
                ctx.body = responseData;
            } catch (err) {
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }

        /**
         * 指数调差 - 编辑指数清单项 (Ajax)
         * @param ctx
         * @return {Promise<void>}
         */
        async saveExponentData(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                const responseData = {
                    err: 0,
                    msg: '',
                    data: {},
                };
                let ex_tp = ctx.material.ex_tp;
                let ex_expr = ctx.material.ex_expr;
                switch (data.type) {
                    case 'add':
                        responseData.data = await ctx.service.materialExponent.add();
                        break;
                    case 'del':
                        [ex_tp, ex_expr] = await ctx.service.materialExponent.del(data.id);
                        responseData.data.ex_tp = ex_tp;
                        responseData.data.ex_expr = ex_expr;
                        break;
                    case 'update':
                        [ex_tp, ex_expr] = await ctx.service.materialExponent.save(data.updateData);
                        responseData.data.ex_tp = ex_tp;
                        responseData.data.ex_expr = ex_expr;
                        break;
                    case 'rate':
                        // 判断数量是否为数字
                        if (isNaN(data.rate)) {
                            throw '不能输入其它非数字类型字符';
                        }
                        if (ctx.material.readOnly) {
                            throw '无权操作';
                        }
                        await ctx.service.material.changeRate(data.rate);
                        break;
                    case 'paste':
                        [ex_tp, ex_expr] = await ctx.service.materialExponent.saveDatas(data.updateData);
                        responseData.data.ex_tp = ex_tp;
                        responseData.data.ex_expr = ex_expr;
                        // 取所有指数清单
                        responseData.data.info = await this._getMaterialExponentData(ctx);
                        break;
                    case 'ex_calc':
                        // 判断数量是否为数字
                        [ex_tp, ex_expr] = await ctx.service.material.changeExCalc(data.updateData);
                        responseData.data.ex_tp = ex_tp;
                        responseData.data.ex_expr = ex_expr;
                        break;
                    default: throw '参数有误';
                }

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

        // 审批相关
        /**
         * 添加审批人
         * @param ctx
         * @return {Promise<void>}
         */
        async addAudit(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                const id = this.app._.toInteger(data.auditorId);
                if (isNaN(id) || id <= 0) {
                    throw '参数错误';
                }
                // 检查权限等
                if (ctx.material.user_id !== ctx.session.sessionUser.accountId) {
                    throw '您无权添加审核人';
                }
                if (ctx.material.status === auditConst.status.checking || ctx.material.status === auditConst.status.checked) {
                    throw '当前不允许添加审核人';
                }

                ctx.material.auditorList = await ctx.service.materialAudit.getAuditors(ctx.material.id, ctx.material.times);
                // 检查审核人是否已存在
                const exist = this.app._.find(ctx.material.auditorList, { aid: id });
                if (exist) {
                    throw '该审核人已存在，请勿重复添加';
                }

                const result = await ctx.service.materialAudit.addAuditor(ctx.material.id, id, ctx.material.times);
                if (!result) {
                    throw '添加审核人失败';
                }

                const audit = await ctx.service.materialAudit.getAuditor(ctx.material.id, id, ctx.material.times);
                ctx.body = { err: 0, msg: '', data: audit };
            } catch (err) {
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }
        /**
         * 移除审批人
         * @param ctx
         * @return {Promise<void>}
         */
        async deleteAudit(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                const id = data.auditorId instanceof Number ? data.auditorId : this.app._.toNumber(data.auditorId);
                if (isNaN(id) || id <= 0) {
                    throw '参数错误';
                }

                const result = await ctx.service.materialAudit.deleteAuditor(ctx.material.id, id, ctx.material.times);
                if (!result) {
                    throw '移除审核人失败';
                }

                const auditors = await ctx.service.materialAudit.getAuditors(ctx.material.id, ctx.material.times);
                ctx.body = { err: 0, msg: '', data: auditors };
            } catch (err) {
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }
        /**
         * 上报和重新上报
         * @param ctx
         * @return {Promise<void>}
         */
        async startAudit(ctx) {
            try {
                // 检查权限等
                if (!ctx.material) {
                    throw '数据错误';
                }
                if (ctx.material.user_id !== ctx.session.sessionUser.accountId) {
                    throw '您无权上报该期数据';
                }
                if (ctx.material.status === auditConst.status.checking || ctx.material.status === auditConst.status.checked) {
                    throw '该材料调差期数据当前无法上报';
                }

                await ctx.service.materialAudit.start(ctx.material.id, ctx.material.times);

                ctx.redirect(ctx.request.header.referer);
            } catch (err) {
                this.log(err);
                ctx.session.postError = err.toString();
                ctx.redirect(ctx.request.header.referer);
            }
        }
        /**
         * 审批
         * @param ctx
         * @return {Promise<void>}
         */
        async checkAudit(ctx) {
            try {
                if (!this.ctx.material || this.ctx.material.status !== auditConst.status.checking) {
                    throw '当前材料调差期数据有误';
                }
                if (!this.ctx.material.curAuditor || this.ctx.material.curAuditor.aid !== ctx.session.sessionUser.accountId) {
                    throw '您无权进行该操作';
                }
                const data = {
                    checkType: parseInt(ctx.request.body.checkType),
                    opinion: ctx.request.body.opinion,
                };
                if (!data.checkType || isNaN(data.checkType)) {
                    throw '提交数据错误';
                }
                if (data.checkType === auditConst.status.checkNo) {
                    if (!data.checkType || isNaN(data.checkType)) {
                        throw '提交数据错误';
                    }
                }

                await ctx.service.materialAudit.check(ctx.material.id, data, ctx.material.times);

                ctx.redirect(ctx.request.header.referer);
            } catch (err) {
                this.log(err);
                ctx.session.postError = err.toString();
                ctx.redirect(ctx.request.header.referer);
            }
        }

        _checkMaterialFileCanModify(ctx) {
            // 检查登录用户，是否可操作
            const accountId = ctx.session.sessionUser.accountId;
            if (!ctx.material.curAuditor) {
                if (ctx.material.status === auditConst.status.uncheck || ctx.material.status === auditConst.status.checkNo && accountId === ctx.material.user_id) {
                    return;
                }
                throw '该调差期当前您无权操作';
            } else {
                if (ctx.material.curAuditor.aid === accountId) return;
                throw '该调差期当前您无权操作';
            }

        }
        /**
         * 上传附件
         * @param {*} ctx 上下文
         */
        async upload(ctx) {
            let stream;
            try {
                this._checkMaterialFileCanModify(ctx);
                const parts = this.ctx.multipart({
                    autoFields: true,
                });
                const files = [];
                const create_time = Date.parse(new Date()) / 1000;
                let idx = 0;
                while ((stream = await parts()) !== undefined) {
                    if (!stream.filename) {
                        // 如果没有传入直接返回
                        return;
                    }
                    const fileInfo = path.parse(stream.filename);
                    // const filepath = path.join('public/upload', this.ctx.tender.id.toString(), 'tc', 'fujian_' + create_time + fileInfo.ext);
                    const filepath = `public/upload/${this.ctx.tender.id.toString()}/tc/fujian_${create_time + idx.toString() + fileInfo.ext}`;
                    await ctx.helper.saveStreamFile(stream, path.resolve(this.app.baseDir, 'app', filepath));
                    files.push({ filepath, name: stream.filename, ext: fileInfo.ext });
                    ++idx;
                }
                const upload_time = this.ctx.helper.dateTran(new Date());
                const payload = files.map(file => {
                    let idx;
                    if (Array.isArray(parts.field.name)) {
                        idx = parts.field.name.findIndex(name => name === file.name);
                    } else {
                        idx = 'isString';
                    }
                    const newFile = {
                        tid: ctx.tender.id,
                        user_id: ctx.session.sessionUser.accountId,
                        mid: ctx.material.id,
                        s_order: ctx.params.order,
                        upload_time,
                        filepath: file.filepath,
                        file_size: ctx.helper.bytesToSize(idx === 'isString' ? parts.field.size : parts.field.size[idx]),
                        file_name: file.name,
                        fileext: file.ext,
                    };
                    return newFile;
                });
                // 执行文件信息写入数据库
                await ctx.service.materialFile.saveFileMsgToDb(payload);
                // 将最新的当前标段的所有文件信息返回
                const data = await ctx.service.materialFile.getAllMaterialFiles(ctx.tender.id);
                ctx.body = { err: 0, msg: '', data };
            } catch (err) {
                stream && (await sendToWormhole(stream));
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }

        /**
         * 下载附件
         * @param {Object} ctx - egg全局变量
         * @return {void}
         */
        async downloadFile(ctx) {
            const id = ctx.params.fid;
            if (id) {
                try {
                    const fileInfo = await ctx.service.materialFile.getDataById(id);
                    if (fileInfo !== undefined && fileInfo !== '') {
                        const fileName = path.join(__dirname, '../', fileInfo.filepath);
                        // 解决中文无法下载问题
                        const userAgent = (ctx.request.header['user-agent'] || '').toLowerCase();
                        let disposition = '';
                        if (userAgent.indexOf('msie') >= 0 || userAgent.indexOf('chrome') >= 0) {
                            disposition = 'attachment; filename=' + encodeURIComponent(fileInfo.file_name);
                        } else if (userAgent.indexOf('firefox') >= 0) {
                            disposition = 'attachment; filename*="utf8\'\'' + encodeURIComponent(fileInfo.file_name) + '"';
                        } else {
                            /* safari等其他非主流浏览器只能自求多福了 */
                            disposition = 'attachment; filename=' + new Buffer(fileInfo.file_name).toString('binary');
                        }
                        ctx.response.set({
                            'Content-Type': 'application/octet-stream',
                            'Content-Disposition': disposition,
                            'Content-Length': fileInfo.file_size,
                        });
                        ctx.body = await fs.createReadStream(fileName);
                    } else {
                        throw '不存在该文件';
                    }
                } catch (err) {
                    this.log(err);
                    this.setMessage(err.toString(), this.messageType.ERROR);
                }
            }
        }


        /**
         * 查看当前标段以往所有期的附件
         * @param {Object} ctx 上下文
         */
        async getCurMatericalFiles(ctx) {
            try {
                // const { isCheck } = JSON.parse(ctx.request.body.data);
                const data = await ctx.service.materialFile.getAllMaterialFiles(ctx.tender.id);
                ctx.body = { err: 0, msg: '', data };
            } catch (err) {
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }

        /**
         * 删除附件
         * @param {Ojbect} ctx 上下文
         */
        async deleteFile(ctx) {
            try {
                const { data } = ctx.request.body;
                const { id } = JSON.parse(data);
                const fileInfo = await ctx.service.materialFile.getMaterialFileById(id);
                if (fileInfo) {
                    // 先删除文件
                    await fs.unlinkSync(path.resolve(this.app.baseDir, './app', fileInfo.filepath));
                    // 再删除数据库
                    await ctx.service.materialFile.delete(id);
                } else {
                    throw '不存在该文件';
                }
                ctx.body = { err: 0, msg: '请求成功' };
            } catch (err) {
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }
    }

    return MaterialController;
};