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