//============================================================
// CLASS SUMMARY
//============================================================
/// <summary>
/// Provides example code for the AtomSource class.
/// </summary>
public static void ClassExample()
{
#region AtomSource
AtomFeed feed = new AtomFeed();
feed.Id = new AtomId(new Uri("urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6"));
feed.Title = new AtomTextConstruct("Example Feed");
feed.UpdatedOn = new DateTime(2003, 12, 13, 18, 30, 2);
feed.Links.Add(new AtomLink(new Uri("http://example.org/")));
feed.Links.Add(new AtomLink(new Uri("/feed"), "self"));
feed.Authors.Add(new AtomPersonConstruct("John Doe"));
AtomEntry entry = new AtomEntry();
entry.Id = new AtomId(new Uri("urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a"));
entry.Title = new AtomTextConstruct("Atom-Powered Robots Run Amok");
entry.UpdatedOn = new DateTime(2003, 12, 13, 18, 30, 2);
entry.Summary = new AtomTextConstruct("Some text.");
// Entry was copied from another feed, so preserve source meta-data
AtomSource source = new AtomSource();
source.Id = new AtomId(new Uri("http://example2.org/"));
source.Title = new AtomTextConstruct("Fourty-Two");
source.UpdatedOn = new DateTime(2003, 11, 13, 18, 30, 2);
source.Rights = new AtomTextConstruct("© 2003 Example, Inc.");
entry.Source = source;
feed.AddEntry(entry);
#endregion
}
//============================================================
// CLASS SUMMARY
//============================================================
/// <summary>
/// Provides example code for the AtomTextConstruct class.
/// </summary>
public static void ClassExample()
{
#region AtomTextConstruct
AtomFeed feed = new AtomFeed();
feed.Id = new AtomId(new Uri("urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6"));
feed.Title = new AtomTextConstruct("Example Feed");
feed.UpdatedOn = new DateTime(2003, 12, 13, 18, 30, 2);
feed.Links.Add(new AtomLink(new Uri("http://example.org/")));
feed.Links.Add(new AtomLink(new Uri("/feed"), "self"));
feed.Authors.Add(new AtomPersonConstruct("John Doe"));
AtomEntry entry = new AtomEntry();
entry.Id = new AtomId(new Uri("urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a"));
entry.Title = new AtomTextConstruct("Atom-Powered Robots Run Amok");
entry.UpdatedOn = new DateTime(2003, 12, 13, 18, 30, 2);
// Provide summary as entity escaped html
AtomTextConstruct summary = new AtomTextConstruct();
summary.Content = "AT&amp;T bought <b>by SBC</b>!";
summary.TextType = AtomTextConstructType.Html;
entry.Summary = summary;
feed.AddEntry(entry);
#endregion
}
//============================================================
// CLASS SUMMARY
//============================================================
/// <summary>
/// Provides example code for the AtomFeed class.
/// </summary>
public static void ClassExample()
{
#region AtomFeed
AtomFeed feed = new AtomFeed();
feed.Id = new AtomId(new Uri("urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6"));
feed.Title = new AtomTextConstruct("Example Feed");
feed.UpdatedOn = new DateTime(2003, 12, 13, 18, 30, 2);
feed.Links.Add(new AtomLink(new Uri("http://example.org/")));
feed.Links.Add(new AtomLink(new Uri("/feed"), "self"));
feed.Authors.Add(new AtomPersonConstruct("John Doe"));
AtomEntry entry = new AtomEntry();
entry.Id = new AtomId(new Uri("urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a"));
entry.Title = new AtomTextConstruct("Atom-Powered Robots Run Amok");
entry.UpdatedOn = new DateTime(2003, 12, 13, 18, 30, 2);
entry.Summary = new AtomTextConstruct("Some text.");
feed.AddEntry(entry);
#endregion
}
//============================================================
// CLASS SUMMARY
//============================================================
/// <summary>
/// Provides example code for the AtomGenerator class.
/// </summary>
public static void ClassExample()
{
#region AtomGenerator
AtomFeed feed = new AtomFeed();
feed.Id = new AtomId(new Uri("urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6"));
feed.Title = new AtomTextConstruct("Example Feed");
feed.UpdatedOn = new DateTime(2003, 12, 13, 18, 30, 2);
feed.Links.Add(new AtomLink(new Uri("http://example.org/")));
feed.Links.Add(new AtomLink(new Uri("/feed"), "self"));
feed.Authors.Add(new AtomPersonConstruct("John Doe"));
// Identify the software used to generate the feed
AtomGenerator generator = new AtomGenerator("Example Toolkit");
generator.Uri = new Uri("/myblog.php");
generator.Version = "1.0";
feed.Generator = generator;
AtomEntry entry = new AtomEntry();
entry.Id = new AtomId(new Uri("urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a"));
entry.Title = new AtomTextConstruct("Atom-Powered Robots Run Amok");
entry.UpdatedOn = new DateTime(2003, 12, 13, 18, 30, 2);
entry.Summary = new AtomTextConstruct("Some text.");
feed.AddEntry(entry);
#endregion
}
private static string ToXmlString(AtomFeed feed)
{
var stringBuilder = new StringBuilder();
var xmlWriter = XmlWriter.Create(stringBuilder);
feed.Save(xmlWriter);
xmlWriter.Flush();
xmlWriter.Close();
return stringBuilder.ToString();
}
private static AtomFeed CreateAtomFeed(DateTime updatedOn)
{
var feed = new AtomFeed
{
Id = new AtomId(new Uri("http://henrylawson.net/atom")),
Title = new AtomTextConstruct("Henry Lawson"),
UpdatedOn = updatedOn
};
feed.Authors.Add(new AtomPersonConstruct("Henry Lawson"));
feed.Links.Add(new AtomLink
{
Uri = new Uri("http://henrylawson.net")
});
feed.Links.Add(new AtomLink
{
Relation = "self",
Uri = new Uri("http://henrylawson.net/atom")
});
return feed;
}
protected override Feed CreateFeed(XmlReader reader, string url) {
var atomFeed = new AtomFeed();
atomFeed.Load(reader);
var items = atomFeed.Entries.OrderBy(e => GetPublishedDate(e)).Select(CreateFeedItem);
var feed = new Feed {
Title = atomFeed.Title.Content,
Url = url,
SiteUrl = atomFeed.Links.Any() ? atomFeed.Links[0].ToString() : String.Empty,
Description = atomFeed.Subtitle == null ? String.Empty : atomFeed.Subtitle.Content,
Items = new List<Item>(items)
};
var latest = items.LastOrDefault();
if (latest != null) {
feed.Updated = latest.Published;
}
return feed;
}
//============================================================
// CLASS SUMMARY
//============================================================
/// <summary>
/// Provides example code for the AtomPersonConstruct class.
/// </summary>
public static void ClassExample()
{
#region AtomPersonConstruct
AtomFeed feed = new AtomFeed();
feed.Id = new AtomId(new Uri("urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6"));
feed.Title = new AtomTextConstruct("Example Feed");
feed.UpdatedOn = new DateTime(2003, 12, 13, 18, 30, 2);
feed.Links.Add(new AtomLink(new Uri("http://example.org/")));
feed.Links.Add(new AtomLink(new Uri("/feed"), "self"));
// Identify the author of the feed
feed.Authors.Add(new AtomPersonConstruct("John Doe"));
// Identify the contributors to the feed
feed.Contributors.Add(new AtomPersonConstruct("Jane Doe"));
AtomPersonConstruct contributor = new AtomPersonConstruct();
contributor.EmailAddress = "*****@*****.**";
contributor.Name = "Some Person";
contributor.Uri = new Uri("http://example.org/somePerson");
feed.Contributors.Add(contributor);
AtomEntry entry = new AtomEntry();
entry.Id = new AtomId(new Uri("urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a"));
entry.Title = new AtomTextConstruct("Atom-Powered Robots Run Amok");
entry.UpdatedOn = new DateTime(2003, 12, 13, 18, 30, 2);
entry.Summary = new AtomTextConstruct("Some text.");
// Identify the author of the entry
entry.Authors.Add(new AtomPersonConstruct("Jane Doe"));
feed.AddEntry(entry);
#endregion
}
protected override IList<Item> UpdateFeed(Feed feed, XmlReader reader) {
var atomFeed = new AtomFeed();
atomFeed.Load(reader);
var items = (from e in atomFeed.Entries
let date = GetPublishedDate(e)
orderby date
where date > feed.Updated
select CreateFeedItem(e)).ToList();
feed.Items.AddRange(items);
var latest = items.LastOrDefault();
if (latest != null) {
feed.Updated = latest.Published;
}
// OPML does not set full description so check for one when updating.
if (String.IsNullOrEmpty(feed.Description) && atomFeed.Subtitle != null) {
feed.Description = atomFeed.Subtitle.Content;
}
return items;
}
public static void RefreshFeed(
mojoPortal.Business.RssFeed feedInfo,
int moduleId,
Guid moduleGuid,
int maxDaysOld,
int maxEntriesPerFeed,
bool enableSelectivePublishing)
{
if (feedInfo == null)
{
return;
}
try
{
if (FeedManagerConfiguration.UseReadWriteLockForCacheMenagement)
{
cacheLock.AcquireWriterLock(cacheLockTimeoutInMilliseconds);
}
DateTime cutoffDate = DateTime.Now.AddDays(-maxDaysOld);
mojoPortal.Business.RssFeed.DeleteExpiredEntriesByModule(moduleGuid, cutoffDate);
mojoPortal.Business.RssFeed.DeleteUnPublishedEntriesByFeed(feedInfo.ItemId);
int entriesAdded = 0;
string siteRoot = SiteUtils.GetNavigationSiteRoot();
string secureSiteRoot = SiteUtils.GetSecureNavigationSiteRoot();
bool publish = true;
if (enableSelectivePublishing)
{
if (!feedInfo.PublishByDefault)
{
publish = false;
}
}
string feedUrl = feedInfo.RssUrl;
if (feedUrl.StartsWith("~/"))
{
feedUrl = WebUtils.ResolveServerUrl(feedUrl).Replace("https:", "http:");
}
try
{
GenericSyndicationFeed gsFeed = GenericSyndicationFeed.Create(new Uri(FormatFeedUrl(feedUrl, siteRoot, secureSiteRoot)));
#region RSSFeed_management
if (gsFeed.Format == SyndicationContentFormat.Rss)
{
Argotic.Syndication.RssFeed rssFeed = gsFeed.Resource as Argotic.Syndication.RssFeed;
if (rssFeed != null)
{
foreach (Argotic.Syndication.RssItem rssItem in rssFeed.Channel.Items)
{
if ((rssItem.PublicationDate >= cutoffDate) || (maxDaysOld == 0))
{
if ((entriesAdded < maxEntriesPerFeed) || (maxEntriesPerFeed == 0))
{
string entryBlob = rssItem.Title + rssItem.Link.ToString();
int entryHash = GetEntryHash(entryBlob);
if (UpdateEntry(
moduleGuid,
EnsureDate(rssItem.PublicationDate),
rssItem.Title,
rssItem.Author,
feedInfo.RssUrl,
rssItem.Description,
rssItem.Link.ToString(),
entryHash,
feedInfo.ItemGuid,
feedInfo.ItemId,
publish) > 0)
{
entriesAdded += 1;
}
}
}
}
}
}
#endregion
#region ATOMFeed_management
if (gsFeed.Format == SyndicationContentFormat.Atom)
{
Argotic.Syndication.AtomFeed atomFeed = gsFeed.Resource as Argotic.Syndication.AtomFeed;
foreach (AtomEntry atItem in atomFeed.Entries)
{
if ((atItem.PublishedOn >= cutoffDate) || (maxDaysOld == 0))
{
if ((entriesAdded < maxEntriesPerFeed) || (maxEntriesPerFeed == 0))
{
string entryLink = string.Empty;
StringBuilder entryAuthor = new StringBuilder();
string comma = string.Empty;
foreach (AtomPersonConstruct atPerson in atItem.Authors)
{
entryAuthor.Append(comma + atPerson.Name);
comma = ",";
}
if (entryAuthor.Length == 0)
{
foreach (AtomPersonConstruct atPerson in atomFeed.Authors)
{
entryAuthor.Append(comma + atPerson.Name);
comma = ",";
}
}
foreach (AtomLink atLink in atItem.Links)
{
if (atLink.Relation == "alternate")
{
entryLink = atLink.Uri.ToString();
}
}
if ((entryLink.Length == 0) && (atItem.Links.Count > 0))
{
entryLink = atItem.Links[0].Uri.ToString();
}
string content = string.Empty;
if (atItem.Content == null)
{
if (atItem.Summary != null)
{
content = atItem.Summary.Content;
}
}
else
{
content = atItem.Content.Content;
}
if (content.Length == 0)
{
continue;
}
string entryBlob = atItem.Title.ToString() + entryLink;
int entryHash = GetEntryHash(entryBlob);
if (UpdateEntry(
moduleGuid,
EnsureDate(atItem.PublishedOn),
atItem.Title.ToString(),
entryAuthor.ToString(),
feedInfo.RssUrl,
content,
entryLink,
entryHash,
feedInfo.ItemGuid,
feedInfo.ItemId,
publish) > 0)
{
entriesAdded += 1;
}
}
}
}
}
#endregion
}
catch (WebException ex)
{
if (log.IsErrorEnabled)
{
string logMsg = String.Format("There was a problem trying to read the feed for url {0}. Ignoring.", feedInfo.RssUrl);
log.Error(logMsg, ex);
}
}
catch (UriFormatException ex)
{
if (log.IsErrorEnabled)
{
string logMsg = String.Format("There was a problem trying to read the feed for url {0}. Ignoring.", feedInfo.RssUrl);
log.Error(logMsg, ex);
}
}
catch (System.Net.Sockets.SocketException ex)
{
if (log.IsErrorEnabled)
{
string logMsg = String.Format("There was a problem trying to read the feed for url {0}. Ignoring.", feedInfo.RssUrl);
log.Error(logMsg, ex);
}
}
catch (System.Xml.XmlException ex)
{
if (log.IsErrorEnabled)
{
string logMsg = String.Format("There was a problem trying to read the feed for url {0}. Ignoring.", feedInfo.RssUrl);
log.Error(logMsg, ex);
}
}
catch (System.Security.SecurityException ex)
{
log.Error("Could not load feed due to security exception. Must be running in restricted trust level. Creating server side web requests is not allowed in current configuration.", ex);
}
catch (System.Data.Common.DbException ex)
{
log.Error("Error updating feed database cache", ex);
}
}
finally
{
if (FeedManagerConfiguration.UseReadWriteLockForCacheMenagement)
{
try
{
cacheLock.ReleaseWriterLock();
}
catch (ApplicationException ex)
{
log.Error("swallowed error", ex);
}
}
}
}
private void GetPosts(object sender, EventArgs e)
{
TransitPostQueryOptions options = new TransitPostQueryOptions();
options.PageNumber = 0;
options.PageSize = 25;
options.SortDirection = WebServiceQuerySortDirection.Descending;
options.SortExpression = "Created";
options.PublishedOnly = true;
options.DisplayedOnly = true;
Response.ContentType = "application/atom+xml;charset=\"utf-8\"";
AtomFeed feed = new AtomFeed();
feed.Title = new AtomTextConstruct(SessionManager.GetSetting("title", "Untitled"));
List<TransitPost> posts = SessionManager.GetCachedCollection<TransitPost>(
"GetPosts", SessionManager.PostTicket, options);
foreach (TransitPost post in posts)
{
AtomEntry atomEntry = GetPost(post);
feed.AddEntry(atomEntry);
}
feed.Save(Response.OutputStream);
Response.End();
}
/// <summary>
/// Modifies the <see cref="AtomFeed"/> optional entities to match the supplied <see cref="XPathNavigator"/> data source.
/// </summary>
/// <param name="feed">The <see cref="AtomFeed"/> to be filled.</param>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the fill operation.</param>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="AtomFeed"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="feed"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
private static void FillFeedOptionals(AtomFeed feed, XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(feed, "feed");
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Attempt to extract syndication information
//------------------------------------------------------------
XPathNavigator generatorNavigator = source.SelectSingleNode("atom:generator", manager);
XPathNavigator iconNavigator = source.SelectSingleNode("atom:icon", manager);
XPathNavigator logoNavigator = source.SelectSingleNode("atom:logo", manager);
XPathNavigator rightsNavigator = source.SelectSingleNode("atom:rights", manager);
XPathNavigator subtitleNavigator = source.SelectSingleNode("atom:subtitle", manager);
if (generatorNavigator != null)
{
feed.Generator = new AtomGenerator();
feed.Generator.Load(generatorNavigator, settings);
}
if (iconNavigator != null)
{
feed.Icon = new AtomIcon();
feed.Icon.Load(iconNavigator, settings);
}
if (logoNavigator != null)
{
feed.Logo = new AtomLogo();
feed.Logo.Load(logoNavigator, settings);
}
if (rightsNavigator != null)
{
feed.Rights = new AtomTextConstruct();
feed.Rights.Load(rightsNavigator, settings);
}
if (subtitleNavigator != null)
{
feed.Subtitle = new AtomTextConstruct();
feed.Subtitle.Load(subtitleNavigator, settings);
}
}
//============================================================
// ASYNC METHODS
//============================================================
/// <summary>
/// Provides example code for the LoadAsync(Uri, Object) method
/// </summary>
public static void LoadAsyncExample()
{
#region LoadAsync(Uri source, Object userToken)
//------------------------------------------------------------
// Load feed asynchronously using event-based notification
//------------------------------------------------------------
AtomFeed feed = new AtomFeed();
feed.Loaded += new EventHandler<SyndicationResourceLoadedEventArgs>(FeedLoadedCallback);
feed.LoadAsync(new Uri("http://news.google.com/?output=atom"), null);
#endregion
}
/// <summary>
/// Instantiates a <see cref="ISyndicationResource"/> that conforms to the specified <see cref="SyndicationContentFormat"/> using the supplied <see cref="Stream"/>.
/// </summary>
/// <param name="stream">The <see cref="Stream"/> used to load the syndication resource.</param>
/// <param name="format">A <see cref="SyndicationContentFormat"/> enumeration value that indicates the type syndication resource the <paramref name="stream"/> represents.</param>
/// <returns>
/// An <see cref="ISyndicationResource"/> object that conforms to the specified <paramref name="format"/>, initialized using the supplied <paramref name="stream"/>.
/// If the <paramref name="format"/> is not supported by the provider, returns a <b>null</b> reference.
/// </returns>
/// <exception cref="ArgumentNullException">The <paramref name="stream"/> is a null reference (Nothing in Visual Basic).</exception>
private static ISyndicationResource BuildResource(SyndicationContentFormat format, Stream stream)
{
//------------------------------------------------------------
// Validate parameters
//------------------------------------------------------------
Guard.ArgumentNotNull(stream, "stream");
//------------------------------------------------------------
// Create syndication resource based on content format
//------------------------------------------------------------
if (format == SyndicationContentFormat.Apml)
{
ApmlDocument document = new ApmlDocument();
document.Load(stream);
return document;
}
else if (format == SyndicationContentFormat.Atom)
{
XPathDocument document = new XPathDocument(stream);
XPathNavigator navigator = document.CreateNavigator();
navigator.MoveToRoot();
navigator.MoveToChild(XPathNodeType.Element);
if(String.Compare(navigator.LocalName, "entry", StringComparison.OrdinalIgnoreCase) == 0)
{
AtomEntry entry = new AtomEntry();
entry.Load(navigator);
return entry;
}
else if (String.Compare(navigator.LocalName, "feed", StringComparison.OrdinalIgnoreCase) == 0)
{
AtomFeed feed = new AtomFeed();
feed.Load(navigator);
return feed;
}
else
{
return null;
}
}
else if (format == SyndicationContentFormat.BlogML)
{
BlogMLDocument document = new BlogMLDocument();
document.Load(stream);
return document;
}
else if (format == SyndicationContentFormat.Opml)
{
OpmlDocument document = new OpmlDocument();
document.Load(stream);
return document;
}
else if (format == SyndicationContentFormat.Rsd)
{
RsdDocument document = new RsdDocument();
document.Load(stream);
return document;
}
else if (format == SyndicationContentFormat.Rss)
{
RssFeed feed = new RssFeed();
feed.Load(stream);
return feed;
}
else
{
return null;
}
}
/// <summary>
/// Provides example code for the Save(XmlWriter) method
/// </summary>
public static void SaveXmlWriterExample()
{
#region Save(XmlWriter writer)
AtomFeed feed = new AtomFeed();
// Modify feed state using public properties and methods
using (Stream stream = new FileStream("AtomFeed.xml", FileMode.Create, FileAccess.Write))
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
using(XmlWriter writer = XmlWriter.Create(stream, settings))
{
feed.Save(writer);
}
}
#endregion
}
/// <summary>
/// Provides example code for the Save(Stream) method
/// </summary>
public static void SaveStreamExample()
{
#region Save(Stream stream)
AtomFeed feed = new AtomFeed();
// Modify feed state using public properties and methods
using(Stream stream = new FileStream("AtomFeed.xml", FileMode.Create, FileAccess.Write))
{
feed.Save(stream);
}
#endregion
}
/// <summary>
/// Modifies the <see cref="AtomFeed"/> optional entities to match the supplied <see cref="XPathNavigator"/> data source.
/// </summary>
/// <param name="feed">The <see cref="AtomFeed"/> to be filled.</param>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the fill operation.</param>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="AtomFeed"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="feed"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
private static void FillFeedOptionals(AtomFeed feed, XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(feed, "feed");
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Attempt to extract syndication information
//------------------------------------------------------------
XPathNavigator generatorNavigator = source.SelectSingleNode("atom:generator", manager);
XPathNavigator copyrightNavigator = source.SelectSingleNode("atom:copyright", manager);
XPathNavigator taglineNavigator = source.SelectSingleNode("atom:tagline", manager);
if (generatorNavigator != null)
{
feed.Generator = Atom03SyndicationResourceAdapter.CreateGenerator(generatorNavigator, manager, settings);
}
if (copyrightNavigator != null)
{
feed.Rights = Atom03SyndicationResourceAdapter.CreateTextContent(copyrightNavigator, manager, settings);
}
if (taglineNavigator != null)
{
feed.Subtitle = Atom03SyndicationResourceAdapter.CreateTextContent(taglineNavigator, manager, settings);
}
}
/// <summary>
/// Called when a corresponding asynchronous load operation completes.
/// </summary>
/// <param name="result">The result of the asynchronous operation.</param>
private static void AsyncLoadCallback(IAsyncResult result)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
System.Text.Encoding encoding = System.Text.Encoding.UTF8;
XPathNavigator navigator = null;
WebRequest httpWebRequest = null;
GenericSyndicationFeed feed = null;
Uri source = null;
WebRequestOptions options = null;
SyndicationResourceLoadSettings settings = null;
//------------------------------------------------------------
// Determine if the async send operation completed
//------------------------------------------------------------
if (result.IsCompleted)
{
//------------------------------------------------------------
// Extract the send operations parameters from the user state
//------------------------------------------------------------
object[] parameters = (object[])result.AsyncState;
httpWebRequest = parameters[0] as WebRequest;
feed = parameters[1] as GenericSyndicationFeed;
source = parameters[2] as Uri;
settings = parameters[3] as SyndicationResourceLoadSettings;
options = parameters[4] as WebRequestOptions;
object userToken = parameters[5];
//------------------------------------------------------------
// Verify expected parameters were found
//------------------------------------------------------------
if (feed != null)
{
//------------------------------------------------------------
// Get the response to the syndication resource request
//------------------------------------------------------------
WebResponse httpWebResponse = (WebResponse)httpWebRequest.EndGetResponse(result);
//------------------------------------------------------------
// Load syndication resource
//------------------------------------------------------------
using (Stream stream = httpWebResponse.GetResponseStream())
{
if (settings != null)
{
encoding = settings.CharacterEncoding;
}
using (StreamReader streamReader = new StreamReader(stream, encoding))
{
XmlReaderSettings readerSettings = new XmlReaderSettings();
readerSettings.IgnoreComments = true;
readerSettings.IgnoreWhitespace = true;
readerSettings.ProhibitDtd = false;
using (XmlReader reader = XmlReader.Create(streamReader, readerSettings))
{
if (encoding == System.Text.Encoding.UTF8)
{
navigator = SyndicationEncodingUtility.CreateSafeNavigator(source, options, null);
}
else
{
navigator = SyndicationEncodingUtility.CreateSafeNavigator(source, options, settings.CharacterEncoding);
}
//------------------------------------------------------------
// Initialize generic feed based on syndication resource format
//------------------------------------------------------------
SyndicationResourceMetadata metadata = new SyndicationResourceMetadata(navigator);
if (metadata.Format == SyndicationContentFormat.Atom)
{
AtomFeed atomFeed = new AtomFeed();
SyndicationResourceAdapter adapter = new SyndicationResourceAdapter(navigator, settings);
adapter.Fill(atomFeed, SyndicationContentFormat.Atom);
feed.Parse(atomFeed);
}
else if (metadata.Format == SyndicationContentFormat.Rss)
{
RssFeed rssFeed = new RssFeed();
SyndicationResourceAdapter adapter = new SyndicationResourceAdapter(navigator, settings);
adapter.Fill(rssFeed, SyndicationContentFormat.Rss);
feed.Parse(rssFeed);
}
//------------------------------------------------------------
// Raise Loaded event to notify registered handlers of state change
//------------------------------------------------------------
feed.OnFeedLoaded(new SyndicationResourceLoadedEventArgs(navigator, source, options, userToken));
}
}
}
//------------------------------------------------------------
// Reset load operation in progress indicator
//------------------------------------------------------------
feed.LoadOperationInProgress = false;
}
}
}
/// <summary>
/// Initializes the generic syndication feed using the supplied <see cref="AtomFeed"/>.
/// </summary>
/// <param name="feed">The <see cref="AtomFeed"/> to build an abstraction against.</param>
/// <exception cref="ArgumentNullException">The <paramref name="feed"/> is a null reference (Nothing in Visual Basic).</exception>
public void Parse(AtomFeed feed)
{
//------------------------------------------------------------
// Validate parameters
//------------------------------------------------------------
Guard.ArgumentNotNull(feed, "feed");
//------------------------------------------------------------
// Initialize generic feed
//------------------------------------------------------------
feedResource = feed;
feedFormat = SyndicationContentFormat.Atom;
if (feed.Title != null && !String.IsNullOrEmpty(feed.Title.Content))
{
feedTitle = feed.Title.Content;
}
if (feed.Subtitle != null && !String.IsNullOrEmpty(feed.Title.Content))
{
feedDescription = feed.Subtitle.Content;
}
if (feed.UpdatedOn != DateTime.MinValue)
{
feedLastUpdatedOn = feed.UpdatedOn;
}
if(feed.Language != null)
{
feedLanguage = feed.Language;
}
foreach(AtomCategory category in feed.Categories)
{
GenericSyndicationCategory genericCategory = new GenericSyndicationCategory(category);
feedCategories.Add(genericCategory);
}
foreach(AtomEntry entry in feed.Entries)
{
GenericSyndicationItem genericItem = new GenericSyndicationItem(entry);
((Collection<GenericSyndicationItem>)feedItems).Add(genericItem);
}
}
public static DataTable GetRssFeedEntries(
int moduleId,
Guid moduleGuid,
int entryCacheTimeout,
int maxDaysOld,
int maxEntriesPerFeed,
bool enableSelectivePublishing)
{
DateTime cutoffDate = DateTime.UtcNow.AddDays(-maxDaysOld);
DateTime cacheExpiration = DateTime.UtcNow.AddMinutes(-entryCacheTimeout);
DateTime lastCacheTime = mojoPortal.Business.RssFeed.GetLastCacheTime(moduleGuid);
if (lastCacheTime > cacheExpiration)
{
// data "cached" in the db has not expired so just return it
return(mojoPortal.Business.RssFeed.GetEntries(moduleGuid));
}
try
{
if (FeedManagerConfiguration.UseReadWriteLockForCacheMenagement)
{
cacheLock.AcquireWriterLock(cacheLockTimeoutInMilliseconds);
}
//if (debugLog) { log.Debug("got lock in GetRssFeeds"); }
lastCacheTime = mojoPortal.Business.RssFeed.GetLastCacheTime(moduleGuid);
if (lastCacheTime > cacheExpiration)
{
// data "cached" in the db has not expired so just return it
return(mojoPortal.Business.RssFeed.GetEntries(moduleGuid));
}
if (enableSelectivePublishing)
{
mojoPortal.Business.RssFeed.DeleteExpiredEntriesByModule(moduleGuid, cutoffDate);
mojoPortal.Business.RssFeed.DeleteUnPublishedEntriesByModule(moduleGuid);
}
else
{
mojoPortal.Business.RssFeed.DeleteEntriesByModule(moduleGuid);
}
DataTable dtFeeds = mojoPortal.Business.RssFeed.GetFeeds(moduleId);
string siteRoot = SiteUtils.GetNavigationSiteRoot();
string secureSiteRoot = SiteUtils.GetSecureNavigationSiteRoot();
foreach (DataRow dr in dtFeeds.Rows)
{
Guid feedGuid = new Guid(dr["ItemGuid"].ToString());
int feedId = Convert.ToInt32(dr["ItemID"]);
string feedUrl = dr["RssUrl"].ToString();
if (feedUrl.StartsWith("~/"))
{
feedUrl = WebUtils.ResolveServerUrl(feedUrl).Replace("https:", "http:");
}
bool publishByDefault = Convert.ToBoolean(dr["PublishByDefault"]);
int countOfPreservedEntries = Convert.ToInt32(dr["TotalEntries"]);
bool publish = true;
if (enableSelectivePublishing)
{
if (!publishByDefault)
{
publish = false;
}
}
int entriesAdded = countOfPreservedEntries;
try
{
GenericSyndicationFeed gsFeed = GenericSyndicationFeed.Create(new Uri(FormatFeedUrl(feedUrl, siteRoot, secureSiteRoot)));
#region RSSFeed_management
if (gsFeed.Format == SyndicationContentFormat.Rss)
{
Argotic.Syndication.RssFeed rssFeed = gsFeed.Resource as Argotic.Syndication.RssFeed;
if (rssFeed != null)
{
foreach (Argotic.Syndication.RssItem rssItem in rssFeed.Channel.Items)
{
DateTime itemPubDate = EnsureDate(rssItem.PublicationDate);
if ((itemPubDate >= cutoffDate) || (maxDaysOld == 0))
{
if ((entriesAdded < maxEntriesPerFeed) || (maxEntriesPerFeed == 0))
{
string entryBlob = rssItem.Title + rssItem.Link.ToString();
int entryHash = GetEntryHash(entryBlob);
string channelLink = string.Empty;
if ((rssFeed.Channel != null) && (rssFeed.Channel.Link != null))
{
channelLink = rssFeed.Channel.Link.ToString();
}
if (UpdateEntry(
moduleGuid,
itemPubDate,
rssItem.Title,
rssItem.Author,
channelLink,
rssItem.Description,
rssItem.Link.ToString(),
entryHash,
feedGuid,
feedId,
publish) > 0)
{
entriesAdded += 1;
}
}
}
}
}
}
#endregion
#region ATOMFeed_management
if (gsFeed.Format == SyndicationContentFormat.Atom)
{
Argotic.Syndication.AtomFeed atomFeed = gsFeed.Resource as Argotic.Syndication.AtomFeed;
foreach (AtomEntry atItem in atomFeed.Entries)
{
string entryLink = string.Empty;
StringBuilder entryAuthor = new StringBuilder();
string comma = string.Empty;
DateTime itemPubDate = EnsureDate(atItem.UpdatedOn);
if ((itemPubDate >= cutoffDate) || (maxDaysOld == 0))
{
if ((entriesAdded < maxEntriesPerFeed) || (maxEntriesPerFeed == 0))
{
foreach (AtomPersonConstruct atPerson in atItem.Authors)
{
entryAuthor.Append(comma + atPerson.Name);
comma = ",";
}
if (entryAuthor.Length == 0)
{
foreach (AtomPersonConstruct atPerson in atomFeed.Authors)
{
entryAuthor.Append(comma + atPerson.Name);
comma = ",";
}
}
foreach (AtomLink atLink in atItem.Links)
{
if (atLink.Relation == "alternate")
{
entryLink = atLink.Uri.ToString();
}
}
if ((entryLink.Length == 0) && (atItem.Links.Count > 0))
{
entryLink = atItem.Links[0].Uri.ToString();
}
string content = string.Empty;
if (atItem.Content == null)
{
if (atItem.Summary != null)
{
content = atItem.Summary.Content;
}
}
else
{
content = atItem.Content.Content;
}
// commented out 2010-02-27 some feeds have only a title and link
//if (content.Length == 0) { continue; }
string entryBlob = atItem.Title.Content + entryLink;
int entryHash = GetEntryHash(entryBlob);
if (UpdateEntry(
moduleGuid,
itemPubDate,
atItem.Title.Content,
entryAuthor.ToString(),
feedUrl,
content,
entryLink,
entryHash,
feedGuid,
feedId,
publish) > 0)
{
entriesAdded += 1;
}
}
}
}
}
#endregion
}
catch (WebException ex)
{
if (log.IsErrorEnabled)
{
string logMsg = String.Format("There was a problem trying to read the feed for url {0}. Ignoring.", (string)dr["RssUrl"]);
log.Error(logMsg, ex);
}
}
catch (UriFormatException ex)
{
if (log.IsErrorEnabled)
{
string logMsg = String.Format("There was a problem trying to read the feed for url {0}. Ignoring.", (string)dr["RssUrl"]);
log.Error(logMsg, ex);
}
}
catch (System.Net.Sockets.SocketException ex)
{
if (log.IsErrorEnabled)
{
string logMsg = String.Format("There was a problem trying to read the feed for url {0}. Ignoring.", (string)dr["RssUrl"]);
log.Error(logMsg, ex);
}
}
catch (System.Xml.XmlException ex)
{
if (log.IsErrorEnabled)
{
string logMsg = String.Format("There was a problem trying to read the feed for url {0}. Ignoring.", (string)dr["RssUrl"]);
log.Error(logMsg, ex);
}
}
catch (System.Security.SecurityException ex)
{
log.Error("Could not load feed due to security exception. Must be running in restricted trust level. Creating server side web requests is not allowed in current configuration.", ex);
}
catch (ArgumentNullException ex)
{
string logMsg = String.Format("There was a problem trying to read the feed for url {0}. Ignoring.", (string)dr["RssUrl"]);
log.Error(logMsg, ex);
}
catch (System.Data.Common.DbException ex)
{
log.Error("Error updating feed database cache", ex);
}
}
}
finally
{
if (FeedManagerConfiguration.UseReadWriteLockForCacheMenagement)
{
try
{
cacheLock.ReleaseWriterLock();
}
catch (ApplicationException ex)
{
log.Error("swallowed error", ex);
}
}
}
return(mojoPortal.Business.RssFeed.GetEntries(moduleGuid));
}
/// <summary>
/// Creates a new <see cref="AtomFeed"/> instance using the specified <see cref="Uri"/>, <see cref="ICredentials"/>, <see cref="IWebProxy"/>, and <see cref="SyndicationResourceLoadSettings"/> object.
/// </summary>
/// <param name="source">A <see cref="Uri"/> that represents the URL of the syndication resource XML data.</param>
/// <param name="options">A <see cref="WebRequestOptions"/> that holds options that should be applied to web requests.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the <see cref="AtomFeed"/> instance. This value can be <b>null</b>.</param>
/// <returns>An <see cref="AtomFeed"/> object loaded using the <paramref name="source"/> data.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="FormatException">The <paramref name="source"/> data does not conform to the expected syndication content format. In this case, the feed remains empty.</exception>
public static AtomFeed Create(Uri source, WebRequestOptions options, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
AtomFeed syndicationResource = new AtomFeed();
//------------------------------------------------------------
// Validate parameters
//------------------------------------------------------------
Guard.ArgumentNotNull(source, "source");
//------------------------------------------------------------
// Create new instance using supplied parameters
//------------------------------------------------------------
syndicationResource.Load(source, options, settings);
return syndicationResource;
}
private int ReadSource(Source source,bool? IsForTest)
{
var count = 0;
var client = new WebClient();
try
{
using (var stream = client.OpenRead(source.StreamUrl))
{
try
{
#region RssFeed
RssFeed feed = new RssFeed();
feed.Load(stream);
foreach (var i in feed.Channel.Items)
{
try
{
if (ReadFeedItem(i, source,IsForTest))
count++;
Thread.Sleep(500);
}
catch (Exception e)
{
var failed = new FailedUrl();
failed.Url = i.Link.ToString();
failed.Exception = e.Message;
this.Data.FailedUrls.Add(failed);
this.Data.SaveChanges();
continue;
}
}
#endregion RssFeed
}
catch (FormatException f)
{
#region AtomFeed
AtomFeed afeed = new AtomFeed();
using (var astream = client.OpenRead(source.StreamUrl))
{
afeed.Load(astream);
foreach (var i in afeed.Entries)
{
try
{
if (ReadFeedItem(i, source,IsForTest))
count++;
Thread.Sleep(500);
}
catch (Exception e)
{
var failed = new FailedUrl();
failed.Url = i.Links.FirstOrDefault().ToString();
failed.Exception = e.Message;
this.Data.FailedUrls.Add(failed);
this.Data.SaveChanges();
continue;
}
}
}
#endregion AtomFeed
}
Source s = this.Data.Sources.FirstOrDefault(d => d.Id == source.Id);
s.LastUpdated = DateTime.Now;
this.Data.Sources.Update(s);
this.Data.SaveChanges();
}
//try
//{
// if (count > 0)
// CacheManager.Clear(CacheRegions.News);
//}
//catch (Exception e)
//{
// //TODO handle exc
//}
}
catch (Exception e)
{
//TODO handle exc
}
Console.WriteLine(source.Name);
return count;
}
private int GetAtomFeedItems(AtomFeed feed, Subscription subscription)
{
var itemsAdded = 0;
foreach (var entry in feed.Entries.Where(x => subscription.LastFeedUpdatesUTC == null
|| x.PublishedOn.ToUniversalTime() > subscription.LastFeedUpdatesUTC))
{
var categories = entry.Categories.Aggregate(String.Empty, (current, category) => current + (category.Label + ",")).TrimEnd(',');
var authors = entry.Authors.Aggregate(String.Empty, (current, author) => current + (author.Name + ",")).TrimEnd(',');
var subscriptionPost = new SubscriptionPost
{
Authors = authors,
Categories = categories,
Content = entry.Content != null ? entry.Content.Content : (entry.Summary != null) ? entry.Summary.Content : String.Empty,
OriginalUrl = GetOriginalUrl(entry),
PublishDateUTC = GetGoodDateTime(entry.PublishedOn.ToUniversalTime()),
Subscription = subscription,
Title = entry.Title.Content
};
itemsAdded++;
_dbContext.SubscriptionPosts.Add(subscriptionPost);
subscription.SubscriptionPosts.Add(subscriptionPost);
}
return itemsAdded;
}
private static string GetAtomSubscriptionTitle(AtomFeed atom)
{
if (atom.BaseUri == null)
{
var link = atom.Links.SingleOrDefault(x => x.Relation == String.Empty);
if (link != null)
{
return link.Uri.ToString();
}
var alternateUrl = atom.Links.SingleOrDefault(x => x.Relation == "alternate");
if (alternateUrl != null)
{
return alternateUrl.Uri.ToString();
}
}
return atom.BaseUri.ToString();
}
//============================================================
// INSTANCE METHODS
//============================================================
/// <summary>
/// Provides example code for the Load(IXPathNavigable) method
/// </summary>
public static void LoadIXPathNavigableExample()
{
#region Load(IXPathNavigable source)
XPathDocument source = new XPathDocument("http://news.google.com/?output=atom");
AtomFeed feed = new AtomFeed();
feed.Load(source);
foreach (AtomEntry entry in feed.Entries)
{
if (entry.PublishedOn >= DateTime.Today)
{
// Perform some processing on the feed entry
}
}
#endregion
}
/// <summary>
/// Provides example code for the Load(Stream) method
/// </summary>
public static void LoadStreamExample()
{
#region Load(Stream stream)
AtomFeed feed = new AtomFeed();
using (Stream stream = new FileStream("AtomFeed.xml", FileMode.Open, FileAccess.Read))
{
feed.Load(stream);
foreach (AtomEntry entry in feed.Entries)
{
if (entry.PublishedOn >= DateTime.Today)
{
// Perform some processing on the feed entry
}
}
}
#endregion
}
/// <summary>
/// Loads the generic syndication feed using the specified <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="navigator">A read-only <see cref="XPathNavigator"/> object for navigating through the syndication resource information.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the load operation of the <see cref="GenericSyndicationFeed"/>.</param>
/// <param name="eventData">A <see cref="SyndicationResourceLoadedEventArgs"/> that contains the event data used when raising the <see cref="GenericSyndicationFeed.Loaded"/> event.</param>
/// <remarks>
/// After the load operation has successfully completed, the <see cref="GenericSyndicationFeed.Loaded"/> event is raised using the specified <paramref name="eventData"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="eventData"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="FormatException">The <paramref name="navigator"/> data does not conform to the expected syndication content format. In this case, the feed remains empty.</exception>
private void Load(XPathNavigator navigator, SyndicationResourceLoadSettings settings, SyndicationResourceLoadedEventArgs eventData)
{
//------------------------------------------------------------
// Validate parameters
//------------------------------------------------------------
Guard.ArgumentNotNull(navigator, "navigator");
Guard.ArgumentNotNull(settings, "settings");
Guard.ArgumentNotNull(eventData, "eventData");
//------------------------------------------------------------
// Initialize generic feed based on syndication resource format
//------------------------------------------------------------
SyndicationResourceMetadata metadata = new SyndicationResourceMetadata(navigator);
if (metadata.Format == SyndicationContentFormat.Atom)
{
AtomFeed feed = new AtomFeed();
SyndicationResourceAdapter adapter = new SyndicationResourceAdapter(navigator, settings);
adapter.Fill(feed, SyndicationContentFormat.Atom);
this.Parse(feed);
}
else if (metadata.Format == SyndicationContentFormat.Rss)
{
RssFeed feed = new RssFeed();
SyndicationResourceAdapter adapter = new SyndicationResourceAdapter(navigator, settings);
adapter.Fill(feed, SyndicationContentFormat.Rss);
this.Parse(feed);
}
else if (metadata.Format == SyndicationContentFormat.Opml)
{
OpmlDocument opmlDoc = new OpmlDocument();
SyndicationResourceAdapter adapter = new SyndicationResourceAdapter(navigator, settings);
adapter.Fill(opmlDoc, SyndicationContentFormat.Opml);
this.Parse(opmlDoc);
}
//------------------------------------------------------------
// Raise Loaded event to notify registered handlers of state change
//------------------------------------------------------------
this.OnFeedLoaded(eventData);
}
/// <summary>
/// Provides example code for the Load(Uri, ICredentials, IWebProxy) method
/// </summary>
public static void LoadUriExample()
{
#region Load(Uri source, ICredentials credentials, IWebProxy proxy)
AtomFeed feed = new AtomFeed();
Uri source = new Uri("http://news.google.com/?output=atom");
feed.Load(source, CredentialCache.DefaultNetworkCredentials, null);
foreach (AtomEntry entry in feed.Entries)
{
if (entry.PublishedOn >= DateTime.Today)
{
// Perform some processing on the feed entry
}
}
#endregion
}
/// <summary>
/// Modifies the <see cref="AtomFeed"/> collection entities to match the supplied <see cref="XPathNavigator"/> data source.
/// </summary>
/// <param name="feed">The <see cref="AtomFeed"/> to be filled.</param>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the fill operation.</param>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="AtomFeed"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="feed"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
private static void FillFeedCollections(AtomFeed feed, XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(feed, "feed");
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Attempt to extract syndication information
//------------------------------------------------------------
XPathNodeIterator authorIterator = source.Select("atom:author", manager);
XPathNodeIterator contributorIterator = source.Select("atom:contributor", manager);
XPathNodeIterator linkIterator = source.Select("atom:link", manager);
XPathNodeIterator entryIterator = source.Select("atom:entry", manager);
if (authorIterator != null && authorIterator.Count > 0)
{
while (authorIterator.MoveNext())
{
AtomPersonConstruct author = Atom03SyndicationResourceAdapter.CreatePerson(authorIterator.Current, manager, settings);
feed.Authors.Add(author);
}
}
if (contributorIterator != null && contributorIterator.Count > 0)
{
while (contributorIterator.MoveNext())
{
AtomPersonConstruct contributor = Atom03SyndicationResourceAdapter.CreatePerson(contributorIterator.Current, manager, settings);
feed.Contributors.Add(contributor);
}
}
if (entryIterator != null && entryIterator.Count > 0)
{
int counter = 0;
while (entryIterator.MoveNext())
{
AtomEntry entry = new AtomEntry();
counter++;
Atom03SyndicationResourceAdapter.FillEntry(entry, entryIterator.Current, manager, settings);
if (settings.RetrievalLimit != 0 && counter > settings.RetrievalLimit)
{
break;
}
((Collection<AtomEntry>)feed.Entries).Add(entry);
}
}
if (linkIterator != null && linkIterator.Count > 0)
{
while (linkIterator.MoveNext())
{
AtomLink link = new AtomLink();
if (link.Load(linkIterator.Current, settings))
{
feed.Links.Add(link);
}
}
}
}
/// <summary>
/// Provides example code for the Load(XmlReader) method
/// </summary>
public static void LoadXmlReaderExample()
{
#region Load(XmlReader reader)
AtomFeed feed = new AtomFeed();
using (Stream stream = new FileStream("AtomFeed.xml", FileMode.Open, FileAccess.Read))
{
XmlReaderSettings settings = new XmlReaderSettings();
settings.IgnoreComments = true;
settings.IgnoreWhitespace = true;
using(XmlReader reader = XmlReader.Create(stream, settings))
{
feed.Load(reader);
foreach (AtomEntry entry in feed.Entries)
{
if (entry.PublishedOn >= DateTime.Today)
{
// Perform some processing on the feed entry
}
}
}
}
#endregion
}
/// <summary>
/// Modifies the <see cref="AtomFeed"/> to match the data source.
/// </summary>
/// <param name="resource">The <see cref="AtomFeed"/> to be filled.</param>
/// <exception cref="ArgumentNullException">The <paramref name="resource"/> is a null reference (Nothing in Visual Basic).</exception>
public void Fill(AtomFeed resource)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(resource, "resource");
//------------------------------------------------------------
// Create namespace resolver
//------------------------------------------------------------
XmlNamespaceManager manager = Atom03SyndicationResourceAdapter.CreateNamespaceManager(this.Navigator.NameTable);
//------------------------------------------------------------
// Attempt to fill syndication resource
//------------------------------------------------------------
XPathNavigator feedNavigator = this.Navigator.SelectSingleNode("atom:feed", manager);
if (feedNavigator != null)
{
AtomUtility.FillCommonObjectAttributes(resource, feedNavigator);
XPathNavigator idNavigator = feedNavigator.SelectSingleNode("atom:id", manager);
XPathNavigator titleNavigator = feedNavigator.SelectSingleNode("atom:title", manager);
XPathNavigator modifiedNavigator = feedNavigator.SelectSingleNode("atom:modified", manager);
if (idNavigator != null)
{
resource.Id = new AtomId();
resource.Id.Load(idNavigator, this.Settings);
}
if (titleNavigator != null)
{
resource.Title = Atom03SyndicationResourceAdapter.CreateTextContent(titleNavigator, manager, this.Settings);
}
if (modifiedNavigator != null)
{
DateTime updatedOn;
if (SyndicationDateTimeUtility.TryParseRfc3339DateTime(modifiedNavigator.Value, out updatedOn))
{
resource.UpdatedOn = updatedOn;
}
}
Atom03SyndicationResourceAdapter.FillFeedOptionals(resource, feedNavigator, manager, this.Settings);
Atom03SyndicationResourceAdapter.FillFeedCollections(resource, feedNavigator, manager, this.Settings);
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(feedNavigator, this.Settings);
adapter.Fill(resource, manager);
}
}
public override void ExecuteItemSequence(string groupByValue, IEnumerable<Tuple<ITaskItem, ITaskItem, ITaskItem>> items)
{
var feed = new AtomFeed
{
Id = new AtomId(new Uri(FeedId)),
Title = new AtomTextConstruct(FeedTitle ?? ""),
UpdatedOn = DateTime.Now,
};
if (!string.IsNullOrWhiteSpace(FeedRights))
{
feed.Rights = new AtomTextConstruct(FeedRights);
}
if (!string.IsNullOrWhiteSpace(FeedIcon))
{
feed.Icon = new AtomIcon(new Uri(FeedIcon));
}
if (!string.IsNullOrWhiteSpace(FeedLogo))
{
feed.Logo = new AtomLogo(new Uri(FeedLogo));
}
if (!string.IsNullOrWhiteSpace(FeedSubtitle))
{
feed.Subtitle = new AtomTextConstruct(FeedSubtitle);
}
if (!string.IsNullOrWhiteSpace(FeedAuthors))
{
foreach (string author in FeedAuthors.Split(';').Select(item => item.Trim()))
{
feed.Authors.Add(new AtomPersonConstruct(author));
}
}
if (!string.IsNullOrWhiteSpace(FeedContributors))
{
foreach (string contributor in FeedContributors.Split(';').Select(item => item.Trim()))
{
feed.Contributors.Add(new AtomPersonConstruct(contributor));
}
}
if (!string.IsNullOrWhiteSpace(FeedCategories))
{
foreach (string category in FeedCategories.Split(';').Select(item => item.Trim()))
{
feed.Categories.Add(new AtomCategory(category));
}
}
if (FeedLinkRelationSelf != null)
{
var selfLink = new AtomLink
{
Relation = "self",
Uri = new Uri(FeedLinkRelationSelf)
};
feed.Links.Add(selfLink);
}
foreach (Tuple<ITaskItem, ITaskItem, ITaskItem> tuple in items.OrderByDescending(item => item.Item2.GetTimestamp()))
{
ITaskItem modelInput = tuple.Item1;
ITaskItem receiptInput = tuple.Item2;
ITaskItem contentInput = tuple.Item3;
modelInput.LoadCustomMetadata();
DateTime receiptModified = receiptInput.GetTimestamp();
var entry = new AtomEntry
{
Id = new AtomId(new Uri(modelInput.GetMetadata(EntryIdSelector ?? "Uri"))),
Title = new AtomTextConstruct(modelInput.GetMetadata(EntryTitleSelector ?? "Title")),
UpdatedOn = receiptModified,
Summary = new AtomTextConstruct(modelInput.GetMetadata(EntrySummarySelector ?? "Summary")),
};
if (string.IsNullOrWhiteSpace(entry.Title.Content))
{
entry.Title.Content = tuple.Item1.ItemSpec;
}
if (string.IsNullOrWhiteSpace(entry.Summary.Content))
{
entry.Summary.Content = entry.Title.Content;
}
if (contentInput.Exists())
{
if (string.IsNullOrWhiteSpace(EntryContentEncoding))
{
entry.Content = new AtomContent(contentInput.ReadAllText());
}
else
{
entry.Content = new AtomContent(contentInput.ReadAllText(), EntryContentEncoding);
}
if (!string.IsNullOrWhiteSpace(EntryContentType))
{
entry.Content.ContentType = EntryContentType;
}
}
var alternateLink = new AtomLink
{
Relation = "alternate",
Uri = new Uri(modelInput.GetMetadata(EntryLinkAlternateSelector ?? "Uri"))
};
entry.Links.Add(alternateLink);
feed.AddEntry(entry);
}
using (FileStream stream = File.OpenWrite(Output.ItemSpec))
{
SyndicationResourceSaveSettings s = new SyndicationResourceSaveSettings() { CharacterEncoding = Encoding.UTF8 };
feed.Save(stream, s);
}
}