ConstructionOperation/web/maintain/report/js/rpt_tpl_data_map.js

/**
 * Created by Tony on 2017/10/5.
 */
'use strict'

let dataInfoMapTreeOprObj = {
    treeObj : null,
    bandTreeObj: null,
    selectedTreeObj: null,
    currentNode: null,
    dataTypeDef: ['string', 'int32', 'int64', 'double', 'currency', 'date', 'image'],
    iniTree: function(rptTpl) {
        let me = this;
        let fieldMapList = me.buildTreeData(rptTpl);
        me.treeObj = $.fn.zTree.init($("#tpl_data_info_reversed"), rptDataInfoSetting, fieldMapList);
        me.treeObj.expandAll(true);
    },
    iniDataMap: function () {
        let me = this, bandList = bandTreeOprObj.copyBandList(false);
        if (bandList) {
            me.bandTreeObj = $.fn.zTree.init($("#band_tree2_reversed"), bandSetting2, bandList);
            me.bandTreeObj.expandAll(true);
            let selectedFieldList = fieldMapTreeOprObj.copySelectedFieldList();
            if (me.selectedTreeObj) {
                let nodes = me.selectedTreeObj.getNodes();
                for (let node of nodes) {
                    me.selectedTreeObj.removeNode(node);
                }
                me.selectedTreeObj.refresh();
            }
            // me.selectedTreeObj = $.fn.zTree.init(document.getElementById("tpl_data_selected_field_map_reversed"), selectedFieldMapSetting, selectedFieldList);
            me.selectedTreeObj = $.fn.zTree.init($("#tpl_data_selected_field_map_reversed"), selectedFieldMapSetting, selectedFieldList);
            me.selectedTreeObj.expandAll(true);
        }
    },
    buildTreeData: function (rptTpl) {
        let me = this, rst = null;

        $("#dispRowHeight")[0].style.display = "";
        $("#dispColWidth")[0].style.display = "";
        if (rptTpl[JV.NODE_FLOW_INFO]) {
            //
        } else if (rptTpl[JV.NODE_CROSS_INFO]) {
            //
        } else if (rptTpl[JV.NODE_BILL_INFO]) {
            rst = me.buildBillData(rptTpl);
            $("#dispRowHeight")[0].style.display = "none";
            $("#dispColWidth")[0].style.display = "none";
        }

        return rst;
    },
    buildBillData: function(rptTpl) {
        let me = this, rst = [];
        let rootFieldNode = {Name: JV.NODE_BILL_CONTENT, type: "bill_data", isParent: true};
        let discreteNode = {Name: JV.NODE_DISCRETE_INFO};
        rst.push(rootFieldNode);
        rst.push(discreteNode);
        me.private_build_bill_data(rootFieldNode, rptTpl[JV.NODE_BILL_INFO][JV.NODE_BILL_CONTENT], rptTpl);
        me.private_build_bill_discrete_data(discreteNode, rptTpl[JV.NODE_BILL_INFO][JV.NODE_DISCRETE_INFO], rptTpl);

        return rst;
    },

    private_build_bill_data: function (rootFieldNode, billData, rptTpl) {
        let me = this, bandName = billData[JV.PROP_BAND_NAME];
        if (rootFieldNode) {
            rootFieldNode[JV.PROP_BAND_NAME] = bandName;
            rootFieldNode.items = [];
            for (let fieldItem of billData[JV.PROP_BILL_FIELDS]) {
                if (fieldItem[JV.PROP_FIELD_ID]) {
                    rootFieldNode.items.push(me.private_build_field_node(fieldItem, rptTpl))
                } else if (fieldItem[JV.PROP_PARAM_ID]) {
                    rootFieldNode.items.push(me.private_build_param_node(fieldItem, rptTpl));
                }
            }
        }
    },
    private_build_bill_discrete_data: function (discreteNode, discreteData, rptTpl) {
        let me = this;
        discreteNode.isParent = true;
        discreteNode.items = [];
        for (let i = 0; i < discreteData.length; i++) {
            let dtl = discreteData[i];
            let item = {"Name": "离散" + (i + 1), "items":[]};
            item[JV.PROP_BAND_NAME] = dtl[JV.PROP_BAND_NAME];
            let discreteFieldsNode = {"Name": "离散字段集", "items": [], "isParent": true};
            let discreteTextsNode = {"Name": "离散文本集", "items": [], "isParent": true};
            item.items.push(discreteFieldsNode);
            item.items.push(discreteTextsNode);

            discreteNode.items.push(item);
            if (dtl[JV.PROP_DISCRETE_FIELDS]) {
                for (let field of dtl[JV.PROP_DISCRETE_FIELDS]) {
                    if (field[JV.PROP_FIELD_ID]) {
                        discreteFieldsNode.items.push(me.private_build_field_node(field, rptTpl))
                    } else if (field[JV.PROP_PARAM_ID]) {
                        discreteFieldsNode.items.push(me.private_build_param_node(field, rptTpl));
                    }
                }
            }
            if (dtl[JV.PROP_TEXTS]) {
                for (let txt of dtl[JV.PROP_TEXTS]) {
                    discreteTextsNode.items.push(me.private_build_text_node(txt));
                }
            }
        }
    },
    private_get_field_by_id: function (fieldId, rptTpl) {
        let rst = null;
        function getField(collection) {
            if (!rst && collection) {
                for (let item of collection) {
                    if (item[JV.PROP_ID] === fieldId) {
                        rst = item;
                        break;
                    }
                }
            }
        }
        getField(rptTpl[JV.NODE_FIELD_MAP][JV.NODE_DISCRETE_FIELDS]);
        getField(rptTpl[JV.NODE_FIELD_MAP][JV.NODE_NO_MAPPING_FIELDS]);
        getField(rptTpl[JV.NODE_FIELD_MAP][JV.NODE_MASTER_FIELDS]);
        getField(rptTpl[JV.NODE_FIELD_MAP][JV.NODE_MASTER_FIELDS_EX]);
        getField(rptTpl[JV.NODE_FIELD_MAP][JV.NODE_DETAIL_FIELDS]);
        getField(rptTpl[JV.NODE_FIELD_MAP][JV.NODE_DETAIL_FIELDS_EX]);
        return rst;
    },
    private_get_param_by_id: function (paramId, rptTpl) {
        let rst = null;
        function getParam(collection) {
            if (!rst && collection) {
                for (let item of collection) {
                    if (item[JV.PROP_ID] === paramId) {
                        rst = item;
                        break;
                    }
                }
            }
        }
        getParam(rptTpl[JV.NODE_DISCRETE_PARAMS]);
        return rst;
    },
    private_build_field_node: function (fieldData, rptTpl) {
        let me = this, rst = null;
        if (fieldData) {
            rst = {};
            let f = me.private_get_field_by_id(fieldData[JV.PROP_FIELD_ID], rptTpl);
            if (f) {
                rst[JV.PROP_NAME] = f[JV.PROP_NAME];
            } else {
                rst[JV.PROP_NAME] = fieldData[JV.PROP_FIELD_ID];
            }
            me.private_copy_field_properties(fieldData, rst);
        }
        return rst;
    },
    private_copy_field_properties: function (source, destination) {
        let me = this;
        destination[JV.PROP_FIELD_ID] = source[JV.PROP_FIELD_ID];
        if (source[JV.TAB_FIELD_PROP_SORT]) destination[JV.TAB_FIELD_PROP_SORT] = source[JV.TAB_FIELD_PROP_SORT];
        destination[JV.PROP_FONT] = source[JV.PROP_FONT];
        destination[JV.PROP_CONTROL] = source[JV.PROP_CONTROL];
        destination[JV.PROP_STYLE] = source[JV.PROP_STYLE];
        destination[JV.PROP_PREFIX] = source[JV.PROP_PREFIX];
        destination[JV.PROP_SUFFIX] = source[JV.PROP_SUFFIX];
        destination[JV.PROP_AREA] = {};
        me.private_copy_area(source[JV.PROP_AREA], destination[JV.PROP_AREA]);
    },
    private_copy_area: function (orgArea, destArea) {
        destArea[JV.PROP_LEFT] = orgArea[[JV.PROP_LEFT]];
        destArea[JV.PROP_RIGHT] = orgArea[[JV.PROP_RIGHT]];
        destArea[JV.PROP_TOP] = orgArea[[JV.PROP_TOP]];
        destArea[JV.PROP_BOTTOM] = orgArea[[JV.PROP_BOTTOM]];
        destArea[JV.PROP_H_CALCULATION] = orgArea[[JV.PROP_H_CALCULATION]];
        destArea[JV.PROP_V_CALCULATION] = orgArea[[JV.PROP_V_CALCULATION]];
    },
    private_build_param_node: function (param, rptTpl) {
        let me = this, rst = null;
        if (param) {
            rst = {};
            let p = me.private_get_param_by_id(param[JV.PROP_PARAM_ID], rptTpl);
            if (p) {
                rst[JV.PROP_NAME] = p[JV.PROP_NAME];
            } else {
                rst[JV.PROP_NAME] = param[JV.PROP_PARAM_ID];
            }
            me.private_copy_param_properties(param, rst);
        }
        return rst;
    },
    private_copy_param_properties: function (source, destination) {
        let me = this;
        destination[JV.PROP_PARAM_ID] = source[JV.PROP_PARAM_ID];
        destination[JV.PROP_FONT] = source[JV.PROP_FONT];
        destination[JV.PROP_CONTROL] = source[JV.PROP_CONTROL];
        destination[JV.PROP_STYLE] = source[JV.PROP_STYLE];
        destination[JV.PROP_PREFIX] = source[JV.PROP_PREFIX];
        destination[JV.PROP_SUFFIX] = source[JV.PROP_SUFFIX];
        destination[JV.PROP_AREA] = {};
        me.private_copy_area(source[JV.PROP_AREA], destination[JV.PROP_AREA]);
    },
    private_build_text_node: function (text) {
        let me = this, rst = null;
        if (text) {
            rst = {};
            rst[JV.PROP_NAME] = text[JV.PROP_LABEL];
            me.private_copy_text_properties(text, rst);
        }
        return rst;
    },
    private_copy_text_properties: function (source, destination) {
        let me = this;
        destination[JV.PROP_LABEL] = source[JV.PROP_LABEL];
        destination[JV.PROP_FONT] = source[JV.PROP_FONT];
        destination[JV.PROP_CONTROL] = source[JV.PROP_CONTROL];
        destination[JV.PROP_STYLE] = source[JV.PROP_STYLE];
        destination[JV.PROP_AREA] = {};
        me.private_copy_area(source[JV.PROP_AREA], destination[JV.PROP_AREA]);
    },

    private_get_dummy_text_node: function() {
        let me = this, rst = {};
        rst[JV.PROP_NAME] = "文本";
        rst[JV.PROP_LABEL] = "文本";
        rst[JV.PROP_FONT] = "Content";
        rst[JV.PROP_CONTROL] = "Default";
        rst[JV.PROP_STYLE] = "Default_None";
        rst[JV.PROP_AREA] = {};
        rst[JV.PROP_AREA][JV.PROP_LEFT] = 0;
        rst[JV.PROP_AREA][JV.PROP_RIGHT] = 100;
        rst[JV.PROP_AREA][JV.PROP_TOP] = 0;
        rst[JV.PROP_AREA][JV.PROP_BOTTOM] = 100;
        rst[JV.PROP_AREA][JV.PROP_H_CALCULATION] = JV.CAL_TYPE[0];
        rst[JV.PROP_AREA][JV.PROP_V_CALCULATION] = JV.CAL_TYPE[0];
        return rst;
    },

    onTabDataClick: function (event,treeId,treeNode) {
        let me = dataInfoMapTreeOprObj, matchedBandNode = null;
        let chked = false;
        me.currentNode = treeNode;
        function checkBandNode(bNode, bandName) {
            if (bNode[JV.PROP_NAME] === bandName) {
                chked = true;
                matchedBandNode = bNode;
            } else if (bNode.items){
                for (let subNode of bNode.items) {
                    checkBandNode(subNode, bandName);
                    if (chked) {
                        break;
                    }
                }
            }
        }
        let nodes = me.bandTreeObj.getNodes();
        function setDisabledBandSelect(disabled) {
            for (let node of nodes) {
                me.bandTreeObj.setChkDisabled(node, disabled, true, true);
            }
        }
        if (treeNode[JV.PROP_BAND_NAME]) {
            for (let node of nodes) {
                checkBandNode(node, treeNode[JV.PROP_BAND_NAME]);
                if (chked) {
                    break;
                }
            }
        }
        if (chked) {
            setDisabledBandSelect(false);
            me.bandTreeObj.checkNode(matchedBandNode, true, true);
        } else {
            setDisabledBandSelect(true);
        }
    },
    onCheck: function (event,treeId,treeNode) {
        let me = dataInfoMapTreeOprObj;
        if (me.currentNode[JV.PROP_BAND_NAME] && me.currentNode[JV.PROP_BAND_NAME] !== treeNode[JV.PROP_NAME])  {
            alert("change band from: " + me.currentNode[JV.PROP_BAND_NAME] + " to : " + treeNode[JV.PROP_NAME]);
            me.currentNode[JV.PROP_BAND_NAME] = treeNode[JV.PROP_NAME];
        }
    },
    onBeforeRemove: function(treeId, treeNode){
        let rst = true;
        if (treeNode.isParent) {
            rst = false;
        } else {
            //
        }
        return rst;
    },
    beforeRename: function(treeId, treeNode, newName, isCancel) {
        let rst = false;
        return rst;
    },
    beforeEditName: function(treeId, treeNode) {
        let rst = false;
        let pn = treeNode.getParentNode();
        if (pn && pn[JV.PROP_NAME] === "离散文本集") {
            rst = true;
        }
        return rst;
    },
    onBeforeDrag: function (treeId, treeNodes) {
        let rst = true;
        for (let node of treeNodes) {
            if (node.level === 0) {
                rst = false;
                break;
            }
        }
        return rst;
    },
    onBeforeDrop: function(treeId, treeNodes, targetNode, moveType){
        let rst = false;
        if (targetNode.tId && targetNode.tId.indexOf("tpl_data_info_reversed") >= 0 && (!(targetNode.isParent && moveType !== 'inner')) ) {
            if (targetNode.level === 0) {
                if (targetNode.Name !== JV.NODE_DISCRETE_INFO && moveType === 'inner') {
                    rst = true;
                }
            } else {
                let parentNode = targetNode.getParentNode();
                if (parentNode.Name === "离散信息") {
                    // if (targetNode.Name === "Fields") {
                    //     rst = true;
                    // }
                }
            }
        }
        return rst;
    },
    onRemove: function () {
        //
    },
    onRename: function () {
        //
    },
    addHoverDom: function(treeId, treeNode) {
        let me = dataInfoMapTreeOprObj, sObj = $("#" + treeNode.tId + "_span");
        if (treeNode.editNameFlag || $("#addBtn_"+treeNode.tId).length > 0) {
            return;
        } else if ((treeNode.level === 0 && treeNode[JV.PROP_NAME] === JV.NODE_DISCRETE_INFO) || (treeNode.level === 2 && treeNode[JV.PROP_NAME] === "离散文本集")) {
            let addStr = "<span class='button add' id='addBtn_" + treeNode.tId + "' title='新增' onfocus='this.blur();'></span>";
            sObj.after(addStr);
            let btn = $("#addBtn_"+treeNode.tId);
            if (treeNode[JV.PROP_NAME] === JV.NODE_DISCRETE_INFO) {
                btn.bind("click", function(){
                    let amtIdx = treeNode.items.length + 1;
                    let node = {};
                    node[JV.PROP_NAME] = "离散" + amtIdx;
                    node[JV.PROP_BAND_NAME] = me.bandTreeObj.getNodes()[0][JV.PROP_NAME];
                    node.items = [];
                    let fields = {"Name": "离散字段集", "items": [], "isParent": true};
                    let texts = {"Name": "离散文本集", "items": [], "isParent": true};
                    node.items.push(fields);
                    node.items.push(texts);
                    let newNodes = [];
                    newNodes.push(node);
                    me.treeObj.addNodes(treeNode, -1, newNodes, true);
                });
            } else {
                //text
                btn.bind("click", function(){
                    let node = me.private_get_dummy_text_node();
                    let newNodes = [];
                    newNodes.push(node);
                    me.treeObj.addNodes(treeNode, -1, newNodes, true);
                });
            }
        }
    },
    removeHoverDom: function(treeId, treeNode) {
        $("#addBtn_"+treeNode.tId).unbind().remove();
    },
    extractTabFields: function (rptTpl) {
        let me = dataInfoMapTreeOprObj;
        // for (let rootNode of me.treeObj.getNodes()) {
        //     rptTpl[JV.NODE_FIELD_MAP][rootNode.Name] = [];
        //     for (let mappingFieldNode of rootNode.items) {
        //         rptTpl[JV.NODE_FIELD_MAP][rootNode.Name].push(me.createMapFieldByNode(mappingFieldNode));
        //     }
        // }
        if (rptTpl[JV.NODE_FLOW_INFO]) {
            //
        }
        if (rptTpl[JV.NODE_CROSS_INFO]) {
            //
        }
        if (rptTpl[JV.NODE_BILL_INFO]) {
            let nodes = me.treeObj.getNodes();
            for (let node of nodes) {
                if (node[JV.PROP_NAME] === JV.NODE_BILL_CONTENT) {
                    let newContent = {};
                    newContent[JV.PROP_BAND_NAME] = node[JV.PROP_BAND_NAME];
                    newContent[JV.PROP_BILL_FIELDS] = [];
                    for (let subNode of node.items) {
                        let f = {};
                        me.private_copy_field_properties(subNode, f);
                        newContent[JV.PROP_BILL_FIELDS].push(f);
                    }
                    rptTpl[JV.NODE_BILL_INFO][JV.NODE_BILL_CONTENT] = newContent;
                } else if (node[JV.PROP_NAME] === JV.NODE_DISCRETE_INFO) {
                    rptTpl[JV.NODE_BILL_INFO][JV.NODE_DISCRETE_INFO] = me.private_extract_discrete_info(node);
                }
            }
        }
    },
    private_extract_discrete_info: function(discreteNode) {
        let me = this, rst = [];
        for (let node of discreteNode) {
            let newContent = {};
            rst.push(newContent);
            newContent[JV.PROP_BAND_NAME] = node[JV.PROP_BAND_NAME];
            if (node[JV.PROP_DISCRETE_FIELDS] && node[JV.PROP_DISCRETE_FIELDS].length > 0) {
                newContent[JV.PROP_DISCRETE_FIELDS] = [];
                for (let field of node[JV.PROP_DISCRETE_FIELDS]) {
                    let item = {};
                    newContent[JV.PROP_DISCRETE_FIELDS].push(item);
                    if (field[JV.PROP_FIELD_ID]) {
                        me.private_copy_field_properties(field, item);
                    } else if (field[JV.PROP_PARAM_ID]) {
                        me.private_copy_param_properties(field, item);
                    }
                }
            }
            if (node[JV.PROP_TEXTS] && node[JV.PROP_TEXTS].length > 0) {
                newContent[JV.PROP_TEXTS] = [];
                for (let txt of node[JV.PROP_TEXTS]) {
                    let item = {};
                    newContent[JV.PROP_TEXTS].push(item);
                    me.private_copy_text_properties(txt, item);
                }
            }
        }
        return rst;
    },
    extractDiscreteFieldParam: function(rptTpl) {
        let me = dataInfoMapTreeOprObj;
    },
    createMapFieldByNode: function (node) {
        //
    }
};