/// <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); } }