public ManifestTreeNode GetTree(string xml)
{
var rootNode = new ManifestTreeNode();
var document = new XmlDocument();
document.Load(new StringReader(xml));
RecurseXmlDocument(document.DocumentElement, ref rootNode, null);
return(rootNode);
}
internal ManifestTreeNode GetTree(XmlSchemaSet set)
{
XmlSchema customerSchema = null;
foreach (XmlSchema schema in set.Schemas())
{
customerSchema = schema;
}
var rootNode = new ManifestTreeNode();
foreach (XmlSchemaElement element in customerSchema.Elements.Values)
{
rootNode.NodePath = "/";
if (customerSchema.Namespaces.Count > 0)
{
rootNode.Namespace = GetXsdNamespace(customerSchema.TargetNamespace, customerSchema.Namespaces.ToArray());
}
RecursiveElementAnalyser(element, ref rootNode, rootNode.Namespace);
}
return(rootNode);
}
private void RecursiveElementAnalyser(XmlSchemaElement element, ref ManifestTreeNode node, ManifestXmlNamespace xmlNamespace)
{
string elementName = element.Name ?? element.RefName.ToString();
var children = new List <ManifestTreeNode>();
string nameSpacePrefix = xmlNamespace != null ? xmlNamespace.Prefix : string.Empty;
//string dataType = element.ElementSchemaType.TypeCode.ToString(); // we are not using this anymore.
node.Name = element.Name ?? element.RefName.ToString();
node.DisplayName = elementName;
//node.NodeDataType = dataType;
node.NodeType = XmlNodeTypeEnum.Element;
var nameSpaceXPath = !string.IsNullOrEmpty(element.Name) ? !string.IsNullOrEmpty(nameSpacePrefix) ? $"{nameSpacePrefix}:" : "" : "";
node.NodePath = node.NodePath + nameSpaceXPath + element.Name;
var complexType = element.ElementSchemaType as XmlSchemaComplexType;
if (complexType != null)
{
if (complexType.AttributeUses.Count > 0)
{
var enumerator = complexType.AttributeUses.GetEnumerator();
while (enumerator.MoveNext())
{
var attribute = (XmlSchemaAttribute)enumerator.Value;
string attrDataType = attribute.AttributeSchemaType.TypeCode.ToString();
var childNode = new ManifestTreeNode
{
Name = attribute.QualifiedName.Name,
DisplayName = attribute.QualifiedName.Name,
//NodeDataType = attrDataType,
NodeType = XmlNodeTypeEnum.Attribute,
NodePath = node.NodePath + "/@" + attribute.QualifiedName.Name
};
children.Add(childNode);
}
}
var sequence = complexType.ContentTypeParticle as XmlSchemaSequence;
if (sequence != null)
{
foreach (var childElement in sequence.Items)
{
var xmlSchemaElement = childElement as XmlSchemaElement;
if (xmlSchemaElement != null)
{
if (xmlSchemaElement.RefName == null)
{
RecursiveElementAnalyser(xmlSchemaElement, ref node, xmlNamespace);
}
else if (xmlSchemaElement.RefName != null)
{
string seqDataType = sequence.GetType().ToString();
nameSpaceXPath = !string.IsNullOrEmpty(nameSpacePrefix) ? $"{nameSpacePrefix}:" : "";
var childNode = new ManifestTreeNode
{
Name = xmlSchemaElement.RefName.Name,
DisplayName = xmlSchemaElement.RefName.Name,
//NodeDataType = seqDataType,
NodeType = XmlNodeTypeEnum.Element,
NodePath = !string.IsNullOrEmpty(xmlSchemaElement.RefName.Name) ? $"{node.NodePath}/{nameSpaceXPath}{xmlSchemaElement.RefName}" : $"{node.NodePath}/{xmlSchemaElement.RefName}"
};
RecursiveElementAnalyser(xmlSchemaElement, ref childNode, xmlNamespace);
children.Add(childNode);
}
else
{
var choice = childElement as XmlSchemaChoice;
if (choice != null)
{
foreach (var choiceElement in choice.Items)
{
var xmlChoiceSchemaElement = choiceElement as XmlSchemaElement;
if (xmlChoiceSchemaElement != null)
{
RecursiveElementAnalyser(xmlChoiceSchemaElement, ref node, xmlNamespace);
}
}
}
}
}
}
}
}
node.Children = children;
}
private static XmlNode RecurseXmlDocument(XmlNode nodeofxml, ref ManifestTreeNode node, XmlNode previousnode)
{
node.Name = nodeofxml.LocalName;
node.DisplayName = nodeofxml.LocalName;
node.NodeType = XmlNodeTypeEnum.Element;
if (nodeofxml.ParentNode.ParentNode == null) // I ensure that we take the rootNode of xml
{
if (!string.IsNullOrEmpty(nodeofxml.NamespaceURI))
{
node.Namespace = GetXmlNamespace(nodeofxml);
}
}
var children = new List <ManifestTreeNode>();
int countSimilarChildren = 0, countskip = 0;
foreach (XmlNode similarchildren in nodeofxml.ParentNode.ChildNodes)
{
if (similarchildren.Name == nodeofxml.Name)
{
countSimilarChildren++;
}
}
var arrayXPath = countSimilarChildren > 1 ? "[*]" : string.Empty;
var nameSpaceXPath = String.IsNullOrEmpty(nodeofxml.GetPrefixOfNamespace(nodeofxml.NamespaceURI)) && !String.IsNullOrEmpty(nodeofxml.NamespaceURI) ? "ns:" : "";
node.NodePath = $"{node.NodePath}/{nameSpaceXPath}{nodeofxml.Name}{arrayXPath}";
for (int index = 0; index < nodeofxml.Attributes.Count; index++)
{
if (countskip == 0)
{
if (!nodeofxml.Attributes[index].Name.Contains("xmlns"))
{
var childNode = new ManifestTreeNode
{
Name = nodeofxml.Attributes[index].LocalName,
DisplayName = nodeofxml.Attributes[index].LocalName,
//NodeDataType = root.GetType().Name.ToString(),
NodeType = XmlNodeTypeEnum.Attribute,
NodePath = node.NodePath + "/@" + nodeofxml.Attributes[index].Name
};
children.Add(childNode);
}
}
}
if (nodeofxml is XmlElement)
{
XmlNodeList listofchildren = nodeofxml.ChildNodes;
foreach (XmlNode child in listofchildren)
{
if (child.Name != "#text")
{
countskip = previousnode != null && previousnode.Name == child.Name ? 1 : 0;
if (countskip == 0)
{
var childNode = new ManifestTreeNode
{
Name = child.LocalName,
DisplayName = child.LocalName,
//NodeDataType = child.GetType().Name.ToString(),
NodeType = XmlNodeTypeEnum.Element,
NodePath = node.NodePath
};
previousnode = RecurseXmlDocument(child, ref childNode, previousnode);
children.Add(childNode);
}
}
}
}
node.Children = children;
return(nodeofxml);
}
