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();
}
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 <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 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 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 <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());
}
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>
/// 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 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);
}
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 static Task <string> GetFeedAsync(IEnumerable <Post> posts)
{
var sw = new StringWriterWithEncoding(Encoding.UTF8);
const string ExampleNs = "https://feed.lucasteles.net";
using (var xmlWriter = XmlWriter.Create(sw, new XmlWriterSettings {
Async = true, Indent = true
}))
{
var attributes = new List <SyndicationAttribute>
{
new SyndicationAttribute("xmlns:feed", ExampleNs)
};
var formatter = new RssFormatter(attributes, xmlWriter.Settings);
var writer = new RssFeedWriter(xmlWriter, null, new RssFormatter()
{
UseCDATA = true
});
//
// Add Title
await writer.WriteTitle("Lucas Teles - Blog");
//
// Add Description
await writer.WriteDescription("Tecnologia e inovação");
//
// Add Link
await writer.Write(new SyndicationLink(new Uri("https://lucasteles.net")));
//
// Add managing editor
await writer.Write(new SyndicationPerson("lucasteles", "*****@*****.**", RssContributorTypes.ManagingEditor));
//
// Add publish date
await writer.WritePubDate(DateTimeOffset.UtcNow);
//
// Add Items
foreach (var post in posts)
{
var item = new SyndicationItem
{
Id = $"https://lucasteles.net/p={post.Id}",
Title = post.Title,
Description = post.Description,
Published = post.Date,
};
item.AddLink(new SyndicationLink(new Uri($"https://lucasteles.net/{post.Path}")));
item.AddCategory(new SyndicationCategory("Technology"));
item.AddContributor(new SyndicationPerson("Lucas Teles", "*****@*****.**"));
// Format the item as SyndicationContent
var content = new SyndicationContent(formatter.CreateContent(item));
content.AddField(new SyndicationContent("content:encoded", string.Empty, post.Content));
// Write
await writer.Write(content);
}
//
// Done
xmlWriter.Flush();
}
return(sw.ToString());
}
public static async Task WriteFeed()
{
var sw = new StringWriterWithEncoding(Encoding.UTF8);
using (XmlWriter xmlWriter = XmlWriter.Create(sw, new XmlWriterSettings()
{
Async = true, Indent = true
}))
{
var writer = new RssFeedWriter(xmlWriter);
//
// Add Title
await writer.WriteTitle("Example of RssFeedWriter");
//
// Add Description
await writer.WriteDescription("Hello World, RSS 2.0!");
//
// Add Link
await writer.Write(new SyndicationLink(new Uri("https://github.com/dotnet/SyndicationFeedReaderWriter")));
//
// Add managing editor
await writer.Write(new SyndicationPerson("managingeditor", "*****@*****.**", RssContributorTypes.ManagingEditor));
//
// Add publish date
await writer.WritePubDate(DateTimeOffset.UtcNow);
//
// Add custom element
var customElement = new SyndicationContent("customElement");
customElement.AddAttribute(new SyndicationAttribute("attr1", "true"));
customElement.AddField(new SyndicationContent("Company", "Contoso"));
await writer.Write(customElement);
//
// Add Items
for (int i = 0; i < 5; ++i)
{
var item = new SyndicationItem()
{
Id = "https://www.nuget.org/packages/Microsoft.SyndicationFeed.ReaderWriter",
Title = $"Item #{i + 1}",
Description = "The new Microsoft.SyndicationFeed.ReaderWriter is now available as a NuGet package!",
Published = DateTimeOffset.UtcNow
};
item.AddLink(new SyndicationLink(new Uri("https://github.com/dotnet/SyndicationFeedReaderWriter")));
item.AddCategory(new SyndicationCategory("Technology"));
item.AddContributor(new SyndicationPerson("user", "*****@*****.**"));
await writer.Write(item);
}
//
// Done
xmlWriter.Flush();
}
//
// Ouput the feed
Console.WriteLine(sw.ToString());
}