public static void AddADNodes(string ldapPath)
{
try
{
TreeNode adCNode = Tree.Node.AddNode(Type.Container);
Container.Info nContI = new Container.Info();
nContI.TreeNode = adCNode;
nContI.ConnectionInfo = new Info(nContI);
if (Tree.Node.SelectedNode != null)
{
if (Tree.Node.GetNodeType(Tree.Node.SelectedNode) == Tree.Node.Type.Container)
{
nContI.Parent = Tree.Node.SelectedNode.Tag;
}
}
string strDisplayName;
strDisplayName = ldapPath.Remove(0, System.Convert.ToInt32(ldapPath.IndexOf("OU=") + 3));
strDisplayName = strDisplayName.Substring(0, strDisplayName.IndexOf(","));
nContI.Name = strDisplayName;
nContI.TreeNode.Text = strDisplayName;
adCNode.Tag = nContI;
Runtime.ContainerList.Add(nContI);
CreateADSubNodes(adCNode, ldapPath);
SelectedNode.Nodes.Add(adCNode);
SelectedNode = SelectedNode.Nodes[SelectedNode.Nodes.Count - 1];
}
catch (Exception ex)
{
Runtime.MessageCollector.AddMessage(Messages.MessageClass.ErrorMsg,
(string)
("AddADNodes failed" + Constants.vbNewLine + ex.Message), true);
}
}
public static void AddADNodes(string ldapPath)
{
try
{
TreeNode adCNode = Tree.Node.AddNode(Type.Container);
Container.Info nContI = new Container.Info();
nContI.TreeNode = adCNode;
nContI.ConnectionInfo = new Info(nContI);
if (Tree.Node.SelectedNode != null)
{
if (Tree.Node.GetNodeType(Tree.Node.SelectedNode) == Tree.Node.Type.Container)
{
nContI.Parent = Tree.Node.SelectedNode.Tag;
}
}
string strDisplayName;
strDisplayName = ldapPath.Remove(0, System.Convert.ToInt32(ldapPath.IndexOf("OU=") + 3));
strDisplayName = strDisplayName.Substring(0, strDisplayName.IndexOf(","));
nContI.Name = strDisplayName;
nContI.TreeNode.Text = strDisplayName;
adCNode.Tag = nContI;
Runtime.ContainerList.Add(nContI);
CreateADSubNodes(adCNode, ldapPath);
SelectedNode.Nodes.Add(adCNode);
SelectedNode = SelectedNode.Nodes[SelectedNode.Nodes.Count - 1];
}
catch (Exception ex)
{
Runtime.MessageCollector.AddMessage(Messages.MessageClass.ErrorMsg,
(string)
("AddADNodes failed" + Constants.vbNewLine + ex.Message), true);
}
}
public static void ImportConnections()
{
try
{
OpenFileDialog lD = Controls.ConnectionsLoadDialog();
lD.Multiselect = true;
if (lD.ShowDialog() == DialogResult.OK)
{
TreeNode nNode = null;
for (int i = 0; i <= lD.FileNames.Length - 1; i++)
{
nNode = Node.AddNode(Node.Type.Container, "Import #" + i.ToString());
Container.Info nContI = new Container.Info();
nContI.TreeNode = nNode;
nContI.ConnectionInfo = new Connection.Info(nContI);
if (Node.SelectedNode != null)
{
if (Node.GetNodeType(Node.SelectedNode) == Node.Type.Container)
{
nContI.Parent = Node.SelectedNode.Tag;
}
}
nNode.Tag = nContI;
ContainerList.Add(nContI);
Load conL = new Load
{
ConnectionFileName = lD.FileNames[i],
RootTreeNode = nNode,
Import = true,
ConnectionList = ConnectionList,
ContainerList = ContainerList
};
conL.LoadConnections();
Windows.treeForm.tvConnections.SelectedNode.Nodes.Add(nNode);
}
}
}
catch (Exception ex)
{
MessageCollector.AddMessage(MessageClass.ErrorMsg,
Language.strConnectionsFileCouldNotBeImported +
Constants.vbNewLine + ex.Message);
}
}
public static void CloneNode(TreeNode oldTreeNode, TreeNode parentNode = null)
{
try
{
if (GetNodeType(oldTreeNode) == Type.Connection)
{
Connection.Info oldConnectionInfo = (Info)oldTreeNode.Tag;
Connection.Info newConnectionInfo = oldConnectionInfo.Copy();
Connection.Info.Inheritance newInheritance = oldConnectionInfo.Inherit.Copy();
newInheritance.Parent = newConnectionInfo;
newConnectionInfo.Inherit = newInheritance;
Runtime.ConnectionList.Add(newConnectionInfo);
TreeNode newTreeNode = new TreeNode((string)newConnectionInfo.Name);
newTreeNode.Tag = newConnectionInfo;
newTreeNode.ImageIndex = System.Convert.ToInt32(Images.Enums.TreeImage.ConnectionClosed);
newTreeNode.SelectedImageIndex = System.Convert.ToInt32(Images.Enums.TreeImage.ConnectionClosed);
newConnectionInfo.TreeNode = newTreeNode;
if (parentNode == null)
{
oldTreeNode.Parent.Nodes.Add(newTreeNode);
Tree.Node.TreeView.SelectedNode = newTreeNode;
}
else
{
var parentContainerInfo = parentNode.Tag as Container.Info;
if (parentContainerInfo != null)
{
newConnectionInfo.Parent = parentContainerInfo;
}
parentNode.Nodes.Add(newTreeNode);
}
}
else if (GetNodeType(oldTreeNode) == Type.Container)
{
Container.Info newContainerInfo = (oldTreeNode.Tag as Container.Info).Copy();
Connection.Info newConnectionInfo = (oldTreeNode.Tag as Container.Info).ConnectionInfo.Copy();
newContainerInfo.ConnectionInfo = newConnectionInfo;
TreeNode newTreeNode = new TreeNode(newContainerInfo.Name);
newTreeNode.Tag = newContainerInfo;
newTreeNode.ImageIndex = System.Convert.ToInt32(Images.Enums.TreeImage.Container);
newTreeNode.SelectedImageIndex = System.Convert.ToInt32(Images.Enums.TreeImage.Container);
newContainerInfo.ConnectionInfo.Parent = newContainerInfo;
Runtime.ContainerList.Add(newContainerInfo);
oldTreeNode.Parent.Nodes.Add(newTreeNode);
Tree.Node.TreeView.SelectedNode = newTreeNode;
foreach (TreeNode childTreeNode in oldTreeNode.Nodes)
{
CloneNode(childTreeNode, newTreeNode);
}
}
}
catch (Exception ex)
{
Runtime.MessageCollector.AddMessage(Messages.MessageClass.WarningMsg,
string.Format(Language.strErrorCloneNodeFailed, ex.Message));
}
}
public void AddFolder()
{
try
{
TreeNode newNode = Node.AddNode(Node.Type.Container);
Container.Info newContainerInfo = new Container.Info();
newNode.Tag = newContainerInfo;
newContainerInfo.TreeNode = newNode;
if (tvConnections.Nodes.Count < 1)
{
System.Windows.Forms.TreeNode treeNode1 = new System.Windows.Forms.TreeNode("Connections");
treeNode1.Name = "nodeRoot";
treeNode1.Text = "Connections";
this.tvConnections.Nodes.AddRange(new[] {treeNode1});
}
TreeNode selectedNode = Node.SelectedNode;
TreeNode parentNode;
if (selectedNode == null)
{
parentNode = tvConnections.Nodes[0];
}
else
{
if (Node.GetNodeType(selectedNode) == Node.Type.Connection)
{
parentNode = selectedNode.Parent;
}
else
{
parentNode = selectedNode;
}
}
// We can only inherit from a container node, not the root node or connection nodes
if (Node.GetNodeType(parentNode) == Node.Type.Container)
{
newContainerInfo.Parent = parentNode.Tag;
}
else
{
if (newContainerInfo.ConnectionInfo.Inherit == null)
{
newContainerInfo.ConnectionInfo.Inherit = new Info.Inheritance(parentNode);
}
newContainerInfo.ConnectionInfo.Inherit.TurnOffInheritanceCompletely();
}
newContainerInfo.ConnectionInfo = new Info(newContainerInfo);
Runtime.ContainerList.Add(newContainerInfo);
parentNode.Nodes.Add(newNode);
this.tvConnections.SelectedNode = newNode;
this.tvConnections.SelectedNode.BeginEdit();
}
catch (Exception ex)
{
Runtime.MessageCollector.AddMessage(Messages.MessageClass.ErrorMsg,
string.Format(Language.strErrorAddFolderFailed, ex.Message),
true);
}
}
public Container.Info Add(Container.Info cInfo)
{
this.List.Add(cInfo);
return(cInfo);
}
private void AddNodeFromXml(XmlNode parentXmlNode, TreeNode parentTreeNode)
{
try
{
// Loop through the XML nodes until the leaf is reached.
// Add the nodes to the TreeView during the looping process.
if (parentXmlNode.HasChildNodes)
{
foreach (XmlNode xmlNode in parentXmlNode.ChildNodes)
{
TreeNode treeNode = new TreeNode((string)(xmlNode.Attributes["Name"].Value));
parentTreeNode.Nodes.Add(treeNode);
if (Tree.Node.GetNodeTypeFromString(xmlNode.Attributes["Type"].Value) ==
Tree.Node.Type.Connection) //connection info
{
Connection.Info connectionInfo = GetConnectionInfoFromXml(xmlNode);
connectionInfo.TreeNode = treeNode;
connectionInfo.Parent = _previousContainer; //NEW
ConnectionList.Add(connectionInfo);
treeNode.Tag = connectionInfo;
treeNode.ImageIndex = System.Convert.ToInt32(Images.Enums.TreeImage.ConnectionClosed);
treeNode.SelectedImageIndex =
System.Convert.ToInt32(Images.Enums.TreeImage.ConnectionClosed);
}
else if (Tree.Node.GetNodeTypeFromString((string)(xmlNode.Attributes["Type"].Value)) ==
Tree.Node.Type.Container) //container info
{
Container.Info containerInfo = new Container.Info();
if (treeNode.Parent != null)
{
if (Tree.Node.GetNodeType(treeNode.Parent) == Tree.Node.Type.Container)
{
containerInfo.Parent = treeNode.Parent.Tag;
}
}
_previousContainer = containerInfo; //NEW
containerInfo.TreeNode = treeNode;
containerInfo.Name = xmlNode.Attributes["Name"].Value;
if (confVersion >= 0.8)
{
if (xmlNode.Attributes["Expanded"].Value == "True")
{
containerInfo.IsExpanded = true;
}
else
{
containerInfo.IsExpanded = false;
}
}
Connection.Info connectionInfo;
if (confVersion >= 0.9)
{
connectionInfo = GetConnectionInfoFromXml(xmlNode);
}
else
{
connectionInfo = new Connection.Info();
}
connectionInfo.Parent = containerInfo;
connectionInfo.IsContainer = true;
containerInfo.ConnectionInfo = connectionInfo;
ContainerList.Add(containerInfo);
treeNode.Tag = containerInfo;
treeNode.ImageIndex = System.Convert.ToInt32(Images.Enums.TreeImage.Container);
treeNode.SelectedImageIndex =
System.Convert.ToInt32(Images.Enums.TreeImage.Container);
}
AddNodeFromXml(xmlNode, treeNode);
}
}
else
{
string nodeName = "";
XmlAttribute nameAttribute = parentXmlNode.Attributes["Name"];
if (nameAttribute != null)
{
nodeName = nameAttribute.Value.Trim();
}
if (!string.IsNullOrEmpty(nodeName))
{
parentTreeNode.Text = nodeName;
}
else
{
parentTreeNode.Text = parentXmlNode.Name;
}
}
}
catch (Exception ex)
{
Runtime.MessageCollector.AddMessage(Messages.MessageClass.ErrorMsg,
Language.strAddNodeFromXmlFailed + Constants.vbNewLine +
ex.Message + ex.StackTrace, true);
throw;
}
}
private void AddNodesFromSQL(TreeNode baseNode)
{
try
{
sqlCon.Open();
sqlQuery = new SqlCommand("SELECT * FROM tblCons ORDER BY PositionID ASC", sqlCon);
sqlRd = sqlQuery.ExecuteReader(CommandBehavior.CloseConnection);
if (sqlRd.HasRows == false)
{
return;
}
TreeNode tNode;
while (sqlRd.Read())
{
tNode = new TreeNode((string)(sqlRd["Name"]));
//baseNode.Nodes.Add(tNode)
if (Tree.Node.GetNodeTypeFromString((string)(sqlRd["Type"])) == Tree.Node.Type.Connection)
{
Connection.Info conI = GetConnectionInfoFromSQL();
conI.TreeNode = tNode;
//conI.Parent = _previousContainer 'NEW
this._ConnectionList.Add(conI);
tNode.Tag = conI;
if (SQLUpdate == true)
{
Connection.Info prevCon = PreviousConnectionList.FindByConstantID(conI.ConstantID);
if (prevCon != null)
{
foreach (mRemoteNC.Base prot in prevCon.OpenConnections)
{
prot.InterfaceControl.Info = conI;
conI.OpenConnections.Add(prot);
}
if (conI.OpenConnections.Count > 0)
{
tNode.ImageIndex = System.Convert.ToInt32(Images.Enums.TreeImage.ConnectionOpen);
tNode.SelectedImageIndex =
System.Convert.ToInt32(Images.Enums.TreeImage.ConnectionOpen);
}
else
{
tNode.ImageIndex =
System.Convert.ToInt32(Images.Enums.TreeImage.ConnectionClosed);
tNode.SelectedImageIndex =
System.Convert.ToInt32(Images.Enums.TreeImage.ConnectionClosed);
}
}
else
{
tNode.ImageIndex = System.Convert.ToInt32(Images.Enums.TreeImage.ConnectionClosed);
tNode.SelectedImageIndex =
System.Convert.ToInt32(Images.Enums.TreeImage.ConnectionClosed);
}
if (conI.ConstantID == _PreviousSelected)
{
selNode = tNode;
}
}
else
{
tNode.ImageIndex = System.Convert.ToInt32(Images.Enums.TreeImage.ConnectionClosed);
tNode.SelectedImageIndex =
System.Convert.ToInt32(Images.Enums.TreeImage.ConnectionClosed);
}
}
else if (Tree.Node.GetNodeTypeFromString((string)(sqlRd["Type"])) == Tree.Node.Type.Container)
{
Container.Info contI = new Container.Info();
//If tNode.Parent IsNot Nothing Then
// If Tree.Node.GetNodeType(tNode.Parent) = Tree.Node.Type.Container Then
// contI.Parent = tNode.Parent.Tag
// End If
//End If
//_previousContainer = contI 'NEW
contI.TreeNode = tNode;
contI.Name = (string)(sqlRd["Name"]);
Connection.Info conI;
conI = GetConnectionInfoFromSQL();
conI.Parent = contI;
conI.IsContainer = true;
contI.ConnectionInfo = conI;
if (SQLUpdate == true)
{
Container.Info prevCont = PreviousContainerList.FindByConstantID(conI.ConstantID);
if (prevCont != null)
{
contI.IsExpanded = prevCont.IsExpanded;
}
if (conI.ConstantID == _PreviousSelected)
{
selNode = tNode;
}
}
else
{
if (Convert.ToBoolean(sqlRd["Expanded"]) == true)
{
contI.IsExpanded = true;
}
else
{
contI.IsExpanded = false;
}
}
this._ContainerList.Add(contI);
this._ConnectionList.Add(conI);
tNode.Tag = contI;
tNode.ImageIndex = System.Convert.ToInt32(Images.Enums.TreeImage.Container);
tNode.SelectedImageIndex = System.Convert.ToInt32(Images.Enums.TreeImage.Container);
}
if (Convert.ToInt32(sqlRd["ParentID"]) != 0)
{
TreeNode pNode = Tree.Node.GetNodeFromConstantID((string)(sqlRd["ParentID"]));
if (pNode != null)
{
pNode.Nodes.Add(tNode);
if (Tree.Node.GetNodeType(tNode) == Tree.Node.Type.Connection)
{
(tNode.Tag as Connection.Info).Parent = pNode.Tag;
}
else if (Tree.Node.GetNodeType(tNode) == Tree.Node.Type.Container)
{
(tNode.Tag as Container.Info).Parent = pNode.Tag;
}
}
else
{
baseNode.Nodes.Add(tNode);
}
}
else
{
baseNode.Nodes.Add(tNode);
}
//AddNodesFromSQL(tNode)
}
}
catch (Exception ex)
{
Runtime.MessageCollector.AddMessage(Messages.MessageClass.ErrorMsg,
Language.strAddNodesFromSqlFailed + Constants.vbNewLine +
ex.Message, true);
}
}
