public SyndicationFeedFormatter GetJobs(string format) { var groups = _Scheduler.GetJobGroupNames(); SyndicationFeed feed = new SyndicationFeed(); List<SyndicationItem> items = new List<SyndicationItem>(); foreach (var group in groups) { var jobKeys = _Scheduler.GetJobKeys(GroupMatcher<JobKey>.GroupEquals(group)); foreach (var jobKey in jobKeys) { var job = _Scheduler.GetJobDetail(jobKey); SyndicationItem item = new SyndicationItem(); item.Id = job.Key.ToString(); item.LastUpdatedTime = DateTime.UtcNow; item.Title = new TextSyndicationContent(string.Format("{0} - {1}", job.Key.Group, job.Key.Name), TextSyndicationContentKind.Plaintext); item.Summary = new TextSyndicationContent(string.Format("Job {0} for group {1}.", job.Key.Name, job.Key.Group), TextSyndicationContentKind.Plaintext); items.Add(item); } } feed.Items = items; SyndicationFeedFormatter formatter = new Rss20FeedFormatter(feed); return formatter; }
protected void Page_Load(object sender, System.EventArgs e) { List<SyndicationItem> syndicationItems = new List<SyndicationItem>(); IList<Card> cards = uWiMP.TVServer.Cards.GetCards(); foreach (Card card in cards) { if (card.Enabled & card.Name.ToLower().Contains("builtin")) { uWiMP.TVServer.Cards.Status status = uWiMP.TVServer.Cards.GetCardStatus(card); SyndicationItem si = new SyndicationItem(); si.Title = new TextSyndicationContent("Recording"); } } SyndicationFeed feed = new SyndicationFeed(syndicationItems); StringWriter output = new StringWriter(); XmlTextWriter writer = new XmlTextWriter(output); Rss20FeedFormatter f = new Rss20FeedFormatter(feed); f.WriteTo(writer); Context.Response.ContentType = "application/rss+xml"; Context.Response.Write(output.ToString()); }
protected override void because() { base.because(); entry = new BlogEntry {Author = "Me", Content = "Content", PublicationDate = DateTime.Now, Title = "Title"}; item = new BlogEntryToRssConverter(entry).ToRssItem(); }
/// <summary> /// Converts This IComposableMessage Into A Geo-RSS SyndicationItem /// </summary> /// <param name="myitem">Pointer to a Syndication Item to Populate</param> internal override void ToGeoRSS(System.ServiceModel.Syndication.SyndicationItem myitem) { myitem.Title = new TextSyndicationContent("Field Observation - " + this.observationType.ToString() + " (EDXL-SitRep)"); TextSyndicationContent content = new TextSyndicationContent("Observation: " + this.observationText + "\nImmediate Needs: " + this.immediateNeeds); myitem.Content = content; }
public virtual ActionResult Feed() { using (var repository = ObjectFactory.GetInstance<IBlogService>()) { var items = new List<SyndicationItem>(); foreach (var post in repository.GetPublishedPosts()) { var item = new SyndicationItem(post.Title, post.Summary, new Uri(String.Format("{0}://{1}{2}", Request.Url.Scheme, Request.Url.Authority, Url.Action(Actions.PostByName(post.Title, post.DateCreated.Year, post.DateCreated.Month, post.DateCreated.Day))))); items.Add(item); } var feed = new SyndicationFeed(MvcApplication.BlogTitle, MvcApplication.BlogSubtitle, new Uri(String.Format("{0}://{1}", Request.Url.Scheme, Request.Url.Authority)), items); return new RssActionResult(feed); } }
public static SyndicationFeed GetPostFeed() { SyndicationFeed postfeed = Feeds.GetFeed(); postfeed.Title = new TextSyndicationContent("Key Mapper Developer Blog"); postfeed.Description = new TextSyndicationContent("Post feed for the Key Mapper Developer Blog"); Collection<Post> posts = Post.GetAllPosts(CommentType.Approved); List<SyndicationItem> items = new List<SyndicationItem>(); foreach (Post p in posts) { SyndicationItem item = new SyndicationItem(); item.Id = p.Id.ToString(); item.Title = new TextSyndicationContent(p.Title); item.Content = new TextSyndicationContent(p.Body); SyndicationLink itemlink = new SyndicationLink(); itemlink.Title = "Key Mapper Blog"; itemlink.Uri = new Uri("http://justkeepswimming.net/keymapper/default.aspx?p=" + p.Id.ToString() + ".aspx"); item.Links.Add(itemlink); SyndicationPerson person = new SyndicationPerson(); person.Name = "Stuart Dunkeld"; person.Email = "*****@*****.**"; item.Authors.Add(person); items.Add(item); } postfeed.Items = items; return postfeed; }
public SyndicationFeed GenerateFeeds(int noOfFeeds) { var feed = new SyndicationFeed { Title = new TextSyndicationContent("A simple rss feeder."), Language = "en-us", LastUpdatedTime = DateTime.Now, Copyright = new TextSyndicationContent("RRiwaj"), Description = new TextSyndicationContent("This is a simple rss feeder created using WCF Syndication class."), ImageUrl = new Uri("/Contents/Images/rss.png", UriKind.Relative), }; var itemsRepo = _feedRepository.GetFeedItems(noOfFeeds); // Get Item Feeds from feed repository. var feedItems = new List<SyndicationItem>(); // Create new Syndication Item List which will be added to Syndication Feed foreach (var proxyItem in itemsRepo) { var item = new SyndicationItem { Title = SyndicationContent.CreatePlaintextContent(proxyItem.Title), PublishDate = proxyItem.FeedDate, Summary = SyndicationContent.CreateHtmlContent(proxyItem.Summary) }; var authInfo = new SyndicationPerson { Name = proxyItem.AuthorName, Email = proxyItem.AuthorEmail }; item.Authors.Add(authInfo); item.Links.Add(SyndicationLink.CreateAlternateLink(new Uri(proxyItem.FeedUrl))); feedItems.Add(item); } feed.Items = feedItems; return feed; }
protected override void WriteFile(System.Web.HttpResponseBase response) { var items = new List<SyndicationItem>(); foreach (Dinner d in this.Dinners) { string contentString = String.Format("{0} with {1} on {2:MMM dd, yyyy} at {3}. Where: {4}, {5}", d.Description, d.HostedBy, d.EventDate, d.EventDate.ToShortTimeString(), d.Address, d.Country); var item = new SyndicationItem( title: d.Title, content: contentString, itemAlternateLink: new Uri("http://nrddnr.com/" + d.DinnerID), id: "http://nrddnr.com/" + d.DinnerID, lastUpdatedTime: d.EventDate.ToUniversalTime() ); item.PublishDate = d.EventDate.ToUniversalTime(); item.Summary = new TextSyndicationContent(contentString, TextSyndicationContentKind.Plaintext); items.Add(item); } SyndicationFeed feed = new SyndicationFeed( this.Title, this.Title, /* Using Title also as Description */ currentUrl, items); Rss20FeedFormatter formatter = new Rss20FeedFormatter(feed); using (XmlWriter writer = XmlWriter.Create(response.Output)) { formatter.WriteTo(writer); } }
public ActionResult Rss(string domain="") { var news = NewsProvider.GetSeason(2014, domain).OrderByDescending(n=>n.Date).Take(10); var feedItems = new List<SyndicationItem>(); foreach (var news_item in news) { var item = new SyndicationItem() { Title = TextSyndicationContent.CreatePlaintextContent(news_item.Title), PublishDate = new DateTimeOffset(news_item.Date), Summary = TextSyndicationContent.CreateHtmlContent(CombineBriefWithImage(news_item)), }; string url = "http://afspb.org.ru/news/" + news_item.Slug; var link = new SyndicationLink(new Uri(url)); link.Title = "Перейти к новости"; item.Links.Add(link); feedItems.Add(item); } var feed = new SyndicationFeed( "Новости сайта Автомобильной Федерации Санкт-Петербурга и Ленинградской области", "", new Uri("http://afspb.org.ru/news/Rss"), feedItems); return new RssResult() { Feed = feed }; }
public SyndicationFeedFormatter CreateFeedForBlog(string user, string blog) { SyndicationFeed feed = new SyndicationFeed("Blog feed", "A feed linked to a blog", null); List<SyndicationItem> items = new List<SyndicationItem>(); List<Dbo.RssArticle> articles = BusinessManagement.Feed.GetBlogContent(user, blog); foreach (Dbo.RssArticle article in articles) { SyndicationItem item = new SyndicationItem(article.Title, article.Content, null); item.PublishDate = article.CreationDate; items.Add(item); } feed.Items = items; // Renvoie ATOM ou RSS en fonction de la chaîne de requête // rss -> http://localhost:8733/Design_Time_Addresses/FluxRss/Feed1/ // atom -> http://localhost:8733/Design_Time_Addresses/FluxRss/Feed1/?format=atom string query = WebOperationContext.Current.IncomingRequest.UriTemplateMatch.QueryParameters["format"]; SyndicationFeedFormatter formatter = null; if (query == "atom") { formatter = new Atom10FeedFormatter(feed); } else { formatter = new Rss20FeedFormatter(feed); } return formatter; }
/// <summary> /// Executes the syndication result on the given context. /// </summary> /// <param name="context">The current context.</param> public override void ExecuteResult(ControllerContext context) { var response = context.HttpContext.Response; var writer = new XmlTextWriter(response.OutputStream, Encoding.UTF8); // Write headers response.ContentType = ContentType; response.ContentEncoding = Encoding.UTF8; var feed = new SyndicationFeed() { Title = new TextSyndicationContent(Config.Blog.Title), LastUpdatedTime = Posts.First().Published.Value, Description = new TextSyndicationContent(Config.Blog.Description), }; feed.Links.Add(SyndicationLink.CreateAlternateLink(new Uri(Utils.AbsoluteUrl("~/")))); var items = new List<SyndicationItem>(); foreach (var post in Posts) { var item = new SyndicationItem() { Title = SyndicationContent.CreatePlaintextContent(post.Title), PublishDate = post.Published.Value, Summary = SyndicationContent.CreateHtmlContent(post.Html.ToHtmlString()) }; item.Links.Add(SyndicationLink.CreateAlternateLink(new Uri(Utils.AbsoluteUrl("~/" + post.Slug)))); items.Add(item); } feed.Items = items; var formatter = GetFormatter(feed); formatter.WriteTo(writer); writer.Flush(); writer.Close(); }
public Rss20FeedFormatter GetFeed() { List<News> news = NewsRepository.GetNews(); var feed = new SyndicationFeed("Nieuwsoverzicht van het festival", "Description", new Uri("http://localhost:8080")); feed.Authors.Add(new SyndicationPerson("Festival naam")); feed.Categories.Add(new SyndicationCategory("Festival")); feed.Description = new TextSyndicationContent("This is a how to sample that demonstrates how to expose a feed using RSS with WCF"); List<SyndicationItem> items = new List<SyndicationItem>(); foreach (News n in news) { SyndicationItem item = new SyndicationItem( n.Title, n.Content, new Uri("http://localhost:51172/"), n.Id, n.Date); item.Authors.Add(new SyndicationPerson(n.Author)); items.Add(item); } feed.Items = items; return new Rss20FeedFormatter(feed); }
public SyndicationFeedFormatter CreateFeed() { // Create a new Syndication Feed. SyndicationFeed feed = new SyndicationFeed("Feed Title", "A WCF Syndication Feed", null); List<SyndicationItem> items = new List<SyndicationItem>(); // Create a new Syndication Item. SyndicationItem item = new SyndicationItem("An item", "Item content", null); items.Add(item); feed.Items = items; // Return ATOM or RSS based on query string // rss -> http://localhost:8733/Design_Time_Addresses/SyndicationServiceLibrary1/Feed1/ // atom -> http://localhost:8733/Design_Time_Addresses/SyndicationServiceLibrary1/Feed1/?format=atom string query = WebOperationContext.Current.IncomingRequest.UriTemplateMatch.QueryParameters["format"]; SyndicationFeedFormatter formatter = null; if (query == "atom") { formatter = new Atom10FeedFormatter(feed); } else { formatter = new Rss20FeedFormatter(feed); } return formatter; }
private static FeedItem CreateFeedItem(SyndicationItem syndicationItem, out string[] searchWords) { FeedItem newFeedItem = new FeedItem(); try { var link = syndicationItem.Links.FirstOrDefault(l => l.RelationshipType == "alternate") ?? syndicationItem.Links.FirstOrDefault(l => l.RelationshipType == "self") ?? syndicationItem.Links.First(); newFeedItem.Url = link.Uri.ToString(); } catch (Exception ex) { throw new Exception("Syndication item has no links", ex); } newFeedItem.Published = syndicationItem.PublishDate; var builder = new SyndicationItemParser(syndicationItem); newFeedItem.Summary = builder.Summary; searchWords = builder.Keywords; newFeedItem.Title = syndicationItem.Title.Text; return newFeedItem; }
/// <summary> /// The add syndication item. /// </summary> /// <param name="currentList"> /// The current list. /// </param> /// <param name="title"> /// The title. /// </param> /// <param name="content"> /// The content. /// </param> /// <param name="summary"> /// The summary. /// </param> /// <param name="link"> /// The alternate link. /// </param> /// <param name="id"> /// The id. /// </param> /// <param name="posted"> /// The posted. /// </param> public static void AddSyndicationItem( this List<SyndicationItem> currentList, string title, string content, string summary,string link, string id, DateTime posted, YafSyndicationFeed feed, List<SyndicationLink> mlinks) { var si = new SyndicationItem( YafContext.Current.Get<IBadWordReplace>().Replace(title), new TextSyndicationContent(YafContext.Current.Get<IBadWordReplace>().Replace(content),TextSyndicationContentKind.Html), // Alternate Link new Uri(link), id, new DateTimeOffset(posted)) {PublishDate = new DateTimeOffset(posted)}; if (mlinks != null) { foreach (var syndicationLink in mlinks) { si.Links.Add(syndicationLink); } } si.Authors.Add(new SyndicationPerson(String.Empty, feed.Contributors[feed.Contributors.Count - 1].Name, String.Empty)); si.SourceFeed = feed; if (summary.IsNotSet()) { si.Summary = new TextSyndicationContent(YafContext.Current.Get<IBadWordReplace>().Replace(content), TextSyndicationContentKind.Html); } else { si.Summary = new TextSyndicationContent(YafContext.Current.Get<IBadWordReplace>().Replace(summary), TextSyndicationContentKind.Html); } currentList.Add(si); }
private RssActionResult RSS(Func<V1FeedPackage, bool> exclude) { var nugetODataUrl = new Uri("http://packages.nuget.org/v1/FeedService.svc"); var nugetOData = new FeedContext_x0060_1(nugetODataUrl); var packages = nugetOData.Packages.OrderByDescending(p => p.Published); var nugetFeed = new List<SyndicationItem>(); foreach (var package in packages) { if (exclude(package)) continue; var syndicationItem = new SyndicationItem( package.Title, package.Description, new Uri(package.ProjectUrl ?? package.GalleryDetailsUrl), package.Id, package.LastUpdated); nugetFeed.Add(syndicationItem); } return new RssActionResult { Feed = new SyndicationFeed( "NuGet Feed", "NuGet OData feed converted to RSS", new Uri("http://www.nugetfeed.com/"), "urn:uuid:f4df456c-6643-4c53-a6e5-f180ce6e030d", nugetFeed.First().LastUpdatedTime, nugetFeed) }; }
public ActionResult ActivityFeed(string name, int id) { var polfeed = _polRep.LatestFeed(id, includeposts); List<SyndicationItem> items = new List<SyndicationItem>(); var pol = _polRep.GetPoliticianById(id); var polLink = this.Request.Url.GetLeftPart(UriPartial.Authority) + pol.PolLink(this); SyndicationFeed feed = new SyndicationFeed( String.Format("{0} Feed", pol.FullName()), "Activity Feed på Folkets Ting", new Uri(Request.Url.ToString()), Request.Url.AbsoluteUri, polfeed.Last().date); foreach (var feeditem in polfeed) { var link = (this.Request.Url.GetLeftPart(UriPartial.Authority) + feeditem.ActionUrl); SyndicationItem item = new SyndicationItem(feeditem.ActionText, feeditem.BodyText, new Uri(link), feeditem.ActionUrl + feeditem.ActionText, feeditem.date); items.Add(item); } feed.Items = items; return new RssActionResult() { Feed = feed }; }
public SyndicationFeed CreateSyndicationFeed(string nickname, string feedType, string scheme, string host) { IList<Post> posts = _postRepository.GetBlogPosts(nickname); Blog blog = _blogRepository.GetBlog(nickname); string url = string.Format("{0}://{1}/{2}", scheme, host, nickname); var feed = new SyndicationFeed(blog.Title, blog.Description, new Uri(url), url, blog.LastUpdated); feed.Authors.Add(new SyndicationPerson {Name = blog.User.Name}); feed.Links.Add(SyndicationLink.CreateSelfLink(new Uri(url + "/feed/" + feedType))); var items = new List<SyndicationItem>(); foreach (Post post in posts) { var htmlurl = string.Format("{0}://{1}/{2}/{3}/{4}/{5}/{6}", scheme, host, nickname, post.Posted.Year, post.Posted.Month, post.Posted.Day, post.TitleLink); var item = new SyndicationItem(); item.Title = new TextSyndicationContent(post.Title, TextSyndicationContentKind.Html); item.Content = new TextSyndicationContent(post.BlogPost, TextSyndicationContentKind.Html); item.Links.Add(SyndicationLink.CreateAlternateLink(new Uri(htmlurl), "text/html")); var editurl = string.Format("{0}://{1}/{2}/pub/atom/{3}", scheme, host, nickname, post.Id); item.Links.Add(SyndicationLink.CreateSelfLink(new Uri(editurl))); item.Links.Add(new SyndicationLink { RelationshipType = "edit", Uri = new Uri(editurl), MediaType = "application/atom+xml;type=entry" }); item.PublishDate = post.Edited; item.Id = editurl; items.Add(item); } feed.Items = items; return feed; }
/// <summary> /// Create the feed /// </summary> /// <returns>The created feed</returns> public override SyndicationFeed ToFeed() { SyndicationFeed feed = new SyndicationFeed(Title, Title, new Uri(Uri), Id, DateTime.Parse(Updated.At)); //feed.Authors.Add(new SyndicationPerson("*****@*****.**")); feed.Categories.Add(new SyndicationCategory(Title)); feed.Description = new TextSyndicationContent(Title); List<SyndicationItem> items = new List<SyndicationItem>(); if (commentList != null && commentList.comments != null) { for (int i = 0; i < commentList.comments.Count; i++) { SyndicationItem item = new SyndicationItem( "", commentList.comments[i].text, new Uri(commentList.comments[i].Uri), commentList.comments[i].ID.ToString(), DateTime.Parse(commentList.comments[i].Created.At)); items.Add(item); } } feed.Items = items; return feed; }
/// <summary> /// Normalizes a SyndicationItem into a FeedItem. /// </summary> /// <param name="feed">The <see cref="SyndicationFeed"/> on which the item was retrieved.</param> /// <param name="item">A <see cref="SyndicationItem"/> to normalize into a <see cref="FeedItem"/>.</param> /// <returns>Returns a normalized <see cref="FeedItem"/>.</returns> public virtual FeedItem Normalize(SyndicationFeed feed, SyndicationItem item) { var alternatelink = item.Links.FirstOrDefault(l => l.RelationshipType == null || l.RelationshipType.Equals("alternate", StringComparison.OrdinalIgnoreCase)); Uri itemuri = null; Uri parsed; if (alternatelink == null && !Uri.TryCreate(item.Id, UriKind.Absolute, out parsed)) { itemuri = parsed; } else { itemuri = alternatelink.GetAbsoluteUri(); } return new FeedItem { Id = string.IsNullOrEmpty(item.Id) ? null : item.Id.Trim(), Title = item.Title == null ? null : Normalize(item.Title.Text), Content = item.Content == null ? null : Normalize(((TextSyndicationContent)item.Content).Text), Summary = item.Summary == null ? null : Normalize(item.Summary.Text), PublishDate = item.PublishDate, LastUpdatedDate = item.LastUpdatedTime == DateTimeOffset.MinValue ? item.PublishDate : item.LastUpdatedTime, Uri = itemuri }; }
public ActionResult NewsRssFeed() { var latestNews = Umbraco.TypedContentAtXPath("//ulgNewsItem").Where(x => x.IsVisible()).OrderByDescending(x => x.GetPropertyValue<DateTime>("articleDate")).Take(20); var lastUpdate = (from news in latestNews select news.UpdateDate).Max(); SyndicationFeed feed = new SyndicationFeed("Local Government Starter Kit News RSS Feed Example", "Latest News for Local Government Starter Kit site", new Uri("http://www.uLocalGov.co.uk"), "uLocalCovNews", lastUpdate); List<SyndicationItem> items = new List<SyndicationItem>(); foreach (var newsItem in latestNews) { string itemTitle = string.Format("{0}", newsItem.GetPropertyValue("title")); Uri itemURI = new Uri(newsItem.UrlWithDomain()); string itemContent = string.Format("<p>{0:dddd, MM yyyy} - {1}</p>", newsItem.GetPropertyValue<DateTime>("articleDate"), newsItem.GetPropertyValue("newsSummary")); SyndicationItem item = new SyndicationItem(itemTitle, itemContent, itemURI, newsItem.Id.ToString(), newsItem.UpdateDate); items.Add(item); } feed.Items = items; return new RssActionResult(feed); }
internal override void WriteXml(XmlWriter writer, SyndicationItem item) { writer.WriteStartElement(ItemName, ItemNamespace); writer.WriteElementString("id", item.Id); WriteXml(writer, item.Title, "title"); WriteXml(writer, item.Summary, "summary"); DateTime defDate = new DateTime(0); if (item.PublishDate != defDate) { string date = item.PublishDate.ToUniversalTime().ToString("s"); writer.WriteElementString("published", date + "Z"); } if (item.LastUpdatedTime != defDate) { string date = item.LastUpdatedTime.ToUniversalTime().ToString("s"); writer.WriteElementString("updated", date + "Z"); } WriteXml(writer, item.Content, "content"); WriteXml(writer, item.Copyright, "rights"); writer.WriteEndElement(); }
private SyndicationItem FormatLogEntry(LogEntry entry, string repo) { var markdownParser = new Markdown(true); var item = new SyndicationItem(); item.Id = entry.CommitHash; item.Title = new TextSyndicationContent(entry.Subject); item.Content = SyndicationContent.CreateHtmlContent(markdownParser.Transform(entry.Subject + "\n\n" + entry.Body)); item.LastUpdatedTime = entry.AuthorDate; item.PublishDate = entry.CommitterDate; item.Links.Add(SyndicationLink.CreateAlternateLink(new Uri(Url.Action("ViewCommit", "Browse", new { repo, @object = entry.CommitHash }), UriKind.Relative))); item.Categories.Add(new SyndicationCategory("commit")); if (entry.Parents.Count > 1) { item.Categories.Add(new SyndicationCategory("merge")); } item.Authors.Add(new SyndicationPerson(entry.AuthorEmail, entry.Author, null)); if (entry.Author != entry.Committer || entry.AuthorEmail != entry.CommitterEmail) { item.Contributors.Add(new SyndicationPerson(entry.CommitterEmail, entry.Committer, null)); } return item; }
private SyndicationItem CreateSyndicationItem(IContent content) { var changeTrackable = content as IChangeTrackable; var changed = DateTime.Now; var changedby = string.Empty; if (changeTrackable != null) { changed = changeTrackable.Saved; changedby = changeTrackable.ChangedBy; } var item = new SyndicationItem { Title = new TextSyndicationContent(content.Name), Summary = new TextSyndicationContent(FeedDescriptionProvider.ItemDescripton(content)), PublishDate = changed, }; foreach (var contentCategory in ContentCategoryLoader.GetContentCategories(content)) { item.Categories.Add(new SyndicationCategory(contentCategory)); } var mimeType = GetMimeType(content); Uri url = GetItemUrl(content); item.Content = new UrlSyndicationContent(url, mimeType); item.AddPermalink(url); item.Authors.Add(new SyndicationPerson(string.Empty, changedby, string.Empty)); return item; }
public void set_the_title() { var subject = new ItemSubject(){ Title = "first", Title2 = "second" }; var target = new SimpleValues<ItemSubject>(subject); var map1 = new FeedItem<ItemSubject>(); map1.Title(x => x.Title); var map2 = new FeedItem<ItemSubject>(); map2.Title(x => x.Title2); var item1 = new SyndicationItem(); map1.As<IFeedItem<ItemSubject>>().ConfigureItem(item1, target); item1.Title.Text.ShouldEqual(subject.Title); var item2 = new SyndicationItem(); map2.As<IFeedItem<ItemSubject>>().ConfigureItem(item2, target); item2.Title.Text.ShouldEqual(subject.Title2); }
/// <summary> /// Executes the syndication result on the given context. /// </summary> /// <param name="context">The current context.</param> public virtual void Write(IStreamResponse response) { var writer = new XmlTextWriter(response.OutputStream, Encoding.UTF8); var ui = new Client.Helpers.UIHelper(); // Write headers response.ContentType = ContentType; response.ContentEncoding = Encoding.UTF8; var feed = new SyndicationFeed() { Title = new TextSyndicationContent(Config.Site.Title), LastUpdatedTime = Posts.First().Published.Value, Description = new TextSyndicationContent(Config.Site.Description), }; feed.Links.Add(SyndicationLink.CreateAlternateLink(new Uri(App.Env.AbsoluteUrl("~/")))); var items = new List<SyndicationItem>(); foreach (var post in Posts) { var item = new SyndicationItem() { Title = SyndicationContent.CreatePlaintextContent(post.Title), PublishDate = post.Published.Value, Summary = SyndicationContent.CreateHtmlContent(post.Body) }; item.Links.Add(SyndicationLink.CreateAlternateLink(new Uri(App.Env.AbsoluteUrl("~/" + post.Type.Slug + "/" + post.Slug)))); items.Add(item); } feed.Items = items; var formatter = GetFormatter(feed); formatter.WriteTo(writer); writer.Flush(); writer.Close(); }
public SyndicationFeedFormatter CreateFeed() { // Create a new Syndication Feed. SyndicationFeed feed = new SyndicationFeed("Bug Track", "Flux rss du bug track", null); List<SyndicationItem> items = new List<SyndicationItem>(); // Create a new Syndication Item. List<DBO.Bug> list = BusinessManagement.Bug.GetLastBug(10); foreach (DBO.Bug itemBug in list) { SyndicationItem item = new SyndicationItem(itemBug.ProjectName + " : " + itemBug.Title, itemBug.CreateDate + " \n " + itemBug.Details, null); items.Add(item); } feed.Items = items; // Return ATOM or RSS based on query string // rss -> http://localhost:8731/Design_Time_Addresses/SyndicationServiceBugTrack/Feed1/ // atom -> http://localhost:8731/Design_Time_Addresses/SyndicationServiceBugTrack/Feed1/?format=atom string query = WebOperationContext.Current.IncomingRequest.UriTemplateMatch.QueryParameters["format"]; SyndicationFeedFormatter formatter = null; if (query == "atom") { formatter = new Atom10FeedFormatter(feed); } else { formatter = new Rss20FeedFormatter(feed); } return formatter; }
public Atom10FeedFormatter GetFeed(int id) { SyndicationFeed feed = new SyndicationFeed("Atom Feed", "This is a test feed", new Uri("http://SomeURI"), "FeedOneID", new DateTimeOffset(DateTime.Now)); feed.Authors.Add(new SyndicationPerson("*****@*****.**")); feed.Categories.Add(new SyndicationCategory("How To Sample Code")); feed.Description = new TextSyndicationContent("This is a sample that illistrates how to expose a feed using ATOM with WCF"); SyndicationItem item1 = new SyndicationItem( "Item One", "This is the content for item one", new Uri("http://localhost/Content/One"), "ItemOneID", DateTime.Now); SyndicationItem item2 = new SyndicationItem( "Item Two", "This is the content for item two", new Uri("http://localhost/Content/Two"), "ItemTwoID", DateTime.Now); List<SyndicationItem> items = new List<SyndicationItem>(); items.Add(item1); items.Add(item2); feed.Items = items; return new Atom10FeedFormatter(feed); }
/// <summary> /// Initializes a new instance of the FeedActionResult class /// </summary> /// <param name="blogName">Name of the blog</param> /// <param name="description">Feed description</param> /// <param name="format">Format of the feed</param> /// <param name="url">A URL Helper</param> /// <param name="posts">The posts to include in the feed</param> public FeedActionResult(string blogName, string description, FeedFormat format, UrlHelper url, IEnumerable<BlogPost> posts) { Guid blogPostId; string postRelative; SyndicationItem item; List<SyndicationItem> items = new List<SyndicationItem>(); // Specify the type of feed Format = format; // Initialize the current feed Feed = new SyndicationFeed(blogName, description, new Uri(url.RouteUrl("Default"), UriKind.Relative)); //load the posts as items foreach (BlogPost post in posts) { blogPostId = post.BlogPostId; postRelative = url.Action( "Details", "Posts", new { year = post.PostedDate.Value.Year, month = post.PostedDate.Value.Month, day = post.PostedDate.Value.Day, id = blogPostId }); item = new SyndicationItem(post.Title, post.Post, new Uri(postRelative, UriKind.Relative), post.BlogPostId.ToString(), post.PostedDate.Value); items.Add(item); } Feed.Items = items.OrderByDescending(x => x.LastUpdatedTime); }
public static SyndicationFeed ProcessFeedSource( string feedSource ) { HtmlElement rootElement = HtmlElement.Create( feedSource ); // identify the row container HtmlElement container = GetRowContainer( rootElement ); // identify the rows and pass them into a list IList<HtmlElement> elementList = GetElementList( container ); var items = new List<SyndicationItem>(); //find all the headlines foreach (HtmlElement element in elementList) { //find the first link within the div HtmlAnchorElement link = (HtmlAnchorElement)element.ChildElements.Find( "a", 0 ); string title = GetFeedItemTitle( link ); string hRef = GetFeedItemLink( link ); DateTime publishedTime = GetFeedItemPublishedTime(); string summary = GetFeedItemSummary(); DateTime lastUpdatedTime = GetFeedItemLastUpdatedTime(); var syndicationItem = new SyndicationItem( title, string.Empty, new Uri( hRef ), hRef, lastUpdatedTime ); syndicationItem.Summary = new TextSyndicationContent( summary, TextSyndicationContentKind.XHtml ); syndicationItem.PublishDate = publishedTime; items.Add( syndicationItem ); } return new SyndicationFeed( items ); }
/// <summary> /// Turn a SimpleFeed object into a SyndicationFeed object /// </summary> private SyndicationFeed GetSyndicationFeed(SimpleFeed pFeed) { var feed = new SyndicationFeed(); var items = new List<SyndicationItem>(); feed.BaseUri = new Uri(pFeed.BaseUrl); if (!string.IsNullOrWhiteSpace(pFeed.Title)) feed.Title = new TextSyndicationContent(pFeed.Title); if (!string.IsNullOrWhiteSpace(pFeed.Description)) feed.Description = new TextSyndicationContent(pFeed.Description); if (!string.IsNullOrWhiteSpace(pFeed.Language)) feed.Language = pFeed.Language; if (pFeed.Entries != null) { foreach (var entry in pFeed.Entries) { var item = new SyndicationItem(entry.Title, entry.Body, entry.TitleLinkUri); //Id, DatePublished, DateLastUpdated are required so that each new post won't make readers think that every entry is new item.Id = entry.Id; item.PublishDate = entry.DatePublished; item.LastUpdatedTime = entry.DateLastUpdated; item.BaseUri = entry.TitleLinkUri; items.Add(item); } } feed.Items = items; return feed; }
/// <summary> /// Converts This IComposableMessage Into A Geo-RSS SyndicationItem /// </summary> /// <param name="myitem">Pointer to a Syndication Item to Populate</param> internal override void ToGeoRSS(System.ServiceModel.Syndication.SyndicationItem myitem) { // myitem.Title = new TextSyndicationContent("Field Observation - " + observationType.ToString() + " (EDXL-SitRep)"); // TextSyndicationContent content = new TextSyndicationContent("Observation: " + this.observationText + "\nImmediate Needs: " + this.immediateNeeds); myitem.Title = new TextSyndicationContent("Casualty and Illness Summary By Period - " + " (EDXL-SitRep)"); TextSyndicationContent content = new TextSyndicationContent("CasualtyandIllnessSummaryByPeriod: " + "\nImmediate Needs: "); myitem.Content = content; }
public override WrapperObject ConvertToWraperObject(System.ServiceModel.Syndication.SyndicationItem item) { var obj = base.ConvertToWraperObject(item); if (item.Summary != null) { obj.SetOrAddProperty(PublishingConstants.FieldSummary, item.Summary.Text.StripHtmlTags()); } var contentText = item.ElementExtensions.Select(extension => extension.GetObject <XElement>()) .Where(e => e.Name.LocalName == "encoded" && e.Name.Namespace.ToString().Contains("content")) .Select(e => e.Value).FirstOrDefault(); obj.SetOrAddProperty(PublishingConstants.FieldContent, contentText); //vimeo feed contains custom elements for media thumbnail var mediaContent = item.ElementExtensions.Select(extension => extension.GetObject <XElement>()) .FirstOrDefault(e => e.Name.LocalName == "content"); if (mediaContent != null) { var thumbnailElement = mediaContent.Elements().FirstOrDefault(e => e.Name.LocalName == "thumbnail"); if (thumbnailElement != null) { var thumbnailUrl = thumbnailElement.Attributes().First(a => a.Name.LocalName == "url").Value; obj.SetOrAddProperty("ThumbnailUrl", thumbnailUrl); } } //youtube feed contains custom elements for media description & thumbnail var mediaGroup = item.ElementExtensions.Select(extension => extension.GetObject <XElement>()) .FirstOrDefault(e => e.Name.LocalName == "group"); if (mediaGroup != null) { var thumbnailElement = mediaGroup.Elements().FirstOrDefault(e => e.Name.LocalName == "thumbnail"); if (thumbnailElement != null) { var thumbnailUrl = thumbnailElement.Attributes().First(a => a.Name.LocalName == "url").Value; obj.SetOrAddProperty("ThumbnailUrl", thumbnailUrl); } var descriptionElement = mediaGroup.Elements().FirstOrDefault(e => e.Name.LocalName == "description"); if (descriptionElement != null) { var content = descriptionElement.Value; obj.SetOrAddProperty(PublishingConstants.FieldContent, content); } } return(obj); }
/// <summary> /// Update the Atom entry specified by the id. If none exists, return null. Return the updated Atom entry. Return null if the entry does not exist. /// This method must be idempotent. /// </summary> /// <param name="collection">collection name</param> /// <param name="id">id of the entry</param> /// <param name="entry">Entry to put</param> /// <returns></returns> protected override SyndicationItem PutEntry(string collection, string id, System.ServiceModel.Syndication.SyndicationItem entry) { var headers = WebOperationContext.Current.IncomingRequest.Headers; var originalEntry = this.unitOfWork.Entries.GetById(id); if (originalEntry == null) { return(null); } var newEntry = entry.ConvertToModelEntry(); try { originalEntry.Title = newEntry.Title; originalEntry.Content = newEntry.Content; originalEntry.StrippedDownTitle = BlogEntry.StripeDownTitle(newEntry.Title); originalEntry.LastUpdateDate = newEntry.LastUpdateDate; originalEntry.Categories.Clear(); foreach (var sCat in entry.Categories) { // search if the category already exists. var category = unitOfWork.Categories.GetById(BlogEntry.StripeDownTitle(sCat.Label)); if (category == null) { // create a new category category = new Category() { Name = sCat.Label, Value = BlogEntry.StripeDownTitle(sCat.Label) }; } originalEntry.Categories.Add(category); } this.unitOfWork.Commit(); return(originalEntry.ConvertToSyndicationItem(this.webOperationContext.BaseUri)); } catch (Exception ex) { // TODO: add logging return(null); } }
protected static bool TryParseAttribute(string name, string ns, string value, SyndicationItem item, string version) { return(default(bool)); }
protected static bool TryParseElement(System.Xml.XmlReader reader, SyndicationItem item, string version) { return(default(bool)); }
protected static void WriteElementExtensions(System.Xml.XmlWriter writer, SyndicationItem item, string version) { }
internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, SyndicationItem item) { if (item == null) { throw new ArgumentNullException(nameof(item)); } CloseBuffer(buffer, writer); item.LoadElementExtensions(buffer); }
protected SyndicationItemFormatter() { _item = null; }
protected static SyndicationCategory CreateCategory(SyndicationItem item) { return(SyndicationFeedFormatter.CreateCategory(item)); }
protected internal virtual new void SetItem(SyndicationItem item) { }
protected SyndicationItemFormatter(SyndicationItem itemToWrite) { }
protected virtual new void WriteItem(System.Xml.XmlWriter writer, SyndicationItem item, Uri feedBaseUri) { Contract.Requires(item != null); Contract.Requires(writer != null); }
internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, SyndicationItem item) { Debug.Assert(item != null); CloseBuffer(buffer, writer); item.LoadElementExtensions(buffer); }
public Rss20ItemFormatter(SyndicationItem itemToWrite) : this(itemToWrite, true) { }
protected static bool TryParseElement(XmlReader reader, SyndicationItem item, string version) { return(SyndicationFeedFormatter.TryParseElement(reader, item, version)); }
public Rss20ItemFormatter(SyndicationItem itemToWrite, bool serializeExtensionsAsAtom) : base(itemToWrite) { ext_atom_serialization = serializeExtensionsAsAtom; }
protected static void LoadElementExtensions(System.Xml.XmlReader reader, SyndicationItem item, int maxExtensionSize) { }
public Atom10ItemFormatter(SyndicationItem feedToWrite) : base(feedToWrite) { }
protected static SyndicationPerson CreatePerson(SyndicationItem item) { return(default(SyndicationPerson)); }
internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, SyndicationItem item) { SyndicationFeedFormatter.LoadElementExtensions(buffer, writer, item); }
protected static SyndicationLink CreateLink(SyndicationItem item) { return(default(SyndicationLink)); }
protected static async Task WriteElementExtensionsAsync(XmlWriter writer, SyndicationItem item, string version) { await SyndicationFeedFormatter.WriteElementExtensionsAsync(writer, item, version); }
protected static SyndicationCategory CreateCategory(SyndicationItem item) { return(default(SyndicationCategory)); }
protected static bool TryParseContent(XmlReader reader, SyndicationItem item, string contentType, string version, out SyndicationContent content) { return(SyndicationFeedFormatter.TryParseContent(reader, item, contentType, version, out content)); }
protected static bool TryParseAttribute(string name, string ns, string value, SyndicationItem item, string version) { return(SyndicationFeedFormatter.TryParseAttribute(name, ns, value, item, version)); }
internal static protected bool TryParseContent(XmlReader reader, SyndicationItem item, string contentType, string version, out SyndicationContent content) { return(item.TryParseContent(reader, contentType, version, out content)); }
internal static protected Task WriteAttributeExtensionsAsync(XmlWriter writer, SyndicationItem item, string version) { if (item == null) { throw new ArgumentNullException(nameof(item)); } return(item.WriteAttributeExtensionsAsync(writer, version)); }
internal static protected bool TryParseAttribute(string name, string ns, string value, SyndicationItem item, string version) { if (item == null) { throw new ArgumentNullException(nameof(item)); } if (FeedUtils.IsXmlns(name, ns)) { return(true); } return(item.TryParseAttribute(name, ns, value, version)); }
protected static void LoadElementExtensions(XmlReader reader, SyndicationItem item, int maxExtensionSize) { SyndicationFeedFormatter.LoadElementExtensions(reader, item, maxExtensionSize); }