public static SyndicationFeed GetSyndycationHelper() { //Uri uri = new Uri("http://localhost/WebApplication1/"); SyndicationFeed syndicationFeed = new SyndicationFeed( "AAA ラジオ", "", //uri, null, "", DateTime.Now); List <SyndicationItem> items = new List <SyndicationItem>(); List <Blog> oBlogList = Blog.GetMyBlogList(); foreach (Blog oBlog in oBlogList) { SyndicationItem oItem = new SyndicationItem( oBlog.Title, SyndicationContent.CreateHtmlContent(oBlog.Description), new Uri(oBlog.Url), oBlog.BlogId.ToString(), oBlog.LastUpdated); SyndicationLink syndicationLink = SyndicationLink.CreateMediaEnclosureLink(new Uri(oBlog.Url), "audio/mpeg", 0); oItem.Links.Add(syndicationLink); items.Add(oItem); } syndicationFeed.Items = items; return(syndicationFeed); }
public ActionResult RssFeed(long id) { NewsBusiness newsBusiness = new NewsBusiness(); List <Common.SearchNewByGroupID_Result> model = new List <Common.SearchNewByGroupID_Result>(); int totalRecord = 0; model = _newsBusiness.ListByNewsIdNewsGroup(id, ref totalRecord, 1, 10000); var items = new List <SyndicationItem>(); foreach (SearchNewByGroupID_Result re in model) { var item = new SyndicationItem() { Id = re.Id.ToString(), Title = SyndicationContent.CreatePlaintextContent(re.Title), Content = SyndicationContent.CreateHtmlContent(re.Descriptions), PublishDate = re.CreateDate }; string url = Util.ReturnLinkFull(re.FriendlyUrl); item.Links.Add(SyndicationLink.CreateAlternateLink(new Uri(url)));//Nothing alternate about it. It is the MAIN link for the item. items.Add(item); } return(new RssFeed(title: "Greatness", items: items, contentType: "application/rss+xml", description: String.Format("Sooper Dooper {0}", Guid.NewGuid()))); }
private static SyndicationContent GetItemContent(Node node, string browseUriString) { var sb = new StringBuilder(); sb.Append("<html><body>"); var headerProp = (from pt in node.PropertyTypes where pt.Name == "Subtitle" && (pt.DataType == DataType.String || pt.DataType == DataType.Text) select pt).FirstOrDefault(); if (headerProp != null) { sb.Append(node.GetProperty <string>(headerProp)).Append("<br />"); } WriteTypeInfo(node, sb); var folder = node as IFolder; var trashBag = node as TrashBag; //skip trash bags and non-folders if (trashBag == null && folder != null) { sb.Append("<br /><a href=\"").Append(browseUriString).Append("?").Append(PortalContext.ActionParamName).Append("=RSS").Append("\">view children</a>"); } sb.Append("</body></html>"); return(SyndicationContent.CreateHtmlContent(sb.ToString())); }
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); }
/// <summary> /// Creates the fake item with the given id and a couple of example links and author. /// Every item with an even ID gets a feedsync extension /// </summary> /// <param name="id">The id.</param> public static SyndicationItem CreateExampleItemWithId(int id) { var item = new SynchronizableArticle(String.Format("A title with ID {0}", id), String.Empty, null, id.ToString(), DateTime.Now.Subtract(TimeSpan.FromDays(Random.Next(30)))); if (id % 2 == 0) { item.FeedSync = new FeedSync { Deleted = false, Id = id.ToString(), NoConflicts = true, Updates = 6 } } ; item.Authors.Add(GetRandomAuthor()); if (id % 3 == 0) { item.Authors.Add(GetRandomAuthor()); } item.Links.Add(GetLink(1)); item.Links.Add(GetLink(2)); item.Content = SyndicationContent.CreateHtmlContent( "<html><head></head><body><p>Some test text & escaping test</p><body></html>"); return(item); }
public void ProcessRequest(HttpContext context) { context.Response.ContentEncoding = Encoding.UTF8; var portalContext = PortalContext.Current; var serviceContext = PortalCrmConfigurationManager.CreateServiceContext(); serviceContext.MergeOption = MergeOption.NoTracking; var newsRootPage = serviceContext.GetPageBySiteMarkerName(portalContext.Website, "News"); if (newsRootPage == null) { context.Response.StatusCode = 404; context.Response.ContentType = "text/plain"; context.Response.Write("Not Found"); return; } var feed = new SyndicationFeed(GetSyndicationItems(serviceContext, newsRootPage.ToEntityReference())) { Title = SyndicationContent.CreatePlaintextContent(newsRootPage.GetAttributeValue <string>("adx_title") ?? newsRootPage.GetAttributeValue <string>("adx_name")), Description = SyndicationContent.CreateHtmlContent(newsRootPage.GetAttributeValue <string>("adx_summary") ?? string.Empty), BaseUri = new Uri(context.Request.Url.GetLeftPart(UriPartial.Authority)) }; context.Response.ContentType = "application/atom+xml"; using (var writer = new XmlTextWriter(context.Response.OutputStream, Encoding.UTF8)) { feed.SaveAsAtom10(writer); } }
private List <SyndicationItem> GetItems(IEnumerable <UserMessage> messages) { var items = new List <SyndicationItem>(); foreach (var message in messages) { var content = message.Text; if (message.ParentMessageID == null) { content += "<br/>" + H.Anchor( RootUrl + Url.Action <RssController>(c => c.Messages(null, message.UserMessageID)), "rss"); } var uri = RootUrl + Url.Action <MessageController>(c => c.Details(message.ParentMessageID.HasValue ? message.ParentMessageID.Value : message.UserMessageID, 1)); var item = new SyndicationItem(GetTitle(message), SyndicationContent.CreateHtmlContent(content), new Uri(uri), message.UserMessageID.ToString(), message.CreateDate); if (message.ParentMessageID == null) { item.ElementExtensions.Add(new XElement("comments", RootUrl + Url.Action <RssController>(c => c.Messages(null, message.UserMessageID)))); } items.Add(item); } return(items); }
/// <summary> /// Builds the syndication item from the <paramref name="galleryObject" /> and having the properties specified /// in <paramref name="options" />. /// </summary> /// <param name="galleryObject">The gallery object.</param> /// <param name="options">The options that direct the creation of HTML and URLs for a media object.</param> /// <returns>An instance of <see cref="SyndicationItem" />.</returns> private static SyndicationItem BuildSyndicationItem(IGalleryObject galleryObject, MediaObjectHtmlBuilderOptions options) { options.GalleryObject = galleryObject; options.DisplayType = (galleryObject.GalleryObjectType == GalleryObjectType.External ? DisplayObjectType.External : DisplayObjectType.Optimized); var moBuilder = new MediaObjectHtmlBuilder(options); var pageUrl = moBuilder.GetPageUrl(); var content = GetGalleryObjectContent(galleryObject, pageUrl, moBuilder); var item = new SyndicationItem( RssEncode(HtmlValidator.RemoveHtml(galleryObject.Title, false)), SyndicationContent.CreateHtmlContent(content), new Uri(pageUrl), galleryObject.Id.ToString(CultureInfo.InvariantCulture), galleryObject.DateLastModified); item.PublishDate = galleryObject.DateAdded; item.Authors.Add(new SyndicationPerson() { Name = galleryObject.CreatedByUserName }); item.Categories.Add(new SyndicationCategory(galleryObject.GalleryObjectType.ToString())); return(item); }
public SyndicationFeed BuildFeed(IEnumerable <JobResponse> jobs, Uri requestUri, string referrer, bool formatIsHtml) { var feed = new SyndicationFeed { Title = new TextSyndicationContent(_mandatorResponse.Name) }; var items = new List <SyndicationItem>(); foreach (var job in jobs) { var url = _urlBuilder.GetAbsolutJobUrl(job.Id, requestUri, referrer); var item = new SyndicationItem { Title = SyndicationContent.CreatePlaintextContent(job.Title), Content = SyndicationContent.CreateHtmlContent(BuildContent(job, requestUri, referrer, formatIsHtml)) }; item.Authors.Add(new SyndicationPerson(job.UserEmail, job.UserFullName, null)); item.Id = url; item.AddPermalink(new Uri(url)); item.LastUpdatedTime = job.OnlineDateCorrected; items.Add(item); } feed.Items = items; return(feed); }
public ActionResult Rss() { List <SyndicationItem> items1 = new List <SyndicationItem>(); List <Models.MyBook> items2 = ns.GetNewBooks(); for (int i = 0; i < 9; i++) { string imgURL = "<img src=\""; imgURL += "http://localhost/Image/Sach/" + items2[i].AnhBia + "\"style=\"width:180px; height:230px; margin-top:9px;\"/><br>"; SyndicationItem item = new SyndicationItem() { Id = items2[i].MaSach.ToString(), Title = SyndicationContent.CreatePlaintextContent(String.Format("{0}", items2[i].TenSach)), Content = SyndicationContent.CreateHtmlContent(String.Format("{0} Giá bán: {1} <br>", imgURL, items2[i].GiaBan.ToString())), }; string mylink = "http://localhost/Product/Product/" + ns.Encode("id=" + items2[i].MaSach.ToString()); item.Links.Add(SyndicationLink.CreateAlternateLink(new Uri(mylink)));//link to item items1.Add(item); } var feed = new SyndicationFeed("Usagi's Store", "Cửa hàng sách Usagi", new Uri("http://localhost"), items1) { Copyright = new TextSyndicationContent("© 2015 - Usagi's Store"), Language = "vi-VN" }; Response.ContentType = "text/xml"; return(new FeedResult(new Rss20FeedFormatter(feed))); }
public SyndicationFeedFormatter GetProcesses(string format) { IEnumerable <Process> processes = new List <Process>(Process.GetProcesses()); //SyndicationFeed also has convenience constructors //that take in common elements like Title and Content. SyndicationFeed f = new SyndicationFeed(); f.LastUpdatedTime = DateTimeOffset.Now; f.Title = SyndicationContent.CreatePlaintextContent("Currently running processes"); f.Links.Add(SyndicationLink.CreateSelfLink(OperationContext.Current.IncomingMessageHeaders.To)); f.Items = from p in processes select new SyndicationItem() { LastUpdatedTime = DateTimeOffset.Now, Title = SyndicationContent.CreatePlaintextContent(p.ProcessName), Summary = SyndicationContent.CreateHtmlContent(String.Format("<b>{0}</b>", p.MainWindowTitle)), Content = SyndicationContent.CreateXmlContent(new ProcessData(p)) }; // Choose a formatter according to the query string passed. if (format == "rss") { return(new Rss20FeedFormatter(f)); } else { return(new Atom10FeedFormatter(f)); } }
public virtual ActionResult CommentFeed() { var comments = Repository.Find(new GetCommentsQuery(), 0, 20); var baseUri = Request.GetOriginalUrl(); var items = from e in comments let itemUri = new Uri(baseUri, Url.Action("Page", "Wiki", new { page = e.Entry.Name }) + "#comment-" + e.Id) select new SyndicationItem { Id = itemUri.ToString(), Title = SyndicationContent.CreatePlaintextContent(e.AuthorName + " on " + e.Entry.Title), Summary = SyndicationContent.CreateHtmlContent(Renderer.RenderUntrusted(e.Body, Formats.Markdown, CreateHelper())), Content = SyndicationContent.CreateHtmlContent(Renderer.RenderUntrusted(e.Body, Formats.Markdown, CreateHelper())), LastUpdatedTime = e.Posted, PublishDate = e.Posted, Links = { new SyndicationLink(itemUri) }, Authors = { new SyndicationPerson { Name = e.AuthorName, Uri = e.AuthorUrl } }, }; return(FeedResult(items.ToList())); }
public static async Task <SyndicationFeed> BuildSyndication(this IBlogService service, string baseAddress) { ClientUrlGenerator generator = new ClientUrlGenerator { BaseAddress = baseAddress }; BlogOptions blogOptions = await service.GetOptions(); SyndicationFeed feed = new SyndicationFeed(blogOptions.Name, blogOptions.Description, new Uri(baseAddress)); SyndicationPerson author = new SyndicationPerson("", blogOptions.Onwer, baseAddress); feed.Authors.Add(author); Dictionary <string, SyndicationCategory> categoryMap = new Dictionary <string, SyndicationCategory>(); { /*var cates = await BlogService.CategoryService.GetCategories(await BlogService.CategoryService.All()); * foreach (var p in cates) * { * var cate = new SyndicationCategory(p.Name); * categoryMap.Add(p.Id, cate); * feed.Categories.Add(cate); * }*/ } { var posts = await service.PostService.GetPosts(await service.PostService.All()); List <SyndicationItem> items = new List <SyndicationItem>(); foreach (var p in posts) { if (p is null) { continue; } var s = new SyndicationItem(p.Title, SyndicationContent.CreateHtmlContent(Markdown.ToHtml(p.Content.Raw, Pipeline)), new Uri(generator.Post(p.Id)), p.Id, p.ModificationTime); s.Authors.Add(author); string summary; if (await service.PostService.Protector.IsProtected(p.Content)) { summary = "Protected Post"; } else { summary = Markdown.ToPlainText(p.Content.Raw, Pipeline); } s.Summary = SyndicationContent.CreatePlaintextContent(summary.Length <= 100 ? summary : summary.Substring(0, 100)); s.Categories.Add(new SyndicationCategory(p.Category.ToString())); /*if (categoryMap.TryGetValue(p.CategoryId, out var cate)) * s.Categories.Add(cate);*/ s.PublishDate = p.CreationTime; items.Add(s); } feed.Items = items.AsEnumerable(); } return(feed); }
private async Task <IEnumerable <SyndicationItem> > GetItemsAsync(GetSyndicationFeedQuery request, CancellationToken cancellationToken) { var posts = await _uow.Posts.GetPublishedAsync(25, cancellationToken); var items = new List <SyndicationItem>(); foreach (var post in posts.AsQueryable().Select(p => _postUrlHelper.ReplaceUrlFormatWithBaseUrl(p))) { var absoluteUrl = new Uri(request.BaseUri, $"{request.PostBasePath}/{post.Slug}"); var content = SyndicationContent.CreateHtmlContent(Markdig.Markdown.ToHtml(post.Content)); var item = new SyndicationItem(post.Title, content, absoluteUrl, absoluteUrl.ToString(), post.Modified) { PublishDate = post.Published.Value }; if (!string.IsNullOrWhiteSpace(post.Description)) { item.Summary = new TextSyndicationContent(post.Description); } if (!string.IsNullOrWhiteSpace(post.Categories)) { foreach (var category in post.Categories.Split(',')) { item.Categories.Add(new SyndicationCategory(category)); } } item.Authors.Add(new SyndicationPerson("", post.Author.DisplayName, request.BaseUri.ToString())); items.Add(item); } return(items); }
protected override void Run() { base.Run(); if (IsFirstRun) { if (database == null) { waitToken.WaitHandle.WaitOne(10000); //WaitFor 10 seconds } if (database == null) { Console.WriteLine("No DiffDatabase connected,Service Terminate"); } } DateTime updateTime = DateTime.Now; //Rebuild RssData try { var iter = (from p in database.Table <DiffData>() orderby p.OutputTime descending select p).Take(50); List <SyndicationItem> item = new List <SyndicationItem>(); bool isFirst = true; foreach (var val in iter) { if (isFirst) { isFirst = false; updateTime = val.OutputTime; } var destTime = TimeZoneInfo.ConvertTime(val.OutputTime, _timeZone); SyndicationItem sitem = new SyndicationItem() { Title = new TextSyndicationContent(val.Summary), //Summary = SyndicationContent.CreatePlaintextContent(val.Summary), Content = SyndicationContent.CreateHtmlContent(val.Content), PublishDate = destTime, LastUpdatedTime = destTime, Links = { new SyndicationLink(new Uri(val.RelatedAddress)) }, Id = GetStringHash(val.Summary) }; item.Add(sitem); } feed.Items = item; feed.LastUpdatedTime = updateTime; //Console.WriteLine("RssData Updated"); } catch (Exception e) { Console.WriteLine(e); string outputstr = e.ToString() + "\n"; string anotherPart = "模块RssTerminal发生了异常!\n" + e.StackTrace + "\n" + e.InnerException; File.AppendAllText("ErrorDump.txt", outputstr + anotherPart); } }
public void CreateHtmlContent_Invoke_ReturnsExpected(string content) { TextSyndicationContent syndicationContent = SyndicationContent.CreateHtmlContent(content); Assert.Empty(syndicationContent.AttributeExtensions); Assert.Equal(content, syndicationContent.Text); Assert.Equal("html", syndicationContent.Type); }
internal static SyndicationItem CreateSyndicationItem(IEntry entry, string uriString) { return(new SyndicationItem(entry.SeoTitle, SyndicationContent. CreateHtmlContent(entry.EntryBody), new Uri(uriString), string.Format("item-id-{0}", entry.Id), entry.CreatedAt)); }
private static SyndicationContent GetSyndicationContent(string content, string contentType) { if (content.IsNullOrEmpty() || contentType.ToLowerInvariant() == PublicationContentTypes.Text) { return(SyndicationContent.CreatePlaintextContent(content ?? string.Empty)); } return(SyndicationContent.CreateHtmlContent(content)); }
private SyndicationItem TransformPost(PostEntry entry) { entry = RenderEntry(entry); SyndicationItem item = new SyndicationItem(); item.Id = entry.Name; item.Title = SyndicationContent.CreatePlaintextContent(entry.Title); item.Content = SyndicationContent.CreateHtmlContent(Transformer.Transform(entry.Content)); item.AddPermalink(new Uri("http://otakustay.com/" + entry.Name + "/")); item.PublishDate = new DateTimeOffset(entry.PostDate); item.LastUpdatedTime = new DateTimeOffset(entry.UpdateDate); item.Authors.Add(Author.Clone()); return(item); }
public virtual ActionResult Feed() { var settings = Settings.GetSettings <FunnelWebSettings>(); var entries = Repository.Find(new GetFullEntriesQuery(entryStatus: EntryStatus.PublicBlog), 0, 20); var baseUri = Request.GetOriginalUrl(); var items = from e in entries let itemUri = new Uri(baseUri, Url.Action("Page", "Wiki", new { page = e.Name })) let viaFeedUri = new Uri(baseUri, "/via-feed" + Url.Action("Page", "Wiki", new { page = e.Name })) orderby e.Published descending let content = SyndicationContent.CreateHtmlContent(BuildFeedItemBody(itemUri, viaFeedUri, e)) select new { Item = new SyndicationItem { Id = itemUri.ToString(), Title = SyndicationContent.CreatePlaintextContent(e.Title), Summary = content, Content = content, LastUpdatedTime = TimeZoneInfo.ConvertTimeFromUtc(e.Revised, TimeZoneInfo.Local), PublishDate = e.Published, Links = { new SyndicationLink(itemUri) }, Authors = { new SyndicationPerson { Name = settings.Author } }, }, Keywords = e.TagsCommaSeparated.Split(',') }; return(FeedResult(items.Select(i => { var item = i.Item; foreach (var k in i.Keywords) { item.Categories.Add(new SyndicationCategory(k.Trim())); } return item; }).ToList())); }
private static List<SyndicationItem> MapToSyndicationItem(IEnumerable<FeedItemViewModel> rssItems) { var results = new List<SyndicationItem>(); foreach (var item in rssItems) { var uri = new Uri(item.Url); var feedItem = new SyndicationItem(item.Title.CorrectRtl(), SyndicationContent.CreateHtmlContent(item.Content.CorrectRtlBody()), uri, item.Url.SHA1(), item.LastUpdatedTime ) { PublishDate = item.PublishDate }; feedItem.Authors.Add(new SyndicationPerson(item.AuthorName, item.AuthorName, uri.Host)); results.Add(feedItem); } return results; }
public SyndicationFeed CreateFeed(IPortalContext portal, HttpContext context, string selfRouteName, int maximumItems) { if (portal == null) { throw new ArgumentNullException("portal"); } if (context == null) { throw new ArgumentNullException("context"); } var blog = _dataAdapter.Select(); if (blog == null) { throw new InvalidOperationException("Blog not found."); } var posts = _dataAdapter.SelectPosts(0, maximumItems).ToArray(); var feedLastUpdatedTime = posts.Any() ? new DateTimeOffset(posts.First().PublishDate) : DateTimeOffset.UtcNow; var blogHtmlUri = new Uri(context.Request.Url, blog.ApplicationPath.AbsolutePath); var feed = new SyndicationFeed(posts.Select(p => GetFeedItem(p, context))) { Id = "uuid:{0};{1}".FormatWith(blog.Id, feedLastUpdatedTime.Ticks), Title = SyndicationContent.CreatePlaintextContent(blog.Title), Description = SyndicationContent.CreateHtmlContent(blog.Summary.ToString()), LastUpdatedTime = feedLastUpdatedTime, BaseUri = new Uri(context.Request.Url, "/") }; var selfPath = RouteTable.Routes.GetVirtualPath(context.Request.RequestContext, selfRouteName, new RouteValueDictionary { { "__portalScopeId__", portal.Website.Id }, { "id", blog.Id } }); if (selfPath != null) { feed.Links.Add(SyndicationLink.CreateSelfLink(new Uri(context.Request.Url, ApplicationPath.FromPartialPath(selfPath.VirtualPath).AbsolutePath), "application/atom+xml")); } feed.Links.Add(SyndicationLink.CreateAlternateLink(blogHtmlUri, "text/html")); return(feed); }
/// <summary> /// Build the feed using the IPublishable items. /// </summary> /// <param name="feedAuthor">The author of the feed.</param> /// <param name="feedTitle">The title of the feed</param> /// <param name="feedDescription">The description of the feed.</param> /// <param name="feedUrl">The url of the feed</param> /// <param name="posts">The feed entries.</param> public static SyndicationFeed Build(string feedAuthor, string feedTitle, string feedDescription, string feedUrl, IList <IPublishable> posts) { Uri feedUri = new Uri(feedUrl); SyndicationFeed feed = new SyndicationFeed(feedTitle, feedDescription, feedUri, feedTitle, DateTime.Now); feed.Authors.Add(new SyndicationPerson(string.Empty, feedAuthor, string.Empty)); IList <SyndicationItem> items = new List <SyndicationItem>(); foreach (var post in posts) { SyndicationItem item = new SyndicationItem(post.Title, SyndicationContent.CreateHtmlContent(post.Description), null, post.GuidId, post.UpdateDate); item.Authors.Add(new SyndicationPerson(string.Empty, post.Author, string.Empty)); items.Add(item); } feed.Items = items; return(feed); }
//public ActionResult TestRssFeed() //{ // var items = new List<SyndicationItem>(); // for (int i = 0; i < 20; i++) // { // var item = new SyndicationItem() // { // Id = Guid.NewGuid().ToString(), // Title = SyndicationContent.CreatePlaintextContent(String.Format("My Title {0}", Guid.NewGuid())), // Content = SyndicationContent.CreateHtmlContent("Content The stuff."), // PublishDate = DateTime.Now // }; // item.Links.Add(SyndicationLink.CreateAlternateLink(new Uri("http://www.google.com")));//Nothing alternate about it. It is the MAIN link for the item. // items.Add(item); // } // return new RssFeed(title: "Test rss", // items: items, // contentType: "application/rss+xml", // description: String.Format("rss de test {0}", Guid.NewGuid())); //} public ActionResult RssFeed() { var fundInvestments = InvestmentStream.GetNewFundInvestmentList(); var news = new List <SyndicationItem>(); foreach (var fundInvestment in fundInvestments) { foreach (var investment in fundInvestment.Investments) { SyndicationItem newInvestment = new SyndicationItem() { Title = SyndicationContent.CreatePlaintextContent(string.Format("{0} {1} {2}", fundInvestment.Fund.Name, Constants.INVEST_IN, investment.Startup.Name)), Content = SyndicationContent.CreateHtmlContent(investment.Description), PublishDate = DateTime.Parse(investment.DateActivityFeed), }; newInvestment.Links.Add(SyndicationLink.CreateAlternateLink(new Uri(investment.Startup.Url))); news.Add(newInvestment); } } var fundIncubations = IncubationStream.GetNewFundIncubationList(); foreach (var fundIncubation in fundIncubations) { foreach (var incubation in fundIncubation.Incubations) { SyndicationItem newInvestment = new SyndicationItem() { Title = SyndicationContent.CreatePlaintextContent(string.Format("{0} {1} {2}", fundIncubation.Fund.Name, Constants.INCUBATE, incubation.Startup.Name)), PublishDate = DateTime.Parse(incubation.DateActivityFeed), }; newInvestment.Links.Add(SyndicationLink.CreateAlternateLink(new Uri(incubation.Startup.Url))); news.Add(newInvestment); } } ExecutionUpdater.UpdateRss(); Log.Info("RssFeed", "refresh new feeds"); return(new RssFeed(title: "Angel list feed", items: news, contentType: "application/rss+xml", description: String.Format("Thibaut Cantet Angel list {0}", Guid.NewGuid()))); }
private static SyndicationItem GetSyndicationItem(OrganizationServiceContext serviceContext, Entity newsItemPage) { var displayDate = newsItemPage.GetAttributeValue <DateTime?>("adx_displaydate"); var item = new SyndicationItem( newsItemPage.GetAttributeValue <string>("adx_title") ?? newsItemPage.GetAttributeValue <string>("adx_name"), SyndicationContent.CreateHtmlContent(newsItemPage.GetAttributeValue <string>("adx_copy") ?? string.Empty), new Uri(new UrlBuilder(serviceContext.GetUrl(newsItemPage))), "uuid:{0}".FormatWith(newsItemPage.Id), displayDate.GetValueOrDefault(newsItemPage.GetAttributeValue <DateTime?>("modifiedon").GetValueOrDefault(DateTime.UtcNow))); if (displayDate != null) { item.PublishDate = displayDate.Value; } return(item); }
public async Task <ActionResult> GetFeed() { SyndicationFeed feed = new SyndicationFeed(BlogSettings.Name, BlogSettings.Description, new Uri(BaseAddress)); SyndicationPerson author = new SyndicationPerson("", BlogSettings.Onwer, BaseAddress); feed.Authors.Add(author); Dictionary <string, SyndicationCategory> categoryMap = new Dictionary <string, SyndicationCategory>(); { var cates = await BlogService.CategoryService.GetCategories(await BlogService.CategoryService.All()); foreach (var p in cates) { var cate = new SyndicationCategory(p.Name); categoryMap.Add(p.Id, cate); feed.Categories.Add(cate); } } { var posts = await BlogService.PostService.GetPosts(await BlogService.PostService.All()); List <SyndicationItem> items = new List <SyndicationItem>(); foreach (var p in posts) { var s = new SyndicationItem(p.Title, SyndicationContent.CreateHtmlContent(Markdown.ToHtml(p.Content.Raw, Pipeline)), new Uri($"{BaseAddress}/posts/{p.Id}"), p.Id, p.ModificationTime); s.Authors.Add(author); string summary = Markdown.ToPlainText(p.Content.Raw, Pipeline); s.Summary = SyndicationContent.CreatePlaintextContent(summary.Length <= 100 ? summary : summary.Substring(0, 100)); if (categoryMap.TryGetValue(p.CategoryId, out var cate)) { s.Categories.Add(cate); } s.PublishDate = p.CreationTime; items.Add(s); } feed.Items = items.AsEnumerable(); } StringBuilder sb = new StringBuilder(); using (var writer = XmlWriter.Create(sb)) feed.GetAtom10Formatter().WriteTo(writer); return(Content(sb.ToString(), "text/xml")); }
private static SyndicationContent GetSyndicationContent(IPublication publication) { if (string.IsNullOrEmpty(publication.Content)) { return(SyndicationContent.CreatePlaintextContent(string.Empty)); } switch (publication.ContentType) { case PublicationContentTypes.Text: return(SyndicationContent.CreatePlaintextContent(publication.Content)); case PublicationContentTypes.HTML: return(SyndicationContent.CreateHtmlContent(publication.Content)); default: Throw.NotSupported(string.Format("{0} is not a supported content type.", publication.ContentType)); return(null); } }
public async Task <IActionResult> RssAsync() { var objGeneralSettings = await _GeneralSettingsService.GetGeneralSettingsAsync(); var feed = new SyndicationFeed(objGeneralSettings.ApplicationName, objGeneralSettings.ApplicationName, new Uri(GetBaseUrl()), "RSSUrl", DateTime.Now); feed.Copyright = new TextSyndicationContent($"{DateTime.Now.Year} {objGeneralSettings.ApplicationName}"); var items = new List <SyndicationItem>(); var postings = _BlazorBlogsContext.Blogs.OrderByDescending(x => x.BlogDate); foreach (var item in postings) { string BlogURL = $"{GetBaseUrl()}/ViewBlogPost/{item.BlogId}"; var postUrl = Url.Action("Article", "Blog", new { id = BlogURL }, HttpContext.Request.Scheme); var title = item.BlogTitle; var description = SyndicationContent.CreateHtmlContent(item.BlogSummary.Replace(" ", " ")); items.Add(new SyndicationItem(title, description, new Uri(BlogURL), item.BlogId.ToString(), item.BlogDate)); } feed.Items = items; var settings = new XmlWriterSettings { Encoding = Encoding.UTF8, NewLineHandling = NewLineHandling.Entitize, NewLineOnAttributes = true, Indent = true }; using (var stream = new MemoryStream()) { using (var xmlWriter = XmlWriter.Create(stream, settings)) { var rssFormatter = new Rss20FeedFormatter(feed, false); rssFormatter.WriteTo(xmlWriter); xmlWriter.Flush(); } return(File(stream.ToArray(), "application/rss+xml; charset=utf-8")); } }
private async Task <SyndicationItem> GetItem(FeedIndex index) { string text = ""; if (config.EnableContent) { string filepath = ConfigReader.GetFileContentURL( config.ContentFileRoot, index.Name ); HttpResponseMessage resp = await httpClient.GetAsync(filepath); if (resp.IsSuccessStatusCode) { text = await resp.Content.ReadAsStringAsync(); } } string blogpath = config.BlogUrl; string link = string.Format("{0}/{1}", blogpath, index.Name); var pubDate = DateTime.Parse(index.Date).ToUniversalTime(); SyndicationItem item = new SyndicationItem( index.Title, text, new Uri(link), link, pubDate ); if (config.EnableContent) { string substr = text.Length > MAX_CONTENT_LENGTH ? text.Substring(0, MAX_CONTENT_LENGTH) : text; item.Content = SyndicationContent.CreateHtmlContent(substr); } item.PublishDate = pubDate; return(item); }
public SyndicationFeed BuildFeed(string websiteUrl, Func <CmsPage, string> generateEntryUrl) { string rssFeedTitle = settingData.Get(Constant.Settings.SiteLogo).Value; string rssFeedDescr = settingData.Get(Constant.Settings.SiteSubLogo).Value; IEnumerable <CmsPage> entries = pageData.LoadLast(10); List <SyndicationItem> items = entries.Select(entry => new SyndicationItem(entry.SeoTitle, SyndicationContent. CreateHtmlContent(entry.PageContent), new Uri(generateEntryUrl(entry)), string.Format("item-id-{0}", entry.Id), entry.CreatedAt)).ToList(); return(new SyndicationFeed(rssFeedTitle, rssFeedDescr, new Uri(websiteUrl), "syndicationID", DateTime.Now, items)); }