private void createVideoSyndicationFeed()
{
//Create syndicated feed
var myFeed = new SyndicationFeed();
myFeed.Title = TextSyndicationContent.CreatePlaintextContent(user.CompanyName);
myFeed.Description = TextSyndicationContent.CreatePlaintextContent("Video Podcast RSS FEED");
myFeed.Links.Add(SyndicationLink.CreateAlternateLink(new Uri("https://versolstore.blob.core.windows.net/" + user.CompanyName.ToLower() + "devstoreaccount1/videos/rss.xml")));
myFeed.Links.Add(SyndicationLink.CreateSelfLink(new Uri("https://versolstore.blob.core.windows.net/" + user.CompanyName.ToLower() + "devstoreaccount1/videos/rss.xml")));
myFeed.Copyright = TextSyndicationContent.CreatePlaintextContent("All rights reserved");
myFeed.Language = "en-us";
//Return the feed's xml content as the response
MemoryStream ms = new MemoryStream();
XmlWriter feedWriter = XmlWriter.Create(ms);
Rss20FeedFormatter rssFormatter = new Rss20FeedFormatter(myFeed);
rssFormatter.WriteTo(feedWriter);
feedWriter.Close();
var container = client.GetContainerReference(user.CompanyName.ToLower());
var blob = container.GetBlockBlobReference("videos/video.rss");
blob.UploadFromByteArray(ms.ToArray(), 0, ms.ToArray().Length);
ms.Close();
}
private Action <Stream> GetXmlContents(IEnumerable <Post> model)
{
var items = new List <SyndicationItem>();
foreach (Post post in model)
{
var item = new SyndicationItem(
title: post.Title,
content: post.Content,
itemAlternateLink: new Uri(siteUrl + post.Url),
id: siteUrl + post.Url,
lastUpdatedTime: post.Date.ToUniversalTime()
);
item.PublishDate = post.Date.ToUniversalTime();
item.Summary = new TextSyndicationContent(post.ContentExcerpt, TextSyndicationContentKind.Plaintext);
items.Add(item);
}
var feed = new SyndicationFeed(
this.RssTitle,
this.RssTitle, /* Using Title also as Description */
new Uri(siteUrl + "/" + feedfileName),
items);
var formatter = new Rss20FeedFormatter(feed);
return(stream =>
{
using (XmlWriter writer = XmlWriter.Create(stream))
{
formatter.WriteTo(writer);
}
});
}
public static void SyndicationFeed_CreateNewFeed()
{
string filePath = Path.GetTempFileName();
try
{
// *** SETUP *** \\
SyndicationFeed sf = new SyndicationFeed("First feed on .net core ever!!", "This is the first feed on .net core ever!", new Uri("https://github.com/dotnet/wcf"));
Assert.True(sf != null);
XmlWriter xmlw = XmlWriter.Create(filePath);
Rss20FeedFormatter rssf = new Rss20FeedFormatter(sf);
// *** EXECUTE *** \\
rssf.WriteTo(xmlw);
xmlw.Close();
// *** VALIDATE *** \\
Assert.True(File.Exists(filePath));
}
finally
{
// *** CLEANUP *** \\
File.Delete(filePath);
}
}
public void ParseAndFormat(SampleFeed embeddedDocument)
{
// arrange
var document1 = embeddedDocument.XDocument;
// action
var tryParseResult = Rss20FeedParser.TryParseRss20Feed(document1, out var feed);
Assert.True(tryParseResult);
var tryFormatResult = Rss20FeedFormatter.TryFormatRss20Feed(feed, out var document2);
Assert.True(tryFormatResult);
var xmlWriterSettings = new XmlWriterSettings {
Indent = true
};
var xmlStringBuilder1 = new StringBuilder();
var xmlStringBuilder2 = new StringBuilder();
using (var xmlWriter1 = XmlWriter.Create(xmlStringBuilder1, xmlWriterSettings))
using (var xmlWriter2 = XmlWriter.Create(xmlStringBuilder2, xmlWriterSettings))
{
document1.WriteTo(xmlWriter1);
document2.WriteTo(xmlWriter2);
xmlWriter1.Flush();
xmlWriter2.Flush();
// assert
var xmlString1 = xmlStringBuilder1.ToString();
var xmlString2 = xmlStringBuilder2.ToString();
Assert.Equal(xmlString1, xmlString2);
}
}
public RssFeed OnGetFeed(string url)
{
try
{
RssFeed rssFeed = null;
using (XmlReader reader = XmlReader.Create(url))
{
var formatter = new Rss20FeedFormatter();
formatter.ReadFrom(reader);
var DataFeed = formatter.Feed as SyndicationFeed;
var DataFeedItems = formatter.Feed.Items; //{System.ServiceModel.Syndication.SyndicationItem}
if (DataFeed != null)
{
rssFeed = MappingDataFeed(DataFeed);
}
return(rssFeed);
}
}
catch (System.IO.FileNotFoundException)
{
//throw new Exception("File " + url + "not found");
Log.Write("File " + url + "not found", "DL", "RSS_Reader", "OnGetFeed");
return(null);
}
catch (Exception ex)
{
Log.Write(ex.Message, "DL", "RSS_Reader", "OnGetFeed");
return(null);
}
}
public override void ExecuteResult(ControllerContext context)
{
context.HttpContext.Response.ContentType = "application/atom+xml";
//check request is for Atom or RSS
if (context.HttpContext.Request.QueryString["type"] != null && context.HttpContext.Request.QueryString["type"].ToString().ToLower() == "atom")
{
//Atom Feed
context.HttpContext.Response.ContentType = "application/atom+xml";
var rssFormatter = new Atom10FeedFormatter(feedData);
using (XmlWriter writer = XmlWriter.Create(context.HttpContext.Response.Output, new XmlWriterSettings {
Indent = true
}))
{
rssFormatter.WriteTo(writer);
}
}
else
{
//RSS Feed
context.HttpContext.Response.ContentType = "application/rss+xml";
var rssFormatter = new Rss20FeedFormatter(feedData);
using (XmlWriter writer = XmlWriter.Create(context.HttpContext.Response.Output, new XmlWriterSettings {
Indent = true
}))
{
rssFormatter.WriteTo(writer);
}
}
}
public ActionResult Feed()
{
var blogTitle = ConfigurationManager.AppSettings["BlogTitle"];
var blogDescription = ConfigurationManager.AppSettings["BlogDescription"];
var blogUrl = ConfigurationManager.AppSettings["BlogUrl"];
// Create a collection of SyndicationItemobjects from the latest posts
var posts = _blogRepository.Posts(0, 25).Select
(
p => new SyndicationItem
(
p.Title,
p.Description,
new Uri(string.Concat(blogUrl, p.Href(Url)))
)
);
// Create an instance of SyndicationFeed class passing the SyndicationItem collection
var feed = new SyndicationFeed(blogTitle, blogDescription, new Uri(blogUrl), posts)
{
Copyright = new TextSyndicationContent(String.Format("Copyright (c) {0}", blogTitle)),
Language = "en-US"
};
// Format feed in RSS format through Rss20FeedFormatter formatter
var feedFormatter = new Rss20FeedFormatter(feed);
// Call the custom action that write the feed to the response
return(new FeedResult(feedFormatter));
}
public static IEnumerable <Entity> GetEntitiesFromFeed(string urlFeedLocation)
{
if (String.IsNullOrEmpty(urlFeedLocation))
{
return(null);
}
using (XmlReader reader = XmlReader.Create(urlFeedLocation))
{
Atom10FeedFormatter atom = new Atom10FeedFormatter();
// try to read it as an atom feed
if (atom.CanRead(reader))
{
atom.ReadFrom(reader);
AtomFormatter formatter = new AtomFormatter();
return(formatter.GetEntities(urlFeedLocation));
}
Rss20FeedFormatter rss = new Rss20FeedFormatter();
// try reading it as an rss feed
if (rss.CanRead(reader))
{
rss.ReadFrom(reader);
RSSFormater formatter = new RSSFormater();
return(formatter.GetEntities(urlFeedLocation));
}
//add new custom formatters
}
return(null);
}
public void ReadFrom_Versionless()
{
Rss20FeedFormatter f = new Rss20FeedFormatter();
Assert.IsNull(f.Feed, "#1");
f.ReadFrom(CreateReader("<rss>"));
}
public static void SyndicationFeed_Rss_UriParser()
{
// *** SETUP *** \\
// *** EXECUTE *** \\
SyndicationFeed feed;
using (XmlReader reader = XmlReader.Create("TestFeeds/RssSpecCustomParser.xml"))
{
var formatter = new Rss20FeedFormatter
{
UriParser = (XmlUriData xmlUriData, out Uri uri) =>
{
uri = new Uri($"http://value-{xmlUriData.UriString}-kind-{xmlUriData.UriKind}-localName-{xmlUriData.ElementQualifiedName.Name}-ns-{xmlUriData.ElementQualifiedName.Namespace}-end");
return(true);
}
};
formatter.ReadFrom(reader);
feed = formatter.Feed;
}
// *** ASSERT *** \\
Assert.True(feed != null, "res was null.");
Assert.Equal(new Uri("http://value-ChannelBase-kind-relativeorabsolute-localName-channel-ns--end"), feed.BaseUri);
Assert.Equal(new Uri("http://value-ImageUrl-kind-relativeorabsolute-localName-url-ns--end"), feed.ImageUrl);
Assert.NotNull(feed.Links);
Assert.Equal(1, feed.Links.Count);
Assert.Equal(new Uri("http://value-FeedLink-kind-relativeorabsolute-localName-link-ns--end"), feed.Links.First().Uri);
Assert.True(feed.Items != null, "res.Items was null.");
Assert.Equal(1, feed.Items.Count());
Assert.Equal(1, feed.Items.First().Links.Count);
Assert.Equal(new Uri("http://value-itemlink-kind-relativeorabsolute-localName-link-ns--end"), feed.Items.First().Links.First().Uri);
}
public SyndicationFeedFormatter CreateFeed()
{
// Crear una fuente de distribución nueva.
SyndicationFeed feed = new SyndicationFeed("Feed Title", "A WCF Syndication Feed", null);
List <SyndicationItem> items = new List <SyndicationItem>();
// Crear un elemento de distribución nuevo.
SyndicationItem item = new SyndicationItem("An item", "Item content", null);
items.Add(item);
feed.Items = items;
// Devolver ATOM o RSS en función de la cadena de consulta
// rss -> http://localhost:8733/Design_Time_Addresses/SyndicationServiceLibrary1/Feed1/
// átomo -> http://localhost:8733/Design_Time_Addresses/SyndicationServiceLibrary1/Feed1/?format=atom
string query = WebOperationContext.Current.IncomingRequest.UriTemplateMatch.QueryParameters["format"];
SyndicationFeedFormatter formatter = null;
if (query == "atom")
{
formatter = new Atom10FeedFormatter(feed);
}
else
{
formatter = new Rss20FeedFormatter(feed);
}
return(formatter);
}
public void CreateRssFeed()
{
SyndicationFeed feed = new SyndicationFeed("Hyston blog", "Mumblings about programblings", new Uri("https://hyston.blog/rss"), "hyston.blog", DateTime.Now);
SyndicationPerson sp = new SyndicationPerson("[email protected] (Ilja Stepanow)", "Ilja Stepanow", "https://hyston.blog");
feed.Authors.Add(sp);
var allPosts = blogPostRepository.RetrieveAll();
List <SyndicationItem> items = new List <SyndicationItem>();
foreach (var post in allPosts)
{
try
{
TextSyndicationContent textContent = new TextSyndicationContent(post.HtmlContent);
SyndicationItem item = new SyndicationItem(post.Title, textContent, new Uri($"https://hyston.blog/{post.FileName}"), post.FileName, post.Created);
items.Add(item);
}
catch (System.Exception)
{
logger.LogError($"Failed to add post {post.FileName} into rss");
}
}
feed.Items = items;
feed.Language = "en-us";
feed.LastUpdatedTime = DateTime.Now;
var rssPath = String.Join('/', configuration["PostsLocalPath"], configuration["RssFeedFile"]);
XmlWriter rssWriter = XmlWriter.Create(rssPath);
Rss20FeedFormatter rssFormatter = new Rss20FeedFormatter(feed);
rssFormatter.WriteTo(rssWriter);
rssWriter.Close();
}
/// <summary>
/// Default Page Load Method
/// </summary>
/// <param name="sender">Sender of the event.</param>
/// <param name="e">Event Argument.</param>
protected void Page_Load(object sender, EventArgs e)
{
try
{
XmlReader reader = XmlReader.Create(BlogSyndicationUrl);
Rss20FeedFormatter rss = new Rss20FeedFormatter();
if (reader != null)
{
if (rss.CanRead(reader))
{
rss.ReadFrom(reader);
SyndicationItem item;
item = rss.Feed.Items.First <SyndicationItem>();
if (item != null)
{
this.latestBlogEntryTitle.Text = item.Title.Text;
this.latestBlogEntrySummary.Text = item.Summary.Text;
this.blogLink.NavigateUrl = item.Id;
this.blogFullPostLink.NavigateUrl = item.Id;
this.latestBlogPublishTime.Text = item.PublishDate.DateTime.ToString("dd-MMM-yyyy HH:mm", CultureInfo.CurrentCulture) + " " + "by" + " " + item.Authors[0].Email;
}
}
}
}
catch (WebException)
{
AppSettingsReader appsReader = new AppSettingsReader();
this.latestBlogEntrySummary.Text = appsReader.GetValue("LatestBlogAccessMessage", typeof(string)).ToString();
this.blogFullPostLink.Visible = false;
}
}
public SyndicationFeedFormatter CreateFeedForBlog(string user, string blog)
{
SyndicationFeed feed = new SyndicationFeed("Blog feed", "A feed linked to a blog", null);
List <SyndicationItem> items = new List <SyndicationItem>();
List <Dbo.RssArticle> articles = BusinessManagement.Feed.GetBlogContent(user, blog);
foreach (Dbo.RssArticle article in articles)
{
SyndicationItem item = new SyndicationItem(article.Title, article.Content, null);
item.PublishDate = article.CreationDate;
items.Add(item);
}
feed.Items = items;
// Renvoie ATOM ou RSS en fonction de la chaîne de requête
// rss -> http://localhost:8733/Design_Time_Addresses/FluxRss/Feed1/
// atom -> http://localhost:8733/Design_Time_Addresses/FluxRss/Feed1/?format=atom
string query = WebOperationContext.Current.IncomingRequest.UriTemplateMatch.QueryParameters["format"];
SyndicationFeedFormatter formatter = null;
if (query == "atom")
{
formatter = new Atom10FeedFormatter(feed);
}
else
{
formatter = new Rss20FeedFormatter(feed);
}
return(formatter);
}
public RssFeedItem[] GetFeedByKeywords(string urlText, string[] keywords)
{
if (!String.IsNullOrEmpty(urlText))
{
using (var reader = XmlReader.Create(urlText, new XmlReaderSettings()
{
DtdProcessing = DtdProcessing.Parse
}))
{
var formatter = new Rss20FeedFormatter();
formatter.ReadFrom(reader);
List <RssFeedItem> items = new List <RssFeedItem>();
foreach (SyndicationItem item in formatter.Feed.Items)
{
foreach (var keyword in keywords)
{
if (CultureInfo.InvariantCulture.CompareInfo.IndexOf(item.Title.Text, keyword, CompareOptions.IgnoreCase) >= 0 ||
CultureInfo.InvariantCulture.CompareInfo.IndexOf(item.Summary.Text, keyword, CompareOptions.IgnoreCase) >= 0)
{
items.Add(new RssFeedItem(item.Title.Text, item.Summary.Text, urlText));
}
}
}
return(items.ToArray());
}
}
return(Array.Empty <RssFeedItem>());
}
public SyndicationFeedFormatter CreateFeed()
{
// Создать новый веб-канал.
SyndicationFeed feed = new SyndicationFeed("Feed Title", "A WCF Syndication Feed", null);
List <SyndicationItem> items = new List <SyndicationItem>();
// Создать новый элемент рассылки.
SyndicationItem item = new SyndicationItem("An item", "Item content", null);
items.Add(item);
feed.Items = items;
// Возвращать канал ATOM или RSS, основываясь на строке запроса
// RSS-> http://localhost:8733/Design_Time_Addresses/SyndicationServiceLibrary1/Feed1/
// Atom-> http://localhost:8733/Design_Time_Addresses/SyndicationServiceLibrary1/Feed1/?format=atom
string query = WebOperationContext.Current.IncomingRequest.UriTemplateMatch.QueryParameters["format"];
SyndicationFeedFormatter formatter = null;
if (query == "atom")
{
formatter = new Atom10FeedFormatter(feed);
}
else
{
formatter = new Rss20FeedFormatter(feed);
}
return(formatter);
}
public async Task <IActionResult> GetRssFeed(string bank)
{
//TODO: move the logic somewhere where can be tested
var data = await retrieve.TodayRates(bank);
var items = data
.Select(it =>
new SyndicationItem(
it.ExchangeTo,
it.ExchangeValue.ToString(),
new Uri($"http://www.infovalutar.ro/bnr/{it.Date.Year}/{it.Date.Month}/{it.Date.Day}/{it.ExchangeTo}"))
)
.ToArray();
var feed = new SyndicationFeed(
"Curs Valutar",
"CursValutar, case, banci",
new Uri("http://www.infovalutar.ro/"),
items
);
feed.Language = "ro-ro";
feed.TimeToLive = TimeSpan.FromMinutes(10);
using var sw = new StringWriter();
using var rssWriter = XmlWriter.Create(sw);
var rssFormatter = new Rss20FeedFormatter(feed, false);
rssFormatter.WriteTo(rssWriter);
rssWriter.Close();
return(Content(sw.ToString(), "text/xml"));
}
public ActionResult Index(string url)
{
// Send request
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
request.Method = "GET";
// Get response
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
// Read Feed
XmlReader xmlReader = XmlReader.Create(response.GetResponseStream());
Rss20FeedFormatter ff = new Rss20FeedFormatter();
ff.ReadFrom(xmlReader);
List <SyndicationItem> items = ff.Feed.Items.ToList();
List <BESyndicationItem> beItems = new List <BESyndicationItem>();
for (int i = 0; i < items.Count; i++)
{
beItems.Add(new BESyndicationItem(items[i]));
}
xmlReader.Close();
response.GetResponseStream().Close();
response.Close();
return(View("RssTree", beItems));
}
public ActionResult Feed()
{
var blogTitle = "Your Blog Title";
var blogDescription = " Your Blog Description.";
var blogUrl = "http://yourblog.com ";
var posts = _blogRepository.GetPosts().Select(
p => new SyndicationItem(
p.Title,
p.ShortDescription,
new Uri(blogUrl)
)
);
// Create an instance of SyndicationFeed class passing the SyndicationItem collection
var feed = new SyndicationFeed(blogTitle, blogDescription, new Uri(blogUrl), posts)
{
Copyright = new TextSyndicationContent(string.Format("Copyright © {0}", blogTitle)),
Language = "en-US"
};
// Format feed in RSS format through Rss20FeedFormatter formatter
var feedFormatter = new Rss20FeedFormatter(feed);
// Call the custom action that write the feed to the response
return(new FeedResult(feedFormatter));
}
protected override void WriteFile(System.Web.HttpResponseBase response)
{
var items = new List <SyndicationItem>();
foreach (Dinner d in this.Dinners)
{
string contentString = String.Format("{0} with {1} on {2:MMM dd, yyyy} at {3}. Where: {4}, {5}",
d.Description, d.HostedBy, d.EventDate, d.EventDate.ToShortTimeString(), d.Address, d.Country);
var item = new SyndicationItem(
title: d.Title,
content: contentString,
itemAlternateLink: new Uri("http://nrddnr.com/" + d.DinnerId),
id: "http://nrddnr.com/" + d.DinnerId,
lastUpdatedTime: d.EventDate.ToUniversalTime()
);
item.PublishDate = d.EventDate.ToUniversalTime();
item.Summary = new TextSyndicationContent(contentString, TextSyndicationContentKind.Plaintext);
items.Add(item);
}
SyndicationFeed feed = new SyndicationFeed(
this.Title,
this.Title, /* Using Title also as Description */
currentUrl,
items);
Rss20FeedFormatter formatter = new Rss20FeedFormatter(feed);
using (XmlWriter writer = XmlWriter.Create(response.Output))
{
formatter.WriteTo(writer);
}
}
public SyndicationFeedFormatter GetWhetherInfoFeed(string format)
{
string[] locations = { "Minsk", "Vitebsk" };
//WhetherInfo res = GetWhetherInfo(location);
var feedData = new SyndicationFeed("WhetherInfo",
"Whether information for the given location",
new Uri("http://localhost:8080/WhetherService/whether/feed"));
List <SyndicationItem> items = new List <SyndicationItem>();
foreach (string location in locations)
{
SyndicationItem item = new SyndicationItem(location,
string.Format("{0} temperature: {1}",
location, GetTemperature(location)),
new Uri("http://localhost:8080/WhetherService/whether/get?loc="
+ location), "ItemID", DateTime.Now);
items.Add(item);
}
feedData.Items = items;
SyndicationFeedFormatter feed;
if (string.Compare(format, "rss20", true) == 0)
{
feed = new Rss20FeedFormatter(feedData);
}
else
{
feed = new Atom10FeedFormatter(feedData);
}
return(feed);
}
public SyndicationFeedFormatter CreateFeed()
{
// Create a new Syndication Feed.
SyndicationFeed feed = new SyndicationFeed("Feed Title", "A WCF Syndication Feed", null);
List <SyndicationItem> items = new List <SyndicationItem>();
// Create a new Syndication Item.
SyndicationItem item = new SyndicationItem("An item", "Item content", null);
items.Add(item);
feed.Items = items;
// Return ATOM or RSS based on query string
// rss -> http://localhost:8732/Design_Time_Addresses/Greg.RestLearning.BuildInTemplate/Feed1/
// atom -> http://localhost:8732/Design_Time_Addresses/Greg.RestLearning.BuildInTemplate/Feed1/?format=atom
string query = WebOperationContext.Current.IncomingRequest.UriTemplateMatch.QueryParameters["format"];
SyndicationFeedFormatter formatter = null;
if (query == "atom")
{
formatter = new Atom10FeedFormatter(feed);
}
else
{
formatter = new Rss20FeedFormatter(feed);
}
return(formatter);
}
public static void SyndicationFeed_Rss_UriParser()
{
// *** SETUP *** \\
// *** EXECUTE *** \\
SyndicationFeed feed;
using (XmlReader reader = XmlReader.Create(@"RssSpecCustomParser.xml"))
{
var formatter = new Rss20FeedFormatter
{
UriParser = (value, kind, localName, ns) => new Uri($"http://value-{value}-kind-{kind}-localName-{localName}-ns-{ns}-end")
};
formatter.ReadFrom(reader);
feed = formatter.Feed;
}
// *** ASSERT *** \\
Assert.True(feed != null, "res was null.");
Assert.Equal(new Uri("http://value-ChannelBase-kind-relativeorabsolute-localName-channel-ns--end"), feed.BaseUri);
Assert.Equal(new Uri("http://value-ImageUrl-kind-relativeorabsolute-localName-url-ns--end"), feed.ImageUrl);
Assert.NotNull(feed.Links);
Assert.Equal(1, feed.Links.Count);
Assert.Equal(new Uri("http://value-FeedLink-kind-relativeorabsolute-localName-link-ns--end"), feed.Links.First().Uri);
Assert.True(feed.Items != null, "res.Items was null.");
Assert.Equal(1, feed.Items.Count());
Assert.Equal(1, feed.Items.First().Links.Count);
Assert.Equal(new Uri("http://value-itemlink-kind-relativeorabsolute-localName-link-ns--end"), feed.Items.First().Links.First().Uri);
}
public static void SyndicationFeed_Load_Write_RSS_Feed_()
{
string path = Path.GetTempFileName();
try
{
// *** SETUP *** \\\
XmlReaderSettings settingsReader = new XmlReaderSettings();
XmlReader xmlr = XmlReader.Create(@"rssSpecExample.xml", settingsReader);
SyndicationFeed sf = SyndicationFeed.Load(xmlr);
Assert.True(sf != null);
// *** EXECUTE *** \\
//Write the same feed that was read.
XmlWriterSettings settingsWriter = new XmlWriterSettings();
XmlWriter xmlw = XmlWriter.Create(path, settingsWriter);
Rss20FeedFormatter atomFeed = new Rss20FeedFormatter(sf);
atomFeed.WriteTo(xmlw);
xmlw.Close();
// *** VALIDATE *** \\
Assert.True(File.Exists(path));
}
finally
{
// *** CLEANUP *** \\
File.Delete(path);
}
}
private Action <Stream> getXmlContent(IEnumerable <BlogPost> model)
{
var items = model.Select(post =>
new SyndicationItem(
title: post.Title,
content: post.Content,
itemAlternateLink: new Uri(BaseUrl + post.GetLink().TrimStart('/')),
id: post.Id,
lastUpdatedTime: post.PubDate)
{
PublishDate = post.PubDate,
Summary = new TextSyndicationContent(post.Content, TextSyndicationContentKind.Html)
})
.ToList();
var feed = new SyndicationFeed(RssTitle, RssTitle, BaseUrl, items);
var formatter = new Rss20FeedFormatter(feed);
return(stream =>
{
using (var writer = XmlWriter.Create(stream))
{
formatter.WriteTo(writer);
}
});
}
public void FormatSampleFeedEmpty()
{
var feed = new Rss20Feed
{
Channel = new Rss20Channel
{
Items = new List <Rss20Item>
{
new Rss20Item(),
},
},
};
var tryFormatResult = Rss20FeedFormatter.TryFormatRss20Feed(feed, out var document);
Assert.True(tryFormatResult);
var targetEncoding = Encoding.UTF8;
var xmlWriterSettings = new XmlWriterSettings
{
Encoding = targetEncoding,
Indent = true,
};
using (var memoryStream = new MemoryStream())
using (var streamWriter = new StreamWriter(memoryStream, targetEncoding))
using (var xmlWriter = XmlWriter.Create(streamWriter, xmlWriterSettings))
{
document.WriteTo(xmlWriter);
xmlWriter.Flush();
var xmlString = targetEncoding.GetString(memoryStream.ToArray());
Assert.NotEmpty(xmlString);
}
}
public static void SyndicationFeed_Load_Write_RSS_Feed()
{
string path = Path.GetTempFileName();
try
{
// *** SETUP *** \\\
SyndicationFeed sf;
using (XmlReader xmlr = XmlReader.Create("TestFeeds/SimpleRssFeed.xml"))
{
sf = SyndicationFeed.Load(xmlr);
Assert.True(sf != null);
}
// *** EXECUTE *** \\
//Write the same feed that was read.
using (XmlWriter xmlw = XmlWriter.Create(path))
{
var rss20FeedFormatter = new Rss20FeedFormatter(sf);
rss20FeedFormatter.WriteTo(xmlw);
}
// *** VALIDATE *** \\
Assert.True(File.Exists(path));
}
finally
{
// *** CLEANUP *** \\
File.Delete(path);
}
}
[ResponseCache(Duration = 60)] // 60 second cache duration to avoid duplicated requests
public async Task <IActionResult> GetLatestItemsRssFeed(int count = 100, string format = "rss")
{
var feed = ScraperManager.Instance.CreateSyndicationFeedFromLatestItemsAsync(count);
var settings = new XmlWriterSettings
{
Async = true,
Encoding = Encoding.UTF8,
NewLineHandling = NewLineHandling.Entitize,
NewLineOnAttributes = true,
Indent = true
};
var contentType = "rss";
using var stream = new MemoryStream();
using var xmlWriter = XmlWriter.Create(stream, settings);
SyndicationFeedFormatter rssFormatter = null;
switch (format)
{
case "atom":
rssFormatter = new Atom10FeedFormatter(await feed);
contentType = "atom";
break;
default:
rssFormatter = new Rss20FeedFormatter(await feed, true);
break;
}
rssFormatter.WriteTo(xmlWriter);
xmlWriter.Flush();
return(File(stream.ToArray(), $"application/{contentType}+xml; charset=utf-8"));
}
public static List <WebFeed> ReadFeed(FuenteWEB[] fuentes, string tematica)
{
List <WebFeed> lwf = new List <WebFeed>();
try
{
foreach (FuenteWEB fweb in fuentes)
{
if (fweb.Tipo.Equals("RSS"))
{
SyndicationFeedFormatter formatter = new Rss20FeedFormatter();
lwf.Add(ReadFeedRA(fweb.Url, formatter, tematica, true, true));
}
else if (fweb.Tipo.Equals("ATOM"))
{
SyndicationFeedFormatter formatter = new Atom10FeedFormatter();
lwf.Add(ReadFeedRA(fweb.Url, formatter, tematica, true, false));
}
else if (fweb.Tipo.Equals("YOUTUBE"))
{
lwf.Add(ReadFeedYT(fweb.Url, tematica));
}
}
return(lwf);
}
catch (Exception ex)
{
return(lwf);
}
}
private void WriteToFile()
{
var formatter = new Rss20FeedFormatter(Feed);
formatter.WriteTo(XmlWriter);
XmlWriter.Flush();
}
/// <summary>
/// Executes the call to the ActionResult method and returns the created feed to the output response.
/// </summary>
/// <param name="context">The context in which the result is executed. The context information includes the
/// controller, HTTP content, request context, and route data.</param>
public override void ExecuteResult(ControllerContext context)
{
context.HttpContext.Response.ContentType = "application/xml";
Rss20FeedFormatter feedFormatter = new Rss20FeedFormatter(_syndicationFeed);
XmlWriterSettings xmlWriterSettings = new XmlWriterSettings {Encoding = Encoding.UTF8};
if (HttpContext.Current.IsDebuggingEnabled)
{
// Indent the XML for easier viewing but only in Debug mode. In Release mode, everything is output on
// one line for best performance.
xmlWriterSettings.Indent = true;
}
using (XmlWriter xmlWriter = XmlWriter.Create(context.HttpContext.Response.Output, xmlWriterSettings))
{
feedFormatter.WriteTo(xmlWriter);
}
}
