private void StartFeed()
{
ISyndicationAttribute xmlns = _attributes.FirstOrDefault(a => a.Name == "xmlns");
// Write <feed>
if (xmlns != null)
{
_writer.WriteStartElement(AtomElementNames.Feed, xmlns.Value);
}
else
{
_writer.WriteStartElement(AtomElementNames.Feed);
}
// Add attributes
foreach (var a in _attributes)
{
if (a != xmlns)
{
_writer.WriteSyndicationAttribute(a);
}
}
_feedStarted = true;
}
private static ISyndicationContent ReadSyndicationContent(XmlReader reader)
{
var content = new SyndicationContent(reader.LocalName, reader.NamespaceURI, null);
//
// Attributes
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
ISyndicationAttribute attr = reader.ReadSyndicationAttribute();
if (attr != null)
{
content.AddAttribute(attr);
}
}
reader.MoveToContent();
}
//
// Content
if (!reader.IsEmptyElement)
{
reader.ReadStartElement();
//
// Value
if (reader.HasValue)
{
content.Value = reader.ReadContentAsString();
}
//
// Children
else
{
while (reader.IsStartElement())
{
content.AddField(ReadSyndicationContent(reader));
}
}
reader.ReadEndElement(); // end
}
else
{
reader.Skip();
}
return(content);
}
public void AddAttribute(ISyndicationAttribute attribute)
{
if (attribute == null)
{
throw new ArgumentNullException(nameof(attribute));
}
if (_attributes.IsReadOnly)
{
_attributes = _attributes.ToList();
}
_attributes.Add(attribute);
}
private static IEnumerable <ISyndicationAttribute> EnsureXmlNs(IEnumerable <ISyndicationAttribute> attributes)
{
ISyndicationAttribute xmlnsAttr = attributes.FirstOrDefault(a => a.Name.StartsWith("xmlns") && a.Value == AtomConstants.Atom10Namespace);
//
// Insert Atom namespace if it doesn't already exist
if (xmlnsAttr == null)
{
var list = new List <ISyndicationAttribute>(attributes);
list.Insert(0, new SyndicationAttribute("xmlns", AtomConstants.Atom10Namespace));
attributes = list;
}
return(attributes);
}
public async Task EmbededAtomInRssFeed()
{
var author = new SyndicationPerson("john doe", "*****@*****.**");
var entry = new AtomEntry()
{
Id = "https://contoso.com/28af09b3",
Title = "Atom Entry",
Description = "Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et quasi architecto beatae vitae dicta sunt explicabo. Nemo enim ipsam voluptatem quia voluptas sit aspernatur aut odit aut fugit...",
LastUpdated = DateTimeOffset.UtcNow
};
entry.AddContributor(author);
var sw = new StringWriterWithEncoding(Encoding.UTF8);
using (var xmlWriter = XmlWriter.Create(sw))
{
var attributes = new ISyndicationAttribute[] { new SyndicationAttribute("xmlns:atom", "http://www.w3.org/2005/Atom") };
var writer = new SyndicationFeed.Rss.RssFeedWriter(xmlWriter, attributes);
var formatter = new AtomFormatter(attributes, xmlWriter.Settings);
//
// Write Rss elements
await writer.WriteValue(SyndicationFeed.Rss.RssElementNames.Title, "Rss Title");
await writer.Write(author);
await writer.Write(new SyndicationItem()
{
Title = "Rss Item",
Id = "https://contoso.com/rss/28af09b3",
Description = "Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium",
LastUpdated = DateTimeOffset.UtcNow
});
//
// Write atom entry
await writer.WriteRaw(formatter.Format(entry));
await writer.Flush();
}
string res = sw.ToString();
Assert.True(res.Contains($"<atom:entry><atom:id>{entry.Id}</atom:id><atom:title>{entry.Title}</atom:title><atom:updated>{entry.LastUpdated.ToString("r")}</atom:updated><atom:author><atom:name>{author.Name}</atom:name><atom:email>{author.Email}</atom:email></atom:author><atom:content>{entry.Description}</atom:content></atom:entry>"));
}
public static XmlWriter CreateXmlWriter(XmlWriterSettings settings, IEnumerable <ISyndicationAttribute> attributes, StringBuilder buffer)
{
settings.Async = false;
settings.OmitXmlDeclaration = true;
settings.ConformanceLevel = ConformanceLevel.Fragment;
XmlWriter writer = XmlWriter.Create(buffer, settings);
//
// Apply attributes
if (attributes != null && attributes.Count() > 0)
{
//
// Create element wrapper
ISyndicationAttribute xmlns = attributes.FirstOrDefault(a => a.Name == "xmlns");
if (xmlns != null)
{
writer.WriteStartElement("w", xmlns.Value);
}
else
{
writer.WriteStartElement("w");
}
//
// Write attributes
foreach (var a in attributes)
{
if (a != xmlns)
{
writer.WriteSyndicationAttribute(a);
}
}
writer.WriteStartElement("y");
writer.WriteEndElement();
writer.Flush();
buffer.Clear();
}
return(writer);
}
public static void WriteSyndicationAttribute(this XmlWriter writer, ISyndicationAttribute attr)
{
XmlUtils.SplitName(attr.Name, out string prefix, out string localName);
prefix = prefix ?? writer.LookupPrefix(attr.Namespace ?? string.Empty);
if (prefix == string.Empty)
{
writer.WriteStartAttribute(attr.Name);
}
else if (prefix != null)
{
writer.WriteStartAttribute(prefix, localName, attr.Namespace);
}
else
{
writer.WriteStartAttribute(localName, attr.Namespace);
}
writer.WriteString(attr.Value);
writer.WriteEndAttribute();
}
private static ISyndicationContent ReadSyndicationContent(XmlReader reader)
{
string type = null;
var content = new SyndicationContent(reader.LocalName, reader.NamespaceURI, null);
//
// Attributes
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
ISyndicationAttribute attr = reader.ReadSyndicationAttribute();
if (attr != null)
{
if (type == null && attr.IsAtom(AtomConstants.Type))
{
type = attr.Value;
}
content.AddAttribute(attr);
}
}
reader.MoveToContent();
}
//
// Content
if (!reader.IsEmptyElement)
{
//
// Xml (applies to <content>)
if (XmlUtils.IsXmlMediaType(type) && content.IsAtom(AtomElementNames.Content))
{
if (reader.NodeType != XmlNodeType.Element)
{
throw new FormatException($"Invalid Xml element");
}
content.Value = reader.ReadInnerXml();
}
else
{
reader.ReadStartElement();
//
// Xhtml
if (XmlUtils.IsXhtmlMediaType(type) && content.IsAtom())
{
if (reader.NamespaceURI != AtomConstants.XhtmlNamespace)
{
throw new FormatException($"Invalid Xhtml namespace");
}
content.Value = reader.ReadInnerXml();
}
//
// Text/Html
else if (reader.HasValue)
{
content.Value = reader.ReadContentAsString();
}
//
// Children
else
{
while (reader.IsStartElement())
{
content.AddField(ReadSyndicationContent(reader));
}
}
reader.ReadEndElement(); // end
}
}
else
{
reader.Skip();
}
return(content);
}
public static bool IsAtom(this ISyndicationAttribute attr, string name)
{
return(attr.Name == name && (attr.Namespace == null || attr.Namespace == string.Empty || attr.Namespace == AtomConstants.Atom10Namespace));
}
public static void WriteSyndicationAttribute(this XmlWriter writer, ISyndicationAttribute attr)
{
XmlUtils.SplitName(attr.Name, out string prefix, out string localName);
writer.WriteAttribute(prefix, attr.Name, localName, attr.Namespace, attr.Value);
}
