public async Task <IActionResult> Feed() { var builder = new StringBuilder(); var sw = new StringWriter(builder); using (XmlWriter xmlWriter = XmlWriter.Create(sw, new XmlWriterSettings() { Async = true, Indent = true, OmitXmlDeclaration = true })) { var writer = new RssFeedWriter(xmlWriter); await writer.WriteTitle("Test Feed"); await writer.WriteDescription("Test description of the feed"); foreach (var item in Enumerable.Range(0, 9)) { var feedItem = new SyndicationItem(); feedItem.Title = $"Setting-{item}"; feedItem.Description = $"Value {item}"; await writer.Write(feedItem); } xmlWriter.Flush(); } return(new ContentResult { Content = builder.ToString(), ContentType = "application/rss+xml" }); }
public static async Task <string> ToRSS(this IList <Page> pages) { using (var stringWriter = new StringWriter()) { using (var xmlWriter = XmlWriter.Create(stringWriter, new XmlWriterSettings { Async = true, Indent = true, Encoding = Encoding.UTF8, WriteEndDocumentOnClose = true })) { var rssWriter = new RssFeedWriter(xmlWriter); var tasks = new List <Task> { rssWriter.WriteTitle(Settings.Title), rssWriter.WriteDescription(Settings.Description), rssWriter.Write(new SyndicationLink(new Uri(Settings.Domain))) }; tasks.AddRange(pages.Select(p => rssWriter.Write(p.ToSyndicationItem()))); Task.WaitAll(tasks.ToArray()); await rssWriter.Flush(); } return(stringWriter.ToString()); } }
private async Task <ISyndicationFeedWriter> GetWriter(string type, XmlWriter xmlWriter, DateTime updated) { string host = Request.Scheme + "://" + Request.Host + "/"; if (type.Equals("rss", StringComparison.OrdinalIgnoreCase)) { var rss = new RssFeedWriter(xmlWriter); await rss.WriteTitle(_manifest.Name); await rss.WriteDescription(_manifest.Description); await rss.WriteGenerator("BrickApp"); await rss.WriteValue("link", host); return(rss); } var atom = new AtomFeedWriter(xmlWriter); await atom.WriteTitle(_manifest.Name); await atom.WriteId(host); await atom.WriteSubtitle(_manifest.Description); await atom.WriteValue("updated", updated.ToString("yyyy-MM-ddTHH:mm:ssZ")); return(atom); }
public async Task <MemoryStream> Write() { var sw = new MemoryStream(); using (var xmlWriter = XmlWriter.Create(sw, new XmlWriterSettings() { Async = true, Indent = true })) { var writer = new RssFeedWriter(xmlWriter); await writer.WriteTitle(Title); await writer.WriteDescription(Description); await writer.Write(Link); var languageElement = new SyndicationContent("language") { Value = Language }; await writer.Write(languageElement); foreach (var item in Items) { await writer.Write(item); } await writer.WritePubDate(LastUpdatedTime); await xmlWriter.FlushAsync(); } return(sw); }
public async Task ProcessRequest(IDotvvmRequestContext context) { var items = await this.GetSyndicationItemsAsync(15); using (var sw = new StreamWriter(this.context.HttpContext.Response.Body, Encoding.UTF8, 1024, true)) { var settings = new XmlWriterSettings { Async = true, Indent = true, Encoding = Encoding.UTF8, OmitXmlDeclaration = true }; using (var xmlWriter = XmlWriter.Create(sw, settings)) { var writer = new RssFeedWriter(xmlWriter); await writer.WriteTitle("ASKme"); await writer.WriteDescription("Zeptej se mě na co chceš, já na co chci odpovím"); await writer.Write(new SyndicationLink(this.GetAbsoluteUri())); await writer.WritePubDate(DateTimeOffset.UtcNow); foreach (var item in items) { await writer.Write(item); } await writer.Flush(); xmlWriter.Flush(); } } }
private async Task <ISyndicationFeedWriter> GetWriter(string type, XmlWriter xmlWriter, DateTime updated) { string host = Request.Scheme + "://" + Request.Host + "/"; if (type.Equals("rss", StringComparison.OrdinalIgnoreCase)) { var rss = new RssFeedWriter(xmlWriter); await rss.WriteTitle(_settings.Value.Name); await rss.WriteDescription(_settings.Value.Description); await rss.WriteGenerator("Miniblog.Core"); await rss.WriteValue("link", host); return(rss); } var atom = new AtomFeedWriter(xmlWriter); await atom.WriteTitle(_settings.Value.Name); await atom.WriteId(host); await atom.WriteSubtitle(_settings.Value.Description); await atom.WriteGenerator("Miniblog.Core", "https://github.com/madskristensen/Miniblog.Core", "1.0"); await atom.WriteValue("updated", updated.ToString("yyyy-MM-ddTHH:mm:ssZ")); return(atom); }
public async Task <IActionResult> RssFeed() { var homepageUrl = this.Url.Page("/Index", pageHandler: null, values: null, protocol: this.Request.Scheme); var items = await this.GetSyndicationItemsAsync(this.Request.Scheme, 15); using (var sw = new StringWriter()) { var settings = new XmlWriterSettings { Async = true, Indent = true, Encoding = Encoding.UTF8, OmitXmlDeclaration = true }; using (var xmlWriter = XmlWriter.Create(sw, settings)) { var writer = new RssFeedWriter(xmlWriter); await writer.WriteTitle("ASKme"); await writer.WriteDescription("Zeptej se mě na co chceš, já na co chci odpovím"); await writer.Write(new SyndicationLink(new Uri(homepageUrl))); await writer.WritePubDate(DateTimeOffset.UtcNow); foreach (var item in items) { await writer.Write(item); } xmlWriter.Flush(); } return(File(Encoding.UTF8.GetBytes(sw.ToString()), "application/rss+xml;charset=utf-8")); } }
public async Task WriteRss20FileAsync(string absolutePath) { var feed = GetSyndicationItemCollection(FeedItemCollection); var settings = new XmlWriterSettings { Async = true, Encoding = Encoding.UTF8, Indent = true }; using var xmlWriter = XmlWriter.Create(absolutePath, settings); var writer = new RssFeedWriter(xmlWriter); await writer.WriteTitle(HeadTitle); await writer.WriteDescription(HeadDescription); await writer.Write(new SyndicationLink(new Uri(TrackBackUrl))); await writer.WritePubDate(DateTimeOffset.UtcNow); await writer.WriteCopyright(Copyright); await writer.WriteGenerator(Generator); foreach (var item in feed) { await writer.Write(item); } await xmlWriter.FlushAsync(); xmlWriter.Close(); }
private async Task <ISyndicationFeedWriter> GetWriter(string?type, XmlWriter xmlWriter, DateTime updated) { var host = $"{this.Request.Scheme}://{this.Request.Host}/"; if (type?.Equals("rss", StringComparison.OrdinalIgnoreCase) ?? false) { var rss = new RssFeedWriter(xmlWriter); await rss.WriteTitle(this.manifest.Name).ConfigureAwait(false); await rss.WriteDescription(this.manifest.Description).ConfigureAwait(false); await rss.WriteGenerator("Miniblog.Core").ConfigureAwait(false); await rss.WriteValue("link", host).ConfigureAwait(false); return(rss); } var atom = new AtomFeedWriter(xmlWriter); await atom.WriteTitle(this.manifest.Name).ConfigureAwait(false); await atom.WriteId(host).ConfigureAwait(false); await atom.WriteSubtitle(this.manifest.Description).ConfigureAwait(false); await atom.WriteGenerator("Miniblog.Core", "https://github.com/madskristensen/Miniblog.Core", "1.0").ConfigureAwait(false); await atom.WriteValue("updated", updated.ToString("yyyy-MM-ddTHH:mm:ssZ", CultureInfo.InvariantCulture)).ConfigureAwait(false); return(atom); }
private async Task <ISyndicationFeedWriter> GetWriter(string type, XmlWriter xmlWriter, DateTime updated) { var host = Request.Scheme + "://" + Request.Host + "/"; if (type.Equals("rss", StringComparison.OrdinalIgnoreCase)) { var rss = new RssFeedWriter(xmlWriter); await rss.WriteTitle(_settings.Brand); await rss.WriteDescription(_settings.Description); await rss.WriteGenerator("Bagombo Blog Engine"); await rss.WriteValue("link", host); return(rss); } var atom = new AtomFeedWriter(xmlWriter); await atom.WriteTitle(_settings.Brand); await atom.WriteId(host); await atom.WriteSubtitle(_settings.Description); await atom.WriteGenerator("Bagombo Blog Engine", "https://github.com/tylerlrhodes/bagobo", "0.2.5a"); await atom.WriteValue("updated", updated.ToString("yyyy-MM-ddTHH:mm:ssZ")); return(atom); }
public override async Task ExecuteResultAsync(ActionContext context) { using (XmlWriter xmlWriter = XmlWriter.Create(context.HttpContext.Response.Body, new XmlWriterSettings { Async = true, Indent = true })) { var writer = new RssFeedWriter(xmlWriter); await writer.WriteTitle(m_feedTitle); await writer.WriteDescription(m_feedTitle); await writer.Write(new SyndicationLink(m_feedRequestUrl)); //await writer.WritePubDate(DateTimeOffset.UtcNow); foreach (var syndicationItem in m_feedItems) { syndicationItem.Id = null; // GUID in RSS is not required await writer.Write(syndicationItem); } xmlWriter.Flush(); } }
public async Task StatusFeed() { var item = new SyndicationItem { Title = "status" }; item.AddLink(new SyndicationLink(new Uri("http://www.w3.org/2005/Atom"))); using (var writer = new StringWriter()) { using (var xmlWriter = XmlWriter.Create(writer, new XmlWriterSettings() { Async = true, Indent = true, Encoding = Encoding.UTF8 })) { var rssWriter = new RssFeedWriter(xmlWriter); await rssWriter.WriteTitle("This is the title"); await rssWriter.WriteDescription("description"); await rssWriter.Write(item); } var text = writer.ToString(); } }
private XmlFeedWriter InitializeRssFeedWriter(XmlWriter xmlWriter) { var result = new RssFeedWriter(xmlWriter); result.WriteTitle(_siteSettings.SiteName); result.WriteDescription(_siteSettings.Description); result.WriteCopyright(_siteSettings.Copyright); result.WriteGenerator(_siteSettings.Nickname); result.WritePubDate(_blogPostsConfig.Blogs.Where(x => x.Published).First().CreateDate.Date); return(result); }
private async Task addChannelIdentityAsync(RssFeedWriter rssFeedWriter) { await rssFeedWriter.WriteDescription(_feedChannel.FeedDescription.ApplyRle().RemoveHexadecimalSymbols()); await rssFeedWriter.WriteCopyright(_feedChannel.FeedCopyright.ApplyRle().RemoveHexadecimalSymbols()); await rssFeedWriter.WriteTitle(_feedChannel.FeedTitle.ApplyRle().RemoveHexadecimalSymbols()); await rssFeedWriter.WriteLanguage(new CultureInfo(_feedChannel.CultureName)); await rssFeedWriter.WriteRaw($"<atom:link href=\"{_httpContextInfo.GetRawUrl()}\" rel=\"self\" type=\"application/rss+xml\" />"); await rssFeedWriter.Write(new SyndicationLink(_httpContextInfo.GetBaseUri(), relationshipType : RssElementNames.Link)); }
public async Task Podcast() { Response.ContentType = "application/rss+xml"; List <SyndicationItem> items = new List <SyndicationItem>(); List <Podcast.Models.Podcast> podcasts = _dbContext.Podcasts.Where(p => p.Published).OrderByDescending(p => p.Episode).ToList(); if (podcasts != null) { foreach (Podcast.Models.Podcast podcast in podcasts) { SyndicationItem item = new SyndicationItem() { Id = podcast.Episode.ToString(), Title = podcast.Title, Description = MarkdownHelper.Markdown(podcast.Description).Value, Published = podcast.DatePublished }; item.AddLink(new SyndicationLink(new Uri(Url.SubRouteUrl("podcast", "Podcast.View", new { episode = podcast.Episode })))); foreach (Podcast.Models.PodcastFile file in podcast.Files) { SyndicationLink enclosure = new SyndicationLink(new Uri(Url.SubRouteUrl("podcast", "Podcast.Download", new { episode = podcast.Episode, fileName = file.FileName }))); item.AddLink(enclosure); } items.Add(item); } } using (var xmlWriter = CreateXmlWriter()) { var feedWriter = new RssFeedWriter(xmlWriter); await feedWriter.WriteTitle(_config.PodcastConfig.Title); await feedWriter.WriteDescription(_config.PodcastConfig.Description); await feedWriter.Write(new SyndicationLink(new Uri(Url.SubRouteUrl("podcast", "Podcast.Index")))); foreach (SyndicationItem item in items) { await feedWriter.Write(item); } await xmlWriter.FlushAsync(); } }
public async Task ExecuteResultAsync(ActionContext context) { var response = context.HttpContext.Response; var request = context.HttpContext.Request; response.ContentType = "application/xml"; var host = request.Scheme + "://" + request.Host; using (var xmlWriter = XmlWriter.Create(response.Body, new XmlWriterSettings() { Async = true, Indent = true, Encoding = new UTF8Encoding(true) })) { var rss = new RssFeedWriter(xmlWriter); await rss.WriteTitle(_options.Value.Title); await rss.WriteDescription(_options.Value.Description); await rss.WriteGenerator(_options.Value.GeneratorDescription); await rss.WriteValue("link", host); foreach (var post in _page.Items) { var item = new AtomEntry { Title = post.Title, Description = post.GetContentWithoutDataSrc(), Id = post.Id.ToString(), Published = post.PublishedDate.Value, LastUpdated = post.ModifiedDate, ContentType = "html", }; foreach (var tag in post.BlogStoryTags) { item.AddCategory(new SyndicationCategory(tag.Tag.Name)); } item.AddContributor(new SyndicationPerson(_options.Value.AuthorName, _options.Value.FullEmail, "author")); item.AddLink(new SyndicationLink(new Uri($"{host}/{post.Alias}"))); await rss.Write(item); } } }
public async Task Index() { Response.ContentType = "application/rss+xml"; using (var xmlWriter = CreateXmlWriter()) { var feedWriter = new RssFeedWriter(xmlWriter); await feedWriter.WriteTitle("Teknik RSS"); await feedWriter.WriteDescription("RSS feeds for the Teknik Services."); await feedWriter.Write(new SyndicationLink(new Uri(Url.SubRouteUrl("help", "Help.RSS")))); await xmlWriter.FlushAsync(); } }
private async Task <string> FormatGamerskyFeed(IEnumerable <GamerskyEntry> entries) { var sw = new StringWriterWithEncoding(Encoding.UTF8); using (XmlWriter xmlWriter = XmlWriter.Create(sw, new XmlWriterSettings() { Async = true, Indent = true })) { var writer = new RssFeedWriter(xmlWriter); await writer.WriteTitle("Gamersky RSS feed"); await writer.WriteDescription("Gamersky RSS feed"); await writer.Write(new SyndicationLink(new Uri("https://www.gamersky.com/"))); await writer.WritePubDate(DateTimeOffset.UtcNow); foreach (var e in entries) { try { var item = new SyndicationItem() { Id = e.Link, Title = e.Title, Published = e.PubDate, Description = e.Content, }; item.AddLink(new SyndicationLink(new Uri(e.Link))); await writer.Write(item); } catch (Exception ex) { Console.WriteLine($"Issue happens during generating rss for {e.Link}"); Console.WriteLine(e.Title); Console.WriteLine(e.Content); Console.WriteLine(e.PubDate); Console.WriteLine(ex.ToString()); } } xmlWriter.Flush(); } return(sw.ToString()); }
static void WriteRss(IEnumerable <dynamic> items) { var streamWritter = File.CreateText($"../{FeedPath}"); using (var xmlWriter = XmlWriter.Create(streamWritter, new XmlWriterSettings { Indent = true })) { var writer = new RssFeedWriter(xmlWriter); writer.WriteTitle(FullName); writer.WriteDescription(FeedDescription); writer.WriteValue("link", Link); var markdown = new Markdown(); foreach (var item in items) { var itemPath = string.Format(ItemFilenamePathFormat, item.MarkdownFilename); var markdownText = File.ReadAllText($"../{itemPath}"); var permalink = $"{Link}/#/{item.MarkdownFilename}"; var syndicationItem = new SyndicationItem { Title = item.Title, Description = markdown.Transform(markdownText), Published = item.Date }; syndicationItem.AddContributor(new SyndicationPerson(FullName, $"{Email} ({FullName})")); syndicationItem.AddLink(new SyndicationLink(new Uri(permalink), "guid")); string category = item.Category; if (!string.IsNullOrWhiteSpace(category)) { syndicationItem.AddCategory(new SyndicationCategory(category)); } writer.Write(syndicationItem); } xmlWriter.Flush(); } }
public async Task WriteCDATAValue() { var sb = new StringBuilder(); using (var xmlWriter = XmlWriter.Create(sb)) { var writer = new RssFeedWriter(xmlWriter, null, new RssFormatter() { UseCDATA = true }); await writer.WriteTitle("<h1>HTML Title</h1>"); await writer.Flush(); } var res = sb.ToString(); Assert.True(res == "<?xml version=\"1.0\" encoding=\"utf-16\"?><rss version=\"2.0\"><channel><title><![CDATA[<h1>HTML Title</h1>]]></title></channel></rss>"); }
/// <summary> /// Creates the feed writer and writes the initial headers. /// </summary> /// <param name="writer">The current xml writer</param> /// <param name="blog">The blog service</param> /// <param name="url">The currently requested url</param> /// <param name="host">The host name</param> /// <returns>The feed writer</returns> private async Task <ISyndicationFeedWriter> GetWriter(XmlWriter writer, IBlogService blog, string url, string host, DateTime?latest) { var segments = url.Substring(1).Split('/'); if (latest.HasValue && segments.Length == 2) { if (segments[1] == "rss") { var rss = new RssFeedWriter(writer); // Write feed headers await rss.WriteTitle(blog.Settings.Title); await rss.WriteDescription(blog.Settings.Description); await rss.WriteGenerator("RazorBlog"); await rss.WriteValue("link", host); return(rss); } else if (segments[1] == "atom") { var atom = new AtomFeedWriter(writer); // Write feed headers await atom.WriteTitle(blog.Settings.Title); await atom.WriteId(host); await atom.WriteSubtitle(blog.Settings.Description); await atom.WriteGenerator("RazorBlog", "https://github.com/tidyui/razorblog", "0.1"); await atom.WriteValue("updated", latest.Value.ToString("yyyy-MM-ddTHH:mm:ssZ")); return(atom); } } return(null); }
public async Task <string> WriteRssAsync() { var feed = GetItemCollection(FeedItemCollection); var settings = new XmlWriterSettings { Async = true }; var sw = new StringWriterWithEncoding(Encoding.UTF8); await using var xmlWriter = XmlWriter.Create(sw, settings); var writer = new RssFeedWriter(xmlWriter); await writer.WriteTitle(HeadTitle); await writer.WriteDescription(HeadDescription); await writer.Write(new SyndicationLink(new(TrackBackUrl))); await writer.WritePubDate(DateTimeOffset.UtcNow); await writer.WriteCopyright(Copyright); await writer.WriteGenerator(Generator); foreach (var item in feed) { await writer.Write(item); } await xmlWriter.FlushAsync(); xmlWriter.Close(); await sw.FlushAsync(); sw.GetStringBuilder(); var xml = sw.ToString(); return(xml); }
/// <summary> /// /// </summary> /// <param name="context"></param> /// <returns></returns> public async override Task ExecuteResultAsync(ActionContext context) { context.HttpContext.Response.ContentType = "application/rss+xml"; using var xmlWriter = XmlWriter.Create( context.HttpContext.Response.Body, new XmlWriterSettings() { Async = true, Indent = true }); var writer = new RssFeedWriter(xmlWriter); await writer.WriteTitle(feed.Title); await writer.WriteDescription(feed.Description); await writer.Write(feed.Link); await writer.WriteLastBuildDate(feed.LastUpdatedTime); var languageElement = new SyndicationContent("language") { Value = feed.Language }; await writer.Write(languageElement); foreach (var item in feed.Items) { await writer.Write(item); } await xmlWriter.WriteEndElementAsync(); await xmlWriter.WriteEndElementAsync(); await xmlWriter.FlushAsync(); }
public async Task <ISyndicationFeedWriter> GetWriter(string type, string host, XmlWriter xmlWriter) { var lastPost = _db.BlogPosts.All().OrderByDescending(p => p.Published).FirstOrDefault(); var blog = await _db.CustomFields.GetBlogSettings(); if (lastPost == null) { return(null); } if (type.Equals("rss", StringComparison.OrdinalIgnoreCase)) { var rss = new RssFeedWriter(xmlWriter); await rss.WriteTitle(blog.Title); await rss.WriteDescription(blog.Description); await rss.WriteGenerator("Blogifier"); await rss.WriteValue("link", host); return(rss); } var atom = new AtomFeedWriter(xmlWriter); await atom.WriteTitle(blog.Title); await atom.WriteId(host); await atom.WriteSubtitle(blog.Description); await atom.WriteGenerator("Blogifier", "https://github.com/blogifierdotnet/Blogifier", "1.0"); await atom.WriteValue("updated", lastPost.Published.ToString("yyyy-MM-ddTHH:mm:ssZ")); return(atom); }
public async Task <ActionResult> BlogRssFeed(string blogName) { var blog = WorkContext.Blogs.FirstOrDefault(); if (!string.IsNullOrEmpty(blogName)) { WorkContext.CurrentBlog = WorkContext.Blogs.FirstOrDefault(x => x.Name.EqualsInvariant(blogName)); } if (blog == null) { return(NotFound()); } var feedItems = new List <SyndicationItem>(); foreach (var article in blog.Articles.OrderByDescending(a => a.PublishedDate)) { if (!string.IsNullOrEmpty(article.Url)) { var urlString = UriHelper.GetDisplayUrl(Request); var requestUri = new Uri(urlString); var baseUri = new Uri(requestUri.Scheme + Uri.SchemeDelimiter + requestUri.Host); var fullUrl = new Uri(baseUri, UrlBuilder.ToAppAbsolute(article.Url, WorkContext.CurrentStore, WorkContext.CurrentLanguage)); var syndicationItem = new SyndicationItem() { Title = article.Title, Description = article.Excerpt, Published = article.PublishedDate.HasValue ? new DateTimeOffset(article.PublishedDate.Value) : new DateTimeOffset() }; syndicationItem.AddLink(new SyndicationLink(fullUrl)); feedItems.Add(syndicationItem); } } var sw = new StringWriter(); using (var xmlWriter = XmlWriter.Create(sw, new XmlWriterSettings() { Async = true, Indent = true })) { var writer = new RssFeedWriter(xmlWriter); await writer.WriteTitle(blog.Title); await writer.WriteDescription(blog.Title); await writer.Write(new SyndicationLink(new Uri(blog.Url, UriKind.Relative))); foreach (var item in feedItems) { await writer.Write(item); } xmlWriter.Flush(); } return(Content(sw.ToString(), "text/xml")); }
private async Task <string> BuildRSSFeedInternal(RSSFeedOptions rssOptions) { var sb = new StringBuilder(); using (var _ = new StringWriter(sb)) using (XmlWriter xmlWriter = XmlWriter.Create(_, new XmlWriterSettings { Async = true, Indent = true })) { //Since the XmlWriter doesn't care about actually setting UTF-8, let's just do it manually await xmlWriter.WriteProcessingInstructionAsync("xml", @"version=""1.0"" encoding=""UTF-8"""); var syndicationFeedWriter = new RssFeedWriter(xmlWriter); await syndicationFeedWriter.WriteTitle(rssOptions.Title).ConfigureAwait(false); if (!string.IsNullOrEmpty(rssOptions.Description)) { await syndicationFeedWriter.WriteDescription(rssOptions.Description).ConfigureAwait(false); } if (rssOptions.Url != null) { await syndicationFeedWriter.Write(new SyndicationLink(rssOptions.Url)).ConfigureAwait(false); if (rssOptions.ImageUrl != null) { await syndicationFeedWriter.Write(new SyndicationImage(rssOptions.ImageUrl) { Title = rssOptions.Title, Link = new SyndicationLink(rssOptions.Url) }).ConfigureAwait(false); } } //Choose the current culture if no language has been chosen await syndicationFeedWriter.WriteLanguage(rssOptions.Language ?? CultureInfo.CurrentCulture).ConfigureAwait(false); if (!string.IsNullOrEmpty(rssOptions.ManagingEditor)) { await syndicationFeedWriter.Write(new SyndicationPerson(null, rssOptions.ManagingEditor, RssContributorTypes.ManagingEditor)).ConfigureAwait(false); } //Do we even still care about Webmaster? if (!string.IsNullOrEmpty(rssOptions.Webmaster)) { await syndicationFeedWriter.WriteValue("webMaster", rssOptions.Webmaster).ConfigureAwait(false); } if (!string.IsNullOrEmpty(rssOptions.Copyright)) { await syndicationFeedWriter.WriteCopyright(rssOptions.Copyright).ConfigureAwait(false); } var syndicationItems = await _rssProvider.RetrieveSyndicationItems().ConfigureAwait(false); //Use the latest LastUpdated item in the list to determine the last build date. await syndicationFeedWriter.WriteLastBuildDate(syndicationItems.Max(x => x.LastUpdated)).ConfigureAwait(false); foreach (var __ in syndicationItems) { await syndicationFeedWriter.Write(__.ToSyndicationItem()).ConfigureAwait(false); } await xmlWriter.FlushAsync().ConfigureAwait(false); } return(sb.ToString()); }
public async Task <IActionResult> GetRssAsync() { var result = await Mediator.Send(new GetMaterialListQuery.Request { CurrentPage = 1, PageSize = 10 }); var host = Request.Scheme + "://" + Request.Host + "/"; var sw = new StringWriter(); var settings = new XmlWriterSettings { Async = true, Indent = true }; using (var xmlWriter = XmlWriter.Create(sw, settings)) { var attributes = new List <SyndicationAttribute> { new SyndicationAttribute("xmlns:link", host) }; var writer = new RssFeedWriter(xmlWriter); await writer.WriteTitle("MyLFC.ru - новостная лента"); var formatter = new RssFormatter(attributes, xmlWriter.Settings); foreach (var material in result.Results) { var item = new SyndicationItem { Title = material.Title, Description = $"<img src='{material.PhotoPreview}' /><br/>{material.Brief}", Id = material.Id.ToString(), Published = material.AdditionTime, LastUpdated = material.AdditionTime, }; item.AddCategory(new SyndicationCategory(material.CategoryName)); item.AddContributor(new SyndicationPerson(material.UserName, material.UserName)); item.AddLink(new SyndicationLink(new Uri(host + material.TypeName + "/" + material.Id))); //item.AddLink(new SyndicationLink(new Uri(host + material.TypeName + "/" + material.Id))); // Format the item as SyndicationContent var content = new SyndicationContent(formatter.CreateContent(item)); // Add custom fields/attributes //content.AddAttribute(new SyndicationAttribute("img", host + material.Photo)); //content.AddField(new SyndicationContent("customElement", "321321", "Custom Value")); await writer.Write(content); } xmlWriter.Flush(); } var xml = new XmlDocument(); xml.LoadXml(sw.ToString()); return(Content(xml.InnerXml, "application/xml")); // return Ok(xml.InnerXml); }
/// <summary> /// Returns the rss xml string for the blog or a blog category. The result is cached for 1 hour. /// The rss feed always returns first page with 10 results. /// </summary> /// <param name="cat"></param> /// <returns></returns> private async Task <string> GetFeed(Category cat = null) { var key = cat == null ? "RssFeed" : $"RssFeed_{cat.Slug}"; return(await _cache.GetAsync(key, new TimeSpan(1, 0, 0), async() => { var sw = new StringWriter(); using (XmlWriter xmlWriter = XmlWriter.Create(sw, new XmlWriterSettings() { Async = true, Indent = true })) { var postList = cat == null ? await _blogSvc.GetPostsAsync(1, 10) : await _blogSvc.GetPostsForCategoryAsync(cat.Slug, 1); var coreSettings = await _settingSvc.GetSettingsAsync <CoreSettings>(); var blogSettings = await _settingSvc.GetSettingsAsync <BlogSettings>(); var vm = new BlogPostListViewModel(postList, blogSettings, Request); var channelTitle = cat == null ? "Fanray" : $"{cat.Title} - Fanray"; var channelDescription = coreSettings.Tagline; var channelLink = $"{Request.Scheme}://{Request.Host}"; var channelLastPubDate = postList.Posts.Count <= 0 ? DateTimeOffset.UtcNow : postList.Posts[0].CreatedOn; var writer = new RssFeedWriter(xmlWriter); await writer.WriteTitle(channelTitle); await writer.WriteDescription(channelDescription); await writer.Write(new SyndicationLink(new Uri(channelLink))); await writer.WritePubDate(channelLastPubDate); await writer.WriteGenerator("https://www.fanray.com"); foreach (var postVM in vm.BlogPostViewModels) { var post = postVM; var item = new SyndicationItem() { Id = postVM.Permalink, // guid https://www.w3schools.com/xml/rss_tag_guid.asp Title = post.Title, Description = blogSettings.FeedShowExcerpt ? post.Excerpt : post.Body, Published = post.CreatedOn, }; // link to the post item.AddLink(new SyndicationLink(new Uri(postVM.CanonicalUrl))); // category takes in both cats and tags item.AddCategory(new SyndicationCategory(post.Category.Title)); foreach (var tag in post.Tags) { item.AddCategory(new SyndicationCategory(tag.Title)); } // https://www.w3schools.com/xml/rss_tag_author.asp // the author tag exposes email //item.AddContributor(new SyndicationPerson(post.User.DisplayName, post.User.Email)); await writer.Write(item); } xmlWriter.Flush(); } return sw.ToString(); })); }
public async Task <ActionResult> Feed() { var entries = await this.unitOfWork.BlogEntries .Include(b => b.Author) .Include(b => b.Tags) .ThenInclude(t => t.Tag) .AsNoTracking() .Where(b => b.Visible && b.PublishDate <= DateTimeOffset.UtcNow) .OrderByDescending(b => b.PublishDate) .ToListAsync(); string baseUrl = $"{this.Request.Scheme}://{this.Request.Host}{this.Request.PathBase}"; using (var sw = new StringWriterWithEncoding(Encoding.UTF8)) { using (XmlWriter xmlWriter = XmlWriter.Create(sw, new XmlWriterSettings() { Async = true, Indent = true })) { var writer = new RssFeedWriter(xmlWriter); await writer.WriteTitle(this.blogSettings.BlogName); await writer.WriteDescription(this.blogSettings.BlogDescription); await writer.Write(new SyndicationLink(new Uri(baseUrl))); await writer.WriteRaw($"<atom:link href=\"{baseUrl}/Blog/{nameof(this.Feed)}\" rel=\"self\" type=\"application/rss+xml\" xmlns:atom=\"http://www.w3.org/2005/Atom\" />"); await writer.Write(new SyndicationImage(new Uri($"{baseUrl}/apple-touch-icon_192.png")) { Title = this.blogSettings.BlogName, Description = this.blogSettings.BlogDescription, Link = new SyndicationLink(new Uri(baseUrl)) }); if (entries.Count > 0) { await writer.WritePubDate(entries[0].PublishDate); } var pipeline = new MarkdownPipelineBuilder() .UseAdvancedExtensions() .Build(); foreach (var blogEntry in entries) { var syndicationItem = new SyndicationItem() { Id = blogEntry.Id.ToString(), Title = blogEntry.Header, Published = blogEntry.PublishDate, LastUpdated = blogEntry.PublishDate > blogEntry.UpdateDate ? blogEntry.PublishDate : blogEntry.UpdateDate, Description = $"{Markdown.ToHtml(blogEntry.ShortContent, pipeline)}{Markdown.ToHtml(blogEntry.Content, pipeline)}" }; syndicationItem.AddLink(new SyndicationLink(new Uri($"{baseUrl}/Blog/{blogEntry.Url}"))); syndicationItem.AddContributor(new SyndicationPerson(blogEntry.Author.UserName, blogEntry.Author.Email)); foreach (var tag in blogEntry.Tags) { syndicationItem.AddCategory(new SyndicationCategory(tag.Tag.Name)); } await writer.Write(syndicationItem); } xmlWriter.Flush(); } return(this.Content(sw.ToString(), "application/rss+xml")); } }
public async Task ShouldGenerateBlogRss() { var projectInfo = this.TestContext.ShouldGetProjectDirectoryInfo(this.GetType()); #region test properties: var blobContainerName = this.TestContext.Properties["blobContainerName"].ToString(); var blobContainerNameClassic = this.TestContext.Properties["blobContainerNameClassic"].ToString(); var rssPath = this.TestContext.Properties["rssPath"].ToString(); rssPath = projectInfo.ToCombinedPath(rssPath); this.TestContext.ShouldFindFile(rssPath); #endregion var containerClassic = cloudStorageAccountClassic.CreateCloudBlobClient().GetContainerReference(blobContainerNameClassic); var keys = new AzureBlobKeys(); keys.Add <BlogEntry>(i => i.Slug); var repository = new BlogRepository(keys, containerClassic); var data = await(repository as IBlogEntryIndex).GetIndexAsync(); Assert.IsTrue(data.Any(), "The expected data are not here."); var feed = data .OrderByDescending(i => i.InceptDate) .Take(10); var builder = new StringBuilder(); var settings = new XmlWriterSettings { Async = true, CloseOutput = true, Encoding = Encoding.UTF8, Indent = true, OmitXmlDeclaration = true }; var person = new SyndicationPerson("Bryan Wilhite", "*****@*****.**"); using (var writer = XmlWriter.Create(builder, settings)) { var feedWriter = new RssFeedWriter(writer); await feedWriter.WritePubDate(DateTime.Now); await feedWriter.WriteTitle($">DayPath_"); await feedWriter.WriteDescription($"The technical journey of @BryanWilhite."); await feedWriter.WriteCopyright($"Bryan Wilhite, Songhay System {DateTime.Now.Year}"); await feedWriter.Write(new SyndicationLink(new Uri("http://songhayblog.azurewebsites.net", UriKind.Absolute))); var tasks = feed.Select(async entry => { var item = new SyndicationItem { Description = entry.Content, Id = entry.Slug, LastUpdated = entry.ModificationDate, Published = entry.InceptDate, Title = entry.Title }; item.AddContributor(person); item.AddLink(new SyndicationLink(new Uri($"http://songhayblog.azurewebsites.net/blog/entry/{entry.Slug}", UriKind.Absolute))); await feedWriter.Write(item); }); await Task.WhenAll(tasks); await writer.FlushAsync(); } File.WriteAllText(rssPath, builder.ToString()); var container = cloudStorageAccount.CreateCloudBlobClient().GetContainerReference(blobContainerName); await container.UploadBlobAsync(rssPath, string.Empty); }