1581 lines
43 KiB
JavaScript
1581 lines
43 KiB
JavaScript
var mindmapMgr = undefined;
|
||
|
||
$(document).ready(function()
|
||
{
|
||
mindmapMgr = new ztmindmap.Wraper({
|
||
product: productID,
|
||
branch: branch,
|
||
typeKeys:{
|
||
module: userConfig_module,
|
||
scene: userConfig_scene,
|
||
testcase: userConfig_case,
|
||
stepGroup: userConfig_group,
|
||
precondition: userConfig_precondition,
|
||
pri: userConfig_pri
|
||
}
|
||
});
|
||
|
||
$.get($.createLink('testcase', 'getXmindImport'),function(res)
|
||
{
|
||
var data = JSON.parse(res);
|
||
if(ztmindmap.isArray(data))
|
||
{
|
||
var rootTopic = data[0].rootTopic;
|
||
mindmapMgr.initFromJSON(rootTopic);
|
||
}
|
||
else
|
||
{
|
||
var sheet = data["xmap-content"]["sheet"];
|
||
if(ztmindmap.isArray(sheet)) sheet = sheet[0];
|
||
mindmapMgr.initFromSheet(sheet);
|
||
}
|
||
|
||
setTimeout(() => mindmapMgr.render(), 500)
|
||
});
|
||
|
||
$("#xmindmapSave").on("click",function(e)
|
||
{
|
||
var data = mindmapMgr.toJson();
|
||
if(data.testcaseList.length == 0)
|
||
{
|
||
zui.Modal.alert(jsLng.caseNotExist);
|
||
return;
|
||
}
|
||
|
||
var hasExist = false;
|
||
for(i in data.sceneList)
|
||
{
|
||
if(hasExist) break;
|
||
|
||
var scene = data.sceneList[i];
|
||
if(typeof(scene.id) != 'undefined') hasExist = true;
|
||
}
|
||
for(i in data.testcaseList)
|
||
{
|
||
if(hasExist) break;
|
||
|
||
var testcase = data.testcaseList[i];
|
||
if(typeof(testcase.id) != 'undefined') hasExist = true;
|
||
}
|
||
|
||
if(hasExist)
|
||
{
|
||
var confirmActions = [{btnType: 'primary', class: 'btn-wide', key: 'confirm', text: importAndCoverLang}, {class: 'btn-wide', key: 'cancel', text: importAndInsertLang}];
|
||
zui.Modal.confirm({message: noticeImport, actions: confirmActions, onResult: (confirmed) => {submitXmindImport(data, confirmed ? 0 : 1);}});
|
||
return;
|
||
}
|
||
|
||
submitXmindImport(data);
|
||
})
|
||
|
||
});
|
||
|
||
function submitXmindImport(data, insert)
|
||
{
|
||
if(typeof(insert) == 'undefined') insert = 1;
|
||
|
||
var sceneList = JSON.stringify(data.sceneList);
|
||
var testcaseList = JSON.stringify(data.testcaseList);
|
||
|
||
var form = new FormData();
|
||
form.append("insert", insert);
|
||
form.append("productID", productID);
|
||
form.append("branch", branch);
|
||
form.append("sceneList", sceneList);
|
||
form.append("testcaseList", testcaseList);
|
||
|
||
$.ajaxSubmit({url: $.createLink('testcase', 'saveXmindImport'), data: form});
|
||
}
|
||
|
||
function setStories(){
|
||
//do nothing
|
||
}
|
||
|
||
if(window.ztmindmap == undefined) window.ztmindmap = {};
|
||
|
||
ztmindmap.ModuleManager = function(wraper){ this.wraper = wraper;}
|
||
ztmindmap.ModuleManager.prototype.clearNodeDisplay = function($node, data){ $node.find(".suffix").hide();};
|
||
|
||
ztmindmap.ModuleManager.prototype.getContextMenuList = function(data)
|
||
{
|
||
if(data.$.typeBy.import == true) return [];
|
||
|
||
//如果上一个节点时模型，当前节点可以在 ”场景“ 和 ”测试用例间切换“
|
||
var parentNode = this.wraper.findParentNode(data);
|
||
if(parentNode.$.type == "module")
|
||
{
|
||
var menus = [];
|
||
|
||
if(data.$.type == "testcase" || data.$.type == undefined) menus.push({action:"addScene", label:jsLng.set2Scene});
|
||
if(data.$.type == "scene" || data.$.type == undefined) menus.push({action:"addTestcase", label:jsLng.set2Testcase});
|
||
if(data.$.type != undefined) menus.push({action:"delType", label:jsLng.clearSetting});
|
||
|
||
return menus;
|
||
}
|
||
|
||
return [];
|
||
};
|
||
|
||
ztmindmap.ModuleManager.prototype.delType = function($node,data)
|
||
{
|
||
this.wraper.changeNodeType($node,data,undefined);
|
||
this.wraper.clearTypeAfter($node,data);
|
||
//this.refreshDisplay();
|
||
}
|
||
|
||
ztmindmap.ModuleManager.prototype.addScene = function($node,data)
|
||
{
|
||
var moduleData = this.wraper.findParentData(data);
|
||
data.$.moduleID = moduleData.$.moduleID;
|
||
this.wraper.changeNodeType($node,data,"scene");
|
||
this.wraper.clearTypeAfter($node,data);
|
||
//this.refreshDisplay();
|
||
}
|
||
|
||
ztmindmap.ModuleManager.prototype.addTestcase = function($node,data)
|
||
{
|
||
this.wraper.changeNodeType($node,data,"testcase");
|
||
this.wraper.clearTypeAfter($node,data);
|
||
//this.refreshDisplay();
|
||
}
|
||
|
||
ztmindmap.ModuleManager.prototype.refreshNodeDisplay = function($node, data)
|
||
{
|
||
$node.find(".suffix").hide();
|
||
|
||
if(data.$.moduleID != undefined)
|
||
{
|
||
$node.find(".suffix").show();
|
||
$node.find(".suffix").find(".content").html(this.wraper.disKeys['module'] + ":" + data.$.moduleID);
|
||
}
|
||
}
|
||
|
||
ztmindmap.ModuleManager.prototype.refreshDisplay = function(){ this.wraper.refreshDisplay();};
|
||
|
||
|
||
if(window.ztmindmap == undefined) window.ztmindmap = {};
|
||
|
||
ztmindmap.SceneManager = function(wraper)
|
||
{
|
||
this.wraper = wraper;
|
||
this.proprMgr = new ztmindmap.SceneProperyManager(this);
|
||
this.proprMgr.init();
|
||
};
|
||
|
||
ztmindmap.SceneManager.prototype.clearNodeDisplay = function($node, data)
|
||
{
|
||
$node.find(".suffix").hide();
|
||
$node.find(".scene-indicator").hide();
|
||
|
||
$node.removeAttr("title");
|
||
data.tooltip = undefined;
|
||
data.$.moduleID = undefined;
|
||
$node.tooltip('destroy');
|
||
};
|
||
|
||
ztmindmap.SceneManager.prototype.refreshNodeDisplay = function($node, data)
|
||
{
|
||
$node.find(".scene-indicator").show();
|
||
|
||
$node.find(".scene-indicator").removeClass("scene-indicator-yes");
|
||
|
||
if(data.$.moduleID != undefined)
|
||
{
|
||
$node.attr("title",data.tooltip);
|
||
$node.tooltip();
|
||
|
||
$node.find(".scene-indicator").addClass("scene-indicator-yes");
|
||
}
|
||
|
||
if(data.$.sceneID != undefined)
|
||
{
|
||
$node.find(".suffix").show();
|
||
$node.find(".suffix").find(".content").html(this.wraper.disKeys['scene'] + ":" + data.$.sceneID);
|
||
}
|
||
};
|
||
|
||
ztmindmap.SceneManager.prototype.getContextMenuList = function(data)
|
||
{
|
||
var parentNode = this.wraper.findParentNode(data);
|
||
if(parentNode.$.type == "scene" && (data.$.type != "testcase" && data.$.type != "scene"))
|
||
return [{action:"addTestcase", label:jsLng.set2Testcase}];
|
||
|
||
if(data.$.typeBy.import == true || data.$.type != "scene") return [];
|
||
|
||
//如果有父场景(包括父父节点)，当前节点禁止设置所属模块，只能最前面的场景节点设置
|
||
var parents = this.wraper.findParentNodes(data);
|
||
for(var i=0;i<parents.length;i++)
|
||
{
|
||
var item = parents[i];
|
||
if(item.$.type == "scene") return [];
|
||
}
|
||
|
||
return [{action:"configModule", label:jsLng.setModule}];
|
||
};
|
||
|
||
ztmindmap.SceneManager.prototype.addTestcase = function($node,data)
|
||
{
|
||
this.wraper.changeNodeType($node,data,"testcase");
|
||
this.wraper.clearTypeAfter($node,data);
|
||
//this.refreshDisplay();
|
||
}
|
||
|
||
ztmindmap.SceneManager.prototype.configModule = function($node,data){ this.proprMgr.show($node,data);};
|
||
|
||
ztmindmap.SceneManager.prototype.refreshDisplay = function(){ this.wraper.refreshDisplay();}
|
||
|
||
ztmindmap.SceneProperyManager = function(mgr)
|
||
{
|
||
this.$modal = undefined;
|
||
this.$node = undefined;
|
||
this.data = undefined;
|
||
this.mgr = mgr;
|
||
};
|
||
|
||
ztmindmap.SceneProperyManager.prototype.init = function()
|
||
{
|
||
var that = this;
|
||
|
||
this.$modal = new zui.ModalBase('#moduleSelector', {show: false});
|
||
this.$modal.$element.find("#sceneProperySave").on("click",function(){ that.save();});
|
||
this.$modal.$element.find("#moduleSelectorCancel").on("click",function(){ that.$modal.hide();});
|
||
};
|
||
|
||
ztmindmap.SceneProperyManager.prototype.show = function($node,data)
|
||
{
|
||
this.$node = $node;
|
||
this.data = data;
|
||
|
||
if(data.$.type != "scene") return;
|
||
|
||
var initScene = data.$.sceneID || 0;
|
||
this.$modal.$element.find(".picker").zui('picker').$.setValue(initScene);
|
||
this.$modal.show();
|
||
};
|
||
|
||
ztmindmap.SceneProperyManager.prototype.save = function()
|
||
{
|
||
var moduleID = this.$modal.$element.find("[name='module']").val();
|
||
|
||
if(moduleID == undefined || moduleID == 0)
|
||
{
|
||
alert(jsLng.pickModule);
|
||
return;
|
||
}
|
||
|
||
var moduleName = this.$modal.$element.find(".picker-single-selection").html();
|
||
|
||
this.data.$.moduleID = moduleID;
|
||
this.data.tooltip = moduleName;
|
||
this.mgr.refreshNodeDisplay(this.$node,this.data);
|
||
|
||
this.mgr.wraper.autoSetSceneModuleAfter(this.$node,this.data);
|
||
this.mgr.refreshDisplay();
|
||
|
||
this.$modal.hide();
|
||
};
|
||
|
||
|
||
if(window.ztmindmap == undefined) window.ztmindmap = {};
|
||
|
||
ztmindmap.StepGroupManager = function(wraper){ this.wraper = wraper;};
|
||
|
||
ztmindmap.StepGroupManager.prototype.clearNodeDisplay = function($node, data){ $node.find(".suffix").hide();};
|
||
|
||
ztmindmap.StepGroupManager.prototype.refreshNodeDisplay = function($node, data)
|
||
{
|
||
$node.find(".suffix").hide();
|
||
$node.find(".suffix").show();
|
||
$node.find(".suffix").find(".content").html(this.wraper.disKeys['stepGroup']);
|
||
};
|
||
|
||
if(window.ztmindmap == undefined) window.ztmindmap = {};
|
||
|
||
ztmindmap.PreconditionManager = function(wraper){ this.wraper = wraper; };
|
||
|
||
ztmindmap.PreconditionManager.prototype.clearNodeDisplay = function($node, data){ $node.find(".suffix").hide();};
|
||
|
||
ztmindmap.PreconditionManager.prototype.refreshNodeDisplay = function($node, data)
|
||
{
|
||
$node.find(".suffix").hide();
|
||
$node.find(".suffix").show();
|
||
$node.find(".suffix").find(".content").html(this.wraper.disKeys['precondition']);
|
||
};
|
||
|
||
|
||
if(window.ztmindmap == undefined) window.ztmindmap = {};
|
||
|
||
/**
|
||
* 设为场景：节点后面的自动推断, 按照最多4级来判断：测试用例 -> 步骤分组 ->步骤 -> 期望结果
|
||
*
|
||
* 清除前面场景：不做其他推断
|
||
* 清除后面场景：直接子节点设置为测试用例
|
||
* 清除当前场景：仅在只有一个场景的情况下有这个菜单，同时删除所有用例
|
||
*
|
||
* 设为废弃：当前节点及其后续节点全部丢掉
|
||
* 重新启用：当前节点及其后续节点全部启用
|
||
*
|
||
* 清除场景： 操作不够明确，无法判断用户意图，这里不提供
|
||
*/
|
||
|
||
ztmindmap.nodeTemplate =
|
||
"<div data-toggle='tooltip' data-placement='bottom' id='node-{id}' class='mindmap-node' data-type='{type}' data-id='{id}' data-parent='{parent}'>" +
|
||
" <div class='scene-indicator' style='display:none;'><i class='icon icon-flag'></i></div>" +
|
||
" <a class='pri-level' style='display:none;'></a>" +
|
||
" <div class='wrapper'>" +
|
||
" <div class='text'>{text}</div>" +
|
||
" <div class='caption'>{caption}</div>" +
|
||
" <div class='btn-toggle'></div>" +
|
||
" </div>" +
|
||
" <div class='suffix'><span>[</span><span class='content'>M:10000</span><span>]</span></div>" +
|
||
"</div>";
|
||
|
||
ztmindmap.defaultTypeKeys = {
|
||
module: "M",
|
||
scene: "S",
|
||
testcase: "C",
|
||
stepGroup:"G",
|
||
precondition:"pre",
|
||
pri: "P"
|
||
}
|
||
|
||
|
||
ztmindmap.Wraper = function(params)
|
||
{
|
||
this.data = undefined;
|
||
this.productID = params.product;
|
||
this.branch = params.branch;
|
||
this.typeKeys = $.extend({},ztmindmap.defaultTypeKeys,params.typeKeys);
|
||
this.disKeys = $.extend({},ztmindmap.defaultTypeKeys,params.typeKeys);
|
||
|
||
for(var key in this.typeKeys) this.typeKeys[key] = this.typeKeys[key].toLowerCase();
|
||
|
||
this.nodeMgrs = {
|
||
scene: new ztmindmap.SceneManager(this),
|
||
testcase: new ztmindmap.TestcaseManager(this),
|
||
module: new ztmindmap.ModuleManager(this),
|
||
stepGroup: new ztmindmap.StepGroupManager(this),
|
||
precondition: new ztmindmap.PreconditionManager(this)
|
||
}
|
||
};
|
||
|
||
ztmindmap.Wraper.prototype.initFromJSON = function(root)
|
||
{
|
||
var rootNode = this.paserXmindNode(root,0);
|
||
|
||
this.xmindJson2zendao(root,rootNode,1);
|
||
|
||
this.data = rootNode;
|
||
|
||
this.inheritImportProps();
|
||
}
|
||
|
||
ztmindmap.Wraper.prototype.initFromSheet = function(sheet)
|
||
{
|
||
var title = ztmindmap.isObject(sheet.title) ? sheet.title.text : sheet.title;
|
||
|
||
var root = {id:sheet.id, text:title,children:[],type:"tmpTop"};
|
||
|
||
this.xmindXml2zendao(sheet.topic, root, 0);
|
||
|
||
this.data = root.children[0];
|
||
|
||
this.inheritImportProps();
|
||
};
|
||
|
||
ztmindmap.Wraper.prototype.render = function()
|
||
{
|
||
var that = this;
|
||
|
||
that.instance = createMindmap({
|
||
hSpace:80,
|
||
showToggleButton: true,
|
||
nodeTeamplate: ztmindmap.nodeTemplate,
|
||
data: that.data,
|
||
enableDrag: false,
|
||
subLineWidth: 2,
|
||
afterNodeLoad: function(event)
|
||
{
|
||
var data = event.data;
|
||
var $node = event.$node;
|
||
|
||
that.refreshNodeDisplay($node,data);
|
||
that.register($node,data);
|
||
|
||
$node.on("contextmenu",function(e)
|
||
{
|
||
var contextMenuList = that.getContextMenuList(data);
|
||
if(contextMenuList.length == 0) return;
|
||
|
||
e.preventDefault();
|
||
|
||
mindmap$.zui.ContextMenu.show(contextMenuList,{event:e,onClickItem:function(item)
|
||
{
|
||
if(item.type == undefined)
|
||
that[item.action] && that[item.action]($node,data);
|
||
else
|
||
that.nodeMgrs[item.type][item.action] && that.nodeMgrs[item.type][item.action]($node, data);
|
||
}});
|
||
});
|
||
}
|
||
});
|
||
|
||
for(var key in this.nodeMgrs)
|
||
{
|
||
this.nodeMgrs[key]["init"] && this.nodeMgrs[key]["init"]();
|
||
}
|
||
};
|
||
|
||
ztmindmap.Wraper.prototype.refreshDisplay = function(){ this.instance.showNode();};
|
||
|
||
ztmindmap.Wraper.prototype.getContextMenuList = function(data)
|
||
{
|
||
var contextMenuList = [];
|
||
|
||
if(data.$.typeBy.import == false)
|
||
{
|
||
if(data.$.type != "scene")
|
||
{
|
||
var parents = this.findParentNodes(data);
|
||
var canChangeToScene = true;
|
||
for(var i=parents.length-1;i>=0;i--)
|
||
{
|
||
var item = parents[i];
|
||
if(item.$.type == "testcase" || item.$.type == "stepGroup")
|
||
{
|
||
canChangeToScene = false;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if(canChangeToScene == true) contextMenuList.push({ action: "setAsScene", label: jsLng.set2Scene});
|
||
}
|
||
|
||
if(data.$.type == "scene")
|
||
{
|
||
var removeBeforeScene = this.canRemoveSceneBefore(data);
|
||
var removeAfterScene = this.canRemoveSceneAfter(data);
|
||
|
||
if(removeBeforeScene == true) contextMenuList.push({ action: "clearBeforeScene", label: jsLng.clearBefore });
|
||
|
||
if(removeAfterScene == true) contextMenuList.push({ action: "clearAfterScene", label: jsLng.clearAfter });
|
||
|
||
if(removeBeforeScene == false && removeAfterScene == false && data.$.typeBy.import == false) contextMenuList.push({ action: "clearCurrentScene", label: jsLng.clearCurrent });
|
||
}
|
||
}
|
||
|
||
for(var key in this.nodeMgrs)
|
||
{
|
||
var mgr = this.nodeMgrs[key];
|
||
var menuList = mgr.getContextMenuList != undefined ? mgr.getContextMenuList(data) : [];
|
||
|
||
if(menuList.length > 0 && contextMenuList.length >0) contextMenuList.push({type:"divider"});
|
||
|
||
for(var i=0; i<menuList.length; i++)
|
||
{
|
||
var menuItem = menuList[i];
|
||
menuItem.type = key;
|
||
contextMenuList.push(menuItem);
|
||
}
|
||
}
|
||
|
||
return contextMenuList;
|
||
}
|
||
|
||
ztmindmap.Wraper.prototype.setAsScene = function($node, data)
|
||
{
|
||
|
||
this.changeNodeType($node,data, "scene");
|
||
this.autoReasoningAfter($node,data);
|
||
|
||
//如果父节点也是场景
|
||
let parent = this.findParentNode(data);
|
||
if(parent.$.type == "scene" && parent.$.moduleID != undefined)
|
||
{
|
||
let $parent = mindmap$("#node-" + parent.id);
|
||
this.copyScenePropertyAfter($parent,parent);
|
||
}
|
||
|
||
this.refreshDisplay();
|
||
}
|
||
|
||
ztmindmap.Wraper.prototype.copyScenePropertyAfter = function($node, data)
|
||
{
|
||
var children = data.children || [];
|
||
for(var childData of children)
|
||
{
|
||
if(childData.$.type != "scene") continue;
|
||
if(childData.$.typeBy.import == true) continue;
|
||
|
||
childData.$.moduleID = data.$.moduleID;
|
||
var $childNode = mindmap$("#node-" + childData.id);
|
||
this.refreshNodeDisplay($childNode,childData);
|
||
|
||
this.copyScenePropertyAfter($childNode,childData);
|
||
}
|
||
}
|
||
|
||
ztmindmap.Wraper.prototype.clearTypeAfter = function($node, data)
|
||
{
|
||
var that = this;
|
||
|
||
var children = data.children || [];
|
||
for(var child of children)
|
||
{
|
||
var $child = mindmap$("#node-" + child.id);
|
||
clearTypeImpl($child, child);
|
||
}
|
||
|
||
function clearTypeImpl($curNode, curData)
|
||
{
|
||
that.changeNodeType($curNode,curData,undefined);
|
||
var curChildren = curData.children || [];
|
||
for(var curChild of curChildren)
|
||
{
|
||
var $curChild = mindmap$("#node-" + curChild.id);
|
||
clearTypeImpl($curChild, curChild);
|
||
}
|
||
}
|
||
|
||
this.refreshDisplay();
|
||
}
|
||
|
||
ztmindmap.Wraper.prototype.clearBeforeScene = function($node, data)
|
||
{
|
||
var beforeScenes = this.findParentNodes(data);
|
||
for(var sceneData of beforeScenes)
|
||
{
|
||
if(sceneData.$.type != "scene" || sceneData.$.typeBy.import == true) continue;
|
||
|
||
var $sceneNode = mindmap$("#node-" + sceneData.id);
|
||
this.changeNodeType($sceneNode,sceneData,undefined);
|
||
}
|
||
|
||
this.refreshDisplay();
|
||
}
|
||
|
||
ztmindmap.Wraper.prototype.clearAfterScene = function($node,data)
|
||
{
|
||
this.autoRemoveSceneAfer($node,data);
|
||
|
||
var children = data.children || [];
|
||
for(var child of children)
|
||
{
|
||
var $child = mindmap$("#node-" + child.id);
|
||
this.changeNodeType($child,child,"testcase");
|
||
}
|
||
|
||
this.refreshDisplay();
|
||
}
|
||
|
||
ztmindmap.Wraper.prototype.clearCurrentScene = function($node, data)
|
||
{
|
||
if(data.$.typeBy.import == true) return;
|
||
|
||
this.changeNodeType($node,data,undefined);
|
||
this.autoRemoveSceneAfer($node,data);
|
||
|
||
var parentData = this.findParentData(data);
|
||
if(parentData.$.type == "scene")
|
||
{
|
||
this.changeNodeType($node,data,"testcase");
|
||
}
|
||
|
||
this.refreshDisplay();
|
||
}
|
||
|
||
/**
|
||
* 从给定节点开始(给定节点是场景节点)自动推动后续场景节点
|
||
* @param {*} $node 给定的场景节点$dom 元素
|
||
* @param {*} data 给定的场景节点数据
|
||
*/
|
||
ztmindmap.Wraper.prototype.autoReasoningAfter = function($node,data)
|
||
{
|
||
var children = data.children || [];
|
||
for(var i=0; i<children.length; i++)
|
||
{
|
||
var childData = children[i];
|
||
var $childNode = mindmap$("#node-" + childData.id);
|
||
|
||
if(childData.$.typeBy.import == true) continue;
|
||
|
||
if(childData.$.type == "scene") continue;
|
||
|
||
//获取给定子节点的子元素长度(包括节点本身)
|
||
var length = ztmindmap.getLengthOfNode(childData);
|
||
//测试用例 -> 测试步骤 -> 预期
|
||
//测试用例 -> 测试步骤分组 -> 测试步骤 -> 预期
|
||
if(length > 4)
|
||
{
|
||
//本身 + 子元素长度 大于 4 的肯定不是测试用例，这里自动推断为场景
|
||
childData.$.moduleID = data.$.moduleID;
|
||
childData.tooltip = data.tooltip;
|
||
this.changeNodeType($childNode,childData,"scene");
|
||
|
||
this.autoReasoningAfter($childNode,childData);
|
||
}
|
||
else
|
||
{
|
||
//本身 + 子元素长度 小于等于 4 的可能是场景，也可能是测试用例，这里默认推断为测试用例
|
||
//这里需要用户通过界面手动指定
|
||
this.changeNodeType($childNode,childData,"testcase");
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 移除给点节点下面的所有场景 和 测试用例
|
||
* @param {Object} $node 给定节点$Dom
|
||
* @param {Object} data 给定节点数据
|
||
*/
|
||
ztmindmap.Wraper.prototype.autoRemoveSceneAfer = function($node,data)
|
||
{
|
||
var children = data.children || [];
|
||
for(var i=0; i<children.length; i++)
|
||
{
|
||
var childData = children[i];
|
||
var $childNode = mindmap$("#node-" + childData.id);
|
||
|
||
if(childData.$.typeBy.import == true) continue;
|
||
|
||
//所有后续节点都先设置成 undefined
|
||
this.changeNodeType($childNode,childData,undefined);
|
||
|
||
this.autoRemoveSceneAfer($childNode,childData);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 自动设置后续所有的场景模块为指定节点的模块
|
||
* @param {Object} $node 指定节点
|
||
* @param {Object} data 指定节点的数据
|
||
*/
|
||
ztmindmap.Wraper.prototype.autoSetSceneModuleAfter = function($node, data)
|
||
{
|
||
var children = data.children || [];
|
||
for(var child of children)
|
||
{
|
||
if(child.$.type == "scene")
|
||
{
|
||
child.$.moduleID = data.$.moduleID;
|
||
child.tooltip = data.tooltip;
|
||
|
||
$child = mindmap$("#node-" + child.id);
|
||
this.refreshNodeDisplay($child,child);
|
||
|
||
this.autoSetSceneModuleAfter($child,child)
|
||
}
|
||
}
|
||
|
||
this.refreshDisplay();
|
||
}
|
||
|
||
/**
|
||
* 判断是否能删除给定场景节点前面的场景
|
||
* 必须满足：
|
||
* @param {Object} data
|
||
*/
|
||
ztmindmap.Wraper.prototype.canRemoveSceneBefore = function(data)
|
||
{
|
||
var scenes = this.findParentNodes(data);
|
||
for(var scene of scenes)
|
||
{
|
||
if(scene.$.type == "scene") return scene.$.typeBy.import == false;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
ztmindmap.Wraper.prototype.canRemoveSceneAfter = function(data)
|
||
{
|
||
var children = data.children || [];
|
||
for(var child of children)
|
||
{
|
||
if(child.$.type == "scene")
|
||
{
|
||
return child.$.typeBy.import == false;
|
||
}
|
||
else
|
||
{
|
||
if(this.canRemoveSceneAfter(child) == true) return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* 获取所有的叶子节点数据
|
||
*/
|
||
ztmindmap.Wraper.prototype.getLeafDatas = function()
|
||
{
|
||
var leafs = [];
|
||
|
||
function findLeafs(data)
|
||
{
|
||
if(data.children == undefined || data.children.length == 0)
|
||
leafs.push(data);
|
||
else
|
||
{
|
||
var children = data.children || [];
|
||
for(var child of children)
|
||
{
|
||
findLeafs(child);
|
||
}
|
||
}
|
||
}
|
||
|
||
findLeafs(this.data);
|
||
|
||
return leafs;
|
||
}
|
||
|
||
ztmindmap.Wraper.prototype.findParentData = function(purData)
|
||
{
|
||
var parentList = this.findParentDatas(purData);
|
||
|
||
return parentList.length >=2 ? parentList[parentList.length-2] : undefined;
|
||
}
|
||
|
||
/**
|
||
* 查找给数据的父节点，父父数据的集合(包括当前叶子节点)
|
||
* @param {Object} purData
|
||
*/
|
||
ztmindmap.Wraper.prototype.findParentDatas = function(purData)
|
||
{
|
||
var results = [];
|
||
|
||
function findParentDataPath(data)
|
||
{
|
||
if(data == purData) return true;
|
||
|
||
var children = data.children || [];
|
||
for(var child of children)
|
||
{
|
||
if(findParentDataPath(child) == true)
|
||
{
|
||
results.unshift(child);
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
var flag = findParentDataPath(this.data);
|
||
|
||
if(flag == true) results.unshift(this.data);
|
||
|
||
return results;
|
||
}
|
||
|
||
/**
|
||
* 查找给数据的父节点，父父节点的集合
|
||
* 倒序，使用的时候注意坑
|
||
* @param {Object} data
|
||
*/
|
||
ztmindmap.Wraper.prototype.findParentNodes = function(data)
|
||
{
|
||
|
||
var results = [];
|
||
|
||
function findParentPath(iData)
|
||
{
|
||
if(iData.id == data.parent)
|
||
{
|
||
results.push(iData);
|
||
return true;
|
||
}
|
||
|
||
var children = iData.children || [];
|
||
for(var child of children)
|
||
{
|
||
if(findParentPath(child) == true)
|
||
{
|
||
results.push(child);
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
findParentPath(this.instance.data);
|
||
|
||
return results;
|
||
}
|
||
|
||
/**
|
||
* 查找给定数据的父节点
|
||
* @param {Object} data 给定数据
|
||
*/
|
||
ztmindmap.Wraper.prototype.findParentNode = function(data)
|
||
{
|
||
function findParentImpl(iData)
|
||
{
|
||
if(iData.id == data.parent) return iData;
|
||
|
||
var children = iData.children || [];
|
||
for(var child of children)
|
||
{
|
||
var result = findParentImpl(child);
|
||
if(result != undefined) return result;
|
||
}
|
||
|
||
return undefined;
|
||
}
|
||
|
||
return findParentImpl(this.instance.data);
|
||
}
|
||
|
||
ztmindmap.Wraper.prototype.refreshNodeDisplay = function($node,data)
|
||
{
|
||
var mgr = this.nodeMgrs[data.$.type];
|
||
mgr && mgr.refreshNodeDisplay && mgr.refreshNodeDisplay($node,data);
|
||
}
|
||
|
||
ztmindmap.Wraper.prototype.register = function($node, data)
|
||
{
|
||
var mgr = this.nodeMgrs[data.$.type];
|
||
mgr && mgr.register && mgr.register($node,data);
|
||
}
|
||
|
||
ztmindmap.Wraper.prototype.changeNodeType = function($node,data,newType)
|
||
{
|
||
if(data.$.type == newType) return;
|
||
|
||
var oldMgr = this.nodeMgrs[data.$.type];
|
||
var newMgr = this.nodeMgrs[newType];
|
||
|
||
data.$.type = newType;
|
||
|
||
if(oldMgr != undefined)
|
||
{
|
||
oldMgr["clearNodeDisplay"] && oldMgr["clearNodeDisplay"]($node,data);
|
||
oldMgr["unRegister"] && oldMgr["unRegister"]($node,data);
|
||
}
|
||
|
||
if(newMgr != undefined)
|
||
{
|
||
newMgr["refreshNodeDisplay"] && newMgr["refreshNodeDisplay"]($node,data);
|
||
newMgr["register"] && newMgr["register"]($node,data);
|
||
}
|
||
};
|
||
|
||
ztmindmap.Wraper.prototype.xmindXml2zendao = function(topic, parent,level)
|
||
{
|
||
var obj = this.paserXmindNode(topic,level);
|
||
parent.children.push(obj);
|
||
|
||
var joinChildren = [];
|
||
|
||
if(topic.children != undefined)
|
||
{
|
||
var children = topic.children;
|
||
if(ztmindmap.isObject(children)) children = [children];
|
||
|
||
for(child of children)
|
||
{
|
||
var topicsList = child.topics;
|
||
if(ztmindmap.isObject(topicsList)) topicsList = [topicsList];
|
||
|
||
for(var topics of topicsList)
|
||
{
|
||
var topic = topics.topic;
|
||
if(typeof topic == 'undefined') continue;
|
||
if(ztmindmap.isObject(topic)) topic = [topic];
|
||
for(var t of topic)
|
||
{
|
||
joinChildren.push(t);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
for(var i=0; i<joinChildren.length; i++)
|
||
this.xmindXml2zendao(joinChildren[i],obj,level+1);
|
||
};
|
||
|
||
ztmindmap.Wraper.prototype.xmindJson2zendao = function(parentJson, parentNode,level)
|
||
{
|
||
if(parentJson.children == undefined) return;
|
||
if(parentJson.children.attached == undefined) return;
|
||
|
||
var children = parentJson.children;
|
||
|
||
var attached = children.attached;
|
||
if(ztmindmap.isArray(attached) == false)
|
||
attached = [attached];
|
||
|
||
for(var att of attached)
|
||
{
|
||
var obj = this.paserXmindNode(att,level);
|
||
parentNode.children.push(obj);
|
||
this.xmindJson2zendao(att,obj,level+1);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* 导出的数据再次导入时，自动继承设置属性
|
||
* 1）模块后面的所有场景继承模块的Id
|
||
* 2）场景后面的所有子场景继承场景的模块
|
||
* 3）场景之前的所有节点，前置设置为场景，并不容许删除(import=true, create=auto)
|
||
*/
|
||
ztmindmap.Wraper.prototype.inheritImportProps = function()
|
||
{
|
||
if(this.data.$.typeBy.import == false || this.data.$.productID == undefined) return;
|
||
|
||
var leafs = this.getLeafDatas();
|
||
for(var leaf of leafs)
|
||
{
|
||
var strandList = this.findParentDatas(leaf);
|
||
//两个场景之间的其他节点统一设置为场景节点
|
||
checkOtherBetweenScene(strandList);
|
||
//两个 import 之间的场景强制设置为 import
|
||
checkImportBetweenImportScene(strandList);
|
||
|
||
//module 或者 scene 节点后的所有场景节点模块都设置成 module or scene 节点对应的ID
|
||
checkSceneAfterModuleNode(strandList);
|
||
|
||
//最后一个场景的下一个节点默认识别为测试用例
|
||
checkLastSceneAfter(strandList);
|
||
}
|
||
|
||
function checkLastSceneAfter(dataList)
|
||
{
|
||
var lastIndex = -1;
|
||
for(var i=dataList.length-1;i>=0;i--)
|
||
{
|
||
if(dataList[i].$.type == "scene")
|
||
{
|
||
lastIndex = i;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if(lastIndex < 0 || lastIndex == dataList.length-1) return;
|
||
|
||
var nextData = dataList[lastIndex+1];
|
||
nextData.$.type = "testcase";
|
||
}
|
||
|
||
function checkOtherBetweenScene(dataList)
|
||
{
|
||
var firstSceneIndex = -1;
|
||
var lastSceneIndex = -1;
|
||
|
||
for(var i=0;i<dataList.length;i++)
|
||
{
|
||
if(dataList[i].$.type == "scene")
|
||
{
|
||
firstSceneIndex = i;
|
||
break;
|
||
}
|
||
}
|
||
|
||
for(var i=dataList.length-1;i>=0;i--)
|
||
{
|
||
if(dataList[i].$.type == "scene")
|
||
{
|
||
lastSceneIndex = i;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if(firstSceneIndex == lastSceneIndex)
|
||
return;
|
||
|
||
for(var i=firstSceneIndex;i<=lastSceneIndex;i++)
|
||
{
|
||
dataList[i].$.type = "scene";
|
||
}
|
||
}
|
||
|
||
function checkSceneAfterModuleNode(dataList)
|
||
{
|
||
var referIndex = -1;
|
||
for(var i=0;i<dataList.length;i++)
|
||
{
|
||
if(dataList[i].$.type == "module" || dataList[i].$.type == "scene")
|
||
{
|
||
referIndex = i;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if(referIndex < 0) return;
|
||
|
||
var moduleID = dataList[referIndex].$.moduleID;
|
||
for(var i=referIndex + 1; i<dataList.length;i++)
|
||
{
|
||
if(dataList[i].$.type == "scene") dataList[i].$.moduleID = moduleID;
|
||
}
|
||
}
|
||
|
||
function checkImportBetweenImportScene(dataList)
|
||
{
|
||
var firstSceneIndex = -1;
|
||
var lastSceneIndex = -1;
|
||
|
||
for(var i=0;i<dataList.length;i++)
|
||
{
|
||
if(dataList[i].$.type == "scene" && dataList[i].$.typeBy.import == true)
|
||
{
|
||
firstSceneIndex = i;
|
||
break;
|
||
}
|
||
}
|
||
|
||
for(var i=dataList.length-1;i>=0;i--)
|
||
{
|
||
if(dataList[i].$.type == "scene" && dataList[i].$.typeBy.import == true)
|
||
{
|
||
lastSceneIndex = i;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if(firstSceneIndex == lastSceneIndex) return;
|
||
|
||
for(var i=firstSceneIndex;i<=lastSceneIndex;i++)
|
||
{
|
||
dataList[i].$.typeBy.import = true;
|
||
dataList[i].$.typeBy.create = "auto";
|
||
}
|
||
}
|
||
}
|
||
|
||
ztmindmap.Wraper.prototype.paserXmindNode = function(nodeData, level)
|
||
{
|
||
var titleInfo = ztmindmap.splitText(getNodeText(nodeData.title));
|
||
|
||
var obj = { id:nodeData.id,
|
||
text: titleInfo.text,
|
||
type: level == 0 ? "root": (level == 1 ? "sub" : "node"),
|
||
children:[],
|
||
subSide:"right",
|
||
$:{
|
||
type: undefined,
|
||
typeBy: { import:false, create: "auto" }
|
||
}};
|
||
|
||
var props = ztmindmap.kv2Obj(titleInfo.suffix);
|
||
if(obj.type == "root" && titleInfo.suffix != undefined)
|
||
this['setPropsInProduct'] && this['setPropsInProduct'](obj, titleInfo.suffix);
|
||
else if(props[this.typeKeys.module] != undefined)
|
||
this['setPropsInModule'] && this['setPropsInModule'](obj, props);
|
||
else if(props[this.typeKeys.scene] != undefined)
|
||
this['setPropsInScene'] && this['setPropsInScene'](obj, props);
|
||
else if(props[this.typeKeys.testcase] != undefined)
|
||
this['setPropsInTestcase'] && this['setPropsInTestcase'](obj, props);
|
||
else if(props[this.typeKeys.precondition] != undefined)
|
||
this['setPropsInPrecondition'] && this['setPropsInPrecondition'](obj, props);
|
||
else if(props[this.typeKeys.stepGroup] != undefined)
|
||
{
|
||
obj.$.type = "stepGroup";
|
||
obj.$.typeBy.import = true;
|
||
}
|
||
else if(typeof(nodeData.title) == 'string')
|
||
{
|
||
let varType = typeof(nodeData.title);
|
||
if(varType == 'string') obj.text = nodeData.title;
|
||
if(varType == 'object') obj.text = nodeData.title.text;
|
||
}
|
||
|
||
return obj;
|
||
|
||
function getNodeText(v)
|
||
{
|
||
return ztmindmap.isObject(v) ? v.text : v;
|
||
}
|
||
};
|
||
|
||
ztmindmap.Wraper.prototype.setPropsInProduct = function(obj, suffix)
|
||
{
|
||
if(ztmindmap.isID(suffix) == false) return;
|
||
|
||
obj.readonly = true;
|
||
obj.$.productID = suffix * 1;
|
||
obj.$.type = "product";
|
||
obj.$.typeBy.import = true;
|
||
obj.$.typeBy.create = "auto";
|
||
}
|
||
|
||
ztmindmap.Wraper.prototype.setPropsInModule = function(obj, props)
|
||
{
|
||
var moduleID = props[this.typeKeys.module];
|
||
|
||
obj.$.type = "module";
|
||
obj.$.typeBy.create = "auto";
|
||
|
||
if(ztmindmap.isID(moduleID) == true)
|
||
{
|
||
obj.readonly = true;
|
||
obj.$.moduleID = moduleID;
|
||
obj.$.typeBy.import = true;
|
||
}
|
||
}
|
||
|
||
ztmindmap.Wraper.prototype.setPropsInScene = function(obj, props)
|
||
{
|
||
var sceneID = props[this.typeKeys.scene];
|
||
|
||
obj.$.type = "scene";
|
||
obj.$.typeBy.create = "auto";
|
||
|
||
if(ztmindmap.isID(sceneID))
|
||
{
|
||
obj.$.sceneID = sceneID;
|
||
obj.$.typeBy.import = true;
|
||
}
|
||
}
|
||
|
||
ztmindmap.Wraper.prototype.setPropsInTestcase = function(obj, props)
|
||
{
|
||
|
||
var testcaseID = props[this.typeKeys.testcase];
|
||
|
||
obj.$.type = "testcase";
|
||
obj.$.pri = props[this.typeKeys['pri']] || 3;
|
||
obj.$.typeBy.create = "auto";
|
||
|
||
if(ztmindmap.isID(testcaseID))
|
||
{
|
||
obj.$.testcaseID = testcaseID;
|
||
obj.$.typeBy.import = true;
|
||
}
|
||
}
|
||
|
||
ztmindmap.Wraper.prototype.setPropsInPrecondition = function(obj, props)
|
||
{
|
||
var precondition = props[this.typeKeys.precondition];
|
||
|
||
obj.$.type = "precondition";
|
||
obj.$.typeBy.create = "auto";
|
||
obj.$.typeBy.import = true;
|
||
obj.$.precondition = precondition;
|
||
}
|
||
|
||
ztmindmap.Wraper.prototype.toJson = function()
|
||
{
|
||
var that = this;
|
||
|
||
var sceneList = [];
|
||
var testcaseList = [];
|
||
|
||
var rootData = this.instance.data;
|
||
|
||
function sceneToJson(data)
|
||
{
|
||
if(data.$.type == "scene") sceneList.push(that.singleSceneToJson(data));
|
||
if(data.$.type == "testcase") return;
|
||
|
||
var children = data.children || [];
|
||
for(var child of children) sceneToJson(child);
|
||
}
|
||
|
||
function testcaseToJson(data)
|
||
{
|
||
if(data.$.type == "testcase")
|
||
testcaseList.push(that.singleTestCaseToJson(data));
|
||
else {
|
||
var children = data.children || [];
|
||
for(var child of children)
|
||
testcaseToJson(child);
|
||
}
|
||
}
|
||
|
||
sceneToJson(rootData);
|
||
testcaseToJson(rootData);
|
||
|
||
return {sceneList:sceneList, testcaseList:testcaseList};
|
||
};
|
||
|
||
ztmindmap.Wraper.prototype.singleSceneToJson = function(data)
|
||
{
|
||
var obj = {
|
||
name: data.text,
|
||
module: ztmindmap.toNum(data.$.moduleID,undefined),
|
||
product: this.productID * 1,
|
||
branch: this.branch * 1,
|
||
tmpId: data.id,
|
||
tmpPId: data.parent,
|
||
}
|
||
|
||
if(data.$.sceneID != undefined && data.$.sceneID != "") obj.id = data.$.sceneID * 1;
|
||
|
||
return obj;
|
||
};
|
||
|
||
ztmindmap.Wraper.prototype.singleTestCaseToJson = function(data)
|
||
{
|
||
var parentNode = this.findParentNode(data);
|
||
|
||
//获取测试用例数据
|
||
var obj = {
|
||
pri: ztmindmap.toNum(data.$.pri,3),
|
||
name: data.text,
|
||
//module: ztmindmap.toNum(scene.$.moduleID,0),
|
||
product: this.productID * 1,
|
||
branch: this.branch * 1,
|
||
precondition:'',
|
||
tmpId: data.id,
|
||
tmpPId: data.parent,
|
||
}
|
||
|
||
if(parentNode.$.type == "scene")
|
||
obj.module = ztmindmap.toNum(parentNode.$.moduleID,0);
|
||
else if(parentNode.$.type == "module")
|
||
obj.module = ztmindmap.toNum(parentNode.$.moduleID,0);
|
||
else
|
||
obj.module = 0;
|
||
|
||
//设置测试用例的id
|
||
if(data.$.testcaseID != undefined && data.$.testcaseID != "")
|
||
obj.id = data.$.testcaseID * 1;
|
||
|
||
//获取测试用例的步骤
|
||
obj.stepList = [];
|
||
var children = data.children || [];
|
||
for(var child of children)
|
||
{
|
||
if(child.$.type == "precondition")
|
||
{
|
||
obj.precondition = child.text;
|
||
continue;
|
||
}
|
||
|
||
var step = {
|
||
type: "step",
|
||
desc: child.text,
|
||
tmpId: child.id,
|
||
tmpPId: child.parent,
|
||
}
|
||
|
||
obj.stepList.push(step);
|
||
|
||
var maxLng = ztmindmap.getLengthOfNode(child);
|
||
var nextChilds = child.children || [];
|
||
|
||
//child的子元素：
|
||
//1) 有且仅只有一个，这个子元素作为期望结果来处理
|
||
if(maxLng == 2 && child.$.type != "stepGroup")
|
||
{
|
||
step.expect = nextChilds[0].text;
|
||
step.type = "step";
|
||
continue;
|
||
}
|
||
|
||
//2) 有多个子元素， 当前元素是步骤分组， 这些子元素作为子步骤
|
||
if(maxLng > 2 || child.$.type == "stepGroup")
|
||
{
|
||
step.type = "group";
|
||
for(var nextChild of nextChilds)
|
||
{
|
||
var subStep = {
|
||
type: "item",
|
||
desc: nextChild.text,
|
||
tmpId: nextChild.id,
|
||
tmpPId: nextChild.parent
|
||
};
|
||
|
||
obj.stepList.push(subStep);
|
||
|
||
//如果后续只有一个子元素，作为期望的结果来处理。
|
||
var nextNextChild = nextChild.children || [];
|
||
if(nextNextChild.length == 1)
|
||
subStep.expect = nextNextChild[0].text;
|
||
|
||
if(nextNextChild.length > 1)
|
||
{
|
||
subStep.type = "group";
|
||
for(var thirdLevelNode of nextNextChild)
|
||
{
|
||
var thirdLevelStep = {
|
||
type: "item",
|
||
desc: thirdLevelNode.text,
|
||
tmpId: thirdLevelNode.id,
|
||
tmpPId: thirdLevelNode.parent
|
||
};
|
||
|
||
//如果后续只有一个子元素，作为期望的结果来处理，超过一个子元素，丢掉后面的子元素
|
||
var forthLevelNode = thirdLevelNode.children || [];
|
||
if(forthLevelNode.length == 1)
|
||
thirdLevelStep.expect = forthLevelNode[0].text;
|
||
|
||
obj.stepList.push(thirdLevelStep);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return obj;
|
||
};
|
||
|
||
|
||
if(window.ztmindmap == undefined) window.ztmindmap = {};
|
||
|
||
ztmindmap.TestcaseManager = function(wraper)
|
||
{
|
||
this.wraper = wraper;
|
||
this.priSelector = undefined;
|
||
}
|
||
|
||
ztmindmap.TestcaseManager.prototype.init = function()
|
||
{
|
||
this.priSelector = new ztmindmap.PriSelector(this);
|
||
}
|
||
|
||
ztmindmap.TestcaseManager.prototype.register = function($node, data)
|
||
{
|
||
let that = this;
|
||
|
||
$node.find(".pri-level").on("click",function(e)
|
||
{
|
||
that.priSelector.show($node,data);
|
||
});
|
||
};
|
||
|
||
ztmindmap.TestcaseManager.prototype.unRegister = function($node, data)
|
||
{
|
||
$node.find(".pri-level").unbind();
|
||
};
|
||
|
||
ztmindmap.TestcaseManager.prototype.getContextMenuList = function(data)
|
||
{
|
||
var parent = this.wraper.findParentNode(data);
|
||
if(parent == undefined || parent.$.type != "testcase" || data.$.type == "precondition")
|
||
return [];
|
||
|
||
if(data.$.type == "stepGroup")
|
||
return [{action:"removeStepGroup", label:jsLng.removeGroup}];
|
||
else
|
||
return [{action:"addStepGroup", label:jsLng.set2Group}];
|
||
};
|
||
|
||
ztmindmap.TestcaseManager.prototype.removeStepGroup = function($node,data)
|
||
{
|
||
this.wraper.changeNodeType($node,data,undefined);
|
||
this.refreshDisplay();
|
||
}
|
||
|
||
ztmindmap.TestcaseManager.prototype.addStepGroup = function($node,data)
|
||
{
|
||
this.wraper.changeNodeType($node,data,"stepGroup");
|
||
this.refreshDisplay();
|
||
}
|
||
|
||
ztmindmap.TestcaseManager.prototype.clearNodeDisplay = function($node, data)
|
||
{
|
||
$node.find(".suffix").hide();
|
||
$node.find(".pri-level").hide();
|
||
};
|
||
|
||
ztmindmap.TestcaseManager.prototype.refreshNodeDisplay = function($node, data)
|
||
{
|
||
$node.find(".pri-level").show();
|
||
|
||
$node.find(".pri-level").removeClass("pri-1");
|
||
$node.find(".pri-level").removeClass("pri-2");
|
||
$node.find(".pri-level").removeClass("pri-3");
|
||
$node.find(".pri-level").removeClass("pri-4");
|
||
|
||
if(data.$.pri == undefined)
|
||
{
|
||
$node.find(".pri-level").addClass("pri-empty");
|
||
$node.find(".pri-level").html("");
|
||
}
|
||
else
|
||
{
|
||
$node.find(".pri-level").removeClass("pri-empty");
|
||
$node.find(".pri-level").html(data.$.pri);
|
||
$node.find(".pri-level").addClass("pri-" + data.$.pri);
|
||
}
|
||
|
||
if(data.$.testcaseID != undefined)
|
||
{
|
||
$node.find(".suffix").show();
|
||
$node.find(".suffix").find(".content").html(this.wraper.disKeys['testcase'] + ":" + data.$.testcaseID);
|
||
}
|
||
};
|
||
|
||
ztmindmap.TestcaseManager.prototype.refreshDisplay = function()
|
||
{
|
||
this.wraper.refreshDisplay();
|
||
}
|
||
|
||
ztmindmap.PriSelector = function(mgr)
|
||
{
|
||
this.$gradeDom = undefined;
|
||
this.$node = undefined;
|
||
this.data = undefined;
|
||
this.mgr = mgr;
|
||
|
||
this.init();
|
||
};
|
||
|
||
ztmindmap.PriSelector.prototype.init = function()
|
||
{
|
||
var that = this;
|
||
|
||
var htmlStr = "";
|
||
htmlStr += "<div class='testcase-pri-root effect'>";
|
||
htmlStr += " <a pri='1' class='pri-1' href='javascript:void(0);'>1</a>";
|
||
htmlStr += " <a pri='2' class='pri-2' href='javascript:void(0);'>2</a>";
|
||
htmlStr += " <a pri='3' class='pri-3' href='javascript:void(0);'>3</a>";
|
||
htmlStr += " <a pri='4' class='pri-4' href='javascript:void(0);'>4</a>";
|
||
htmlStr += "</div>";
|
||
|
||
var $priDom = mindmap$(htmlStr);
|
||
|
||
mindmap$(".mindmap-container").append($priDom);
|
||
|
||
$priDom.find("a").on("click",function(e)
|
||
{
|
||
var pri = mindmap$(e.currentTarget).attr("pri");
|
||
that.data.$.pri = pri;
|
||
that.mgr.refreshNodeDisplay(that.$node,that.data);
|
||
that.mgr.refreshDisplay();
|
||
});
|
||
|
||
mindmap$(document).on("click",function(e)
|
||
{
|
||
that.hide();
|
||
})
|
||
|
||
$priDom.hide();
|
||
that.$priDom = $priDom;
|
||
};
|
||
|
||
ztmindmap.PriSelector.prototype.show = function($node, data)
|
||
{
|
||
this.$node = $node;
|
||
this.data = data;
|
||
|
||
var nodeLeft = $node.position().left - 15;
|
||
var nodeTop = $node.position().top;
|
||
var nodeHeight = $node.height();
|
||
|
||
this.$priDom.css({left:nodeLeft, top:nodeTop + nodeHeight + 10});
|
||
|
||
this.$priDom.show();
|
||
};
|
||
|
||
ztmindmap.PriSelector.prototype.hide = function($node, data)
|
||
{
|
||
this.$node = undefined;
|
||
this.data = undefined;
|
||
|
||
this.$priDom && this.$priDom.hide();
|
||
};
|
||
|
||
|
||
if(window.ztmindmap == undefined) window.ztmindmap = {};
|
||
|
||
ztmindmap.isArray = function(obj)
|
||
{
|
||
return Object.prototype.toString.call(obj) === '[object Array]';
|
||
}
|
||
|
||
ztmindmap.isObject = function(obj)
|
||
{
|
||
return Object.prototype.toString.call(obj) === '[object Object]';
|
||
};
|
||
|
||
ztmindmap.getLengthOfNode = function(data)
|
||
{
|
||
var maxLength = 0;
|
||
|
||
var children = data.children || [];
|
||
for(var i=0; i<children.length; i++)
|
||
{
|
||
var tmpLength = ztmindmap.getLengthOfNode(children[0]);
|
||
maxLength = Math.max(maxLength, tmpLength);
|
||
}
|
||
|
||
return maxLength + 1;
|
||
}
|
||
|
||
ztmindmap.toNum = function(v, defaultValue = undefined)
|
||
{
|
||
if(v == undefined || v == "")
|
||
return defaultValue ? defaultValue * 1 : defaultValue;
|
||
|
||
return v * 1;
|
||
}
|
||
|
||
ztmindmap.trim = function(str)
|
||
{
|
||
if(str == undefined) return undefined;
|
||
|
||
return str.replace(/(^\s*)|(\s*$)/g, "");
|
||
}
|
||
|
||
ztmindmap.splitText = function(str)
|
||
{
|
||
str = ztmindmap.trim(str);
|
||
|
||
if(str == undefined || str == "") return {text:undefined, suffix:undefined};
|
||
|
||
var last = str.substr(str.length-1,1);
|
||
|
||
if(last != "]" && last != "】") return {text:str, suffix:undefined};
|
||
|
||
var sIndex1 = str.lastIndexOf("[");
|
||
var sIndex2 = str.lastIndexOf("【");
|
||
var sIndex = Math.max(sIndex1,sIndex2);
|
||
|
||
if(sIndex < 0) return {text:str, suffix:undefined};
|
||
|
||
var text = str.substring(0, sIndex);
|
||
var suffix = str.substring(sIndex+1, str.length-1);
|
||
|
||
return {text:ztmindmap.trim(text), suffix:ztmindmap.trim(suffix)};
|
||
}
|
||
|
||
ztmindmap.kv2Obj = function(suffix)
|
||
{
|
||
if(suffix == undefined) return {};
|
||
|
||
suffix = suffix.replace("，",",");
|
||
suffix = suffix.replace("：",":");
|
||
suffix = suffix.toLowerCase();
|
||
|
||
var obj = {};
|
||
|
||
var kvList = suffix.split(",");
|
||
for(var kvStr of kvList)
|
||
{
|
||
var tmpKvStr = ztmindmap.trim(kvStr);
|
||
if(tmpKvStr == undefined || tmpKvStr == "") continue;
|
||
|
||
var kvSplit = tmpKvStr.split(":");
|
||
|
||
var key = undefined;
|
||
var value = undefined;
|
||
|
||
if(kvSplit.length == 1)
|
||
{
|
||
key = ztmindmap.trim(kvSplit[0]);
|
||
value = key;
|
||
}
|
||
else
|
||
{
|
||
key = ztmindmap.trim(kvSplit[0]);
|
||
value = ztmindmap.trim(kvSplit[1]);
|
||
}
|
||
|
||
obj[key] = value;
|
||
}
|
||
|
||
return obj;
|
||
}
|
||
|
||
ztmindmap.isID = function(str)
|
||
{
|
||
if(str == undefined || str == "") return false;
|
||
|
||
return /(^[1-9]\d*$)/.test(str);
|
||
}
|