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 shenpiConst = require('../const/shenpi');
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),
                };
                let openMaterialTax = ctx.session.sessionProject.page_show.openMaterialTax;
                let allMaterialTax = true;
                renderData.materials = await ctx.service.material.getValidMaterials(ctx.tender.id);
                const lastMaterial = renderData.materials.length > 0 ? renderData.materials[0] : null;
                if (lastMaterial && (lastMaterial.status === auditConst.status.uncheck || lastMaterial.status === auditConst.status.checkNo) && lastMaterial.material_tax !== openMaterialTax) {
                    await ctx.service.material.updateMaterialTax(lastMaterial.id, openMaterialTax);
                    lastMaterial.material_tax = openMaterialTax;
                }
                // 获取未选中和已完成的计量期
                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);
                    }
                    if (allMaterialTax && s.material_tax === 0) {
                        allMaterialTax = false;
                    }
                    if (!openMaterialTax && s.material_tax === 1) {
                        openMaterialTax = 1;
                    }
                    s.decimal = s.decimal ? JSON.parse(s.decimal) : materialConst.decimal;
                }
                if (lastMaterial && lastMaterial.status === auditConst.status.checked && ctx.session.sessionUser.accountId === ctx.tender.data.user_id && stages.length > 0) {
                    renderData.lastMaterialList = lastMaterial.is_new ? await ctx.service.materialListGcl.getAllDataByCondition({ where: { tid: ctx.tender.id } }) : await ctx.service.materialList.getMaterialData(ctx.tender.id, lastMaterial.id);
                } else {
                    renderData.lastMaterialList = null;
                }
                renderData.stages = stages;
                renderData.openMaterialTax = openMaterialTax;
                renderData.allMaterialTax = allMaterialTax;
                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.getAuditorsWithOwner(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 save(ctx) {
            try {
                const data = {
                    mid: ctx.request.body.mid,
                    period: ctx.request.body.period,
                };
                const material = await ctx.service.material.getDataById(data.mid);
                if (!material) {
                    throw '提交数据错误';
                }
                // if (stage.status === auditConst.status.checked) {
                //     throw '该计量期当前不可编辑';
                // }
                // if (ctx.session.sessionUser.accountId !== stage.user_id) {
                //     throw '您无权修改该数据';
                // }
                await this.ctx.service.material.saveMaterial(data.mid, data.period);
                ctx.redirect('/tender/' + ctx.tender.id + '/measure/material');
            } catch (err) {
                this.log(err);
                ctx.redirect('/tender/' + ctx.tender.id + '/measure/material');
            }
        }

        /**
         * 新增期(Post)
         * @param ctx
         * @return {Promise<void>}
         */
        async add(ctx) {
            try {
                if (ctx.session.sessionUser.accountId !== ctx.tender.data.user_id) {
                    throw '您无权创建材料调差期';
                }
                const data = JSON.parse(ctx.request.body.data);
                if (data.s_order === '') {
                    throw '没有选中计量期';
                }
                // 调差期是否存在审批或待上报，存在则无法重复添加
                const doingMaterial = await ctx.service.material.getDataByCondition({ tid: ctx.tender.id, status: [auditConst.status.uncheck, auditConst.status.checking, auditConst.status.checkNo] });
                if (doingMaterial) {
                    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);
                ctx.body = { err: 0, msg: '', data: newMaterial };
            } catch (err) {
                this.log(err);
                // ctx.redirect(ctx.request.header.referer);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }

        /**
         * 删除期(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.is_admin || ((materialInfo.status === auditConst.status.uncheck || materialInfo.status === auditConst.status.checkNo) && materialInfo.user_id === ctx.session.sessionUser.accountId)) || 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,
                shenpiConst,
            };
            if ((ctx.material.status === auditConst.status.uncheck || ctx.material.status === auditConst.status.checkNo) && (ctx.session.sessionUser.accountId === ctx.material.user_id || ctx.tender.isTourist)) {
                // 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 = ctx.material.status === auditConst.status.checkNo && ctx.material.user_id !== ctx.session.sessionUser.accountId ?
                await ctx.service.materialAudit.getAuditorsWithOwner(ctx.material.id, times) :
                await ctx.service.materialAudit.getAuditorsWithOwner(ctx.material.id, ctx.material.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);
            }

            // 是否已验证手机短信
            const pa = await ctx.service.projectAccount.getDataById(ctx.session.sessionUser.accountId);
            ctx.material.authMobile = pa.auth_mobile;
        }

        /**
         * 获取当前期工料列表信息
         * @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, orders: [['order', 'asc']] });
        }

        /**
         * 获取当前月信息价列表信息
         * @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,
                        origin: mbd.origin,
                        mb_id: mbd.id,
                        order: mbd.order,
                    };
                    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;
                        });
                    }
                }
                // 取所有已被调用的工料清单表
                const materialListData = await ctx.service.materialList.getAllDataByCondition({ where: { tid: ctx.tender.id, mid: ctx.material.id } });
                renderData.materialListData = ctx.helper._.uniqBy(materialListData, 'mb_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.material.m_tax_tp = renderData.material.m_tax_tp ? renderData.material.m_tax_tp : renderData.material.m_tp;
                renderData.pre_tp_hs = await ctx.service.material.getPreTpHs(ctx.tender.id, ctx.material.order, ctx.material.decimal.tp);
                renderData.ex_pre_tp_hs = await ctx.service.material.getExPreTpHs(ctx.tender.id, ctx.material.order, ctx.material.decimal.tp);
                // renderData.tax_pre_tp_hs = await ctx.service.material.getTaxPreTpHs(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);
                // 判断之前期有无调用过材料税
                renderData.old_had_tax = await ctx.service.material.getOldMaterialTax(ctx.tender.id, ctx.params.order);
                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, orders: [['order', 'asc']] });
                // 取对应期的截取上期的调差金额和应耗数量
                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) {
                            if (key === 'mb_id') {
                                renderData.materialBillsData[mindex].id = result ? result[key] : null;
                            } else {
                                renderData.materialBillsData[mindex][key] = result ? result[key] : null;
                            }
                        });
                    }
                }
                // 取所有已被调用的工料清单表
                // 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, 'list');
                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 loadListsData(ctx) {
            try {
                // const data = JSON.parse(ctx.request.body.data);
                // const filter = data.filter.split(';');
                const responseData = { err: 0, msg: '', data: {} };
                // 取所有已被调用的工料清单表
                responseData.data.materialListData = await ctx.service.materialList.getMaterialData(ctx.tender.id, ctx.material.id);
                responseData.data.materialNotJoinListData = await ctx.service.materialListNotjoin.getAllDataByCondition({ where: { tid: ctx.tender.id, mid: ctx.material.id } });
                responseData.data.materialSelfListData = await ctx.service.materialListSelf.getAllDataByCondition({ where: { tid: ctx.tender.id, mid: ctx.material.id } });
                // 获取清单数据
                responseData.data.ledger = await ctx.service.ledger.getData(ctx.tender.id);
                responseData.data.pos = await ctx.service.pos.getPosData({ tid: ctx.tender.id });
                // 获取所选期数据并合并相加同类清单项
                responseData.data.curLedgerData = await ctx.service.stageBills.getStagesData(ctx.tender.id, ctx.material.stage_id);
                responseData.data.curPosData = await ctx.service.stagePos.getStagesData(ctx.tender.id, ctx.material.stage_id, 'list');
                // 获取清单设置已选清单
                const materialChecklistData = await ctx.service.materialChecklist.getAllDataByCondition({ where: { tid: ctx.tender.id } });
                responseData.data.materialChecklistData = materialChecklistData.sort(function(a, b) {
                    return ctx.helper.compareCode(a.b_code, b.b_code);
                });
                const lastMaterial = await ctx.service.material.getLastestMaterial(ctx.tender.id, true);
                if (lastMaterial && !lastMaterial.is_new) {
                    const materialListData = await ctx.service.materialList.getMaterialData(ctx.tender.id, lastMaterial.id);
                    const hadBillsList = [];
                    for (const ml of materialListData) {
                        const hb = _.find(hadBillsList, { gcl_id: ml.gcl_id, mb_id: ml.mb_id });
                        if (!hb) {
                            hadBillsList.push({
                                gcl_id: ml.gcl_id,
                                mb_id: ml.mb_id,
                                order: ml.order,
                                quantity: ml.quantity,
                                expr: ml.expr,
                            });
                        }
                    }
                    // 批量插入并修改is_new值
                    await ctx.service.materialListGcl.setData(lastMaterial.id, hadBillsList);
                    responseData.data.gclList = hadBillsList;
                } else {
                    const hadBillsList = await ctx.service.materialListGcl.getAllDataByCondition({ where: { tid: ctx.tender.id } });
                    responseData.data.gclList = hadBillsList;
                }
                ctx.body = responseData;
            } catch (err) {
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }

        /**
         * 调差清单新建台账数据获取 (Post)
         * @param {Object} ctx - egg全局变量
         * @return {Promise<void>}
         */
        async loadGclData(ctx) {
            try {
                // const data = JSON.parse(ctx.request.body.data);
                // const filter = data.filter.split(';');
                const responseData = { err: 0, msg: '', data: {} };
                const data = JSON.parse(ctx.request.body.data);
                if (data.stage_id === '') {
                    throw '没有选中计量期';
                }
                // 取所有已被调用的工料清单表
                // responseData.data.materialListData = await ctx.service.materialList.getMaterialData(ctx.tender.id, ctx.material.id);
                // responseData.data.materialNotJoinListData = await ctx.service.materialListNotjoin.getAllDataByCondition({ where: { tid: ctx.tender.id, mid: ctx.material.id } });
                // 获取清单数据
                responseData.data.ledger = await ctx.service.ledger.getData(ctx.tender.id);
                responseData.data.pos = await ctx.service.pos.getPosData({ tid: ctx.tender.id });
                // 获取所选期数据并合并相加同类清单项
                responseData.data.curLedgerData = await ctx.service.stageBills.getStagesData(ctx.tender.id, data.stage_id.join(','));
                responseData.data.curPosData = await ctx.service.stagePos.getStagesData(ctx.tender.id, data.stage_id.join(','), 'list');

                // 获取gclidlist值
                const lastMaterial = await ctx.service.material.getLastestCompleteMaterial(ctx.tender.id);
                // responseData.data.materialListData = await ctx.service.materialList.getMaterialData(ctx.tender.id, lastMaterial.id);
                if (lastMaterial && !lastMaterial.is_new) {
                    const materialListData = await ctx.service.materialList.getMaterialData(ctx.tender.id, lastMaterial.id);
                    const hadBillsList = [];
                    for (const ml of materialListData) {
                        const hb = _.find(hadBillsList, { gcl_id: ml.gcl_id, mb_id: ml.mb_id });
                        if (!hb) {
                            hadBillsList.push({
                                gcl_id: ml.gcl_id,
                                mb_id: ml.mb_id,
                                order: ml.order,
                                quantity: ml.quantity,
                                expr: ml.expr,
                            });
                        }
                    }
                    // 批量插入并修改is_new值
                    await ctx.service.materialListGcl.setData(lastMaterial.id, hadBillsList);
                    // responseData.data.gclList = hadBillsList;
                }
                const hadBillsList = await ctx.service.materialListGcl.getAllDataByCondition({ where: { tid: ctx.tender.id } });
                responseData.data.gclList = hadBillsList;

                // 获取上一期的单独设置的清单明细
                responseData.data.materialListForSelf = lastMaterial ? await ctx.service.materialList.getAllDataByCondition({ where: { tid: ctx.tender.id, mid: lastMaterial.id, is_self: 1 } }) : [];
                responseData.data.selfList = lastMaterial ? await ctx.service.materialListSelf.getAllDataByCondition({ where: { tid: ctx.tender.id, mid: lastMaterial.id } }) : [];
                // 获取清单设置已选清单
                // const materialChecklistData = await ctx.service.materialChecklist.getAllDataByCondition({ where: { tid: ctx.tender.id } });
                // responseData.data.materialChecklistData = materialChecklistData.sort(function(a, b) {
                //     return ctx.helper.compareCode(a.b_code, b.b_code);
                // });
                ctx.body = responseData;
            } catch (err) {
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }

        /**
         * 指数调差页面 (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, { code: bq.code }) || _.find(calcBase, { code: 'bqwc' });
                        bq.value = calc.value;
                        // if (calc.code === 'bqwc') {
                        //     ctx.material.ex_expr = calc.value.toString() + '*[0-1]';
                        //     ctx.material.ex_tp = this.ctx.helper.round(this.ctx.helper.mul(calc.value, -1), 2);
                        // }
                    }
                    // 并更新至调差表中
                    await ctx.service.material.update({ ex_calc: JSON.stringify(renderData.ex_calc) }, { id: ctx.material.id });
                } else {
                    const ex_calc = JSON.parse(ctx.material.ex_calc);
                    if (ctx.helper._.findIndex(ex_calc, { code: 'zdy' }) === -1) {
                        ex_calc.push({
                            code: 'zdy',
                            text: '自定义金额',
                            value: ctx.helper._.find(ex_calc, { code: 'bqwc' }).value,
                            select: false,
                        });
                        // 并更新至调差表中
                        await ctx.service.material.update({ ex_calc: JSON.stringify(ex_calc) }, { id: ctx.material.id });
                    }
                    renderData.ex_calc = 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, ctx.material.decimal.tp);
                renderData.ex_pre_tp_hs = await ctx.service.material.getExPreTpHs(ctx.tender.id, ctx.material.order, ctx.material.decimal.tp);
                renderData.materialType = materialConst;
                renderData.jsFiles = this.app.jsFiles.common.concat(this.app.jsFiles.material.exponent);
                // 判断之前期有无调用过材料税
                renderData.old_had_tax = await ctx.service.material.getOldMaterialTax(ctx.tender.id, ctx.params.order);
                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');
            }
        }

        /**
         *  调差操作 (form)
         * @param ctx
         * @return {Promise<void>}
         */
        async saveDecimal(ctx) {
            try {
                const data = ctx.request.body;
                if (ctx.material.status !== auditConst.status.uncheck && ctx.material.status !== auditConst.status.checkNo) {
                    throw '当前调差期无法调整小数位数';
                }
                const newDecimalUp = parseInt(data.up);
                const newDecimalTp = parseInt(data.tp);
                if (ctx.app._.isNaN(newDecimalUp) || newDecimalUp > 6 || newDecimalUp < 0) {
                    throw '单价小数位数设置不能大于6或小于0';
                }
                if (ctx.app._.isNaN(newDecimalTp) || newDecimalTp > 6 || newDecimalTp < 0) {
                    throw '金额小数位数设置不能大于6或小于0';
                }
                if (ctx.material.decimal.up === newDecimalUp && ctx.material.decimal.tp === newDecimalTp) {
                    throw '小数位数设置未发生变化';
                }
                const result = await ctx.service.material.saveDecimal(newDecimalUp, newDecimalTp);
                if (!result) {
                    throw '小数位数设置失败';
                }
                this.setMessage('设置小数位数成功', this.messageType.SUCCESS);
            } catch (err) {
                console.log(err);
                this.log(err);
                ctx.session.postError = err.toString();
            }
            ctx.redirect(ctx.request.header.referer);
        }

        /**
         * 调差清单 - 工料操作 (Ajax)
         * @param ctx
         * @return {Promise<void>}
         */
        async saveListsData(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                const responseData = {
                    err: 0,
                    msg: '',
                    data: {},
                };
                if (ctx.session.sessionProject.page_show.openMaterialChecklist && ctx.app._.findIndex(['join', 'notjoin', 'self', 'noself', 'useOther'], data.type) === -1) {
                    throw '清单设置功能已启动，请前往清单设置页操作清单内容';
                }
                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 'self':
                        responseData.data = await ctx.service.materialListSelf.add(data.select);
                        break;
                    case 'noself':
                        await ctx.service.materialListSelf.del(data.select.id);
                        break;
                    case 'paste':
                        await ctx.service.materialList.saveDatas(data.updateData);
                        // 取所有工料表
                        responseData.data = await ctx.service.materialList.getMaterialData(ctx.tender.id, ctx.material.id);
                        break;
                    case 'adds':
                        responseData.data = await ctx.service.materialList.adds(data.postData);
                        break;
                    case 'dels':
                        responseData.data = await ctx.service.materialList.dels(data.postData);
                        break;
                    case 'updates':
                        if (data.updateData.quantity === '' || data.updateData.quantity === null) {
                            throw '请输入数量';
                        }
                        // 判断数量是否为数字
                        if (isNaN(data.updateData.quantity)) {
                            throw '不能输入其它非数字类型字符';
                        }
                        responseData.data = await ctx.service.materialList.saves(data.updateData);
                        break;
                    case 'pastes':
                        responseData.data = await ctx.service.materialList.savePastes(data.updateData);
                        // 取所有工料表
                        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 'changeOrder':
                        await ctx.service.materialBills.changeOrder(data.id1, data.id2);
                        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 ? ctx.helper.round(quantity, ctx.material.decimal.qty) : 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, orders: [['order', 'asc']] });
                        responseData.data.info = await this._getMaterialBillsData(ctx);
                        break;
                    default: throw '参数有误';
                }
                if (ctx.material.material_tax) {
                    responseData.data.m_tax_tp = await ctx.service.material.getMaterialTaxTp(ctx.material.id);
                }
                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);
                const material_month = this.ctx.material.months ? this.ctx.material.months.split(',') : [];
                switch (data.type) {
                    case 'add':
                        // 判断是否已存在该月份
                        if (ctx.app._.indexOf(material_month, data.updateData.yearmonth) !== -1) {
                            throw '调差期已创建过本月的信息价,请刷新页面重新获取';
                        }
                        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':
                        // 判断是否已不存在该月份
                        if (ctx.app._.intersection(data.updateData.del_yearmonth, material_month).length !== data.updateData.del_yearmonth.length) {
                            throw '调差期已删除本月的信息价,请刷新页面重新获取';
                        }
                        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 'updateOrigin':
                        await ctx.service.materialBills.saveOrigin(data.updateData);
                        break;
                    case 'paste':
                        const tp4 = await ctx.service.materialMonth.saveDatas(data.updateData, mbList);
                        responseData.data = {
                            m_tp: tp4,
                        };
                        break;
                    case 'pasteOrigin':
                        await ctx.service.materialBills.saveOrigins(data.updateData);
                        break;
                    default: throw '参数有误';
                }
                if (ctx.material.material_tax) {
                    responseData.data.m_tax_tp = await ctx.service.material.getMaterialTaxTp(ctx.material.id);
                }
                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.changeExponentRate(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 shenpiInfo = await ctx.service.shenpiAudit.getDataByCondition({ tid: ctx.tender.id, sp_type: shenpiConst.sp_type.material, sp_status: shenpiConst.sp_status.gdzs });
                const is_gdzs = shenpiInfo && ctx.tender.info.shenpi.material === shenpiConst.sp_status.gdzs ? 1 : 0;
                const result = await ctx.service.materialAudit.addAuditor(ctx.material.id, id, ctx.material.times, is_gdzs);
                if (!result) {
                    throw '添加审核人失败';
                }

                const auditors = await ctx.service.materialAudit.getAuditorsWithOwner(ctx.material.id, ctx.material.times);
                ctx.body = { err: 0, msg: '', data: auditors };
            } 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);
            }
        }

        async _checkMaterialFileCanModify(ctx) {
            // 检查登录用户，是否可操作
            const accountId = ctx.session.sessionUser.accountId;
            const auditors = await ctx.service.materialAudit.getAuditorsWithOwner(ctx.material.id, ctx.material.times);
            // console.log(auditors);

            if (auditors.findIndex(item => item.aid === accountId) === -1 && !ctx.tender.touristPermission.file) {
                throw '该调差期当前您无权操作';
            }
            // 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 {
                await this._checkMaterialFileCanModify(ctx);
                const parts = this.ctx.multipart({
                    autoFields: true,
                });
                const files = [];
                const create_time = Date.parse(new Date()) / 1000;
                let idx = 0;
                const extra_upload = ctx.material.status === auditConst.status.checked;
                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 = `app/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));
                    await ctx.app.fujianOss.put(ctx.app.config.fujianOssFolder + filepath, stream);
                    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,
                        extra_upload,
                    };
                    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);
                        ctx.body = await ctx.helper.ossFileGet(fileInfo.filepath);
                    } 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 || !Object.keys(fileInfo).length) {
                    throw '该文件不存在';
                }
                if (!fileInfo.extra_upload && ctx.material.status === auditConst.status.checked) {
                    throw '无权限删除';
                }
                if (fileInfo) {
                    // 先删除文件
                    // await fs.unlinkSync(path.resolve(this.app.baseDir, './app', fileInfo.filepath));
                    await ctx.app.fujianOss.delete(ctx.app.config.fujianOssFolder + 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 };
            }
        }

        /**
         * 批量下载 - 压缩成zip文件返回
         * @param {Object} ctx - 全局上下文
         */
        async downloadZip(ctx) {
            const zipFilename = `${ctx.tender.data.name}-材料调差-${ctx.params.order}-附件.zip`;
            const time = Date.now();
            const zipPath = `app/public/upload/${ctx.tender.id}/tc/fu_jian_zip${time}.zip`;
            const responseData = {
                err: 0,
                msg: '',
            };
            try {
                // const fileIds = JSON.parse(ctx.request.query.fileIds);
                const { fileIds = [] } = JSON.parse(ctx.request.body.data);
                const size = await ctx.service.materialFile.compressedFile(fileIds, zipPath);

                // 解决中文无法下载问题
                const userAgent = (ctx.request.header['user-agent'] || '').toLowerCase();
                let disposition = '';
                if (userAgent.indexOf('msie') >= 0 || userAgent.indexOf('chrome') >= 0) {
                    disposition = 'attachment; filename=' + encodeURIComponent(zipFilename);
                } else if (userAgent.indexOf('firefox') >= 0) {
                    disposition = 'attachment; filename*="utf8\'\'' + encodeURIComponent(zipFilename) + '"';
                } else {
                    /* safari等其他非主流浏览器只能自求多福了 */
                    disposition = 'attachment; filename=' + new Buffer(zipFilename).toString('binary');
                }
                ctx.response.set({
                    'Content-Type': 'application/octet-stream',
                    'Content-Disposition': disposition,
                    'Content-Length': size,
                });
                const readStream = fs.createReadStream(path.join(this.app.baseDir, zipPath));

                ctx.body = readStream;
                readStream.on('close', () => {
                    if (fs.existsSync(path.resolve(this.app.baseDir, zipPath))) {
                        fs.unlinkSync(path.resolve(this.app.baseDir, zipPath));
                    }
                });
                // fs的错误不能被try catch捕捉
                readStream.on('error', err => {
                    this.log(err);
                    if (fs.existsSync(path.resolve(this.app.baseDir, zipPath))) {
                        fs.unlinkSync(path.resolve(this.app.baseDir, zipPath));
                    }
                    responseData.err = 1;
                    responseData.msg = err.toString();
                    ctx.body = responseData;
                });
            } catch (err) {
                this.log(err);
                if (fs.existsSync(path.resolve(this.app.baseDir, zipPath))) {
                    fs.unlinkSync(path.resolve(this.app.baseDir, zipPath));
                }
                this.setMessage(err.toString(), this.messageType.ERROR);
                responseData.err = 1;
                responseData.msg = err.toString();
                ctx.body = responseData;
            }
        }

        async _setChecklistPermission(ctx) {
            // 清单设置权限判断
            ctx.material.checklistPermission = false;
            if (ctx.session.sessionProject.page_show.openMaterialChecklist && ctx.material.highOrder === ctx.material.order && ctx.material.status !== auditConst.status.checked) {
                const permission = ctx.session.sessionUser.permission;
                if ((permission && permission.tender !== undefined && permission.tender.indexOf('4') !== -1) || (ctx.material.order === 1 && ctx.session.sessionUser.accountId === ctx.material.user_id && (ctx.material.status === auditConst.status.uncheck || ctx.material.status === auditConst.status.checkNo))) {
                    ctx.material.checklistPermission = true;
                }
            }
        }

        /**
         * 清单设置页
         * @param {Object} ctx - 全局上下文
         */
        async checklist(ctx) {
            try {
                await this._getMaterialAuditViewData(ctx);
                await this._setChecklistPermission(ctx);
                ctx.material.readOnly = !ctx.material.checklistPermission;
                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, orders: [['order', 'asc']] });
                // 取对应期的截取上期的调差金额和应耗数量
                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) {
                            if (key === 'mb_id') {
                                renderData.materialBillsData[mindex].id = result ? result[key] : null;
                            } else {
                                renderData.materialBillsData[mindex][key] = result ? result[key] : null;
                            }
                        });
                    }
                }
                // 取所有已被调用的工料清单表
                // 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.checklist);
                // 获取清单数据
                // 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, 'list');
                await this.layout('material/checklist.ejs', renderData, 'material/checklist_modal.ejs');
            } catch (err) {
                this.log(err);
                ctx.redirect('/tender/' + ctx.tender.id + '/measure/material');
            }
        }

        /**
         * 清单设置 - 编辑指数清单项 (Ajax)
         * @param ctx
         * @return {Promise<void>}
         */
        async saveChecklistData(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                const responseData = {
                    err: 0,
                    msg: '',
                    data: {},
                };
                await this._setChecklistPermission(ctx);
                if (ctx.material.order !== ctx.material.highOrder) {
                    throw '无法设置非最新期的清单设置数据';
                }
                // 权限控制
                if (!ctx.material.checklistPermission && data.type !== 'resetChecklist') {
                    throw '本期已审批完成或权限不足，无法设置清单数据';
                }
                switch (data.type) {
                    case 'adds':
                        responseData.data = await ctx.service.materialList.adds(data.postData, data.checklist);
                        break;
                    case 'dels':
                        responseData.data = await ctx.service.materialList.dels(data.postData, data.checklist);
                        break;
                    case 'updates':
                        if (data.updateData.quantity === '' || data.updateData.quantity === null) {
                            throw '请输入数量';
                        }
                        // 判断数量是否为数字
                        if (isNaN(data.updateData.quantity)) {
                            throw '不能输入其它非数字类型字符';
                        }
                        responseData.data = await ctx.service.materialList.saves(data.updateData, true);
                        break;
                    case 'pastes':
                        responseData.data = await ctx.service.materialList.savePastes(data.updateData, true);
                        // 取所有工料表
                        break;
                    case 'resetChecklist':
                        responseData.data = await ctx.service.materialChecklist.resetData(data.pushData, data.removeData, data.updateData);
                        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 checkAuditAgain(ctx) {
            try {
                if (ctx.query.confirm !== undefined && ctx.query.confirm !== '确认设置终审审批') {
                    throw '请输入正确的文本信息';
                }
                if (ctx.session.sessionUser.loginStatus === 0) {
                    const code = ctx.query.code;
                    const pa = await ctx.service.projectAccount.getDataById(ctx.session.sessionUser.accountId);
                    if (!pa.auth_mobile) {
                        throw '未绑定手机号';
                    }
                    const cacheKey = 'smsCode:' + ctx.session.sessionUser.accountId;
                    const cacheCode = await app.redis.get(cacheKey);
                    if (cacheCode === null || code === undefined || cacheCode !== (code + pa.auth_mobile)) {
                        throw '验证码不正确！';
                    }
                }

                if ((ctx.material.auditors[ctx.material.auditors.length - 1].aid === ctx.session.sessionUser.accountId || (ctx.query.confirm === '确认设置终审审批' && ctx.session.sessionUser.is_admin)) && ctx.material.status === auditConst.status.checked && ctx.material.order === ctx.material.highOrder) {
                    await ctx.service.materialAudit.checkAgain(ctx.material.id, ctx.material.times);
                    // ctx.redirect(ctx.request.header.referer);
                    ctx.body = {
                        err: 0,
                        url: ctx.request.header.referer,
                        msg: '',
                    };
                } else {
                    throw '您无权进行该操作';
                }
            } catch (err) {
                this.log(err);
                // ctx.session.postError = err.toString();
                // ctx.redirect(ctx.request.header.referer);
                ctx.body = {
                    err: 1,
                    // url: ctx.request.header.referer,
                    msg: err,
                };
            }
        }
    }

    return MaterialController;
};