Calculation/app/controller/schedule_controller.js

'use strict';

/**
 *
 *
 * @author Ellisran
 * @date 2020/7/2
 * @version
 */

const moment = require('moment');
const reviseStatus = require('../const/audit').revise.status;
const measureType = require('../const/tender').measureType;
const scheduleConst = require('../const/schedule');
const billsPosConvert = require('../lib/bills_pos_convert');
const _ = require('lodash');

module.exports = app => {
    class ScheduleController extends app.BaseController {

        async _getSelectedLedgerList(ctx) {
            const scheduleLedgerList = await ctx.service.scheduleLedger.getAllDataByCondition({ where: { tid: ctx.tender.id } });
            return _.map(scheduleLedgerList, 'ledger_id');
        }

        async _getLastPlanMonth(ctx) {
            const lastMonth = await ctx.service.scheduleMonth.getLastPlanMonth();
            return lastMonth && lastMonth[0] && lastMonth[0].yearmonth ? lastMonth[0].yearmonth : null;
        }

        async _getLastReviseStatus(ctx) {
            const lastRevise = await ctx.service.ledgerRevise.getLastestRevise(ctx.tender.id);
            return (lastRevise && lastRevise.status !== reviseStatus.checked) || false;
        }

        async _checkScheduleCanModify(ctx) {
            if (await this._getLastReviseStatus(ctx)) {
                throw '台账修订中，请勿修改提交进度数据';
            }
        }

        async index(ctx) {
            try {
                const scheduleInfo = await ctx.service.schedule.getDataByCondition({ tid: ctx.tender.id });
                const scheduleMonth = await ctx.service.scheduleMonth.getAllDataByCondition({ where: { tid: ctx.tender.id }, orders: [['yearmonth', 'asc']] });
                const renderData = {
                    scheduleInfo,
                    scheduleMonth,
                    tender: ctx.tender.data,
                    tenderMenu: this.menu.tenderMenu,
                    planMonth: await this._getLastPlanMonth(ctx),
                    scheduleLedgerList: await this._getSelectedLedgerList(ctx),
                    preUrl: '/tender/' + ctx.tender.id,
                    revising: await this._getLastReviseStatus(ctx),
                };
                await this.layout('schedule/index.ejs', renderData, 'schedule/modal.ejs');
            } catch (err) {
                this.log(err);
                ctx.redirect(this.menu.menu.dashboard.url);
            }
        }

        async ledger(ctx) {
            const tender = ctx.tender;
            const scheduleLedgerList = await this._getSelectedLedgerList(ctx);
            const allSlmList = await ctx.service.scheduleLedgerMonth.getAllDataByCondition({ where: { tid: ctx.tender.id } });
            const hadDataLidList = [];
            for (const sl of scheduleLedgerList) {
                const info = _.find(allSlmList, function(item) {
                    return item.lid === sl && ((item.plan_tp !== null && item.plan_tp !== 0) ||
                        (item.plan_gcl !== null && item.plan_gcl !== 0) ||
                        (item.sj_tp !== null && item.sj_tp !== 0) ||
                        (item.sj_gcl !== null && item.sj_gcl !== 0));
                });
                if (info) {
                    hadDataLidList.push(info.lid);
                }
            }
            const renderData = {
                tender: tender.data,
                tenderInfo: tender.info,
                measureType,
                scheduleLedgerList,
                hadDataLidList,
                jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.schedule.ledger),
                revising: await this._getLastReviseStatus(ctx),
            };
            await this.layout('schedule/ledger.ejs', renderData, 'schedule/modal.ejs');
        }

        async plan(ctx) {
            const tender = ctx.tender;
            const schedule = await ctx.service.schedule.getDataByCondition({ tid: tender.id });
            const scheduleMonth = await ctx.service.scheduleMonth.getAllDataByCondition({ where: { tid: tender.id }, orders: [['yearmonth', 'asc']] });
            const renderData = {
                tender: tender.data,
                tenderInfo: tender.info,
                schedule,
                scheduleMonth,
                planMonth: await this._getLastPlanMonth(ctx),
                measureType,
                mode: scheduleConst.plan_mode,
                scheduleLedgerList: await this._getSelectedLedgerList(ctx),
                jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.schedule.plan),
                revising: await this._getLastReviseStatus(ctx),
            };
            await this.layout('schedule/plan.ejs', renderData, 'schedule/plan_modal.ejs');
        }

        async stageTp(ctx) {
            const tender = ctx.tender;
            const schedule = await ctx.service.schedule.getDataByCondition({ tid: tender.id });
            const scheduleMonth = await ctx.service.scheduleMonth.getAllDataByCondition({ where: { tid: tender.id }, orders: [['yearmonth', 'asc']] });
            const stageOrderList = await ctx.service.stage.getAllDataByCondition({ columns: ['id', 's_time', 'order'], where: { tid: tender.id } });
            const scheduleStage = await ctx.service.scheduleStage.getAllDataByCondition({ where: { tid: tender.id }, orders: [['order', 'desc']] });
            let curScheduleStage = scheduleStage.length > 0 ? _.maxBy(scheduleStage, 'order') : null;
            let slmList = [];
            let nextSlmList = [];
            let endSlmList = [];
            let yearSlmList = [];
            let curYearStageData = [];
            if (ctx.params.order && scheduleStage.length > 0) {
                curScheduleStage = _.find(scheduleStage, { order: parseInt(ctx.params.order) });
            }
            if (curScheduleStage) {
                // const newSS = _.sortBy(scheduleStage, 'yearmonth');
                const newSM = _.sortBy(scheduleMonth, 'yearmonth');
                const nowScheduleStage = _.findIndex(newSM, { yearmonth: curScheduleStage.yearmonth });
                slmList = await ctx.service.scheduleLedgerMonth.getAllDataByCondition({ where: { tid: tender.id, yearmonth: curScheduleStage.yearmonth } });
                const nextScheduleStage = nowScheduleStage >= 0 && nowScheduleStage + 1 <= newSM.length - 1 ? newSM[nowScheduleStage + 1] : null;
                if (nextScheduleStage) nextSlmList = await ctx.service.scheduleLedgerMonth.getAllDataByCondition({ where: { tid: tender.id, yearmonth: nextScheduleStage.yearmonth } });
                if (nowScheduleStage === 0) {
                    endSlmList = slmList;
                } else if (nowScheduleStage > 0) {
                    const endYearmonthCollection = _.map(_.take(newSM, nowScheduleStage + 1), 'yearmonth');
                    endSlmList = await ctx.service.scheduleLedgerMonth.getConllectionList(tender.id, endYearmonthCollection);
                }
                const yearConllection = _.map(_.filter(newSM, function(item) {
                    return item.yearmonth.indexOf(curScheduleStage.yearmonth.split('-')[0]) !== -1;
                }), 'yearmonth');
                yearSlmList = await ctx.service.scheduleLedgerMonth.getConllectionList(tender.id, yearConllection);
                // 获取本年完成计量数据
                const curStage = _.find(stageOrderList, { order: curScheduleStage.order });
                const stageList = _.filter(stageOrderList, function(item) {
                    return item.s_time.indexOf(curStage.s_time.split('-')[0]) !== -1;
                });
                const newSS = _.sortBy(scheduleStage, 'yearmonth');
                const stageIdList = _.map(_.filter(stageList, function(item) {
                    return _.find(newSS, { order: item.order });
                }), 'id');
                curYearStageData = await ctx.service.stageBills.getStagesData(ctx.tender.id, stageIdList.join(','));
            }
            const renderData = {
                tender: tender.data,
                tenderInfo: tender.info,
                schedule,
                scheduleMonth,
                measureType,
                stageOrderList,
                scheduleStage,
                curScheduleStage,
                slmList,
                nextSlmList,
                endSlmList,
                yearSlmList,
                curYearStageData,
                scheduleLedgerList: await this._getSelectedLedgerList(ctx),
                revising: await this._getLastReviseStatus(ctx),
                jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.schedule.stageTp),
            };
            await this.layout('schedule/stage_tp.ejs', renderData, 'schedule/stage_tp_modal.ejs');
        }

        async stageGcl(ctx) {
            const tender = ctx.tender;
            const schedule = await ctx.service.schedule.getDataByCondition({ tid: tender.id });
            const scheduleMonth = await ctx.service.scheduleMonth.getAllDataByCondition({ where: { tid: tender.id }, orders: [['yearmonth', 'asc']] });
            const scheduleStage = await ctx.service.scheduleStage.getAllDataByCondition({ where: { tid: tender.id }, orders: [['order', 'desc']] });
            const curScheduleStage = scheduleStage.length > 0 ? _.maxBy(scheduleStage, 'order') : null;
            const renderData = {
                tender: tender.data,
                tenderInfo: tender.info,
                schedule,
                scheduleMonth,
                measureType,
                scheduleStage,
                curScheduleStage,
                scheduleLedgerList: await this._getSelectedLedgerList(ctx),
                revising: await this._getLastReviseStatus(ctx),
                jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.schedule.stageGcl),
            };
            await this.layout('schedule/stage_gcl.ejs', renderData, 'schedule/stage_gcl_modal.ejs');
        }

        /**
         * 获取金额模式下台账数据(Ajax)
         *
         * @param ctx
         * @return {Promise<void>}
         */
        async loadTpLedgerData(ctx) {
            try {
                const tender = ctx.tender;
                // const ledgerData = await ctx.controller.stage._getStageLedgerData(ctx);
                // console.log(ledgerData);
                const scheduleMonth = await ctx.service.scheduleMonth.getAllDataByCondition({ where: { tid: tender.id }, orders: [['yearmonth', 'asc']] });
                const stageOrderList = await ctx.service.stage.getAllDataByCondition({ columns: ['id', 's_time', 'order'], where: { tid: tender.id } });
                const scheduleStage = await ctx.service.scheduleStage.getAllDataByCondition({ where: { tid: tender.id }, orders: [['order', 'desc']] });
                const curScheduleStage = _.find(scheduleStage, { order: parseInt(ctx.params.order) });
                let slmList = [];
                let nextSlmList = [];
                let endSlmList = [];
                let yearSlmList = [];
                let curYearStageData = [];
                if (curScheduleStage) {
                    const newSM = _.sortBy(scheduleMonth, 'yearmonth');
                    const nowScheduleStage = _.findIndex(newSM, { yearmonth: curScheduleStage.yearmonth });
                    slmList = await ctx.service.scheduleLedgerMonth.getAllDataByCondition({ where: { tid: tender.id, yearmonth: curScheduleStage.yearmonth } });
                    const nextScheduleStage = nowScheduleStage >= 0 && nowScheduleStage + 1 <= newSM.length - 1 ? newSM[nowScheduleStage + 1] : null;
                    if (nextScheduleStage) nextSlmList = await ctx.service.scheduleLedgerMonth.getAllDataByCondition({ where: { tid: tender.id, yearmonth: nextScheduleStage.yearmonth } });
                    if (nowScheduleStage === 0) {
                        endSlmList = slmList;
                    } else if (nowScheduleStage > 0) {
                        const endYearmonthCollection = _.map(_.take(newSM, nowScheduleStage + 1), 'yearmonth');
                        endSlmList = await ctx.service.scheduleLedgerMonth.getConllectionList(tender.id, endYearmonthCollection);
                    }
                    const yearConllection = _.map(_.filter(newSM, function(item) {
                        return item.yearmonth.indexOf(curScheduleStage.yearmonth.split('-')[0]) !== -1;
                    }), 'yearmonth');
                    yearSlmList = await ctx.service.scheduleLedgerMonth.getConllectionList(tender.id, yearConllection);
                    // 获取本年完成计量数据
                    const curStage = _.find(stageOrderList, { order: curScheduleStage.order });
                    const stageList = _.filter(stageOrderList, function(item) {
                        return item.s_time.indexOf(curStage.s_time.split('-')[0]) !== -1;
                    });
                    const newSS = _.sortBy(scheduleStage, 'yearmonth');
                    const stageIdList = _.map(_.filter(stageList, function(item) {
                        return _.find(newSS, { order: item.order });
                    }), 'id');
                    curYearStageData = await ctx.service.stageBills.getStagesData(tender.id, stageIdList.join(','));
                }
                ctx.body = { err: 0, msg: '', data: {
                    // ledgerData,
                    slmList,
                    nextSlmList,
                    endSlmList,
                    yearSlmList,
                    curYearStageData,
                } };
            } catch (err) {
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: [] };
            }
        }

        /**
         * 获取台账数据(Ajax)
         *
         * @param ctx
         * @return {Promise<void>}
         */
        async loadLedgerData(ctx) {
            try {
                const ledgerData = await ctx.service.ledger.getData(ctx.tender.id);
                // const posData = ctx.tender.data.measure_type === measureType.tz.value
                //     ? await ctx.service.pos.getPosData({ tid: ctx.tender.id }) : [];
                // const convert = new billsPosConvert(ctx);
                // convert.loadData(ledgerData, posData, []);
                // const result = await convert.convert();
                const scheduleLedgerMonthData = await ctx.service.scheduleLedgerMonth.getAllDataByCondition({ where: { tid: ctx.tender.id } });
                ctx.body = { err: 0, msg: '', data: { bills: ledgerData, slm: scheduleLedgerMonthData } };
            } catch (err) {
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: [] };
            }
        }

        /**
         * 台账选中提交(Ajax)
         *
         * @param ctx
         * @return {Promise<void>}
         */
        async saveLedger(ctx) {
            try {
                await this._checkScheduleCanModify(ctx);
                const data = JSON.parse(ctx.request.body.data);
                const result = await ctx.service.scheduleLedger.saveLedger(data);
                ctx.body = { err: 0, msg: '', data: result };
            } catch (err) {
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: [] };
            }
        }

        /**
         * 计划进度计算方式提交(Ajax)
         *
         * @param ctx
         * @return {Promise<void>}
         */
        async savePlan(ctx) {
            try {
                await this._checkScheduleCanModify(ctx);
                const data = JSON.parse(ctx.request.body.data);
                const responseData = {
                    err: 0,
                    msg: '',
                    data: {},
                };
                switch (data.type) {
                    case 'mode':
                        responseData.data = await ctx.service.schedule.saveMode(data.postData);
                        break;
                    case 'addmonth':
                        responseData.data = await ctx.service.scheduleMonth.add(data.postData);
                        break;
                    case 'delmonth':
                        responseData.data = await ctx.service.scheduleMonth.del(data.postData);
                        break;
                    case 'ledger_edit':
                        responseData.data = await ctx.service.scheduleLedgerMonth.save(data.postData);
                        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 saveStageTp(ctx) {
            try {
                await this._checkScheduleCanModify(ctx);
                const data = JSON.parse(ctx.request.body.data);
                const responseData = {
                    err: 0,
                    msg: '',
                    data: {},
                };
                switch (data.type) {
                    case 'add_stage':
                        responseData.data = await ctx.service.scheduleStage.add(data.postData);
                        break;
                    case 'del_stage':
                        responseData.data = await ctx.service.scheduleStage.del(data.postData);
                        break;
                    case 'reload_stage':
                        responseData.data = await ctx.service.scheduleStage.changeOrder(data.postData);
                        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 saveStageGcl(ctx) {
            try {
                await this._checkScheduleCanModify(ctx);
                const data = JSON.parse(ctx.request.body.data);
                const responseData = {
                    err: 0,
                    msg: '',
                    data: {},
                };
                switch (data.type) {
                    case 'add_stage':
                        responseData.data = await ctx.service.scheduleMonth.addStageUsed(data.postData);
                        break;
                    case 'del_stage':
                        responseData.data = await ctx.service.scheduleMonth.delStageUsed(data.postData);
                        break;
                    case 'ledger_edit':
                        responseData.data = await ctx.service.scheduleLedgerMonth.saveSj(data.postData);
                        break;
                    default: throw '参数有误';
                }
                ctx.body = responseData;
            } catch (err) {
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }
    }

    return ScheduleController;
};