public CreateNode ( System.Xml.XmlNodeType type, string name, string namespaceURI ) : |
||
type | System.Xml.XmlNodeType | |
name | string | |
namespaceURI | string | |
return |
private void SaveAsXML() { DataTable dt = (DataTable)bindingSource.DataSource; XmlDocument doc = new XmlDocument(); XmlNode rootNode = doc.CreateNode(XmlNodeType.Element,"root", null); foreach (DataRow row in dt.Rows) { object[] values = row.ItemArray; XmlNode prop = doc.CreateNode(XmlNodeType.Element, "propertyset", null); XmlNode name = doc.CreateNode(XmlNodeType.Element, "name", null); XmlNode value = doc.CreateNode(XmlNodeType.Element, "value", null); name.InnerText = (string)values[0]; value.InnerText = (string)values[1]; prop.AppendChild(name); prop.AppendChild(value); rootNode.AppendChild(prop); } doc.AppendChild(rootNode); string file = Path.Combine(GetExecutingDir(), xmlPropertyFileName); if (File.Exists(file)) { File.Delete(file); } doc.Save(file); doc.RemoveAll(); doc = null; }
/// <summary> /// Stores the numeric option as an XML Node (calls base implementation) /// </summary> /// <param name="doc">The XML document to which the node will be added</param> /// <returns>The XML node containing the information of numeric option</returns> internal new XmlNode saveXML(System.Xml.XmlDocument doc) { XmlNode node = base.saveXML(doc); //Min_Value XmlNode minNode = doc.CreateNode(XmlNodeType.Element, "minValue", ""); minNode.InnerText = this.min_value.ToString(); node.AppendChild(minNode); //Max_Value XmlNode maxNode = doc.CreateNode(XmlNodeType.Element, "maxValue", ""); maxNode.InnerText = this.max_value.ToString(); node.AppendChild(maxNode); if (this.stepFunction != null) { //StepFunction XmlNode stepNode = doc.CreateNode(XmlNodeType.Element, "stepFunction", ""); stepNode.InnerText = this.stepFunction.ToString(); node.AppendChild(stepNode); } if (values != null) { //Values XmlNode valuesNode = doc.CreateNode(XmlNodeType.Element, "values", ""); valuesNode.InnerText = values.ToString(); node.AppendChild(valuesNode); } return(node); }
public XmlElement ToXml(XmlDocument document) { if (string.IsNullOrEmpty(program)) throw new InvalidOperationException("There must be a program node."); XmlElement alertNode = document.CreateElement("idmef:OverflowAlert", "http://iana.org/idmef"); XmlElement subNode = document.CreateElement("idmef:program", "http://iana.org/idmef"); XmlNode subNodeText = document .CreateNode(XmlNodeType.Text, "idmef", "program", "http://iana.org/idmef"); subNodeText.Value = program; subNode.AppendChild(subNodeText); alertNode.AppendChild(subNode); if (size != null) { subNode = document.CreateElement("idmef:size", "http://iana.org/idmef"); subNodeText = document.CreateNode(XmlNodeType.Text, "idmef", "size", "http://iana.org/idmef"); subNodeText.Value = size.ToString(); subNode.AppendChild(subNodeText); alertNode.AppendChild(subNode); } if ((buffer != null) && (buffer.Length > 0)) { subNode = document.CreateElement("idmef:buffer", "http://iana.org/idmef"); subNodeText = document.CreateNode(XmlNodeType.Text, "idmef", "buffer", "http://iana.org/idmef"); subNodeText.Value = Convert.ToBase64String(buffer); subNode.AppendChild(subNodeText); alertNode.AppendChild(subNode); } return alertNode; }
public XmlElement ToXml(XmlDocument document) { XmlElement addressNode = document.CreateElement("idmef:Address", "http://iana.org/idmef"); addressNode.SetAttribute("ident", ident); addressNode.SetAttribute("category", EnumDescription.GetEnumDescription(category)); if (!string.IsNullOrEmpty(vlanName)) addressNode.SetAttribute("vlan-name", vlanName); if (vlanNum != null) addressNode.SetAttribute("vlan-num", vlanNum.ToString()); if (string.IsNullOrEmpty(address)) throw new InvalidOperationException("Address must have an address node."); XmlElement addressSubNode = document.CreateElement("idmef:address", "http://iana.org/idmef"); XmlNode subNode = document.CreateNode(XmlNodeType.Text, "idmef", "address", "http://iana.org/idmef"); subNode.Value = address; addressSubNode.AppendChild(subNode); addressNode.AppendChild(addressSubNode); if (!string.IsNullOrEmpty(netmask)) { addressSubNode = document.CreateElement("idmef:netmask", "http://iana.org/idmef"); subNode = document.CreateNode(XmlNodeType.Text, "idmef", "netmask", "http://iana.org/idmef"); subNode.Value = netmask; addressSubNode.AppendChild(subNode); addressNode.AppendChild(addressSubNode); } return addressNode; }
private XmlNode Yandex() { if (DateTime.Now >= _cTemplate.dtNext) { int nBuild; XmlNode cResult; XmlNode[] aItems; XmlDocument cXmlDocument = new XmlDocument(); cXmlDocument.LoadXml((new System.Net.WebClient() { Encoding = Encoding.UTF8 }).DownloadString("http://news.yandex.ru/index.rss")); nBuild = cXmlDocument.NodeGet("rss/channel/lastBuildDate").InnerText.GetHashCode(); if (_cTemplate.nBuild != nBuild) { aItems = cXmlDocument.NodesGet("rss/channel/item", false); if (null != aItems) { _cTemplate.nBuild = nBuild; cXmlDocument = new XmlDocument(); cResult = cXmlDocument.CreateNode(XmlNodeType.Element, "result", null); XmlNode cXNItem; foreach (string sItem in aItems.Select(o => o.NodeGet("title").InnerText).ToArray()) { cXNItem = cXmlDocument.CreateNode(XmlNodeType.Element, "item", null); cXNItem.InnerText = sItem.StripTags() + ". "; cResult.AppendChild(cXNItem); } _cTemplate.cValue = cResult; _cTemplate.dt = DateTime.Now; } else (new Logger()).WriteWarning("can't get any news from rss"); } } return _cTemplate.cValue; }
public XmlElement ToXml(XmlDocument document) { XmlElement addressNode = document.CreateElement("idmef:UserId", "http://iana.org/idmef"); addressNode.SetAttribute("ident", ident); addressNode.SetAttribute("type", EnumDescription.GetEnumDescription(type)); if (!string.IsNullOrEmpty(tty)) addressNode.SetAttribute("tty", tty); if (!string.IsNullOrEmpty(name)) { XmlElement addressSubNode = document.CreateElement("idmef:name", "http://iana.org/idmef"); XmlNode subNode = document.CreateNode(XmlNodeType.Text, "idmef", "name", "http://iana.org/idmef"); subNode.Value = name; addressSubNode.AppendChild(subNode); addressNode.AppendChild(addressSubNode); } if (number != null) { XmlElement addressSubNode = document.CreateElement("idmef:number", "http://iana.org/idmef"); XmlNode subNode = document.CreateNode(XmlNodeType.Text, "idmef", "number", "http://iana.org/idmef"); subNode.Value = number.ToString(); addressSubNode.AppendChild(subNode); addressNode.AppendChild(addressSubNode); } return addressNode; }
public string AddNewElement(string filePathName, string parent) { //Here we load the XML file into the memory XmlDocument xmlDocument = new XmlDocument(); xmlDocument.Load(filePathName); //Here we create employee node without any namespace XmlNode employeeNode = xmlDocument.CreateNode(XmlNodeType.Element, "employee", null); //Here we define an attribute and add it to the employee node XmlAttribute attribute = xmlDocument.CreateAttribute("id"); attribute.Value = "e8000"; employeeNode.Attributes.Append(attribute); //Here we create name node without any namespace XmlNode nameNode = xmlDocument.CreateNode(XmlNodeType.Element, "name", null); nameNode.InnerText = "Arash"; employeeNode.AppendChild(nameNode); //Here we create job node without any namespace XmlNode jobNode = xmlDocument.CreateNode(XmlNodeType.Element, "job", null); jobNode.InnerText = "Software developer"; employeeNode.AppendChild(jobNode); //Here we select the first element with the name specified by variable parent and //append the newly created child to it. xmlDocument.SelectSingleNode("//" + parent).AppendChild(employeeNode); //Here we save changes to the XML tree permanently. xmlDocument.Save(filePathName); //Here we retun some information about the file. return GetFileInfo(filePathName); }
/// <summary> /// Stores the binary options as an XML node (calling base implementation) /// </summary> /// <param name="doc">The XML document to which the node will be added</param> /// <returns>The XML node containing the options information</returns> internal XmlNode saveXML(System.Xml.XmlDocument doc) { XmlNode node = base.saveXML(doc); //Default value XmlNode defaultNode = doc.CreateNode(XmlNodeType.Element, "defaultValue", ""); if (this.DefaultValue == BinaryValue.Selected) { defaultNode.InnerText = "Selected"; } else { defaultNode.InnerText = "Deselected"; } node.AppendChild(defaultNode); //Optional XmlNode optionalNode = doc.CreateNode(XmlNodeType.Element, "optional", ""); if (this.Optional) { optionalNode.InnerText = "True"; } else { optionalNode.InnerText = "False"; } node.AppendChild(optionalNode); return(node); }
// // METHOD : BuildDetail // DESCRIPTION : Create bulk of error log, parameters fill in the specific details like error type, variable name, and explanation // PARAMETERS : string name - Variable name // string type - Error type // string explanation - Explanation of error // RETURNS : XmlNode node - XML containing constructed log. // public XmlNode BuildDetail(string name, string type, string explanation) { XmlDocument doc = new System.Xml.XmlDocument(); XmlNode node = doc.CreateNode(XmlNodeType.Element, SoapException.DetailElementName.Name, SoapException.DetailElementName.Namespace); XmlNode details; XmlAttribute nameAttr; XmlAttribute errorTypeAttr; XmlAttribute explanationAttr; details = doc.CreateNode(XmlNodeType.Element, "ParameterError", "http://localhost/LoanService"); nameAttr = doc.CreateAttribute("s", "name", "http://localhost/LoanService"); nameAttr.Value = name; errorTypeAttr = doc.CreateAttribute("s", "errorType", "http://localhost/LoanService"); errorTypeAttr.Value = type; explanationAttr = doc.CreateAttribute("s", "explanation", "http://localhost/LoanService"); explanationAttr.Value = explanation; details.Attributes.Append(nameAttr); details.Attributes.Append(errorTypeAttr); details.Attributes.Append(explanationAttr); node.AppendChild(details); return(node); }
public static XmlDocument CreateXMLDocument() { XmlDocument doc = new XmlDocument(); XmlNode docNode = doc.CreateXmlDeclaration("1.0", null, null); doc.AppendChild(docNode); XmlNode configurationNode = doc.CreateElement("Configuration"); doc.AppendChild(configurationNode); XmlNode hostNode = doc.CreateNode(XmlNodeType.Element, "host", ""); hostNode.InnerText = "https://testserver.datacash.com/Transaction"; XmlNode timeoutNode = doc.CreateNode(XmlNodeType.Element, "timeout", ""); timeoutNode.InnerText = "500"; XmlNode proxyNode = doc.CreateNode(XmlNodeType.Element, "proxy", ""); proxyNode.InnerText = "http://bloxx.dfguk.com:8080"; XmlNode logfileNode = doc.CreateNode(XmlNodeType.Element, "logfile", ""); logfileNode.InnerText = @"C:\Inetpub\wwwroot\WSDataCash\log.txt"; XmlNode loggingNode = doc.CreateNode(XmlNodeType.Element, "logging", ""); loggingNode.InnerText = "1"; configurationNode.AppendChild(hostNode); configurationNode.AppendChild(timeoutNode); configurationNode.AppendChild(proxyNode); configurationNode.AppendChild(logfileNode); configurationNode.AppendChild(loggingNode); return doc; }
protected override void LoadStaticConfiguration() { base.LoadStaticConfiguration(); Configuration config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); string filename = config.FilePath; database0 = database1 = "test"; XmlDocument configDoc = new XmlDocument(); configDoc.PreserveWhitespace = true; configDoc.Load(filename); XmlElement configNode = configDoc["configuration"]; configNode.RemoveAll(); XmlElement systemData = (XmlElement)configDoc.CreateNode(XmlNodeType.Element, "system.data", ""); XmlElement dbFactories = (XmlElement)configDoc.CreateNode(XmlNodeType.Element, "DbProviderFactories", ""); XmlElement provider = (XmlElement)configDoc.CreateNode(XmlNodeType.Element, "add", ""); provider.SetAttribute("name", "MySQL Data Provider"); provider.SetAttribute("description", ".Net Framework Data Provider for MySQL"); provider.SetAttribute("invariant", "MySql.Data.MySqlClient"); string fullname = String.Format("MySql.Data.MySqlClient.MySqlClientFactory, {0}", typeof(MySqlConnection).Assembly.FullName); provider.SetAttribute("type", fullname); dbFactories.AppendChild(provider); systemData.AppendChild(dbFactories); configNode.AppendChild(systemData); configDoc.Save(filename); ConfigurationManager.RefreshSection("system.data"); }
public XmlSecurityRatings() { _document = new XmlDocument(); /// _securityRatings = _document.CreateNode(XmlNodeType.Element, "SecurityRatings", XmlSecurityRatings._securityNs); _securityRatings = _document.CreateNode(XmlNodeType.Element, "SecurityRatings", null); _document.AppendChild(_securityRatings); _highSecurity = _document.CreateNode(XmlNodeType.Element, "High", null); _securityRatings.AppendChild(_highSecurity); appendAttribute(_highSecurity, @"title", @"HIGH RISK"); appendAttribute(_highSecurity, @"comment", @"This document contains high risk elements"); appendAttribute(_highSecurity, @"color", @"#B14343"); appendAttribute(_highSecurity, @"include-in-summary", @"yes"); appendAttribute(_highSecurity, @"hiddendata", @"This document contains high risk hidden data"); appendAttribute(_highSecurity, @"contentpolicy", @"This document contains high risk content policy violations"); _mediumSecurity = _document.CreateNode(XmlNodeType.Element, "Medium", null); _securityRatings.AppendChild(_mediumSecurity); appendAttribute(_mediumSecurity, @"title", @"MEDIUM RISK"); appendAttribute(_mediumSecurity, @"comment", @"This document contains medium risk elements"); appendAttribute(_mediumSecurity, @"color", @"#F0C060"); appendAttribute(_mediumSecurity, @"include-in-summary", @"yes"); appendAttribute(_mediumSecurity, @"hiddendata", @"This document contains medium risk hidden data"); appendAttribute(_mediumSecurity, @"contentpolicy", @"This document contains medium risk content policy violations"); _lowSecurity = _document.CreateNode(XmlNodeType.Element, "Low", null); _securityRatings.AppendChild(_lowSecurity); appendAttribute(_lowSecurity, @"title", @"LOW RISK"); appendAttribute(_lowSecurity, @"comment", @"This document contains normal elements"); appendAttribute(_lowSecurity, @"color", @"#4E7C49"); appendAttribute(_lowSecurity, @"include-in-summary", @"no"); appendAttribute(_lowSecurity, @"hiddendata", @"This document contains low risk hidden data"); appendAttribute(_lowSecurity, @"contentpolicy", @"This document contains low risk content policy violations"); }
public XmlElement ToXml(XmlDocument document) { XmlElement nodeNode = document.CreateElement("idmef:Node", "http://iana.org/idmef"); nodeNode.SetAttribute("ident", ident); nodeNode.SetAttribute("category", EnumDescription.GetEnumDescription(category)); if (!string.IsNullOrEmpty(location)) { XmlElement nodeSubNode = document.CreateElement("idmef:location", "http://iana.org/idmef"); XmlNode subNode = document.CreateNode(XmlNodeType.Text, "idmef", "location", "http://iana.org/idmef"); subNode.Value = location; nodeSubNode.AppendChild(subNode); nodeNode.AppendChild(nodeSubNode); } if (!string.IsNullOrEmpty(name)) { XmlElement nodeSubNode = document.CreateElement("idmef:name", "http://iana.org/idmef"); XmlNode subNode = document.CreateNode(XmlNodeType.Text, "idmef", "name", "http://iana.org/idmef"); subNode.Value = name; nodeSubNode.AppendChild(subNode); nodeNode.AppendChild(nodeSubNode); } if ((address != null) && (address.Length > 0)) foreach (var a in address) if (a != null) nodeNode.AppendChild(a.ToXml(document)); return nodeNode; }
internal static void Main() { StreamReader textReader = new StreamReader("../../Person.txt"); XmlDocument xmlDocument = new XmlDocument(); XmlNode persons = xmlDocument.CreateNode(XmlNodeType.Element, "persons", string.Empty); using (textReader) { while (!textReader.EndOfStream) { XmlNode person = xmlDocument.CreateNode(XmlNodeType.Element, "person", string.Empty); XmlNode personName = xmlDocument.CreateNode(XmlNodeType.Element, "name", string.Empty); XmlNode personAddres = xmlDocument.CreateNode(XmlNodeType.Element, "address", string.Empty); XmlNode personPhone = xmlDocument.CreateNode(XmlNodeType.Element, "phone", string.Empty); personName.InnerText = textReader.ReadLine(); personPhone.InnerText = textReader.ReadLine(); personAddres.InnerText = textReader.ReadLine(); person.AppendChild(personName); person.AppendChild(personAddres); person.AppendChild(personPhone); persons.AppendChild(person); } } xmlDocument.AppendChild(persons); xmlDocument.Save("../../saved.xml"); Console.WriteLine("See results in saved.xml"); }
public void LoadData() { lock (this) { doc = new XmlDocument(); if (File.Exists(fileName)) { XmlTextReader reader = new XmlTextReader(fileName); reader.WhitespaceHandling = WhitespaceHandling.None; doc.Load(reader); reader.Close(); } else { createdFile = true; rootNode = doc.CreateNode(XmlNodeType.Element, "Root", String.Empty); doc.AppendChild(rootNode); configNode = doc.CreateNode(XmlNodeType.Element, "Config", String.Empty); rootNode.AppendChild(configNode); } LoadDataToClass(); if (createdFile) { Commit(); } } }
public void AddAttachmentPlaceHolder(string actualPath, string placeholderPath) { var placeholderDocument = new XmlDocument(); placeholderDocument.CreateXmlDeclaration("1.0", "utf-16", "yes"); XmlNode rootNode = placeholderDocument.CreateNode(XmlNodeType.Element, "ManagedAttachment", string.Empty); XmlNode actualPathNode = placeholderDocument.CreateNode(XmlNodeType.Element, "ActualPath", string.Empty); XmlNode placeholderNode = placeholderDocument.CreateNode(XmlNodeType.Element, "PlaceholderPath", string.Empty); actualPathNode.InnerText = actualPath; placeholderNode.InnerText = placeholderPath; rootNode.AppendChild(actualPathNode); rootNode.AppendChild(placeholderNode); placeholderDocument.AppendChild(rootNode); using (var ms = new MemoryStream()) { ms.Position = 0; placeholderDocument.Save(ms); ms.Flush(); ms.Position = 0; var sr = new StreamReader(ms); string xml = sr.ReadToEnd(); string filecontents = LargeAttachmentHelper.FileTag + xml; File.WriteAllText(placeholderPath, filecontents, Encoding.Unicode); } }
/// <summary> /// Stores the numeric option as an XML Node (calls base implementation) /// </summary> /// <param name="doc">The XML document to which the node will be added</param> /// <returns>The XML node containing the information of numeric option</returns> internal XmlNode saveXML(System.Xml.XmlDocument doc) { XmlNode node = base.saveXML(doc); //Min_Value XmlNode minNode = doc.CreateNode(XmlNodeType.Element, "minValue", ""); minNode.InnerText = this.min_value.ToString(); node.AppendChild(minNode); //Max_Value XmlNode maxNode = doc.CreateNode(XmlNodeType.Element, "maxValue", ""); maxNode.InnerText = this.max_value.ToString(); node.AppendChild(maxNode); //StepFunction XmlNode stepNode = doc.CreateNode(XmlNodeType.Element, "stepFunction", ""); stepNode.InnerText = this.stepFunction.ToString(); node.AppendChild(stepNode); //DefaultValue XmlNode defNode = doc.CreateNode(XmlNodeType.Element, "defaultValue", ""); defNode.InnerText = this.defaultValue.ToString(); node.AppendChild(defNode); return(node); }
public string CreatingFile(XMLMovieProperties objMovie) { try { if (objMovie == null) return null; BlobStorageService _blobStorageService = new BlobStorageService(); XmlDocument documnet = new XmlDocument(); string fileName = "MovieList-" + objMovie.Month.Substring(0, 3) + "-" + objMovie.Year.ToString() + ".xml"; string existFileContent = _blobStorageService.GetUploadeXMLFileContent(BlobStorageService.Blob_XMLFileContainer, fileName); if (!string.IsNullOrEmpty(existFileContent)) { documnet.LoadXml(existFileContent); var oldMonth = documnet.SelectSingleNode("Movies/Month[@name='" + objMovie.Month + "']"); var oldMovie = oldMonth.SelectSingleNode("Movie[@name='" + objMovie.MovieName + "']"); if (oldMovie == null) oldMonth.AppendChild(AddMovieNode(documnet, objMovie)); else { oldMonth.RemoveChild(oldMovie); oldMonth.AppendChild(AddMovieNode(documnet, objMovie)); } } else { XmlNode root = documnet.CreateNode(XmlNodeType.Element, "Movies", ""); XmlAttribute movieYear = documnet.CreateAttribute("year"); movieYear.Value = objMovie.Year.ToString(); root.Attributes.Append(movieYear); XmlNode month = documnet.CreateNode(XmlNodeType.Element, "Month", ""); XmlAttribute monthName = documnet.CreateAttribute("name"); monthName.Value = objMovie.Month.ToString(); month.Attributes.Append(monthName); month.AppendChild(AddMovieNode(documnet, objMovie)); root.AppendChild(month); documnet.AppendChild(root); } _blobStorageService.UploadXMLFileOnBlob(BlobStorageService.Blob_XMLFileContainer, fileName, documnet.OuterXml); return documnet.OuterXml; //return fileName; } catch (Exception ex) { Console.Write(ex.Message); return ""; } }
public static void SetPluginSettingString(string strDiscCode, string strItem, string strValue) { if (!m_bLoaded) { return; } string strSel = "/Configuration/PluginSettings/" + strDiscCode + "/" + strItem + "/self::*"; System.Xml.XmlNodeList ndList = m_xmlDoc.SelectNodes(strSel); if (ndList.Count == 1) { ndList[0].InnerText = strValue; } else { XmlNode nodePlugin, nodeDiscipline, nodeItem; strSel = "/Configuration/PluginSettings/" + strDiscCode + "/self::*"; ndList = m_xmlDoc.SelectNodes(strSel); if (ndList.Count < 1) { strSel = "/Configuration/PluginSettings/self::*"; ndList = m_xmlDoc.SelectNodes(strSel); if (ndList.Count < 1) { strSel = "/Configuration/self::*"; ndList = m_xmlDoc.SelectNodes(strSel); if (ndList.Count < 1) { return; } nodePlugin = m_xmlDoc.CreateNode(XmlNodeType.Element, "PluginSettings", null); ndList[0].AppendChild(nodePlugin); } else { nodePlugin = ndList[0]; } nodeDiscipline = m_xmlDoc.CreateNode(XmlNodeType.Element, strDiscCode, null); nodePlugin.AppendChild(nodeDiscipline); } else { nodeDiscipline = ndList[0]; } nodeItem = m_xmlDoc.CreateNode(XmlNodeType.Element, strItem, null); nodeDiscipline.AppendChild(nodeItem); nodeItem.InnerText = strValue; } }
public void ProcessInputKeyFile(string inputPath, string outputPath, string pass,X509Certificate2 xcert,bool flag,string oneTimePassword ) { string strKey = string.Format("//{0}/{1}", CollectionIDTag, KeyTag); string strID = string.Format("//{0}/{1}", CollectionIDTag, iFolderIDTag); string decKey; byte[] decKeyByteArray; rsadec = xcert.PrivateKey as RSACryptoServiceProvider; try { string inKeyPath = Path.GetFullPath(inputPath); string outKeyPath = Path.GetFullPath(outputPath); XmlDocument encFile = new XmlDocument(); encFile.Load(inKeyPath); XmlNodeList keyNodeList, idNodeList; XmlElement root = encFile.DocumentElement; keyNodeList = root.SelectNodes(strKey); idNodeList = root.SelectNodes(strID); System.Xml.XmlDocument document = new XmlDocument(); XmlDeclaration xmlDeclaration = document.CreateXmlDeclaration("1.0", "utf-8", null); document.InsertBefore(xmlDeclaration, document.DocumentElement); XmlElement title = document.CreateElement(titleTag); document.AppendChild(title); int i = 0; foreach (XmlNode idNode in idNodeList) { if (idNode.InnerText == null || idNode.InnerText == String.Empty) continue; Console.WriteLine(idNode.InnerText); XmlNode newNode = document.CreateNode("element", CollectionIDTag, ""); newNode.InnerText = ""; document.DocumentElement.AppendChild(newNode); XmlNode innerNode = document.CreateNode("element", iFolderIDTag, ""); innerNode.InnerText = idNode.InnerText; newNode.AppendChild(innerNode); { XmlNode keyNode = keyNodeList[i++]; Console.WriteLine(decKey = keyNode.InnerText); decKeyByteArray = Convert.FromBase64String(decKey); XmlNode newElem2 = document.CreateNode("element", KeyTag, ""); if (decKey == null || decKey == String.Empty) continue; if (flag == true) newElem2.InnerText = DecodeMessage(decKeyByteArray, oneTimePassword); else newElem2.InnerText = DecodeMessage(decKeyByteArray); newNode.AppendChild(newElem2); } } if (File.Exists(outKeyPath)) File.Delete(outKeyPath); document.Save(outKeyPath); } catch (Exception e) { Console.WriteLine("Exception while processing" + e.Message + e.StackTrace); } }
public XmlNode BuildRuleItem(XmlDocument xmlDoc) { XmlNode nodeRuleItem = xmlDoc.CreateNode(XmlNodeType.Element, XMLNames._E_RuleItem, XMLNames._M_NameSpaceURI); Utility.XMLHelper.AddText(xmlDoc, nodeRuleItem, _keyValue); XmlNode nodeRuleItemDetails = xmlDoc.CreateNode(XmlNodeType.Element, XMLNames._E_RuleItemDetails, XMLNames._M_NameSpaceURI); nodeRuleItem.AppendChild(nodeRuleItemDetails); foreach (ExternalInterfaceSearchCriteriaDetail detail in _details) nodeRuleItemDetails.AppendChild(detail.BuildRuleItemDetail(xmlDoc)); return nodeRuleItem; }
public XmlElement ToXml(XmlDocument document) { XmlElement inodeNode = document.CreateElement("idmef:Inode", "http://iana.org/idmef"); if (changeTime != null) { XmlElement inodeSubNode = document.CreateElement("idmef:change-time", "http://iana.org/idmef"); XmlNode subNode = document.CreateNode(XmlNodeType.Text, "idmef", "change-time", "http://iana.org/idmef"); subNode.Value = ((DateTime)changeTime).ToString("o"); inodeSubNode.AppendChild(subNode); inodeNode.AppendChild(inodeSubNode); } if (number != null) { XmlElement inodeSubNode = document.CreateElement("idmef:number", "http://iana.org/idmef"); XmlNode subNode = document.CreateNode(XmlNodeType.Text, "idmef", "number", "http://iana.org/idmef"); subNode.Value = number.ToString(); inodeSubNode.AppendChild(subNode); inodeNode.AppendChild(inodeSubNode); } if (majorDevice != null) { XmlElement inodeSubNode = document.CreateElement("idmef:major-device", "http://iana.org/idmef"); XmlNode subNode = document.CreateNode(XmlNodeType.Text, "idmef", "major-device", "http://iana.org/idmef"); subNode.Value = majorDevice.ToString(); inodeSubNode.AppendChild(subNode); inodeNode.AppendChild(inodeSubNode); } if (minorDevice != null) { XmlElement inodeSubNode = document.CreateElement("idmef:minor-device", "http://iana.org/idmef"); XmlNode subNode = document.CreateNode(XmlNodeType.Text, "idmef", "minor-device", "http://iana.org/idmef"); subNode.Value = minorDevice.ToString(); inodeSubNode.AppendChild(subNode); inodeNode.AppendChild(inodeSubNode); } if (cMajorDevice != null) { XmlElement inodeSubNode = document.CreateElement("idmef:c-major-device", "http://iana.org/idmef"); XmlNode subNode = document.CreateNode(XmlNodeType.Text, "idmef", "c-major-device", "http://iana.org/idmef"); subNode.Value = cMajorDevice.ToString(); inodeSubNode.AppendChild(subNode); inodeNode.AppendChild(inodeSubNode); } if (cMinorDevice != null) { XmlElement inodeSubNode = document.CreateElement("idmef:c-minor-device", "http://iana.org/idmef"); XmlNode subNode = document.CreateNode(XmlNodeType.Text, "idmef", "c-minor-device", "http://iana.org/idmef"); subNode.Value = cMinorDevice.ToString(); inodeSubNode.AppendChild(subNode); inodeNode.AppendChild(inodeSubNode); } return inodeNode; }
public static SoapException RaiseException(string uri, string webServiceNamespace, string errorMessage, string errorNumber, string errorSource, FaultCode code) { XmlQualifiedName faultCodeLocation = null; //Identify the location of the FaultCode switch (code) { case FaultCode.Client: faultCodeLocation = SoapException.ClientFaultCode; break; case FaultCode.Server: faultCodeLocation = SoapException.ServerFaultCode; break; } XmlDocument xmlDoc = new XmlDocument(); //Create the Detail node XmlNode rootNode = xmlDoc.CreateNode(XmlNodeType.Element, SoapException.DetailElementName.Name, SoapException.DetailElementName.Namespace); //Build specific details for the SoapException //Add first child of detail XML element. XmlNode errorNode = xmlDoc.CreateNode(XmlNodeType.Element, "Error", webServiceNamespace); //Create and set the value for the ErrorNumber node XmlNode errorNumberNode = xmlDoc.CreateNode(XmlNodeType.Element, "ErrorNumber", webServiceNamespace); errorNumberNode.InnerText = errorNumber; //Create and set the value for the ErrorMessage node XmlNode errorMessageNode = xmlDoc.CreateNode(XmlNodeType.Element, "ErrorMessage", webServiceNamespace); errorMessageNode.InnerText = errorMessage; //Create and set the value for the ErrorSource node XmlNode errorSourceNode = xmlDoc.CreateNode(XmlNodeType.Element, "ErrorSource", webServiceNamespace); errorSourceNode.InnerText = errorSource; //Append the Error child element nodes to the root detail node. errorNode.AppendChild(errorNumberNode); errorNode.AppendChild(errorMessageNode); errorNode.AppendChild(errorSourceNode); //Append the Detail node to the root node rootNode.AppendChild(errorNode); //Construct the exception SoapException soapEx = new SoapException(errorMessage, faultCodeLocation, uri, rootNode); //Raise the exception back to the caller return soapEx; }
private static XmlNode CreateDValueNodeWithValue(double value) { var doc = new XmlDocument(); var node = doc.CreateNode(XmlNodeType.Element, AstConstants.Node, AstConstants.Nodes.Scalar_DNumber, ""); var valueNode = doc.CreateNode(XmlNodeType.Element, AstConstants.Subnode, AstConstants.Subnodes.Value, ""); var floatNode = doc.CreateNode(XmlNodeType.Element, AstConstants.Scalar, AstConstants.Scalars.Float, ""); floatNode.InnerText = value.ToString(CultureInfo.InvariantCulture); valueNode.AppendChild(floatNode); node.AppendChild(valueNode); return node; }
public string Estadisticas() { try { IlogicaViajes FLogica = FabricaLogica.GetLogicaViajes(); List <Viajes> lista = FLogica.ListarViajesTodos(); XmlDocument xmldoc = new XmlDocument(); xmldoc.LoadXml("<lista></lista>"); foreach (Viajes v in lista) { XmlNode nodoViaje = xmldoc.CreateNode(XmlNodeType.Element, "Viaje", ""); XmlNode nodoNumero = xmldoc.CreateNode(XmlNodeType.Element, "Número", ""); nodoNumero.InnerXml = v.numero.ToString(); nodoViaje.AppendChild(nodoNumero); XmlNode nodoCiudadDestino = xmldoc.CreateNode(XmlNodeType.Element, "CiudadDestino", ""); nodoCiudadDestino.InnerXml = v.t.ciudad; nodoViaje.AppendChild(nodoCiudadDestino); XmlNode nodoPaisDestino = xmldoc.CreateNode(XmlNodeType.Element, "PaisDestino", ""); nodoPaisDestino.InnerXml = v.t.pais; nodoViaje.AppendChild(nodoPaisDestino); XmlNode nodoCompania = xmldoc.CreateNode(XmlNodeType.Element, "Compania", ""); nodoCompania.InnerXml = v.c.nombre; nodoViaje.AppendChild(nodoCompania); XmlNode nodoFechaPartida = xmldoc.CreateNode(XmlNodeType.Element, "FechaPartida", ""); nodoFechaPartida.InnerXml = v.partida.ToString(); nodoViaje.AppendChild(nodoFechaPartida); xmldoc.DocumentElement.AppendChild(nodoViaje); } return(xmldoc.OuterXml); } catch (Exception ex) { XmlDocument unDoc = new System.Xml.XmlDocument(); XmlNode noddoError = unDoc.CreateNode(XmlNodeType.Element, SoapException.DetailElementName.Name, SoapException.DetailElementName.Namespace); XmlNode nodeDetalle = unDoc.CreateNode(XmlNodeType.Element, "Error", ""); nodeDetalle.InnerText = ex.Message; noddoError.AppendChild(nodeDetalle); SoapException miEx = new SoapException(ex.Message, SoapException.ClientFaultCode, Context.Request.Url.AbsolutePath, noddoError); throw miEx; } }
public string ViajesXML() { ILogicaViaje LViaje = FabricaLogica.GetLogicaViajes(); List <Viaje> ListarViajes = LViaje.Listar(); XmlDocument DocumentoXML = new XmlDocument(); XmlNode NodoV = DocumentoXML.CreateNode(XmlNodeType.Element, "Viaje", ""); try { foreach (Viaje V in ListarViajes) { XmlNode NodoViaje = DocumentoXML.CreateNode(XmlNodeType.Element, "Viaje", ""); XmlNode NodoNum = DocumentoXML.CreateNode(XmlNodeType.Element, "Numero", ""); NodoNum.InnerText = V._NumViaje.ToString(); NodoViaje.AppendChild(NodoNum); XmlNode NodoCiudad = DocumentoXML.CreateNode(XmlNodeType.Element, "CiudadDestino", ""); NodoCiudad.InnerText = V._Ter._Ciudad; NodoViaje.AppendChild(NodoCiudad); XmlNode NodoPais = DocumentoXML.CreateNode(XmlNodeType.Element, "PaisDestino", ""); NodoPais.InnerText = V._Ter._Pais; NodoViaje.AppendChild(NodoPais); XmlNode NodoCompañia = DocumentoXML.CreateNode(XmlNodeType.Element, "Compañia", ""); NodoCompañia.InnerText = V._Com._Nombre; NodoViaje.AppendChild(NodoCompañia); XmlNode NodoFecha = DocumentoXML.CreateNode(XmlNodeType.Element, "FechaPartida", ""); NodoFecha.InnerText = V._FechaPartida.ToString();; NodoViaje.AppendChild(NodoFecha); NodoV.AppendChild(NodoViaje); } } catch (Exception ex) { XmlDocument _undoc = new System.Xml.XmlDocument(); XmlNode _NodoError = _undoc.CreateNode(XmlNodeType.Element, SoapException.DetailElementName.Name, SoapException.DetailElementName.Namespace); XmlNode _NodoDetalle = _undoc.CreateNode(XmlNodeType.Element, "Error", ex.Message); _NodoDetalle.InnerText = ex.Message; _NodoError.AppendChild(_NodoDetalle); SoapException _MiEx = new SoapException("Error WS", SoapException.ClientFaultCode, Context.Request.Url.AbsoluteUri, _NodoError); throw _MiEx; } DocumentoXML.AppendChild(NodoV); return(DocumentoXML.OuterXml); }
public XmlElement ToXml(XmlDocument document) { XmlElement processNode = document.CreateElement("idmef:Process", "http://iana.org/idmef"); processNode.SetAttribute("ident", ident); if (string.IsNullOrEmpty(name)) throw new ArgumentException("Process must have a name node."); XmlElement processSubNode = document.CreateElement("idmef:name", "http://iana.org/idmef"); XmlNode subNode = document.CreateNode(XmlNodeType.Text, "idmef", "name", "http://iana.org/idmef"); subNode.Value = name; processSubNode.AppendChild(subNode); processNode.AppendChild(processSubNode); if (pid != null) { processSubNode = document.CreateElement("idmef:pid", "http://iana.org/idmef"); subNode = document.CreateNode(XmlNodeType.Text, "idmef", "pid", "http://iana.org/idmef"); subNode.Value = pid.ToString(); processSubNode.AppendChild(subNode); processNode.AppendChild(processSubNode); } if (!string.IsNullOrEmpty(path)) { processSubNode = document.CreateElement("idmef:path", "http://iana.org/idmef"); subNode = document.CreateNode(XmlNodeType.Text, "idmef", "path", "http://iana.org/idmef"); subNode.Value = path; processSubNode.AppendChild(subNode); processNode.AppendChild(processSubNode); } if ((arg != null) && (arg.Length > 0)) foreach (var a in arg) if (!string.IsNullOrEmpty(a)) { processSubNode = document.CreateElement("idmef:arg", "http://iana.org/idmef"); subNode = document.CreateNode(XmlNodeType.Text, "idmef", "arg", "http://iana.org/idmef"); subNode.Value = a; processSubNode.AppendChild(subNode); processNode.AppendChild(processSubNode); } if ((env != null) && (env.Length > 0)) foreach (var e in env) if (!string.IsNullOrEmpty(e)) { processSubNode = document.CreateElement("idmef:env", "http://iana.org/idmef"); subNode = document.CreateNode(XmlNodeType.Text, "idmef", "env", "http://iana.org/idmef"); subNode.Value = e; processSubNode.AppendChild(subNode); processNode.AppendChild(processSubNode); } return processNode; }
private void Init(string rootName) { try { doc = new XmlDocument(); var dec = doc.CreateNode(XmlNodeType.XmlDeclaration, "", ""); doc.InsertAfter(dec, null); root = doc.CreateNode(XmlNodeType.Element, rootName, ""); doc.InsertAfter(root, dec); } catch { } }
public static void SetValue(string AppKey, string AppValue, bool tt) { XmlDocument document = new XmlDocument(); XmlNode node = document.CreateNode(XmlNodeType.Element, "configuration", ""); document.AppendChild(node); XmlNode node2 = document.CreateNode(XmlNodeType.Element, "appSettings", ""); node.AppendChild(node2); XmlElement newChild = document.CreateElement("add"); newChild.SetAttribute("key", AppKey); newChild.SetAttribute("value", AppValue); node2.AppendChild(newChild); document.Save(System.AppDomain.CurrentDomain.BaseDirectory + "LrcSet.xml"); }
public static XmlDocument GetErrorDocument(string errormessage) { XmlDocument errorDoc = new XmlDocument(); errorDoc.AppendChild(errorDoc.CreateProcessingInstruction("xml-stylesheet", "type='text/xsl' href='xsl/errorPage.xsl'")); XmlNode root = errorDoc.AppendChild(errorDoc.CreateNode(XmlNodeType.Element, "root", null)); XmlNode node = root.AppendChild(errorDoc.CreateNode(XmlNodeType.Element, "message", null)); node.InnerText = errormessage; Timingutil.info("Compile Error ! , generate ErrorDom"); return errorDoc; }
public XmlNode AddSubEntity(TreeNode treeNode, XmlDocument document) { Entity entity = EntityDictionary[treeNode.Text]; XmlNode xmlNode = document.CreateNode(XmlNodeType.Element, "Item", null); XmlAttribute attribute = document.CreateAttribute("Name"); attribute.Value = entity.Name; xmlNode.Attributes.Append(attribute); if (entity.Parameters.Count > 0) { XmlNode parameterContainerNode = document.CreateNode(XmlNodeType.Element, "Parameters", null); foreach (Entity.Parameter parameter in entity.Parameters) { //Create Node for the parameter XmlNode parameterNode = document.CreateNode(XmlNodeType.Element, "Parameter", null); //Create an attribute containing the type XmlAttribute parameterType = document.CreateAttribute("Type"); parameterType.Value = parameter.Type.ToString(); //Set the inner text to the name of the parameter parameterNode.InnerText = parameter.Name; //add the attribute to the node parameterNode.Attributes.Append(parameterType); //add the parameter node to the parameterContainer parameterContainerNode.AppendChild(parameterNode); } xmlNode.AppendChild(parameterContainerNode); } if (treeNode.Nodes.Count > 0) { XmlNode subEntities = document.CreateNode(XmlNodeType.Element, "SubEntities", null); foreach (TreeNode subTreeNode in treeNode.Nodes) { subEntities.AppendChild(AddSubEntity(subTreeNode, document)); } xmlNode.AppendChild(subEntities); } return xmlNode; }
private void GeneroSoapException(Exception ex) { XmlDocument _undoc = new System.Xml.XmlDocument(); XmlNode _NodoError = _undoc.CreateNode(XmlNodeType.Element, SoapException.DetailElementName.Name, SoapException.DetailElementName.Namespace); XmlNode _NodoDetalle = _undoc.CreateNode(XmlNodeType.Element, "Error", ""); _NodoDetalle.InnerText = ex.Message; _NodoError.AppendChild(_NodoDetalle); SoapException _MiEx = new SoapException("Error WS", SoapException.ClientFaultCode, Context.Request.Url.AbsoluteUri, _NodoError); throw _MiEx; }
public RolesDataSource(string rolesFile, string application) { this._rolesFile = rolesFile; this.ApplicationName = application; this._agent = new FileAgent(); if (!this._agent.HasKey(rolesFile)) { XmlDocument doc = new XmlDocument(); doc.AppendChild(doc.CreateNode(XmlNodeType.XmlDeclaration, "", "")); doc.AppendChild(doc.CreateNode(XmlNodeType.Element, "roles", "")); this._agent.Write(this._rolesFile, string.Empty); this.SaveRolesFile(doc); } }
//save into package public void SaveToXML(System.Xml.XmlDocument doc, IDTSInfoEvents infoEvents) { XmlElement elementRoot; XmlNode propertyNode; elementRoot = doc.CreateElement(string.Empty, "DtParameters", string.Empty); if (DtParameters != null) { if (DtParameters.Rows.Count > 0) { // foreach (DataRow row in DtParameters.Rows) { propertyNode = doc.CreateNode(XmlNodeType.Element, "Parameter", string.Empty); propertyNode.InnerText = row["ParameterValue"].ToString(); XmlAttribute attrParameterName = doc.CreateAttribute("ParameterName"); attrParameterName.Value = row["ParameterName"].ToString(); propertyNode.Attributes.Append(attrParameterName); XmlAttribute attrRequired = doc.CreateAttribute("Required"); attrRequired.Value = row["Required"].ToString(); propertyNode.Attributes.Append(attrRequired); elementRoot.AppendChild(propertyNode); } } } propertyNode = doc.CreateNode(XmlNodeType.Element, "Server", string.Empty); propertyNode.InnerText = Server; elementRoot.AppendChild(propertyNode); propertyNode = doc.CreateNode(XmlNodeType.Element, "SelectedReport", string.Empty); propertyNode.InnerText = SelectedReport; elementRoot.AppendChild(propertyNode); propertyNode = doc.CreateNode(XmlNodeType.Element, "FileName", string.Empty); propertyNode.InnerText = FileName; elementRoot.AppendChild(propertyNode); propertyNode = doc.CreateNode(XmlNodeType.Element, "FileFormat", string.Empty); propertyNode.InnerText = FileFormat; elementRoot.AppendChild(propertyNode); doc.AppendChild(elementRoot); }
private void btnOK_Click(object sender, EventArgs e) { String strAddinPath = Path.GetDirectoryName(FAddIn.Object.GetType().Assembly.Location) + "\\ServerPath.xml"; if (!File.Exists(strAddinPath)) { FileStream fs = File.Open(strAddinPath, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite); StreamWriter sw = new StreamWriter(fs); sw.WriteLine("<Infolight></Infolight>"); sw.Close(); fs.Close(); XmlDocument x = new XmlDocument(); x.Load(strAddinPath); XmlNode xn = x.CreateNode(XmlNodeType.Element, "ServerPath", ""); XmlAttribute xa = x.CreateAttribute("Value"); xa.Value = this.tbServerPath.Text; xn.Attributes.Append(xa); x.ChildNodes[0].AppendChild(xn); xn = x.CreateNode(XmlNodeType.Element, "WebClientPath", ""); xa = x.CreateAttribute("Value"); xa.Value = this.tbWebClientPath.Text; xn.Attributes.Append(xa); x.ChildNodes[0].AppendChild(xn); x.Save(strAddinPath); } else { XmlDocument x = new XmlDocument(); x.Load(strAddinPath); x.FirstChild.ChildNodes[0].Attributes["Value"].Value = this.tbServerPath.Text; if (x.FirstChild.ChildNodes.Count < 2) { XmlNode xn = x.CreateNode(XmlNodeType.Element, "WebClientPath", ""); XmlAttribute xa = x.CreateAttribute("Value"); xa.Value = this.tbWebClientPath.Text; xn.Attributes.Append(xa); x.ChildNodes[0].AppendChild(xn); } else { x.FirstChild.ChildNodes[1].Attributes["Value"].Value = this.tbWebClientPath.Text; } x.Save(strAddinPath); } this.Hide(); }
static void Main(string[] args) { XmlDocument xmlDoc = new XmlDocument(); XmlNode xmlNode; xmlNode = xmlDoc.CreateXmlDeclaration("1.0", "utf-8", null); xmlDoc.AppendChild(xmlNode); XmlNode root = xmlDoc.CreateElement("urlset"); xmlDoc.AppendChild(root); using (SqlConnection conn = new SqlConnection(connectionstring)) { SqlCommand cmd = new SqlCommand("select idkey from feature", conn); conn.Open(); SqlDataReader reader = cmd.ExecuteReader(); while (reader.Read()) { XmlNode url = xmlDoc.CreateNode(XmlNodeType.Element, "url", null); root.AppendChild(url); xmlNode = xmlDoc.CreateNode(XmlNodeType.Element, "loc", null); xmlNode.InnerText = string.Format("http://www.culture-visions.com/f/{0}.html", Base64.Encode(reader.GetInt32(0).ToString())); url.AppendChild(xmlNode); xmlNode = xmlDoc.CreateNode(XmlNodeType.Element, "lastmod", null); xmlNode.InnerText = "2011-07-25"; url.AppendChild(xmlNode); xmlNode = xmlDoc.CreateNode(XmlNodeType.Element, "priority", null); xmlNode.InnerText = "0.5"; url.AppendChild(xmlNode); } reader.Close(); cmd = new SqlCommand("select idkey,aired from webcast order by aired desc", conn); reader = cmd.ExecuteReader(); while (reader.Read()) { XmlNode url = xmlDoc.CreateNode(XmlNodeType.Element, "url", null); root.AppendChild(url); xmlNode = xmlDoc.CreateNode(XmlNodeType.Element, "loc", null); xmlNode.InnerText = string.Format("http://www.culture-visions.com/w/{0}.html", Base64.Encode(reader.GetInt32(0).ToString())); url.AppendChild(xmlNode); xmlNode = xmlDoc.CreateNode(XmlNodeType.Element, "lastmod", null); xmlNode.InnerText = reader.GetDateTime(1).ToString("yyyy-MM-dd"); url.AppendChild(xmlNode); xmlNode = xmlDoc.CreateNode(XmlNodeType.Element, "priority", null); xmlNode.InnerText = "0.8"; url.AppendChild(xmlNode); } } xmlDoc.Save(@"E:\sitemap.xml"); }
internal static XElement ToXml(this Property property, IDataTypeService dataTypeService) { var nodeName = UmbracoSettings.UseLegacyXmlSchema ? "data" : property.Alias.ToSafeAlias(); var xd = new XmlDocument(); var xmlNode = xd.CreateNode(XmlNodeType.Element, nodeName, ""); //Add the property alias to the legacy schema if (UmbracoSettings.UseLegacyXmlSchema) { var alias = xd.CreateAttribute("alias"); alias.Value = property.Alias.ToSafeAlias(); xmlNode.Attributes.Append(alias); } //This seems to fail during testing //SD: With the new null checks below, this shouldn't fail anymore. var dt = property.PropertyType.DataType(property.Id, dataTypeService); if (dt != null && dt.Data != null) { //We've already got the value for the property so we're going to give it to the // data type's data property so it doesn't go re-look up the value from the db again. var defaultData = dt.Data as IDataValueSetter; if (defaultData != null) { defaultData.SetValue(property.Value, property.PropertyType.DataTypeDatabaseType.ToString()); } xmlNode.AppendChild(dt.Data.ToXMl(xd)); } var element = xmlNode.GetXElement(); return element; }
static XmlDocument AddOrModifyAppSettings(XmlDocument xmlDoc, string key, string value) { bool isNew = false; XmlNodeList list = xmlDoc.DocumentElement.SelectNodes(string.Format("appSettings/add[@key='{0}']", key)); XmlNode node; isNew = list.Count == 0; if (isNew) { node = xmlDoc.CreateNode(XmlNodeType.Element, "add", null); XmlAttribute attribute = xmlDoc.CreateAttribute("key"); attribute.Value = key; node.Attributes.Append(attribute); attribute = xmlDoc.CreateAttribute("value"); attribute.Value = value; node.Attributes.Append(attribute); xmlDoc.DocumentElement.SelectNodes("appSettings")[0].AppendChild(node); } else { node = list[0]; node.Attributes["value"].Value = value; } return xmlDoc; }
protected void PrepareCSProjUser() { //load csproj user var proj = new System.Xml.XmlDocument(); proj.Load(this.CSProjUserPath); //create XML NameSpace var strNamespace = proj.DocumentElement.NamespaceURI; var nsManager = new XmlNamespaceManager(proj.NameTable); string prefix = el.GetType().ToString() + "Project"; nsManager.AddNamespace(prefix, strNamespace); //remove all reference paths XmlNode ReferencePathParent; if (proj.DocumentElement.SelectSingleNode("//" + prefix + ":ReferencePath", nsManager) == null) { ReferencePathParent = proj.DocumentElement.SelectSingleNode("//" + prefix + ":ReferencePath", nsManager).ParentNode; ReferencePathParent.RemoveAll(); var referenceNode = proj.CreateNode(XmlNodeType.Element, "ReferencePath", strNamespace); referenceNode.InnerText = this.ProjectReferenceDirAssemblies + ";" + this.ProjectReferenceDirBin; ReferencePathParent.AppendChild(referenceNode); } //save .csproj.user proj.Save(this.CSProjUserPath); }
/// <summary> /// 创建Data基础xml /// </summary> /// <param name="path"></param> private void CreateDataXml(string path) { //创建XML文档对象 System.Xml.XmlDocument xmldoc = new System.Xml.XmlDocument(); //创建xml 声明节点 System.Xml.XmlNode xmlnode = xmldoc.CreateNode(System.Xml.XmlNodeType.XmlDeclaration, "", ""); //添加上述创建和 xml声明节点 xmldoc.AppendChild(xmlnode); //创建xml dbGuest 元素(根节点) System.Xml.XmlElement xmlelem = xmldoc.CreateElement("", "Data", ""); xmldoc.AppendChild(xmlelem); try { xmldoc.Save(path); } catch (Exception ex) { if (ex.Message.IndexOf("访问被拒绝") != -1) { return; } } }
public XMLFile() { doc = new System.Xml.XmlDocument(); node = doc.CreateNode(System.Xml.XmlNodeType.Element, "root", null); doc.AppendChild(node); }
/// <summary> /// Adds expiration record to the SQLFileCache /// </summary> public static void AddFileExpiration(string Key, ref SQLOptions o) { string strXMLXPath = "/SQLHelper_FileExpirations/File"; string strXMLForeignKeyAttribute = "Key"; System.Xml.XmlDocument doc = GetFileExpirations(ref o); o.WriteToLog("updating expiration file for this value..." + Key); General.Debug.Trace("updating expiration file for this value..." + Key); System.Xml.XmlNode node = doc.SelectSingleNode(strXMLXPath + "[@" + strXMLForeignKeyAttribute + "='" + Key + "']"); if (node == null) { o.WriteToLog("record not found... creating..." + Key); General.Debug.Trace("record not found... creating..." + Key); node = doc.CreateNode(System.Xml.XmlNodeType.Element, "File", ""); node.Attributes.Append(doc.CreateAttribute("Key")); node.Attributes["Key"].Value = Key; node.Attributes.Append(doc.CreateAttribute("ExpirationDate")); node.Attributes["ExpirationDate"].Value = o.Expiration.ToString(); doc.DocumentElement.AppendChild(node); } else { o.WriteToLog("record found... updating..." + Key); General.Debug.Trace("record found... updating..." + Key); node.Attributes["ExpirationDate"].Value = o.Expiration.ToString(); } SaveFileExpirations(doc, ref o); }
private string GetXML() { XmlDocument document = new XmlDocument(); XmlElement RazaoNode = document.CreateElement("Razao"); RazaoNode.InnerText = Razao; XmlElement ValoresNode = document.CreateElement("Valores"); XmlElement ValorNode = document.CreateElement("Valor"); XmlAttribute moeda = document.CreateAttribute("moeda"); moeda.Value = "BRL"; ValorNode.Attributes.Append(moeda); ValorNode.InnerText = String.Format("{0:0.00}", Valor).Replace(',','.'); ValoresNode.AppendChild(ValorNode); XmlNode EnviarInstrucao = document.CreateElement("EnviarInstrucao"); XmlNode InstrucaoUnica = EnviarInstrucao.AppendChild(document.CreateNode(XmlNodeType.Element, "InstrucaoUnica", "")); InstrucaoUnica.AppendChild(RazaoNode); InstrucaoUnica.AppendChild(ValoresNode); return EnviarInstrucao.OuterXml; }
protected void PrepareCSProj() { //load csproj var proj = new System.Xml.XmlDocument(); proj.Load(this.CSProjPath); //create XML NameSpace var strNamespace = proj.DocumentElement.NamespaceURI; var nsManager = new XmlNamespaceManager(proj.NameTable); string prefix = el.GetType().ToString() + "Project"; nsManager.AddNamespace(prefix, strNamespace); //get all references var ReferenceParent = proj.DocumentElement.SelectSingleNode("//" + prefix + ":Reference", nsManager).ParentNode; foreach (var reference in ReferenceParent.ChildNodes) { //update references path foreach (var referenceChildElement in (reference as XmlElement).ChildNodes) { if ((referenceChildElement as XmlElement).Name.ToLower() == "hintpath") { var hintPath = (referenceChildElement as XmlElement).InnerText; var dllName = hintPath.Split('\\').LastOrDefault(); //Find reference in assembilies folder if (true == System.IO.File.Exists(this.ProjectReferenceDirAssemblies + dllName)) { (referenceChildElement as XmlElement).InnerText = this.ProjectReferenceDirAssemblies + dllName; } else if (true == System.IO.File.Exists(this.ProjectReferenceDirBin + dllName)) { (referenceChildElement as XmlElement).InnerText = this.ProjectReferenceDirBin + dllName; } } } } //set up build to if (proj.DocumentElement.SelectSingleNode("//" + prefix + ":PostBuildEvent", nsManager) != null) { var PostBuildEventParent = proj.DocumentElement.SelectSingleNode("//" + prefix + ":PostBuildEvent", nsManager).ParentNode; PostBuildEventParent.RemoveAll(); var referenceNode = proj.CreateNode(XmlNodeType.Element, "PostBuildEvent", strNamespace); referenceNode.InnerText = string.Empty; if (this.AutoDeploy == true) { referenceNode.InnerText += this.DeployCMD + Environment.NewLine; } if (this.AutoIISRecycle == true) { referenceNode.InnerText += this.IISRecycleCMD + Environment.NewLine; } PostBuildEventParent.AppendChild(referenceNode); } //save csproj proj.Save(this.CSProjPath); }
public string GetUsers(string UID) { XmlDocument xmlDocument = new XmlDocument(); try { IncidentUserTicket ticket = IncidentUserTicket.Load(new Guid(UID)); if (ticket == null) { System.Xml.XmlDocument doc = new System.Xml.XmlDocument(); System.Xml.XmlNode node = doc.CreateNode(XmlNodeType.Element, SoapException.DetailElementName.Name, SoapException.DetailElementName.Namespace); System.Xml.XmlNode resource = doc.CreateNode(XmlNodeType.Element, "resource", string.Empty); resource.InnerText = "strNotfound"; node.AppendChild(resource); throw new SoapException(String.Format("The ticket '{0}' not found", UID), new XmlQualifiedName(typeof(ArgumentException).FullName), System.Web.HttpContext.Current.Request.Url.AbsoluteUri, node); } Security.UserLoginByTicket(ticket); xmlDocument.LoadXml("<Users></Users>"); XmlNode xmlRootNode = xmlDocument.SelectSingleNode("Users"); DataView dataView = Mediachase.IBN.Business.User.GetListActiveDataTable(string.Empty).DefaultView; foreach (DataRow row in dataView.Table.Rows) { /// Row includes fields: /// PrincipalId, Login, Password, FirstName, LastName, Email, IMGroupId, OriginalId, /// DisplayName, Department XmlElement userNode = xmlDocument.CreateElement("User"); xmlRootNode.AppendChild(userNode); userNode.SetAttribute("id", row["PrincipalId"].ToString()); userNode.SetAttribute("fn", row["FirstName"].ToString()); userNode.SetAttribute("ln", row["LastName"].ToString()); userNode.SetAttribute("email", row["Email"].ToString()); userNode.SetAttribute("department", row["Department"].ToString()); } } catch (Exception ex) { Trace.WriteLine(ex.Message); throw; } return(xmlDocument.InnerXml); }
//var node = file.doc.CreateNode(System.Xml.XmlNodeType.Element, "collider", null); public XmlNode CreateNode(String label) { if (doc != null) { return(doc.CreateNode(System.Xml.XmlNodeType.Element, label, null)); } return(null); }
private SoapException devolverSoapException(Exception ex) { //generacion manual de excepcion SOAP - para poder obtener solo el mensaje enviado por alguna de las capas //1.- se debe crear un nodo xml (NodoError) el cual sera utilizado para cargar el atributo Details de la exception SOAP XmlDocument _undoc = new System.Xml.XmlDocument(); XmlNode _NodoError = _undoc.CreateNode(XmlNodeType.Element, SoapException.DetailElementName.Name, SoapException.DetailElementName.Namespace); //2.- Se crea un nodo xml (NodoDetalle) q contendra el texto del error XmlNode _NodoDetalle = _undoc.CreateNode(XmlNodeType.Element, "Error", ""); _NodoDetalle.InnerText = ex.Message; _NodoError.AppendChild(_NodoDetalle); //4. Creacion manual y lanzamiento de la exception SOAP SoapException _MiEx = new SoapException(ex.Message, SoapException.ClientFaultCode, Context.Request.Url.AbsoluteUri, _NodoError); throw _MiEx; }
public Empleado Logueo(string cedula, string pass) { try { ILogicaEmpleado Lempleado = FabricaLogica.GetLogicaEmpleado(); return(Lempleado.Logueo(cedula, pass)); } catch (Exception ex) { XmlDocument _undoc = new System.Xml.XmlDocument(); XmlNode _NodoError = _undoc.CreateNode(XmlNodeType.Element, SoapException.DetailElementName.Name, SoapException.DetailElementName.Namespace); XmlNode _NodoDetalle = _undoc.CreateNode(XmlNodeType.Element, "Error", ex.Message); _NodoDetalle.InnerText = ex.Message; _NodoError.AppendChild(_NodoDetalle); SoapException _MiEx = new SoapException("Error WS", SoapException.ClientFaultCode, Context.Request.Url.AbsoluteUri, _NodoError); throw _MiEx; } }
public Terminal BuscarTerminal(string codigo) { try { ILogicaTerminal LTerminal = FabricaLogica.GetLogicaTerminales(); return(LTerminal.Buscar(codigo)); } catch (Exception ex) { XmlDocument _undoc = new System.Xml.XmlDocument(); XmlNode _NodoError = _undoc.CreateNode(XmlNodeType.Element, SoapException.DetailElementName.Name, SoapException.DetailElementName.Namespace); XmlNode _NodoDetalle = _undoc.CreateNode(XmlNodeType.Element, "Error", ex.Message); _NodoDetalle.InnerText = ex.Message; _NodoError.AppendChild(_NodoDetalle); SoapException _MiEx = new SoapException("Error WS", SoapException.ClientFaultCode, Context.Request.Url.AbsoluteUri, _NodoError); throw _MiEx; } }
public void EliminarCompania(Compania c) { try { ILogicaCompania Lcompania = FabricaLogica.GetLogicaCompania(); Lcompania.Eliminar(c); } catch (Exception ex) { XmlDocument _undoc = new System.Xml.XmlDocument(); XmlNode _NodoError = _undoc.CreateNode(XmlNodeType.Element, SoapException.DetailElementName.Name, SoapException.DetailElementName.Namespace); XmlNode _NodoDetalle = _undoc.CreateNode(XmlNodeType.Element, "Error", ex.Message); _NodoDetalle.InnerText = ex.Message; _NodoError.AppendChild(_NodoDetalle); SoapException _MiEx = new SoapException("Error WS", SoapException.ClientFaultCode, Context.Request.Url.AbsoluteUri, _NodoError); throw _MiEx; } }
public List <Viaje> ListarViajes() { try { ILogicaViaje LViaje = FabricaLogica.GetLogicaViajes(); return(LViaje.Listar()); } catch (Exception ex) { XmlDocument _undoc = new System.Xml.XmlDocument(); XmlNode _NodoError = _undoc.CreateNode(XmlNodeType.Element, SoapException.DetailElementName.Name, SoapException.DetailElementName.Namespace); XmlNode _NodoDetalle = _undoc.CreateNode(XmlNodeType.Element, "Error", ex.Message); _NodoDetalle.InnerText = ex.Message; _NodoError.AppendChild(_NodoDetalle); SoapException _MiEx = new SoapException("Error WS", SoapException.ClientFaultCode, Context.Request.Url.AbsoluteUri, _NodoError); throw _MiEx; } }
public XmlDocument(string baseNodeName, string baseNodeValue) { _doc = new System.Xml.XmlDocument(); var baseNode = _doc.CreateNode(System.Xml.XmlNodeType.Element, baseNodeName, null); baseNode.InnerText = baseNodeValue; _baseElement = new XmlElement(baseNode, null, 0); }
public System.Xml.XmlDocument GetMenu(string app) { _xdoc = new System.Xml.XmlDocument(); XmlNode Nodo = _xdoc.CreateNode(XmlNodeType.Element, "menu", ""); _xdoc.AppendChild(Nodo); this.ItemMenu(0, Nodo); return(_xdoc); }
/// <summary> /// 生成新的文档 /// </summary> public void CreateNewXML() { XmlDoc = new System.Xml.XmlDocument(); //生成根节点 XmlNode xn = XmlDoc.CreateNode(XmlNodeType.XmlDeclaration, "xml", ""); xn.Value = "version=\"1.0\" encoding=\"utf-8\""; XmlDoc.AppendChild(xn); }
/// <summary> /// 生成新的文档 /// </summary> /// <param name="DeclarationValue">XML声明(如:version="1.0" encoding="utf-8")</param> public void CreateNewXML(string DeclarationValue) { XmlDoc = new System.Xml.XmlDocument(); //生成根节点 XmlNode xn = XmlDoc.CreateNode(XmlNodeType.XmlDeclaration, "xml", ""); xn.Value = DeclarationValue; XmlDoc.AppendChild(xn); }
/// ----------------------------------------------------------------------------- /// <summary> /// Constructor to call when creating a Root Node /// </summary> /// <param name="strNamespace">Namespace of node hierarchy</param> /// <remarks> /// </remarks> /// <history> /// [Jon Henning] 12/22/2004 Created /// </history> /// ----------------------------------------------------------------------------- public XmlCollectionBase(string strNamespace) { InnerXMLDoc = new System.Xml.XmlDocument(); InnerXMLNode = InnerXMLDoc.CreateNode(XmlNodeType.Element, "root", ""); System.Xml.XmlAttribute objAttr = InnerXMLDoc.CreateAttribute("id"); objAttr.Value = strNamespace; InnerXMLNode.Attributes.Append(objAttr); InnerXMLDoc.AppendChild(InnerXMLNode); }
/// <summary> /// Stores the numeric option as an XML Node (calls base implementation) /// </summary> /// <param name="doc">The XML document to which the node will be added</param> /// <returns>The XML node containing the information of numeric option</returns> internal new XmlNode saveXML(System.Xml.XmlDocument doc) { XmlNode node = base.saveXML(doc); //Min_Value XmlNode minNode = doc.CreateNode(XmlNodeType.Element, "minValue", ""); minNode.InnerText = this.min_value.ToString(); node.AppendChild(minNode); //Max_Value XmlNode maxNode = doc.CreateNode(XmlNodeType.Element, "maxValue", ""); maxNode.InnerText = this.max_value.ToString(); node.AppendChild(maxNode); if (this.stepFunction != null) { //StepFunction XmlNode stepNode = doc.CreateNode(XmlNodeType.Element, "stepFunction", ""); stepNode.InnerText = this.stepFunction.ToString(); node.AppendChild(stepNode); } if (values != null) { //Values XmlNode valuesNode = doc.CreateNode(XmlNodeType.Element, "values", ""); String valuesAsString = ""; for (int i = 0; i < values.Count(); i++) { valuesAsString += values[i] + ";"; } // remove last ; valuesAsString = valuesAsString.Substring(0, valuesAsString.Count() - 2); valuesNode.InnerText = valuesAsString; node.AppendChild(valuesNode); } return(node); }
public XmlCollectionBase(string strNamespace, DotNetNuke.UI.WebControls.DNNTree objTreeControl) { m_objTree = objTreeControl; InnerXMLDoc = new System.Xml.XmlDocument(); InnerXMLNode = InnerXMLDoc.CreateNode(XmlNodeType.Element, "root", ""); System.Xml.XmlAttribute objAttr = InnerXMLDoc.CreateAttribute("id"); objAttr.Value = strNamespace; InnerXMLNode.Attributes.Append(objAttr); InnerXMLDoc.AppendChild(InnerXMLNode); }
private void button1_Click(object sender, EventArgs e) { System.Xml.XmlDocument xmlDoc = new System.Xml.XmlDocument(); //System.Xml.XmlElement element = xmlDoc.CreateElement("xml",); //xmlDoc.Name = "xml"; //xmlDoc.CreateElement(); System.Xml.XmlNode node = xmlDoc.CreateNode(System.Xml.XmlNodeType.CDATA, "plan_id", "xml"); node.Value = "456"; //xmlDoc.AppendChild(node); System.Xml.XmlCDataSection cData = xmlDoc.CreateCDataSection("test"); label1.Text = cData.ToString(); }
public SoapException manejoError2(Exception ex, string Username, string Metodo) { log.Error("Error " + Metodo + ": " + ex.Message); // Build the detail element of the SOAP fault. System.Xml.XmlDocument doc = new System.Xml.XmlDocument(); System.Xml.XmlNode node = doc.CreateNode(XmlNodeType.Element, SoapException.DetailElementName.Name, SoapException.DetailElementName.Namespace); System.Xml.XmlNode details = doc.CreateNode(XmlNodeType.Element, "Detalle", "http://z2.anses.gov.ar/"); details.InnerText = "Metodo: " + Metodo + " Usuario - [" + Username + "] Mensaje: " + ex.Message; node.AppendChild(details); //Throw the exception SoapException se = new SoapException("Error", SoapException.ClientFaultCode, "", ex); log.Error(Metodo, ex); return(se); }