Calculation/app/controller/budget_controller.js

'use strict';

/**
 *
 *
 * @author Mai
 * @date 2021/10/27
 * @version
 */
const stdDataAddType = {
    withParent: 1,
    child: 2,
    next: 3,
};
const auditConst = require('../const/audit');
const changeConst = require('../const/change');
const LzString = require('lz-string');
const accountGroup = require('../const/account_group').group;
const ValidDskProject = {
    gu: [15, 16],
    gai: [5],
    yu: [1, 18],
    zb: [4, 18, 19],
    ctrl: [4, 18, 19],
};
const DSK = require('../lib/dsk');
const sendToWormhole = require('stream-wormhole');
const streamToArray = require('stream-to-array');

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

        /**
         * 概算投资
         *
         * @param ctx
         * @returns {Promise<void>}
         */
        async list(ctx) {
            try {
                if (!ctx.subProject.page_show.openBudget) throw '该功能已关闭或无法查看';
                const renderData = {
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.budget.list),
                    auditConst,
                };
                renderData.budgetList = await ctx.service.subProject.getBudgetProject(ctx.session.sessionProject.id, ctx.session.sessionUser.accountId, ctx.session.sessionUser.is_admin);
                renderData.budgetStd = await ctx.service.budgetStd.getDataByProjectId(ctx.session.sessionProject.id);
                for (const bl of renderData.budgetList) {
                    if (bl.is_folder) continue;
                    bl.gu_tp = await ctx.service.budgetGu.getSumTp(bl.budget_id);
                    bl.gai_tp = await ctx.service.budgetGai.getSumTp(bl.budget_id);
                    bl.yu_tp = await ctx.service.budgetYu.getSumTp(bl.budget_id);
                    bl.zb_tp = await ctx.service.budgetZb.getSumTp(bl.budget_id);
                    bl.ctrl_tp = await ctx.service.budgetCtrl.getSumTp(bl.budget_id);
                }
                renderData.tenderList = await ctx.service.tender.getList4Select('stage');
                renderData.categoryData = await this.ctx.service.category.getAllCategory(ctx.subProject);
                await this.layout('budget/list.ejs', renderData, 'budget/list_modal.ejs');
            } catch (err) {
                ctx.log(err);
                ctx.session.postError = err.toString();
                ctx.redirect(this.menu.menu.dashboard.url);
            }
        }

        async budgetInfo(ctx) {
            try {
                // 获取变更费用前10的变更令
                const changeList = await ctx.service.change.getListByBudgetInfo(ctx.budget.rela_tender);
                // 获取变更后总金额
                const total_change_tp = await ctx.service.change.getTotalTpByBudgetInfo(ctx.budget.rela_tender);
                const renderData = {
                    changeList,
                    changeConst,
                    total_change_tp,
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.budget.info),
                    auditConst,
                };
                // const relaTenderId = ctx.helper._.map(ctx.budget.rela_tender.split(','), ctx.helper._.toInteger);
                // const tenderList = await ctx.service.tender.getList4Select('stage');
                // renderData.tenderList = relaTenderId.length > 0 ? tenderList.filter(x => {
                //     return relaTenderId.indexOf(x.id) >= 0;
                // }) : tenderList;
                // renderData.tenderList = renderData.tenderList.map(y => {
                //     return { id: y.id, name: y.name, lastStageOrder: y.lastStage.order, lastStageStatus: auditConst.stage.statusString[y.lastStage.status], category: y.category };
                // });
                // renderData.categoryData = await this.ctx.service.category.getAllCategory(ctx.subProject);
                await this.layout('budget/info.ejs', renderData);
            } catch (err) {
                ctx.log(err);
            }
        }

        async _getContractTree(condition) {
            const data = await this.ctx.service.contractTree.getAllDataByCondition({ where: condition });
            const contract_data = await this.ctx.service.contract.getAllDataByCondition({ where: condition });
            return [...data, ...contract_data];
        }

        async compare(ctx) {
            try {
                const renderData = {
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.budget.compare),
                    auditConst,
                };
                const tenderList = await ctx.service.tender.getList4Select('stage');
                renderData.tenderList = tenderList.filter(x => {
                    return !x.filter_budget;
                });
                renderData.tenderList = renderData.tenderList.map(y => {
                    return { id: y.id, name: y.name, lastStageOrder: y.lastStage.order, lastStageStatus: auditConst.stage.statusString[y.lastStage.status], category: y.category };
                });
                renderData.categoryData = await this.ctx.service.category.getAllCategory(ctx.subProject);
                renderData.contract = await this._getContractTree({ spid: this.ctx.subProject.id, contract_type: 1 });
                await this.layout('budget/compare.ejs', renderData, 'budget/compare_modal.ejs');
            } catch (err) {
                ctx.log(err);
            }
        }

        async compareLoad(ctx) {
            try {
                const data = {};
                if (ctx.budget.final_id) {
                    data.final = await ctx.service.budgetFinal.getAllDataByCondition({ where: { final_id: ctx.budget.final_id } });
                    data.finalInfo = await ctx.service.budgetFinalList.getFinal(ctx.budget.final_id);
                    await ctx.service.budgetFinalList.clearExpiredFinal(ctx.budget);
                } else {
                    data.gu = await ctx.service.budgetGu.getData(ctx.budget.id);
                    data.gai = await ctx.service.budgetGai.getData(ctx.budget.id);
                    data.yu = await ctx.service.budgetYu.getData(ctx.budget.id);
                    data.zb = await ctx.service.budgetZb.getData(ctx.budget.id);
                    data.ctrl = await ctx.service.budgetCtrl.getData(ctx.budget.id);
                }
                ctx.body = { err: 0, msg: '', data };
            } catch (err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '获取数据错误');
            }
        }
        async compareFinal(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                if (data.final_type !== ctx.budget.final_type) {
                    await ctx.service.budget.defaultUpdate({ id: ctx.budget.id, final_type: data.final_type });
                    ctx.budget.final_type = data.final_type;
                }
                if (ctx.budget.final_id && data.final_id !== ctx.budget.final_id) {
                    const final = await ctx.service.budgetFinal.getAllDataByCondition({ where: { final_id: ctx.budget.final_id } });
                    const finalInfo = await ctx.service.budgetFinalList.getFinal(ctx.budget.final_id);
                    ctx.body = { err: 0, msg: `决算数据已在${ctx.moment(finalInfo.update_time).format('YYYY-DD-MM HH:mm:ss')}更新，请先查看后再决定是否生成`, data: { final, finalInfo } };
                } else {
                    const finalInfo = await ctx.service.budgetFinalList.addFinal(ctx.budget, data.id);
                    const final = await ctx.service.budget.doFinal(ctx.budget, finalInfo, data.stage, data.contracts);
                    ctx.body = { err: 0, msg: '', data: { final, finalInfo } };
                }
            } catch (err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '获取决算数据错误');
            }
        }

        _getSpreadSetting(needGcl) {
            const spreadSetting = {
                cols: [
                    {title: '项目节编号', colSpan: '1', rowSpan: '2', field: 'code', hAlign: 0, width: 180, formatter: '@', cellType: 'tree'},
                    {title: '清单编号', colSpan: '1', rowSpan: '2', field: 'b_code', hAlign: 0, width: 120, formatter: '@'},
                    {title: '名称', colSpan: '1', rowSpan: '2', field: 'name', hAlign: 0, width: 230, formatter: '@'},
                    {title: '单位', colSpan: '1', rowSpan: '2', field: 'unit', hAlign: 1, width: 50, formatter: '@', cellType: 'unit', comboEdit: true},
                    {title: '设计数量|数量1', colSpan: '2|1', rowSpan: '1|1', field: 'dgn_qty1', hAlign: 2, width: 80, type: 'Number'},
                    {title: '|数量2', colSpan: '|1', rowSpan: '|1', field: 'dgn_qty2', hAlign: 2, width: 80, type: 'Number'},
                    {title: '经济指标', colSpan: '1', rowSpan: '2', field: 'dgn_price', hAlign: 2, width: 80, type: 'Number', readOnly: true},
                    {title: '清单数量', colSpan: '1', rowSpan: '2', field: 'quantity', hAlign: 2, width: 80, type: 'Number'},
                    {title: '单价', colSpan: '1', rowSpan: '2', field: 'unit_price', hAlign: 2, width: 80, type: 'Number'},
                    {title: '金额', colSpan: '1', rowSpan: '2', field: 'total_price', hAlign: 2, width: 80, type: 'Number'},
                    {title: '图册号', colSpan: '1', rowSpan: '2', field: 'drawing_code', hAlign: 0, width: 100, formatter: '@'},
                    {title: '备注', colSpan: '1', rowSpan: '2', field: 'memo', hAlign: 0, width: 100, formatter: '@'},
                ],
                emptyRows: 0,
                headRows: 2,
                headRowHeight: [25, 25],
                defaultRowHeight: 21,
                headerFont: '12px 微软雅黑',
                font: '12px 微软雅黑',
                localCache: { key: 'budget', colWidth: true },
            };
            if (!needGcl) {
                spreadSetting.cols = spreadSetting.cols.filter(x => {
                    return ['b_code', 'quantity', 'unit_price'].indexOf(x.field) < 0;
                });
            }
            return spreadSetting;
        }
        _getRelaService(type) {
            switch(type) {
                case 'gu': return this.ctx.service.budgetGu;
                case 'gai': return this.ctx.service.budgetGai;
                case 'yu': return this.ctx.service.budgetYu;
                case 'zb': return this.ctx.service.budgetZb;
                case 'ctrl': return this.ctx.service.budgetCtrl;
                default: return null;
            }
        }
        async _getNeedGcl() {
            if (!this.ctx.params.btype) throw '参数错误';
            const funRela = this.ctx.subProject.fun_rela;
            return ['yu', 'zb', 'ctrl'].indexOf(this.ctx.params.btype) >= 0 && !!funRela.needGcl;
        }

        async detail(ctx) {
            try {
                const needGcl = await this._getNeedGcl();
                const renderData = {
                    spreadSetting: this._getSpreadSetting(needGcl),
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.budget.detail),
                    needGcl,
                    validDskProjType: ValidDskProject[ctx.params.btype],
                };
                [renderData.stdBills, renderData.stdChapters] = await ctx.service.budgetStd.getStdList(ctx.budget.std_id, ctx.params.btype);
                await this.layout('budget/detail.ejs', renderData, 'budget/detail_modal.ejs');
            } catch (err) {
                ctx.log(err);
            }
        }

        async detailLoad(ctx) {
            try {
                const relaService = this._getRelaService(ctx.params.btype);
                ctx.body = {
                    err: 0, msg: '',
                    data: await relaService.getData(ctx.budget.id),
                }
            } catch (err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '获取数据错误');
            }
        }

        async _billsBase(relaService, type, data) {
            if (isNaN(data.id) || data.id <= 0) throw '数据错误';
            if (type !== 'add') {
                if (isNaN(data.count) || data.count <= 0) data.count = 1;
            }
            switch (type) {
                case 'add':
                    return await relaService.addNodeBatch(this.ctx.budget.id, data.id, {}, data.count);
                case 'delete':
                    return await relaService.delete(this.ctx.budget.id, data.id, data.count);
                case 'up-move':
                    return await relaService.upMoveNode(this.ctx.budget.id, data.id, data.count);
                case 'down-move':
                    return await relaService.downMoveNode(this.ctx.budget.id, data.id, data.count);
                case 'up-level':
                    return await relaService.upLevelNode(this.ctx.budget.id, data.id, data.count);
                case 'down-level':
                    return await relaService.downLevelNode(this.ctx.budget.id, data.id, data.count);
            }
        }
        async _addStd(relaService, data) {
            if (!data.stdType || !data.stdNode) throw '参数错误';

            let stdLib, addType;
            switch (data.stdType) {
                case 'xmj':
                    stdLib = this.ctx.service.stdXmj;
                    addType = stdDataAddType.withParent;
                    break;
                case 'gcl':
                    stdLib = this.ctx.service.stdGcl;
                    const selectNode = await relaService.getDataByKid(this.ctx.budget.id, data.id);
                    addType = selectNode.b_code ? stdDataAddType.next : stdDataAddType.child;
                    break;
                default:
                    throw '未知标准库';
            }
            const stdData = await stdLib.getDataByDataId(data.stdLibId, data.stdNode);
            switch (addType) {
                case stdDataAddType.child:
                    return await relaService.addStdNodeAsChild(this.ctx.budget.id, data.id, stdData);
                case stdDataAddType.next:
                    return await relaService.addStdNode(this.ctx.budget.id, data.id, stdData);
                case stdDataAddType.withParent:
                    return await relaService.addStdNodeWithParent(this.ctx.budget.id, stdData, stdLib);
                default:
                    throw '未知添加方式';
            }
        }
        async _pasteBlock(relaService, data) {
            if ((isNaN(data.id) || data.id <= 0) ||
                (!data.tid && data.tid <= 0) ||
                (!data.block || data.block.length <= 0)) throw '参数错误';
            return await relaService.pasteBlockData(this.ctx.budget.id, data.id, data.block);
        }
        async detailUpdate(ctx) {
            try {
                if (!ctx.budget) throw '项目数据错误';
                if (ctx.budget.readOnly) throw '你无权修改数据';

                const relaService = this._getRelaService(ctx.params.btype);
                const data = JSON.parse(ctx.request.body.data);
                if (!data.postType || !data.postData) throw '数据错误';
                const responseData = { err: 0, msg: '', data: {} };

                switch (data.postType) {
                    case 'add':
                    case 'delete':
                    case 'up-move':
                    case 'down-move':
                    case 'up-level':
                    case 'down-level':
                        responseData.data = await this._billsBase(relaService, data.postType, data.postData);
                        break;
                    case 'update':
                        ctx.helper.checkDgnQtyPrecision(data.postData);
                        responseData.data = await relaService.updateCalc(ctx.budget.id, data.postData);
                        break;
                    case 'add-std':
                        responseData.data = await this._addStd(relaService, data.postData);
                        break;
                    case 'paste-block':
                        responseData.data = await this._pasteBlock(relaService, data.postData);
                        break;
                    default:
                        throw '未知操作';
                }
                ctx.body = responseData;
            } catch (err) {
                this.log(err);
                ctx.body = this.ajaxErrorBody(err, '数据错误');
            }
        }

        async detailUploadExcel(ctx) {
            try {
                if (!ctx.budget) throw '项目数据错误';
                if (ctx.budget.readOnly) throw '你无权导入数据';

                const relaService = this._getRelaService(ctx.params.btype);
                const needGcl = await this._getNeedGcl();
                const ueType = ctx.params.ueType;
                const compressData = ctx.request.body.data;
                const data = JSON.parse(LzString.decompressFromUTF16(compressData));
                const responseData = { err: 0, msg: '', data: {} };
                switch (ueType) {
                    case 'tz':
                        const templateId = await this.ctx.service.budgetStd.getTemplateId(this.ctx.budget.std_id, ctx.params.btype);
                        responseData.data = await relaService.importExcel(templateId, data.sheet, needGcl, data.filter);
                        break;
                    case 'gcl2xmj':
                        responseData.data = await relaService.importGclExcel(data.id, data.sheet);
                        break;
                    default:
                        throw '数据错误';
                }
                ctx.body = responseData;
            } catch (err) {
                this.log(err);
                ctx.body = { err: 1, msg: err.toString(), data: null };
            }
        }

        async uploadYbp(ctx) {
            const stream = await ctx.getFileStream();
            try {
                const relaService = this._getRelaService(ctx.params.btype);
                const needGcl = await this._getNeedGcl();
                // 读取字节流
                const parts = await streamToArray(stream);
                // 转化为buffer
                const buffer = Buffer.concat(parts);
                const bills = await relaService.importYbp(ctx.budget, buffer.toString(), needGcl);
                ctx.body = { err: 0, msg: '', data: bills };
            } catch (err) {
                await sendToWormhole(stream);
                ctx.log(err);
                ctx.ajaxErrorBody(err, '导入计价文件出错');
            }
        }

        async importDsk(ctx) {
            try {
                const relaService = this._getRelaService(ctx.params.btype);
                const needGcl = await this._getNeedGcl();
                const data = JSON.parse(ctx.request.body.data);
                if (!data.subjects || data.subjects.length === 0) throw '无导入计价数据';

                // 拼凑ybp数据
                const ybpData = { header: {}, subjects: [] };
                const dsk = new DSK(ctx);
                for (const s of data.subjects) {
                    const subject = { project: { ID: s.ID, parentID: s.parentID, type: s.type, name: s.name, compilationID: s.compilationId }, rations: [], };
                    subject.bills = await dsk.getProjectBills(s.compilationId, s.subjectId);
                    // 拼凑fees.marketCommon.totalFee，fees.marketLabour.totalFee防止出错
                    subject.bills.forEach(b => {
                        b.fees = {
                            marketCommon: { unitPrice: b.unitPrice, totalFee: b.totalPrice },
                            marketLabour: { unitPrice: 0, totalFee: 0 },
                        };
                    });
                    ybpData.subjects.push(subject);
                }
                const bills = await relaService.importYbpData(ctx.budget, ybpData, needGcl);
                ctx.body = { err: 0, msg: '', data: bills };
            } catch (err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '导入计价分段出错');
            }
        }

        async init(ctx) {
            const relaService = this._getRelaService(ctx.params.btype);
            try {
                const data = await relaService.getData(ctx.budget.id);
                if (data.length > 0) throw '已有数据，请勿重复初始化';
                const budgetStd = await this.ctx.service.budgetStd.getDataById(this.ctx.budget.std_id);
                await relaService.initByTemplate(null, this.ctx.budget.id, budgetStd[ctx.params.btype + '_template_id']);
            } catch(err) {
                ctx.log(err);
                ctx.postError(err, '初始化数据错误');
            }
            ctx.redirect(ctx.request.header.referer);
        }

        async decimal(ctx) {
            try {
                if (!ctx.budget) throw '项目数据错误';
                if (ctx.budget.readOnly) throw '你无权修改小数位数';

                const data = JSON.parse(ctx.request.body.data);
                if (!data || !data.decimal || !data.page) throw '缺少必要参数';

                const refreshData = await ctx.service.budget.saveDecimal(data.decimal, data.page);
                ctx.body = { err: 0, msg: '', data: refreshData };
            } catch (err) {
                this.log(err);
                this.ajaxErrorBody(err, '保存小数位数失败');
            }
        }
    }

    return BudgetController;
};