public void CreateTest()
{
HierarchyTree tree = new HierarchyTree();
tree.GetOrCreateNode(new string[] { "数学" });
tree.GetOrCreateNode(new string[] { "数学", "一年级" });
HierarchyTreeNode node = tree.GetOrCreateNode(new string[] { "数学", "一年级", "上册" });
tree.GetOrCreateNode(new string[] { "物理", "一年级" });
Assert.IsTrue(tree.root.children.Count == 2);
HierarchyTreeNode[] arr = tree.root.GetAllChild();
Assert.IsTrue(arr.Length == 5);
Assert.IsNotNull(tree.GetNode(new string[] { "数学", "一年级", "上册" }));
HierarchyTreeNode node1 = tree.GetNode(new string[] { "数学", "一年级", "上册" });
Assert.IsTrue(node1.IsValid());
Assert.IsTrue(node1.Path.Length == 3);
Assert.IsNotNull(tree.GetNode(new string[] { "数学", "一年级" }));
tree.GetNode(new string[] { "数学", "一年级" }).IsValid();
Assert.IsNull(tree.GetNode(new string[] { "数学123", "一年级" }));
//移除一个节点
tree.RemoveNode(new string[] { "数学", "一年级", "上册" });
Assert.IsNull(tree.GetNode(new string[] { "数学", "一年级", "上册" }));
Assert.IsFalse(node1.IsValid());
}
internal void OpenTable(NamedSmoObject objectToSelect, SqlConnectionInfo connection)
{
try
{
IExplorerHierarchy hierarchy = GetHierarchyForConnection(connection);
if (hierarchy == null)
{
return; // there is nothing we can really do if we don't have one of these
}
HierarchyTreeNode databasesNode = GetUserDatabasesNode(hierarchy.Root);
var resultNode = FindNodeForSmoObject(databasesNode, objectToSelect);
//MSSQLController.Current.SearchWindow.Activate();
if (resultNode != null)
{
OpenTable(resultNode, connection);
}
}
catch (Exception ex)
{
log.Error("Error opening table: " + objectToSelect.Name, ex);
}
}
/// <summary>
/// After expand node
/// </summary>
/// <param name="sender">object explorer</param>
/// <param name="e">expanding node</param>
void _trv_AfterExpand(object sender, TreeViewEventArgs e)
{
logger.LogStart(System.Reflection.MethodBase.GetCurrentMethod().Name);
// Wait for the async node expand to finish or we could miss indexes
try
{
HierarchyTreeNode htn = null;
int cnt = 0;
while ((htn = e.Node as HierarchyTreeNode) != null && htn.Expanding && cnt < 50000)
{
Application.DoEvents();
cnt++;
}
if (_trv.InvokeRequired)
{
_trv.BeginInvoke(new TrvEventAfterExpand(_trv_AfterExpand), new object[] { sender, e });
}
else
{
ReorganizeFolders(e.Node);
}
}
catch (Exception ex)
{
if (System.Diagnostics.Debugger.IsAttached)
{
System.Diagnostics.Debugger.Break();
}
debug_message(ex.ToString());
debug_message(ex.StackTrace.ToString());
}
logger.LogEnd(System.Reflection.MethodBase.GetCurrentMethod().Name);
}
private HierarchyTreeNode FindNodeForSmoObject(HierarchyTreeNode nodeDatabases, NamedSmoObject objectToSelect)
{
if (objectToSelect is Table)
{
return(FindTableNode(nodeDatabases, objectToSelect));
}
else if (objectToSelect is View)
{
var viewToSelect = (View)objectToSelect;
return(FindRecursively(nodeDatabases, viewToSelect.Parent, "Views", GetNodeNameFor(objectToSelect)));
}
else if (objectToSelect is StoredProcedure)
{
var procedure = (StoredProcedure)objectToSelect;
return(FindRecursively(nodeDatabases, procedure.Parent, "Programmability", "Stored Procedures", GetNodeNameFor(objectToSelect)));
}
else if (objectToSelect is UserDefinedFunction)
{
var func = (UserDefinedFunction)objectToSelect;
string functionNodeName = func.FunctionType == UserDefinedFunctionType.Scalar ? "Scalar-valued Functions" : "Table-valued Functions";
return(FindRecursively(nodeDatabases, func.Parent, "Programmability", "Functions", functionNodeName, GetNodeNameFor(objectToSelect)));
}
return(null);
}
protected override void Tree_SelectedItemChanged(object sender, RoutedPropertyChangedEventArgs <object> e)
{
HierarchyTreeNode node = e.NewValue as HierarchyTreeNode;
m_IsReadyToSelection = node != null;
base.Tree_SelectedItemChanged(sender, e);
}
protected override void TreeNode_MouseDoubleClick(object sender, CustomEventArgs <CustomTreeNode> e)
{
// Иерархии будут конечными узлами. Двойной клик на них будет равнозначен выбору
HierarchyTreeNode node = e.Args as HierarchyTreeNode;
if (node != null)
{
Raise_ApplySelection();
}
}
private void SetNodeRecursively(HierarchyTreeNode node)
{
node.Id = 0;
if (node.ChildNodes != null)
{
foreach (var item in node.ChildNodes)
{
this.SetNodeRecursively(item);
}
}
}
private async Task LoadRecursively(HierarchyTreeNode node)
{
node.ChildNodes = this.unitOfWork.HierarchyTreeNodeRepository.FindBy(n => n.ParentNodeId == node.Id).ToList();
if (node.ChildNodes != null)
{
foreach (var childNode in node.ChildNodes)
{
await this.LoadRecursively(childNode);
}
}
}
public NavigationItem GetTreeNodeToNavigationItem(HierarchyTreeNode HierarchyNavTreeNode)
{
IKenticoNavigationRepositoryHelper _CachableSelfHelper = DependencyResolver.Current.GetService <IKenticoNavigationRepositoryHelper>();
NavigationItem NavItem = new NavigationItem();
if (HierarchyNavTreeNode.Page is Navigation)
{
Navigation NavTreeNode = (Navigation)HierarchyNavTreeNode.Page;
switch ((NavigationTypeEnum)(NavTreeNode.NavigationType))
{
case NavigationTypeEnum.Automatic:
if (NavTreeNode.NavigationPageNodeGuid != Guid.Empty)
{
var TempNavItem = _CachableSelfHelper.GetTreeNodeToNav(NavTreeNode.NavigationPageNodeGuid);
// Convert to a new navigation item so it's not linked to the cached memory object, specifically the Children List
NavItem = _Mapper.Map <NavigationItem>(TempNavItem);
}
else
{
NavItem.LinkText = NavTreeNode.NavigationLinkText;
NavItem.LinkTarget = NavTreeNode.NavigationLinkTarget;
NavItem.LinkHref = NavTreeNode.NavigationLinkUrl;
}
break;
case NavigationTypeEnum.Manual:
default:
NavItem.LinkText = NavTreeNode.NavigationLinkText;
NavItem.LinkTarget = NavTreeNode.NavigationLinkTarget;
NavItem.LinkHref = NavTreeNode.NavigationLinkUrl;
break;
}
// Add additional items
NavItem.IsMegaMenu = NavTreeNode.NavigationIsMegaMenu;
NavItem.LinkCSSClass = NavTreeNode.NavigationLinkCSS;
NavItem.LinkOnClick = NavTreeNode.NavigationLinkOnClick;
NavItem.LinkAlt = NavTreeNode.NavigationLinkAlt;
NavItem.LinkPagePath = NavTreeNode.NodeAliasPath;
}
else
{
// Create navigation item from page manually
NavItem = _Mapper.Map <NavigationItem>(HierarchyNavTreeNode.Page);
}
// Add children
foreach (var HierarchyChild in HierarchyNavTreeNode.Children)
{
NavItem.Children.Add(GetTreeNodeToNavigationItem(HierarchyChild));
}
return(NavItem);
}
public void TestInitialize()
{
__root00 = new HierarchyTreeNode <Data>(new Data()
{
generation = 0, order = 0
});
__branch10 = new HierarchyTreeNode <Data>(new Data()
{
generation = 1, order = 0
});
__branch11 = new HierarchyTreeNode <Data>(new Data()
{
generation = 1, order = 1
});
__branch20 = new HierarchyTreeNode <Data>(new Data()
{
generation = 2, order = 0
});
__leaf21 = new HierarchyTreeNode <Data>(new Data()
{
generation = 2, order = 1
});
__leaf22 = new HierarchyTreeNode <Data>(new Data()
{
generation = 2, order = 2
});
__leaf23 = new HierarchyTreeNode <Data>(new Data()
{
generation = 2, order = 3
});
__leaf24 = new HierarchyTreeNode <Data>(new Data()
{
generation = 2, order = 4
});
__leaf30 = new HierarchyTreeNode <Data>(new Data()
{
generation = 3, order = 0
});
//assemble
__branch10.Parent = __root00;
__branch11.Parent = __root00;
__branch20.Parent = __branch10;
__leaf21.Parent = __branch10;
__leaf22.Parent = __branch10;
__leaf23.Parent = __branch11;
__leaf24.Parent = __branch11;
__leaf30.Parent = __branch20;
}
public static void EnumerateChildrenSynchronously(HierarchyTreeNode node)
{
Type t = node.GetType();
MethodInfo method = t.GetMethod("EnumerateChildren", new Type[] { typeof(Boolean) });
if (method != null)
{
method.Invoke(node, new Object[] { false });
}
else
{
node.EnumerateChildren();
}
}
public void TestMethodHierarchyNode1()
{
// Root(0,0)
// |
// |-------Branch10------Branch20-------------------Leaf30
// | |---Leaf21
// | |---Leaf22
// L-------Branch11------Leaf23
// |--Leaf24
var __list = HierarchyTreeNode <Data> .Path(__leaf30, __leaf24);
Assert.IsTrue(__list.Count == 6);
}
public static void SelectNode(IObjectExplorerService explorerService, HierarchyTreeNode node)
{
IServiceProvider provider = node as IServiceProvider;
if (provider != null)
{
INodeInformation containedItem = provider.GetService(typeof(INodeInformation)) as INodeInformation;
if (containedItem != null)
{
explorerService.SynchronizeTree(containedItem);
}
}
}
private void SetParentNodeForNode(HierarchyTreeNode node, IReadOnlyCollection <HierarchyTreeNode> originalNodes)
{
if (node.ChildNodes == null)
{
return;
}
foreach (var hierarchyTreeNode in node.ChildNodes)
{
hierarchyTreeNode.ParentNode =
node.Id == 0 ? node : originalNodes.FirstOrDefault(n => n.Id == node.Id) ?? node;
hierarchyTreeNode.ParentNodeId = hierarchyTreeNode.ParentNode.Id;
this.SetParentNodeForNode(hierarchyTreeNode, originalNodes);
}
}
private void SelectNode(HierarchyTreeNode node)
{
IServiceProvider provider = node as IServiceProvider;
if (provider != null)
{
INodeInformation containedItem = provider.GetService(typeof(INodeInformation)) as INodeInformation;
if (containedItem != null)
{
IObjectExplorerService objExplorer = GetObjectExplorer();
objExplorer.SynchronizeTree(containedItem);
}
}
}
protected override void RefreshTree()
{
base.RefreshTree();
if (CubeInfo != null)
{
// Если задано уникальное имя измерения, то создаем для данного измерения узел
if (!String.IsNullOrEmpty(DimensionUniqueName))
{
DimensionInfo info = CubeInfo.GetDimension(DimensionUniqueName);
if (info != null)
{
if (!String.IsNullOrEmpty(HierarchyUniqueName))
{
HierarchyInfo hierarchyInfo = info.GetHierarchy(HierarchyUniqueName);
if (hierarchyInfo != null)
{
HierarchyTreeNode hierarchyNode = AddHierarchyNode(null, hierarchyInfo);
CreateLevels(hierarchyNode, hierarchyInfo, false);
hierarchyNode.IsExpanded = true;
return;
}
else
{
LogManager.LogError(this, String.Format(Localization.MetadataResponseException_HierarchyByUniqueName_InDimension_NotFound, HierarchyUniqueName, DimensionUniqueName));
}
}
else
{
DimensionTreeNode dimNode = AddDimensionNode(null, info);
CreateHierarchies(dimNode, info, true);
dimNode.IsExpanded = true;
return;
}
}
else
{
LogManager.LogError(this, String.Format(Localization.MetadataResponseException_DimensionByUniqueName_InCube_NotFound, DimensionUniqueName, CubeName));
}
}
// Отображаем все измерения
CreateDimensions(null, CubeInfo, true);
}
}
private void OpenTable(HierarchyTreeNode node, SqlConnectionInfo connection)
{
var t = Type.GetType("Microsoft.SqlServer.Management.UI.VSIntegration.ObjectExplorer.OpenTableHelperClass,ObjectExplorer", true, true);
var mi = t.GetMethod("EditTopNRows", BindingFlags.Static | BindingFlags.Public);
var ncT = Type.GetType("Microsoft.SqlServer.Management.UI.VSIntegration.ObjectExplorer.NodeContext,ObjectExplorer", true, true);
IServiceProvider provider = node as IServiceProvider;
INodeInformation containedItem = provider.GetService(typeof(INodeInformation)) as INodeInformation;
var inst = Activator.CreateInstance(ncT, containedItem);
if (inst == null)
{
throw new Exception("Cannot create type" + ncT.ToString());
}
mi.Invoke(null, new Object[] { containedItem, 200 });
}
private HierarchyTreeNode GetUserDatabasesNode(HierarchyTreeNode rootNode)
{
if (rootNode != null)
{
// root should always be expandable
if (rootNode.Expandable)
{
EnumerateChildrenSynchronously(rootNode);
rootNode.Expand();
// TODO this is horrible code - it assumes the first node will ALWAYS be the "Databases" node in the object explorer, which may not always be the case
// however I couldn't think of a clean way to always find the right node
return((HierarchyTreeNode)rootNode.Nodes[0]);
}
}
return(null);
}
HierarchyTreeNode FindChildNodeByName(HierarchyTreeNode parentNode, string name)
{
if (!parentNode.Expandable)
{
return(null);
}
EnumerateChildrenSynchronously(parentNode);
parentNode.Expand();
foreach (HierarchyTreeNode child in parentNode.Nodes)
{
if (child.Text.ToLower() == name.ToLower())
{
return(child);
}
}
return(null);
}
HierarchyTreeNode FindDatabaseNodeByName(HierarchyTreeNode parentNode, Database database)
{
var databaseNode = FindChildNodeByName(parentNode, database.Name);
if (databaseNode != null)
{
return(databaseNode);
}
// trying to find node with (Read-Only) text at the end as read only database node will change its text
var readonlyDatabaseName = FindChildNodeByName(parentNode, database.Name + " (Read-Only)");
if (readonlyDatabaseName != null)
{
return(readonlyDatabaseName);
}
var standbyDatabaseName = FindChildNodeByName(parentNode, database.Name + " (Standby / Read-Only)");
return(standbyDatabaseName);
}
HierarchyTreeNode FindRecursively(HierarchyTreeNode parent, Database database, params string[] nodes)
{
var databaseNode = FindDatabaseNodeByName(parent, database);
if (databaseNode == null)
{
return(null);
}
HierarchyTreeNode currentLevel = databaseNode;
foreach (var nodeName in nodes)
{
currentLevel = FindChildNodeByName(currentLevel, nodeName);
if (currentLevel == null)
{
return(null);
}
}
return(currentLevel);
}
internal void SelectSMOObjectInObjectExplorer(NamedSmoObject objectToSelect, SqlConnectionInfo connection)
{
if (objectToSelect.State == SqlSmoState.Dropped)
{
log.Info("Trying to locate dropped object:" + objectToSelect.Name);
return;
}
IExplorerHierarchy hierarchy = GetHierarchyForConnection(connection);
if (hierarchy == null)
{
return; // there is nothing we can really do if we don't have one of these
}
HierarchyTreeNode databasesNode = GetUserDatabasesNode(hierarchy.Root);
var resultNode = FindNodeForSmoObject(databasesNode, objectToSelect);
if (resultNode != null)
{
SelectNode(resultNode);
}
}
public static string GetInvariantPath(this HierarchyTreeNode node)
{
return(FollowPropertyPath(node, "InvariantPath") as string);
}
private HierarchyTreeNode FindTableNode(HierarchyTreeNode nodeDatabases, NamedSmoObject tableSmoObject)
{
var tableToSelect = (Table)tableSmoObject;
return(FindRecursively(nodeDatabases, tableToSelect.Parent, "Tables", GetNodeNameFor(tableSmoObject)));
}
public NavigationItem GetTreeNodeToNavigationItem(HierarchyTreeNode HierarchyNavTreeNode)
{
return(GetTreeNodeToNavigationItemAsync(HierarchyNavTreeNode).Result);
}
/// <summary>
/// Transformation to any family member
/// if destination = null , means to root
/// </summary>
/// <returns></returns>
public CoordinateComposed Generate(HierarchyTreeNode <CoordinateBase> destination = null)
{
var _path = Node.Path(destination);
return(new CoordinateComposed(_path.ToList <ElementBase>()));
}
