SMGW_NewWeb.git

 
using System.Collections;
using System.Data;
using System.IO;
using System.Web;
using System.Xml;
 
namespace Common
{
  public class XmlHelper
  {
    private XmlDocument xmlDoc = new XmlDocument();
    private XmlNode xmlNode;
    private XmlElement xmlElem;
 
    public static DataSet GetDataSet(string xmlFilePath)
    {
      DataSet dataSet = new DataSet();
      if (File.Exists(xmlFilePath))
      {
        int num = (int) dataSet.ReadXml(xmlFilePath);
      }
      return dataSet;
    }
 
    public static bool WriteTableToXml(DataTable dt, string xmlFilePath)
    {
      try
      {
        dt.WriteXml(xmlFilePath);
        return true;
      }
      catch
      {
        return false;
      }
    }
 
    public static bool WriteDataSetToXml(DataSet ds, string xmlFilePath)
    {
      try
      {
        ds.WriteXml(xmlFilePath);
        return true;
      }
      catch
      {
        return false;
      }
    }
 
    public static bool DeleteTableRows(DataTable dt, int index, string xmlFilePath)
    {
      dt.Rows[index].Delete();
      return XmlHelper.WriteTableToXml(dt, xmlFilePath);
    }
 
    public static bool DeleteTableRowsInDataSet(DataSet ds, int tableIndex, int rowIndex, string xmlFilePath)
    {
      ds.Tables[tableIndex].Rows[rowIndex].Delete();
      return XmlHelper.WriteDataSetToXml(ds, xmlFilePath);
    }
 
    public static DataSet GetXml(string XmlPath)
    {
      DataSet dataSet = new DataSet();
      int num = (int) dataSet.ReadXml(XmlPath);
      return dataSet;
    }
 
    public static DataTable readXML()
    {
      XmlDocument xmlDocument = new XmlDocument();
      xmlDocument.Load(HttpContext.Current.Server.MapPath("xml/XmlComfig.xml"));
      DataTable dataTable = new DataTable("config");
      dataTable.Columns.Add("id");
      dataTable.Columns.Add("val");
      foreach (XmlNode xmlNode1 in xmlDocument.ChildNodes)
      {
        if (xmlNode1.Name == "config")
        {
          foreach (XmlNode xmlNode2 in xmlNode1)
          {
            if (xmlNode2.Name == "item")
            {
              DataRow row = dataTable.NewRow();
              row["id"] = (object) xmlNode2.Attributes["key"].Value;
              row["val"] = (object) xmlNode2.Attributes["value"].Value;
              dataTable.Rows.Add(row);
            }
          }
        }
      }
      return dataTable;
    }
 
    public static string ReadXmlReturnNode(string XmlPath, string Node)
    {
      XmlDocument xmlDocument = new XmlDocument();
      xmlDocument.Load(XmlPath);
      return xmlDocument.GetElementsByTagName(Node).Item(0).InnerText.ToString();
    }
 
    public static DataSet GetXmlData(string xmlPath, string XmlPathNode)
    {
      XmlDocument xmlDocument = new XmlDocument();
      try
      {
        xmlDocument.Load(xmlPath);
        DataSet dataSet = new DataSet();
        StringReader stringReader = new StringReader(xmlDocument.SelectSingleNode(XmlPathNode).OuterXml);
        int num = (int) dataSet.ReadXml((TextReader) stringReader);
        return dataSet;
      }
      catch
      {
        return (DataSet) null;
      }
    }
 
    public static void XmlNodeReplace(string xmlPath, string Node, string Content)
    {
      XmlDocument xmlDocument = new XmlDocument();
      xmlDocument.Load(xmlPath);
      xmlDocument.SelectSingleNode(Node).InnerText = Content;
      xmlDocument.Save(xmlPath);
    }
 
    public static void UpdateXml(DataTable dtab)
    {
      XmlDocument xmlDocument = new XmlDocument();
      xmlDocument.Load(HttpContext.Current.Server.MapPath("xml/XmlComfig.xml"));
      XmlNodeList childNodes = xmlDocument.ChildNodes;
      int index = 0;
      foreach (XmlNode xmlNode1 in childNodes)
      {
        if (xmlNode1.Name == "topictype")
        {
          foreach (XmlNode xmlNode2 in xmlNode1)
          {
            if (xmlNode2.Name == "item")
            {
              xmlNode2.Attributes["key"].Value = dtab.Rows[index]["id"].ToString();
              xmlNode2.Attributes["value"].Value = dtab.Rows[index]["val"].ToString();
              ++index;
            }
          }
        }
      }
      xmlDocument.Save(HttpContext.Current.Server.MapPath("xml/XmlComfig.xml"));
    }
 
    public static void XmlNodeDelete(string xmlPath, string Node)
    {
      XmlDocument xmlDocument = new XmlDocument();
      xmlDocument.Load(xmlPath);
      string xpath = Node.Substring(0, Node.LastIndexOf("/"));
      xmlDocument.SelectSingleNode(xpath).RemoveChild(xmlDocument.SelectSingleNode(Node));
      xmlDocument.Save(xmlPath);
    }
 
    public static void XmlInsertNode(string xmlPath, string MailNode, string ChildNode, string Element, string Content)
    {
      XmlDocument xmlDocument = new XmlDocument();
      xmlDocument.Load(xmlPath);
      XmlNode xmlNode = xmlDocument.SelectSingleNode(MailNode);
      XmlElement element1 = xmlDocument.CreateElement(ChildNode);
      xmlNode.AppendChild((XmlNode) element1);
      XmlElement element2 = xmlDocument.CreateElement(Element);
      element2.InnerText = Content;
      element1.AppendChild((XmlNode) element2);
      xmlDocument.Save(xmlPath);
    }
 
    public static void XmlInsertElement(string xmlPath, string MainNode, string Element, string Attrib, string AttribContent, string Content)
    {
      XmlDocument xmlDocument = new XmlDocument();
      xmlDocument.Load(xmlPath);
      XmlNode xmlNode = xmlDocument.SelectSingleNode(MainNode);
      XmlElement element = xmlDocument.CreateElement(Element);
      element.SetAttribute(Attrib, AttribContent);
      element.InnerText = Content;
      xmlNode.AppendChild((XmlNode) element);
      xmlDocument.Save(xmlPath);
    }
 
    public static void XmlInsertElement(string xmlPath, string MainNode, string Element, string Content)
    {
      XmlDocument xmlDocument = new XmlDocument();
      xmlDocument.Load(xmlPath);
      XmlNode xmlNode = xmlDocument.SelectSingleNode(MainNode);
      XmlElement element = xmlDocument.CreateElement(Element);
      element.InnerText = Content;
      xmlNode.AppendChild((XmlNode) element);
      xmlDocument.Save(xmlPath);
    }
 
    public void CreateXmlRoot(string root)
    {
      this.xmlNode = this.xmlDoc.CreateNode(XmlNodeType.XmlDeclaration, "", "");
      this.xmlDoc.AppendChild(this.xmlNode);
      this.xmlElem = this.xmlDoc.CreateElement("", root, "");
      this.xmlDoc.AppendChild((XmlNode) this.xmlElem);
    }
 
    public void CreatXmlNode(string mainNode, string node)
    {
      this.xmlDoc.SelectSingleNode(mainNode).AppendChild((XmlNode) this.xmlDoc.CreateElement(node));
    }
 
    public void CreatXmlNode(string mainNode, string node, string content)
    {
      XmlNode xmlNode = this.xmlDoc.SelectSingleNode(mainNode);
      XmlElement element = this.xmlDoc.CreateElement(node);
      element.InnerText = content;
      xmlNode.AppendChild((XmlNode) element);
    }
 
    public void CreatXmlNode(string MainNode, string Node, string Attrib, string AttribValue)
    {
      XmlNode xmlNode = this.xmlDoc.SelectSingleNode(MainNode);
      XmlElement element = this.xmlDoc.CreateElement(Node);
      element.SetAttribute(Attrib, AttribValue);
      xmlNode.AppendChild((XmlNode) element);
    }
 
    public void CreatXmlNode(string MainNode, string Node, string Attrib, string AttribValue, string Content)
    {
      XmlNode xmlNode = this.xmlDoc.SelectSingleNode(MainNode);
      XmlElement element = this.xmlDoc.CreateElement(Node);
      element.SetAttribute(Attrib, AttribValue);
      element.InnerText = Content;
      xmlNode.AppendChild((XmlNode) element);
    }
 
    public void CreatXmlNode(string MainNode, string Node, string Attrib, string AttribValue, string Attrib2, string AttribValue2)
    {
      XmlNode xmlNode = this.xmlDoc.SelectSingleNode(MainNode);
      XmlElement element = this.xmlDoc.CreateElement(Node);
      element.SetAttribute(Attrib, AttribValue);
      element.SetAttribute(Attrib2, AttribValue2);
      xmlNode.AppendChild((XmlNode) element);
    }
 
    public void CreatXmlNode(string MainNode, string Node, string Attrib, string AttribValue, string Attrib2, string AttribValue2, string Content)
    {
      XmlNode xmlNode = this.xmlDoc.SelectSingleNode(MainNode);
      XmlElement element = this.xmlDoc.CreateElement(Node);
      element.SetAttribute(Attrib, AttribValue);
      element.SetAttribute(Attrib2, AttribValue2);
      element.InnerText = Content;
      xmlNode.AppendChild((XmlNode) element);
    }
 
    public void XmlSave(string path)
    {
      this.xmlDoc.Save(path);
    }
 
    public static ArrayList GetSubElementByAttribute(string XmlPath, string FatherElenetName, string AttributeName, int AttributeIndex, int ArrayLength)
    {
      ArrayList arrayList = new ArrayList();
      XmlDocument xmlDocument = new XmlDocument();
      xmlDocument.Load(XmlPath);
      foreach (XmlElement xmlElement in xmlDocument.DocumentElement.ChildNodes)
      {
        if (xmlElement.Name == FatherElenetName)
        {
          if (xmlElement.Attributes.Count < AttributeIndex)
            return (ArrayList) null;
          if (xmlElement.Attributes[AttributeIndex].Value == AttributeName)
          {
            XmlNodeList childNodes = xmlElement.ChildNodes;
            if (childNodes.Count > 0)
            {
              for (int index = 0; index < ArrayLength & index < childNodes.Count; ++index)
                arrayList.Add((object) childNodes[index].InnerText);
            }
          }
        }
      }
      return arrayList;
    }
 
    public static ArrayList GetSubElementByAttribute(string XmlPath, string FatherElement, string AttributeName, string AttributeValue, int ArrayLength)
    {
      ArrayList arrayList = new ArrayList();
      XmlDocument xmlDocument = new XmlDocument();
      xmlDocument.Load(XmlPath);
      XmlNodeList childNodes = xmlDocument.DocumentElement.SelectNodes("//" + FatherElement + "[" + AttributeName + "='" + AttributeValue + "']").Item(0).ChildNodes;
      for (int index = 0; index < ArrayLength & index < childNodes.Count; ++index)
        arrayList.Add((object) childNodes.Item(index).InnerText);
      return arrayList;
    }
 
    public static ArrayList GetSubElementByAttribute(XmlDocument docXml, string FatherElement, int ArrayLength)
    {
      ArrayList arrayList = new ArrayList();
      XmlNodeList childNodes = docXml.DocumentElement.SelectNodes("//" + FatherElement).Item(0).ChildNodes;
      for (int index = 0; index < ArrayLength & index < childNodes.Count; ++index)
        arrayList.Add((object) childNodes.Item(index).InnerText);
      return arrayList;
    }
  }
}