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 LzString = require('lz-string');
const accountGroup = require('../const/account_group').group;
module.exports = app => {
    class BudgetController extends app.BaseController {

        /**
         * 概算投资
         *
         * @param ctx
         * @returns {Promise<void>}
         */
        async list(ctx) {
            try {
                const renderData = {
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.budget.list),
                    auditConst,
                };
                renderData.budgetList = await ctx.service.budget.getBudget(ctx.session.sessionUser.is_admin);
                renderData.budgetStd = await ctx.service.budgetStd.getDataByProjectId(ctx.session.sessionProject.id);
                for (const bl of renderData.budgetList) {
                    const std = renderData.budgetStd.find(x => { return x.id === bl.std_id; });
                    bl.std_name = std ? std.name : '';
                    bl.gu_tp = await ctx.service.budgetGu.getSumTp(bl.id);
                    bl.gai_tp = await ctx.service.budgetGai.getSumTp(bl.id);
                    bl.yu_tp = await ctx.service.budgetYu.getSumTp(bl.id);
                }
                renderData.tenderList = await ctx.service.tender.getList4Select('stage');
                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'],
                });
                renderData.accountList = accountList;
                renderData.accountGroup = accountGroup.map((item, idx) => {
                    const groupList = accountList.filter(item => item.account_group === idx);
                    return { groupName: item, groupList };
                });
                renderData.permissionConst = ctx.service.budgetPermission.PermissionConst;
                await this.layout('budget/list.ejs', renderData, 'budget/list_modal.ejs');
            } catch (err) {
                ctx.log(err);
            }
        }

        async add(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                if (!data.name || data.name.length > 100) throw '项目名称有误';
                if (!data.std_id) throw '概预算标准有误';
                const result = await ctx.service.budget.add(data);
                ctx.body = { err: 0, msg: '', data: result };
            } catch (err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '新建项目失败');
            }
        }

        async del(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                if (!data.id) throw '参数有误';
                const result = await ctx.service.budget.deleteBudgetNoBackup(data.id);
                ctx.body = { err: 0, msg: '', data: result };
            } catch(err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '删除项目失败');
            }
        }

        async save(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                if (!data.id) throw '参数有误';
                let result = null;
                if (data.name !== undefined) {
                    if (!data.name || data.name.length > 100) throw '项目名称有误';
                    result = await ctx.service.budget.save({ id: data.id, name: data.name });
                } else if (data.rela_tender !== undefined) {
                    result = await ctx.service.budget.save({ id: data.id, rela_tender: data.rela_tender });
                }
                ctx.body = { err: 0, msg: '', data: result };
            } catch(err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '保存数据失败');
            }
        }

        async rela(ctx) {
            try {
                const id = parseInt(ctx.query.id);
                const budgetList = await ctx.service.budget.getBudget(true);
                const otherBudget = budgetList.filter(x => { return x.id !== id || !x.rela_tender });
                const _ = ctx.helper._;
                const otherRela = _.map(_.map(otherBudget, 'rela_tender').join(',').split(','), _.toInteger);
                const tenderList = await ctx.service.tender.getList4Select('stage');
                ctx.body = {
                    err: 0,
                    msg: '',
                    data: tenderList.filter(x => { return otherRela.indexOf(x.id) === -1})
                        .map(y => { return {id: y.id, name: y.name, lastStageOrder: y.lastStage.order, lastStageStatus: auditConst.stage.statusString[y.lastStage.status]}}),
                };
            } catch (err) {
                ctx.log(err);
                ctx.postError(err, '获取数据失败');
            }
        }

        async member(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                const member = await ctx.service.budgetPermission.getBudgetPermission(data.id);
                ctx.body = { err: 0, msg: '', data: member };
            } catch (err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '查询项目成员失败');
            }
        }

        async memberSave(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                if (!data.id) throw '参数有误';
                await ctx.service.budgetPermission.saveBudgetPermission(data.id, data.member);
                ctx.body = { err: 0, msg: '', data: '' };
            } catch (err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '保存数据失败');
            }
        }

        async compare(ctx) {
            try {
                const renderData = {
                    jsFiles: this.app.jsFiles.common.concat(this.app.jsFiles.budget.compare),
                    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;
                await this.layout('budget/compare.ejs', renderData, 'budget/compare_modal.ejs');
            } catch (err) {
                ctx.log(err);
            }
        }

        async compareLoad(ctx) {
            try {
                const gu = await ctx.service.budgetGu.getData(ctx.budget.id);
                const gai = await ctx.service.budgetGai.getData(ctx.budget.id);
                const yu = await ctx.service.budgetYu.getData(ctx.budget.id);
                ctx.body = { err: 0, msg: '', data: { gu, gai, yu } }
            } catch (err) {
                ctx.log(err);
                ctx.ajaxErrorBody(err, '获取数据错误');
            }
        }
        async compareFinal(ctx) {
            try {
                const data = JSON.parse(ctx.request.body.data);
                const final = [], helper = this.ctx.helper;
                for (const id of data.id) {
                    const bills = await ctx.service.ledger.getFinalData(id, ['id', 'ledger_id', 'ledger_pid', 'level', 'order', 'full_path', 'is_leaf',
                        'code', 'b_code', 'name', 'unit', 'dgn_qty1', 'dgn_qty2', 'total_price']);
                    // 使用完成数据对比
                    // const stage = ctx.service.stage.getLastestCompleteStage(id);
                    // const finalBills = ctx.service.stageBillsFinal.getFinalData(id, stage.id);
                    // ctx.helper.assignRelaData(bills, [
                    //     { data: finalBills, fields: ['contract_tp', 'qc_tp', 'used'], prefix: 'end_', relaId: 'lid' },
                    // ]);

                    // 使用最新一期对比
                    const stage = await ctx.service.stage.getLastestStage(id);
                    if (stage.status === auditConst.stage.status.checked) {
                        const finalBills = await ctx.service.stageBillsFinal.getFinalData({id}, stage.order);
                        ctx.helper.assignRelaData(bills, [
                            { data: finalBills, fields: ['contract_tp', 'qc_tp'], prefix: 'end_', relaId: 'lid' },
                        ]);
                        bills.forEach(b => {
                            b.end_gather_tp = helper.add(b.end_qc_tp, b.end_contract_tp);
                            delete b.end_contract_tp;
                            delete b.end_qc_tp;
                        });
                    } else {
                        await ctx.service.stage.doCheckStage(stage);
                        const curBills = stage.readOnly
                            ? await ctx.service.stageBills.getAuditorStageData2(id, stage.id, stage.curTimes, stage.curOrder)
                            : await ctx.service.stageBills.getLastestStageData2(id, stage.id);
                        const preBills = stage.order > 1 ? await ctx.service.stageBillsFinal.getFinalData({id}, stage.order - 1) : [];
                        ctx.helper.assignRelaData(bills, [
                            { data: curBills, fields: ['contract_tp', 'qc_tp'], prefix: '', relaId: 'lid' },
                            { data: preBills, fields: ['contract_tp', 'qc_tp'], prefix: 'pre_', relaId: 'lid' },
                        ]);
                        bills.forEach(b => {
                            b.end_gather_tp = helper.sum([b.qc_tp, b.contract_tp, b.pre_qc_tp, b.pre_contract_tp]);
                            delete b.contract_tp;
                            delete b.qc_tp;
                            delete b.pre_contract_tp;
                            delete b.pre_qc_tp;
                        });
                    }
                    final.push(bills);
                }
                ctx.body = { err: 0, msg: '', data: final }
            } 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'},
                    {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: 3,
                headRows: 2,
                headRowHeight: [25, 25],
                defaultRowHeight: 21,
                headerFont: '12px 微软雅黑',
                font: '12px 微软雅黑',
            };
            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;
                default: return null;
            }
        }
        async _getNeedGcl() {
            if (!this.ctx.params.btype) throw '参数错误';
            const funRela = await this.ctx.service.project.getFunRela(this.ctx.session.sessionProject.id);
            return this.ctx.params.btype === 'yu' && !!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,
                };
                [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 ((isNaN(data.id) || data.id <= 0) || !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 {
                const relaService = this._getRelaService(ctx.params.btype);
                if (!ctx.budget) throw '项目数据错误';
                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 {
                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 };
            }
        }
    }

    return BudgetController;
};