Calculation/app/controller/measure_controller.js

'use strict';

/**
 * 计量相关控制器
 *
 * @author olym
 * @date 2018/2/11
 * @version
 */

const spreadConst = require('../const/spread');
const codeRuleConst = require('../const/code_rule');
const auditConst = require('../const/audit').stage;
const auditType = require('../const/audit').auditType;
const moment = require('moment');
const measureType = require('../const/tender').measureType;
const stdConst = require('../const/standard');

module.exports = app => {

    class MeasureController 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 stage(ctx) {
            try {
                const renderData = {
                    tender: ctx.tender.data,
                    tenderMenu: this.menu.tenderMenu,
                    preUrl: '/tender/' + ctx.tender.id,
                    auditConst,
                    auditConst2: JSON.stringify(auditConst),
                    auditType,
                };
                renderData.stages = await ctx.service.stage.getValidStages(ctx.tender.id, this.ctx.session.sessionUser.is_admin);
                for (const s of renderData.stages) {
                    if (!s.rpt_filed) {
                        s.rpt_filed = await ctx.service.rptArchive.count({ stage_id: s.id });
                        if (s.rpt_filed) await ctx.service.stage.defaultUpdate({ id: s.id, rpt_filed: 1});
                    }
                    if (!s.final_auditor_str || s.status !== auditConst.status.checked) {
                        // 根据期状态返回展示用户
                        if (s.status === auditConst.status.checkNoPre) s.status = auditConst.status.checking;
                        if (s.status !== auditConst.status.checkNo) s.curAuditors = await ctx.service.stageAudit.getAuditorsByStatus(s.id, s.status, s.times);
                        if (s.status === auditConst.status.checked) {
                            const final_auditor_str = (s.curAuditors[0].audit_type === auditType.key.common)
                                ? `${s.curAuditors[0].name}${(s.curAuditors[0].role ? '-' + s.curAuditors[0].role : '')}`
                                : ctx.helper.transFormToChinese(s.curAuditors[0].audit_order) + '审';
                            await ctx.service.stage.defaultUpdate({ id: s.id, final_auditor_str});
                        }
                    }
                }
                renderData.unCompleteStageCount = renderData.stages.filter(s => { return s.status !== auditConst.status.checked; }).length;
                await this.layout('measure/stage.ejs', renderData, 'measure/stage_modal.ejs');
            } catch (err) {
                this.log(err);
                ctx.redirect(this.menu.menu.dashboard.url);
            }
        }

        /**
         * 期审批流程(Get)
         * @param ctx
         * @return {Promise<void>}
         */
        async stageAuditors(ctx) {
            try {
                const order = JSON.parse(ctx.request.body.data).order;
                const tenderId = ctx.params.id;
                const stageInfo = await ctx.service.stage.getDataByCondition({ tid: tenderId, order });
                await ctx.service.stage.loadStageUser(stageInfo);
                await ctx.service.stage.loadStageAuditViewData(stageInfo);
                ctx.body = { err: 0, msg: '', data: stageInfo };
            } 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 && ctx.tender.userAssistsId.indexOf(ctx.session.sessionUser.accountId) < 0) {
                    throw '您无权创建计量期';
                }
                const date = ctx.request.body.date;
                const period = ctx.request.body.period;
                if (!date || !period) {
                    throw '请选择计量年月和开始-截止日期';
                }
                const stages = await ctx.service.stage.getAllDataByCondition({ where: { tid: ctx.tender.id }});
                const unCompleteStageCount = stages.filter(s => { return s.status !== auditConst.status.checked; }).length;
                if (unCompleteStageCount.length > 0) {
                    if (ctx.subProject.page_show.openMultiStageCalc) {
                        if (ctx.tender.info.calc_type === 'tp') throw `【总价合同】不允许新增下一期，请联系管理员`;
                        if (ctx.subProject.page_show.correctCalcContractTp) throw `【反算本期合同计量】不允许新增下一期，请联系管理员`;
                        if (unCompleteStageCount >= ctx.session.sessionProject.page_show.maxMultiStageCount)
                            throw `最多只可同时进行${ctx.session.sessionProject.page_show.maxMultiStageCount}期计量`;
                    } else {
                        throw `最新一起未审批通过，请审批通过后再新增计量`
                    }
                }
                const newStage = await ctx.service.stage.addStage(ctx.tender.data, date, period);
                if (!newStage) {
                    throw '新增计量期失败，请重试';
                }
                ctx.redirect('/tender/' + ctx.tender.id + '/measure/stage/' + newStage.order);
            } catch (err) {
                this.log(err);
                ctx.postError(err, '新增计量期失败');
                ctx.redirect(ctx.request.header.referer);
            }
        }

        /**
         * 编辑期(Post)
         * @param ctx
         * @return {Promise<void>}
         */
        async save(ctx) {
            try {
                const data = {
                    order: ctx.request.body.order,
                    date: ctx.request.body.date,
                    period: ctx.request.body.period,
                };
                const stage = await ctx.service.stage.getDataByCondition({
                    tid: ctx.tender.id,
                    order: data.order,
                });
                if (!stage) {
                    throw '提交数据错误';
                }
                // if (stage.status === auditConst.status.checked) {
                //     throw '该计量期当前不可编辑';
                // }
                if (ctx.session.sessionUser.accountId !== stage.user_id) {
                    throw '您无权修改该数据';
                }
                await this.ctx.service.stage.saveStage(ctx.tender.id, data.order, data.date, data.period);
                ctx.redirect('/tender/' + ctx.tender.id + '/measure/stage/');
            } catch (err) {
                this.log(err);
                ctx.redirect('/tender/' + ctx.tender.id + '/measure/stage/');
            }
        }

        /**
         * 多期汇总 (Get)
         * @param ctx
         * @return {Promise<void>}
         */
        async gather(ctx) {
            try {
                const renderData = {
                    tender: ctx.tender.data,
                    tenderMenu: this.menu.tenderMenu,
                    preUrl: '/tender/' + ctx.tender.id,
                };
                await this.layout('measure/gather.ejs', renderData);
            } catch (err) {
                this.log(err);
                ctx.redirect(this.menu.menu.dashboard.url);
            }
        }

        /**
         * 多期比较(Get)
         * @param ctx
         * @return {Promise<void>}
         */
        async compare(ctx) {
            try {
                const renderData = {
                    tender: ctx.tender.data,
                    tenderMenu: this.menu.tenderMenu,
                    preUrl: '/tender/' + ctx.tender.id,
                };
                renderData.stages = await ctx.service.stage.getAllDataByCondition({
                    where: { tid: ctx.tender.id, status: auditConst.status.checked },
                    orders: [['order', 'asc']],
                });
                renderData.jsFiles = this.app.jsFiles.common.concat(this.app.jsFiles.measure.compare);
                await this.layout('measure/compare.ejs', renderData, 'measure/compare_modal.ejs');
            } catch (err) {
                this.log(err);
                ctx.redirect(this.menu.menu.dashboard.url);
            }
        }

        joinData(main, idField, rela) {
            const index = {},
                indexPre = 'id_';
            const loadFields = function(datas, fields, prefix, relaId) {
                for (const d of datas) {
                    const key = indexPre + d[relaId];
                    let m = index[key];
                    if (!m) {
                        m = {};
                        m[idField] = d[relaId];
                        main.push(m);
                        index[indexPre + d[relaId]] = m;
                    }
                    for (const f of fields) {
                        if (d[f] !== undefined) {
                            m[prefix + f] = d[f];
                        }
                    }
                }
            };
            for (const m of main) {
                index[indexPre + m[idField]] = m;
                for (const r of rela) {
                    if (r.defaultData) _.assignIn(m, r.defaultData);
                }
            }
            for (const r of rela) {
                loadFields(r.data, r.fields, r.prefix, r.relaId);
            }
        }

        /**
         * 多期比较 - 获取数据(Ajax)
         * @param ctx
         * @return {Promise<void>}
         */
        async loadCompareData(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                const result = {
                    main: null,
                    stages: [],
                };
                if (data.main) {
                    result.main = {};
                    result.main.ledger = await ctx.service.ledger.getData(ctx.tender.id);
                    result.main.pos = await ctx.service.pos.getPosData({ tid: ctx.tender.id });
                    result.main.deal = await ctx.service.dealBills.getAllDataByCondition({ where: { tender_id: ctx.tender.id } });
                }
                if (data.stages) {
                    for (const order of data.stages) {
                        const data = { order, bills: [], pos: [] };
                        const stage = await this.ctx.service.stage.getDataByCondition({ tid: ctx.tender.id, order });
                        data.bills = await ctx.service.stageBills.getLastestStageData2(ctx.tender.id, stage.id);
                        const bpcData = await ctx.service.stageBillsPc.getAllDataByCondition({ where: { sid: stage.id } });
                        this.joinData(data.bills, 'lid', [
                            { data: bpcData, fields: ['contract_pc_tp', 'qc_pc_tp', 'pc_tp'], prefix: '', relaId: 'lid' },
                        ]);
                        data.pos = await ctx.service.stagePos.getLastestStageData2(ctx.tender.id, stage.id);
                        result.stages.push(data);
                    }
                }
                const zlj = JSON.parse(JSON.stringify(stdConst.zlj));
                zlj.deal_bills_tp = ctx.tender.info.deal_param.zanLiePrice;
                result.spec = { zlj: zlj, jrg: stdConst.jrg };
                ctx.body = { err: 0, msg: '', data: result };
            } catch (err) {
                this.log(err);
                ctx.body = this.ajaxErrorBody(err, '获取数据错误');
            }
        }

        /**
         * 删除期(Post)
         * @param ctx
         * @return {Promise<void>}
         */
        async delete(ctx) {
            try {
                const stage_id = ctx.request.body.stage_id;
                const stageInfo = await ctx.service.stage.getDataById(stage_id);
                // 获取最新的期数
                const stage_highOrder = await ctx.service.stage.count({
                    tid: ctx.tender.id,
                });

                const readySettle = await ctx.service.settle.getReadySettle(stageInfo.tid);
                if (readySettle && readySettle.final_sorder >= stageInfo.order) {
                    throw '已结算，不可删除';
                }
                if (ctx.request.body.confirm !== undefined && ctx.request.body.confirm !== '确认删除本期') {
                    throw '请输入正确的文本信息';
                }
                const relaStage = await ctx.service.stageRela.getDataByCondition({ rela_sid: stage_id });
                if (relaStage) throw `该期已关联到标段"${relaStage.rela_tname}"，不可删除`;
                if (stageInfo && (ctx.session.sessionUser.accountId === stageInfo.user_id || (ctx.session.sessionUser.is_admin && ctx.request.body.confirm === '确认删除本期')) && stage_highOrder === stageInfo.order) {
                    const result = await ctx.service.stage.deleteStage(stage_id);
                    if (!result) {
                        throw '删除计量期失败，请重试';
                    }
                } else {
                    throw '您无权删除计量期';
                }
                if (ctx.request.body.stage_order !== undefined && parseInt(ctx.request.body.stage_order) !== stage_highOrder) {
                    ctx.redirect(ctx.request.header.referer);
                } else {
                    ctx.redirect('/tender/' + ctx.tender.id + '/measure/stage/');
                }
            } catch (err) {
                this.log(err);
                console.log(err);
                ctx.session.postError = err.toString();
                ctx.redirect(ctx.request.header.referer);
            }
        }
    }

    return MeasureController;
};