public static void XmlWriterConvertsSurrogatePairToEntity()
        {
            MemoryStream ms = new MemoryStream();
            XmlWriterSettings settings = new XmlWriterSettings();

            // Code page: 367
            settings.Encoding = Encoding.GetEncoding("us-ascii");

            string problematicString = "ABCDEF" + s_ExampleSurrogate + "GHI";
            string problematicStringAfterFallback = "ABCDEF" + ExampleSurrogateEntity + "GHI";

            using (XmlWriter writer = XmlWriter.Create(ms, settings))
            {
                writer.WriteStartDocument();
                writer.WriteElementString("test", problematicString);
                writer.Flush();
            }

            ms.Position = 0;
            StreamReader sr = new StreamReader(ms);
            string output = sr.ReadToEnd();

            string expectedOutput = "<?xml version=\"1.0\" encoding=\"us-ascii\"?><test>" + problematicStringAfterFallback + "</test>";
            Assert.Equal(expectedOutput, output);
        }
	private bool parseXMLFile(IsolatedStorageFileStream xmlFile)
	{
		values.Clear();

		string key = "";

		// Create an XmlReader
		using (XmlReader reader = XmlReader.Create(xmlFile)) {
			XmlWriterSettings ws = new XmlWriterSettings();
			ws.Indent = false;
				// Parse the file and display each of the nodes.
				while (reader.Read()) {
					switch (reader.NodeType) {
						case XmlNodeType.Element:
							key = reader.Name;
							break;
						case XmlNodeType.Text:
							values.Add(key, reader.Value);
							break;
						case XmlNodeType.XmlDeclaration:
						case XmlNodeType.ProcessingInstruction:
							break;
						case XmlNodeType.Comment:
							break;
						case XmlNodeType.EndElement:
							break;
					}
				}
		}
		return true;
	}
Example #3
0
 protected void Page_Load(object sender, EventArgs e)
 {
     if (!IsPostBack)
     {
         DateTime dt = new DateTime();
         XmlWriterSettings xws = new XmlWriterSettings();
         xws.Indent = true;
         xws.IndentChars=("  ");
         xws.ConformanceLevel = ConformanceLevel.Fragment;
         XmlWriter xwr = XmlWriter.Create(Server.MapPath("stu.xml"), xws);
         try
         {
             xwr.WriteStartElement("userinfo");
             xwr.WriteStartElement("user");
             xwr.WriteElementString("name","zhangsan");
             xwr.WriteEndElement();
             xwr.WriteStartElement("user");
             xwr.WriteElementString("name", "Jim john");
             xwr.WriteEndElement();
             xwr.WriteStartElement("user");
             xwr.WriteElementString("name", "Marry");
             xwr.WriteEndElement();
             xwr.WriteEndElement();
             xwr.Flush();
             xwr.Close();
         }
         catch (Exception ex)
             {
             xwr.Close();
                 TextBox2.Text=ex.Message.ToString();
             }
     }
     mydom.Load(Server.MapPath("cat1.xml"));
 }
Example #4
0
    public static string Transform(string xsltFile, string xml, XsltArgumentList xslArg)
    {
        string result = "";
        try {

        XslCompiledTransform xslt = new XslCompiledTransform();
        xslt.Load(xsltFile);
        // XmlWriterSettings.OmitXmlDeclaration

        XmlDocument xmlDoc = new XmlDocument();
        xmlDoc.Load(new StringReader(xml));

        XmlWriterSettings settings = new XmlWriterSettings();
        settings.Indent = true;
        settings.OmitXmlDeclaration = true;
        settings.NewLineOnAttributes = true;

        using (StringWriter sw = new StringWriter()) {
        using (XmlWriter writer = XmlWriter.Create(sw, settings)) {
            xslt.Transform(xmlDoc, xslArg, writer);
        }
        sw.Flush();
        result = sw.ToString();
          }
        } catch (Exception ex) {
        Console.WriteLine(ex.ToString());
        }
        return result;
    }
Example #5
0
 internal static string ToXml(this object item)
 {
     if (item == null)
         return null;
     try
     {
         using (var stream = new StringWriter())
         {
             var settings = new XmlWriterSettings();
             settings.Indent = false;
             settings.OmitXmlDeclaration = true;
             using (var writer = XmlWriter.Create(stream, settings))
             {
                 var serializer = new XmlSerializer(item.GetType());
                 var emptyNamepsaces = new XmlSerializerNamespaces(new[] { XmlQualifiedName.Empty });
                 serializer.Serialize(writer, item, emptyNamepsaces);
                 return stream.ToString();
             }
         }
     }
     catch
     {
         throw;
     }
 }
Example #6
0
 public static void Main(string[] args)
 {
     AtomXmlReader reader = new AtomXmlReader();
     reader.DocumentTypeDetected += delegate(object sender, DocumentTypeDetectedEventArgs e) {
       if (!e.DocumentType.IsAssignableFrom(typeof(AtomEntry))) {
     e.HaltFurtherProcess = true;
       }
     };
     try {
       if (args.Length == 0) {
     Stream input = Console.OpenStandardInput();
     XmlWriterSettings settings = new XmlWriterSettings();
     settings.Indent = true;
     reader.ReadDocument(input).WriteDocument(Console.Out, settings);
       }
       else {
     foreach (string feedLocation in args) {
       XmlWriterSettings settings = new XmlWriterSettings();
       settings.Indent = true;
       reader.ReadDocument(feedLocation).WriteDocument(Console.Out, settings);
       break;
     }
       }
     }
     catch (ArgumentException e) {
       Console.Error.WriteLine(e.Message);
     }
 }
Example #7
0
    // Use this for initialization
    void Start()
    {
        cardList.Add(new CreatureCard());
        cardList.Add(new CreatureCard("アリスに化けたマミゾウ"));
        XmlSerializer xmls = new XmlSerializer(typeof(List<CreatureCard>));

        XmlWriterSettings settings = new XmlWriterSettings { OmitXmlDeclaration = true, Indent = true };
        using (var stream = File.OpenWrite("cardList.xml"))
        {
            using (var xmlWriter = XmlWriter.Create(stream, settings))
            {
                xmls.Serialize(xmlWriter, cardList);
            }
        }

        Type[] extraTypes = { typeof(Land), typeof(LiveableLand) };
        xmls = new XmlSerializer(typeof(Map),extraTypes);
        using (var stream = File.OpenWrite("map.xml"))
        {
            using (var xmlWriter = XmlWriter.Create(stream, settings))
            {
                xmls.Serialize(xmlWriter, map);
            }
        }
    }
Example #8
0
	void Awake(){
		player1HandPosition = GameObject.Find ("Canvas/Player1Hand");
		CL = GameObject.Find ("CardLoader").GetComponent<CardLoader>();
		using (XmlReader reader = XmlReader.Create (new StreamReader (Application.persistentDataPath + "/Decks/DeckList.xml"))) {
			XmlWriterSettings ws = new XmlWriterSettings ();
			ws.Indent = true;
			while (reader.Read ()) {
				switch (reader.NodeType) {
				case XmlNodeType.Element:
					switch (reader.Name) {
					case "Deck":
						deckName = reader.GetAttribute ("Name");
						//Debug.Log (deckName);
						break;
					}
					break;
				case XmlNodeType.Text:
					//Debug.Log (reader.Value);
					line = reader.Value;
					break;
				}
			}
		}
		player1Deck = line.Split (',').ToList<string> ();
		player1Deck.RemoveAt (player1Deck.Count - 1); // Remove the blank string at the end of the list of cards
		RandomizeDeck(player1Deck);
		DrawStartingHands (player1Deck);
		//Debug.Log (player1Deck.Count);
		DisplayHand(player1HandPosition, player1Hand);

	}
		public XmlWriterTraceListener (TextWriter writer, string name)
			: base (writer, name)
			{
			XmlWriterSettings settings = new XmlWriterSettings ();
			settings.OmitXmlDeclaration = true;
			w = XmlWriter.Create (writer, settings);
			}
Example #10
0
 /// <summary>
 /// This function is called on every recompilation to discard all previous results
 /// </summary>
 private void Reset()
 {
     _compilerErrorColl = null;
     _outputSettings = null;
     _qil = null;
     _command = null;
 }
Example #11
0
        public static void DisposeFlushesAndDisposesOutputStream()
        {
            bool[] asyncValues = { false, true };
            bool[] closeOutputValues = { false, true };
            bool[] indentValues = { false, true };
            bool[] omitXmlDeclarationValues = { false, true };
            bool[] writeEndDocumentOnCloseValues = { false, true };
            foreach (var async in asyncValues)
                foreach (var closeOutput in closeOutputValues)
                    foreach (var indent in indentValues)
                        foreach (var omitXmlDeclaration in omitXmlDeclarationValues)
                            foreach (var writeEndDocumentOnClose in writeEndDocumentOnCloseValues)
                            {
                                using (MemoryStream ms = new MemoryStream())
                                {
                                    XmlWriterSettings settings = new XmlWriterSettings();
                                    // UTF8 without BOM
                                    settings.Encoding = new UTF8Encoding(false);
                                    settings.Async = async;
                                    settings.CloseOutput = closeOutput;
                                    settings.Indent = indent;
                                    settings.OmitXmlDeclaration = omitXmlDeclaration;
                                    settings.WriteEndDocumentOnClose = writeEndDocumentOnClose;
                                    XmlWriter writer = XmlWriter.Create(ms, settings);
                                    writer.WriteStartDocument();
                                    writer.WriteStartElement("root");
                                    writer.WriteStartElement("test");
                                    writer.WriteString("abc");
                                    // !!! intentionally not closing both elements
                                    // !!! writer.WriteEndElement();
                                    // !!! writer.WriteEndElement();
                                    writer.Dispose();

                                    if (closeOutput)
                                    {
                                        bool failed = true;
                                        try
                                        {
                                            ms.WriteByte(123);
                                        }
                                        catch (ObjectDisposedException) { failed = false; }
                                        if (failed)
                                        {
                                            throw new Exception("Failed!");
                                        }
                                    }
                                    else
                                    {
                                        string output = ReadAsString(ms);
                                        Assert.True(output.Contains("<test>abc"));
                                        Assert.NotEqual(output.Contains("<?xml version"), omitXmlDeclaration);
                                        Assert.Equal(output.Contains("  "), indent);
                                        Assert.Equal(output.Contains("</test>"), writeEndDocumentOnClose);
                                    }

                                    // should not throw
                                    writer.Dispose();
                                }
                            }
        }
    // Use this for initialization
    void Start()
    {
        playerData = new PlayerData1("PkerkidHD", 10.0f);

        XmlWriterSettings xmlWriterSettings = new XmlWriterSettings()
        {
            Indent = true,
            IndentChars = "\t",
            NewLineOnAttributes = true
        };

        using (XmlWriter xml = XmlWriter.Create("PlayerData.xml", xmlWriterSettings)) {

            //ROOT
            xml.WriteStartDocument();
            xml.WriteStartElement("PlayerData");

            xml.WriteStartElement("Player");
            xml.WriteElementString("PlayerName", playerData.PlayerName);
            xml.WriteElementString("Money", playerData.Money.ToString());
            xml.WriteEndElement();

            // End.
            xml.WriteEndElement();
            xml.WriteEndDocument();
            xml.Flush();
        }

        Debug.Log ("DONE");
    }
 private static XmlWriter CreateUtf8Writer()
 {
     MemoryStream output = new MemoryStream();
     XmlWriterSettings settings = new XmlWriterSettings();
     settings.Encoding = Encoding.UTF8;
     return XmlWriter.Create(output, settings);
 }
    protected void Page_Load(object sender, EventArgs e)
    {
        var pathSVGIcons = Server.MapPath("~/Composite/images/icons/svg/");

        XNamespace svgNamespace = @"http://www.w3.org/2000/svg";

        var svgSprite = XElement.Parse(svgBlank);

        var defs = svgSprite.Descendants(svgNamespace + "defs").First();

        foreach (var file in Directory.GetFiles(pathSVGIcons))
        {
            var id = Path.GetFileNameWithoutExtension(file);
            var svgElement = XElement.Load(file);

            var taggetGroup = svgElement.Descendants(svgNamespace + "g").FirstOrDefault(el => (string) el.Attribute("id") == id);

            if (taggetGroup != null)
            {
                defs.Add(taggetGroup);
            }
        }

           var settings = new XmlWriterSettings {OmitXmlDeclaration = true};

        using (XmlWriter xw = XmlWriter.Create(PathUtil.Resolve("~/Composite/images/sprite.svg"), settings))
        {
            svgSprite.Save(xw);
        }
    }
Example #15
0
 /// <summary>
 /// This function is called on every recompilation to discard all previous results
 /// </summary>
 private void Reset()
 {
     _compilerResults = null;
     _outputSettings = null;
     _qil = null;
     _command = null;
 }
Example #16
0
    void XmlTest()
    {
        XElement root = new XElement ("root");
        for (int i = 0; i < 3; i ++) {
            XElement item = new XElement ("item");
            item.Add (new XAttribute ("1item" + i.ToString (), i));
            item.Add (new XAttribute ("2item" + i.ToString (), i));
            item.Add (new XAttribute ("3item" + i.ToString (), i));
        }
        using (FileStream fs = new FileStream( Application.dataPath + "/test.xml",FileMode.Create)) {
            XmlWriterSettings setting = new XmlWriterSettings ();
            setting.Indent = true;
            setting.IndentChars = "\t";
            setting.NewLineChars = "\n";
            setting.Encoding = Encoding.UTF8;
            using (XmlWriter xw = XmlWriter.Create(fs, setting)) {
                root.WriteTo (xw);
            }
        }

        //		using(FileStream fs = new FileStream( FILE_DIR + "/" + "ServerConfig/terrainEditorConfig.xml", FileMode.Create ) )
        //		{
        //			XmlWriterSettings setting = new XmlWriterSettings();
        //			setting.Indent = true;
        //			setting.IndentChars = "\t";
        //			setting.NewLineChars = "\n";
        //			setting.Encoding = Encoding.UTF8;
        //			using (XmlWriter xw = XmlWriter.Create(fs, setting))
        //			{
        //				root.WriteTo(xw);
        //			}
        //		}
        //	}
    }
Example #17
0
        /// <summary>
        /// Constructor.
        /// </summary>
        public XmlQueryStaticData(XmlWriterSettings defaultWriterSettings, IList<WhitespaceRule> whitespaceRules, StaticDataManager staticData)
        {
            Debug.Assert(defaultWriterSettings != null && staticData != null);
            _defaultWriterSettings = defaultWriterSettings;
            _whitespaceRules = whitespaceRules;
            _names = staticData.Names;
            _prefixMappingsList = staticData.PrefixMappingsList;
            _filters = staticData.NameFilters;
            _types = staticData.XmlTypes;
            _collations = staticData.Collations;
            _globalNames = staticData.GlobalNames;
            _earlyBound = staticData.EarlyBound;

#if DEBUG
            // Round-trip check
            byte[] data;
            Type[] ebTypes;
            this.GetObjectData(out data, out ebTypes);
            XmlQueryStaticData copy = new XmlQueryStaticData(data, ebTypes);

            _defaultWriterSettings = copy._defaultWriterSettings;
            _whitespaceRules = copy._whitespaceRules;
            _names = copy._names;
            _prefixMappingsList = copy._prefixMappingsList;
            _filters = copy._filters;
            _types = copy._types;
            _collations = copy._collations;
            _globalNames = copy._globalNames;
            _earlyBound = copy._earlyBound;
#endif
        }
Example #18
0
        public static void WriteWithEncoding()
        {
            Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);

            XmlWriterSettings settings = new XmlWriterSettings();
            settings.OmitXmlDeclaration = true;
            settings.ConformanceLevel = ConformanceLevel.Fragment;
            settings.CloseOutput = false;
            settings.Encoding = Encoding.GetEncoding("Windows-1252");
            MemoryStream strm = new MemoryStream();

            using (XmlWriter writer = XmlWriter.Create(strm, settings))
            {
                writer.WriteElementString("orderID", "1-456-ab\u0661");
                writer.WriteElementString("orderID", "2-36-00a\uD800\uDC00\uD801\uDC01");
                writer.Flush();
            }

            strm.Seek(0, SeekOrigin.Begin);
            byte[] bytes = new byte[strm.Length];
            int bytesCount = strm.Read(bytes, 0, (int)strm.Length);
            string s = settings.Encoding.GetString(bytes, 0, bytesCount);

            Assert.Equal("<orderID>1-456-ab&#x661;</orderID><orderID>2-36-00a&#x10000;&#x10401;</orderID>", s);
        }
Example #19
0
	public static void SaveXmlLevel(ABLevel level) {

		StringBuilder output = new StringBuilder();
		XmlWriterSettings ws = new XmlWriterSettings();
		ws.Indent = true;

		using (XmlWriter writer = XmlWriter.Create(output, ws))
		{
			writer.WriteStartElement("Level");

			writer.WriteStartElement("BirdsAmount");
			writer.WriteValue(level.birdsAmount);
			writer.WriteEndElement();

			writer.WriteStartElement("GameObjects");

			foreach(ABGameObject abObj in level.gameObjects)
			{
				writer.WriteStartElement("GameObject");
				writer.WriteAttributeString("label", abObj.Label.ToString());
				writer.WriteAttributeString("x", abObj.Position.x.ToString());
				writer.WriteAttributeString("y", abObj.Position.y.ToString());
				writer.WriteEndElement();
			}
		}

		int levelsAmountInResources = LoadAllLevels().Length;

		StreamWriter streamWriter = new StreamWriter("Assets/Resources/GeneratedLevels/genetic-level-" + (levelsAmountInResources + 1) + ".xml");
		streamWriter.WriteLine(output.ToString());
		streamWriter.Close();
	}
Example #20
0
        //[Variation(id=2, Desc="Default value of OmitXmlDeclaration")]
        public int default_2()
        {
            XmlWriterSettings wSettings = new XmlWriterSettings();
            CError.Compare(wSettings.OmitXmlDeclaration, false, "Incorrect default value of OmitXmlDeclaration");

            return TEST_PASS;
        }
	public void SaveGame(string savePath){
		//Create a folder for saves incase it does not already exist
		string saveFolder = Directory.GetCurrentDirectory () + "/Saves";
		if (!Directory.Exists (saveFolder))
			Directory.CreateDirectory (saveFolder);

		//Setup Xml writer and file-stream
		XmlWriterSettings ws = new XmlWriterSettings ();
		ws.Indent = true;
		ws.Encoding = Encoding.UTF8;
		//Setup the writer and ouptut
		using (FileStream fs = new FileStream (saveFolder + '/' + savePath + ".xml", FileMode.Create)) {
			using (XmlWriter writer = XmlWriter.Create (fs, ws)) {
				//Write start of document
				writer.WriteStartDocument ();
				writer.WriteStartElement ("Save");

				//Add things to save here!
				_player.GetComponent<Wizard> ().Save (writer);
				SaveEnemies (writer);

				writer.WriteEndElement ();
				writer.WriteEndDocument ();
			}
		}
	}
    public override string Serialize()
    {
        MemoryStream memoryStream = new MemoryStream();
        XmlWriterSettings xmlWriterSettings = new XmlWriterSettings();
        xmlWriterSettings.Encoding = new UTF8Encoding(false);
        xmlWriterSettings.ConformanceLevel = ConformanceLevel.Document;
        xmlWriterSettings.Indent = true;

        using (XmlWriter xmlWriter = XmlWriter.Create(memoryStream, xmlWriterSettings))
        {
            xmlWriter.WriteStartElement("behavior");

                xmlWriter.WriteStartElement("name");
                    xmlWriter.WriteString(gameObject.name);
                xmlWriter.WriteEndElement(); // End of Name node

                xmlWriter.WriteStartElement("finiteStateMachine");
                    foreach (FSMNodeWithTransitions node in readNodes)
                    {
                        xmlWriter.WriteStartElement("state");
                        xmlWriter.WriteAttributeString("node", node.NodeName);

                        /*
                        if (firstNode) {
                            writer.WriteAttributeString("type", "initial-final");
                            firstNode = false;
                        } else {
                            writer.WriteAttributeString("type", "final");
                        }
                        */

                        foreach (FSMTransition transition in node.Transitions)
                        {
                            xmlWriter.WriteStartElement("transition");
                                //xmlWriter.WriteAttributeString("action", transition.ActionName + transition.Argument);
                                xmlWriter.WriteAttributeString("action", transition.ActionName);

                                /*
                                writer.WriteStartElement("invocation-parameter");
                                writer.WriteAttributeString("value", transition.Argument);
                                writer.WriteEndElement(); // End of Invocation-Parametere node
                                */

                                xmlWriter.WriteStartElement("target");
                                    xmlWriter.WriteString(transition.Argument);
                                xmlWriter.WriteEndElement(); // End of Target node

                            xmlWriter.WriteEndElement(); //End of Transition node
                        }

                        xmlWriter.WriteEndElement(); // End of State node
                    }
                xmlWriter.WriteEndElement(); // End of FiniteStateMachine node

            xmlWriter.WriteEndElement(); // End of Behavior node
        }

        return Encoding.UTF8.GetString(memoryStream.ToArray());
    }
    public override void SaveAsXml()
    {
        bool firstNode = true;

        XmlWriterSettings settings = new XmlWriterSettings();
        settings.Indent = true;
        settings.IndentChars = "\t";
        settings.OmitXmlDeclaration = false;

        XmlWriter writer = XmlWriter.Create(@"Assets/Composition/XML/" + gameObject.name + ".sbl.xml", settings);
        writer.WriteStartElement("service");
        //writer.WriteAttributeString("xmlns", "http://www.sm4all-project.eu/composition/sbl");
        writer.WriteAttributeString("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
        writer.WriteAttributeString("xsi:schemaLocation", "http://www.sm4all-project.eu/composition/sbl ../sbl.xsd");
        writer.WriteAttributeString("name", gameObject.name);
        writer.WriteAttributeString("stid", "http://www.sm4all-project.eu/composition/sample/" + gameObject.name);
        writer.WriteAttributeString("class", "service-type");

        writer.WriteStartElement("ts");

        foreach (FSMNodeWithTransitions node in readNodes)
        {
            writer.WriteStartElement("state");
            writer.WriteAttributeString("name", node.NodeName);

            if (firstNode) {
                writer.WriteAttributeString("type", "initial-final");
                firstNode = false;
            } else {
                writer.WriteAttributeString("type", "final");
            }

            foreach (FSMTransition transition in node.Transitions)
            {
                writer.WriteStartElement("transition");
                writer.WriteAttributeString("action", transition.ActionName);

                /*
                writer.WriteStartElement("invocation-parameter");
                writer.WriteAttributeString("value", transition.Argument);
                writer.WriteEndElement(); // End of Invocation-Parametere node
                */

                writer.WriteStartElement("target");
                writer.WriteAttributeString("state", transition.Argument);
                writer.WriteEndElement(); // End of Target node

                writer.WriteEndElement(); //End of Transition node
            }

            writer.WriteEndElement(); // End of State node
        }

        writer.WriteEndElement(); // End of TS node
        writer.WriteEndElement(); // End of Service node

        writer.Close();
    }
 private void SaveGenome()
 {
     XmlWriterSettings _xwSettings = new XmlWriterSettings();
     _xwSettings.Indent = true;
     using (XmlWriter xw = XmlWriter.Create(Application.persistentDataPath + "/genome.gnm.xml", _xwSettings))
     {
         NeatGenomeXmlIO.WriteComplete(xw, currentGenome, true);
     }
 }
Example #25
0
 public void Save(string path)
 {
     XmlSerializer xs = new XmlSerializer(typeof(XML));
     XmlWriterSettings settings = new XmlWriterSettings();
     settings.CloseOutput = true;
     using (var stream = new FileStream(path, FileMode.Create)) {
         xs.Serialize(stream, this);
         stream.Close();
     }
 }
Example #26
0
        private XmlWriter CreateMemWriter(XmlWriterSettings settings)
        {
            XmlWriterSettings wSettings = settings.Clone();
            wSettings.CloseOutput = false;
            wSettings.OmitXmlDeclaration = true;
            wSettings.CheckCharacters = false;
            XmlWriter w = null;

            switch (WriterType)
            {
                case WriterType.UTF8Writer:
                    wSettings.Encoding = Encoding.UTF8;
                    if (_strWriter != null) _strWriter.Dispose();
                    _strWriter = new StringWriter();
                    w = WriterHelper.Create(_strWriter, wSettings);
                    break;
                case WriterType.UnicodeWriter:
                    wSettings.Encoding = Encoding.Unicode;
                    if (_strWriter != null) _strWriter.Dispose();
                    _strWriter = new StringWriter();
                    w = WriterHelper.Create(_strWriter, wSettings);
                    break;
                case WriterType.WrappedWriter:
                    if (_strWriter != null) _strWriter.Dispose();
                    _strWriter = new StringWriter();
                    XmlWriter ww = WriterHelper.Create(_strWriter, wSettings);
                    w = WriterHelper.Create(ww, wSettings);
                    break;
                case WriterType.CharCheckingWriter:
                    if (_strWriter != null) _strWriter.Dispose();
                    _strWriter = new StringWriter();
                    XmlWriter cw = WriterHelper.Create(_strWriter, wSettings);
                    XmlWriterSettings cws = settings.Clone();
                    cws.CheckCharacters = true;
                    w = WriterHelper.Create(cw, cws);
                    break;
                case WriterType.UTF8WriterIndent:
                    wSettings.Encoding = Encoding.UTF8;
                    wSettings.Indent = true;
                    if (_strWriter != null) _strWriter.Dispose();
                    _strWriter = new StringWriter();
                    w = WriterHelper.Create(_strWriter, wSettings);
                    break;
                case WriterType.UnicodeWriterIndent:
                    wSettings.Encoding = Encoding.Unicode;
                    wSettings.Indent = true;
                    if (_strWriter != null) _strWriter.Dispose();
                    _strWriter = new StringWriter();
                    w = WriterHelper.Create(_strWriter, wSettings);
                    break;
                default:
                    throw new Exception("Unknown writer type");
            }
            return w;
        }
        //[Variation(Desc = "NamespaceHandling Default value - NamespaceHandling.Default")]
        public int NS_Handling_1()
        {
            XmlWriterSettings wSettings = new XmlWriterSettings();
            CError.Compare(wSettings.NamespaceHandling, NamespaceHandling.Default, "Incorect default value for XmlWriterSettings.NamespaceHandling");

            using (XmlWriter w = CreateMemWriter(wSettings))
            {
                CError.Compare(w.Settings.NamespaceHandling, NamespaceHandling.Default, "Incorect default value for XmlWriter.Settings.NamespaceHandling");
            }
            return TEST_PASS;
        }
Example #28
0
  //optionally saves details about biobricks
  public void saveDevicesToFile(List<Device> devices, string filePath, bool exhaustive = true)
  {
    Logger.Log("DeviceSaver::saveDevicesToFile("+Logger.ToString<Device>(devices)+", "+filePath+")", Logger.Level.INFO);

    XmlWriterSettings settings = new XmlWriterSettings { Indent = true };

    using(XmlWriter writer = XmlWriter.Create(filePath, settings))
    {
      writer.WriteStartDocument();
      writer.WriteStartElement(BioBricksXMLTags.DEVICES);

      foreach (Device device in devices)
      {
        writer.WriteStartElement(BioBricksXMLTags.DEVICE);
        writer.WriteAttributeString(BioBricksXMLTags.ID, device.getInternalName());
        foreach (BioBrick brick in device.getExpressionModules().First.Value.getBioBricks())
        {
          writer.WriteStartElement(BioBricksXMLTags.BIOBRICK);
          writer.WriteAttributeString(BioBricksXMLTags.ID, brick.getName());

          if (exhaustive) { //saves details about biobricks
            writer.WriteAttributeString(BioBricksXMLTags.SIZE, brick.getSize().ToString());
            BioBrick.Type bioBrickType = brick.getType();
            writer.WriteAttributeString(BioBricksXMLTags.TYPE, bioBrickType.ToString().ToLower());
            switch(bioBrickType) {
              case BioBrick.Type.PROMOTER:
                writer.WriteElementString(BioBricksXMLTags.BETA, ((PromoterBrick)brick).getBeta().ToString());
                writer.WriteElementString(BioBricksXMLTags.FORMULA, ((PromoterBrick)brick).getFormula());
                break;
              case BioBrick.Type.RBS:
                writer.WriteElementString(BioBricksXMLTags.RBSFACTOR, ((RBSBrick)brick).getRBSFactor().ToString());
                break;
              case BioBrick.Type.GENE:
                writer.WriteElementString(BioBricksXMLTags.PROTEIN, ((GeneBrick)brick).getProteinName());
                break;
              case BioBrick.Type.TERMINATOR:
                writer.WriteElementString(BioBricksXMLTags.TERMINATORFACTOR, ((TerminatorBrick)brick).getTerminatorFactor().ToString());
                break;
              default:
                Logger.Log("DeviceSaver::saveDevicesToFile unknown biobrick type "+ bioBrickType, Logger.Level.WARN);
                break;
            }
          }

          writer.WriteEndElement();
        }
        writer.WriteEndElement();
      }
      writer.WriteEndElement();
      writer.WriteEndDocument();
    }

    Logger.Log("DeviceSaver.saveDevicesToFile done", Logger.Level.TRACE);
  }
Example #29
0
        //[Variation(id=4, Desc="Default value of NewLineChars")]
        public int default_4()
        {
            XmlWriterSettings wSettings = new XmlWriterSettings();
            CError.Equals(wSettings.NewLineChars, Environment.NewLine, "Incorrect default value of NewLineChars");

            XmlWriter w = CreateWriter();
            CError.Equals(w.Settings.NewLineChars, Environment.NewLine, "Incorrect default value of NewLineChars");

            w.Dispose();
            return TEST_PASS;
        }
Example #30
0
	// This sample requires managed card.
	// You can get one from e.g. http://itickr.com/index.php/?p=41

	// usage: gettoken.exe issuerURI issuerCertificate
	// example:
	// gettoken.exe https://infocard.pingidentity.com/idpdemo/sts ping.cer
	public static void Main (string [] args)
	{
		XmlDocument doc = new XmlDocument ();
		doc.AppendChild (doc.CreateElement ("root"));
		X509Certificate2 cert = new X509Certificate2 ("test.cer");
		using (XmlWriter w = doc.DocumentElement.CreateNavigator ().AppendChild ()) {
			new EndpointAddress (new Uri ("http://localhost:8080"),
				new X509CertificateEndpointIdentity (cert))
				.WriteTo (AddressingVersion.WSAddressing10, w);
		}
		XmlElement endpoint = doc.DocumentElement.FirstChild as XmlElement;
		XmlElement issuer = null;
	if (args.Length > 1) {
		using (XmlWriter w = doc.DocumentElement.CreateNavigator ().AppendChild ()) {
			new EndpointAddress (new Uri (args [0]),
				new X509CertificateEndpointIdentity (new X509Certificate2 (args [1])))
				.WriteTo (AddressingVersion.WSAddressing10, w);

		}
		issuer = doc.DocumentElement.LastChild as XmlElement;
	}
		string wst = "http://schemas.xmlsoap.org/ws/2005/02/trust";
		string infocard = "http://schemas.xmlsoap.org/ws/2005/05/identity";
		XmlElement p = doc.CreateElement ("Claims", wst);
		p.SetAttribute ("Dialect", ClaimTypes.Name);
		XmlElement ct = doc.CreateElement ("ClaimType", infocard);
		//ct.SetAttribute ("Uri", ClaimTypes.Email);
		ct.SetAttribute ("Uri", ClaimTypes.PPID);
		p.AppendChild (ct);
		GenericXmlSecurityToken token = CardSpaceSelector.GetToken (
			//endpoint, new XmlElement [] {p}, issuer, WSSecurityTokenSerializer.DefaultInstance);
			new CardSpacePolicyElement [] {new CardSpacePolicyElement (endpoint, issuer, new Collection<XmlElement> (new XmlElement [] {p}), null, 0, false)}, WSSecurityTokenSerializer.DefaultInstance);
		XmlWriterSettings s = new XmlWriterSettings ();
		s.Indent = true;
		s.ConformanceLevel = ConformanceLevel.Fragment;
		using (XmlWriter xw = XmlWriter.Create (Console.Out, s)) {
			// GenericXmlSecurityToken is writable but not readable.
			WSSecurityTokenSerializer.DefaultInstance.WriteToken (
				xw, token);
			// This cannot be serialized.
			//WSSecurityTokenSerializer.DefaultInstance.WriteToken (
			//	xw, token.ProofToken);
			WSSecurityTokenSerializer.DefaultInstance.WriteKeyIdentifierClause (xw, token.InternalTokenReference);
		}
		StringWriter sw = new StringWriter ();
		using (XmlWriter xw = XmlWriter.Create (sw, s)) {
			WSSecurityTokenSerializer.DefaultInstance.WriteKeyIdentifierClause (xw, token.ExternalTokenReference);
		}
		Console.WriteLine (sw);
		using (XmlReader xr = XmlReader.Create (new StringReader (sw.ToString ()))) {
			object o = WSSecurityTokenSerializer.DefaultInstance.ReadKeyIdentifierClause (xr);
Console.WriteLine (o);
		}
	}
Example #31
0
 private void OKBtn_Click(object sender, EventArgs e)
 {
     try
     {
         bool updatesAvailable = false;
         foreach (ListViewItem it in listView1.Items)
         {
             GXAddIn addIn = it.Tag as GXAddIn;
             if (addIn.State == AddInStates.Available || addIn.State == AddInStates.Update)
             {
                 updatesAvailable = true;
             }
             //If user has select items to download do not notify.
             else if (addIn.State == AddInStates.Download)
             {
                 updatesAvailable = false;
                 break;
             }
         }
         DialogResult res = DialogResult.Yes;
         if (updatesAvailable)
         {
             res = MessageBox.Show(this, Resources.NewProtocolsDownloadTxt, Resources.NewProtocolsAvailableTxt, MessageBoxButtons.YesNoCancel);
             if (res != DialogResult.Yes)
             {
                 this.DialogResult = DialogResult.OK;
                 this.Close();
                 return;
             }
         }
         //Add downloadable items to the list or they are not shown anymore.
         foreach (ListViewItem it in listView1.Items)
         {
             GXAddIn addIn = it.Tag as GXAddIn;
             if (addIn.State == AddInStates.Available ||
                 addIn.State == AddInStates.Download)
             {
                 if (addIn.State == AddInStates.Available)
                 {
                     if (res == DialogResult.Yes)
                     {
                         addIn.State = AddInStates.Download;
                     }
                     else if (res == DialogResult.No)
                     {
                         addIn.State = AddInStates.Disabled;
                     }
                 }
                 //Add new Addins.
                 bool exists = false;
                 foreach (var a in AddIns)
                 {
                     if (a.Name == addIn.Name)
                     {
                         exists = true;
                         break;
                     }
                 }
                 if (!exists)
                 {
                     AddIns.Add(addIn);
                 }
             }
         }
         XmlWriterSettings settings = new XmlWriterSettings();
         settings.Indent          = true;
         settings.Encoding        = System.Text.Encoding.UTF8;
         settings.CloseOutput     = true;
         settings.CheckCharacters = false;
         string path = System.IO.Path.Combine(GXCommon.ProtocolAddInsPath, "updates.xml");
         DataContractSerializer x = new DataContractSerializer(typeof(GXAddInList));
         using (XmlWriter writer = XmlWriter.Create(path, settings))
         {
             x.WriteObject(writer, AddIns);
             writer.Close();
         }
         Gurux.Common.GXFileSystemSecurity.UpdateFileSecurity(path);
         GXUpdateChecker updater = new GXUpdateChecker();
         updater.OnProgress += new GXUpdateChecker.ProgressEventHandler(updater_OnProgress);
         Status              = updater.UpdateProtocols();
         updater.UpdateApplications();
         this.DialogResult = DialogResult.OK;
         this.Close();
     }
     catch (Exception ex)
     {
         GXCommon.ShowError(this, ex);
     }
 }
Example #32
0
        /// <summary>
        /// Executes the custom runtime task component to process the input message and returns the result message.
        /// </summary>
        /// <param name="pContext">A reference to <see cref="Microsoft.BizTalk.Component.Interop.IPipelineContext"/> object that contains the current pipeline context.</param>
        /// <param name="pInMsg">A reference to <see cref="Microsoft.BizTalk.Message.Interop.IBaseMessage"/> object that contains the message to process.</param>
        /// <returns>A reference to the returned <see cref="Microsoft.BizTalk.Message.Interop.IBaseMessage"/> object which will contain the output message.</returns>
        public IBaseMessage Execute(IPipelineContext pContext, IBaseMessage pInMsg)
        {
            Guard.ArgumentNotNull(pContext, "pContext");
            Guard.ArgumentNotNull(pInMsg, "pInMsg");

            var callToken = TraceManager.PipelineComponent.TraceIn();

            // It is OK to load the entire message into XML DOM. The size of these requests is anticipated to be very small.
            XDocument request = XDocument.Load(pInMsg.BodyPart.GetOriginalDataStream());

            string transformName = (from childNode in request.Root.Descendants() where childNode.Name.LocalName == WellKnownContractMember.MessageParameters.TransformName select childNode.Value).FirstOrDefault <string>();

            TraceManager.PipelineComponent.TraceInfo(TraceLogMessages.GetXslTransformRequest, transformName);

            IBaseMessagePart  responsePart = BizTalkUtility.CreateResponsePart(pContext.GetMessageFactory(), pInMsg);
            XmlWriterSettings settings     = new XmlWriterSettings();

            MemoryStream dataStream = new MemoryStream();

            pContext.ResourceTracker.AddResource(dataStream);

            settings.CloseOutput       = false;
            settings.CheckCharacters   = false;
            settings.ConformanceLevel  = ConformanceLevel.Fragment;
            settings.NamespaceHandling = NamespaceHandling.OmitDuplicates;

            using (XmlWriter responseWriter = XmlWriter.Create(dataStream, settings))
            {
                responseWriter.WriteResponseStartElement("r", WellKnownContractMember.MethodNames.GetXslTransformMetadata, WellKnownNamespace.ServiceContracts.General);

                try
                {
                    Type transformType = ResolveTransformType(transformName);

                    if (transformType != null)
                    {
                        // Get the actual map from the BizTalk metadata cache.
                        BtsTransformMetadata btsTransform = BtsTransformMetadata.For(transformType);

                        if (btsTransform != null)
                        {
                            // Map existence confirmed, now it's safe to instantiate the transform type.
                            TransformBase transform = Activator.CreateInstance(transformType) as TransformBase;

                            // Is this really a valid map that implements TransformBase?
                            if (transform != null)
                            {
                                XslTransformMetadata transformMetadata = new XslTransformMetadata(transform.XmlContent, transform.XsltArgumentListContent, transform.SourceSchemas, transform.TargetSchemas);

                                DataContractSerializer dcSerializer = new DataContractSerializer(typeof(XslTransformMetadata), String.Concat(WellKnownContractMember.MethodNames.GetXslTransformMetadata, WellKnownContractMember.ResultMethodSuffix), WellKnownNamespace.ServiceContracts.General);
                                dcSerializer.WriteObject(responseWriter, transformMetadata);
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    // Log but do not pass the exception to the caller.
                    TraceManager.PipelineComponent.TraceError(ex);
                }

                responseWriter.WriteEndElement();
                responseWriter.Flush();
            }

            dataStream.Seek(0, SeekOrigin.Begin);
            responsePart.Data = dataStream;

            TraceManager.PipelineComponent.TraceOut(callToken);
            return(pInMsg);
        }
 /// <summary>Initializes a new instance of the <see cref="S101Logger"/> class.</summary>
 /// <param name="types">The types to pass to the internal <see cref="EmberConverter"/>, which is used to convert
 /// the payload to XML.</param>
 /// <param name="logWriter">The <see cref="TextWriter"/> to write log messages to, will be passed to
 /// <see cref="XmlWriter.Create(TextWriter, XmlWriterSettings)"/>.</param>
 /// <param name="settings">The settings to create the internal <see cref="XmlWriter"/> with, will be passed to
 /// <see cref="XmlWriter.Create(TextWriter, XmlWriterSettings)"/>.</param>
 /// <exception cref="ArgumentNullException"><paramref name="types"/>, <paramref name="logWriter"/> and/or
 /// <paramref name="settings"/> equal <c>null</c>.</exception>
 public S101Logger(EmberTypeBag types, TextWriter logWriter, XmlWriterSettings settings)
     : this(types, XmlWriter.Create(ValidateLogWriter(logWriter), settings))
 {
 }
Example #34
0
        public void Write()
        {
            project.OnWrite();
            var settings = new XmlWriterSettings {
                Encoding = Encoding.UTF8,
                Indent   = true,
            };

            if (projectVersion == ProjectVersion.VS2005)
            {
                settings.OmitXmlDeclaration = true;
            }
            using (var writer = XmlWriter.Create(project.Filename, settings)) {
                project.Platform = GetPlatformString();

                writer.WriteStartDocument();
                writer.WriteStartElement("Project", "http://schemas.microsoft.com/developer/msbuild/2003");
                var toolsVersion = GetToolsVersion();
                if (toolsVersion != null)
                {
                    writer.WriteAttributeString("ToolsVersion", toolsVersion);
                }
                writer.WriteAttributeString("DefaultTargets", "Build");
                if (projectVersion >= ProjectVersion.VS2012)
                {
                    writer.WriteStartElement("Import");
                    writer.WriteAttributeString("Project", @"$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props");
                    writer.WriteAttributeString("Condition", @"Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')");
                    writer.WriteEndElement();
                }

                // Default property group
                writer.WriteStartElement("PropertyGroup");

                writer.WriteStartElement("Configuration");
                writer.WriteAttributeString("Condition", " '$(Configuration)' == '' ");
                writer.WriteString("Debug");
                writer.WriteEndElement();

                writer.WriteStartElement("Platform");
                writer.WriteAttributeString("Condition", " '$(Platform)' == '' ");
                writer.WriteString(project.Platform);
                writer.WriteEndElement();

                writer.WriteElementString("ProjectGuid", project.Guid.ToString("B").ToUpperInvariant());
                writer.WriteElementString("OutputType", GetOutputType());
                var appDesignFolder = GetAppDesignerFolder();
                if (appDesignFolder != null)
                {
                    writer.WriteElementString("AppDesignerFolder", appDesignFolder);
                }
                writer.WriteElementString("RootNamespace", GetRootNamespace());
                var asmName = GetAssemblyName();
                if (!string.IsNullOrEmpty(asmName))
                {
                    writer.WriteElementString("AssemblyName", GetAssemblyName());
                }
                var fwkInfo = TargetFrameworkInfo.Create(project.Module);
                if (projectVersion > ProjectVersion.VS2005 || !fwkInfo.IsDotNetFramework || fwkInfo.Version != "2.0")
                {
                    writer.WriteElementString("TargetFrameworkVersion", "v" + fwkInfo.Version);
                }
                if (!string.IsNullOrEmpty(fwkInfo.Profile))
                {
                    writer.WriteElementString("TargetFrameworkProfile", fwkInfo.Profile);
                }
                if (!fwkInfo.IsDotNetFramework)
                {
                    writer.WriteElementString("TargetFrameworkIdentifier", fwkInfo.Framework);
                }
                writer.WriteElementString("FileAlignment", GetFileAlignment());
                if (project.ProjectTypeGuids.Count != 0)
                {
                    var text = string.Join(";", project.ProjectTypeGuids.Select(a => a.ToString("B")).ToArray());
                    writer.WriteElementString("ProjectTypeGuids", text);
                }
                //TODO: VB includes a "MyType"
                if (project.ApplicationManifest != null)
                {
                    writer.WriteElementString("ApplicationManifest", GetRelativePath(project.ApplicationManifest.Filename));
                }
                if (project.ApplicationIcon != null)
                {
                    writer.WriteElementString("ApplicationIcon", GetRelativePath(project.ApplicationIcon.Filename));
                }
                if (project.StartupObject != null)
                {
                    writer.WriteElementString("StartupObject", project.StartupObject);
                }
                writer.WriteEndElement();

                // Debug property group
                var noWarnList = GetNoWarnList();
                writer.WriteStartElement("PropertyGroup");
                writer.WriteAttributeString("Condition", string.Format(" '$(Configuration)|$(Platform)' == 'Debug|{0}' ", project.Platform));
                writer.WriteElementString("PlatformTarget", project.Platform);
                writer.WriteElementString("DebugSymbols", "true");
                writer.WriteElementString("DebugType", "full");
                writer.WriteElementString("Optimize", "false");
                writer.WriteElementString("OutputPath", @"bin\Debug\");
                writer.WriteElementString("DefineConstants", "DEBUG;TRACE");
                writer.WriteElementString("ErrorReport", "prompt");
                writer.WriteElementString("WarningLevel", "4");
                if (project.Options.DontReferenceStdLib)
                {
                    writer.WriteElementString("NoStdLib", "true");
                }
                if (project.AllowUnsafeBlocks)
                {
                    writer.WriteElementString("AllowUnsafeBlocks", "true");
                }
                if (noWarnList != null)
                {
                    writer.WriteElementString("NoWarn", noWarnList);
                }
                writer.WriteEndElement();

                // Release property group
                writer.WriteStartElement("PropertyGroup");
                writer.WriteAttributeString("Condition", string.Format(" '$(Configuration)|$(Platform)' == 'Release|{0}' ", project.Platform));
                writer.WriteElementString("PlatformTarget", project.Platform);
                writer.WriteElementString("DebugType", "pdbonly");
                writer.WriteElementString("Optimize", "true");
                writer.WriteElementString("OutputPath", @"bin\Release\");
                writer.WriteElementString("DefineConstants", "TRACE");
                writer.WriteElementString("ErrorReport", "prompt");
                writer.WriteElementString("WarningLevel", "4");
                if (project.Options.DontReferenceStdLib)
                {
                    writer.WriteElementString("NoStdLib", "true");
                }
                if (project.AllowUnsafeBlocks)
                {
                    writer.WriteElementString("AllowUnsafeBlocks", "true");
                }
                if (noWarnList != null)
                {
                    writer.WriteElementString("NoWarn", noWarnList);
                }
                writer.WriteEndElement();

                // GAC references
                var gacRefs = project.Module.GetAssemblyRefs().Where(a => a.Name != "mscorlib").ToArray();
                if (gacRefs.Length > 0 || project.ExtraAssemblyReferences.Count > 0)
                {
                    writer.WriteStartElement("ItemGroup");
                    var hash = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
                    foreach (var r in gacRefs)
                    {
                        var asm = project.Module.Context.AssemblyResolver.Resolve(r, project.Module);
                        if (asm != null && ExistsInProject(asm.ManifestModule.Location))
                        {
                            continue;
                        }
                        hash.Add(r.Name);
                        writer.WriteStartElement("Reference");
                        writer.WriteAttributeString("Include", IdentifierEscaper.Escape(r.Name));
                        var hintPath = GetHintPath(asm);
                        if (hintPath != null)
                        {
                            writer.WriteElementString("HintPath", hintPath);
                        }
                        writer.WriteEndElement();
                    }
                    foreach (var r in project.ExtraAssemblyReferences)
                    {
                        if (hash.Contains(r) || AssemblyExistsInProject(r))
                        {
                            continue;
                        }
                        hash.Add(r);
                        writer.WriteStartElement("Reference");
                        writer.WriteAttributeString("Include", IdentifierEscaper.Escape(r));
                        writer.WriteEndElement();
                    }
                    writer.WriteEndElement();
                }

                writer.WriteStartElement("ItemGroup");
                writer.WriteStartElement("AppDesigner");
                writer.WriteAttributeString("Include", project.PropertiesFolder + "\\");
                writer.WriteEndElement();
                writer.WriteEndElement();

                Write(writer, BuildAction.Compile);
                Write(writer, BuildAction.EmbeddedResource);

                // Project references
                var projRefs = project.Module.GetAssemblyRefs().
                               Select(a => project.Module.Context.AssemblyResolver.Resolve(a, project.Module)).
                               Select(a => a == null ? null : FindOtherProject(a.ManifestModule.Location)).
                               Where(a => a != null).ToArray();
                if (projRefs.Length > 0)
                {
                    writer.WriteStartElement("ItemGroup");
                    foreach (var otherProj in projRefs)
                    {
                        writer.WriteStartElement("ProjectReference");
                        writer.WriteAttributeString("Include", GetRelativePath(otherProj.Filename));
                        writer.WriteStartElement("Project");
                        var guidString = otherProj.Guid.ToString("B");
                        if (projectVersion < ProjectVersion.VS2012)
                        {
                            guidString = guidString.ToUpperInvariant();
                        }
                        writer.WriteString(guidString);
                        writer.WriteEndElement();
                        writer.WriteStartElement("Name");
                        writer.WriteString(IdentifierEscaper.Escape(otherProj.Module.Assembly == null ? string.Empty : otherProj.Module.Assembly.Name.String));
                        writer.WriteEndElement();
                        writer.WriteEndElement();
                    }
                    writer.WriteEndElement();
                }

                Write(writer, BuildAction.None);
                Write(writer, BuildAction.ApplicationDefinition);
                Write(writer, BuildAction.Page);
                Write(writer, BuildAction.Resource);
                Write(writer, BuildAction.SplashScreen);

                writer.WriteStartElement("Import");
                writer.WriteAttributeString("Project", GetLanguageTargets());
                writer.WriteEndElement();

                writer.WriteEndElement();
                writer.WriteEndDocument();
            }
        }
Example #35
0
        /// Create an xml file that contains the same hierarchy specified in
        /// the GEDCOM file. GEDCOM lines are limited to 255 characters,
        /// combineSplitValues indicates if the split lines should be combined
        /// into a single XML element.
        static public void ConvertToXml(string gedcomFilePath,
                                        string xmlFilePath, bool combineSplitValues)
        {
            // Store the previous level so can determine when need
            // to close xml element tags.
            int prevLevel = -1;

            // Used to create the .xml file, XmlWriterSettings. Indent is
            // specified if you want to examine the xml file, otherwise
            // it should be removed.
            XmlWriterSettings settings = new XmlWriterSettings();

            settings.Indent = true;
            using (XmlWriter writer = XmlWriter.Create(xmlFilePath, settings))
            {
                // Root element that contains all of the other elements.
                writer.WriteStartElement("root");

                // Convert each line of the gedcom file to an xml element.
                using (StreamReader sr = new StreamReader(gedcomFilePath))
                {
                    string     text;
                    GedcomLine line = new GedcomLine();
                    while ((text = sr.ReadLine()) != null)
                    {
                        // Some GEDCOM files indent each line with whitespace, delete any
                        // whitespace from the beginning and end of the line.
                        text = text.Trim();

                        // Parse gedcome line into Level, Tag and Value fields.
                        if (line.Parse(text))
                        {
                            // See if need to close previous xml elements.
                            if (line.Level <= prevLevel)
                            {
                                // Determine how many elements to close.
                                int count = prevLevel - line.Level + 1;
                                for (int i = 0; i < count; i++)
                                {
                                    writer.WriteEndElement();
                                }
                            }

                            // Create new xml element.
                            writer.WriteStartElement(line.Tag);
                            writer.WriteAttributeString("Value", line.Data);

                            prevLevel = line.Level;
                        }
                    }
                }

                // Close the last element.
                writer.WriteEndElement();

                // Close the root element.
                writer.WriteEndElement();

                // Write to the file system.
                writer.Flush();
                writer.Close();

                if (combineSplitValues)
                {
                    CombineSplitValues(xmlFilePath);
                }
            }
        }
Example #36
0
        public void ReplaceFragment_Test()
        {
            File.Copy("SmtpAgentConfig.xml", "SmtpAgentConfig.xml.test", true);
            var anchorsPlugin = @"<Anchors>
<PluginResolver>
  <!-- NEW Resolver that COMBINES Anchors from multiple sources into a single list-->
  <Definition>
    <TypeName>Health.Direct.ResolverPlugins.MultiSourceAnchorResolver, Health.Direct.ResolverPlugins</TypeName>
    <Settings>
      <!-- New Bundle Resolver -->
      <BundleResolver>
        <ClientSettings>
          <Url>http://localhost/ConfigService/CertificateService.svc/Bundles</Url>
        </ClientSettings>
        <CacheSettings>
          <Cache>true</Cache>
          <NegativeCache>true</NegativeCache>
          <!-- Set cache to longer duration in production -->
          <CacheTTLSeconds>60</CacheTTLSeconds>
        </CacheSettings>
        <MaxRetries>1</MaxRetries>
        <Timeout>30000</Timeout> <!-- In milliseconds -->
        <VerifySSL>true</VerifySSL>
      </BundleResolver>
      <!-- Standard Resolver that pulls from Anchor store -->
      <ServiceResolver>
        <ClientSettings>
          <Url>http://localhost/ConfigService/CertificateService.svc/Anchors</Url>
        </ClientSettings>
        <CacheSettings>
          <Cache>true</Cache>
          <NegativeCache>true</NegativeCache>
          <CacheTTLSeconds>60</CacheTTLSeconds>
        </CacheSettings>
      </ServiceResolver>
    </Settings>
  </Definition>
</PluginResolver>    
</Anchors>";

            var xpath  = "/SmtpAgentConfig/Anchors";
            var editor = new XPath();

            editor.XmlFilePath = "SmtpAgentConfig.xml.test";

            //var original = editor.SelectSingleAttribute("xpath");

            //Act
            editor.ReplaceFragment(xpath, anchorsPlugin);


            //Assert
            var updatedDocument = new XmlDocument();

            updatedDocument.Load("SmtpAgentConfig.xml.test");

            var updatedAnchors = updatedDocument.SelectSingleNode(xpath);

            Assert.NotNull(updatedAnchors);

            var settings = new XmlWriterSettings();

            settings.NewLineChars     = string.Empty;
            settings.Indent           = false;
            settings.IndentChars      = "";
            settings.ConformanceLevel = ConformanceLevel.Auto;

            string actualFragment;

            using (var stringWriter = new StringWriter())
            {
                using (XmlWriter writer = XmlWriter.Create(stringWriter, settings))
                {
                    updatedAnchors.WriteTo(writer);
                    writer.Flush();
                    actualFragment = stringWriter.ToString();
                }
            }

            string expectedFragment;

            using (var stringWriter = new StringWriter())
            {
                using (XmlWriter writer = XmlWriter.Create(stringWriter, settings))
                {
                    XmlNode newNode = updatedDocument.CreateDocumentFragment();
                    newNode.InnerXml = anchorsPlugin;
                    newNode.WriteTo(writer);
                    writer.Flush();
                    expectedFragment = stringWriter.ToString();
                }
            }

            var cleanExpectedFragment = new XmlDocument();

            cleanExpectedFragment.LoadXml(expectedFragment);
            expectedFragment = cleanExpectedFragment.OuterXml;

            Assert.Equal(expectedFragment, actualFragment);
        }
Example #37
0
        public override bool Go(TVRenameStats stats)
        {
            XmlWriterSettings settings = new XmlWriterSettings
            {
                Indent              = true,
                IndentChars         = "    ",
                Encoding            = Encoding.UTF8,
                NewLineChars        = "\r\n",
                NewLineOnAttributes = true,

                //Multipart NFO files are not actually valid XML as they have multiple episodeDetails elements
                ConformanceLevel = ConformanceLevel.Fragment
            };

            try
            {
                // "try" and silently fail.  eg. when file is use by other...
                using (XmlWriter writer = XmlWriter.Create(Where.FullName, settings))
                {
                    if (Episode != null) // specific episode
                    {
                        if (Episode.Type == ProcessedEpisode.ProcessedEpisodeType.merged)
                        {
                            foreach (Episode ep in Episode.SourceEpisodes)
                            {
                                ShowItem si = Episode.Show ?? SelectedShow;
                                WriteEpisodeDetailsFor(ep, si, writer, true, si.DvdOrder);
                            }
                        }
                        else
                        {
                            ShowItem si = Episode.Show ?? SelectedShow;
                            WriteEpisodeDetailsFor(Episode, si, writer, false, si.DvdOrder);
                        }
                    }
                    else if (SelectedShow != null) // show overview (tvshow.nfo)
                    {
                        SeriesInfo series = SelectedShow.TheSeries();

                        // https://kodi.wiki/view/NFO_files/TV_shows
                        writer.WriteStartElement("tvshow");

                        writer.WriteElement("title", SelectedShow.ShowName);
                        writer.WriteElement("originaltitle", series?.Name);
                        writer.WriteElement("studio", series?.Network);
                        float?showRating = series?.SiteRating;
                        if (showRating.HasValue)
                        {
                            writer.WriteStartElement("ratings");

                            writer.WriteStartElement("rating");
                            writer.WriteAttributeString("name", "tvdb");
                            writer.WriteAttributeString("max", "10");
                            writer.WriteAttributeString("default", "true");

                            writer.WriteElement("value", showRating.Value);
                            writer.WriteElement("votes", series.SiteRatingVotes, true);

                            writer.WriteEndElement(); //rating

                            writer.WriteEndElement(); //ratings
                        }

                        string lang = TVSettings.Instance.PreferredLanguageCode;
                        if (SelectedShow.UseCustomLanguage && SelectedShow.PreferredLanguage != null)
                        {
                            lang = SelectedShow.PreferredLanguage.Abbreviation;
                        }

                        writer.WriteElement("episodeguideurl",
                                            TheTVDB.BuildUrl(SelectedShow.TvdbCode, lang));

                        if (!(series is null))
                        {
                            writer.WriteElement("id", series.SeriesId);
                            writer.WriteElement("runtime", series.Runtime, true);
                            writer.WriteElement("mpaa", series.ContentRating, true);

                            writer.WriteStartElement("uniqueid");
                            writer.WriteAttributeString("type", "tvdb");
                            writer.WriteAttributeString("default", "true");
                            writer.WriteValue(series.TvdbCode);
                            writer.WriteEndElement();

                            writer.WriteStartElement("uniqueid");
                            writer.WriteAttributeString("type", "imdb");
                            writer.WriteAttributeString("default", "false");
                            writer.WriteValue(series.Imdb);
                            writer.WriteEndElement();

                            writer.WriteElement("plot", series.Overview);

                            writer.WriteElement("premiered", series.FirstAired);
                            writer.WriteElement("year", series.Year);
                            writer.WriteElement("status", series.Status);
                        }

                        writer.WriteStringsToXml("genre", SelectedShow.Genres);

                        // actors...
                        foreach (Actor aa in SelectedShow.Actors.Where(aa => !string.IsNullOrEmpty(aa.ActorName)))
                        {
                            writer.WriteStartElement("actor");
                            writer.WriteElement("name", aa.ActorName);
                            writer.WriteElement("role", aa.ActorRole);
                            writer.WriteElement("order", aa.ActorSortOrder);
                            writer.WriteElement("thumb", aa.ActorImage);
                            writer.WriteEndElement(); // actor
                        }

                        writer.WriteEndElement(); // tvshow
                    }
                }
            }
            catch (Exception e)
            {
                ErrorText = e.Message;
                LastError = e;
                Error     = true;
                Done      = true;
                return(false);
            }
            Done = true;
            return(true);
        }
Example #38
0
        /// <summary>
        /// Converts and serializes the user-defined commands into an XML file
        /// </summary>
        public static Script SerializeScript(ListView.ListViewItemCollection scriptCommands, List <ScriptVariable> scriptVariables, string scriptFilePath = "")
        {
            var script = new Core.Script.Script();

            //save variables to file

            script.Variables = scriptVariables;

            //save listview tags to command list

            int lineNumber = 1;

            List <Core.Script.ScriptAction> subCommands = new List <Core.Script.ScriptAction>();

            foreach (ListViewItem commandItem in scriptCommands)
            {
                var command = (Core.AutomationCommands.ScriptCommand)commandItem.Tag;
                command.LineNumber = lineNumber;

                if ((command is Core.AutomationCommands.BeginNumberOfTimesLoopCommand) || (command is Core.AutomationCommands.BeginContinousLoopCommand) || (command is Core.AutomationCommands.BeginListLoopCommand) || (command is Core.AutomationCommands.BeginIfCommand) || (command is Core.AutomationCommands.BeginExcelDatasetLoopCommand))
                {
                    if (subCommands.Count == 0)  //if this is the first loop
                    {
                        //add command to root node
                        var newCommand = script.AddNewParentCommand(command);
                        //add to tracking for additional commands
                        subCommands.Add(newCommand);
                    }
                    else  //we are already looping so add to sub item
                    {
                        //get reference to previous node
                        var parentCommand = subCommands[subCommands.Count - 1];
                        //add as new node to previous node
                        var nextNodeParent = parentCommand.AddAdditionalAction(command);
                        //add to tracking for additional commands
                        subCommands.Add(nextNodeParent);
                    }
                }
                else if ((command is Core.AutomationCommands.EndLoopCommand) || (command is Core.AutomationCommands.EndIfCommand))  //if current loop scenario is ending
                {
                    //get reference to previous node
                    var parentCommand = subCommands[subCommands.Count - 1];
                    //add to end command // DECIDE WHETHER TO ADD WITHIN LOOP NODE OR PREVIOUS NODE
                    parentCommand.AddAdditionalAction(command);
                    //remove last command since loop is ending
                    subCommands.RemoveAt(subCommands.Count - 1);
                }
                else if (subCommands.Count == 0) //add command as a root item
                {
                    script.AddNewParentCommand(command);
                }
                else //we are within a loop so add to the latest tracked loop item
                {
                    var parentCommand = subCommands[subCommands.Count - 1];
                    parentCommand.AddAdditionalAction(command);
                }

                //increment line number
                lineNumber++;
            }

            //output to xml file
            XmlSerializer serializer = new XmlSerializer(typeof(Script));
            var           settings   = new XmlWriterSettings
            {
                NewLineHandling = NewLineHandling.Entitize,
                Indent          = true
            };

            //if output path was provided
            if (scriptFilePath != "")
            {
                //write to file
                System.IO.FileStream fs;
                using (fs = System.IO.File.Create(scriptFilePath))
                {
                    using (XmlWriter writer = XmlWriter.Create(fs, settings))
                    {
                        serializer.Serialize(writer, script);
                    }
                }
            }


            return(script);
        }
Example #39
0
 private void CompileQilToMsil(XsltSettings settings)
 {
     _command        = new XmlILGenerator().Generate(_qil, /*typeBuilder:*/ null);
     _outputSettings = _command.StaticData.DefaultWriterSettings;
     _qil            = null;
 }
Example #40
0
        void BadXmlValueTest()
        {
            var sb = new System.Text.StringBuilder();

            var forbidden = new System.Collections.Generic.HashSet <int>();
            int start = 64976; int end = 65007;

            for (int i = start; i <= end; i++)
            {
                forbidden.Add(i);
            }

            forbidden.Add(0xFFFE);
            forbidden.Add(0xFFFF);

            for (int i = char.MinValue; i <= char.MaxValue; i++)
            {
                char c = Convert.ToChar(i);
                if (char.IsSurrogate(c))
                {
                    continue; // skip surrogates
                }

                if (forbidden.Contains(c))
                {
                    continue;
                }

                sb.Append(c);
            }

            var badString = sb.ToString();

            var settings = new XmlWriterSettings
            {
                Indent           = true,
                ConformanceLevel = ConformanceLevel.Fragment,
                IndentChars      = "  ",
            };

            sb.Length = 0;
            using (XmlWriter xtw = XmlWriter.Create(sb, settings))
            {
                xtw.WriteStartElement("log4j", "event", "http:://hello/");
                xtw.WriteElementSafeString("log4j", "message", "http:://hello/", badString);
                xtw.WriteEndElement();
                xtw.Flush();
            }

            string goodString = null;

            using (XmlReader reader = XmlReader.Create(new StringReader(sb.ToString())))
            {
                while (reader.Read())
                {
                    if (reader.NodeType == XmlNodeType.Text)
                    {
                        if (reader.Value.Contains("abc"))
                        {
                            goodString = reader.Value;
                        }
                    }
                }
            }

            Assert.NotNull(goodString);
            Assert.NotEqual(badString.Length, goodString.Length);
            Assert.Contains("abc", badString);
            Assert.Contains("abc", goodString);
        }
Example #41
0
    public void SlbToXml()
    {
        string importPath = EditorUtility.OpenFilePanel("Load SLB", "", "slb");

        if (importPath.Length == 0)
        {
            return;
        }

        FileStream   fileStream   = new FileStream(importPath, FileMode.Open);
        BinaryReader binaryReader = new BinaryReader(fileStream);

        XmlDocument xmlDocument = new XmlDocument();

        // INITIAL DATA
        string id = Utilities.CharArrayToString(binaryReader.ReadChars(4));

        XmlElement root = xmlDocument.CreateElement("movelist");

        root.SetAttribute("id", id);
        xmlDocument.AppendChild(root);

        binaryReader.ReadUInt32();         // unused entry count
        UInt32 entryCount1  = binaryReader.ReadUInt32();
        UInt32 tableOffset1 = binaryReader.ReadUInt32();

        binaryReader.ReadUInt32();         // unused entry count
        UInt32 entryCount2  = binaryReader.ReadUInt32();
        UInt32 tableOffset2 = binaryReader.ReadUInt32();

        // TABLE 1
        XmlElement table1 = xmlDocument.CreateElement("table1");

        xmlDocument.DocumentElement.AppendChild(table1);
        fileStream.Seek(tableOffset1, SeekOrigin.Begin);
        for (int i1 = 0; i1 < entryCount1; i1++)
        {
            XmlElement entry = xmlDocument.CreateElement("entry");
            table1.AppendChild(entry);

            string id1 = Utilities.CharArrayToString(binaryReader.ReadChars(4));
            entry.SetAttribute("id_1", id1);

            string id2 = Utilities.CharArrayToString(binaryReader.ReadChars(4));
            entry.SetAttribute("id_2", id2);

            UInt16 flags1 = binaryReader.ReadUInt16();
            entry.SetAttribute("flags_1", Convert.ToString(flags1, 2).PadLeft(16, '0'));

            Int16 index = binaryReader.ReadInt16();
            entry.SetAttribute("index", index.ToString());

            UInt32 long1 = binaryReader.ReadUInt32();
            entry.SetAttribute("long_1", long1.ToString());

            float float1 = binaryReader.ReadSingle();
            entry.SetAttribute("float_1", float1.ToString());

            float float2 = binaryReader.ReadSingle();
            entry.SetAttribute("float_2", float2.ToString());

            UInt32 flags2 = binaryReader.ReadUInt32();
            entry.SetAttribute("flags_2", Convert.ToString(flags2, 2).PadLeft(32, '0'));

            Int16 reservedCounter = binaryReader.ReadInt16();
            entry.SetAttribute("reserved_counter", reservedCounter.ToString());
            fileStream.Seek(2, SeekOrigin.Current);             // skip padding

            // split trigger stuff, whatever that is
            binaryReader.ReadUInt32();             // unused entry count
            UInt32 splitTriggerEntryCount = binaryReader.ReadUInt32();
            UInt32 splitTriggerOffset     = binaryReader.ReadUInt32();
            long   rememberMe             = fileStream.Position;
            fileStream.Seek(splitTriggerOffset, SeekOrigin.Begin);
            for (int j = 0; j < splitTriggerEntryCount; j++)
            {
                XmlElement splitTrigger = xmlDocument.CreateElement("split_trigger");
                entry.AppendChild(splitTrigger);

                UInt32 input = binaryReader.ReadUInt32();
                splitTrigger.SetAttribute("input", Convert.ToString(input, 2).PadLeft(32, '0'));

                string id3 = Utilities.CharArrayToString(binaryReader.ReadChars(4));
                splitTrigger.SetAttribute("id", id3);

                float sFloat1 = binaryReader.ReadSingle();
                splitTrigger.SetAttribute("float_1", sFloat1.ToString());

                float sFloat2 = binaryReader.ReadSingle();
                splitTrigger.SetAttribute("float_2", sFloat2.ToString());

                float sFloat3 = binaryReader.ReadSingle();
                splitTrigger.SetAttribute("float_3", sFloat3.ToString());

                byte sFlags = binaryReader.ReadByte();
                splitTrigger.SetAttribute("flags", Convert.ToString(sFlags, 2).PadLeft(8, '0'));

                fileStream.Seek(3, SeekOrigin.Current);                 // skip padding
            }
            fileStream.Seek(rememberMe, SeekOrigin.Begin);
        }

        // TABLE 2
        // I'M GOING TO BED, COPY PASTE TIME, DON'T CARE
        XmlElement table2 = xmlDocument.CreateElement("table2");

        xmlDocument.DocumentElement.AppendChild(table2);
        fileStream.Seek(tableOffset2, SeekOrigin.Begin);
        for (int i2 = 0; i2 < entryCount2; i2++)
        {
            XmlElement entry = xmlDocument.CreateElement("entry");
            table2.AppendChild(entry);

            string id1 = Utilities.CharArrayToString(binaryReader.ReadChars(4));
            entry.SetAttribute("id_1", id1);

            string id2 = Utilities.CharArrayToString(binaryReader.ReadChars(4));
            entry.SetAttribute("id_2", id2);

            UInt16 flags1 = binaryReader.ReadUInt16();
            entry.SetAttribute("flags_1", Convert.ToString(flags1, 2).PadLeft(16, '0'));

            Int16 index = binaryReader.ReadInt16();
            entry.SetAttribute("index", index.ToString());

            UInt32 long1 = binaryReader.ReadUInt32();
            entry.SetAttribute("long_1", long1.ToString());

            float float1 = binaryReader.ReadSingle();
            entry.SetAttribute("float_1", float1.ToString());

            float float2 = binaryReader.ReadSingle();
            entry.SetAttribute("float_2", float2.ToString());

            UInt32 flags2 = binaryReader.ReadUInt32();
            entry.SetAttribute("flags_2", Convert.ToString(flags2, 2).PadLeft(32, '0'));

            Int16 reservedCounter = binaryReader.ReadInt16();
            entry.SetAttribute("reserved_counter", reservedCounter.ToString());
            fileStream.Seek(2, SeekOrigin.Current);             // skip padding

            // split trigger stuff, whatever that is
            binaryReader.ReadUInt32();             // unused entry count
            UInt32 splitTriggerEntryCount = binaryReader.ReadUInt32();
            UInt32 splitTriggerOffset     = binaryReader.ReadUInt32();

            UInt32 extra = binaryReader.ReadUInt32();
            entry.SetAttribute("extra", extra.ToString());

            long rememberMe = fileStream.Position;
            fileStream.Seek(splitTriggerOffset, SeekOrigin.Begin);
            for (int j = 0; j < splitTriggerEntryCount; j++)
            {
                XmlElement splitTrigger = xmlDocument.CreateElement("split_trigger");
                entry.AppendChild(splitTrigger);

                UInt32 input = binaryReader.ReadUInt32();
                splitTrigger.SetAttribute("input", Convert.ToString(input, 2).PadLeft(32, '0'));

                string id3 = Utilities.CharArrayToString(binaryReader.ReadChars(4));
                splitTrigger.SetAttribute("id", id3);

                float sFloat1 = binaryReader.ReadSingle();
                splitTrigger.SetAttribute("float_1", sFloat1.ToString());

                float sFloat2 = binaryReader.ReadSingle();
                splitTrigger.SetAttribute("float_2", sFloat2.ToString());

                float sFloat3 = binaryReader.ReadSingle();
                splitTrigger.SetAttribute("float_3", sFloat3.ToString());

                byte sFlags = binaryReader.ReadByte();
                splitTrigger.SetAttribute("flags", Convert.ToString(sFlags, 2).PadLeft(8, '0'));

                fileStream.Seek(3, SeekOrigin.Current);                 // skip padding
            }
            fileStream.Seek(rememberMe, SeekOrigin.Begin);
        }

        string pathWithoutFile = Path.GetDirectoryName(importPath);
        string exportPath      = EditorUtility.SaveFilePanel("Save XML", pathWithoutFile, "Movelist.xml", "xml");

        if (exportPath.Length == 0)
        {
            return;
        }

        // thanks random guy who answered that stackoverflow post, we couldn't have done it without you
        XmlWriterSettings settings = new XmlWriterSettings
        {
            Indent              = true,
            IndentChars         = "	",
            NewLineOnAttributes = true
        };

        using (XmlWriter writer = XmlWriter.Create(exportPath, settings))
        {
            xmlDocument.Save(writer);
        }
        Debug.Log("Saved " + exportPath);
    }
Example #42
0
        static public string buildFile(AlarmDefinitionList alarms)
        {
            XmlWriterSettings settings = new XmlWriterSettings {
                ConformanceLevel = ConformanceLevel.Document,
                Encoding         = Encoding.UTF8,
                Indent           = true
            };
            string filename;

            using (Stream stream = TempFile.Open("sDB_Larm", "xml", out filename))
            {
                // Round up to multiples of 16, since HMI uses words to transfer alarm state
                int       maxAlarmCount = ((alarms.Count() + 15) / 16) * 16;
                XmlWriter w             = XmlWriter.Create(stream, settings);
                w.WriteStartDocument();
                w.WriteStartElement("Document");

                w.WriteStartElement("DocumentInfo");
                w.WriteEndElement(); // DocumentInfo
                w.WriteStartElement("SW.DataBlock");
                w.WriteAttributeString("ID", "0");
                w.WriteStartElement("AttributeList");

                XMLUtil.SimpleValue(w, "AutoNumber", "true");
                XMLUtil.SimpleValue(w, "DatablockType", "SharedDB");
                XMLUtil.SimpleValue(w, "HeaderVersion", "0.1");

                w.WriteStartElement("Interface");
                w.WriteStartElement("Sections", "http://www.siemens.com/automation/Openness/SW/Interface/v1");
                w.WriteStartElement("Section");
                w.WriteAttributeString("Name", "Static");

                w.WriteStartElement("Member");
                w.WriteAttributeString("Name", "Props");
                w.WriteAttributeString("Remanence", "Classic");
                w.WriteAttributeString("Datatype", "Array[1.." + maxAlarmCount + "] of \"AlarmProperties\"");
                w.WriteStartElement("AttributeList");
                XMLUtil.BooleanAttribute(w, "HmiAccessible", true, XMLUtil.SystemDefined);
                XMLUtil.BooleanAttribute(w, "HmiVisible", true, XMLUtil.SystemDefined);
                w.WriteEndElement(); // AttributeList

                w.WriteStartElement("Sections");
                w.WriteStartElement("Section");
                w.WriteAttributeString("Name", "None");

                // Silent member
                w.WriteStartElement("Member");
                w.WriteAttributeString("Name", "Silent");
                w.WriteAttributeString("Datatype", "Bool");

                w.WriteStartElement("AttributeList");
                w.WriteEndElement(); // AttributeList

                int index = 1;
                foreach (AlarmDefinition a in alarms)
                {
                    StartValue(w, index.ToString(), (a.Options & AlarmDefinition.Option.Silent) != 0 ? "true" : "false");
                    index++;
                }
                w.WriteEndElement(); // Member

                // AutoAck member
                w.WriteStartElement("Member");
                w.WriteAttributeString("Name", "AutoAck");
                w.WriteAttributeString("Datatype", "Bool");

                w.WriteStartElement("AttributeList");
                w.WriteEndElement(); // AttributeList

                index = 1;
                foreach (AlarmDefinition a in alarms)
                {
                    StartValue(w, index.ToString(), (a.Options & AlarmDefinition.Option.AutoAck) != 0 ? "true" : "false");
                    index++;
                }
                w.WriteEndElement(); // Member

                // Text member
                w.WriteStartElement("Member");
                w.WriteAttributeString("Name", "Text");
                w.WriteAttributeString("Datatype", "String[64]");

                w.WriteStartElement("AttributeList");
                w.WriteEndElement(); // AttributeList

                index = 1;
                foreach (AlarmDefinition a in alarms)
                {
                    StartValue(w, index.ToString(), "'" + a.Text + "'");
                    index++;
                }
                w.WriteEndElement(); // Member

                w.WriteEndElement(); // Section
                w.WriteEndElement(); // Sections
                w.WriteEndElement(); // Member

                w.WriteEndElement(); // Section
                w.WriteEndElement(); // Sections
                w.WriteEndElement(); // Interface

                string now = DateTime.UtcNow.ToString("o");
                XMLUtil.SimpleValue(w, "InterfaceModifiedDate", now, true);
                XMLUtil.SimpleValue(w, "IsKnowHowProtected", now, true);
                XMLUtil.SimpleValue(w, "IsOnlyStoredInLoadMemory", "false");
                XMLUtil.SimpleValue(w, "IsPLCDB", "false", true);
                XMLUtil.SimpleValue(w, "IsWriteProtectedInAS", "false");
                XMLUtil.SimpleValue(w, "MemoryLayout", "Standard");
                XMLUtil.SimpleValue(w, "ModifiedDate", now, true);
                XMLUtil.SimpleValue(w, "Name", "sDB_LarmDefs");
                XMLUtil.SimpleValue(w, "Number", "532");
                XMLUtil.SimpleValue(w, "ParameterModified", now, true);
                XMLUtil.SimpleValue(w, "ProgrammingLanguage", "DB");
                XMLUtil.SimpleValue(w, "StructureModified", now, true);
                XMLUtil.SimpleValue(w, "Type", "DB");
                w.WriteEndElement(); // AttributeList
                w.WriteEndElement(); // SW.Datablock
                w.WriteEndElement(); // Document
                w.Close();
            }
            return(filename);
        }
Example #43
0
 public TextWriterWithSettings(StringBuilder buffer, XmlWriterSettings settings)
 {
     _baseObject = new StringWriter(buffer);
     _settings   = settings;
 }
Example #44
0
        public void CreateFragmentBefore_Create_Test()
        {
            File.Copy("SmtpAgentConfig.xml", "SmtpAgentConfig.xml.test", true);
            var domainsFragement = @"<Domains><ServiceResolver><AgentName>SmtpAgent1</AgentName><ClientSettings><Url>http://localhost/ConfigService/DomainManagerService.svc/Domains</Url></ClientSettings><CacheSettings><Cache>true</Cache><CacheTTLSeconds>20</CacheTTLSeconds></CacheSettings></ServiceResolver></Domains>";

            var   xpath  = "/SmtpAgentConfig/Domains";
            IPath editor = new XPath();

            editor.XmlFilePath = "SmtpAgentConfig.xml.test";

            //var original = editor.SelectSingleAttribute("xpath");

            //Act
            editor.CreateFragmentBefore(domainsFragement, "//DomainManager");


            //Assert
            var updatedDocument = new XmlDocument();

            updatedDocument.Load("SmtpAgentConfig.xml.test");

            var updatedAnchors = updatedDocument.SelectSingleNode(xpath);

            Assert.NotNull(updatedAnchors);

            var settings = new XmlWriterSettings();

            settings.NewLineChars     = string.Empty;
            settings.Indent           = false;
            settings.IndentChars      = "";
            settings.ConformanceLevel = ConformanceLevel.Auto;

            string actualFragment;

            using (var stringWriter = new StringWriter())
            {
                using (var writer = XmlWriter.Create(stringWriter, settings))
                {
                    updatedAnchors.WriteTo(writer);
                    writer.Flush();
                    actualFragment = stringWriter.ToString();
                }
            }

            string expectedFragment;

            using (var stringWriter = new StringWriter())
            {
                using (var writer = XmlWriter.Create(stringWriter, settings))
                {
                    XmlNode newNode = updatedDocument.CreateDocumentFragment();
                    newNode.InnerXml = domainsFragement;
                    newNode.WriteTo(writer);
                    writer.Flush();
                    expectedFragment = stringWriter.ToString();
                }
            }

            var cleanExpectedFragment = new XmlDocument();

            cleanExpectedFragment.LoadXml(expectedFragment);
            expectedFragment = cleanExpectedFragment.OuterXml;

            Assert.Equal(expectedFragment, actualFragment);
        }
Example #45
0
        public override MetadataFileResult MovieMetadata(Movie movie, MovieFile movieFile)
        {
            var xmlResult = string.Empty;

            if (Settings.MovieMetadata)
            {
                _logger.Debug("Generating Movie Metadata for: {0}", Path.Combine(movie.Path, movieFile.RelativePath));

                var movieMetadataLanguage = (Settings.MovieMetadataLanguage == (int)Language.Original) ?
                                            (int)movie.OriginalLanguage :
                                            Settings.MovieMetadataLanguage;

                var movieTranslations        = _movieTranslationsService.GetAllTranslationsForMovie(movie.Id);
                var selectedSettingsLanguage = Language.FindById(movieMetadataLanguage);
                var movieTranslation         = movieTranslations.FirstOrDefault(mt => mt.Language == selectedSettingsLanguage);

                var credits = _creditService.GetAllCreditsForMovie(movie.Id);

                var watched = GetExistingWatchedStatus(movie, movieFile.RelativePath);

                var sb  = new StringBuilder();
                var xws = new XmlWriterSettings();
                xws.OmitXmlDeclaration = true;
                xws.Indent             = false;

                using (var xw = XmlWriter.Create(sb, xws))
                {
                    var doc       = new XDocument();
                    var thumbnail = movie.Images.SingleOrDefault(i => i.CoverType == MediaCoverTypes.Screenshot);
                    var posters   = movie.Images.Where(i => i.CoverType == MediaCoverTypes.Poster);
                    var fanarts   = movie.Images.Where(i => i.CoverType == MediaCoverTypes.Fanart);

                    var details = new XElement("movie");

                    details.Add(new XElement("title", movieTranslation?.Title ?? movie.Title));

                    details.Add(new XElement("originaltitle", movie.OriginalTitle));

                    details.Add(new XElement("sorttitle", movie.SortTitle));

                    if (movie.Ratings != null && movie.Ratings.Votes > 0)
                    {
                        var setRating         = new XElement("ratings");
                        var setRatethemoviedb = new XElement("rating", new XAttribute("name", "themoviedb"), new XAttribute("max", "10"), new XAttribute("default", "true"));
                        setRatethemoviedb.Add(new XElement("value", movie.Ratings.Value));
                        setRatethemoviedb.Add(new XElement("votes", movie.Ratings.Votes));
                        setRating.Add(setRatethemoviedb);
                        details.Add(setRating);
                    }

                    if (movie.Ratings != null && movie.Ratings.Votes > 0)
                    {
                        details.Add(new XElement("rating", movie.Ratings.Value));
                    }

                    details.Add(new XElement("userrating"));

                    details.Add(new XElement("top250"));

                    details.Add(new XElement("outline"));

                    details.Add(new XElement("plot", movieTranslation?.Overview ?? movie.Overview));

                    details.Add(new XElement("tagline"));

                    details.Add(new XElement("runtime", movie.Runtime));

                    if (thumbnail != null)
                    {
                        details.Add(new XElement("thumb", thumbnail.Url));
                    }

                    foreach (var poster in posters)
                    {
                        if (poster != null && poster.Url != null)
                        {
                            details.Add(new XElement("thumb", new XAttribute("aspect", "poster"), new XAttribute("preview", poster.Url), poster.Url));
                        }
                    }

                    if (fanarts.Any())
                    {
                        var fanartElement = new XElement("fanart");
                        foreach (var fanart in fanarts)
                        {
                            if (fanart != null && fanart.Url != null)
                            {
                                fanartElement.Add(new XElement("thumb", new XAttribute("preview", fanart.Url), fanart.Url));
                            }
                        }

                        details.Add(fanartElement);
                    }

                    if (movie.Certification.IsNotNullOrWhiteSpace())
                    {
                        details.Add(new XElement("mpaa", movie.Certification));
                    }

                    details.Add(new XElement("playcount"));

                    details.Add(new XElement("lastplayed"));

                    details.Add(new XElement("id", movie.TmdbId));

                    var uniqueId = new XElement("uniqueid", movie.TmdbId);
                    uniqueId.SetAttributeValue("type", "tmdb");
                    uniqueId.SetAttributeValue("default", true);
                    details.Add(uniqueId);

                    if (movie.ImdbId.IsNotNullOrWhiteSpace())
                    {
                        var imdbId = new XElement("uniqueid", movie.ImdbId);
                        imdbId.SetAttributeValue("type", "imdb");
                        details.Add(imdbId);
                    }

                    foreach (var genre in movie.Genres)
                    {
                        details.Add(new XElement("genre", genre));
                    }

                    details.Add(new XElement("country"));

                    if (movie.Collection?.Name != null)
                    {
                        var setElement = new XElement("set");

                        setElement.Add(new XElement("name", movie.Collection.Name));
                        setElement.Add(new XElement("overview"));

                        details.Add(setElement);
                    }

                    var tags = _tagService.GetTags(movie.Tags);

                    foreach (var tag in tags)
                    {
                        details.Add(new XElement("tag", tag.Label));
                    }

                    foreach (var credit in credits)
                    {
                        if (credit.Name != null && credit.Job == "Screenplay")
                        {
                            details.Add(new XElement("credits", credit.Name));
                        }
                    }

                    foreach (var credit in credits)
                    {
                        if (credit.Name != null && credit.Job == "Director")
                        {
                            details.Add(new XElement("director", credit.Name));
                        }
                    }

                    if (movie.InCinemas.HasValue)
                    {
                        details.Add(new XElement("premiered", movie.InCinemas.Value.ToString("yyyy-MM-dd")));
                    }

                    details.Add(new XElement("year", movie.Year));

                    details.Add(new XElement("studio", movie.Studio));

                    details.Add(new XElement("trailer", "plugin://plugin.video.youtube/play/?video_id=" + movie.YouTubeTrailerId));

                    if (movieFile.MediaInfo != null)
                    {
                        var sceneName = movieFile.GetSceneOrFileName();

                        var fileInfo      = new XElement("fileinfo");
                        var streamDetails = new XElement("streamdetails");

                        var video = new XElement("video");
                        video.Add(new XElement("aspect", (float)movieFile.MediaInfo.Width / (float)movieFile.MediaInfo.Height));
                        video.Add(new XElement("bitrate", movieFile.MediaInfo.VideoBitrate));
                        video.Add(new XElement("codec", MediaInfoFormatter.FormatVideoCodec(movieFile.MediaInfo, sceneName)));
                        video.Add(new XElement("framerate", movieFile.MediaInfo.VideoFps));
                        video.Add(new XElement("height", movieFile.MediaInfo.Height));
                        video.Add(new XElement("scantype", movieFile.MediaInfo.ScanType));
                        video.Add(new XElement("width", movieFile.MediaInfo.Width));

                        if (movieFile.MediaInfo.RunTime != default)
                        {
                            video.Add(new XElement("duration", movieFile.MediaInfo.RunTime.TotalMinutes));
                            video.Add(new XElement("durationinseconds", Math.Round(movieFile.MediaInfo.RunTime.TotalSeconds)));
                        }

                        streamDetails.Add(video);

                        var audio             = new XElement("audio");
                        var audioChannelCount = movieFile.MediaInfo.AudioChannelsStream > 0 ? movieFile.MediaInfo.AudioChannelsStream : movieFile.MediaInfo.AudioChannelsContainer;
                        audio.Add(new XElement("bitrate", movieFile.MediaInfo.AudioBitrate));
                        audio.Add(new XElement("channels", audioChannelCount));
                        audio.Add(new XElement("codec", MediaInfoFormatter.FormatAudioCodec(movieFile.MediaInfo, sceneName)));
                        audio.Add(new XElement("language", movieFile.MediaInfo.AudioLanguages));
                        streamDetails.Add(audio);

                        if (movieFile.MediaInfo.Subtitles != null && movieFile.MediaInfo.Subtitles.Length > 0)
                        {
                            var subtitle = new XElement("subtitle");
                            subtitle.Add(new XElement("language", movieFile.MediaInfo.Subtitles));
                            streamDetails.Add(subtitle);
                        }

                        fileInfo.Add(streamDetails);
                        details.Add(fileInfo);

                        foreach (var credit in credits)
                        {
                            if (credit.Name != null && credit.Character != null)
                            {
                                var actorElement = new XElement("actor");

                                actorElement.Add(new XElement("name", credit.Name));
                                actorElement.Add(new XElement("role", credit.Character));
                                actorElement.Add(new XElement("order", credit.Order));

                                var headshot = credit.Images.FirstOrDefault(m => m.CoverType == MediaCoverTypes.Headshot);

                                if (headshot != null && headshot.Url != null)
                                {
                                    actorElement.Add(new XElement("thumb", headshot.Url));
                                }

                                details.Add(actorElement);
                            }
                        }
                    }

                    doc.Add(details);
                    doc.Save(xw);

                    xmlResult += doc.ToString();
                    xmlResult += Environment.NewLine;
                }
            }

            if (Settings.MovieMetadataURL)
            {
                xmlResult += "https://www.themoviedb.org/movie/" + movie.TmdbId;
                xmlResult += Environment.NewLine;

                xmlResult += "https://www.imdb.com/title/" + movie.ImdbId;
                xmlResult += Environment.NewLine;
            }

            var metadataFileName = GetMovieMetadataFilename(movieFile.RelativePath);

            return(string.IsNullOrEmpty(xmlResult) ? null : new MetadataFileResult(metadataFileName, xmlResult.Trim(Environment.NewLine.ToCharArray())));
        }
        public override void Apply(XmlDocument document, string id)
        {
            // only generate IntelliSense if id corresponds to an allowed IntelliSense ID
            if (id.Length < 2 || id[1] != ':')
            {
                return;
            }

            if (!((id[0] == 'T') || (id[0] == 'M') || (id[0] == 'P') ||
                  (id[0] == 'F') || (id[0] == 'E') || (id[0] == 'N')))
            {
                return;
            }

            if ((id[0] == 'N') && id.EndsWith("TocExcluded",
                                              StringComparison.OrdinalIgnoreCase))
            {
                return;
            }

            XPathNavigator root = null;

            if (_rootExpression != null)
            {
                root = document.CreateNavigator().SelectSingleNode(_rootExpression);
            }
            else
            {
                root = document.CreateNavigator();
            }

            // get the assembly information
            string assembly = (string)root.Evaluate(_assemblyExpression);

            if (String.IsNullOrEmpty(assembly))
            {
                assembly = "namespaces";
            }

            // try/catch block for capturing errors
            try
            {
                // get the writer for the assembly
                XmlWriter writer;
                if (!_outputWriters.TryGetValue(assembly, out writer))
                {
                    // create a writer for the assembly
                    string name = Path.Combine(_outputDirectory, assembly + ".xml");

                    XmlWriterSettings settings = new XmlWriterSettings();
                    settings.Indent = true;

                    try
                    {
                        writer = XmlWriter.Create(name, settings);
                    }
                    catch (IOException e)
                    {
                        WriteMessage(MessageLevel.Error, String.Format(
                                         "An access error occurred while attempting to create the IntelliSense output file '{0}'. The error message is: {1}", name, e.Message));
                    }

                    _outputWriters.Add(assembly, writer);

                    // write out the initial data
                    writer.WriteStartDocument();
                    writer.WriteStartElement("doc");
                    //do not generate assembly nodes for namespace topics
                    if (assembly != "namespaces")
                    {
                        writer.WriteStartElement("assembly");
                        writer.WriteElementString("name", assembly);
                        writer.WriteEndElement();
                    }
                    writer.WriteStartElement("members");
                }

                writer.WriteStartElement("member");
                writer.WriteAttributeString("name", id);

                // summary
                WriteSummary(root, _summaryExpression, writer);

                // return value
                XPathNavigator returns = root.SelectSingleNode(_returnsExpression);
                if (returns != null)
                {
                    //writer.WriteStartElement("returns");
                    XmlReader reader = returns.ReadSubtree();

                    CopyContent(reader, writer);
                    reader.Close();

                    //writer.WriteEndElement();
                }

                // parameters
                XPathNodeIterator parameters = root.Select(_paramsExpression);
                foreach (XPathNavigator parameter in parameters)
                {
                    string    name   = String.Empty;
                    XmlReader reader = null;
                    if (_paramContentExpression != null)
                    {
                        name = (string)parameter.GetAttribute("paramName", String.Empty);

                        XPathNavigator parameterContent = parameter.SelectSingleNode(_paramContentExpression);

                        if (parameterContent == null)
                        {
                            continue;
                        }

                        reader = parameterContent.ReadSubtree();
                    }
                    else
                    {
                        name   = (string)parameter.GetAttribute("name", String.Empty);
                        reader = parameter.ReadSubtree();
                    }

                    writer.WriteStartElement("param");
                    writer.WriteAttributeString("name", name);
                    CopyContentEx(reader, writer);
                    writer.WriteFullEndElement();

                    reader.Close();
                }

                // templates
                XPathNodeIterator templates = root.Select(_templatesExpression);
                foreach (XPathNavigator template in templates)
                {
                    string    name   = String.Empty;
                    XmlReader reader = null;
                    if (_templateContentExpression != null)
                    {
                        name = (string)template.GetAttribute("paramName", String.Empty);

                        XPathNavigator templateContent = template.SelectSingleNode(_templateContentExpression);

                        if (templateContent == null)
                        {
                            continue;
                        }

                        reader = templateContent.ReadSubtree();
                    }
                    else
                    {
                        name   = (string)template.GetAttribute("name", String.Empty);
                        reader = template.ReadSubtree();
                    }

                    writer.WriteStartElement("typeparam");
                    writer.WriteAttributeString("name", name);
                    CopyContentEx(reader, writer);
                    writer.WriteFullEndElement();

                    reader.Close();
                }

                // exceptions
                XPathNodeIterator exceptions = root.Select(_exceptionExpression);
                foreach (XPathNavigator exception in exceptions)
                {
                    string cref = String.Empty;
                    if (_exceptionCrefExpression != null) //TODO: Do not know if such case exists
                    {
                        XPathNavigator exceptionCref = exception.SelectSingleNode(_exceptionCrefExpression);

                        if (exceptionCref == null)
                        {
                            continue;
                        }

                        cref = exceptionCref.GetAttribute("target", String.Empty);
                    }
                    else
                    {
                        cref = exception.GetAttribute("cref", String.Empty);
                    }

                    XmlReader reader = exception.ReadSubtree();

                    //writer.WriteStartElement("exception");
                    //writer.WriteAttributeString("cref", cref);
                    CopyContent(reader, writer);
                    //writer.WriteFullEndElement();

                    reader.Close();
                }

                // stored contents
                XPathNavigator input;
                if (_userInputContents != null && _userInputContents.TryGetValue(id, out input))
                {
                    XPathNodeIterator input_nodes = input.SelectChildren(XPathNodeType.Element);
                    foreach (XPathNavigator input_node in input_nodes)
                    {
                        input_node.WriteSubtree(writer);
                    }
                }

                writer.WriteFullEndElement();

                // enumeration members
                XPathNodeIterator enumerationIterator = root.Select(_enumExpression);

                foreach (XPathNavigator enumeration in enumerationIterator)
                {
                    string api = String.Empty;
                    if (_enumApiExpression != null) //TODO: Do not know if such case exists
                    {
                        XPathNavigator enumApi = enumeration.SelectSingleNode(_enumApiExpression);

                        if (enumApi == null)
                        {
                            continue;
                        }

                        api = enumApi.GetAttribute("target", String.Empty);
                    }
                    else
                    {
                        api = enumeration.GetAttribute("api", String.Empty);
                    }
                    writer.WriteStartElement("member");
                    writer.WriteAttributeString("name", api);

                    //summary
                    WriteSummary(enumeration, _memberSummaryExpression, writer);

                    writer.WriteFullEndElement();
                }
            }
            catch (IOException e)
            {
                WriteMessage(MessageLevel.Error, String.Format(
                                 "An access error occurred while attempting to write IntelliSense data. The error message is: {0}", e.Message));
            }
            catch (XmlException e)
            {
                WriteMessage(MessageLevel.Error, String.Format(
                                 "IntelliSense data was not valid XML. The error message is: {0}", e.Message));
            }
        }
Example #47
0
        // [test] Write project file as XML.
        private void WriteProjectFileXml()
        {
            var stream   = new FileStream(ProjectPath + ProjectFileName, FileMode.Create);
            var settings = new XmlWriterSettings()
            {
                NewLineChars = Environment.NewLine,
                Indent       = true,
            };
            var writer = XmlWriter.Create(stream, settings);

            // Root element.
            XElement root = new XElement("Project");

            root.SetAttributeValue("rom", RomFileName);

            // Areas element.
            XElement areasElement = new XElement("Areas");

            for (int n = 0; n < AreaCount; n++)
            {
                XElement area = new XElement("Area");
                area.SetAttributeValue("index", n);
                area.SetAttributeValue("name", AreaNames [n]);
                areasElement.Add(area);
            }
            root.Add(areasElement);

            // Sections element.
            XElement sectionsElement = new XElement("Sections");

            foreach (RomSection s in CurrentRom.Sections)
            {
                XElement section = new XElement("Section");
                section.SetAttributeValue("name", s.Name);
                section.SetAttributeValue("type", s.SectionType.ToString());
                sectionsElement.Add(section);
                // Add data.
                foreach (KeyValuePair <string, IEnumerable <Data> > kv in s.Data)
                {
                    XElement data = new XElement("Data");
                    data.SetAttributeValue("name", kv.Key);
                    section.Add(data);
                }
                // Add blocks.
                foreach (var b in s.Blocks)
                {
                    XElement block = new XElement("Block");
                    block.SetAttributeValue("address", Tools.IntToHex(b.Item1));
                    block.SetAttributeValue("end", Tools.IntToHex(b.Item2));
                    section.Add(block);
                }
            }
            root.Add(sectionsElement);

            // Write room data.
            XElement roomsElement = new XElement("Rooms");

            for (int i = 0; i < AreaCount; i++)
            {
                foreach (Room r in Rooms[i])
                {
                    XElement room = new XElement("Room");
                    room.SetAttributeValue("address", Tools.IntToHex(r.StartAddressPC));
                    room.SetAttributeValue("doorCount", r.MyDoorSet?.DoorCount ?? 0);
                    room.SetAttributeValue("name", r.Name);
                    roomsElement.Add(room);
                }
            }
            root.Add(roomsElement);

            // Write asm data.
            XElement asmElement = new XElement("Asms");

            WriteAsmDataXml(asmElement, "DoorAsm", DoorAsms);
            WriteAsmDataXml(asmElement, "SetupAsm", SetupAsms);
            WriteAsmDataXml(asmElement, "MainAsm", MainAsms);
            root.Add(asmElement);

            // Write background data.
            XElement backgroundsElement = new XElement("Backgrounds");

            foreach (Background b in Backgrounds)
            {
                XElement background = new XElement("Background");
                background.SetAttributeValue("address", Tools.IntToHex(b.StartAddressPC));
                background.SetAttributeValue("name", b.Name);
                backgroundsElement.Add(background);
            }
            root.Add(backgroundsElement);

            root.WriteTo(writer);
            writer.Close();
            stream.Close();
        }
Example #48
0
        /// -----------------------------------------------------------------------------
        /// <summary>
        /// Exports the selected portal
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        /// <remarks>
        /// Template will be saved in Portals\_default folder.
        /// An extension of .template will be added to filename if not entered
        /// </remarks>
        /// <history>
        ///     [VMasanas]	23/09/2004	Created
        ///     [cnurse]	11/08/2004	Addition of files to template
        ///     [aprasad]	1/17/2011	New setting AutoAddPortalAlias
        /// </history>
        /// -----------------------------------------------------------------------------
        private void cmdExport_Click(Object sender, EventArgs e)
        {
            try
            {
                ZipOutputStream resourcesFile;
                var             sb       = new StringBuilder();
                var             settings = new XmlWriterSettings();
                settings.ConformanceLevel   = ConformanceLevel.Fragment;
                settings.OmitXmlDeclaration = true;
                settings.Indent             = true;

                if (!Page.IsValid)
                {
                    return;
                }
                string filename;
                filename = Globals.HostMapPath + txtTemplateName.Text;
                if (!filename.EndsWith(".template"))
                {
                    filename += ".template";
                }
                XmlWriter writer = XmlWriter.Create(filename, settings);

                writer.WriteStartElement("portal");
                writer.WriteAttributeString("version", "5.0");

                //Add template description
                writer.WriteElementString("description", Server.HtmlEncode(txtDescription.Text));

                //Serialize portal settings
                PortalInfo objportal;
                var        objportals = new PortalController();
                objportal = objportals.GetPortal(Convert.ToInt32(cboPortals.SelectedValue));

                writer.WriteStartElement("settings");

                writer.WriteElementString("logofile", objportal.LogoFile);
                writer.WriteElementString("footertext", objportal.FooterText);
                writer.WriteElementString("userregistration", objportal.UserRegistration.ToString());
                writer.WriteElementString("banneradvertising", objportal.BannerAdvertising.ToString());
                writer.WriteElementString("defaultlanguage", objportal.DefaultLanguage);

                Dictionary <string, string> settingsDictionary = PortalController.GetPortalSettingsDictionary(objportal.PortalID);

                string setting = "";
                settingsDictionary.TryGetValue("DefaultPortalSkin", out setting);
                if (!string.IsNullOrEmpty(setting))
                {
                    writer.WriteElementString("skinsrc", setting);
                }
                settingsDictionary.TryGetValue("DefaultAdminSkin", out setting);
                if (!string.IsNullOrEmpty(setting))
                {
                    writer.WriteElementString("skinsrcadmin", setting);
                }
                settingsDictionary.TryGetValue("DefaultPortalContainer", out setting);
                if (!string.IsNullOrEmpty(setting))
                {
                    writer.WriteElementString("containersrc", setting);
                }
                settingsDictionary.TryGetValue("DefaultAdminContainer", out setting);
                if (!string.IsNullOrEmpty(setting))
                {
                    writer.WriteElementString("containersrcadmin", setting);
                }
                settingsDictionary.TryGetValue("EnableSkinWidgets", out setting);
                if (!string.IsNullOrEmpty(setting))
                {
                    writer.WriteElementString("enableskinwidgets", setting);
                }
                settingsDictionary.TryGetValue("portalaliasmapping", out setting);
                if (!String.IsNullOrEmpty(setting))
                {
                    writer.WriteElementString("portalaliasmapping", setting);
                }
                settingsDictionary.TryGetValue("ContentLocalizationEnabled", out setting);
                if (!String.IsNullOrEmpty(setting))
                {
                    writer.WriteElementString("contentlocalizationenabled", setting);
                }
                settingsDictionary.TryGetValue("TimeZone", out setting);
                if (!string.IsNullOrEmpty(setting))
                {
                    writer.WriteElementString("timezone", setting);
                }

                writer.WriteElementString("hostspace", objportal.HostSpace.ToString());
                writer.WriteElementString("userquota", objportal.UserQuota.ToString());
                writer.WriteElementString("pagequota", objportal.PageQuota.ToString());

                //End Portal Settings
                writer.WriteEndElement();

                //Serialize Profile Definitions
                SerializeProfileDefinitions(writer, objportal);

                //Serialize Portal Desktop Modules
                DesktopModuleController.SerializePortalDesktopModules(writer, objportal.PortalID);

                //Serialize Roles
                RoleController.SerializeRoleGroups(writer, objportal.PortalID);

                //Serialize tabs
                SerializeTabs(writer, objportal);

                if (chkContent.Checked)
                {
                    //Create Zip File to hold files
                    resourcesFile = new ZipOutputStream(File.Create(filename + ".resources"));
                    resourcesFile.SetLevel(6);

                    //Serialize folders (while adding files to zip file)
                    SerializeFolders(writer, objportal, ref resourcesFile);

                    //Finish and Close Zip file
                    resourcesFile.Finish();
                    resourcesFile.Close();
                }
                writer.WriteEndElement();

                writer.Close();

                DotNetNuke.UI.Skins.Skin.AddModuleMessage(this, "", string.Format(Localization.GetString("ExportedMessage", LocalResourceFile), filename), ModuleMessage.ModuleMessageType.GreenSuccess);
            }
            catch (Exception exc)
            {
                Exceptions.ProcessModuleLoadException(this, exc);
            }
        }
Example #49
0
        static void Main(string[] args)
        {
            Settings.Load();
            Settings.Save();
            proxy     = new Net.Proxy(8877);
            _handler += new EventHandler(Handler);
            SetConsoleCtrlHandler(_handler, true);

            for (int i = 0; i < args.Length; i++)
            {
                var group = Regex.Match(args[i], "[-]{1,2}(.*)").Groups[1];
                if (group.Success)
                {
                    switch (group.Value)
                    {
                    case "nopatch":
                        PatchPublicKey = false;
                        break;

                    case "showconsole":
                        showConsole = true;
                        break;
                    }
                }
            }

            logger.WriteLine("Made by FailedShack");
            SetConsoleVisibility(showConsole);
            Application.EnableVisualStyles();

            if (Settings.ShowUpdateNag)
            {
                Task.Run(async() =>
                {
                    JObject release;
                    try
                    {
                        release = await GithubUtil.GetRelease("FailedShack", "USBHelperLauncher", "latest");
                    }
                    catch
                    {
                        return;
                    }
                    string newVersion = (string)release["tag_name"];
                    string version    = GetVersion();
                    if (newVersion.CompareTo(version) > 0)
                    {
                        var updateNag       = new CheckboxDialog("New version found: " + newVersion + "\nCurrent version: " + version + "\nDo you want to open the download site?", "Do not show this again.", "Update Checker", MessageBoxButtons.YesNo, MessageBoxIcon.Information);
                        DialogResult result = updateNag.ShowDialog();
                        if (result == DialogResult.Yes)
                        {
                            Process.Start((string)release["html_url"]);
                        }
                        Settings.ShowUpdateNag = !updateNag.Checked;
                        Settings.Save();
                    }
                });
            }

            string hostsFile = GetHostsFile();

            if (File.Exists(hostsFile))
            {
                try
                {
                    Hosts = Hosts.Load(hostsFile);
                }
                catch (Exception e)
                {
                    MessageBox.Show("Could not load hosts file: " + e.Message, "Malformed hosts file", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
            else
            {
                Hosts = new Hosts();
                if (Settings.ShowHostsWarning)
                {
                    var hostsWarning = new CheckboxDialog(
                        "It appears you don't currently have a hosts redirector file. This file may be required to route obsolete hostnames to their correct destination.\n" +
                        "If you intended to use this feature, make sure a file named 'hosts.json' is located in the same directory as this executable.\n" +
                        "You may also use the built-in editor located in the Advanced section in the tray icon's context menu.", "Do not show this again.", "Hosts file missing", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    hostsWarning.ShowDialog();
                    Settings.ShowHostsWarning = !hostsWarning.Checked;
                    Settings.Save();
                }
            }

            try
            {
                database.LoadFromDir(Path.Combine(GetLauncherPath(), "data"));
            }
            catch (FileNotFoundException e)
            {
                MessageBox.Show(e.Message + "\nMake sure this file is under the data directory.", "Initialization error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                Environment.Exit(0);
            }

            if (!File.Exists("ver") || !File.Exists("WiiU_USB_Helper.exe"))
            {
                MessageBox.Show("Could not find Wii U USB Helper, please make sure this executable is in the correct folder.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                Environment.Exit(0);
            }
            helperVersion = File.ReadAllLines("ver")[0];
            int revision = Int32.Parse(helperVersion.Substring(helperVersion.LastIndexOf('.') + 1));

            if (helperVersion.StartsWith("0.6.1"))
            {
                // Workaround to allow it to launch
                if (revision >= 653)
                {
                    string installPath = GetInstallPath();
                    string lastTitles  = Path.Combine(installPath, "lasttitles");
                    if (revision > 653)
                    {
                        string installConfPath = GetInstallConfPath();
                        Directory.CreateDirectory(installConfPath);
                        File.Create(Path.Combine(installConfPath, "user.config")).Close();
                    }
                    if (!File.Exists(lastTitles))
                    {
                        Directory.CreateDirectory(installPath);
                        StringBuilder sb = new StringBuilder();
                        // Rev. 653 minimums: 3 lines, single character each
                        // Revs. 654 & 655 minimums: 25 lines, 16 chars each
                        for (int lines = 0; lines != 25; lines++)
                        {
                            sb.Append('0', 16).AppendLine();
                        }
                        File.WriteAllText(lastTitles, sb.ToString());
                    }
                }
            }

            // Ensure that the cached title key JSON files are valid
            string[] toCheck = { "3FFFD23A80F800ABFCC436A5EC8F7F0B94C728A4", "9C6DD14B8E3530B701BC4F1B77345DADB0C32020" };
            foreach (string file in toCheck)
            {
                string path = Path.Combine(GetInstallPath(), file);
                if (File.Exists(path))
                {
                    try
                    {
                        JToken.Parse(File.ReadAllText(path));
                    }
                    catch (JsonReaderException)
                    {
                        File.Delete(path);
                        logger.WriteLine(string.Format("Removed bad cache file: {0}", file));
                    }
                }
            }

            if (!CertMaker.rootCertExists() && !CertMaker.createRootCert())
            {
                MessageBox.Show("Creation of the interception certificate failed.", "Unable to generate certificate.", MessageBoxButtons.OK, MessageBoxIcon.Error);
                Environment.Exit(0);
            }

            string executable = Path.Combine(GetLauncherPath(), "WiiU_USB_Helper.exe");

            var running = Process.GetProcessesByName("Patched").FirstOrDefault(p => p.GetMainModuleFileName().StartsWith(GetLauncherPath(), StringComparison.OrdinalIgnoreCase));

            if (running != default(Process))
            {
                DialogResult result = MessageBox.Show("An instance of Wii U USB Helper is already running.\nWould you like to close it?", "Already running", MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation);
                if (result == DialogResult.No)
                {
                    Environment.Exit(0);
                }
                running.Kill();
            }

            proxy.Start();
            ServiceHost host = new ServiceHost(typeof(LauncherService), new Uri("net.pipe://localhost/LauncherService"));

            host.AddServiceEndpoint(typeof(ILauncherService), new NetNamedPipeBinding(), "");
            host.Open();

            // Patching
            ProgressDialog dialog = new ProgressDialog();

            dialog.SetStyle(ProgressBarStyle.Marquee);
            dialog.GetProgressBar().MarqueeAnimationSpeed = 30;
            dialog.SetHeader("Injecting...");
            new Thread(() => {
                dialog.ShowDialog();
            }).Start();
            var injector = new ModuleInitInjector(executable);

            executable = Path.Combine(GetLauncherPath(), "Patched.exe");
            injector.Inject(executable);
            logger.WriteLine("Injected module initializer.");
            if (PatchPublicKey)
            {
                dialog.Invoke(new Action(() => dialog.SetHeader("Patching...")));
                RSAPatcher patcher = new RSAPatcher(executable);
                string     xml;
                using (var rsa = new RSACryptoServiceProvider(2048))
                {
                    rsaParams = rsa.ExportParameters(true);
                    xml       = rsa.ToXmlString(false);
                }
                var builder  = new StringBuilder();
                var element  = XElement.Parse(xml);
                var settings = new XmlWriterSettings
                {
                    OmitXmlDeclaration = true,
                    Indent             = true
                };
                using (var xmlWriter = XmlWriter.Create(builder, settings))
                {
                    element.Save(xmlWriter);
                }
                patcher.SetPublicKey(builder.ToString());
                logger.WriteLine("Patched public key.");
            }
            else
            {
                logger.WriteLine("Patching has been disabled.");
            }
            dialog.Invoke(new Action(() => dialog.Close()));

            // Time to launch Wii U USB Helper
            sessionStart = DateTime.UtcNow;
            process      = StartProcess(executable, helperVersion);

            if (Settings.DisableOptionalPatches)
            {
                logger.WriteLine("Optional patches have been disabled.");
            }

            ContextMenu trayMenu   = new ContextMenu();
            MenuItem    dlEmulator = new MenuItem("Download Emulator");

            foreach (EmulatorConfiguration.Emulator emulator in Enum.GetValues(typeof(EmulatorConfiguration.Emulator)))
            {
                EmulatorConfiguration config = EmulatorConfiguration.GetConfiguration(emulator);
                dlEmulator.MenuItems.Add(config.GetName(), (sender, e) => OnDownloadEmulator(config));
            }
            MenuItem advanced = new MenuItem("Advanced");

            advanced.MenuItems.Add("Toggle Console", OnVisibilityChange);
            advanced.MenuItems.Add("Clear Install", OnClearInstall);
            advanced.MenuItems.Add("Generate Donation Key", OnGenerateKey).Enabled = PatchPublicKey;
            advanced.MenuItems.Add("Hosts Editor", OnOpenHostsEditor);
            advanced.MenuItems.Add("Export Sessions", OnExportSessions);
            trayMenu.MenuItems.Add("Exit", OnExit);
            trayMenu.MenuItems.Add("Check for Updates", OnUpdateCheck);
            trayMenu.MenuItems.Add("Report Issue", OnDebugMessage);
            trayMenu.MenuItems.Add(dlEmulator);
            trayMenu.MenuItems.Add(advanced);
            trayIcon             = new NotifyIcon();
            trayIcon.Text        = "Wii U USB Helper Launcher";
            trayIcon.Icon        = Icon.ExtractAssociatedIcon(Application.ExecutablePath);
            trayIcon.ContextMenu = trayMenu;
            trayIcon.Visible     = true;
            backgroundThread     = new Thread(() =>
            {
                Thread.CurrentThread.IsBackground = true;
                while (!process.HasExited)
                {
                    try
                    {
                        Thread.Sleep(30);
                    }
                    catch (ThreadInterruptedException) { }
                }
                Cleanup();
                Application.Exit();
            });
            backgroundThread.Start();
            Application.Run();
        }
 public RssFormatter(IEnumerable <ISyndicationAttribute> knownAttributes, XmlWriterSettings settings)
 {
     _buffer = new StringBuilder();
     _writer = XmlUtils.CreateXmlWriter(settings?.Clone() ?? new XmlWriterSettings(), knownAttributes, _buffer);
 }
Example #51
0
        static void Merge()
        {
            string outpath = Path.Combine(Environment.CurrentDirectory, "result.xml");

            outpath = cl.GetPath(outpath, "out", "output");

            string input = cl.GetPath(Environment.CurrentDirectory, "in", "input");
            string ext   = cl.GetOption(null, "ext");

            if (string.IsNullOrEmpty(ext))
            {
                ext = "xml";
            }
            else
            {
                if (ext[0] == '.')
                {
                    ext = ext.Substring(1);
                }
            }

            var docs = new List <XmlDocument>();

            foreach (var docpath in Directory.GetFiles(input, "*." + ext))
            {
                try
                {
                    var doc = new XmlDocument();
                    doc.Load(docpath);
                    docs.Add(doc);
                }
                catch (XmlException exc)
                {
                    Console.WriteLine("{0} ({1})", docpath, exc.LineNumber);
                    throw;
                }
            }

            string xpath = cl.GetOption(null, "xpath");
            string root  = cl.GetOption("root", "root", "root-name");

            var xws = new XmlWriterSettings {
                Indent = true, IndentChars = "  "
            };

            using (XmlWriter writer = XmlWriter.Create(outpath, xws))
            {
                writer.WriteStartDocument();
                writer.WriteStartElement(root);

                foreach (var doc in docs)
                {
                    if (string.IsNullOrEmpty(xpath))
                    {
                        doc.DocumentElement.WriteTo(writer);
                    }
                    else
                    {
                        try
                        {
                            var sel = doc.SelectNodes(xpath);
                            foreach (XmlNode node in sel)
                            {
                                node.WriteTo(writer);
                            }
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine(e);
                            Environment.Exit(-1);
                        }
                    }
                }

                writer.WriteEndElement();
                writer.WriteEndDocument();
            }
        }
Example #52
0
        static int Main()
        {
            var depDir   = Path.Combine("..", "external", "benchmarker");
            var benchDir = Path.Combine(depDir, "benchmarks");
            var testDir  = Path.Combine(depDir, "tests");

            var benchmarks = Directory.EnumerateFiles(benchDir, "*.benchmark")
                             .Select(Benchmark.Load)
                             .Where(b => !b.OnlyExplicit && b.ClientCommandLine == null && IsSupported(b))
                             .OrderBy(b => b.Name)
                             .ToArray();

            var monoPath = Path.GetFullPath(Path.Combine("..", "..", "runtime", "mono-wrapper"));
            var classDir = Path.GetFullPath(Path.Combine("..", "..", "mcs", "class", "lib", "net_4_x"));

            var rand = new Random();
            var cpus = Environment.ProcessorCount;

            var results = new List <TestResult> (benchmarks.Length);

            var sw = Stopwatch.StartNew();

            for (var i = 0; i < benchmarks.Length; i++)
            {
                var bench = benchmarks [i];

                var sampleFreq   = rand.Next(-1000, 1001);
                var sampleMode   = rand.Next(0, 2) == 1 ? "-real" : string.Empty;
                var maxSamples   = rand.Next(0, cpus * 2000 + 1);
                var heapShotFreq = rand.Next(-10, 11);
                var maxFrames    = rand.Next(0, 33);
                var options      = _options.ToDictionary(x => x, _ => rand.Next(0, 2) == 1)
                                   .Select(x => (x.Value ? string.Empty : "no") + x.Key)
                                   .ToArray();

                var profOptions = $"maxframes={maxFrames},{string.Join (",", options)},output=/dev/null";

                if (sampleFreq > 0)
                {
                    profOptions += $",sample{sampleMode}={sampleFreq},maxsamples={maxSamples}";
                }

                if (heapShotFreq > 0)
                {
                    profOptions += $",heapshot={heapShotFreq}gc";
                }

                var info = new ProcessStartInfo {
                    UseShellExecute        = false,
                    WorkingDirectory       = Path.Combine(testDir, bench.TestDirectory),
                    FileName               = monoPath,
                    Arguments              = $"--debug --profile=log:{profOptions} " + string.Join(" ", bench.CommandLine),
                    RedirectStandardOutput = true,
                    RedirectStandardError  = true,
                };

                info.EnvironmentVariables.Clear();
                info.EnvironmentVariables.Add("MONO_PATH", classDir);

                var progress = $"({i + 1}/{benchmarks.Length})";

                Console.ForegroundColor = ConsoleColor.Blue;
                Console.WriteLine($"[{sw.Elapsed.ToString ("G")}] {progress} Running {bench.Name} with profiler options: {profOptions}");
                Console.ResetColor();

                var result = new TestResult {
                    Benchmark = bench,
                    StartInfo = info,
                };

                using (var proc = new Process()) {
                    proc.StartInfo = info;

                    var stdout = new StringBuilder();
                    var stderr = new StringBuilder();

                    proc.OutputDataReceived += (sender, args) => {
                        if (args.Data != null)
                        {
                            lock (result)
                                stdout.AppendLine(args.Data);
                        }
                    };

                    proc.ErrorDataReceived += (sender, args) => {
                        if (args.Data != null)
                        {
                            lock (result)
                                stderr.AppendLine(args.Data);
                        }
                    };

                    result.Stopwatch.Start();

                    proc.Start();

                    proc.BeginOutputReadLine();
                    proc.BeginErrorReadLine();

                    if (!proc.WaitForExit((int)_timeout.TotalMilliseconds))
                    {
                        // Force a thread dump.
                        Syscall.kill(proc.Id, Signum.SIGQUIT);
                        Thread.Sleep(1000);

                        try {
                            proc.Kill();
                        } catch (Exception) {
                        }
                    }
                    else
                    {
                        result.ExitCode = proc.ExitCode;
                    }

                    result.Stopwatch.Stop();

                    lock (result) {
                        result.StandardOutput = stdout.ToString();
                        result.StandardError  = stderr.ToString();
                    }
                }

                var resultStr = result.ExitCode == null ? "timed out" : $"exited with code: {result.ExitCode}";

                Console.ForegroundColor = result.ExitCode != 0 ? ConsoleColor.Red : ConsoleColor.Green;
                Console.WriteLine($"[{sw.Elapsed.ToString ("G")}] {progress} {bench.Name} took {result.Stopwatch.Elapsed.ToString ("G")} and {resultStr}");
                Console.ResetColor();

                if (result.ExitCode != 0)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine("===== stdout =====");
                    Console.ResetColor();

                    Console.WriteLine(result.StandardOutput);

                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine("===== stderr =====");
                    Console.ResetColor();

                    Console.WriteLine(result.StandardError);
                }

                results.Add(result);
            }

            sw.Stop();

            var successes = results.Count(r => r.ExitCode == 0);
            var failures  = results.Count(r => r.ExitCode != null && r.ExitCode != 0);
            var timeouts  = results.Count(r => r.ExitCode == null);

            var settings = new XmlWriterSettings {
                NewLineOnAttributes = true,
                Indent = true,
            };

            using (var writer = XmlWriter.Create("TestResult-profiler-stress.xml", settings)) {
                writer.WriteStartDocument();
                writer.WriteComment("This file represents the results of running a test suite");

                writer.WriteStartElement("test-results");
                writer.WriteAttributeString("name", "profiler-stress-tests.dummy");
                writer.WriteAttributeString("total", results.Count.ToString());
                writer.WriteAttributeString("failures", failures.ToString());
                writer.WriteAttributeString("not-run", "0");
                writer.WriteAttributeString("date", DateTime.Now.ToString("yyyy-MM-dd"));
                writer.WriteAttributeString("time", DateTime.Now.ToString("HH:mm:ss"));

                writer.WriteStartElement("environment");
                writer.WriteAttributeString("nunit-version", "2.4.8.0");
                writer.WriteAttributeString("clr-version", Environment.Version.ToString());
                writer.WriteAttributeString("os-version", Environment.OSVersion.ToString());
                writer.WriteAttributeString("platform", Environment.OSVersion.Platform.ToString());
                writer.WriteAttributeString("cwd", Environment.CurrentDirectory);
                writer.WriteAttributeString("machine-name", Environment.MachineName);
                writer.WriteAttributeString("user", Environment.UserName);
                writer.WriteAttributeString("user-domain", Environment.UserDomainName);
                writer.WriteEndElement();

                writer.WriteStartElement("culture-info");
                writer.WriteAttributeString("current-culture", CultureInfo.CurrentCulture.Name);
                writer.WriteAttributeString("current-uiculture", CultureInfo.CurrentUICulture.Name);
                writer.WriteEndElement();

                writer.WriteStartElement("test-suite");
                writer.WriteAttributeString("name", "profiler-stress-tests.dummy");
                writer.WriteAttributeString("success", (failures + timeouts == 0).ToString());
                writer.WriteAttributeString("time", ((int)sw.Elapsed.TotalSeconds).ToString());
                writer.WriteAttributeString("asserts", (failures + timeouts).ToString());
                writer.WriteStartElement("results");

                writer.WriteStartElement("test-suite");
                writer.WriteAttributeString("name", "MonoTests");
                writer.WriteAttributeString("success", (failures + timeouts == 0).ToString());
                writer.WriteAttributeString("time", ((int)sw.Elapsed.TotalSeconds).ToString());
                writer.WriteAttributeString("asserts", (failures + timeouts).ToString());
                writer.WriteStartElement("results");

                writer.WriteStartElement("test-suite");
                writer.WriteAttributeString("name", "profiler-stress");
                writer.WriteAttributeString("success", (failures + timeouts == 0).ToString());
                writer.WriteAttributeString("time", ((int)sw.Elapsed.TotalSeconds).ToString());
                writer.WriteAttributeString("asserts", (failures + timeouts).ToString());
                writer.WriteStartElement("results");

                foreach (var result in results)
                {
                    var timeoutStr = result.ExitCode == null ? "_timeout" : string.Empty;

                    writer.WriteStartElement("test-case");
                    writer.WriteAttributeString("name", $"MonoTests.profiler-stress.{result.Benchmark.Name}{timeoutStr}");
                    writer.WriteAttributeString("executed", "True");
                    writer.WriteAttributeString("success", (result.ExitCode == 0).ToString());
                    writer.WriteAttributeString("time", ((int)result.Stopwatch.Elapsed.TotalSeconds).ToString());
                    writer.WriteAttributeString("asserts", result.ExitCode == 0 ? "0" : "1");

                    if (result.ExitCode != 0)
                    {
                        writer.WriteStartElement("failure");

                        writer.WriteStartElement("message");
                        writer.WriteCData(ReplaceInvalidXmlChars(result.StandardOutput));
                        writer.WriteEndElement();

                        writer.WriteStartElement("stack-trace");
                        writer.WriteCData(ReplaceInvalidXmlChars(result.StandardError));
                        writer.WriteEndElement();

                        writer.WriteEndElement();
                    }

                    writer.WriteEndElement();
                }

                writer.WriteEndElement();
                writer.WriteEndElement();

                writer.WriteEndElement();
                writer.WriteEndElement();

                writer.WriteEndElement();
                writer.WriteEndElement();

                writer.WriteEndElement();

                writer.WriteEndDocument();
            }

            var failureStr = failures + timeouts != 0 ? $" ({failures} failures, {timeouts} timeouts)" : string.Empty;

            Console.ForegroundColor = failures + timeouts != 0 ? ConsoleColor.Red : ConsoleColor.Green;
            Console.WriteLine($"[{sw.Elapsed.ToString ("G")}] Finished with {successes}/{results.Count} passing tests{failureStr}");
            Console.ResetColor();

            return(failures + timeouts);
        }
Example #53
0
        /// <summary>
        /// Adds a file, along with its attributes. If the file already exists then it will
        /// be overwritten and its attributes will be replaced.
        /// </summary>
        /// <param name="sysAttrs">Collection of system attributes to be associated with the
        /// file. This can be null if desired to create the file with an empty list of
        /// system attributes.</param>
        /// /// <param name="usrAttrs">Collection of user attributes to be associated with the
        /// file. This can be null if desired to create the file with an empty list of
        /// user attributes.</param>
        public bool AddFile(string fileName, Stream data,
                            Dictionary <string, string> sysAttrs,
                            Dictionary <string, string> usrAttrs)
        {
            // We don't allow subdirectories or absolute paths. We need just a file
            // name with no slashes.
            if (fileName.Contains('\\') || fileName.Contains('/'))
            {
                return(false);
            }

            string path     = DataFilesPath;
            string filePath = Path.Combine(path, fileName);

            if (!System.IO.Directory.Exists(path))
            {
                System.IO.Directory.CreateDirectory(path);
            }
            if (!System.IO.Directory.Exists(AttrFilesPath))
            {
                System.IO.Directory.CreateDirectory(AttrFilesPath);
            }

            // Get the file name for the attributes file
            string attrFileName = AttributableFileCollection.GetAttrFileName(AttrFilesPath, fileName);

            // Create the XML file for the attributes
            XmlWriterSettings settings = new XmlWriterSettings()
            {
                CloseOutput  = true,
                Indent       = true,
                NewLineChars = "\n",
            };
            XmlWriter writer = null;

            try { writer = XmlWriter.Create(attrFileName, settings); }
            catch (Exception)
            {
                writer = null;
            }
            if (null == writer)
            {
                return(false);
            }

            // Write the attribute data
            writer.WriteStartElement("osblefileattributes");
            // System attributes first
            writer.WriteStartElement("systemattributes");
            WriteElements(writer, sysAttrs);
            writer.WriteEndElement();
            // Then user attributes
            writer.WriteStartElement("userattributes");
            WriteElements(writer, usrAttrs);
            writer.WriteEndElement();
            writer.WriteEndElement();
            // Close
            writer.Close();

            bool retVal = true;

            try
            {
                FileStream output = System.IO.File.Open(filePath, FileMode.Create);
                data.CopyTo(output);
                output.Close();
                output.Dispose();
            }
            catch (Exception)
            {
                retVal = false;
            }

            // If we wrote the attribute data but not the file data then we want
            // to delete the attribute file
            if (!retVal)
            {
                if (System.IO.File.Exists(attrFileName))
                {
                    System.IO.File.Delete(attrFileName);
                }
            }

            return(retVal);
        }
Example #54
0
        public void WriteXml(Stream outputStream)
        {
            if (null == outputStream)
            {
                throw new ArgumentNullException("outputStream");
            }

            XmlWriterSettings settings = new XmlWriterSettings
            {
                Indent = true
            };

            using (XmlWriter writer = XmlWriter.Create(outputStream, settings))
            {
                writer.WriteStartElement("Profile");

                writer.WriteStartElement("Id");
                writer.WriteValue(Id.ToString());
                writer.WriteEndElement();

                if (!string.IsNullOrWhiteSpace(_name))
                {
                    writer.WriteStartElement("Name");
                    writer.WriteValue(_name.Trim());
                    writer.WriteEndElement();
                }

                writer.WriteStartElement("Generation");
                writer.WriteValue(Generation);
                writer.WriteEndElement();

                if (ParentA.HasValue)
                {
                    writer.WriteStartElement("ParentA");
                    writer.WriteValue(ParentA.ToString());
                    writer.WriteEndElement();
                }

                if (ParentB.HasValue)
                {
                    writer.WriteStartElement("ParentB");
                    writer.WriteValue(ParentB.ToString());
                    writer.WriteEndElement();
                }


                writer.WriteStartElement("EloRating");
                writer.WriteValue(EloRating);
                writer.WriteEndElement();

                writer.WriteStartElement("Wins");
                writer.WriteValue(Wins);
                writer.WriteEndElement();

                writer.WriteStartElement("Losses");
                writer.WriteValue(Losses);
                writer.WriteEndElement();

                writer.WriteStartElement("Draws");
                writer.WriteValue(Draws);
                writer.WriteEndElement();

                writer.WriteStartElement("Creation");
                writer.WriteValue(CreationTimestamp);
                writer.WriteEndElement();

                writer.WriteStartElement("LastUpdated");
                writer.WriteValue(LastUpdatedTimestamp);
                writer.WriteEndElement();

                writer.WriteStartElement("StartMetricWeights");

                MetricWeights.IterateOverWeights((bugType, bugTypeWeight) =>
                {
                    string key   = MetricWeights.GetKeyName(bugType, bugTypeWeight);
                    double value = StartMetricWeights.Get(bugType, bugTypeWeight);

                    writer.WriteStartElement(key);
                    writer.WriteValue(value);
                    writer.WriteEndElement();
                });

                writer.WriteEndElement(); // </StartMetricWeights>

                writer.WriteStartElement("EndMetricWeights");

                MetricWeights.IterateOverWeights((bugType, bugTypeWeight) =>
                {
                    string key   = MetricWeights.GetKeyName(bugType, bugTypeWeight);
                    double value = EndMetricWeights.Get(bugType, bugTypeWeight);

                    writer.WriteStartElement(key);
                    writer.WriteValue(value);
                    writer.WriteEndElement();
                });

                writer.WriteEndElement(); // </EndMetricWeights>

                writer.WriteEndElement(); // </Profile>
            }
        }
Example #55
0
        public static bool GenerateManufacturingLabel(string labelShippingData, string labelClass, string printerName, string numberOfCopies)
        {
            bool labelPrinted = false;

            string xmlOutputPath = "";
            string labelFileName = "";
            string dataFileName  = "";

            XmlWriterSettings setting = new XmlWriterSettings();

            setting.ConformanceLevel = ConformanceLevel.Auto;
            setting.Encoding         = Encoding.UTF8;
            setting.Indent           = true;

            if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Development")
            {
                xmlOutputPath = @"S:\";
            }
            else if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Production")
            {
                xmlOutputPath = @"C:\BarTender\Scan\";
            }
            else
            {
                xmlOutputPath = @"C:\BarTender\Scan\";
            }

            //determine which label format to use

            if (labelClass == "101")
            {
                labelFileName = "101 Manufacturing Case Label (Warranty) DataMax DMX-I4208.btw";
                dataFileName  = "101 Manufacturing Case Label (Warranty)";
            }
            else if (labelClass == "102")
            {
                labelFileName = "102 Manufacturing Stocking Label Zebra LP2844.btw";
                dataFileName  = "102 Manufacturing Stocking";
            }
            else if (labelClass == "103")
            {
                labelFileName = "103 Manufacturing MM Stocking Label Zebra LP2844.btw";
                dataFileName  = "103 Manufacturing MM Stocking";
            }
            else if (labelClass == "104")
            {
                labelFileName = "104 Manufacturing Large Blank Bin Label Zebra LP2844.btw";
                dataFileName  = "104 Manufacturing Large Blank Bin";
            }
            else if (labelClass == "105")
            {
                labelFileName = "105 Manufacturing Large Bin Label Zebra LP2844.btw";
                dataFileName  = "105 Manufacturing Large Bin";
            }
            else if (labelClass == "106")
            {
                labelFileName = "106 Manufacturing Large Bin With Cell Label Zebra LP2844.btw";
                dataFileName  = "106 Manufacturing Large Bin With Cell";
            }
            else if (labelClass == "107")
            {
                labelFileName = "107 Manufacturing Small Bin With Cell Label Zebra LP2844.btw";
                dataFileName  = "107 Manufacturing Small Bin With Cell";
            }
            else if (labelClass == "108")
            {
                labelFileName = "108 Manufacturing Small Blank Bin Label Zebra LP2844.btw";
                dataFileName  = "108 Manufacturing Small Blank Bin";
            }
            else if (labelClass == "109")
            {
                labelFileName = "109 Manufacturing String Stop Label Zebra LP2844.btw";
                dataFileName  = "109 Manufacturing String Stop";

                System.Diagnostics.Debug.WriteLine(labelShippingData);
            }
            else
            {
            }

            if (labelClass == "109")
            {
                using (XmlWriter writer = XmlWriter.Create(xmlOutputPath + labelClass + " " + DateTime.Now.ToString("yyyyMMddHHmmssFFF") + ".xml", setting))
                {
                    writer.WriteProcessingInstruction("xml", @"version=""1.0"" encoding=""UTF-8""");
                    writer.WriteStartElement("XMLScript");
                    writer.WriteAttributeString("Version", @"2.0");
                    writer.WriteStartElement("Command");
                    writer.WriteAttributeString("Name", @"Job1");
                    writer.WriteStartElement("Print");
                    writer.WriteElementString("Format", @"C:\BarTender\BTW\100\" + labelFileName);
                    writer.WriteStartElement("NamedSubString");
                    writer.WriteAttributeString("Name", $"Text");
                    writer.WriteStartElement("Value");
                    writer.WriteCData($"{labelShippingData}");
                    writer.WriteEndElement(); //</Value>
                    writer.WriteEndElement(); //</NamedSubString>
                    writer.WriteStartElement("PrintSetup");
                    writer.WriteElementString("Printer", $"{printerName}");
                    writer.WriteElementString("IdenticalCopiesOfLabel", numberOfCopies);
                    writer.WriteEndElement(); //</PrintSetup>
                    writer.WriteEndElement(); //</Print>
                    writer.WriteEndElement(); //</Command>
                    writer.WriteEndElement(); //</XMLScript>
                    writer.Flush();
                    writer.Close();
                }
            }
            else
            {
                using (XmlWriter writer = XmlWriter.Create(xmlOutputPath + labelClass + " " + DateTime.Now.ToString("yyyyMMddHHmmssFFF") + ".xml", setting))
                {
                    writer.WriteProcessingInstruction("xml", @"version=""1.0"" encoding=""UTF-8""");
                    writer.WriteStartElement("XMLScript");
                    writer.WriteAttributeString("Version", @"2.0");
                    writer.WriteStartElement("Command");
                    writer.WriteAttributeString("Name", @"Job1");
                    writer.WriteStartElement("Print");
                    writer.WriteElementString("Format", @"C:\BarTender\BTW\100\" + labelFileName);
                    writer.WriteStartElement("RecordSet");
                    writer.WriteAttributeString("Name", $"{dataFileName}");
                    writer.WriteAttributeString("Type", @"btTextFile");
                    writer.WriteElementString("Delimitation", "btDelimCustom");
                    writer.WriteElementString("FieldDelimiter", "|");
                    writer.WriteElementString("UseFieldNamesFromFirstRecord", "true");
                    writer.WriteStartElement("TextData");
                    writer.WriteCData($"{labelShippingData}");
                    writer.WriteEndElement(); //</TextData>
                    writer.WriteEndElement(); //</RecordSet>
                    writer.WriteStartElement("PrintSetup");
                    writer.WriteElementString("Printer", $"{printerName}");
                    writer.WriteElementString("IdenticalCopiesOfLabel", numberOfCopies);
                    writer.WriteEndElement(); //</PrintSetup>
                    writer.WriteEndElement(); //</Print>
                    writer.WriteEndElement(); //</Command>
                    writer.WriteEndElement(); //</XMLScript>
                    writer.Flush();
                    writer.Close();
                }
            }

            //put some error handling here

            labelPrinted = true;

            return(labelPrinted);
        }
Example #56
0
        /// <summary>
        /// Simulate a Base64 encoded XML Request
        /// </summary>
        /// <param name="id"></param>
        /// <param name="issueInstant"></param>
        /// <param name="consumeUrl"></param>
        /// <param name="issuer"></param>
        /// <param name="nameIdFormat"></param>
        /// <returns></returns>
        public string XmlRequestBase64Encoded(string id, string issueInstant, string consumeUrl = null, string issuer = null, string nameIdFormat = null)
        {
            // Default values
            if (string.IsNullOrEmpty(consumeUrl))
            {
                consumeUrl = MnoHelper.Sso.ConsumeUrl();
            }
            if (string.IsNullOrEmpty(nameIdFormat))
            {
                nameIdFormat = MnoHelper.Sso.NameIdFormat;
            }
            if (string.IsNullOrEmpty(issuer))
            {
                issuer = MnoHelper.Api.Id;
            }

            using (StringWriter sw = new StringWriter())
            {
                XmlWriterSettings xws = new XmlWriterSettings();
                xws.OmitXmlDeclaration = true;

                using (XmlWriter xw = XmlWriter.Create(sw, xws))
                {
                    xw.WriteStartElement("samlp", "AuthnRequest", "urn:oasis:names:tc:SAML:2.0:protocol");
                    xw.WriteAttributeString("ID", id);
                    xw.WriteAttributeString("Version", "2.0");
                    xw.WriteAttributeString("IssueInstant", issueInstant);
                    xw.WriteAttributeString("ProtocolBinding", "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST");
                    xw.WriteAttributeString("AssertionConsumerServiceURL", consumeUrl);

                    xw.WriteStartElement("saml", "Issuer", "urn:oasis:names:tc:SAML:2.0:assertion");
                    xw.WriteString(issuer);
                    xw.WriteEndElement();

                    xw.WriteStartElement("samlp", "NameIDPolicy", "urn:oasis:names:tc:SAML:2.0:protocol");
                    xw.WriteAttributeString("Format", nameIdFormat);
                    xw.WriteAttributeString("AllowCreate", "true");
                    xw.WriteEndElement();

                    xw.WriteStartElement("samlp", "RequestedAuthnContext", "urn:oasis:names:tc:SAML:2.0:protocol");
                    xw.WriteAttributeString("Comparison", "exact");

                    xw.WriteStartElement("saml", "AuthnContextClassRef", "urn:oasis:names:tc:SAML:2.0:assertion");
                    xw.WriteString("urn:oasis:names:tc:SAML:2.0:ac:classes:PasswordProtectedTransport");
                    xw.WriteEndElement();

                    xw.WriteEndElement();

                    xw.WriteEndElement();
                }

                // Encode in base64 and compress
                byte[] bytes = System.Text.ASCIIEncoding.ASCII.GetBytes(sw.ToString());

                using (var output = new MemoryStream())
                {
                    using (var zip = new DeflateStream(output, CompressionMode.Compress))
                    {
                        zip.Write(bytes, 0, bytes.Length);
                    }
                    return(Convert.ToBase64String(output.ToArray()));
                }
            }
        }
Example #57
0
        public static bool GenerateManufacturingBowCaseLabel(string labelShippingData, string printerName)
        {
            bool labelPrinted = false;

            string xmlOutputPath = "";
            string labelFileName = "";
            string dataFileName  = "";
            string labelClass    = "";

            XmlWriterSettings setting = new XmlWriterSettings();

            setting.ConformanceLevel = ConformanceLevel.Auto;
            setting.Encoding         = Encoding.UTF8;
            setting.Indent           = true;

            if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Development")
            {
                xmlOutputPath = @"S:\";
            }
            else if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") == "Production")
            {
                xmlOutputPath = @"C:\BarTender\Scan\";
            }
            else
            {
                xmlOutputPath = @"C:\BarTender\Scan\";
            }

            //
            labelClass    = "100";
            labelFileName = "100 Manufacturing Bow Case Label Zebra GX420D.btw";
            dataFileName  = "100 Manufacturing Bow Case Label";

            using (XmlWriter writer = XmlWriter.Create(xmlOutputPath + labelClass + " " + DateTime.Now.ToString("yyyyMMddHHmmssFFF") + ".xml", setting))
            {
                writer.WriteProcessingInstruction("xml", @"version=""1.0"" encoding=""UTF-8""");
                writer.WriteStartElement("XMLScript");
                writer.WriteAttributeString("Version", @"2.0");
                writer.WriteStartElement("Command");
                writer.WriteAttributeString("Name", @"Job1");
                writer.WriteStartElement("Print");
                writer.WriteElementString("Format", @"C:\BarTender\BTW\100\" + labelFileName);
                writer.WriteStartElement("RecordSet");
                writer.WriteAttributeString("Name", $"{dataFileName}");
                writer.WriteAttributeString("Type", @"btTextFile");
                writer.WriteElementString("Delimitation", "btDelimCustom");
                writer.WriteElementString("FieldDelimiter", "|");
                writer.WriteElementString("UseFieldNamesFromFirstRecord", "true");
                writer.WriteStartElement("TextData");
                writer.WriteCData($"{labelShippingData}");
                writer.WriteEndElement(); //</TextData>
                writer.WriteEndElement(); //</RecordSet>
                writer.WriteStartElement("PrintSetup");
                writer.WriteElementString("Printer", $"{printerName}");
                writer.WriteElementString("IdenticalCopiesOfLabel", "1");
                writer.WriteEndElement(); //</PrintSetup>
                writer.WriteEndElement(); //</Print>
                writer.WriteEndElement(); //</Command>
                writer.WriteEndElement(); //</XMLScript>
                writer.Flush();
                writer.Close();
            }

            //put some error handling here

            labelPrinted = true;

            return(labelPrinted);
        }
Example #58
0
        public static void MultiExportLibrary(ObjectFileDefinition objectFileDef,
                                              string basePath,
                                              string outputPath,
                                              InfoManager infoManager,
                                              BinaryObjectFile bof)
        {
            var settings = new XmlWriterSettings
            {
                Encoding           = Encoding.UTF8,
                Indent             = true,
                CheckCharacters    = false,
                OmitXmlDeclaration = false
            };

            var objectDef = objectFileDef != null ? objectFileDef.Object : null;

            using (var writer = XmlWriter.Create(outputPath, settings))
            {
                writer.WriteStartDocument();

                var root  = bof.Root;
                var chain = new[] { root };
                {
                    writer.WriteStartElement("object");
                    writer.WriteAttributeString("name", "lib");

                    if (objectFileDef != null &&
                        string.IsNullOrEmpty(objectFileDef.Name) == false)
                    {
                        writer.WriteAttributeString("def", objectFileDef.Name);
                    }

                    Directory.CreateDirectory(basePath);

                    var itemNames = new Dictionary <string, int>();

                    foreach (var item in root.Children)
                    {
                        var itemDef = objectDef != null
                                          ? objectDef.GetObjectDefinition(item.NameHash, null)
                                          : null;

                        var itemName =
                            FieldTypeDeserializers.Deserialize <string>(FieldType.String,
                                                                        item.Fields[TextHidNameHash]);
                        itemName = itemName.Replace('/', Path.DirectorySeparatorChar);
                        itemName = itemName.Replace('\\', Path.DirectorySeparatorChar);

                        if (itemNames.ContainsKey(itemName) == false)
                        {
                            itemNames.Add(itemName, 1);
                        }
                        else
                        {
                            itemName = string.Format("{0} ({1})", itemName, ++itemNames[itemName]);
                        }

                        var itemPath = itemName + ".xml";

                        writer.WriteStartElement("object");
                        writer.WriteAttributeString("external", itemPath);
                        writer.WriteEndElement();

                        itemPath = Path.Combine(basePath, itemPath);

                        var itemParentPath = Path.GetDirectoryName(itemPath);
                        if (string.IsNullOrEmpty(itemParentPath) == false)
                        {
                            Directory.CreateDirectory(itemParentPath);
                        }

                        using (var itemWriter = XmlWriter.Create(itemPath, settings))
                        {
                            itemWriter.WriteStartDocument();
                            WriteNode(infoManager,
                                      itemWriter,
                                      chain,
                                      item,
                                      itemDef,
                                      null);
                            itemWriter.WriteEndDocument();
                        }
                    }
                }

                writer.WriteEndDocument();
            }
        }
Example #59
0
        /*public Boolean ReserveRoom(String r,int floor)
        {
           Boolean str= c.ReserveRoom(r,floor);
            return str;
        }
        */

        public int WriteHotelRooms(String room)
        {
            int floorno = 1;
            int roomno = 1;
            int roomlimit = 0;
            if (room.Equals("Standard"))
            {
                floorno = 1;
                roomno = 1;
                roomlimit = 10;
            }
            else if (room.Equals("Moderate"))
            {
                floorno = 1;
                roomno = 11;
                roomlimit = 20;
            }
            else if (room.Equals("Superior"))
            {
                floorno = 1;
                roomno = 21;
                roomlimit = 30;
            }
            else if (room.Equals("Junior Suite"))
            {
                floorno = 1;
                roomno = 31;
                roomlimit = 40;
            }
            else if (room.Equals("Suite"))
            {
                floorno = 1;
                roomno = 41;
                roomlimit = 50;
            }
            else
                return 0;
            String r = room + ".xml";
            Console.WriteLine(r);

            for (; floorno <= 5; floorno++)
            {
                for (; roomno <= roomlimit; roomno++)
                {
//                    Console.WriteLine("yes");

                    if (File.Exists(r) == false)
                    {
                        //                      Console.WriteLine("yesss");

                        XmlWriterSettings xmlWriterSettings = new XmlWriterSettings();
                        xmlWriterSettings.Indent = true;
                        xmlWriterSettings.NewLineOnAttributes = true;
                        using (XmlWriter xmlWriter = XmlWriter.Create(r, xmlWriterSettings))
                        {
//                            Console.WriteLine("ysss");

                            xmlWriter.WriteStartDocument();
                            xmlWriter.WriteStartElement("Hotel");

                            xmlWriter.WriteStartElement("Customer");
                            xmlWriter.WriteElementString("Name", "");
                            //xmlWriter.WriteElementString("Age", "");
                            //xmlWriter.WriteElementString("Gender", "");
                            xmlWriter.WriteElementString("IDCardNo", "");
                            //xmlWriter.WriteElementString("BalanceRs", "");
                            //xmlWriter.WriteElementString("DaysReserve", "");
                            xmlWriter.WriteElementString("FloorNo", floorno.ToString());
                            //xmlWriter.WriteElementString("RoomType", "Standard");
                            xmlWriter.WriteElementString("Roomno", roomno.ToString());
                            // xmlWriter.WriteElementString("CheckInTime", "");
                            // xmlWriter.WriteElementString("CheckOutTime", "");
                            // xmlWriter.WriteElementString("TimeRemaining", "");
                            xmlWriter.WriteElementString("Status", "notreserve");

                            xmlWriter.WriteEndElement();

                            xmlWriter.WriteEndElement();
                            xmlWriter.WriteEndDocument();
                            xmlWriter.Flush();
                            xmlWriter.Close();
                        }
                    }
                    else
                    {
                        XDocument xDocument = XDocument.Load(r);
                        XElement root = xDocument.Element("Hotel");
                        IEnumerable<XElement> rows = root.Descendants("Customer");
                        XElement firstRow = rows.First();
                        firstRow.AddBeforeSelf(
                            new XElement("Customer",
                                new XElement("Name", ""),
                                //new XElement("Age", ""),
                                //new XElement("Gender", ""),
                                new XElement("IDCardNo", ""),
                                //new XElement("BalanceRs", ""),
                                //new XElement("DaysReserve", ""),
              
                                new XElement("FloorNo", floorno.ToString()),
                                //new XElement("RoomType", "Standard"),
                                new XElement("Roomno", roomno.ToString()),
                                //new XElement("CheckInTime", ""),
                                //new XElement("CheckOutTime", ""),
                                //new XElement("TimeRemaining", ""),
                                new XElement("Status", "notreserve")));


                        xDocument.Save(r);
                    }
                }
                roomlimit = roomlimit + 10;
            }
            return 0;
        }
Example #60
0
 public TextWriterWithSettings(Stream stream, XmlWriterSettings settings)
 {
     _baseObject = new StreamWriter(stream, settings.Encoding);
     _settings   = settings;
 }