/// <summary>
/// Compares the current instance with another object of the same type.
/// </summary>
/// <param name="obj">An object to compare with this instance.</param>
/// <returns>A 32-bit signed integer that indicates the relative order of the objects being compared.</returns>
/// <exception cref="ArgumentException">The <paramref name="obj"/> is not the expected <see cref="Type"/>.</exception>
public int CompareTo(object obj)
{
if (obj == null)
{
return(1);
}
AtomLink value = obj as AtomLink;
if (value != null)
{
int result = this.Length.CompareTo(value.Length);
result = result | String.Compare(this.ContentType, value.ContentType, StringComparison.OrdinalIgnoreCase);
result = result | String.Compare(this.Relation, value.Relation, StringComparison.OrdinalIgnoreCase);
string sourceLanguageName = this.ContentLanguage != null ? this.ContentLanguage.Name : String.Empty;
string targetLanguageName = value.ContentLanguage != null ? value.ContentLanguage.Name : String.Empty;
result = result | String.Compare(sourceLanguageName, targetLanguageName, StringComparison.OrdinalIgnoreCase);
result = result | String.Compare(this.Title, value.Title, StringComparison.OrdinalIgnoreCase);
result = result | Uri.Compare(this.Uri, value.Uri, UriComponents.AbsoluteUri, UriFormat.SafeUnescaped, StringComparison.OrdinalIgnoreCase);
result = result | AtomUtility.CompareCommonObjectAttributes(this, value);
return(result);
}
else
{
throw new ArgumentException(String.Format(null, "obj is not of type {0}, type was found to be '{1}'.", this.GetType().FullName, obj.GetType().FullName), "obj");
}
}
/// <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>
/// Modifies the <see cref="AtomEntry"/> collection entities to match the supplied <see cref="XPathNavigator"/> data source.
/// </summary>
/// <param name="entry">The <see cref="AtomEntry"/> 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 an Atom 0.3 element.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="entry"/> 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 FillEntryCollections(AtomEntry entry, XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(entry, "entry");
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);
if (authorIterator != null && authorIterator.Count > 0)
{
while (authorIterator.MoveNext())
{
AtomPersonConstruct author = Atom03SyndicationResourceAdapter.CreatePerson(authorIterator.Current, manager, settings);
entry.Authors.Add(author);
}
}
if (contributorIterator != null && contributorIterator.Count > 0)
{
while (contributorIterator.MoveNext())
{
AtomPersonConstruct contributor = Atom03SyndicationResourceAdapter.CreatePerson(contributorIterator.Current, manager, settings);
entry.Contributors.Add(contributor);
}
}
if (linkIterator != null && linkIterator.Count > 0)
{
while (linkIterator.MoveNext())
{
AtomLink link = new AtomLink();
if (link.Load(linkIterator.Current, settings))
{
entry.Links.Add(link);
}
}
}
}
/// <summary>
/// Loads this <see cref="AtomSource"/> collection elements using the supplied <see cref="XPathNavigator"/>.
/// </summary>
/// <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>
/// <returns><b>true</b> if the <see cref="AtomSource"/> collection entities were initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="AtomSource"/>.
/// </remarks>
/// <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>
private bool LoadCollections(XPathNavigator source, XmlNamespaceManager manager)
{
//------------------------------------------------------------
// Local members
//------------------------------------------------------------
bool wasLoaded = false;
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(manager, "manager");
//------------------------------------------------------------
// Attempt to extract syndication information
//------------------------------------------------------------
XPathNodeIterator authorIterator = source.Select("atom:author", manager);
XPathNodeIterator contributorIterator = source.Select("atom:contributor", manager);
XPathNodeIterator categoryIterator = source.Select("atom:category", manager);
XPathNodeIterator linkIterator = source.Select("atom:link", manager);
if (authorIterator != null && authorIterator.Count > 0)
{
while (authorIterator.MoveNext())
{
AtomPersonConstruct author = new AtomPersonConstruct();
if (author.Load(authorIterator.Current))
{
this.Authors.Add(author);
wasLoaded = true;
}
}
}
if (categoryIterator != null && categoryIterator.Count > 0)
{
while (categoryIterator.MoveNext())
{
AtomCategory category = new AtomCategory();
if (category.Load(categoryIterator.Current))
{
this.Categories.Add(category);
wasLoaded = true;
}
}
}
if (contributorIterator != null && contributorIterator.Count > 0)
{
while (contributorIterator.MoveNext())
{
AtomPersonConstruct contributor = new AtomPersonConstruct();
if (contributor.Load(contributorIterator.Current))
{
this.Contributors.Add(contributor);
wasLoaded = true;
}
}
}
if (linkIterator != null && linkIterator.Count > 0)
{
while (linkIterator.MoveNext())
{
AtomLink link = new AtomLink();
if (link.Load(linkIterator.Current))
{
this.Links.Add(link);
wasLoaded = true;
}
}
}
return wasLoaded;
}
private AtomEntry GetPost(TransitPost post)
{
AtomEntry atomEntry = new AtomEntry();
atomEntry.Title = new AtomTextConstruct(post.Title);
foreach (TransitTopic topic in post.Topics)
{
atomEntry.Categories.Add(new AtomCategory(topic.Name));
}
atomEntry.Content = new AtomContent(post.BodyXHTML, "html");
atomEntry.PublishedOn = post.Created;
atomEntry.UpdatedOn = post.Modified;
atomEntry.Id = new AtomId(new Uri(string.Format("{0}Post/{1}", SessionManager.WebsiteUrl, post.Id)));
atomEntry.Links.Add(new AtomLink(new Uri(string.Format("{0}AtomBlog.aspx?id={1}", SessionManager.WebsiteUrl, post.Id)), "edit"));
AtomLink atomEntryUri = new AtomLink(new Uri(string.Format("{0}{1}", SessionManager.WebsiteUrl, post.LinkUri)), "alternate");
atomEntryUri.ContentType = "text/html";
atomEntry.Links.Add(atomEntryUri);
return atomEntry;
}
private void CreateOrUpdatePost(object sender, EventArgs e)
{
SessionManager.BasicAuth();
if (!SessionManager.IsAdministrator)
{
throw new ManagedLogin.AccessDeniedException();
}
AtomEntry atomEntry = new AtomEntry();
atomEntry.Load(Request.InputStream);
TransitPost post = (RequestId > 0)
? SessionManager.BlogService.GetPostById(SessionManager.Ticket, RequestId)
: new TransitPost();
post.Title = atomEntry.Title.Content;
List<TransitTopic> topics = new List<TransitTopic>();
foreach (AtomCategory category in atomEntry.Categories)
{
TransitTopic topic = SessionManager.BlogService.GetTopicByName(SessionManager.Ticket, category.Term);
if (topic == null)
{
topic = new TransitTopic();
topic.Name = category.Term;
}
topics.Add(topic);
}
post.Topics = topics.ToArray();
post.Body = atomEntry.Content.Content;
post.Publish = true;
post.Display = true;
post.Sticky = false;
post.Export = false;
if (atomEntry.PublishedOn != DateTime.MinValue)
post.Created = atomEntry.PublishedOn;
if (atomEntry.UpdatedOn != DateTime.MinValue)
post.Modified = atomEntry.UpdatedOn;
post.Id = SessionManager.BlogService.CreateOrUpdatePost(SessionManager.Ticket, post);
Response.ContentType = "application/atom+xml;type=entry;charset=\"utf-8\"";
Response.StatusCode = 201;
Response.StatusDescription = "Created";
string location = string.Format("{0}AtomPost.aspx?id={1}", SessionManager.WebsiteUrl, post.Id);
Response.Headers.Add("Location", location);
Response.Headers.Add("Content-Location", location);
Response.Headers.Add("ETag", string.Format("\"{0}\"", Guid.NewGuid().ToString()));
atomEntry.Id = new AtomId(new Uri(string.Format("{0}Post/{1}", SessionManager.WebsiteUrl, post.Id)));
atomEntry.Links.Add(new AtomLink(new Uri(string.Format("{0}AtomPost.aspx?id={1}", SessionManager.WebsiteUrl, post.Id))));
atomEntry.Links.Add(new AtomLink(new Uri(string.Format("{0}AtomPost.aspx?id={1}", SessionManager.WebsiteUrl, post.Id)), "edit"));
AtomLink atomEntryUri = new AtomLink(new Uri(string.Format("{0}{1}", SessionManager.WebsiteUrl, post.LinkUri)), "alternate");
atomEntryUri.ContentType = "text/html";
atomEntry.Links.Add(atomEntryUri);
atomEntry.Save(Response.OutputStream);
Response.End();
}
private AtomEntry GetImage(TransitImage image)
{
AtomEntry atomEntry = new AtomEntry();
atomEntry.Id = new AtomId(new Uri(string.Format("{0}Image/{1}", SessionManager.WebsiteUrl, image.Id)));
atomEntry.Title = new AtomTextConstruct(image.Name);
atomEntry.UpdatedOn = DateTime.UtcNow;
atomEntry.Summary = new AtomTextConstruct();
atomEntry.Content = new AtomContent("", "image/jpg");
atomEntry.Content.Source = new Uri(string.Format("{0}ShowPicture.aspx?id={1}&ShowThumbnail=false", SessionManager.WebsiteUrl, image.Id));
atomEntry.Links.Add(new AtomLink(new Uri(string.Format("{0}AtomImage.aspx?id={1}", SessionManager.WebsiteUrl, image.Id)), "edit"));
AtomLink atomEntryUri = new AtomLink(new Uri(string.Format("{0}ShowPicture.aspx?id={1}&ShowThumbnail=false", SessionManager.WebsiteUrl, image.Id)), "edit-media");
atomEntryUri.ContentType = "image/jpg";
atomEntry.Links.Add(atomEntryUri);
return atomEntry;
}
/// <summary>
/// Loads this <see cref="AtomSource"/> collection elements using the supplied <see cref="XPathNavigator"/>.
/// </summary>
/// <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>
/// <returns><b>true</b> if the <see cref="AtomSource"/> collection entities were initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="AtomSource"/>.
/// </remarks>
/// <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>
private bool LoadCollections(XPathNavigator source, XmlNamespaceManager manager)
{
bool wasLoaded = false;
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(manager, "manager");
XPathNodeIterator authorIterator = source.Select("atom:author", manager);
XPathNodeIterator contributorIterator = source.Select("atom:contributor", manager);
XPathNodeIterator categoryIterator = source.Select("atom:category", manager);
XPathNodeIterator linkIterator = source.Select("atom:link", manager);
if (authorIterator != null && authorIterator.Count > 0)
{
while (authorIterator.MoveNext())
{
AtomPersonConstruct author = new AtomPersonConstruct();
if (author.Load(authorIterator.Current))
{
this.Authors.Add(author);
wasLoaded = true;
}
}
}
if (categoryIterator != null && categoryIterator.Count > 0)
{
while (categoryIterator.MoveNext())
{
AtomCategory category = new AtomCategory();
if (category.Load(categoryIterator.Current))
{
this.Categories.Add(category);
wasLoaded = true;
}
}
}
if (contributorIterator != null && contributorIterator.Count > 0)
{
while (contributorIterator.MoveNext())
{
AtomPersonConstruct contributor = new AtomPersonConstruct();
if (contributor.Load(contributorIterator.Current))
{
this.Contributors.Add(contributor);
wasLoaded = true;
}
}
}
if (linkIterator != null && linkIterator.Count > 0)
{
while (linkIterator.MoveNext())
{
AtomLink link = new AtomLink();
if (link.Load(linkIterator.Current))
{
this.Links.Add(link);
wasLoaded = true;
}
}
}
return(wasLoaded);
}
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);
}
}
