| public abstract WriteRaw ( char buffer, int index, int count ) : void | ||
| buffer | char | |
| index | int | |
| count | int | |
| return | void | |
/// <summary>
/// Writes raw markup to the debug XML stream from the supplied string.
/// </summary>
/// <param name="text"></param>
protected void WriteDebugXmlRaw(string text)
{
if (_xmlDebugging)
{
_debugXmlWriter.WriteRaw(text);
}
}
public new void WriteXml(System.Xml.XmlWriter writer)
{
base.WriteXml(writer);
//writer.WriteRaw(string.Format("<PicLarge>{0}</PicLarge>", this.URLImage));
writer.WriteRaw(string.Format("<Height>{0}</Height>", Height));
writer.WriteRaw(string.Format("<Width>{0}</Width>", Width));
}
public new void WriteXml(System.Xml.XmlWriter writer)
{
base.WriteXml(writer);
writer.WriteRaw(string.Format("<Price>{0}</Price>", Price));
writer.WriteRaw(string.Format("<Amount>{0}</Amount>", Price));
/*writer.WriteRaw(string.Format("<PinboardPic1>{0}</PinboardPic1>", this.PinboardPicture01Lg));
* writer.WriteRaw(string.Format("<PinboardPic2>{0}</PinboardPic2>", this.PinboardPicture02Lg));
* writer.WriteRaw(string.Format("<PinboardPic3>{0}</PinboardPic3>", this.PinboardPicture03Lg));*/
}
void DoSave(System.Xml.XmlWriter w)
{
w.WriteStartElement("TextLayout");
w.WriteAttributeString("Name", Name);
w.WriteRaw("\r\n");
foreach (TextLabel label in placements)
{
label.Save(w);
}
w.WriteEndElement();
w.WriteRaw("\r\n");
}
public void WriteXml(System.Xml.XmlWriter writer)
{
writer.WriteElementString("Name", Name);
writer.WriteStartElement("XmlString");
writer.WriteRaw(XmlString);
writer.WriteFullEndElement();
}
protected override void WriteTokenCore(System.Xml.XmlWriter writer,
System.IdentityModel.Tokens.SecurityToken token)
{
UserNameSecurityToken userToken = token as UserNameSecurityToken;
string tokennamespace = "o";
DateTime created = DateTime.Now;
string createdStr = created.ToString("yyyy-MM-ddThh:mm:ss.fffZ");
// unique Nonce value - encode with SHA-1 for 'randomness'
// in theory the nonce could just be the GUID by itself
string phrase = Guid.NewGuid().ToString();
var nonce = GetSHA1String(phrase);
// in this case password is plain text
// for digest mode password needs to be encoded as:
// PasswordAsDigest = Base64(SHA-1(Nonce + Created + Password))
// and profile needs to change to
//string password = GetSHA1String(nonce + createdStr + userToken.Password);
string password = userToken.Password;
writer.WriteRaw(string.Format(
"<{0}:UsernameToken u:Id=\"" + token.Id +
"\" xmlns:u=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\">" +
"<{0}:Username>" + userToken.UserName + "</{0}:Username>" +
"<{0}:Password Type=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordText\">" +
password + "</{0}:Password>" +
"<{0}:Nonce EncodingType=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-soap-message-security-1.0#Base64Binary\">" +
nonce + "</{0}:Nonce>" +
"<u:Created>" + createdStr + "</u:Created></{0}:UsernameToken>", tokennamespace));
}
/// <summary>
/// Converts an object into its XML representation.
/// </summary>
/// <param name="writer">The <see cref="T:System.Xml.XmlWriter"/> stream to which the object is serialized.</param>
void IXmlSerializable.WriteXml(XmlWriter writer)
{
var type = GetType();
var element = new XElement(type.Name);
var serializer = SerializationFactory.GetXmlSerializer();
serializer.Serialize(this, new XmlSerializationContextInfo(element, this));
// The serializer gives us the full element, but we only need the actual content. According to
// http://stackoverflow.com/questions/3793/best-way-to-get-innerxml-of-an-xelement, this method is the fastest:
var reader = element.CreateReader();
reader.MoveToContent();
// CTL-710: fix attributes on top level elements
if (reader.HasAttributes)
{
for (int i = 0; i < reader.AttributeCount; i++)
{
reader.MoveToAttribute(i);
var attributePrefix = reader.Prefix;
var attributeLocalName = reader.LocalName;
var attributeNs = reader.NamespaceURI;
var attributeValue = reader.Value;
writer.WriteAttributeString(attributePrefix, attributeLocalName, attributeNs, attributeValue);
}
reader.MoveToElement();
}
var elementContent = reader.ReadInnerXml();
writer.WriteRaw(elementContent);
}
public override void WriteTo(XmlWriter w)
{
Debug.Assert (this.expression != null);
Debug.Assert (w != null);
w.WriteRaw (this.expression);
}
public override void Generate(XmlWriter writer)
{
writer.WriteRaw("<?xml version=\"1.0\"?>");
writer.WriteStartElement(@"response", @"http://schemas.microsoft.com/2006/09/sip/mrasp");
if (Request != null)
{
writer.WriteAttributeString(@"requestID", Request.RequestId);
writer.WriteAttributeString(@"version", Request.Version);
}
writer.WriteAttributeString(@"serverVersion", ServerVersion);
if (Request != null)
{
writer.WriteAttributeString(@"to", Request.To);
writer.WriteAttributeString(@"from", Request.From);
}
writer.WriteAttributeString(@"reasonPhrase", Common.ToString(ReasonPhrase));
if (CredentialsResponses != null)
foreach (var credentialsResponse in CredentialsResponses)
credentialsResponse.Generate(writer);
writer.WriteEndElement();
}
public void WriteXml(System.Xml.XmlWriter writer)
{
XmlSerializer keySerializer = new XmlSerializer(typeof(string));
XmlSerializer valueSerializer = new XmlSerializer(typeof(T));
foreach (string key in this.Keys)
{
writer.WriteStartElement("item");
writer.WriteAttributeString("key", key);
if (this[key] is string)
{
writer.WriteString(this[key].ToString());
}
else
{
XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));
using (StringWriter textWriter = new StringWriter())
{
xmlSerializer.Serialize(textWriter, this[key]);
XmlDocument doc = new XmlDocument();
doc.LoadXml(textWriter.ToString());
writer.WriteRaw(doc.GetElementsByTagName(typeof(T).Name)[0].InnerXml);
}
}
writer.WriteEndElement();
}
}
internal override void SaveValue (XmlWriter writer)
{
base.SaveValue (writer);
SaveAttribute (writer, "Evaluate", Evaluate);
if (!string.IsNullOrWhiteSpace (TaskBody))
writer.WriteRaw (TaskBody);
}
private void WriteElement(XNode node, XmlWriter writer)
{
writer.WriteStartElement(node.Name);
foreach (var attr in node.Attributes)
{
if (attr.Match == MatchType.Change || attr.Match == MatchType.NoMatch)
writer.WriteAttributeString(attr.Name, attr.XmlNode.Value);
}
foreach (var text in node.Texts)
{
if (text.Match == MatchType.Change || text.Match == MatchType.NoMatch)
writer.WriteValue(text.XmlNode.Value);
}
foreach (var element in node.Elements)
{
if (element.Match == MatchType.Change)
WriteElement(element, writer);
if (element.Match == MatchType.NoMatch)
writer.WriteRaw(element.XmlNode.OuterXml);
}
writer.WriteEndElement();
}
public void WriteResponseMessage ( XmlWriter writer, string innerXml, NuxleusAsyncResult asyncResult ) {
using (writer) {
writer.WriteStartDocument();
if (m_responseType == ResponseType.REDIRECT) {
writer.WriteProcessingInstruction("xml-stylesheet", "type='text/xsl' href='/service/transform/openid-redirect.xsl'");
}
writer.WriteStartElement("auth");
writer.WriteAttributeString("xml:base", "http://dev.amp.fm/");
writer.WriteAttributeString("status", m_status);
if (m_responseType == ResponseType.REDIRECT) {
writer.WriteElementString("url", "http://dev.amp.fm/");
}
if (m_responseType == ResponseType.QUERY_RESPONSE && innerXml != null) {
writer.WriteStartElement("response");
writer.WriteRaw(innerXml);
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.WriteEndDocument();
}
asyncResult.CompleteCall();
}
/// <summary>
/// Writes the configuration section values as an XML element to an <see cref="XmlWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="XmlWriter"/> that writes to the configuration source.</param>
public void WriteXml(XmlWriter writer)
{
if (writer == null) throw new ArgumentNullException("writer");
String serialized = SerializeSection(this, "SerializableConfigurationSection", ConfigurationSaveMode.Full);
writer.WriteRaw(serialized);
}
/// <summary>
/// Saving the object into an xml node
/// </summary>
/// <param name="comp">this compiler</param>
/// <param name="writer">Xml writer object</param>
/// <param name="child">html child for nested objects</param>
public void Save(ICompilateur comp, System.Xml.XmlWriter writer, ref System.Windows.Forms.HtmlElement child)
{
writer.WriteStartElement("createmop");
writer.WriteAttributeString("language", this.language);
writer.WriteAttributeString("name", this.name);
if (this.indent > 0)
{
writer.WriteAttributeString("indent", this.indent.ToString());
}
writer.WriteStartElement("legendes");
this.legendes.Save(writer);
writer.WriteEndElement();
writer.WriteStartElement("references");
foreach (string param in this.refs)
{
writer.WriteStartElement("ref");
writer.WriteString(param);
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.WriteStartElement("code");
writer.WriteRaw(this.xmlCode);
writer.WriteEndElement();
writer.WriteEndElement();
child = child.NextSibling;
}
public override void Generate(XmlWriter writer1)
{
this.writer.Flush();
this.writer.Close();
writer1.WriteRaw(output.ToString());
}
public void WriteXml(System.Xml.XmlWriter writer)
{
if (Value == System.DateTime.MinValue)
{
return;
}
writer.WriteRaw(XmlConvert.ToString(Value, XML_DATE_FORMAT));
}
private void AddEntry(XmlWriter writer, Package package, string baseUrl)
{
writer.WriteStartElement("entry");
writer.WriteElementString("id", package.ID);
writer.WriteStartElement("title");
writer.WriteAttributeString("type", "text");
writer.WriteValue(package.Name);
writer.WriteEndElement(); // title
writer.WriteStartElement("link");
writer.WriteAttributeString("rel", "alternate");
writer.WriteAttributeString("href", baseUrl + "/extensions/" + package.ID + "/extension.vsix");
writer.WriteEndElement(); // link
writer.WriteStartElement("summary");
writer.WriteAttributeString("type", "text");
writer.WriteValue(package.Description);
writer.WriteEndElement(); // summary
writer.WriteElementString("published", package.DatePublished.ToString("yyyy-MM-ddTHH:mm:ssZ"));
writer.WriteElementString("updated", package.DatePublished.ToString("yyyy-MM-ddTHH:mm:ssZ"));
writer.WriteStartElement("author");
writer.WriteElementString("name", package.Author);
writer.WriteEndElement(); // author
writer.WriteStartElement("content");
writer.WriteAttributeString("type", "application/octet-stream");
writer.WriteAttributeString("src", baseUrl + "/extensions/" + package.ID + "/extension.vsix");
writer.WriteEndElement(); // content
writer.WriteRaw("\r\n<Vsix xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns=\"http://schemas.microsoft.com/developer/vsx-syndication-schema/2010\">\r\n");
writer.WriteElementString("Id", package.ID);
writer.WriteElementString("Version", package.Version);
writer.WriteStartElement("References");
writer.WriteEndElement();
writer.WriteRaw("</Vsix>");// Vsix
writer.WriteEndElement(); // entry
}
private void Write(IRssSource src, XmlWriter writer)
{
if (src.IsRetranslator)
{
writer.WriteRaw(src.GetRaw());
}
else{
writeEmbeded(src, writer);
}
}
/// <summary>
/// Serializes the configuration section into XML and writes to an XML writer object.
/// </summary>
/// <param name="writer">The XML writer object.</param>
public virtual void WriteXml(XmlWriter writer)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
var serializedSection = SerializeSection(this, GetConfigurationSectionName(), ConfigurationSaveMode.Full);
writer.WriteRaw(serializedSection);
}
/// <summary>
/// Implements a custom serialization of the <see cref="DataModelMap"/> value.
/// </summary>
/// <param name="writer"></param>
/// <param name="value"></param>
protected override void SerializeValue(System.Xml.XmlWriter writer, DataModelMap value)
{
var xmlDoc = new XmlDocument();
xmlDoc.LoadXml((new XmlSerialized <DataModelMap>(value)).SerializedValue);
while (xmlDoc.LastChild.Attributes.Count > 0)
{
xmlDoc.LastChild.Attributes.RemoveAt(0);
}
writer.WriteRaw(xmlDoc.LastChild.OuterXml);
}
private void generateXml(XmlWriter writer)
{
writer.WriteStartDocument();
writer.WriteStartElement("results");
foreach (var runner in _results.GroupBy(x => x.Runner))
{
writer.WriteStartElement("runner");
writer.WriteAttributeString("id", runner.Key);
foreach (var assembly in runner.GroupBy(x => x.Assembly))
{
writer.WriteStartElement("assembly");
writer.WriteAttributeString("name", assembly.Key);
foreach (var fixture in assembly.GroupBy(x => x.TestFixture))
{
writer.WriteStartElement("fixture");
writer.WriteAttributeString("name", fixture.Key);
foreach (var test in fixture)
{
writer.WriteStartElement("test");
writer.WriteAttributeString("state", test.State.ToString());
writer.WriteAttributeString("name", test.TestName);
if (test.TestDisplayName != null)
writer.WriteAttributeString("displayName", test.TestDisplayName);
writer.WriteAttributeString("duration", test.DurationInMilliseconds.ToString());
writer.WriteStartElement("message");
writer.WriteCData(test.Message);
writer.WriteEndElement();
if (test.State == TestState.Failed || test.State == TestState.Ignored)
{
writer.WriteStartElement("stack-trace");
foreach (var line in test.StackLines)
{
writer.WriteStartElement("line");
writer.WriteStartElement("method");
writer.WriteCData(line.Method);
writer.WriteEndElement();
writer.WriteStartElement("file");
writer.WriteAttributeString("line", line.Line.ToString());
writer.WriteRaw(line.File);
writer.WriteEndElement();
writer.WriteEndElement();
}
writer.WriteEndElement();
}
writer.WriteEndElement();
}
writer.WriteEndElement();
}
writer.WriteEndElement();
}
writer.WriteEndElement();
}
writer.WriteEndElement();
}
protected override void WriteContentsTo(XmlWriter writer)
{
string data = this.text ?? string.Empty;
if (this.textKind == TextSyndicationContentKind.XHtml)
{
writer.WriteRaw(data);
}
else
{
writer.WriteString(data);
}
}
public void buildXml(XmlWriter xmlWriter)
{
xmlWriter.WriteStartElement("eventDate");
foreach (DateTime item in eventDates_)
{
//xmlWriter.WriteRaw(item.buildXml().ToString());
xmlWriter.WriteRaw("Not implemented");
}
xmlWriter.WriteEndElement();
}
public void buildXml(XmlWriter xmlWriter)
{
xmlWriter.WriteStartElement("functionEvents");
foreach (EventFunctionMModel item in eventFunctionMList_)
{
item.buildXml(xmlWriter);
}
xmlWriter.WriteRaw(jointFunctionEventModel_.buildXml().ToString());
xmlWriter.WriteEndElement();
}
protected override void WriteTokenCore(XmlWriter writer, SecurityToken securityToken)
{
UserNameSecurityToken token = (UserNameSecurityToken)securityToken;
writer.WriteRaw(string.Format(
"<{0}:UsernameToken {1}:Id=\"" + securityToken.Id +
"\" xmlns:{1}=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\">" +
" xmlns:{0}=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd\">" +
"<{0}:Username>" + token.UserName + "</{0}:Username>" +
"<{0}:Password {0}:Type=\"" + _settings.PasswordType + "\">" +
_settings.GetPassword(token.Password, true) + "</{0}:Password>" +
"<{0}:Nonce EncodingType=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-soap-message-security-1.0#Base64Binary\">" +
_settings.Nonce + "</{0}:Nonce>" +
"<{1}:Created>" + _settings.CreatedDate + "</{1}:Created></{0}:UsernameToken>", _settings.TokenNamespace, _settings.TokenElementNamespace));
}
private void SerializePresets(XmlWriter writer)
{
writer.WriteStartElement("presets");
foreach (DictionaryEntry de in _manager.Presets)
{
writer.WriteStartElement("preset");
writer.WriteAttributeString("name", (string)de.Key);
//SerializeNodes(writer, ((Preset)de.Value).Nodes);
writer.WriteRaw(((Preset)de.Value).Nodes.InnerXml);
writer.WriteEndElement();
}
writer.WriteEndElement();
}
/// <summary>
/// Converts an object into its XML representation.
/// </summary>
/// <param name="writer">The <see cref="T:System.Xml.XmlWriter"/> stream to which the object is serialized.</param>
void IXmlSerializable.WriteXml(XmlWriter writer)
{
var type = GetType();
var element = new XElement(type.Name);
var serializer = SerializationFactory.GetXmlSerializer();
serializer.Serialize(this, new XmlSerializationContextInfo(element, this));
// The serializer gives us the full element, but we only need the actual content. According to
// http://stackoverflow.com/questions/3793/best-way-to-get-innerxml-of-an-xelement, this method is the fastest:
var reader = element.CreateReader();
reader.MoveToContent();
var elementContent = reader.ReadInnerXml();
writer.WriteRaw(elementContent);
}
internal override void WriteContent (XmlWriter writer, WriteContext context)
{
MSBuildWhitespace.Write (StartInnerWhitespace, writer);
if (rawValue != null) {
if (!object.ReferenceEquals (rawValue, EmptyElementMarker)) {
if (rawValue.Length == 0 && !WasReadAsEmptyElement)
writer.WriteString (""); // Keep the non-empty element
else
writer.WriteRaw (rawValue);
}
} else if (textValue != null) {
writer.WriteValue (textValue);
} else {
WriteValue (writer, context, unevaluatedValue);
}
MSBuildWhitespace.Write (EndInnerWhitespace, writer);
}
/// <summary>
/// Implements a custom serialization of the key, using the type name as a specifier.
/// </summary>
/// <param name="writer"></param>
/// <param name="key"></param>
protected override void SerializeKey(System.Xml.XmlWriter writer, Type key)
{
writer.WriteStartElement(SerializedKeyElementName);
if (SerializeKeyTypeAsKeyAttribute)
{
writer.WriteStartAttribute("type");
writer.WriteValue("System.String");
writer.WriteEndAttribute();
}
var typeFullName = key.FullName;
if (!typeFullName.Contains(","))
{
typeFullName += ", " + key.Assembly.GetName().Name;
}
writer.WriteRaw(XmlUtility.EncodeText(typeFullName));
writer.WriteEndElement();
}
public override void buildXml(System.Xml.XmlWriter xmlWriter)
{
xmlWriter.WriteStartElement("messageBody");
xmlWriter.WriteElementString("msg_type", "gridCalculation");
xmlWriter.WriteStartElement("gridCalculation");
xmlWriter.WriteElementString("inst_code", this.inst_code_);
xmlWriter.WriteElementString("inst_name", this.inst_name_);
xmlWriter.WriteElementString("inst_type", this.inst_type_);
xmlWriter.WriteElementString("para_refDate", StringConverter.xmlDateTimeToDateString(this.para_refDate_));
xmlWriter.WriteStartElement("productInnerXml");
xmlWriter.WriteRaw(this.InnerXml_);
xmlWriter.WriteEndElement();
xmlWriter.WriteEndElement();
xmlWriter.WriteEndElement();
}
protected override void WriteElementContent(XmlWriter writer)
{
if (!string.IsNullOrEmpty(_text)) {
if (_type == null || _type.Value == null) {
writer.WriteString(_text);
return;
}
if (Helper.IsXmlType(_type)) {
writer.WriteRaw(_text);
}
else if (_type == AtomContentType.Html) {
writer.WriteCData(_text);
}
else {
writer.WriteString(_text);
}
}
}
private void ChangeParent(XmlContextFile parent)
{
string tmp = ToXMLContent(false);
string newPath = "";
if (parent == null)
newPath = "." + Path.DirectorySeparatorChar;
else
newPath = parent.BasePath + _fileName + Path.DirectorySeparatorChar;
foreach (XmlContextFile xcf in _includes)
{
tmp = tmp.Replace(string.Format(_INCLUDE_LINE, xcf.BasePath + xcf.FileName + ".xml"),
string.Format(_INCLUDE_LINE, newPath + xcf.FileName + ".xml"));
}
_writer.Close();
_ms = new MemoryStream();
_writer = XmlWriter.Create(_ms);
_writer.WriteRaw(tmp);
foreach (XmlContextFile xcf in _includes)
xcf.ChangeParent(this);
}
public XmlWriter createAlertSetSection( XmlWriter writer, cmdletDescription result )
{
try
{
//Start AlertSet section
writer.WriteRaw( " <maml:alertSet>\r\n" );
//writer.WriteComment("Notes Secion");
writer.WriteRaw( " <maml:title></maml:title>\r\n" );
writer.WriteRaw( " <maml:alert>\r\n" );
writer.WriteRaw( " <maml:para>" );
//writer.WriteComment("Note Details");
writer.WriteRaw( HttpUtility.HtmlEncode( result.Note ) );
writer.WriteRaw( "</maml:para>\r\n" );
writer.WriteRaw( " </maml:alert>\r\n" );
//End AlertSet section
writer.WriteRaw( " </maml:alertSet>\r\n" );
//<maml:alertSet>
// <maml:title></maml:title>
// <maml:alert>
// <maml:para>
// <!-- Note details-->
// </maml:para>
// </maml:alert>
// <maml:alert>
// <maml:para></maml:para>
// </maml:alert>
//</maml:alertSet>
}
catch ( Exception ex )
{
MessageBox.Show( ex.Message, "Error writing the XML File.", MessageBoxButtons.OK, MessageBoxIcon.Warning );
}
return writer;
}
public void WriteXml(System.Xml.XmlWriter writer)
{
writer.WriteStartElement("objectType");
writer.WriteString("array");
writer.WriteEndElement();
foreach (T value in this)
{
writer.WriteStartElement("item");
if (value is string)
{
writer.WriteString(value.ToString());
}
else
{
if (value is RestResponse)
{
writer.WriteStartElement("objectType");
writer.WriteString("RestResponse");
writer.WriteEndElement();
}
XmlObjectSerializer xmlSerializer = new DataContractSerializer(typeof(T), GetKnownTypes());
MemoryStream stream = new MemoryStream();
xmlSerializer.WriteObject(stream, value);
stream.Position = 0;
StreamReader streamReader = new StreamReader(stream);
string xml = streamReader.ReadToEnd();
XmlDocument doc = new XmlDocument();
doc.LoadXml(xml);
writer.WriteRaw(doc.DocumentElement.InnerXml);
}
writer.WriteEndElement();
}
}
private void WriteConfiguration(XmlWriter xmlWriter)
{
var filename = Path.GetTempFileName();
try
{
this.SaveAs(filename);
const int BufferSize = 1024;
var buffer = new char[BufferSize];
using (var fileStream = new StreamReader(filename))
{
var readAmount = 0;
while ((readAmount = fileStream.Read(buffer, 0, BufferSize)) > 0)
{
xmlWriter.WriteRaw(buffer, 0, readAmount);
}
}
}
finally
{
File.Delete(filename);
}
}
protected override void WriteXml(XmlWriter writer, bool withChildren, SerializationOptions options)
{
const string thisName = "SearchFolder";
const string thisPath = "/Root/SearchFolder";
writer.WriteStartElement("Content");
base.WriteHead(writer, thisName, thisName, thisName, thisPath, true);
if (_query != null)
{
writer.WriteStartElement("Query");
writer.WriteRaw(_query.ToXml());
writer.WriteEndElement();
}
if (withChildren && Children != null)
{
writer.WriteStartElement("Children");
this.WriteXml(Children, writer, options);
writer.WriteEndElement();
}
writer.WriteEndElement();
}
public override void WriteRaw(string raw)
{
CheckState();
w.WriteRaw(raw);
}
/// <summary>Saves the node to the specified <see cref="T:System.Xml.XmlWriter" />.</summary>
/// <param name="w">The XmlWriter to which you want to save. </param>
public override void WriteTo(XmlWriter w)
{
w.WriteRaw(string.Format("<?xml {0}?>", this.Value));
}
public override void WriteTo(XmlWriter w)
{
// This doesn't seem to match up very well with w.WriteStartDocument()
// so writing out custom here.
w.WriteRaw(String.Format("<?xml {0}?>", Value));
}
public override void WriteRaw(char[] buffer, int index, int count)
{
_writer.WriteRaw(buffer, index, count);
}
public void EventsToWriter(XmlWriter writer)
{
if (this.singleText.Count != 0)
{
writer.WriteString(this.singleText.GetResult());
}
else
{
XmlRawWriter writer2 = writer as XmlRawWriter;
for (int i = 0; i < this.pages.Count; i++)
{
XmlEvent[] eventArray = this.pages[i];
for (int j = 0; j < eventArray.Length; j++)
{
byte[] buffer;
switch (eventArray[j].EventType)
{
case XmlEventType.Unknown:
return;
case XmlEventType.DocType:
{
writer.WriteDocType(eventArray[j].String1, eventArray[j].String2, eventArray[j].String3, (string)eventArray[j].Object);
continue;
}
case XmlEventType.StartElem:
{
writer.WriteStartElement(eventArray[j].String1, eventArray[j].String2, eventArray[j].String3);
continue;
}
case XmlEventType.StartAttr:
{
writer.WriteStartAttribute(eventArray[j].String1, eventArray[j].String2, eventArray[j].String3);
continue;
}
case XmlEventType.EndAttr:
{
writer.WriteEndAttribute();
continue;
}
case XmlEventType.CData:
{
writer.WriteCData(eventArray[j].String1);
continue;
}
case XmlEventType.Comment:
{
writer.WriteComment(eventArray[j].String1);
continue;
}
case XmlEventType.PI:
{
writer.WriteProcessingInstruction(eventArray[j].String1, eventArray[j].String2);
continue;
}
case XmlEventType.Whitespace:
{
writer.WriteWhitespace(eventArray[j].String1);
continue;
}
case XmlEventType.String:
{
writer.WriteString(eventArray[j].String1);
continue;
}
case XmlEventType.Raw:
{
writer.WriteRaw(eventArray[j].String1);
continue;
}
case XmlEventType.EntRef:
{
writer.WriteEntityRef(eventArray[j].String1);
continue;
}
case XmlEventType.CharEnt:
{
writer.WriteCharEntity((char)eventArray[j].Object);
continue;
}
case XmlEventType.SurrCharEnt:
{
char[] chArray = (char[])eventArray[j].Object;
writer.WriteSurrogateCharEntity(chArray[0], chArray[1]);
continue;
}
case XmlEventType.Base64:
{
buffer = (byte[])eventArray[j].Object;
writer.WriteBase64(buffer, 0, buffer.Length);
continue;
}
case XmlEventType.BinHex:
{
buffer = (byte[])eventArray[j].Object;
writer.WriteBinHex(buffer, 0, buffer.Length);
continue;
}
case XmlEventType.XmlDecl1:
{
if (writer2 != null)
{
writer2.WriteXmlDeclaration((XmlStandalone)eventArray[j].Object);
}
continue;
}
case XmlEventType.XmlDecl2:
{
if (writer2 != null)
{
writer2.WriteXmlDeclaration(eventArray[j].String1);
}
continue;
}
case XmlEventType.StartContent:
{
if (writer2 != null)
{
writer2.StartElementContent();
}
continue;
}
case XmlEventType.EndElem:
{
if (writer2 == null)
{
break;
}
writer2.WriteEndElement(eventArray[j].String1, eventArray[j].String2, eventArray[j].String3);
continue;
}
case XmlEventType.FullEndElem:
{
if (writer2 == null)
{
goto Label_0367;
}
writer2.WriteFullEndElement(eventArray[j].String1, eventArray[j].String2, eventArray[j].String3);
continue;
}
case XmlEventType.Nmsp:
{
if (writer2 == null)
{
goto Label_0394;
}
writer2.WriteNamespaceDeclaration(eventArray[j].String1, eventArray[j].String2);
continue;
}
case XmlEventType.EndBase64:
{
if (writer2 != null)
{
writer2.WriteEndBase64();
}
continue;
}
case XmlEventType.Close:
{
writer.Close();
continue;
}
case XmlEventType.Flush:
{
writer.Flush();
continue;
}
case XmlEventType.Dispose:
{
writer.Dispose();
continue;
}
default:
{
continue;
}
}
writer.WriteEndElement();
continue;
Label_0367:
writer.WriteFullEndElement();
continue;
Label_0394:
writer.WriteAttributeString("xmlns", eventArray[j].String1, "http://www.w3.org/2000/xmlns/", eventArray[j].String2);
}
}
}
}
public new void WriteXml(System.Xml.XmlWriter writer)
{
base.WriteXml(writer);
writer.WriteRaw(string.Format("<Price>{0}</Price>", Price));
}
public static void getRowGrouped(row Row, XmlWriter XWriter)
{
XWriter.WriteStartElement("row");
for (int x = 0; x < Row.AnyAttr.Count; x++ )
{
XWriter.WriteAttributeString(Row.AnyAttr[x].Name, Row.AnyAttr[x].Value.ToString());
}
if (Row.Any != null)
{
foreach (var elm in Row.Any)
{
XWriter.WriteRaw(elm.OuterXml);
}
}
XWriter.WriteEndElement();
}
/// <summary>
/// Writes the Atom feed entry element information to the specified <see cref="XmlWriter"/> using the supplied <see cref="Page"/>.
/// </summary>
/// <param name="writer">
/// The <see cref="XmlWriter"/> to write feed entry element information to.
/// </param>
/// <param name="publishable">
/// The <see cref="IPublishable"/> used to generate feed entry content.
/// </param>
private static void WriteAtomEntry(XmlWriter writer, IPublishable publishable)
{
var post = publishable as Post;
// var comment = publishable as Comment;
// ------------------------------------------------------------
// Raise serving event
// ------------------------------------------------------------
var arg = new ServingEventArgs(publishable.Content, ServingLocation.Feed);
publishable.OnServing(arg);
if (arg.Cancel)
{
return;
}
// ------------------------------------------------------------
// Modify publishable content to make references absolute
// ------------------------------------------------------------
var content = Utils.ConvertPublishablePathsToAbsolute(arg.Body, publishable);
writer.WriteStartElement("entry");
// ------------------------------------------------------------
// Write required entry elements
// ------------------------------------------------------------
writer.WriteElementString("id", publishable.AbsoluteLink.ToString());
writer.WriteElementString("title", publishable.Title);
writer.WriteElementString("updated", ToW3CDateTime(publishable.DateCreated.ToUniversalTime()));
// ------------------------------------------------------------
// Write recommended entry elements
// ------------------------------------------------------------
writer.WriteStartElement("link");
writer.WriteAttributeString("rel", "self");
writer.WriteAttributeString("href", GetPermaLink(publishable).ToString());
writer.WriteEndElement();
writer.WriteStartElement("link");
writer.WriteAttributeString("href", publishable.AbsoluteLink.ToString());
writer.WriteEndElement();
writer.WriteStartElement("author");
writer.WriteElementString("name", publishable.Author);
writer.WriteEndElement();
writer.WriteStartElement("summary");
writer.WriteAttributeString("type", "html");
writer.WriteString(content);
writer.WriteEndElement();
// ------------------------------------------------------------
// Write optional entry elements
// ------------------------------------------------------------
writer.WriteElementString("published", ToW3CDateTime(publishable.DateCreated.ToUniversalTime()));
writer.WriteStartElement("link");
writer.WriteAttributeString("rel", "related");
writer.WriteAttributeString("href", String.Concat(publishable.AbsoluteLink.ToString(),
BlogSettings.Instance.ModerationType == BlogSettings.Moderation.Disqus ? "#disqus_thread" : "#comment"));
writer.WriteEndElement();
// ------------------------------------------------------------
// Write enclosure tag for podcasting support
// ------------------------------------------------------------
if (BlogSettings.Instance.EnableEnclosures)
{
var encloser = GetEnclosure(content, publishable);
if (!string.IsNullOrEmpty(encloser))
{
writer.WriteRaw(encloser);
}
}
// ------------------------------------------------------------
// Write entry category elements
// ------------------------------------------------------------
if (publishable.Categories != null)
{
foreach (var category in publishable.Categories)
{
writer.WriteStartElement("category");
writer.WriteAttributeString("term", category.Title);
writer.WriteEndElement();
}
}
// ------------------------------------------------------------
// Write Dublin Core syndication extension elements
// ------------------------------------------------------------
if (!String.IsNullOrEmpty(publishable.Author))
{
writer.WriteElementString("dc", "publisher", "http://purl.org/dc/elements/1.1/", publishable.Author);
}
if (!String.IsNullOrEmpty(publishable.Description))
{
writer.WriteElementString(
"dc", "description", "http://purl.org/dc/elements/1.1/", publishable.Description);
}
// ------------------------------------------------------------
// Write pingback syndication extension elements
// ------------------------------------------------------------
Uri pingbackServer;
if (Uri.TryCreate(
String.Concat(publishable.Blog.AbsoluteWebRoot.ToString().TrimEnd('/'), "/pingback.axd"),
UriKind.RelativeOrAbsolute,
out pingbackServer))
{
writer.WriteElementString(
"pingback",
"server",
"http://madskills.com/public/xml/rss/module/pingback/",
pingbackServer.ToString());
writer.WriteElementString(
"pingback",
"target",
"http://madskills.com/public/xml/rss/module/pingback/",
GetPermaLink(publishable).ToString());
}
// ------------------------------------------------------------
// Write slash syndication extension elements
// ------------------------------------------------------------
if (post != null && post.Comments != null)
{
writer.WriteElementString(
"slash",
"comments",
"http://purl.org/rss/1.0/modules/slash/",
post.Comments.Count.ToString(CultureInfo.InvariantCulture));
}
// ------------------------------------------------------------
// Write trackback syndication extension elements
// ------------------------------------------------------------
if (post != null && post.TrackbackLink != null)
{
writer.WriteElementString(
"trackback",
"ping",
"http://madskills.com/public/xml/rss/module/trackback/",
post.TrackbackLink.ToString());
}
// ------------------------------------------------------------
// Write well-formed web syndication extension elements
// ------------------------------------------------------------
writer.WriteElementString(
"wfw",
"comment",
"http://wellformedweb.org/CommentAPI/",
String.Concat(publishable.AbsoluteLink.ToString(),
BlogSettings.Instance.ModerationType == BlogSettings.Moderation.Disqus ? "#disqus_thread" : "#comment"));
writer.WriteElementString(
"wfw",
"commentRss",
"http://wellformedweb.org/CommentAPI/",
string.Format("{0}/syndication.axd?post={1}", publishable.Blog.AbsoluteWebRoot.ToString().TrimEnd('/'), publishable.Id));
// ------------------------------------------------------------
// Write </entry> element
// ------------------------------------------------------------
writer.WriteEndElement();
}
public void SaveToStream(XmlWriter writer)
{
writer.WriteAttributeString("DialPlanType",_dialPlanType );
writer.WriteStartElement("ConfigCall");
writer.WriteRaw(Utility.ConvertObjectToXML(_configurationCalls, true));
writer.WriteEndElement();
writer.WriteStartElement("TriggerEvents");
writer.WriteRaw(Utility.ConvertObjectToXML(_triggerEvents, true));
writer.WriteEndElement();
}
public bool writeRaw(string content) => CheckedCall(() => _writer.WriteRaw(content));
public bool endCdata()
{
if (_state.Count == 0 || _state.Peek() != State.CDATA)
{
return(false);
}
_state.Pop();
if (_unclosedNodesCount > 0) // If there are unclosed nodes, close them.
{
while (_unclosedNodesCount-- > 0)
{
CheckedCall(() => _writer.WriteEndElement());
}
CheckedCall(() => _writer.WriteRaw("]]>"));
return(false);
}
return(CheckedCall(() => _writer.WriteRaw("]]>")));
}
public override void WriteRaw(string data)
{
writer.WriteRaw(data);
}
public new void WriteXml(System.Xml.XmlWriter writer)
{
base.WriteXml(writer);
writer.WriteRaw(string.Format("<GenericData>{0}</GenericData>", GenericData));
}
public override void WriteRaw(char[] buffer, int index, int count)
{
CheckAsync();
_coreWriter.WriteRaw(buffer, index, count);
}
internal void Replay(XmlWriter writer)
{
if (_singleStringValue != null)
{
writer.WriteString(_singleStringValue);
return;
}
BufferChunk bufChunk;
for (int i = _firstItem; i <= _lastItem; i++)
{
Item item = _items[i];
switch (item.type)
{
case ItemType.EntityRef:
writer.WriteEntityRef((string)item.data);
break;
case ItemType.CharEntity:
writer.WriteCharEntity((char)item.data);
break;
case ItemType.SurrogateCharEntity:
char[] chars = (char[])item.data;
writer.WriteSurrogateCharEntity(chars[0], chars[1]);
break;
case ItemType.Whitespace:
writer.WriteWhitespace((string)item.data);
break;
case ItemType.String:
writer.WriteString((string)item.data);
break;
case ItemType.StringChars:
bufChunk = (BufferChunk)item.data;
writer.WriteChars(bufChunk.buffer, bufChunk.index, bufChunk.count);
break;
case ItemType.Raw:
writer.WriteRaw((string)item.data);
break;
case ItemType.RawChars:
bufChunk = (BufferChunk)item.data;
writer.WriteChars(bufChunk.buffer, bufChunk.index, bufChunk.count);
break;
case ItemType.ValueString:
writer.WriteValue((string)item.data);
break;
default:
Debug.Fail("Unexpected ItemType value.");
break;
}
}
}
/// <summary>
/// Replay all cached events to an XmlWriter.
/// </summary>
public void EventsToWriter(XmlWriter writer)
{
XmlEvent[] page;
int idxPage, idxEvent;
byte[] bytes;
char[] chars;
XmlRawWriter rawWriter;
// Special-case single text node at the top-level
if (_singleText.Count != 0)
{
writer.WriteString(_singleText.GetResult());
return;
}
rawWriter = writer as XmlRawWriter;
// Loop over set of pages
for (idxPage = 0; idxPage < _pages.Count; idxPage++)
{
page = _pages[idxPage];
// Loop over events in each page
for (idxEvent = 0; idxEvent < page.Length; idxEvent++)
{
switch (page[idxEvent].EventType)
{
case XmlEventType.Unknown:
// No more events
Debug.Assert(idxPage + 1 == _pages.Count);
return;
case XmlEventType.DocType:
writer.WriteDocType(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3, (string)page[idxEvent].Object);
break;
case XmlEventType.StartElem:
writer.WriteStartElement(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3);
break;
case XmlEventType.StartAttr:
writer.WriteStartAttribute(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3);
break;
case XmlEventType.EndAttr:
writer.WriteEndAttribute();
break;
case XmlEventType.CData:
writer.WriteCData(page[idxEvent].String1);
break;
case XmlEventType.Comment:
writer.WriteComment(page[idxEvent].String1);
break;
case XmlEventType.PI:
writer.WriteProcessingInstruction(page[idxEvent].String1, page[idxEvent].String2);
break;
case XmlEventType.Whitespace:
writer.WriteWhitespace(page[idxEvent].String1);
break;
case XmlEventType.String:
writer.WriteString(page[idxEvent].String1);
break;
case XmlEventType.Raw:
writer.WriteRaw(page[idxEvent].String1);
break;
case XmlEventType.EntRef:
writer.WriteEntityRef(page[idxEvent].String1);
break;
case XmlEventType.CharEnt:
writer.WriteCharEntity((char)page[idxEvent].Object);
break;
case XmlEventType.SurrCharEnt:
chars = (char[])page[idxEvent].Object;
writer.WriteSurrogateCharEntity(chars[0], chars[1]);
break;
case XmlEventType.Base64:
bytes = (byte[])page[idxEvent].Object;
writer.WriteBase64(bytes, 0, bytes.Length);
break;
case XmlEventType.BinHex:
bytes = (byte[])page[idxEvent].Object;
writer.WriteBinHex(bytes, 0, bytes.Length);
break;
case XmlEventType.XmlDecl1:
if (rawWriter != null)
{
rawWriter.WriteXmlDeclaration((XmlStandalone)page[idxEvent].Object);
}
break;
case XmlEventType.XmlDecl2:
if (rawWriter != null)
{
rawWriter.WriteXmlDeclaration(page[idxEvent].String1);
}
break;
case XmlEventType.StartContent:
if (rawWriter != null)
{
rawWriter.StartElementContent();
}
break;
case XmlEventType.EndElem:
if (rawWriter != null)
{
rawWriter.WriteEndElement(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3);
}
else
{
writer.WriteEndElement();
}
break;
case XmlEventType.FullEndElem:
if (rawWriter != null)
{
rawWriter.WriteFullEndElement(page[idxEvent].String1, page[idxEvent].String2, page[idxEvent].String3);
}
else
{
writer.WriteFullEndElement();
}
break;
case XmlEventType.Nmsp:
if (rawWriter != null)
{
rawWriter.WriteNamespaceDeclaration(page[idxEvent].String1, page[idxEvent].String2);
}
else
{
writer.WriteAttributeString("xmlns", page[idxEvent].String1, XmlReservedNs.NsXmlNs, page[idxEvent].String2);
}
break;
case XmlEventType.EndBase64:
if (rawWriter != null)
{
rawWriter.WriteEndBase64();
}
break;
case XmlEventType.Close:
writer.Close();
break;
case XmlEventType.Flush:
writer.Flush();
break;
case XmlEventType.Dispose:
((IDisposable)writer).Dispose();
break;
default:
Debug.Assert(false, "Unknown event: " + page[idxEvent].EventType);
break;
}
}
}
Debug.Assert(false, "Unknown event should be added to end of event sequence.");
}
/// <summary>
/// Writes the RSS channel item element information to the specified <see cref="XmlWriter"/> using the supplied <see cref="Page"/>.
/// </summary>
/// <param name="writer">
/// The <see cref="XmlWriter"/> to write channel item element information to.
/// </param>
/// <param name="publishable">
/// The <see cref="IPublishable"/> used to generate channel item content.
/// </param>
private static void WriteRssItem(XmlWriter writer, IPublishable publishable)
{
// ------------------------------------------------------------
// Cast IPublishable as Post to support comments/trackback
// ------------------------------------------------------------
var post = publishable as Post;
var comment = publishable as Comment;
// ------------------------------------------------------------
// Raise serving event
// ------------------------------------------------------------
var arg = new ServingEventArgs(publishable.Content, ServingLocation.Feed);
publishable.OnServing(arg);
if (arg.Cancel)
{
return;
}
// ------------------------------------------------------------
// Modify post content to make references absolute
// ------------------------------------------------------------
var content = Utils.ConvertPublishablePathsToAbsolute(arg.Body, publishable);
if (comment != null)
{
content = content.Replace(Environment.NewLine, "<br />");
}
writer.WriteStartElement("item");
// ------------------------------------------------------------
// Write required channel item elements
// ------------------------------------------------------------
if (comment != null)
{
writer.WriteElementString("title", publishable.Author + " on " + comment.Parent.Title);
}
else
{
writer.WriteElementString("title", publishable.Title);
}
writer.WriteElementString("description", content);
writer.WriteElementString("link", publishable.AbsoluteLink.ToString());
// ------------------------------------------------------------
// Write enclosure tag for podcasting support
// ------------------------------------------------------------
if (BlogSettings.Instance.EnableEnclosures)
{
var encloser = GetEnclosure(content, publishable);
if (!string.IsNullOrEmpty(encloser))
{
writer.WriteRaw(encloser);
}
}
// ------------------------------------------------------------
// Write optional channel item elements
// ------------------------------------------------------------
if (!string.IsNullOrEmpty(BlogSettings.Instance.FeedAuthor))
{
writer.WriteElementString("author", BlogSettings.Instance.FeedAuthor);
}
if (post != null)
{
writer.WriteElementString(
"comments", String.Concat(publishable.AbsoluteLink.ToString(),
BlogSettings.Instance.ModerationType == BlogSettings.Moderation.Disqus ? "#disqus_thread" : "#comment"));
}
writer.WriteElementString("guid", GetPermaLink(publishable).ToString());
writer.WriteElementString("pubDate", ToRfc822DateTime(publishable.DateCreated));
// ------------------------------------------------------------
// Write channel item category elements
// ------------------------------------------------------------
if (publishable.Categories != null)
{
foreach (var category in publishable.Categories)
{
writer.WriteElementString("category", category.Title);
}
}
// ------------------------------------------------------------
// Write Dublin Core syndication extension elements
// ------------------------------------------------------------
if (!String.IsNullOrEmpty(publishable.Author))
{
writer.WriteElementString("dc", "publisher", "http://purl.org/dc/elements/1.1/", publishable.Author);
}
// if (!String.IsNullOrEmpty(publishable.Description))
// {
// writer.WriteElementString("dc", "description", "http://purl.org/dc/elements/1.1/", publishable.Description);
// }
// ------------------------------------------------------------
// Write pingback syndication extension elements
// ------------------------------------------------------------
Uri pingbackServer;
if (Uri.TryCreate(
String.Concat(publishable.Blog.AbsoluteWebRoot.ToString().TrimEnd('/'), "/pingback.axd"),
UriKind.RelativeOrAbsolute,
out pingbackServer))
{
writer.WriteElementString(
"pingback",
"server",
"http://madskills.com/public/xml/rss/module/pingback/",
pingbackServer.ToString());
writer.WriteElementString(
"pingback",
"target",
"http://madskills.com/public/xml/rss/module/pingback/",
GetPermaLink(publishable).ToString());
}
// ------------------------------------------------------------
// Write slash syndication extension elements
// ------------------------------------------------------------
if (post != null && post.Comments != null)
{
writer.WriteElementString(
"slash",
"comments",
"http://purl.org/rss/1.0/modules/slash/",
post.Comments.Count.ToString(CultureInfo.InvariantCulture));
}
// ------------------------------------------------------------
// Write trackback syndication extension elements
// ------------------------------------------------------------
if (post != null && post.TrackbackLink != null)
{
writer.WriteElementString(
"trackback",
"ping",
"http://madskills.com/public/xml/rss/module/trackback/",
post.TrackbackLink.ToString());
}
// ------------------------------------------------------------
// Write well-formed web syndication extension elements
// ------------------------------------------------------------
writer.WriteElementString(
"wfw",
"comment",
"http://wellformedweb.org/CommentAPI/",
String.Concat(publishable.AbsoluteLink.ToString(),
BlogSettings.Instance.ModerationType == BlogSettings.Moderation.Disqus ? "#disqus_thread" : "#comment"));
writer.WriteElementString(
"wfw",
"commentRss",
"http://wellformedweb.org/CommentAPI/",
string.Format("{0}/syndication.axd?post={1}", publishable.Blog.AbsoluteWebRoot.ToString().TrimEnd('/'), publishable.Id));
// ------------------------------------------------------------
// Write </item> element
// ------------------------------------------------------------
writer.WriteEndElement();
}
/// <summary>Saves the node to the specified <see cref="T:System.Xml.XmlWriter" />.</summary>
/// <param name="w">The XmlWriter to which you want to save. </param>
public override void WriteTo(XmlWriter w)
{
w.WriteRaw("&");
w.WriteName(this.Name);
w.WriteRaw(";");
}
internal static void WriteProjectXml(
XmlWriter writer,
string projectPath,
string sourcePath,
string filters,
string startupFile,
bool excludeNodeModules,
out Guid projectGuid
) {
var projectHome = CommonUtils.GetRelativeDirectoryPath(Path.GetDirectoryName(projectPath), sourcePath);
projectGuid = Guid.NewGuid();
writer.WriteStartDocument();
writer.WriteStartElement("Project", "http://schemas.microsoft.com/developer/msbuild/2003");
writer.WriteAttributeString("DefaultTargets", "Build");
writer.WriteStartElement("PropertyGroup");
writer.WriteStartElement("Configuration");
writer.WriteAttributeString("Condition", " '$(Configuration)' == '' ");
writer.WriteString("Debug");
writer.WriteEndElement();
writer.WriteElementString("SchemaVersion", "2.0");
writer.WriteElementString("ProjectGuid", projectGuid.ToString("B"));
writer.WriteElementString("ProjectHome", projectHome);
writer.WriteElementString("ProjectView", "ShowAllFiles");
if (CommonUtils.IsValidPath(startupFile)) {
writer.WriteElementString("StartupFile", Path.GetFileName(startupFile));
} else {
writer.WriteElementString("StartupFile", String.Empty);
}
writer.WriteElementString("WorkingDirectory", ".");
writer.WriteElementString("OutputPath", ".");
writer.WriteElementString("ProjectTypeGuids", "{3AF33F2E-1136-4D97-BBB7-1795711AC8B8};{349c5851-65df-11da-9384-00065b846f21};{9092AA53-FB77-4645-B42D-1CCCA6BD08BD}");
bool typeScriptSupport = EnumerateAllFiles(sourcePath, filters, excludeNodeModules)
.Any(filename => NodejsConstants.TypeScriptExtension.Equals(Path.GetExtension(filename), StringComparison.OrdinalIgnoreCase));
if (typeScriptSupport) {
writer.WriteElementString("TypeScriptSourceMap", "true");
writer.WriteElementString("TypeScriptModuleKind", "CommonJS");
writer.WriteElementString("EnableTypeScript", "true");
}
writer.WriteStartElement("VisualStudioVersion");
writer.WriteAttributeString("Condition", "'$(VisualStudioVersion)' == ''");
writer.WriteString("14.0");
writer.WriteEndElement();
writer.WriteStartElement("VSToolsPath");
writer.WriteAttributeString("Condition", "'$(VSToolsPath)' == ''");
writer.WriteString(@"$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)");
writer.WriteEndElement();
writer.WriteEndElement(); // </PropertyGroup>
// VS requires property groups with conditions for Debug
// and Release configurations or many COMExceptions are
// thrown.
writer.WriteStartElement("PropertyGroup");
writer.WriteAttributeString("Condition", "'$(Configuration)' == 'Debug'");
writer.WriteEndElement();
writer.WriteStartElement("PropertyGroup");
writer.WriteAttributeString("Condition", "'$(Configuration)' == 'Release'");
writer.WriteEndElement();
var folders = new HashSet<string>(
Directory.EnumerateDirectories(sourcePath, "*", SearchOption.AllDirectories)
.Select(dirName =>
CommonUtils.TrimEndSeparator(
CommonUtils.GetRelativeDirectoryPath(sourcePath, dirName)
)
)
.Where(ShouldIncludeDirectory)
);
// Exclude node_modules and bower_components folders.
if (excludeNodeModules) {
folders.RemoveWhere(NodejsConstants.ContainsNodeModulesOrBowerComponentsFolder);
}
writer.WriteStartElement("ItemGroup");
foreach (var file in EnumerateAllFiles(sourcePath, filters, excludeNodeModules)) {
var ext = Path.GetExtension(file);
if (NodejsConstants.JavaScriptExtension.Equals(ext, StringComparison.OrdinalIgnoreCase)) {
writer.WriteStartElement("Compile");
} else if (NodejsConstants.TypeScriptExtension.Equals(ext, StringComparison.OrdinalIgnoreCase)) {
writer.WriteStartElement("TypeScriptCompile");
} else {
writer.WriteStartElement("Content");
}
writer.WriteAttributeString("Include", file);
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.WriteStartElement("ItemGroup");
foreach (var folder in folders.Where(s => !string.IsNullOrWhiteSpace(s)).OrderBy(s => s)) {
writer.WriteStartElement("Folder");
writer.WriteAttributeString("Include", folder);
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.WriteStartElement("Import");
writer.WriteAttributeString("Project", @"$(MSBuildToolsPath)\Microsoft.Common.targets");
writer.WriteAttributeString("Condition", @"Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')");
writer.WriteEndElement();
writer.WriteComment("Do not delete the following Import Project. While this appears to do nothing it is a marker for setting TypeScript properties before our import that depends on them.");
writer.WriteStartElement("Import");
writer.WriteAttributeString("Project", @"$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)\TypeScript\Microsoft.TypeScript.targets");
writer.WriteAttributeString("Condition", @"False");
writer.WriteEndElement();
writer.WriteStartElement("Import");
writer.WriteAttributeString("Project", @"$(VSToolsPath)\Node.js Tools\Microsoft.NodejsTools.targets");
writer.WriteEndElement();
writer.WriteRaw(@"
<ProjectExtensions>
<VisualStudio>
<FlavorProperties GUID=""{349c5851-65df-11da-9384-00065b846f21}"">
<WebProjectProperties>
<UseIIS>False</UseIIS>
<AutoAssignPort>True</AutoAssignPort>
<DevelopmentServerPort>0</DevelopmentServerPort>
<DevelopmentServerVPath>/</DevelopmentServerVPath>
<IISUrl>http://localhost:48022/</IISUrl>
<NTLMAuthentication>False</NTLMAuthentication>
<UseCustomServer>True</UseCustomServer>
<CustomServerUrl>http://localhost:1337</CustomServerUrl>
<SaveServerSettingsInUserFile>False</SaveServerSettingsInUserFile>
</WebProjectProperties>
</FlavorProperties>
<FlavorProperties GUID=""{349c5851-65df-11da-9384-00065b846f21}"" User="""">
<WebProjectProperties>
<StartPageUrl>
</StartPageUrl>
<StartAction>CurrentPage</StartAction>
<AspNetDebugging>True</AspNetDebugging>
<SilverlightDebugging>False</SilverlightDebugging>
<NativeDebugging>False</NativeDebugging>
<SQLDebugging>False</SQLDebugging>
<ExternalProgram>
</ExternalProgram>
<StartExternalURL>
</StartExternalURL>
<StartCmdLineArguments>
</StartCmdLineArguments>
<StartWorkingDirectory>
</StartWorkingDirectory>
<EnableENC>False</EnableENC>
<AlwaysStartWebServerOnDebug>False</AlwaysStartWebServerOnDebug>
</WebProjectProperties>
</FlavorProperties>
</VisualStudio>
</ProjectExtensions>
");
writer.WriteEndElement(); // </Project>
writer.WriteEndDocument();
}
public new void WriteXml(System.Xml.XmlWriter writer)
{
base.WriteXml(writer);
writer.WriteRaw(string.Format("<Video>{0}</Video>", Location));
}
