public async Task ReadImage()
{
using (XmlReader xmlReader = XmlReader.Create(@"..\..\..\TestFeeds\simpleAtomFeed.xml", new XmlReaderSettings {
Async = true
}))
{
var reader = new AtomFeedReader(xmlReader);
int imagesRead = 0;
List <String> contentsOfImages = new List <string>();
while (await reader.Read())
{
if (reader.ElementType == SyndicationElementType.Image)
{
ISyndicationImage image = await reader.ReadImage();
imagesRead++;
contentsOfImages.Add(image.Url.OriginalString);
}
}
Assert.True(imagesRead == 2);
Assert.True(contentsOfImages[0] == "/icon.jpg");
Assert.True(contentsOfImages[1] == "/logo.jpg");
}
}
public async Task ReadPerson()
{
using (XmlReader xmlReader = XmlReader.Create(@"..\..\..\TestFeeds\simpleAtomFeed.xml", new XmlReaderSettings {
Async = true
}))
{
var persons = new List <ISyndicationPerson>();
var reader = new AtomFeedReader(xmlReader);
while (await reader.Read())
{
if (reader.ElementType == SyndicationElementType.Person)
{
ISyndicationPerson person = await reader.ReadPerson();
persons.Add(person);
}
}
Assert.True(persons.Count() == 2);
Assert.True(persons[0].Name == "Mark Pilgrim");
Assert.True(persons[0].Email == "*****@*****.**");
Assert.True(persons[0].Uri == "http://example.org/");
Assert.True(persons[1].Name == "Sam Ruby");
}
}
public override async Task <DBSubscription> CreateSubscriptionAsync(Uri uri)
{
var url = uri.AbsoluteUri.Contains(".rss") ? uri.AbsoluteUri : $"{uri.AbsoluteUri}.rss";
using (var xmlReader = XmlReader.Create(url, new XmlReaderSettings {
Async = true
}))
{
var feedReader = new AtomFeedReader(xmlReader);
while (await feedReader.Read())
{
switch (feedReader.ElementType)
{
case SyndicationElementType.Content:
var content = await feedReader.ReadContent();
if (string.Equals(content.Name, "id", StringComparison.OrdinalIgnoreCase))
{
return(new DBSubscription
{
Source = ESource.Reddit,
IsProtected = false,
SourceId = content.Value,
Username = content.Value.Replace(".rss", string.Empty)
});
}
break;
}
}
}
return(null);
}
public override async Task <List <DBCard> > GetCardsAsync(DBSubscription subscription)
{
var items = new List <DBCard>();
using (var xmlReader = XmlReader.Create(new StringReader(await BaseClient.GetStringAsync(new RestRequest($"https://www.reddit.com{subscription.SourceId}"))), new XmlReaderSettings {
Async = true
}))
{
var feedReader = new AtomFeedReader(xmlReader);
while (await feedReader.Read())
{
switch (feedReader.ElementType)
{
case SyndicationElementType.Item:
var item = await feedReader.ReadItem();
var card = new DBCard
{
CardId = item.Id,
Text = item.Title,
Header = item.Categories.First().Label,
Timestamp = item.LastUpdated,
OriginalUrl = item.Links.First().Uri.AbsoluteUri
};
items.Add(card);
break;
}
}
}
return(items);
}
public async Task ReadItemContent()
{
using (XmlReader xmlReader = XmlReader.Create(@"..\..\..\TestFeeds\simpleAtomFeed.xml", new XmlReaderSettings {
Async = true
}))
{
var reader = new AtomFeedReader(xmlReader);
while (await reader.Read())
{
if (reader.ElementType == SyndicationElementType.Item)
{
ISyndicationContent content = await reader.ReadContent();
var fields = content.Fields.ToArray();
Assert.True(fields.Length == 12);
Assert.True(fields[0].Name == "title");
Assert.False(string.IsNullOrEmpty(fields[0].Value));
Assert.True(fields[1].Name == "link");
Assert.True(fields[1].Attributes.Count() > 0);
Assert.True(fields[2].Name == "link");
Assert.True(fields[2].Attributes.Count() > 0);
Assert.True(fields[3].Name == "id");
Assert.False(string.IsNullOrEmpty(fields[3].Value));
Assert.True(fields[4].Name == "updated");
Assert.False(string.IsNullOrEmpty(fields[4].Value));
Assert.True(fields[5].Name == "published");
Assert.False(string.IsNullOrEmpty(fields[5].Value));
Assert.True(fields[6].Name == "source");
Assert.True(fields[6].Fields.Count() > 0);
Assert.True(fields[7].Name == "author");
Assert.True(fields[7].Fields.Count() > 0);
Assert.True(fields[8].Name == "contributor");
Assert.True(fields[8].Fields.Count() > 0);
Assert.True(fields[9].Name == "contributor");
Assert.True(fields[9].Fields.Count() > 0);
Assert.True(fields[10].Name == "rights");
Assert.False(string.IsNullOrEmpty(fields[10].Value));
Assert.True(fields[11].Name == "content");
Assert.False(string.IsNullOrEmpty(fields[11].Value));
}
}
}
}
private static async Task <List <object> > ParseExport(XmlReader xmlReader)
{
List <object> result = new List <object>();
{
var feedReader = new AtomFeedReader(xmlReader);
while (await feedReader.Read())
{
switch (feedReader.ElementType)
{
// Read category
case SyndicationElementType.Category:
ISyndicationCategory category = await feedReader.ReadCategory();
result.Add(category);
break;
// Read Image
case SyndicationElementType.Image:
ISyndicationImage image = await feedReader.ReadImage();
result.Add(image);
break;
// Read Item
case SyndicationElementType.Item:
ISyndicationItem item = await feedReader.ReadItem();
result.Add(item);
break;
// Read link
case SyndicationElementType.Link:
ISyndicationLink link = await feedReader.ReadLink();
result.Add(link);
break;
// Read Person
case SyndicationElementType.Person:
ISyndicationPerson person = await feedReader.ReadPerson();
result.Add(person);
break;
// Read content
default:
ISyndicationContent content = await feedReader.ReadContent();
result.Add(content);
break;
}
}
return(result);
}
}
public override async Task <DBSubscription> CreateSubscriptionAsync(Uri uri)
{
var id = uri.Segments.ElementAtOrDefault(2);
if (id == null)
{
return(null);
}
if (uri.Segments.ElementAt(1) == "c/" || uri.Segments.ElementAt(1) == "user/")
{
var channelId = await PollyHelper.WebFallbackAsync(() => _client.ChannelId(uri.AbsoluteUri));
if (channelId == null)
{
return(null);
}
id = channelId;
}
using (var xmlReader = XmlReader.Create($"https://www.youtube.com/feeds/videos.xml?channel_id={id}", new XmlReaderSettings {
Async = true
}))
{
var feedReader = new AtomFeedReader(xmlReader);
while (await feedReader.Read())
{
switch (feedReader.ElementType)
{
case SyndicationElementType.Content:
var content = await feedReader.ReadContent();
if (string.Equals(content.Name, "title", StringComparison.OrdinalIgnoreCase))
{
return(new DBSubscription
{
Source = ESource.Youtube,
IsProtected = false,
SourceId = id,
Username = content.Value
});
}
break;
}
}
}
return(null);
}
private async Task ProcessBlog(Blog blog)
{
using (var reader = XmlReader.Create(blog.FeedUrl, new XmlReaderSettings {
Async = true, DtdProcessing = DtdProcessing.Parse
}))
{
ISyndicationFeedReader feedReader = null;
if (blog.FeedType == "atom")
{
feedReader = new AtomFeedReader(reader);
}
else
{
feedReader = new RssFeedReader(reader);
}
while (await feedReader.Read())
{
switch (feedReader.ElementType)
{
case SyndicationElementType.Item:
ISyndicationItem item = await feedReader.ReadItem();
var entity = new RssItem()
{
Title = item.Title,
Link = item.Id,
};
if (!entity.Link.StartsWith("http"))
{
entity.Link = blog.Url + item.Id;
}
using (var txn = this.StateManager.CreateTransaction())
{
var items = await this.StateManager.GetOrAddAsync <IReliableDictionary <string, RssItem> >(string.Format(rssItems, blog.Id.ToString("N")));
await items.AddAsync(txn, Guid.NewGuid().ToString("N"), entity);
await txn.CommitAsync();
}
break;
default:
break;
}
}
}
}
private void UpdateCollection()
{
try
{
_sdataResourceCollectionRequest = new SDataResourceCollectionRequest(Service)
{
ResourceKind = tbCollectionResourceKind.Text,
StartIndex = (int)numStartIndex.Value,
Count = (int)numCount.Value
};
_feed = _sdataResourceCollectionRequest.Read();
_reader = null;
var lookup = _feed.Links.ToLookup(link => link.Relation);
btnFirst.Enabled = lookup["first"].Any();
btnPrevious.Enabled = lookup["previous"].Any();
btnNext.Enabled = lookup["next"].Any();
btnLast.Enabled = lookup["last"].Any();
var table = new DataTable();
table.Columns.Add("Author");
table.Columns.Add("Id");
table.Columns.Add("Title");
// iterate through the list of entries in the feed
foreach (var atomentry in _feed.Entries)
{
var dr = table.NewRow();
dr[0] = atomentry.Authors.Select(author => author.Name).FirstOrDefault();
dr[1] = atomentry.Id.Uri.AbsoluteUri;
dr[2] = atomentry.Title.Content;
table.Rows.Add(dr);
}
// show it in the grid
atomEntryGrid.DataSource = table;
atomEntryGrid.Refresh();
atomEntryGrid.AutoResizeColumns();
if (atomEntryGrid.SelectedRows.Count != 0)
{
atomEntryGrid_CellContentClick(null, null);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private async Task <SubscriptionUpdate[]> CheckRssForUpdatesAsync(Subscription subscription, CancellationToken cancellationToken)
{
var url = subscription.Url;
var response = await _httpClient.GetAsync(new HttpRequestMessage(HttpMethod.Get, url), cancellationToken);
if (!response.IsSuccessStatusCode)
{
var content = await response.Content.ReadAsStringAsync();
throw new ResponseException($"Failed to check for subscription update of {url}. Response code: {response.StatusCode}, Response: {content}");
}
var updates = new List <SubscriptionUpdate>();
// https://github.com/dotnet/SyndicationFeedReaderWriter
using (var xmlReader = XmlReader.Create(await response.Content.ReadAsStreamAsync(), new XmlReaderSettings()
{
Async = true
}))
{
// TODO: auto detect Atom vs Rss
var feedReader = new AtomFeedReader(xmlReader);
while (await feedReader.Read())
{
switch (feedReader.ElementType)
{
case SyndicationElementType.Item:
ISyndicationItem item = await feedReader.ReadItem();
var date = item.Published;
var title = item.Title ?? $"update by {subscription.Name}";
var link = item.Links.FirstOrDefault()?.Uri?.ToString() ?? subscription.Url;
updates.Add(new SubscriptionUpdate
{
Subscription = subscription,
Name = subscription.Name,
LastUpdated = date,
Message = title,
Url = link
});
break;
}
}
}
return(updates.ToArray());
}
public override async Task <List <DBCard> > GetCardsAsync(DBSubscription subscription)
{
var items = new List <DBCard>();
using (var xmlReader = XmlReader.Create(new StringReader(await BaseClient.GetStringAsync(new RestRequest(subscription.SourceId))), new XmlReaderSettings {
Async = true, IgnoreComments = true, IgnoreWhitespace = true
}))
{
XmlFeedReader feedReader;
if (new Atom10FeedFormatter().CanRead(xmlReader))
{
feedReader = new AtomFeedReader(xmlReader);
}
else
{
feedReader = new RssFeedReader(xmlReader);
}
while (await feedReader.Read())
{
switch (feedReader.ElementType)
{
case SyndicationElementType.Item:
var item = await feedReader.ReadItem();
var card = new DBCard
{
CardId = item.Id,
Header = subscription.Username,
Text = item.Title.Trim().Replace(""", "\""),
Timestamp = item.Published,
OriginalUrl = item.Links.FirstOrDefault(f => string.Equals(f.RelationshipType, "alternate", StringComparison.OrdinalIgnoreCase))?.Uri.AbsoluteUri
};
items.Add(card);
break;
}
}
}
return(items);
}
public async Task ReadCategory()
{
using (XmlReader xmlReader = XmlReader.Create(@"..\..\..\TestFeeds\simpleAtomFeed.xml", new XmlReaderSettings {
Async = true
}))
{
var reader = new AtomFeedReader(xmlReader);
while (await reader.Read())
{
if (reader.ElementType == SyndicationElementType.Category)
{
ISyndicationCategory category = await reader.ReadCategory();
Assert.True(category.Name == "sports");
Assert.True(category.Label == "testLabel");
Assert.True(category.Scheme == "testScheme");
}
}
}
}
public override async Task <DBSubscription> CreateSubscriptionAsync(Uri uri)
{
using (var xmlReader = XmlReader.Create(uri.AbsoluteUri, new XmlReaderSettings {
Async = true, IgnoreComments = true, IgnoreWhitespace = true
}))
{
XmlFeedReader feedReader;
if (new Atom10FeedFormatter().CanRead(xmlReader))
{
feedReader = new AtomFeedReader(xmlReader);
}
else
{
feedReader = new RssFeedReader(xmlReader);
}
while (await feedReader.Read())
{
switch (feedReader.ElementType)
{
case SyndicationElementType.Content:
var content = await feedReader.ReadContent();
if (string.Equals(content.Name, "title", StringComparison.OrdinalIgnoreCase))
{
return(new DBSubscription
{
Source = ESource.RSS,
IsProtected = false,
SourceId = uri.AbsoluteUri,
Username = content.Value
});
}
break;
}
}
}
return(null);
}
public async Task ReadLink()
{
using (XmlReader xmlReader = XmlReader.Create(@"..\..\..\TestFeeds\simpleAtomFeed.xml", new XmlReaderSettings {
Async = true
}))
{
var reader = new AtomFeedReader(xmlReader);
List <string> hrefs = new List <string>();
while (await reader.Read())
{
if (reader.ElementType == SyndicationElementType.Link)
{
ISyndicationLink link = await reader.ReadLink();
hrefs.Add(link.Uri.OriginalString);
}
}
Assert.True(hrefs[0] == "http://example.org/");
Assert.True(hrefs[1] == "http://example.org/feed.atom");
}
}
public async Task ReadItem()
{
using (XmlReader xmlReader = XmlReader.Create(@"..\..\..\TestFeeds\simpleAtomFeed.xml", new XmlReaderSettings {
Async = true
}))
{
var reader = new AtomFeedReader(xmlReader);
while (await reader.Read())
{
if (reader.ElementType == SyndicationElementType.Item)
{
IAtomEntry item = await reader.ReadEntry();
//Assert content of item
Assert.True(item.Title == "Atom draft-07 snapshot");
Assert.True(item.Links.Count() == 3);
Assert.True(item.Contributors.Count() == 3);
Assert.True(item.Rights == "All rights Reserved. Contoso.");
Assert.True(item.Id == "tag:example.org,2003:3.2397");
}
}
}
}
private void btnReaderRead_Click(object sender, EventArgs e)
{
try
{
_sdataResourceCollectionRequest = new SDataResourceCollectionRequest(Service)
{
ResourceKind = tbCollectionResourceKind.Text,
StartIndex = (int)numStartIndex.Value,
Count = (int)numCount.Value
};
_feed = null;
_reader = _sdataResourceCollectionRequest.ExecuteReader();
tbReaderCount.Text = _reader.Count.ToString();
UpdateReaderGrid();
}
catch (SDataClientException ex)
{
MessageBox.Show(ex.Message);
}
}
public override async Task <List <DBCard> > GetCardsAsync(DBSubscription subscription)
{
var items = new List <DBCard>();
using (var xmlReader = XmlReader.Create(new StringReader(await BaseClient.GetStringAsync(new RestRequest($"https://www.youtube.com/feeds/videos.xml?channel_id={subscription.SourceId}"))), new XmlReaderSettings {
Async = true
}))
{
var feedReader = new AtomFeedReader(xmlReader);
while (await feedReader.Read())
{
switch (feedReader.ElementType)
{
case SyndicationElementType.Item:
var item = await feedReader.ReadItem();
var id = item.Id.Split(":").Last();
var card = new DBCard
{
CardId = item.Id,
Text = item.Title,
Header = item.Contributors.FirstOrDefault()?.Name,
Timestamp = item.Published,
OriginalUrl = $"https://www.youtube.com/embed/{id}?autoplay=1&modestbranding=0&rel=0"
};
items.Add(card);
break;
}
}
}
return(items);
}
public AtomFeedReaderTest()
{
_feedReader = new AtomFeedReader(Mock.Of <ILogger <AtomFeedReader> >());
}
// Handles RSS2.0 and Atom feeds
private async Task <bool> HandleXmlFeed(Feed feed, bool populateCacheOnly = false)
{
using (log.BeginScope($"{ nameof(FeedService) }->{ nameof(HandleXmlFeed) } with feed: {feed}"))
{
try
{
// Create async reader
using (XmlReader xmlReader = XmlReader.Create(feed.ConnectionString, new XmlReaderSettings()
{
Async = true
}))
{
ISyndicationFeedReader reader = null;
// Special reader for every type
switch (feed.Type)
{
case FeedType.RSS:
log.LogDebug("Creating RssFeedReader");
reader = new RssFeedReader(xmlReader);
break;
case FeedType.Atom:
log.LogDebug("Creating AtomFeedReader");
reader = new AtomFeedReader(xmlReader);
break;
default:
log.LogError("Invalid FeedType found.");
return(false);
}
log.LogDebug("Starting feed reading");
// Read the entries async
while (await reader.Read())
{
log.LogDebug("Found elementType '{ElementType}'", reader.ElementType);
// We only need the entrytypes (yet)
if (reader.ElementType == SyndicationElementType.Item)
{
FeedEntry feedEntry = null;
// Create my feedEntry
switch (feed.Type)
{
case FeedType.RSS:
ISyndicationItem rssEntry = await(reader as RssFeedReader).ReadItem();
log.LogDebug("ISyndicationItem: {Item}", rssEntry);
feedEntry = CreateFeedEntry(rssEntry, feed);
break;
case FeedType.Atom:
IAtomEntry atomEntry = await(reader as AtomFeedReader).ReadEntry();
log.LogDebug("IAtomEntry: {Entry}", atomEntry);
feedEntry = CreateFeedEntry(atomEntry, feed);
break;
default:
continue;
}
// Check if we already had this one
if (await cache.IsCached(feedEntry.Id))
{
log.LogDebug("ID '{Id}' is in cache", feedEntry.Id);
}
// Check if the entry is older then MaxAge to prevent double posting
else if (feedEntry?.Published <= (DateTime.Now - cfg.Application.Cache.MaxAge))
{
log.LogInformation("Entry '{Id}' is too old.", feedEntry.Id);
}
else
{
// Hand over to instance service
log.LogDebug("Tooting id '{Id}' ", feedEntry.Id);
await TootTheFeedEntry(feedEntry, populateCacheOnly, feed);
}
}
}
return(true);
}
}
catch (Exception ex)
{
log.LogError(ex, "HandleXmlFeed Exception - {feed}", feed);
return(false);
}
}
}
/// <summary>
/// Reads the Atom feed at <see cref="ReleaseUpdateUri"/> and fills the <see cref="Releases"/>
/// collection with information. If a release with higher version number than <see cref="ApplicationVersion"/>
/// is found then the <see cref="ReleaseToUpdate"/> is set to this release.
/// </summary>
/// <param name="force"></param>
/// <returns></returns>
public async Task <bool> CheckForUpdate(bool force = false)
{
EnsureUpdateEntry();
if (updateEntry.LastCheck == DateTime.Today && !force)
{
return(false);
}
try
{
using (var cl = new HttpClient())
{
var response = await cl.GetAsync(ReleaseUpdateUri);
response.EnsureSuccessStatusCode();
using (var xmlReader = XmlReader.Create(await response.Content.ReadAsStreamAsync(),
new XmlReaderSettings
{
Async = true
}))
{
Releases.Clear();
ReleaseToUpdate = null;
var feedReader = new AtomFeedReader(xmlReader);
while (await feedReader.Read())
{
switch (feedReader.ElementType)
{
case SyndicationElementType.Category:
await feedReader.ReadCategory();
break;
case SyndicationElementType.Image:
await feedReader.ReadImage();
break;
case SyndicationElementType.Item:
var entry = await feedReader.ReadEntry();
var r = new Release();
r.DownloadUri = entry.Links.FirstOrDefault(x => x.RelationshipType == "alternate")?.Uri;
if (r.DownloadUri != null)
{
r.Updated = entry.LastUpdated.ToUniversalTime().LocalDateTime;
r.ParsedVersion = ParseVersion(r.DownloadUri.AbsolutePath);
if (r.ParsedVersion != null)
{
Releases.Add(r);
}
}
break;
case SyndicationElementType.Link:
await feedReader.ReadLink();
break;
case SyndicationElementType.Person:
await feedReader.ReadPerson();
break;
default:
await feedReader.ReadContent();
break;
}
}
if (Releases.Count == 0)
{
return(false);
}
var top = Releases.OrderByDescending(x => x.ParsedVersion).First();
if (top.ParsedVersion > ApplicationVersion)
{
ReleaseToUpdate = top;
return(true);
}
}
}
}
catch (Exception ex)
{
LogException(ex);
return(false);
}
updateEntry.LastCheck = DateTime.Today;
SaveUpdateEntry();
return(false);
}
public static async Task ReadAtomFeed(string filePath)
{
//
// Create an XmlReader from file
// Example: ..\tests\TestFeeds\simpleAtomFeed.xml
using (XmlReader xmlReader = XmlReader.Create(filePath, new XmlReaderSettings()
{
Async = true
}))
{
//
// Create an AtomFeedReader
var reader = new AtomFeedReader(xmlReader);
//
// Read the feed
while (await reader.Read())
{
//
// Check the type of the current element.
switch (reader.ElementType)
{
//
// Read category
case SyndicationElementType.Category:
ISyndicationCategory category = await reader.ReadCategory();
break;
//
// Read image
case SyndicationElementType.Image:
ISyndicationImage image = await reader.ReadImage();
break;
//
// Read entry
case SyndicationElementType.Item:
IAtomEntry entry = await reader.ReadEntry();
break;
//
// Read link
case SyndicationElementType.Link:
ISyndicationLink link = await reader.ReadLink();
break;
//
// Read person
case SyndicationElementType.Person:
ISyndicationPerson person = await reader.ReadPerson();
break;
//
// Read content
default:
ISyndicationContent content = await reader.ReadContent();
break;
}
}
}
}
private async Task <List <BlogPost> > GetFeed()
{
var xmlReader = XmlReader.Create(_settings.Value.FeedUrl);
var reader = new AtomFeedReader(xmlReader);
var posts = new List <BlogPost>();
//
// Read the feed
while (await reader.Read())
{
//
// Check the type of the current element.
switch (reader.ElementType)
{
//
// Read category
case SyndicationElementType.Category:
ISyndicationCategory category = await reader.ReadCategory();
break;
//
// Read image
case SyndicationElementType.Image:
ISyndicationImage image = await reader.ReadImage();
break;
//
// Read entry
case SyndicationElementType.Item:
IAtomEntry entry = await reader.ReadEntry();
// these are the only ones we need for now
posts.Add(new BlogPost
{
Title = entry.Title,
PublishedDate = entry.Published.DateTime,
Categories = entry.Categories?.Select(c => c.Name)?.ToList()
});
break;
//
// Read link
case SyndicationElementType.Link:
ISyndicationLink link = await reader.ReadLink();
break;
//
// Read person
case SyndicationElementType.Person:
ISyndicationPerson person = await reader.ReadPerson();
break;
//
// Read content
default:
ISyndicationContent content = await reader.ReadContent();
break;
}
}
return(posts);
}
/// <summary>
/// Performs initial read from AtomFeedReader
/// </summary>
/// <returns></returns>
public AtomFeedReader ExecuteReader()
{
var reader = new AtomFeedReader(this);
return reader.Read() ? reader : null;
}
private void UpdateCollection()
{
try
{
_sdataResourceCollectionRequest = new SDataResourceCollectionRequest(Service)
{
ResourceKind = tbCollectionResourceKind.Text,
StartIndex = (int) numStartIndex.Value,
Count = (int) numCount.Value
};
_feed = _sdataResourceCollectionRequest.Read();
_reader = null;
var lookup = _feed.Links.ToLookup(link => link.Relation);
btnFirst.Enabled = lookup["first"].Any();
btnPrevious.Enabled = lookup["previous"].Any();
btnNext.Enabled = lookup["next"].Any();
btnLast.Enabled = lookup["last"].Any();
var table = new DataTable();
table.Columns.Add("Author");
table.Columns.Add("Id");
table.Columns.Add("Title");
// iterate through the list of entries in the feed
foreach (var atomentry in _feed.Entries)
{
var dr = table.NewRow();
dr[0] = atomentry.Authors.Select(author => author.Name).FirstOrDefault();
dr[1] = atomentry.Id.Uri.AbsoluteUri;
dr[2] = atomentry.Title.Content;
table.Rows.Add(dr);
}
// show it in the grid
atomEntryGrid.DataSource = table;
atomEntryGrid.Refresh();
atomEntryGrid.AutoResizeColumns();
if (atomEntryGrid.SelectedRows.Count != 0)
{
atomEntryGrid_CellContentClick(null, null);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private void btnReaderRead_Click(object sender, EventArgs e)
{
try
{
_sdataResourceCollectionRequest = new SDataResourceCollectionRequest(Service)
{
ResourceKind = tbCollectionResourceKind.Text,
StartIndex = (int) numStartIndex.Value,
Count = (int) numCount.Value
};
_feed = null;
_reader = _sdataResourceCollectionRequest.ExecuteReader();
tbReaderCount.Text = _reader.Count.ToString();
UpdateReaderGrid();
}
catch (SDataClientException ex)
{
MessageBox.Show(ex.Message);
}
}
public async Task <AtomPage> ReadAtomPage(Stream stream)
{
using var xmlReader = XmlReader.Create(stream, new XmlReaderSettings { Async = true });
var feedReader = new AtomFeedReader(xmlReader);
var entries = new List <AtomEntry>();
Uri?nextPageUri = null, previousPageUri = null, realTimeNotificationUri = null;
while (await feedReader.Read())
{
await ProcessElementAsync();
}
return(new AtomPage(
nextArchivePageUri: nextPageUri,
previousArchivePageUri: previousPageUri,
realTimeNotificationUri: realTimeNotificationUri,
entries: entries
));
async Task ProcessElementAsync()
{
switch (feedReader.ElementType)
{
case SyndicationElementType.Item:
await ProcessItemElementAsync();
break;
case SyndicationElementType.Link:
await ProcessLinkElementAsync();
break;
}
}
async Task ProcessItemElementAsync()
{
var item = (Microsoft.SyndicationFeed.Atom.AtomEntry) await feedReader.ReadItem();
var atomEntry = new AtomEntry(
id: item.Id,
published: item.Published,
contentType: item.ContentType,
payload: item.Description
);
entries.Insert(0, atomEntry);
}
async Task ProcessLinkElementAsync()
{
ISyndicationLink link = await feedReader.ReadLink();
switch (link.RelationshipType)
{
case "next-archive" when nextPageUri == null:
nextPageUri = link.Uri;
break;
case "prev-archive" when previousPageUri == null:
previousPageUri = link.Uri;
break;
case "notifications" when realTimeNotificationUri == null:
realTimeNotificationUri = link.Uri;
break;
}
}
}
public async Task <IEnumerable <IAtomEntry> > ReadEntriesAsync(
Uri feedUrl,
long?from,
string feedUserName = "",
string feedPassword = "",
bool embedEvent = true,
bool embedObject = true)
{
var entries = new List <IAtomEntry>();
var embedString = string.Empty;
if (embedObject && embedEvent)
{
embedString = "embed: \"event,object\"";
}
else if (embedObject)
{
embedString = "embed: \"object\"";
}
else if (embedEvent)
{
embedString = "embed: \"event\"";
}
_httpClient.DefaultRequestHeaders.Remove("X-Filtering");
if (from.HasValue)
{
var filter = string.IsNullOrEmpty(embedString) ? $"{{ position: {@from} }}" : $"{{ position: {@from}, {embedString} }}";
_httpClient.DefaultRequestHeaders.Add("X-Filtering", filter);
}
else
{
_httpClient.DefaultRequestHeaders.Add("X-Filtering", $"{{ {embedString} }}");
}
if (!string.IsNullOrEmpty(feedUserName) && !string.IsNullOrEmpty(feedPassword))
{
_httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.UTF8.GetBytes($"{feedUserName}:{feedPassword}")));
}
try
{
using (var response = await _httpClient.GetAsync(feedUrl))
using (var responseStream = await response.Content.ReadAsStreamAsync())
using (var xmlReader = XmlReader.Create(responseStream, new XmlReaderSettings {
Async = true
}))
{
var atomReader = new AtomFeedReader(xmlReader);
while (await atomReader.Read())
{
if (atomReader.ElementType == SyndicationElementType.Item)
{
entries.Add(await atomReader.ReadEntry());
}
}
}
}
catch (Exception e)
{
_logger.LogError(e.Message, e);
throw;
}
return(entries);
}