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(); }