Calculation/app/controller/stage_controller.js

'use strict';

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

const moment = require('moment');
const auditConst = require('../const/audit');
const spreadConst = require('../const/spread');
const tenderConst = require('../const/tender');
const measureType = tenderConst.measureType;

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

        /**
         * 获取通用的renderData（用于layout, Menu, subMenu部分）
         * @param ctx
         * @returns {{tender, tenderMenu, auditConst}}
         * @private
         */
        _getDefaultRenderData (ctx) {
            const data = {
                tender: ctx.tender.data,
                tenderMenu: JSON.parse(JSON.stringify(this.menu.stageMenu)),
                auditConst: auditConst.flow,
                measureType,
                preUrl: '/tender/' + ctx.tender.id + '/measure/stage/' + ctx.params.order,
                stage: ctx.stage,
            };
            data.tenderMenu.back.children[0].url = '/tender/' + ctx.tender.id + '/measure/stage';
            return data;
        }

        _stageReadOnly(stage) {
            return stage.status === auditConst.flow.status.checked;
        }

        /**
         * 获取SpreadSetting
         * @private
         */
        _getSpreadSetting() {
            const _ = this.app._;
            function removeFieldCols(setting, cols) {
                _.remove(setting.cols, function (c) {
                    return cols.indexOf(c.field) > -1;
                });
            }
            function setColFormat(cols, field, formatter) {
                const filterCols = cols.filter(function (c) {
                    return c.field.search(field) !== -1;
                });
                for (const col of filterCols) {
                    col.formatter = formatter;
                }
            }
            const tpFormatter = this.ctx.helper.getNumberFormatter(this.ctx.tender.info.decimal.tp);
            const upFormatter = this.ctx.helper.getNumberFormatter(2);
            const ledger = JSON.parse(JSON.stringify(spreadConst.stage.ledger));
            setColFormat(ledger.cols, 'unit_price', upFormatter);
            setColFormat(ledger.cols, 'total_price', tpFormatter);
            setColFormat(ledger.cols, 'tp', tpFormatter);
            const pos = JSON.parse(JSON.stringify(spreadConst.stage.pos));
            const tender = this.ctx.tender, stage = this.ctx.stage;
            if (this._stageReadOnly(stage)) {
                ledger.readOnly = true;
                pos.readOnly = true;
            }
            if (tender.data.measure_type === measureType.tz.value) {
                removeFieldCols(ledger, spreadConst.filterCols.tzWithoutCols);
                removeFieldCols(pos, spreadConst.filterCols.posTzWithoutCols);
            }
            if (!tender.info.display.ledger.dgnQty) {
                removeFieldCols(ledger, spreadConst.filterCols.dgnCols);
            }
            return [ledger, pos];
        }

        /**
         * 获取期数据
         * @param ctx
         * @returns {Promise<void>}
         * @private
         */
        async _getStage(ctx) {
            const stageOrder = parseInt(ctx.params.order);
            ctx.stage = await ctx.service.stage.getDataByCondition({
                tid: ctx.tender.id,
                order: stageOrder,
            });
        }

        /**
         * 期计量页面 (Get)
         * @param {Object} ctx - egg全局变量
         * @returns {Promise<void>}
         */
        async index(ctx) {
            try {
                await this._getStage(ctx);
                const renderData = this._getDefaultRenderData(ctx);
                [renderData.ledgerSpread, renderData.posSpread] = this._getSpreadSetting();
                renderData.ledgerData = await ctx.service.ledger.getDataByTenderId(ctx.tender.id, -1);
                renderData.curStageData = await ctx.service.stageBills.getAuditorStageData(ctx.tender.id, ctx.stage.id, ctx.stage.times, 0);
                renderData.jsFiles = this.app.jsFiles.common.concat(this.app.jsFiles.stage.index);
                // 查询截止上期数据
                //if (ctx.stage.order > 0) {
                    //renderData.preStageData
                //}
                await this.layout('stage/index.ejs', renderData, 'stage/modal.ejs');
            } catch (err) {
                this.log(err);
                ctx.redirect('/tender/' + ctx.tender.id + '/measure/stage');
            }
        }

        /**
         * 获取期数据(截止上期 & 本期)
         * @param ctx
         * @returns {Promise<void>}
         */
        async getStagePosData(ctx) {
            try {
                await this._getStage(ctx);
                const condition = JSON.parse(ctx.request.body.data) || {};
                condition.tid = ctx.tender.id;
                const responseData = {err: 0, msg: '', data: {}};
                responseData.data.pos = await ctx.service.pos.getPosData(condition);
                // todo 根据当前人，或指定对象查询数据
                responseData.data.curStageData = await ctx.service.stagePos.getAuditorStageData(ctx.tender.id,
                    ctx.stage.id, ctx.stage.times, ctx.stage.curAuditor ? ctx.stage.curAuditor.order : 0,
                    this.app._.map(responseData.data.pos, 'id'));
                ctx.body = responseData;
            } catch (err) {
                this.log(err);
                ctx.body = {err: 1, msg: err.toString(), data: null};
            }
        }

        /**
         * 保存数据
         * @param ctx
         * @returns {Promise<void>}
         */
        async updateStageData(ctx) {
            try {
                await this._getStage(ctx);
                // 检查登录用户，是否可操作
                if (ctx.session.sessionUser.accountId === ctx.stage.user_id) {
                    if (ctx.stage.status === auditConst.flow.status.checking || ctx.stage.status === auditConst.flow.status.checked) {
                        throw '该计量期当前您无权操作';
                    }
                } else {
                    // 检查是否可修改
                    //const curAuditor = await ctx.service.stageAudit.get
                }

                const data = JSON.parse(ctx.request.body.data);
                const responseData = { err: 0, msg: '', data: {}, };
                if (data.pos) {
                    responseData.data = await ctx.service.stagePos.updateStageData(data.pos);
                } else if (data.bills) {
                    responseData.data.bills = await ctx.service.stageBills.updateStageData(data.bills);
                }
                ctx.body = responseData;
            } catch (err) {
                this.log(err);
                ctx.body = {err: 1, msg: err.toString(), data: null};
            }
        }

        /**
         * 中间计量
         * @param ctx
         * @returns {Promise<void>}
         */
        async detail(ctx) {
            try {
                await this._getStage(ctx);
                const renderData = this._getDefaultRenderData(ctx);
                renderData.jsFiles = this.app.jsFiles.common.concat(this.app.jsFiles.stage.detail);
                renderData.imType = tenderConst.imType;
                await this.layout('stage/detail.ejs', renderData, 'stage/detail_modal.ejs');
            } catch (err) {
                this.log(err);
                ctx.redirect('/tender/' + ctx.tender.id + '/measure/stage');
            }
        }

        /**
         * 设置中间计量生成规则，并生成中间计量数据
         * @param ctx
         * @returns {Promise<void>}
         */
        async buildDetailData (ctx) {
            try {
                await this._getStage(ctx);
                // 检查登录用户，是否可操作
                if (ctx.session.sessionUser.accountId === ctx.stage.user_id) {
                    if (ctx.stage.status === auditConst.flow.status.checking || ctx.stage.status === auditConst.flow.status.checked) {
                        throw '该计量期当前您无权操作';
                    }
                }

                const data = JSON.parse(ctx.request.body.data);
                await ctx.service.stage.buildDetailData(ctx.tender.id, ctx.stage.order, data);

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

        /**
         * 加载数据
         * @param ctx
         * @returns {Promise<void>}
         */
        async loadDetailRelaData(ctx) {
            try {
                await this._getStage(ctx);
                const data = JSON.parse(ctx.request.body.data);
                // 加载台账数据
                if (data.loadType === 'ledger') {
                    const ledgerData = await ctx.service.ledger.getDataByTenderId(ctx.tender.id, -1);
                    ctx.body = {err: 0, msg: '', data: ledgerData };
                } else if (data.loadType === 'all') {
                    const ledger = await ctx.service.ledger.getDataByTenderId(ctx.tender.id, -1);
                    const curStage = await ctx.service.stageBills.getLastestStageData(ctx.tender.id, ctx.stage.id);
                    ctx.body = {
                        err: 0,
                        msg: '',
                        data: {
                            ledger,
                            curStage,
                            stageDetail: [],
                        }
                    };
                }
            } catch (err) {
                this.log(err);
                ctx.body = {err: 1, msg: err.toString(), data: null};
            }
        }

        /**
         * 中间计量，生成规则，高级设置
         * @param ctx
         * @returns {Promise<void>}
         */
        async setAdvancedConfig(ctx) {
            try {
                await this._getStage(ctx);
                // 检查登录用户，是否可操作
                if (ctx.session.sessionUser.accountId === ctx.stage.user_id) {
                    if (ctx.stage.status === auditConst.flow.status.checking || ctx.stage.status === auditConst.flow.status.checked) {
                        throw '该计量期当前您无权操作';
                    }
                }

                const data = JSON.parse(ctx.request.body.data);
                await ctx.service.stage.update(data, { id: ctx.stage.id });

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

        /**
         * 合同支付
         * @param ctx
         * @returns {Promise<void>}
         */
        async pay(ctx) {
            try {
                await this._getStage(ctx);
                const renderData = this._getDefaultRenderData(ctx);
                await this.layout('stage/pay.ejs', renderData, 'stage/pay_modal.ejs');
            } catch (err) {
                this.log(err);
                ctx.redirect('/tender/' + ctx.tender.id + '/measure/stage');
            }
        }

        /**
         * 变更令
         * @param ctx
         * @returns {Promise<void>}
         */
        async change(ctx) {
            try {
                await this._getStage(ctx);
                const renderData = this._getDefaultRenderData(ctx);
                await this.layout('stage/change.ejs', renderData);
            } catch (err) {
                this.log(err);
                ctx.redirect('/tender/' + ctx.tender.id + '/measure/stage');
            }
        }

        /**
         * 审核比较
         * @param ctx
         * @returns {Promise<void>}
         */
        async compare(ctx) {
            try {
                await this._getStage(ctx);
                const renderData = this._getDefaultRenderData(ctx);
                await this.layout('stage/compare.ejs', renderData, 'stage/compare_modal.ejs');
            } catch (err) {
                this.log(err);
                ctx.redirect('/tender/' + ctx.tender.id + '/measure/stage');
            }
        }

        /**
         * 报表
         * @param ctx
         * @returns {Promise<void>}
         */
        async report(ctx) {
            try {
                await this._getStage(ctx);
                const renderData = this._getDefaultRenderData(ctx);
                await this.layout('stage/report.ejs', renderData, 'stage/report_modal.ejs');
            } catch (err) {
                this.log(err);
                ctx.redirect('/tender/' + ctx.tender.id + '/measure/stage');
            }
        }
    }

    return StageController;
};