public SyndicationFeed DeserializeFromStream(Stream stream)
{
var sr = XmlReader.Create(stream);
Atom10FeedFormatter atomFormatter = new Atom10FeedFormatter();
atomFormatter.ReadFrom(sr);
sr.Close();
return atomFormatter.Feed;
}
public static void Snippet11()
{
// <Snippet11>
Atom10FeedFormatter myFeedAtomFormatter = new Atom10FeedFormatter(typeof(MySyndicationFeed));
XmlReader atomReader = XmlReader.Create("http://Contoso/Feeds/MyFeed");
myFeedAtomFormatter.ReadFrom(atomReader);
atomReader.Close();
// </Snippet11>
}
public void ReadXml_TitleOnly()
{
Atom10FeedFormatter f = new Atom10FeedFormatter();
((IXmlSerializable)f).ReadXml(CreateReader("<feed xmlns='http://www.w3.org/2005/Atom'><title>test</title></feed>"));
Assert.IsNotNull(f.Feed.Title, "#1");
Assert.AreEqual("test", f.Feed.Title.Text, "#2");
((IXmlSerializable)f).ReadXml(CreateReader("<dummy xmlns='http://www.w3.org/2005/Atom'><title>test</title></dummy>")); // it is ok
}
public override void ExecuteResult(ControllerContext context)
{
context.HttpContext.Response.ContentType = "application/atom+xml";
var formatter = new Atom10FeedFormatter(Feed);
using (var writer = XmlWriter.Create(context.HttpContext.Response.Output, new XmlWriterSettings {
Indent = true
}))
formatter.WriteTo(writer);
}
public static void Snippet1()
{
// <Snippet1>
XmlReader atomReader = XmlReader.Create("AtomFeed.xml");
Atom10FeedFormatter atomFormatter = new Atom10FeedFormatter();
atomFormatter.ReadFrom(atomReader);
atomReader.Close();
// </Snippet1>
}
public override void OnWriteToStream(Type type, object value, Stream stream, HttpContentHeaders contentHeaders, TransportContext context)
{
var formatter = new Atom10FeedFormatter((SyndicationFeed)value);
using (var xmlWriter = XmlWriter.Create(stream))
{
formatter.WriteTo(xmlWriter);
xmlWriter.Close();
}
}
/// <summary>
/// Gets the ows context atom feed.
/// </summary>
/// <returns>The ows context atom feed.</returns>
/// <param name="s">S.</param>
public static OwsContextAtomFeed GetOwsContextAtomFeed(string s)
{
var atomFormatter = new Atom10FeedFormatter();
XmlReader xmlreader = XmlReader.Create(new StringReader(s));
atomFormatter.ReadFrom(xmlreader);
var feed = new OwsContextAtomFeed(atomFormatter.Feed, true);
return(feed);
}
public override void ExecuteResult(ControllerContext context)
{
context.HttpContext.Response.ContentType = "application/atom+xml";
var formatter = new Atom10FeedFormatter(this.feed);
using (var writer = XmlWriter.Create(context.HttpContext.Response.Output))
{
formatter.WriteTo(writer);
}
}
public static void SyndicationFeed_Write_RSS_Atom()
{
string RssPath = Path.GetTempFileName();
string AtomPath = Path.GetTempFileName();
try
{
// *** SETUP *** \\
SyndicationFeed feed = new SyndicationFeed("Contoso News", "<div>Most recent news from Contoso</div>", new Uri("http://www.Contoso.com/news"), "123FeedID", DateTime.Now);
//Add an author
SyndicationPerson author = new SyndicationPerson("*****@*****.**");
feed.Authors.Add(author);
//Create item
SyndicationItem item1 = new SyndicationItem("SyndicationFeed released for .net Core", "A lot of text describing the release of .net core feature", new Uri("http://Contoso.com/news/path"));
//Add item to feed
List <SyndicationItem> feedList = new List <SyndicationItem> {
item1
};
feed.Items = feedList;
feed.ElementExtensions.Add("CustomElement", "", "asd");
//add an image
feed.ImageUrl = new Uri("http://2.bp.blogspot.com/-NA5Jb-64eUg/URx8CSdcj_I/AAAAAAAAAUo/eCx0irI0rq0/s1600/bg_Contoso_logo3-20120824073001907469-620x349.jpg");
feed.BaseUri = new Uri("http://mypage.com");
// Write to XML > rss
using (XmlWriter xmlwRss = XmlWriter.Create(RssPath))
{
Rss20FeedFormatter rssff = new Rss20FeedFormatter(feed);
rssff.WriteTo(xmlwRss);
}
// Write to XML > atom
using (XmlWriter xmlwAtom = XmlWriter.Create(AtomPath))
{
Atom10FeedFormatter atomf = new Atom10FeedFormatter(feed);
atomf.WriteTo(xmlwAtom);
}
// *** ASSERT *** \\
Assert.True(File.Exists(RssPath));
Assert.True(File.Exists(AtomPath));
}
finally
{
// *** CLEANUP *** \\
File.Delete(RssPath);
File.Delete(AtomPath);
}
}
public static SyndicationFeed AtomFeed(string uri)
{
if (!string.IsNullOrEmpty(uri))
{
var ff = new Atom10FeedFormatter(); // Rss20FeedFormatter for Atom you can use Atom10FeedFormatter()
var xr = XmlReader.Create(uri);
ff.ReadFrom(xr);
return(ff.Feed);
}
return(null);
}
/// <summary>
/// Gets the ows context atom feed.
/// </summary>
/// <returns>The ows context atom feed.</returns>
/// <param name="s">S.</param>
public static OwsContextAtomFeed GetOwsContextAtomFeed(Stream s)
{
var sr = XmlReader.Create(s);
Atom10FeedFormatter atomFormatter = new Atom10FeedFormatter();
atomFormatter.ReadFrom(sr);
sr.Close();
var feed = new OwsContextAtomFeed(atomFormatter.Feed, true);
return(feed);
}
public static string Atom10ToXmlString(Atom10FeedFormatter feed)
{
using (StringWriter sw = new StringWriter())
{
using (XmlWriter xw = XmlWriter.Create(sw))
{
feed.WriteTo(xw);
}
return(sw.ToString());
}
}
public RssResponse(SyndicationFeed feed)
{
StatusCode = HttpStatusCode.OK;
ContentType = "application/rss+xml";
Contents = stream => {
using (var writer = XmlWriter.Create(stream)) {
var formatter = new Atom10FeedFormatter(feed);
formatter.WriteTo(writer);
}
};
}
public static void SerializeToStream(IRequestContext requestContext,
object response, Stream stream)
{
if (!(response is SyndicationFeed))
ServiceStack.Text.XmlSerializer.SerializeToStream(response, stream);
var sw = XmlWriter.Create(stream);
Atom10FeedFormatter atomFormatter = new Atom10FeedFormatter((SyndicationFeed)response);
atomFormatter.WriteTo(sw);
sw.Flush();
sw.Close();
}
public SyndicationFeed CanReadAtom(XmlReader xmlReader)
{
var atom = new Atom10FeedFormatter();
// try to read it as an atom feed
if (atom.CanRead(xmlReader))
{
atom.ReadFrom(xmlReader);
return(atom.Feed);
}
return(null);
}
public void Write(IOutputWriter outputWriter)
{
var builder = new StringBuilder();
var writer = XmlWriter.Create(builder);
var theResultingFeed = BuildFeed();
var formatter = new Atom10FeedFormatter(theResultingFeed);
formatter.WriteTo(writer);
writer.Close();
outputWriter.Write(_definition.ContentType, builder.ToString());
}
/// <summary>
/// Posts the index of the atom feed to.
/// </summary>
/// <returns><c>true</c>, if atom feed to index was posted, <c>false</c> otherwise.</returns>
/// <param name="context">Context.</param>
/// <param name="feed">Feed.</param>
/// <param name="index">Index.</param>
/// <param name="username">Username.</param>
/// <param name="apikey">Apikey.</param>
public static bool PostAtomFeedToIndex(IfyContext context, OwsContextAtomFeed feed, string index, string username, string apikey)
{
using (var stream = new MemoryStream()) {
var sw = System.Xml.XmlWriter.Create(stream);
Atom10FeedFormatter atomFormatter = new Atom10FeedFormatter((SyndicationFeed)feed);
atomFormatter.WriteTo(sw);
sw.Flush();
sw.Close();
stream.Seek(0, SeekOrigin.Begin);
return(PostStreamToIndex(context, stream, index, username, apikey));
}
}
public static void SerializeToStream(SyndicationFeed feed, TextWriter writer)
{
var sw = XmlWriter.Create(writer, new XmlWriterSettings()
{
Indent = true
});
Atom10FeedFormatter atomFormatter = new Atom10FeedFormatter(feed);
atomFormatter.WriteTo(sw);
sw.Flush();
sw.Close();
}
public object Invoke(object instance, object[] inputs, out object[] outputs)
{
outputs = null;
Message result = null;
try
{
UriTemplateMatch match = (UriTemplateMatch)OperationContext.Current.IncomingMessageProperties["HelpPageMatch"];
string operation = (string)match.Data;
if (operation == "GetFeed")
{
Atom10FeedFormatter feed = GetFeed();
WebOperationContext.Current.OutgoingResponse.ContentType = "application/atom+xml";
result = Message.CreateMessage(MessageVersion.None, null, feed);
}
else if (operation == "GetRequestSchema")
{
result = GetRequestXmlSchema(match.BoundVariables["operation"]);
}
else if (operation == "GetRequestExample")
{
result = GetRequestExample(match.BoundVariables["operation"]);
}
else if (operation == "GetResponseSchema")
{
result = GetResponseXmlSchema(match.BoundVariables["operation"]);
}
else if (operation == "GetResponseExample")
{
result = GetResponseExample(match.BoundVariables["operation"]);
}
else
{
WebOperationContext.Current.OutgoingResponse.SetStatusAsNotFound();
result = Message.CreateMessage(MessageVersion.None, null);
}
if (result != null)
{
CacheResult();
}
else
{
WebOperationContext.Current.OutgoingResponse.SetStatusAsNotFound();
}
}
catch (Exception e)
{
WebOperationContext.Current.OutgoingResponse.StatusCode = HttpStatusCode.InternalServerError;
WebOperationContext.Current.OutgoingResponse.StatusDescription = e.Message;
}
return(result);
}
private SyndicationFeed GetFeedForMessage(Message message)
{
var messageId = message.Id.Value;
var topicId = message.TopicId;
var feedEntry = new FeedEntry()
{
MessageId = messageId, TimeStamp = DateTime.UtcNow
};
var feed = new Feed()
{
Entries = new List <FeedEntry>(new[] { feedEntry }),
Id = Identity.Random(),
TopicId = topicId,
Updated = DateTime.UtcNow
};
var topic = new Topic()
{
Id = topicId,
Name = "Topic Name",
Description = "Topic Description",
GroupId = Identity.Random()
};
var key = new MessageKey {
MessageId = messageId, TopicId = topicId
};
messageByMessageKey
.Setup(r => r.Get(It.Is <MessageKey>(k => k.TopicId == key.TopicId && k.MessageId == key.MessageId)))
.Returns(message);
getWorkingFeedForTopic
.Setup(r => r.Execute(topicId))
.Returns(feed);
entityById
.Setup(r => r.Get <Topic>(topicId))
.Returns(topic);
var client = new HttpClient(baseUri);
var response = client.Get(topicId.ToString());
var formatter = new Atom10FeedFormatter();
using (var rdr = XmlReader.Create(response.Content.ContentReadStream))
{
formatter.ReadFrom(rdr);
return(formatter.Feed);
}
}
private static void AtomFeedPositiveTest(string file)
{
string serializeFilePath = Path.GetTempFileName();
bool toDeletedFile = true;
try
{
SyndicationFeed feedObjct;
using (XmlReader reader = XmlReader.Create(file))
{
feedObjct = SyndicationFeed.Load(reader);
reader.Close();
}
using (XmlWriter writer = XmlWriter.Create(serializeFilePath))
{
Atom10FeedFormatter f = new Atom10FeedFormatter(feedObjct);
f.WriteTo(writer);
writer.Close();
}
CompareHelper ch = new CompareHelper
{
Diff = new XmlDiff()
{
Option = XmlDiffOption.IgnoreComments | XmlDiffOption.IgnorePrefix | XmlDiffOption.IgnoreWhitespace | XmlDiffOption.IgnoreChildOrder | XmlDiffOption.IgnoreAttributeOrder
},
AllowableDifferences = GetAtomFeedPositiveTestAllowableDifferences()
};
if (!ch.Compare(file, serializeFilePath))
{
toDeletedFile = false;
Assert.True(false, $"The generated file was different from the baseline file{Environment.NewLine}Baseline: {file}{Environment.NewLine}Actual: {serializeFilePath}");
}
}
catch (Exception e)
{
Console.WriteLine();
Console.WriteLine("------------------------------");
Console.WriteLine($"Failed File Name:{file}");
throw e;
}
finally
{
if (toDeletedFile)
{
File.Delete(serializeFilePath);
}
}
}
// <Snippet10>
public void SerializeFeed(SyndicationFeed feed)
{
Atom10FeedFormatter atomFormatter = feed.GetAtom10Formatter();
Rss20FeedFormatter rssFormatter = feed.GetRss20Formatter();
XmlWriter atomWriter = XmlWriter.Create("atom.xml");
XmlWriter rssWriter = XmlWriter.Create("rss.xml");
atomFormatter.WriteTo(atomWriter);
rssFormatter.WriteTo(rssWriter);
atomWriter.Close();
rssWriter.Close();
}
public void ReadFrom1()
{
Atom10FeedFormatter f = new Atom10FeedFormatter();
Assert.IsNull(f.Feed, "#1");
f.ReadFrom(CreateReader("<feed xmlns='http://www.w3.org/2005/Atom'><title>test</title></feed>"));
SyndicationFeed feed1 = f.Feed;
Assert.IsNotNull(f.Feed.Title, "#2");
Assert.AreEqual("test", f.Feed.Title.Text, "#3");
f.ReadFrom(CreateReader("<feed xmlns='http://www.w3.org/2005/Atom'><title>test</title></feed>"));
Assert.IsFalse(object.ReferenceEquals(feed1, f.Feed), "#4");
}
public static void Snippet12()
{
// <Snippet12>
Atom10FeedFormatter feedFormatter = new Atom10FeedFormatter();
XmlReader atomReader = XmlReader.Create("http://Contoso/Feeds/MyFeed");
if (feedFormatter.CanRead(atomReader))
{
feedFormatter.ReadFrom(atomReader);
atomReader.Close();
}
// </Snippet12>
}
public void Can_Read_Atom_Feed()
{
var formatter = new Atom10FeedFormatter();
using (var reader = XmlReader.Create("../../../XML/people07102013055734.xml"))
{
formatter.ReadFrom(reader);
}
foreach (SyndicationItem item in formatter.Feed.Items)
{
Console.WriteLine("PhotoId:" + item.Id + "|" + "" + item.Title.Text + " " + item.LastUpdatedTime);
}
}
public async Task <Stream> GetStreamAsync()
{
MemoryStream ms = new MemoryStream();
return(await Task <Stream> .Run(() =>
{
var sw = XmlWriter.Create(ms);
Atom10FeedFormatter atomFormatter = new Atom10FeedFormatter(feed);
atomFormatter.WriteTo(sw);
sw.Flush();
ms.Seek(0, SeekOrigin.Begin);
return ms as Stream;
}));
}
/// <summary>
/// Initializes a new instance of the <see cref="website.Controllers.BlogController"/> class.
/// </summary>
public BlogController()
{
_feed = new Atom10FeedFormatter();
using (XmlReader reader = XmlReader.Create("http://mattgaikema.blogspot.com/feeds/posts/default"))
{
_feed.ReadFrom(reader);
}
_posts = new Dictionary <string, SyndicationItem>();
foreach (SyndicationItem item in _feed.Feed.Items)
{
_posts.Add(item.Title.Text, item);
}
}
private void BuildSyndicationFeed(object models, Stream stream, string contenttype)
{
string baseUrl = request.Url.Scheme + "://" + request.Url.Authority;
var items = new List<SyndicationItem>();
var feed = new SyndicationFeed
{
Title = new TextSyndicationContent(portalSettings.PortalName),
Description = new TextSyndicationContent(portalSettings.Description),
Copyright = new TextSyndicationContent(portalSettings.FooterText),
Id = new Uri(baseUrl).ToString(),
LastUpdatedTime = new DateTimeOffset(DateTime.Now)
};
var link = new SyndicationLink(new Uri(baseUrl + request.RawUrl))
{
RelationshipType = "self",
Title = portalSettings.PortalName
};
feed.Links.Add(link);
link = new SyndicationLink(new Uri(baseUrl)) {MediaType = "text/html", Title = portalSettings.PortalName};
feed.Links.Add(link);
var list = models as List<AnnouncementInfo>;
if (list != null)
{
items.AddRange(from announcementInfo in list select BuildSyndicationItem(announcementInfo));
}
else
{
items.Add(BuildSyndicationItem((AnnouncementInfo)models));
}
feed.Items = items;
using (var writer = XmlWriter.Create(stream))
{
if (string.Equals(contenttype, atom))
{
var atomformatter = new Atom10FeedFormatter(feed);
atomformatter.WriteTo(writer);
}
else
{
var rssformatter = new Rss20FeedFormatter(feed);
rssformatter.WriteTo(writer);
}
}
}
public static void SerializeToStream(IRequestContext requestContext, object response, Stream stream)
{
var syndicationFeed = response as SyndicationFeed;
if (syndicationFeed == null)
{
return;
}
using (XmlWriter xmlWriter = XmlWriter.Create(stream)) {
Atom10FeedFormatter atomFormatter = new Atom10FeedFormatter(syndicationFeed);
atomFormatter.WriteTo(xmlWriter);
}
}
private static void _WriteAtomFeed(string file, SyndicationFeed feed, Logger log)
{
var sb = new StringBuilder();
using (var stringStream = new StringWriter(sb))
using (var writer = XmlWriter.Create(stringStream))
{
var formatter = new Atom10FeedFormatter(feed);
formatter.WriteTo(writer);
}
log.Info($"Writing updated feed to {file}");
File.WriteAllText(file, XElement.Parse(sb.ToString()).ToString());
}
public override Task WriteToStreamAsync(Type type, object value, System.IO.Stream writeStream, HttpContent content, System.Net.TransportContext transportContext)
{
// creating a System.ServiceModel.Syndication.SyndicationFeed
var feed = CreateFeed(type, value);
return(Task.Run(() =>
{
using (var writer = XmlWriter.Create(writeStream))
{
Atom10FeedFormatter atomformatter = new Atom10FeedFormatter(feed);
atomformatter.WriteTo(writer);
}
}));
}
public override T ConvertToObject <T>(String xml)
{
StringReader sr = new StringReader(xml);
XmlReader reader = XmlReader.Create(sr);
Atom10FeedFormatter atom = new Atom10FeedFormatter();
if (!atom.CanRead(reader))
{
throw new Exception("Mallformed Atom xml");
}
SyndicationFeedFormatter formatter = atom;
formatter.ReadFrom(reader);
SyndicationFeed feed = formatter.Feed;
StringBuilder sb = new StringBuilder();
XmlWriter writer = XmlWriter.Create(sb);
XmlDocument doc = new XmlDocument();
XmlElement ele = doc.CreateElement("entry");
ele.WriteTo(writer);
foreach (var entry in feed.Items)
{
SyndicationContent content = entry.Content;
if (writer != null)
{
content.WriteTo(writer, "entry", "");
}
}
doc.LoadXml(sb.ToString());
/*
* switch (typeof(T).Name)
* {
* case "Activity":
* return ConvertActivities(doc);
* case "DataCollection":
* return ConvertAppData(doc);
* case "Message":
* return ConvertMessages(doc);
* case "Person":
* return ConvertPeople(doc);
* }
* */
throw new NotImplementedException();
return(default(T));
}
public static object DeserializeFromStream(Type type, Stream stream)
{
if (type == typeof(SyndicationFeed)) {
var sw = XmlReader.Create(stream);
Atom10FeedFormatter atomFormatter = new Atom10FeedFormatter();
atomFormatter.ReadFrom(sw);
sw.Close();
return atomFormatter.Feed;
} else {
try {
return ServiceStack.Text.XmlSerializer.DeserializeFromStream(type, stream);
}
catch (Exception e){
stream.Seek(0, SeekOrigin.Begin);
return Activator.CreateInstance(type);
}
}
}
public void SerializeToStream(System.IO.Stream stream)
{
var sw = XmlWriter.Create(stream);
Atom10FeedFormatter atomFormatter = new Atom10FeedFormatter(this.Feed);
atomFormatter.WriteTo(sw);
sw.Flush();
sw.Close();
}
