static void AddElementToXml(XmlNode node, XmlElement newElement, string targetNodeForParent) { if (node.Name == targetNodeForParent) node.PrependChild(newElement); else { for( int i = 0; i < node.ChildNodes.Count; i++) AddElementToXml(node.ChildNodes[i], newElement, targetNodeForParent); } }
public bool EnableRewriter(string configPath) { try { XmlDocument xDoc = new XmlDocument(); xDoc.Load(configPath); if (xDoc != null) { System.Xml.XmlNode xRoot = xDoc.DocumentElement; System.Xml.XmlNode xNode = xRoot.SelectSingleNode("//system.webServer/modules"); if (xNode != null) { if (xNode.Attributes["runAllManagedModulesForAllRequests"] == null) { XmlAttribute xAttrib = xDoc.CreateAttribute("runAllManagedModulesForAllRequests"); xAttrib.Value = "true"; xNode.Attributes.Append(xAttrib); } bool isInstalled = false; foreach (XmlNode n in xNode.ChildNodes) { if (n.Attributes["name"].Value == "ForumsReWriter") { isInstalled = true; break; } } if (!isInstalled) { XmlElement xNewNode = xDoc.CreateElement("add"); XmlAttribute xAttrib = xDoc.CreateAttribute("name"); xAttrib.Value = "ForumsReWriter"; xNewNode.Attributes.Append(xAttrib); xAttrib = xDoc.CreateAttribute("type"); xAttrib.Value = "DotNetNuke.Modules.ActiveForums.ForumsReWriter, DotNetNuke.Modules.ActiveForums"; xNewNode.Attributes.Append(xAttrib); xAttrib = xDoc.CreateAttribute("preCondition"); xAttrib.Value = "managedHandler"; xNewNode.Attributes.Append(xAttrib); xNode.PrependChild(xNewNode); xDoc.Save(configPath); } } } return(true); } catch (Exception ex) { return(false); } }
/// <summary> /// Sorts the children of the parentNode that match the xpath selector /// </summary> /// <param name="parentNode"></param> /// <param name="childXPathSelector">An xpath expression used to select child nodes of the XmlElement</param> /// <param name="childSelector">An expression that returns true if the XElement passed in is a valid child node to be sorted</param> /// <param name="orderByValue">The value to order the results by</param> internal static void SortNodes( XmlNode parentNode, string childXPathSelector, Func<XElement, bool> childSelector, Func<XElement, object> orderByValue) { var xElement = parentNode.ToXElement(); var children = xElement.Elements().Where(x => childSelector(x)).ToArray(); //(DONT conver to method group, the build server doesn't like it) var data = children .OrderByDescending(orderByValue) //order by the sort order desc .Select(x => children.IndexOf(x)) //store the current item's index (DONT conver to method group, the build server doesn't like it) .ToList(); //get the minimum index that a content node exists in the parent var minElementIndex = xElement.Elements() .TakeWhile(x => childSelector(x) == false) .Count(); //if the minimum index is zero, then it is the very first node inside the parent, // if it is not, we need to store the child property node that exists just before the // first content node found so we can insert elements after it when we're sorting. var insertAfter = minElementIndex == 0 ? null : parentNode.ChildNodes[minElementIndex - 1]; var selectedChildren = parentNode.SelectNodes(childXPathSelector); if (selectedChildren == null) { throw new InvalidOperationException(string.Format("The childXPathSelector value did not return any results {0}", childXPathSelector)); } var childElements = selectedChildren.Cast<XmlElement>().ToArray(); //iterate over the ndoes starting with the node with the highest sort order. //then we insert this node at the begginning of the parent so that by the end //of the iteration the node with the least sort order will be at the top. foreach (var node in data.Select(index => childElements[index])) { if (insertAfter == null) { parentNode.PrependChild(node); } else { parentNode.InsertAfter(node, insertAfter); } } }
// ------------------------------------------------------------------------------------ // Name: SetXmlNodeChild // Goal: Set the attribute [strChildAttr] of the child named [strChildName] of // xml node [ndxThis] with value [strChildValue] // If this child does not exist, then create it as the FIRST child // History: // 12-05-2010 ERK Created // ------------------------------------------------------------------------------------ public XmlNode SetXmlNodeChild(XmlDocument pdxThisFile, ref XmlNode ndxThis, string strChildName, string strAttrSel, string strChildAttr, string strChildValue) { XmlNode ndxChild = null; // Child being looked for XmlAttribute atxChild = null; // The attribute we are looking for string[] arAttr = null; // Array of attribute name + value string strSelect = null; // The string to find the appropriate child int intI = 0; // Counter try { // Verify the input if ((ndxThis == null) || (string.IsNullOrEmpty(strChildName)) || (string.IsNullOrEmpty(strChildAttr))) { return null; } // Start making the selection string strSelect = "./" + strChildName; if (!string.IsNullOrEmpty(strAttrSel)) { // Extract the list of necessary attributes arAttr = strAttrSel.Split(';'); // Append left bracket strSelect += "["; // Visit all attributes for (intI = 0; intI <= arAttr.GetUpperBound(0); intI += 2) { // Should we add the logical "AND"? if (intI > 0) { strSelect += " and "; } // Add this attribute to the list strSelect += "@" + arAttr[intI] + "='" + arAttr[intI + 1] + "'"; } // Append right bracket strSelect += "]"; } // Try to get the appropriate child ndxChild = ndxThis.SelectSingleNode(strSelect); // Is there a child? if (ndxChild == null) { // Create a new child node ndxChild = pdxThisFile.CreateNode(XmlNodeType.Element, strChildName, null); // Should first other attributes be created? if (!string.IsNullOrEmpty(strAttrSel)) { // Create all necessary attributes for (intI = 0; intI <= arAttr.GetUpperBound(0); intI += 2) { // Add this attribute atxChild = pdxThisFile.CreateAttribute(arAttr[intI]); atxChild.Value = arAttr[intI + 1]; ndxChild.Attributes.Append(atxChild); } } // Create a new attribute atxChild = pdxThisFile.CreateAttribute(strChildAttr); // Add the attribute to the node ndxChild.Attributes.Append(atxChild); // Make this new node the FIRST child of [ndxThis] ndxThis.PrependChild(ndxChild); } // Find the attribute of the child atxChild = ndxChild.Attributes[strChildAttr]; if ((atxChild) == null) { // The attribute does not exist, so create it atxChild = pdxThisFile.CreateAttribute(strChildAttr); // Add the attribute to the node ndxChild.Attributes.Append(atxChild); } // Set the attribute of the child atxChild.Value = strChildValue; // Return the child return ndxChild; } catch (Exception ex) { // Show error errHandle.DoError("modEditor/SetXmlNodeChild", ex); // Return failure return null; } }
// ------------------------------------------------------------------------------------ // Name: eTreeInsertLevel // Goal: Insert a node: // eTree, eLeaf - between me and my parent // forest - between forest and remainder // History: // 03-01-2013 ERK Created // ------------------------------------------------------------------------------------ public bool eTreeInsertLevel(ref XmlNode ndxThis, ref XmlNode ndxNew) { XmlNode ndxChild = null; // Working node XmlNodeList ndxList = null; // List of children int intI = 0; // Counter try { // Validate something is selected if (ndxThis != null) { switch (ndxThis.Name) { case "eLeaf": case "eTree": // (1) Create a new <eTree> element ndxNew = CreateNewEtree(ref pdxCurrentFile); // (2) Replace the parent's child with the new one ndxThis.ParentNode.ReplaceChild(ndxNew, ndxThis); // (3) Set its (only) child ndxNew.PrependChild(ndxThis); // (5) Get the appropriate values for @from and @to ndxNew.Attributes["from"].Value = ndxThis.Attributes["from"].Value; ndxNew.Attributes["to"].Value = ndxThis.Attributes["to"].Value; // Return success return true; case "forest": // Insert a level between the <forest> node and the remainder // (1) Create a new <eTree> element ndxNew = CreateNewEtree(ref pdxCurrentFile); // (2) Prepare all the children of the forest parent ndxList = ndxThis.SelectNodes("./eTree"); // (3) Make sure the new node is the child of the forest ndxThis.PrependChild(ndxNew); for (intI = 0; intI < ndxList.Count; intI++) { ndxChild = ndxList[intI]; // Check this is not the new one if (ndxChild != ndxNew) { // Replace the parent of this item ndxNew.AppendChild(ndxChild); } } // Return success return true; } } // Return failure return false; } catch (Exception ex) { // Show error errHandle.DoError("modEditor/eTreeInsertLevel", ex); // Return failure return false; } }
// ------------------------------------------------------------------------------------ // Name: eTreeAdd // Goal: Add a node: // eTree - replace me as child by all my children // forest, eLeaf - not possible // strType can be: // right - Add a sibling to my right // left - Add a sibling to my left // child - Create/add a child <eTree> node // eLeaf - Create an <eLeaf> node under me (if there is none) // History: // 03-01-2013 ERK Created // ------------------------------------------------------------------------------------ public bool eTreeAdd(ref XmlNode ndxThis, ref XmlNode ndxNew, string strType) { XmlNode ndxWork = null; // Working node try { // Validate something is selected if (ndxThis != null) { switch (ndxThis.Name) { case "eLeaf": case "forest": // Impossible return false; case "eTree": // Check what is our task switch (strType) { case "right": case "Right": // Add a sibling <eTree> to my right // (1) Create a new <eTree> element ndxNew = CreateNewEtree(ref pdxCurrentFile); // (2) Get my parent ndxWork = ndxThis.ParentNode; if (ndxWork != null) { // Insert the new node as child after me ndxWork.InsertAfter(ndxNew, ndxThis); //' Adapt the <eTree>/@Id values from [ndxThis] onwards //AdaptEtreeId(ndxThis.Attributes("Id").Value) } // Adapt the sentence, but don't re-calculate "org" eTreeSentence(ref ndxNew, ref ndxNew, bDoOrg: false); // Return success return true; case "left": case "Left": // Add a sibling <eTree> to my left // (1) Create a new <eTree> element ndxNew = CreateNewEtree(ref pdxCurrentFile); // (2) Get my parent ndxWork = ndxThis.ParentNode; if (ndxWork != null) { // Insert the new node as child before me ndxWork.InsertBefore(ndxNew, ndxThis); //' Go to the first <eTree> child of [ndxWork] //ndxWork = ndxWork.SelectSingleNode("./child::eTree[1]") //If (ndxWork IsNot Nothing) Then // ' Adapt the <eTree>/@Id values from [ndxWork] onwards // AdaptEtreeId(ndxWork.Attributes("Id").Value) //End If } // Adapt the sentence, but don't re-calculate "org" eTreeSentence(ref ndxNew, ref ndxNew, bDoOrg: false); // Return success return true; case "child": case "Child": case "childlast": // Add a child <eTree> under me // (1) Create a new <eTree> element ndxNew = CreateNewEtree(ref pdxCurrentFile); // (2) Add the <eTree> child under me ndxThis.AppendChild(ndxNew); //' Adapt the <eTree>/@Id values from [ndxThis] onwards //AdaptEtreeId(ndxThis.Attributes("Id").Value) // Adapt the sentence, but don't re-calculate "org" eTreeSentence(ref ndxNew, ref ndxNew, bDoOrg: false); // Return success return true; case "firstchild": case "childfirst": // Add a child <eTree> under me as the first one // (1) Create a new <eTree> element ndxNew = CreateNewEtree(ref pdxCurrentFile); // (2) Add the <eTree> child under me ndxThis.PrependChild(ndxNew); //' Adapt the <eTree>/@Id values from [ndxThis] onwards //AdaptEtreeId(ndxThis.Attributes("Id").Value) // Adapt the sentence, but don't re-calculate "org" eTreeSentence(ref ndxNew, ref ndxNew, bDoOrg: false); // Return success return true; case "eLeaf": case "eleaf": case "leaf": case "endnode": // (1) Check: do I have any <eLeaf> or <eTree> children? if ((ndxThis.SelectSingleNode("./child::eLeaf") == null) && (ndxThis.SelectSingleNode("./child::eTree") == null)) { // (1) Create a new <eLeaf> element ndxNew = CreateNewEleaf(ref pdxCurrentFile); // (2) Add it under me ndxThis.AppendChild(ndxNew); // Re-do the sentence, including "org" eTreeSentence(ref ndxThis, ref ndxNew); // Return success return true; } break; default: return false; } break; } } // Return failure return false; } catch (Exception ex) { // Show error errHandle.DoError("modEditor/eTreeAdd", ex); // Return failure return false; } }
/// <summary> /// WriteRaw writes out the given string "unescaped", in other words it better be well formed XML markup. /// So for the XmlNodeWriter we parse this string and build the resulting tree, so it maps to setting the /// InnerXml property. /// </summary> /// <param name="data"></param> public override void WriteRaw(string data) { if (data.IndexOf("<") < 0) { WriteString(data); return; } switch (state) { case WriteState.Start: goto case WriteState.Content; case WriteState.Prolog: goto case WriteState.Content; case WriteState.Element: state = WriteState.Content; goto case WriteState.Content; case WriteState.Attribute: { ArrayList saved = new ArrayList(); if (ca.HasChildNodes) { while (ca.FirstChild != null) { saved.Add(ca.FirstChild); ca.RemoveChild(ca.FirstChild); } } ca.InnerXml = data; for (int i = saved.Count - 1; i >= 0; i--) { ca.PrependChild((XmlNode)saved[i]); } } break; case WriteState.Content: { ArrayList saved = new ArrayList(); if (current.HasChildNodes) { while (current.FirstChild != null) { saved.Add(current.FirstChild); current.RemoveChild(current.FirstChild); } } current.InnerXml = data; for (int i = saved.Count - 1; i >= 0; i--) { current.PrependChild((XmlNode)saved[i]); } state = WriteState.Content; } break; case WriteState.Closed: throw new InvalidOperationException("Writer is closed"); } }
public static XmlNode PrependChild(XmlNode parent, XmlNode newChild) { Assert.NotNull(parent); Assert.NotNull(newChild); return parent.PrependChild(newChild); }
private static void SetField( XmlNode parentNode, ref XmlNode previousSibling, string tagName, string tagValue, string nspace) { // obtain a pointer to the XmlDocument object. This is used // in a few places in this method. XmlDocument doc = parentNode.OwnerDocument; // create an XmlText object to hold the field's value. XmlText text = doc.CreateTextNode(tagValue); // look for the field. XmlNode node = GetNode(doc, tagName, nspace); // if the field does not exist,... if (node == null) { // create an element for it and inside this element, // insert the XmlText object we created earlier. node = doc.CreateElement(tagName, nspace); node.AppendChild(text); // if there is a previous sibling, insert the new node // after it. if (previousSibling != null) { parentNode.InsertAfter(node, previousSibling); } // else, the new node becomes the first child. else { parentNode.PrependChild(node); } } // else, if the field already exists, replace its value. else { // if the field does have a value, replace it with // the XmlText object we created earlier. if (node.HasChildNodes) { node.ReplaceChild(text, node.ChildNodes[0]); } // else, if it's empty, append the XmlText object // we created earlier. else { node.AppendChild(text); } } // the next node to be added will be after this node. So, we // set previousSibling to this node. previousSibling = node; }
public static XmlElement PrependElementIfMissing(string tagName, string name, Dictionary<string, string> otherAttributes, XmlNode parent) { XmlElement e = null; if (!string.IsNullOrEmpty(name)) { e = FindElementWithTagAndName(tagName, name, parent); } if (e == null) { e = _document.CreateElement(tagName); if (!string.IsNullOrEmpty(name)) { e.SetAttribute("name", _namespace, name); } parent.PrependChild(e); } if (otherAttributes != null) { foreach(string key in otherAttributes.Keys) { e.SetAttribute(key, _namespace, otherAttributes[key]); } } return e; }
/// <summary> /// Creates, updates and inserts a node. /// </summary> private void InsertNode(XmlNode anchor, IUpdateOperation updateOperation) { // create node according to type XmlNode newXmlNode; switch (GetNodeType()) { case XmlNodeType.Attribute: newXmlNode = XmlDocument.CreateAttribute(Name, Namespace ?? string.Empty); break; case XmlNodeType.Element: newXmlNode = XmlDocument.CreateElement(Name, Namespace ?? string.Empty); break; case XmlNodeType.CData: newXmlNode = XmlDocument.CreateCDataSection(string.Empty); break; case XmlNodeType.Comment: newXmlNode = XmlDocument.CreateComment(string.Empty); break; case XmlNodeType.SignificantWhitespace: newXmlNode = XmlDocument.CreateSignificantWhitespace(string.Empty); break; case XmlNodeType.Text: newXmlNode = XmlDocument.CreateTextNode(string.Empty); break; case XmlNodeType.Whitespace: newXmlNode = XmlDocument.CreateWhitespace(string.Empty); break; default: // should not happen throw new ArgumentOutOfRangeException(); } // update node with input updateOperation.Update(newXmlNode); // insert node relative to anchor if (newXmlNode is XmlAttribute) { var newXmlAttribute = (XmlAttribute) newXmlNode; switch (GetNodePosition()) { case XmlNodePosition.Append: case XmlNodePosition.After: if (anchor is XmlAttribute) { var xmlAttribute = (XmlAttribute) anchor; if (xmlAttribute.OwnerElement != null) xmlAttribute.OwnerElement.Attributes.InsertAfter(newXmlAttribute, xmlAttribute); } else if (anchor.Attributes != null) { anchor.Attributes.Append(newXmlAttribute); } break; case XmlNodePosition.Prepend: case XmlNodePosition.Before: if (anchor is XmlAttribute) { var xmlAttribute = (XmlAttribute) anchor; if (xmlAttribute.OwnerElement != null) xmlAttribute.OwnerElement.Attributes.InsertBefore(newXmlAttribute, xmlAttribute); } else if (anchor.Attributes != null) { anchor.Attributes.Prepend(newXmlAttribute); } break; default: // should not happen throw new ArgumentOutOfRangeException(); } } else { switch (GetNodePosition()) { case XmlNodePosition.Append: anchor.AppendChild(newXmlNode); break; case XmlNodePosition.Prepend: anchor.PrependChild(newXmlNode); break; case XmlNodePosition.After: if (anchor.ParentNode != null) anchor.ParentNode.InsertAfter(newXmlNode, anchor); break; case XmlNodePosition.Before: if (anchor.ParentNode != null) anchor.ParentNode.InsertBefore(newXmlNode, anchor); break; default: // should not happen throw new ArgumentOutOfRangeException(); } } }
public static void AddXmlChildElement(XmlNode parentNode, string strChildNodeName, string strChildOuterXml, bool bForce, bool bAppend) { try { if ((((strChildNodeName != "") && (strChildOuterXml != "")) && (parentNode != null)) && (bForce || (parentNode.SelectSingleNode(strChildNodeName) == null))) { XmlNode newChild = parentNode.SelectSingleNode(strChildNodeName); if (newChild == null) { newChild = parentNode.OwnerDocument.CreateElement(strChildNodeName); parentNode.AppendChild(newChild); } newChild.InnerXml = strChildOuterXml; XmlNode node2 = newChild.SelectSingleNode(strChildNodeName); parentNode.RemoveChild(newChild); if (node2 != null) { if (bAppend) { parentNode.AppendChild(node2); } else { parentNode.PrependChild(node2); } } } } catch { } }
public static bool SetNodeValue(XmlDocument doc, XmlNode node, string name, string text, bool createNew, bool append) { bool flag = true; try { if ((doc == null) || (node == null)) { return flag; } XmlNode newChild = node.SelectSingleNode(name); if (((newChild == null) && createNew) && (text != null)) { newChild = doc.CreateElement(name); if (append) { node.AppendChild(newChild); } else { node.PrependChild(newChild); } } if (newChild == null) { return flag; } if (text != null) { newChild.InnerText = text; return flag; } newChild.ParentNode.RemoveChild(newChild); } catch { flag = false; } return flag; }
public static XmlNode SetNodeValue(XmlNode node, string name, string text, bool createNew, bool append) { XmlNode newChild = null; try { if ((node == null) || (text == null)) { return newChild; } newChild = node.SelectSingleNode(name); if ((newChild == null) && createNew) { newChild = node.OwnerDocument.CreateElement(name); if (append) { node.AppendChild(newChild); } else { node.PrependChild(newChild); } } newChild.InnerText = text; } catch { } return newChild; }
private static void findOrPrependElement(string name, string androidName, string ns, string value, XmlNode parent, XmlDocument doc) { XmlElement e = FindElementForNameWithNamespace(name, androidName, ns, value, parent); if (e == null) { e = doc.CreateElement(name); e.SetAttribute(androidName, ns, value); parent.PrependChild(e); } }
private static void GenerateHeadTags(ITemplateParsingState templateParsingState, XmlNode headNode) { SortedDictionary<double, LinkedList<XmlNode>> headerNodes = templateParsingState.HeaderNodes; foreach (double loc in headerNodes.Keys) if (loc < 0) foreach (XmlNode xmlNode in headerNodes[loc]) headNode.PrependChild(xmlNode); else foreach (XmlNode xmlNode in headerNodes[loc]) headNode.InsertAfter(xmlNode, headNode.LastChild); // handle oc:title, if present // TODO: Use XPATH XmlNodeList ocTitleNodes = headNode.OwnerDocument.GetElementsByTagName("title", templateParsingState.TemplateHandlerLocator.TemplatingConstants.TemplateNamespace); if (ocTitleNodes.Count > 1) for (int ctr = 1; ctr < ocTitleNodes.Count; ctr++) { XmlNode ocTitleNode = ocTitleNodes[ctr]; ocTitleNode.ParentNode.RemoveChild(ocTitleNode); } if (ocTitleNodes.Count > 0) { XmlNode ocTitleNode = ocTitleNodes[0]; bool titleNodePresent = false; foreach (XmlNode titleNode in headNode.OwnerDocument.GetElementsByTagName("title", headNode.NamespaceURI)) if (titleNode.ParentNode == ocTitleNode.ParentNode) titleNodePresent = true; if (!titleNodePresent) { XmlNode titleNode = headNode.OwnerDocument.CreateElement("title", headNode.NamespaceURI); foreach (XmlNode subNode in ocTitleNode.ChildNodes) titleNode.AppendChild(subNode); foreach (XmlAttribute attribute in ocTitleNode.Attributes) titleNode.Attributes.Append(attribute); ocTitleNode.ParentNode.InsertAfter(titleNode, ocTitleNode); } ocTitleNode.ParentNode.RemoveChild(ocTitleNode); } }
internal override void Close(WriteState currentState) { if (currentState == WriteState.Error) { return; } try { switch (_type) { case DocumentXmlWriterType.InsertSiblingAfter: XmlNode?parent = _start.ParentNode; if (parent == null) { throw new InvalidOperationException(SR.Xpn_MissingParent); } for (int i = _fragment.Count - 1; i >= 0; i--) { parent.InsertAfter(_fragment[i], _start); } break; case DocumentXmlWriterType.InsertSiblingBefore: parent = _start.ParentNode; if (parent == null) { throw new InvalidOperationException(SR.Xpn_MissingParent); } for (int i = 0; i < _fragment.Count; i++) { parent.InsertBefore(_fragment[i], _start); } break; case DocumentXmlWriterType.PrependChild: for (int i = _fragment.Count - 1; i >= 0; i--) { _start.PrependChild(_fragment[i]); } break; case DocumentXmlWriterType.AppendChild: for (int i = 0; i < _fragment.Count; i++) { _start.AppendChild(_fragment[i]); } break; case DocumentXmlWriterType.AppendAttribute: CloseWithAppendAttribute(); break; case DocumentXmlWriterType.ReplaceToFollowingSibling: if (_fragment.Count == 0) { throw new InvalidOperationException(SR.Xpn_NoContent); } CloseWithReplaceToFollowingSibling(); break; } } finally { _fragment.Clear(); } }
private void ExpandCodeSnippet(XmlDocument doc, XmlNode node) { XmlNode innerNode = doc.CreateNode("element", "pre", ""); innerNode.InnerText = node.InnerText; node.InnerText = ""; node.PrependChild(innerNode); }