private void OnNodesChanged(object sender, NotifyCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Reset)
{
Children.Clear();
nodeToUmlClassControl.Clear();
umlClassControlToNode.Clear();
NodeNames.Clear();
return;
}
if (e.OldItems != null)
{
foreach (Node node in e.OldItems)
{
var umlClassControl = nodeToUmlClassControl[(UmlClass)node];
Children.Remove(umlClassControl);
nodeToUmlClassControl.Remove((UmlClass)node);
umlClassControlToNode.Remove(umlClassControl);
NodeNames.Remove(node.Name);
}
}
if (e.NewItems != null)
{
foreach (Node node in e.NewItems)
{
AddNode(node);
if (!NodeNames.Contains(node.Name))
{
NodeNames.Add(node.Name);
}
}
}
OnFilterTextChanged(null, FilterText);
}
private void RemoveAssociatedUnitTestNodes(XmlDocument xmlDoc, List <XmlNode> lstRemovedUnitTestResult)
{
var lstUnitTestResultIdentifier = lstRemovedUnitTestResult.Select(x => GetUnitTestResultNodeIdentifier(x)).ToList();
NodeNames nodeNameExecution = NodeNames.Execution;
string strNodeNameExecutionParent = nodeNameExecution.GetParentNodeName().ToString();
var nodes = xmlDoc.GetElementsByTagName(nodeNameExecution.ToString());
var parentNode = xmlDoc.GetElementsByTagName(NodeNames.UnitTest.GetParentNodeName().ToString())[0];
var lstNodes = new List <XmlNode>(Shim <XmlNode>(nodes));
foreach (XmlNode xmlNodeExecution in lstNodes)
{
if (xmlNodeExecution.ParentNode.Name == strNodeNameExecutionParent)
{
string strId = GetExecutionNodeIdentifier(xmlNodeExecution);
int index = lstUnitTestResultIdentifier.IndexOf(strId);
if (index >= 0)
{
lstUnitTestResultIdentifier.RemoveAt(index);
parentNode.RemoveChild(xmlNodeExecution.ParentNode);
}
}
}
}
public void CreateXmlOfTestCasesWithGivenOutcomes(string strResultFile,
string strXmlToContainTestCasesWithGivenOutcomes,
IEnumerable <string> outcomes)
{
StringBuilder sbTestCasesXml = new StringBuilder("<?xml version='1.0' encoding='utf-8' ?>");
sbTestCasesXml.AppendLine("<TestCases>");
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(strResultFile);
NodeNames nodeNameExecution = NodeNames.Execution;
var executionNodes = xmlDoc.GetElementsByTagName(nodeNameExecution.ToString());
string strNodeNameExecutionParent = nodeNameExecution.GetParentNodeName().ToString();
List <string> lstTestCases = new List <string>();
var unitTestResultNodes = Shim <XmlNode>(xmlDoc.GetElementsByTagName(NodeNames.UnitTestResult.ToString()));
Parallel.ForEach(unitTestResultNodes, (unitTestResultNode) =>
{
if (outcomes.Contains(GetTestCaseOutcome(unitTestResultNode).ToString().ToLower()))
{
string strUnitTestResultNodeId = GetUnitTestResultNodeIdentifier(unitTestResultNode);
foreach (XmlNode xmlNodeExecution in executionNodes)
{
if (xmlNodeExecution.ParentNode.Name == strNodeNameExecutionParent)
{
string strExecutionNodeId = GetExecutionNodeIdentifier(xmlNodeExecution);
if (strUnitTestResultNodeId == strExecutionNodeId)
{
var testMethodNode = Shim <XmlNode>(xmlNodeExecution.ParentNode.ChildNodes)
.Where(x => x.Name == NodeNames.TestMethod.ToString()).First();
lock (lstTestCases)
{
lstTestCases.Add(testMethodNode.GetAttributeValue(TestMethodAttributes.className.ToString()).Split(',').First() + "." +
testMethodNode.GetAttributeValue(TestMethodAttributes.name.ToString()));
}
break;
}
}
}
}
});
foreach (string strTestCase in lstTestCases)
{
sbTestCasesXml.AppendLine(string.Format("<TestCase Name='{0}'></TestCase>", strTestCase));
}
sbTestCasesXml.AppendLine("</TestCases>");
XmlDocument xmlDocToContainTestCasesWithGivenOutcomes = new XmlDocument();
xmlDocToContainTestCasesWithGivenOutcomes.LoadXml(sbTestCasesXml.ToString());
xmlDocToContainTestCasesWithGivenOutcomes.Save(strXmlToContainTestCasesWithGivenOutcomes);
}
public void Set(NodeNames nNodeName, string sValue)
{
switch (nNodeName)
{
case NodeNames.MarketplaceId:
id = Convert.ToInt32(sValue);
break;
case NodeNames.Name:
name = sValue;
break;
case NodeNames.Url:
url = sValue;
break;
case NodeNames.Login:
login = sValue;
break;
case NodeNames.Password:
password = sValue;
break;
case NodeNames.DisplayName:
displayName = sValue;
break;
case NodeNames.LimitDays:
limitDays = Convert.ToInt32(sValue);
break;
case NodeNames.AuxLogin:
auxLogin = sValue;
break;
case NodeNames.AuxPassword:
auxPassword = sValue;
break;
case NodeNames.RealmId:
realmId = Convert.ToInt32(sValue);
break;
case NodeNames.AccountTypeName:
accountTypeName = sValue;
break;
default:
throw new ArgumentOutOfRangeException("nNodeName");
} // switch
} // Set
private List <XmlNode> RemoveDuplicateNodes(XmlDocument xmlDoc,
NodeNames nodeName,
string strAttributeToBeCheckedToMarkAsDuplicate,
Func <IEnumerable <XmlNode>, IEnumerable <XmlNode> >
processorBeforeRemoving = null)
{
var nodes = Shim <XmlNode>(xmlDoc.GetElementsByTagName(nodeName.ToString()))
.Where(x => x.ParentNode.Name == nodeName.GetParentNodeName().ToString());
var parentNode = xmlDoc.GetElementsByTagName(nodeName.GetParentNodeName().ToString())[0];
Dictionary <string, List <XmlNode> > dicNodesByAttributeValue = new Dictionary <string, List <XmlNode> >();
foreach (XmlNode xmlNode in nodes)
{
string strAttributeValue = xmlNode.GetAttributeValue(strAttributeToBeCheckedToMarkAsDuplicate);
if (!dicNodesByAttributeValue.ContainsKey(strAttributeValue))
{
dicNodesByAttributeValue.Add(strAttributeValue, new List <XmlNode>());
}
dicNodesByAttributeValue[strAttributeValue].Add(xmlNode);
}
List <XmlNode> lstRemovedNodes = new List <XmlNode>();
foreach (var keyValPair in dicNodesByAttributeValue)
{
IEnumerable <XmlNode> nodesToBeRemoved = keyValPair.Value;
if (processorBeforeRemoving != null)
{
nodesToBeRemoved = processorBeforeRemoving(nodesToBeRemoved).ToList();
}
for (int i = 1; i < nodesToBeRemoved.Count(); i++)
{
lstRemovedNodes.Add(nodesToBeRemoved.ElementAt(i));
parentNode.RemoveChild(nodesToBeRemoved.ElementAt(i));
}
}
return(lstRemovedNodes);
}
public static NodeNames GetParentNodeName(this NodeNames nodeName)
{
switch (nodeName)
{
case NodeNames.UnitTest:
return(NodeNames.TestDefinitions);
case NodeNames.UnitTestResult:
return(NodeNames.Results);
case NodeNames.TestEntry:
return(NodeNames.TestEntries);
case NodeNames.Execution:
return(NodeNames.UnitTest);
}
throw new InvalidOperationException(string.Format("Parent node of {0} is not specified", nodeName.ToString()));
}
private void RemoveAssociatedTestEntryNodes(XmlDocument xmlDoc, List <XmlNode> lstRemovedUnitTestResult)
{
var lstUnitTestResultIdentifier = lstRemovedUnitTestResult.Select(x => GetUnitTestResultNodeIdentifier(x)).ToList();
NodeNames nodeNameTestEntry = NodeNames.TestEntry;
var nodes = xmlDoc.GetElementsByTagName(nodeNameTestEntry.ToString());
var parentNode = xmlDoc.GetElementsByTagName(NodeNames.TestEntry.GetParentNodeName().ToString())[0];
var lstNodes = new List <XmlNode>(Shim <XmlNode>(nodes));
foreach (XmlNode xmlNodeTestEntry in lstNodes)
{
string strId = GetTestEntryNodeIdentifier(xmlNodeTestEntry);
int index = lstUnitTestResultIdentifier.IndexOf(strId);
if (index >= 0)
{
lstUnitTestResultIdentifier.RemoveAt(index);
parentNode.RemoveChild(xmlNodeTestEntry);
}
}
}
/// <summary>
/// Attempts to remove all traces of a particular custom node from Dynamo, assuming the node is not in a loaded workspace.
/// </summary>
/// <param name="guid"></param>
public void Remove(Guid guid)
{
if (loadedNodes.ContainsKey(guid))
{
loadedNodes.Remove(guid);
}
if (nodePaths.ContainsKey(guid))
{
nodePaths.Remove(guid);
}
if (NodeCategories.ContainsKey(guid))
{
NodeCategories.Remove(guid);
}
var nodeName = NodeNames.Where((x) => x.Value == guid).ToList();
nodeName.ForEach((pair) =>
{
NodeNames.Remove(pair.Key);
dynSettings.Controller.SearchViewModel.Remove(pair.Key);
});
dynSettings.Controller.SearchViewModel.SearchAndUpdateResults();
dynSettings.Controller.FSchemeEnvironment.RemoveSymbol(guid.ToString());
}
/// <summary>
/// Tells whether the custom node's name is inside of the manager (initialized or not)
/// </summary>
/// <param name="name">The name of the custom node.</param>
public bool Contains(string name)
{
return(IsInitialized(name) || NodeNames.ContainsKey(name));
}
private void ConsolidateNodes(XmlDocument xmlDocConsolidatedReport, XmlDocument xmlDocReportToBeMerged, NodeNames nodeName)
{
string strNodeName = nodeName.ToString();
string strParentNodeName = nodeName.GetParentNodeName().ToString();
var nodesOfReportToBeMerged = Shim <XmlNode>(xmlDocReportToBeMerged.GetElementsByTagName(strNodeName))
.Where(x => x.ParentNode.Name == strParentNodeName);
var parentNodeOfGivenNodeInConsolidatedReport = xmlDocConsolidatedReport.GetElementsByTagName(strParentNodeName)[0];
foreach (XmlNode xmlNode in nodesOfReportToBeMerged)
{
parentNodeOfGivenNodeInConsolidatedReport.AppendChild(xmlDocConsolidatedReport.ImportNode(xmlNode, true));
}
}
/// <summary>
/// Aktualisiert den Baumstring.
/// </summary>
/// <param name="pTree">Der Baumstring.</param>
public void UpdateTree(string pTree)
{
Debug.WriteLine(pTree);
lock (_updateTreeLock)
{
Reset(pTree); // Listen neu init. und Positionszeiger des Baumstrings auf 0(Anfang) setzen.
//+ --------------------------------
Hash = Next <string>(); // Hash auslesen
Index = Next <int>(); // Hauptknotenindex auslesen
//+ --------------------------------
// Füge X NULL-Werte in die Listen hinzu. 'X' steht hierbei für den Wert der 'Index'-Variable. In 90aeq und kleiner sind es 20 (gewesen).
// Die NULL-Werte sind nicht Sinnlos, sondern dienen für bestimmte Befehle.
// Hier eine Auflistung der Befehle in 90aeq:
// 0 = Byte auslesen
// 1 = Boolean auslesen
// 2 = Byte auslesen
// 3 = Short auslesen
// 4 = int auslesen
// 5 = long auslesen
// 6 = Float auslesen
// 7 = Double auslesen
// 8 = Char auslesen
// 9 = UTF-String auslesen
// 11 = Neue Liste
// 12 = Ende der Liste
// 13 = Verschlüsselter String?
// Alles über oder gleich dem Wert der 'Index'-Variable = Node
for (int i = 0; i < Index; i++)
{
NodeNames.Add(null);
NodeIndices.Add(null);
}
//+ --------------------------------
// Füge nun alle Knotennamen in die Liste hinzu.
while (!IsEmpty())
{
NodeNames.Add(Next <string>());
}
//+ --------------------------------
// Manche Knoten haben nicht wie andere Werte oder andere Knoten gespeichert sondern bestimmte Werte.
for (int i = Index; i < NodeNames.Count; i++)
{
if (!NodeValues.ContainsKey(NodeNames[i]))
{
NodeValues.Add(NodeNames[i], i);
}
}
//+ --------------------------------
// Fügt alle Indices eines Knotens in eine Liste hinzu.
// Key = Knotenname
// Value = Index
// Die Indices geben die Unterknoten des Knotens zurück.
#region " BEISPIEL "
// Baum: 1337;20;PROTOCOL_HASH;;5;;:
// KEY = PROTOCOL_HASH
// VALUE = List<int>() { 5 };
// 5 Gibt an das der Knoten ein Long zurückgibt. Siehe oben in der Befehlsliste.
#endregion
while (NodeIndices.Count < NodeNames.Count)
{
var indices = new List <int>();
while (!IsEmpty())
{
indices.Add(Next <int>());
}
NodeIndices.Add(indices);
}
//+ --------------------------------
// Springt zur Stelle an der ':' steht.
Next <object>(':');
//+ --------------------------------
for (int i = Index; i < NodeIndices.Count; i++)
{
List <int> indices = NodeIndices[i];
foreach (int t in indices)
{
if (t != 0)
{
continue;
}
var values = new Dictionary <string, int>();
for (int k = 0; !IsEmpty(); k++)
{
values.Add(Next <string>(), k);
}
NodeValues[NodeNames[i]] = values;
}
}
}
}
