ConstructionOperation/web/maintain/report/js/rpt_tpl_main.js

'use strict'

let rptTplObj = {
    iniPage: function() {
        zTreeOprObj.iniEngineerIdList();
        zTreeOprObj.getCompilationList();
        rpt_tpl_cfg_helper.getReportTplCfg();
        selectableFiledTreeOprObj.iniTree();
        preview_util.drawBorder($("#tplCanvas")[0]);
        calculationTreeOprObj.buildRunType();
        preHandleObj.buildTypeData();
    }
}

let zTreeOprObj = {
    treeObj: null,
    currentNode: null,
    iniEngineerIdList: function() {
        for (let item of engineeringList) {
            $("#engineerIds").append("<option value='" + item.value + "'>" + item.name + "</option>");
        }
    },
    getCompilationList: function(){
        let me = zTreeOprObj, params = {};
        CommonAjax.postEx("report_tpl_api/getCompilationList", params, 20000, true, function(result){
                //console.log(result);
                for (let item of result) {
                    if (item.is_release) {
                        $("#compilations").append("<option value='" + item._id + "'>" + item.name + "</option>");
                    }
                }
                me.getReportTemplateTree($("#compilations").get(0));
            }, null, null
        );
    },
    refreshNodes: function() {
        let me = this;
        let private_setupIsParent = function(node){
            if (node.nodeType === RT.NodeType.NODE || node.level === 0) {
                node.isParent = true;
            } else {
                node.isParent = false;
            }
            if (node.items && node.items.length) {
                for (let i = 0; i < node.items.length; i++) {
                    private_setupIsParent(node.items[i]);
                }
            }
        };
        let topNodes = me.treeObj.getNodes();
        for (let i = 0; i < topNodes.length; i++) {
            private_setupIsParent(topNodes[i]);
        }
        me.treeObj.refresh();
    },
    removeTreeRootNode: function(rawNode, isAsync, callback, failCallback) {
        let params = {};
        params.compilationId = rawNode.compilationId;
        params.engineerId = rawNode.engineerId;
        params.userId = rawNode.userId;
        params.isPhysically = true;
        CommonAjax.postEx("report_tpl_api/removeTreeRootNode", params, 5000, isAsync, callback, failCallback, null);
    },
    updateTreeRootNode: function(rawNode, isAsync, callback, failCallback) {
        let params = {};
        params.doc = rawNode;
        CommonAjax.postEx("report_tpl_api/updateTreeRootNode", params, 5000, isAsync, callback, failCallback, null);
    },
    updateTopNodeName: function (topNode, isAsync, callback, failCallback) {
        let params = {};
        params.compilationId = topNode.compilationId;
        params.engineerId = topNode.engineerId;
        params.userId = topNode.userId;
        params.nodeName = topNode.name;
        CommonAjax.postEx("report_tpl_api/updateTopNodeName", params, 5000, isAsync, callback, failCallback, null);
    },
    updateSubNode: function (topNode, subNode, isAsync, callback, failCallback) {
        let params = {};
        params.compilationId = topNode.compilationId;
        params.engineerId = topNode.engineerId;
        params.userId = topNode.userId;
        params.subNode = subNode;
        CommonAjax.postEx("report_tpl_api/updateSubLevelOneNode", params, 5000, isAsync, callback, failCallback, null);
    },
    createIniNode: function() {
        return {
            nodeType: RT.NodeType.TEMPLATE,
            refId: -1,
            name: "",
            ID: -1,
            items: null
        };
    },
    buildRootNodeDoc: function(topNode, excludeNode) {
        let me = this, rst = null;
        if (topNode) {
            rst = {
                compilationId: topNode.compilationId,
                engineerId: topNode.engineerId,
                userId: topNode.userId,
                properties: topNode.properties,
                released: true,
                isDeleted: topNode.isDeleted,
                items: me.private_build_items(topNode.items, excludeNode),
                name: topNode.name
            };
        }
        return rst;
    },
    buildSubRootNodeDoc: function(subNode) {
        let me = this, rst = null;
        if (subNode) {
            let isReleased = false;
            if (subNode.nodeType === RT.NodeType.TEMPLATE) {
                isReleased = subNode.checked;
                // if (subNode.hasOwnProperty("released")) {
                //     isReleased = subNode.released;
                // }
            }
            rst = {
                nodeType: subNode.nodeType,
                refId: subNode.refId,
                ID: subNode.ID,
                released: isReleased,
                items: me.private_build_items(subNode.items, null),
                name: subNode.name
            };
        }
        return rst;
    },

    private_build_items: function (items, excludeNode) {
        let me = this, itemRst = null;
        if (items && items.length > 0) {
            itemRst = [];
            for (let item of items) {
                if (item !== excludeNode) {
                    let isReleased = false;
                    if (item.nodeType === RT.NodeType.TEMPLATE) {
                        isReleased = item.checked;
                        // if (item.hasOwnProperty("released")) {
                        //     isReleased = item.released;
                        // }
                    }
                    let ir = {};
                    ir.nodeType = item.nodeType;
                    ir.refId = item.refId;
                    ir.name = item.name;
                    ir.ID = item.ID;
                    ir.released = isReleased;
                    ir.items = me.private_build_items(item.items);
                    itemRst.push(ir);
                }
            }
        }
        return itemRst;
    },

    addHoverDom: function(treeId, treeNode) {
        let me = zTreeOprObj, sObj = $("#" + treeNode.tId + "_span");
        if (treeNode.editNameFlag || $("#addBtn_"+treeNode.tId).length > 0 || treeNode.nodeType === RT.NodeType.TEMPLATE) return;
        let addStr = "<span class='button add' id='addBtn_" + treeNode.tId + "' title='新增子目录' onfocus='this.blur();'></span>";
        sObj.after(addStr);
        let btn = $("#addBtn_"+treeNode.tId);
        if (btn) btn.bind("click", function(){
            me.getNewNodeID(1, function (newNodeID) {
                let rawNode = me.createIniNode();
                rawNode.nodeType = RT.NodeType.NODE;
                rawNode.name = "新增子节点";
                rawNode.ID = newNodeID;
                let newNodes = [], isSilent = false;
                newNodes.push(rawNode);
                if (me.treeObj) {
                    let insertIdx = -1;
                    if (treeNode.items && treeNode.items.length > 0) {
                        for (let i = treeNode.items.length - 1; i >= 0; i--) {
                            if (treeNode.items[i].nodeType === RT.NodeType.NODE) {
                                insertIdx = i + 1;
                                break;
                            } else {
                                insertIdx = i;
                            }
                        }
                    }
                    me.treeObj.addNodes(treeNode, insertIdx, newNodes, isSilent);
                    let tn = me.getTopNodeByCurrentNode(treeNode);
                    let newTopNode = me.buildRootNodeDoc(tn);
                    me.updateTreeRootNode(newTopNode, true, function(rst){
                        if (!(rst)) {
                            alert("新增节点失败！");
                        }
                        me.refreshNodes();
                    }, null);
                }
            });
        });
    },
    removeHoverDom: function(treeId, treeNode) {
        $("#addBtn_"+treeNode.tId).unbind().remove();
    },
    addNewNodeEx: function(rawNode, callback, failCallback) {
        let params = {};
        params.doc = rawNode;
        CommonAjax.postEx("report_tpl_api/createTreeRootNode", params, 5000, true, callback, failCallback, null);
    },
    moveUpNode: function() {
        let me = this;
        if (me.currentNode && me.currentNode.getPreNode() && me.currentNode.level > 0) {
            let preNode = me.currentNode.getPreNode();
            if (preNode.nodeType === me.currentNode.nodeType) {
                me.treeObj.moveNode(preNode, me.currentNode, "prev", true);
                //then update the db
                let topPNode = me.getTopNodeByCurrentNode(preNode);
                let newTopNode = me.buildRootNodeDoc(topPNode);
                me.updateTreeRootNode(newTopNode, true, function(rst){
                    if (!(rst)) {
                        alert("移动请求失败！");
                    }
                });
            }
        }
    },
    moveDownNode: function() {
        let me = this;
        if (me.currentNode && me.currentNode.getNextNode() && me.currentNode.level > 0) {
            let nextNode = me.currentNode.getNextNode();
            if (nextNode.nodeType === me.currentNode.nodeType) {
                me.treeObj.moveNode(nextNode, me.currentNode, "next", true);
                //then update the db
                let topPNode = me.getTopNodeByCurrentNode(nextNode);
                let newTopNode = me.buildRootNodeDoc(topPNode);
                me.updateTreeRootNode(newTopNode, true, function(rst){
                    if (!(rst)) {
                        alert("移动请求失败！");
                    }
                });
            }
        }
    },
    oncheck: function (event, treeId, treeNode) {
        let me = zTreeOprObj;
        let topPNode = me.getTopNodeByCurrentNode(treeNode);
        let newTopNode = me.buildRootNodeDoc(topPNode);
        me.updateTreeRootNode(newTopNode, true, function(rst){
            if (!(rst)) {
                alert("修改发布状态失败！");
            }
        });
    },
    getReportTemplateTree: function(compilationSelect) {
        let me = zTreeOprObj, params = {};
        params.compilationId = compilationSelect.value;
        params.userId = (userAccount ===  'admin')?("-100"):userID;
        let allEngIds = [];
        for (let item of engineeringList) {
            allEngIds.push(item.value);
        }
        params.engineerId = allEngIds;
        CommonAjax.postEx("report_tpl_api/getRptTplTree", params, 20000, true, function(result){
            result.sort(function(item1, item2){
                let rst = 0;
                if (item1.userId < item2.userId) {
                    rst = 1
                } else if (item1.userId > item2.userId) {
                    rst = -1;
                } else {
                    rst = (item1.engineerId > item2.engineerId)?1:((item1.engineerId < item2.engineerId)?-1:0);
                }
                return rst;
            });
            zTreeHelper.createTreeDirectly(result, setting, "rptTplTree", me);
            me.refreshNodes();
            let private_setup_checked = function (itemNode) {
                if (itemNode.nodeType === RT.NodeType.NODE) {
                    me.treeObj.setChkDisabled(itemNode, true);
                } else if (itemNode.nodeType === RT.NodeType.TEMPLATE) {
                    // me.treeObj.setChkDisabled(itemNode, !(itemNode.released));
                    me.treeObj.checkNode(itemNode, (itemNode.released)?true:false);
                }
                if (itemNode.items && itemNode.items.length > 0) {
                    for (let subItem of itemNode.items) {
                        private_setup_checked(subItem);
                    }
                }
            };
            let topNodes = me.treeObj.getNodes();
            me.treeObj.expandAll(true);
            for (let node of topNodes) {
                me.treeObj.setChkDisabled(node, true);
                if (node.items && node.items.length > 0) {
                    for (let item of node.items) {
                        private_setup_checked(item);
                    }
                }
            }
        }, null, null);
    },
    addTplNode: function (){
        let me = this;
        if (me.currentNode && me.currentNode.nodeType === RT.NodeType.NODE || me.currentNode.level === 0) {
            me.getNewNodeID(1, function (newNodeID) {
                let rawNode = me.createIniNode();
                rawNode.nodeType = RT.NodeType.TEMPLATE;
                rawNode.name = "新增报表模板";
                rawNode.ID = newNodeID;
                rawNode.released = false;
                let newNodes = [], isSilent = false;
                newNodes.push(rawNode);
                me.treeObj.addNodes(me.currentNode, -1, newNodes, isSilent);
                let topNode = me.buildRootNodeDoc(me.currentNode);
                me.updateTreeRootNode(topNode, true, function(rst){
                    if (!(rst)) {
                        alert("新增空白模板失败！");
                    }
                    me.refreshNodes();
                }, null);
            });
        }
    },
    getNewNodeID: function (scope, callback) {
        let params = {};
        params.scope = scope;
        CommonAjax.postEx("report_tpl_api/getNewNodeID", params, 5000, true, callback, null, null);
    },
    addRootNode: function() {
        let me = this, rawNode = me.createIniRootNode();
        if (!me.chkIfDupRootNode(rawNode)) {
            me.addNewNodeEx(rawNode, function(rst){
                if (rst) {
                    let newNodes = [], isSilent = false;
                    rawNode.isParent = true;
                    newNodes.push(rawNode);
                    if (me.treeObj) {
                        let insertIdx = -1;
                        let nodes = me.treeObj.getNodes();
                        for (let i = 0; i < nodes.length; i++) {
                            if (nodes[i].compilationId === rawNode.compilationId) {
                                if (nodes[i].engineerId > rawNode.engineerId) {
                                    insertIdx = i;
                                    break;
                                }
                            }
                        }
                        me.treeObj.addNodes(null, insertIdx, newNodes, isSilent);
                    } else {
                        me.treeObj = $.fn.zTree.init($("#rptTplTree"), setting, newNodes);
                    }
                } else {
                    alert("创建失败，请确认是否有重复类型跟节点！")
                }
            }, null);
        } else {
            alert("有重复编办及工程类型！");
        }
    },
    chkIfDupRootNode: function (rawNode) {
        let me = this, rst = false;
        if (me.treeObj) {
            let nodes = me.treeObj.getNodes();
            for (let node of nodes) {
                if (node.compilationId === rawNode.compilationId && node.engineerId === rawNode.engineerId && node.userId === rawNode.userId) {
                    rst = true;
                    break;
                }
            }
        }
        return rst;
    },
    createIniRootNode: function() {
        let rst = {
            compilationId: $("#compilations").get(0).selectedOptions[0].value,
            engineerId: parseInt($("#engineerIds").get(0).selectedOptions[0].value),
            userId: (userAccount ===  'admin')?("-100"):userID,
            properties: [],
            released: true,
            isDeleted: false,
            items: [],
            name: $("#compilations").get(0).selectedOptions[0].innerText + $("#engineerIds").get(0).selectedOptions[0].innerText
        };
        return rst;
    },
    onBeforeRemove: function(treeId, treeNode){
        let canRemove = false;
        if (!(treeNode.items) || treeNode.items.length < 1) {
            canRemove = confirm("请再确认您要删除！");
        } else {
            alert("含有子项，不能删除！");
        }
        return canRemove;
    },
    onRemove: function(e, treeId, treeNode){
        let me = zTreeOprObj, topPNode = me.getTopNodeByCurrentNode(treeNode);
        let rawNode = me.buildRootNodeDoc(topPNode, treeNode);
        if (treeNode.level === 0) {
            me.removeTreeRootNode(rawNode, true, function(rst){
                if (!(rst)) {
                    alert("删除请求失败！");
                }
            });
        } else {
            me.updateTreeRootNode(rawNode, true, function(rst){
                if (!(rst)) {
                    alert("删除请求失败！");
                }
            });
        }
        me.refreshNodes();
    },
    beforeRename: function(treeId, treeNode, newName, isCancel) {
        if (newName.length === 0) {
            return false;
        }
        return true;
    },
    onRename : function(e, treeId, treeNode, isCancel) {
        if (!isCancel) {
            let me = zTreeOprObj;
            if (treeNode.level === 0) {
                me.updateTopNodeName(treeNode, true, function(rst){
                    if (!(rst)) {
                        alert('修改名称请求失败！');
                    }
                }, null);
            } else {
                let subTopNode = me.getSubTopNodeByCurrentNode(treeNode);
                let topPNode = subTopNode.getParentNode();
                let rawNode = me.buildSubRootNodeDoc(subTopNode);
                me.updateSubNode(topPNode, rawNode, true, function(rst){
                    if (!(rst)) {
                        alert('修改名称请求失败！');
                    }
                });
            }
        }
    },

    createNewTpl: function () {
        let me = zTreeOprObj, params = {};
        if (me.currentNode && me.currentNode.nodeType === RT.NodeType.TEMPLATE) {
            params.treeNodeId = me.currentNode.ID;
            let rptTypeId = common_rpt_type_ids.flow;
            if ($("#crossTypeOpt")[0].checked) rptTypeId = common_rpt_type_ids.cross;
            if ($("#billTypeOpt")[0].checked) rptTypeId = common_rpt_type_ids.bill;
            params.rptDftTplId = rptTypeId;
            params.rptName = me.currentNode.name;
            params.grpKey = me.getFolderText(me.currentNode, "_");
            me.currentNode.refId = me.currentNode.ID;
            let subTopNode = me.getSubTopNodeByCurrentNode(me.currentNode);
            let topPNode = me.getTopNodeByCurrentNode(subTopNode);
            let rawNode = me.buildSubRootNodeDoc(subTopNode);
            params.compilationId = topPNode.compilationId;
            params.engineerId = topPNode.engineerId;
            params.userId = topPNode.userId;
            params.subNode = rawNode;
            CommonAjax.postEx("report_tpl_api/createDftRptTpl", params, 10000, true, function(result){
                    if (result) {
                        me.currentNode.rptTpl = result;
                        me.chkAndRreshRefTpl();
                    } else {
                        alert('update error!');
                    }
                }, null, null
            );
        }
    },
    onClick: function(event,treeId,treeNode) {
        let me = zTreeOprObj;
        me.currentNode = treeNode;
        bandTreeOprObj.currentNode = null;
        if (treeNode.nodeType === RT.NodeType.NODE) {
            $("#rpt_tpl_display_label")[0].innerText = "...";
        } else if (treeNode.nodeType === RT.NodeType.TEMPLATE) {
            let showText = me.getFolderText(me.currentNode, " > ");
            $("#rpt_tpl_display_label")[0].innerText = showText;
            if (treeNode.refId < 0) {
                //创建新报表模板
                $('#rptTypeSelectionModal').modal('show');
            } else {
                //显示报表模板
                me.chkAndRreshRefTpl();
            }
        }
    },
    getFolderText: function (treeNode, separator) {
        let rst = "";
        if (treeNode) {
            rst = treeNode.name;
            let parentNode = treeNode.getParentNode();
            while (parentNode !== null) {
                rst = parentNode.name + separator + rst;
                parentNode = parentNode.getParentNode();
            }
        }
        return rst;
    },
    chkAndRreshRefTpl: function() {
        let me = zTreeOprObj, params = {};
        if (me.currentNode && me.currentNode.nodeType === RT.NodeType.TEMPLATE && me.currentNode.refId > 0) {
            if (!(me.currentNode.rptTpl)) {
                params.rptTplId = me.currentNode.refId;
                CommonAjax.postEx("report_tpl_api/getRefRptTpl", params, 20000, true, function(result){
                        me.currentNode.rptTpl = result;
                        me.currentNode.rptTpl[JV.NODE_MAIN_INFO][JV.NODE_MAIN_INFO_RPT_NAME] = me.currentNode.name;
                        if (me.currentNode.rptTpl["GROUP_KEY"]) {
                            let grp_keys = me.currentNode.rptTpl["GROUP_KEY"].split('_');
                            if (grp_keys.length > 0) {
                                grp_keys[1] = me.currentNode.name;
                            }
                            me.currentNode.rptTpl["GROUP_KEY"] = grp_keys.join("_");
                        }
                        tplHelper.refreshTplView(me.currentNode.rptTpl);
                    }, null, null
                );
            } else {
                me.currentNode.rptTpl[JV.NODE_MAIN_INFO][JV.NODE_MAIN_INFO_RPT_NAME] = me.currentNode.name;
                tplHelper.refreshTplView(me.currentNode.rptTpl);
            }
        }
    },
    getRefTpl: function() {
        let me = zTreeOprObj, rst = null;
        if (me.currentNode && me.currentNode.nodeType === RT.NodeType.TEMPLATE && me.currentNode.refId > 0) {
            rst = me.currentNode.rptTpl
        }
        return rst;
    },
    extractMainInfo: function (rptTpl) {
        //模板信息
        rptTpl[JV.NODE_MAIN_INFO][JV.NODE_MAIN_INFO_RPT_NAME] = $("#rptTplName")[0].value;
        rptTpl[JV.NODE_MAIN_INFO][JV.NODE_PAGE_INFO][JV.PROP_PAGE_SIZE] = JV.PAGES_SIZE_STR[$("#rptTplPageSize")[0].selectedIndex];
        if ($("#rptTplPageOrientation")[0].selectedIndex === 1) {
            rptTpl[JV.NODE_MAIN_INFO][JV.NODE_PAGE_INFO][JV.PROP_ORIENTATION] = JV.ORIENTATION_PORTRAIT;
        } else {
            rptTpl[JV.NODE_MAIN_INFO][JV.NODE_PAGE_INFO][JV.PROP_ORIENTATION] = JV.ORIENTATION_LANDSCAPE;
        }
        if (rptTpl[JV.NODE_FLOW_INFO]) {
            rptTpl[JV.NODE_FLOW_INFO][JV.PROP_MULTI_COLUMN] = parseInt($("#rptTplMultiCols")[0].value);
        }
        rptTpl[JV.NODE_MAIN_INFO][JV.NODE_MARGINS][JV.PROP_LEFT] = $("#rptTplMarginLeft")[0].value;
        rptTpl[JV.NODE_MAIN_INFO][JV.NODE_MARGINS][JV.PROP_RIGHT] = $("#rptTplMarginRight")[0].value;
        rptTpl[JV.NODE_MAIN_INFO][JV.NODE_MARGINS][JV.PROP_TOP] = $("#rptTplMarginTop")[0].value;
        rptTpl[JV.NODE_MAIN_INFO][JV.NODE_MARGINS][JV.PROP_BOTTOM] = $("#rptTplMarginBottom")[0].value;
    },
    getTopNodeByCurrentNode: function (currentNode) {
        let topPNode = currentNode, pNode = currentNode.getParentNode();
        while (pNode !== null) {
            topPNode = pNode;
            pNode = pNode.getParentNode();
        }
        return topPNode;
    },
    getSubTopNodeByCurrentNode: function (currentNode) {
        let startNode = currentNode, resultPNode = null, pNode = startNode.getParentNode();
        while (pNode !== null) {
            resultPNode = startNode;
            startNode = pNode;
            pNode = startNode.getParentNode();
        }
        return resultPNode;
    }
};