private bool TestFileLink(SyndicationLink link)
{
return(File.Exists(link.Uri.AbsolutePath));
}
/// <summary>
/// Gets the feed containing meta data about the feed and the feed entries.
/// </summary>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> signifying if the request is cancelled.</param>
/// <returns>A <see cref="SyndicationFeed"/>.</returns>
public async Task <SyndicationFeed> GetFeed(CancellationToken cancellationToken)
{
SyndicationFeed feed = new SyndicationFeed()
{
// id (Required) - The feed universally unique identifier.
Id = FeedId,
// title (Required) - Contains a human readable title for the feed. Often the same as the title of the
// associated website. This value should not be blank.
Title = SyndicationContent.CreatePlaintextContent("ASP.NET MVC Boilerplate"),
// items (Required) - The items to add to the feed.
Items = await this.GetItems(cancellationToken),
// subtitle (Recommended) - Contains a human-readable description or subtitle for the feed.
Description = SyndicationContent.CreatePlaintextContent(
"This is the ASP.NET MVC Boilerplate feed description."),
// updated (Optional) - Indicates the last time the feed was modified in a significant way.
LastUpdatedTime = DateTimeOffset.Now,
// logo (Optional) - Identifies a larger image which provides visual identification for the feed.
// Images should be twice as wide as they are tall.
ImageUrl = new Uri(this.urlHelper.AbsoluteContent("~/content/icons/atom-logo-96x48.png")),
// rights (Optional) - Conveys information about rights, e.g. copyrights, held in and over the feed.
Copyright = SyndicationContent.CreatePlaintextContent(
string.Format("© {0} - {1}", DateTime.Now.Year, Application.Name)),
// lang (Optional) - The language of the feed.
Language = "en-GB",
// generator (Optional) - Identifies the software used to generate the feed, for debugging and other
// purposes. Do not put in anything that identifies the technology you are using.
// Generator = "Sample Code",
// base (Buggy) - Add the full base URL to the site so that all other links can be relative. This is
// great, except some feed readers are buggy with it, INCLUDING FIREFOX!!!
// (See https://bugzilla.mozilla.org/show_bug.cgi?id=480600).
// BaseUri = new Uri(this.urlHelper.AbsoluteRouteUrl(HomeControllerRoute.GetIndex))
};
// self link (Required) - The URL for the syndication feed.
feed.Links.Add(SyndicationLink.CreateSelfLink(
new Uri(this.urlHelper.AbsoluteRouteUrl(HomeControllerRoute.GetFeed)),
ContentType.Atom));
// alternate link (Recommended) - The URL for the web page showing the same data as the syndication feed.
feed.Links.Add(SyndicationLink.CreateAlternateLink(
new Uri(this.urlHelper.AbsoluteRouteUrl(HomeControllerRoute.GetIndex)),
ContentType.Html));
// hub link (Recommended) - The URL for the PubSubHubbub hub. Used to push new entries to subscribers
// instead of making them poll the feed. See feed updated method below.
feed.Links.Add(new SyndicationLink(new Uri(PubSubHubbubHubUrl), "hub", null, null, 0));
// first, last, next previous (Optional) - Atom 1.0 supports paging of your feed. This is good if your feed
// becomes very large and needs splitting up into pages. To add
// paging, you must add links to the first, last, next and previous
// feed pages.
// feed.Links.Add(new SyndicationLink(new Uri("http://example.com/feed"), "first", null, null, 0));
// feed.Links.Add(new SyndicationLink(new Uri("http://example.com/feed?page=10"), "last", null, null, 0));
// if ([HAS_PREVIOUS_PAGE])
// feed.Links.Add(new SyndicationLink(new Uri("http://example.com/feed?page=1")), "previous", null, null, 0));
// if ([HAS_NEXT_PAGE])
// feed.Links.Add(new SyndicationLink(new Uri("http://example.com/feed?page=3"), "next", null, null, 0));
// author (Recommended) - Names one author of the feed. A feed may have multiple author elements. A feed
// must contain at least one author element unless all of the entry elements contain
// at least one author element.
feed.Authors.Add(this.GetPerson());
// category (Optional) - Specifies a category that the feed belongs to. A feed may have multiple category
// elements.
feed.Categories.Add(new SyndicationCategory("CategoryName"));
// contributor (Optional) - Names one contributor to the feed. An feed may have multiple contributor
// elements.
feed.Contributors.Add(this.GetPerson());
// icon (Optional) - Identifies a small image which provides iconic visual identification for the feed.
// Icons should be square.
feed.SetIcon(this.urlHelper.AbsoluteContent("~/content/icons/atom-icon-48x48.png"));
// Add the Yahoo Media namespace (xmlns:media="http://search.yahoo.com/mrss/") to the Atom feed.
// This gives us extra abilities, like the ability to give thumbnail images to entries.
// See http://www.rssboard.org/media-rss for more information.
feed.AddYahooMediaNamespace();
return(feed);
}
public void GetAbsoluteUri_Invoke_ReturnsExpected(SyndicationLink link, Uri expected)
{
Assert.Equal(expected, link.GetAbsoluteUri());
}
static void Snippet0()
{
// <Snippet0>
// <Snippet49>
SyndicationFeed feed = new SyndicationFeed("Feed Title", "Feed Description", new Uri("http://Feed/Alternate/Link"), "FeedID", DateTime.Now);
// </Snippet49>
// Add a custom attribute.
XmlQualifiedName xqName = new XmlQualifiedName("CustomAttribute");
feed.AttributeExtensions.Add(xqName, "Value");
SyndicationPerson sp = new SyndicationPerson("*****@*****.**", "Jesper Aaberg", "http://Jesper/Aaberg");
feed.Authors.Add(sp);
SyndicationCategory category = new SyndicationCategory("FeedCategory", "CategoryScheme", "CategoryLabel");
feed.Categories.Add(category);
feed.Contributors.Add(new SyndicationPerson("*****@*****.**", "Lene Aaling", "http://lene/aaling"));
feed.Copyright = new TextSyndicationContent("Copyright 2007");
feed.Description = new TextSyndicationContent("This is a sample feed");
// Add a custom element.
XmlDocument doc = new XmlDocument();
XmlElement feedElement = doc.CreateElement("CustomElement");
feedElement.InnerText = "Some text";
feed.ElementExtensions.Add(feedElement);
feed.Generator = "Sample Code";
feed.Id = "FeedID";
feed.ImageUrl = new Uri("http://server/image.jpg");
TextSyndicationContent textContent = new TextSyndicationContent("Some text content");
SyndicationItem item = new SyndicationItem("Item Title", textContent, new Uri("http://server/items"), "ItemID", DateTime.Now);
List <SyndicationItem> items = new List <SyndicationItem>();
items.Add(item);
feed.Items = items;
feed.Language = "en-us";
feed.LastUpdatedTime = DateTime.Now;
SyndicationLink link = new SyndicationLink(new Uri("http://server/link"), "alternate", "Link Title", "text/html", 1000);
feed.Links.Add(link);
XmlWriter atomWriter = XmlWriter.Create("atom.xml");
Atom10FeedFormatter atomFormatter = new Atom10FeedFormatter(feed);
atomFormatter.WriteTo(atomWriter);
atomWriter.Close();
XmlWriter rssWriter = XmlWriter.Create("rss.xml");
Rss20FeedFormatter rssFormatter = new Rss20FeedFormatter(feed);
rssFormatter.WriteTo(rssWriter);
rssWriter.Close();
// </Snippet0>
}
private SyndicationItem GetSyndicationItem(Store store, Content product, Category category, int description, String type)
{
if (category == null)
{
return(null);
}
if (description == 0)
{
description = 300;
}
var productDetailLink = LinkHelper.GetContentLink(product, category.Name, type);
String detailPage = String.Format("http://{0}{1}", store.Domain.ToLower(), productDetailLink);
string desc = "";
if (description > 0)
{
desc = GeneralHelper.GeneralHelper.GetDescription(product.Description, description);
}
var uri = new Uri(detailPage);
var si = new SyndicationItem(product.Name, desc, uri);
si.ElementExtensions.Add("guid", String.Empty, uri);
if (product.UpdatedDate != null)
{
si.PublishDate = product.UpdatedDate.Value.ToUniversalTime();
}
if (!String.IsNullOrEmpty(category.Name))
{
si.ElementExtensions.Add(type + ":category", String.Empty, category.Name);
}
if (product.ContentFiles.Any())
{
var mainImage = product.ContentFiles.FirstOrDefault(r => r.IsMainImage);
if (mainImage == null)
{
mainImage = product.ContentFiles.FirstOrDefault();
}
if (mainImage != null)
{
string imageSrc = LinkHelper.GetImageLink("Thumbnail", mainImage.FileManager, this.ImageWidth, this.ImageHeight);
if (!string.IsNullOrEmpty(imageSrc))
{
try
{
SyndicationLink imageLink =
SyndicationLink.CreateMediaEnclosureLink(new Uri(imageSrc), "image/jpeg", 100);
si.Links.Add(imageLink);
}
catch (Exception e)
{
}
}
}
}
return(si);
}
public void Length_SetNegative_ThrowsArgumentOutOfRangeException()
{
var link = new SyndicationLink();
AssertExtensions.Throws <ArgumentOutOfRangeException>("value", () => link.Length = -1);
}
public static void Snippet4()
{
// <Snippet4>
SyndicationLink link = SyndicationLink.CreateAlternateLink(new Uri("http://server/link"));
// </Snippet4>
}
private Action <Stream> GetXmlContents(IEnumerable <Post> model)
{
var items = new List <SyndicationItem>();
foreach (var post in model)
{
// Replace all relative urls with full urls.
var newHtml = Regex.Replace(post.Content, UrlRegex, m => siteUrl.TrimEnd('/') + "/" + m.Value.TrimStart('/'));
var item = new SyndicationItem(
post.Title,
newHtml,
new Uri(siteUrl + post.Url)
)
{
Id = siteUrl + post.Url,
LastUpdatedTime = post.Date.ToUniversalTime(),
PublishDate = post.Date.ToUniversalTime(),
Content = new TextSyndicationContent(post.Content, TextSyndicationContentKind.Html),
Summary = new TextSyndicationContent(post.ContentExcerpt, TextSyndicationContentKind.Html),
};
items.Add(item);
}
var feed = new SyndicationFeed(
AtomTitle,
AtomTitle, /* Using Title also as Description */
new Uri(siteUrl + "/" + feedfileName),
items)
{
Id = siteUrl + "/",
LastUpdatedTime = new DateTimeOffset(DateTime.Now),
Generator = "Sandra.Snow Atom Generator"
};
feed.Authors.Add(new SyndicationPerson(authorEmail, author, siteUrl));
var link = new SyndicationLink(new Uri(siteUrl + "/" + feedfileName))
{
RelationshipType = "self",
MediaType = "text/html",
Title = AtomTitle
};
feed.Links.Add(link);
var formatter = new Atom10FeedFormatter(feed);
return(stream =>
{
var encoding = new UTF8Encoding(false);
var streamWrapper = new UnclosableStreamWrapper(stream);
using (var writer = new XmlTextWriter(streamWrapper, encoding))
{
formatter.WriteTo(writer);
}
});
}
private bool RunPerResource(string resource)
{
bool logTargetResult = false;
this.Logger.Write(string.Format("Starting synchronization for Resource {0} ", resource), Severity.Info);
this.Logger.Write(string.Format("Source: {0}", this.SyncInfo.Source.GetResourceUri(resource)), Severity.Trace);
this.Logger.Write(string.Format("Target: {0}", this.SyncInfo.Target.GetResourceUri(resource)), Severity.Trace);
if ((this.SyncInfo.Logging != null) && (this.SyncInfo.Logging.Url != null))
{
this.Logger.Write(string.Format("Logging: {0}", this.SyncInfo.Logging.GetResourceUri(resource)), Severity.Trace);
logTargetResult = true;
}
this.Logger.Write(string.Format("Direction: {0}", this.Direction.ToString()), Severity.Trace);
HttpClient httpSourceClient = null;
Guid sourceClientTrackingId = Guid.Empty;
HttpClient httpTargetClient = null;
Guid targetClientTrackingId = Guid.Empty;
HttpClient httpLoggingClient = null;
string tmpUrl;
HttpResponseMessage respMsg;
SyndicationFeed tmpSourceFeed;
SyndicationFeed tmpTargetFeed;
SyndicationLink tmpSourceNextLink = null;
SyndicationLink tmpTargetNextLink = null;
// Create application client objects
if (Direction == SynchronisationDirection.forward)
{
httpSourceClient = GetHttpClient(SyncInfo.Source, SyncInfo.Proxy, resource);
httpTargetClient = GetHttpClient(SyncInfo.Target, SyncInfo.Proxy, resource);
}
else
{
httpSourceClient = GetHttpClient(SyncInfo.Target, SyncInfo.Proxy, resource);
httpTargetClient = GetHttpClient(SyncInfo.Source, SyncInfo.Proxy, resource);
}
if (logTargetResult)
{
httpLoggingClient = GetHttpClient(SyncInfo.Logging, SyncInfo.Proxy, resource);
httpLoggingClient.TransportSettings.ConnectionTimeout = new TimeSpan(0, 5, 0);
}
// set timeout
httpSourceClient.TransportSettings.ConnectionTimeout = new TimeSpan(0, 5, 0);
httpTargetClient.TransportSettings.ConnectionTimeout = new TimeSpan(0, 5, 0);
try
{
// *********************************************************
// GET the sync digest from target applictaion ($syncDigest)
// *********************************************************
this.Logger.Write("Requesting the Sync Digest from target application.", Severity.Info);
tmpUrl = GetSyncDigestGetUrl(resource);
this.Logger.Write(string.Format("HTTP GET: {0}", tmpUrl), Severity.Trace);
respMsg = httpTargetClient.Get(tmpUrl);
this.Log(respMsg);
// receive the content of the response
respMsg.Content.LoadIntoBuffer();
// handle errors
this.ThrowIfNotStatusCode(HttpStatusCode.OK, respMsg);
// check for correct content type of the result
ThrowIfNoFeedEntry(respMsg);
this.Logger.Write("Sync Digest received.", Severity.Info);
// As we do not need to read the SyncDigest, the response content will be posted directly to the source application.
// At the same time no reading means no validation. So eventually wrong data could be sent to the source application
// with the next request. The source application must handle eventually wrong input data.
// *************************************************************************
// POST the retrieved Sync Digest to the source application ($syncSource)
// *************************************************************************
this.Logger.Write("Posting the Sync Digest from target application to the source application.", Severity.Info);
sourceClientTrackingId = Guid.NewGuid(); // create the tracking ID for the asynchronous request
tmpUrl = GetSyncSourcePostUrl(sourceClientTrackingId, resource);
this.Logger.Write(string.Format("HTTP POST: {0}", tmpUrl), Severity.Trace);
this.Logger.Write(string.Format("Content Type: {0}", ATOMFEEDENTRY), Severity.Trace);
respMsg = httpSourceClient.Post(tmpUrl, ATOMFEEDENTRY, respMsg.Content);
this.Log(respMsg);
// receive the content of the response
respMsg.Content.LoadIntoBuffer();
// handle errors
this.ThrowIfNotStatusCode(HttpStatusCode.Accepted, respMsg);
// check for correct content type of the result
ThrowIfNoXml(respMsg);
// *************************************************************************
// GET the Sync Feed from source application ($syncSource)
// *************************************************************************
// The helper method used here looks at the header of the response for the Location parameter
// and requests the location url until a Status Code 200(OK) and an sdata feed is returned.
// If an error occurred (No 200 or 202 status) an exception is thown.
this.Logger.Write("Polling source application until retrieving sync feed.", Severity.Info);
respMsg = this.RequestHeaderLocationUntilStatusIs200(respMsg, httpSourceClient);
this.Log(respMsg);
// check for correct content type of the result
ThrowIfNoFeed(respMsg);
// receive the content of the response
respMsg.Content.LoadIntoBuffer();
int sourceFeedPage = 1;
do
{
// parse source result as a feed
// needed to read a 'next' link, so that we can retrieve and submit the next page.
tmpSourceFeed = respMsg.Content.ReadAsSyndicationFeed();
Atom10FeedFormatter ff = tmpSourceFeed.GetAtom10Formatter();
// Handle error feed
this.ThrowIfDiagnosisFeed(tmpSourceFeed);
// *************************************************************************
// POST the retrieved Sync Feed to the target application ($syncTarget)
// *************************************************************************
this.Logger.Write(string.Format("Posting page {0} of the Sync Feed from source application to the target application.", sourceFeedPage), Severity.Info);
targetClientTrackingId = Guid.NewGuid(); // create the tracking ID for the asynchronous request
tmpUrl = GetSyncTargetPostUrl(targetClientTrackingId, resource);
this.Logger.Write(string.Format("HTTP POST: {0}", tmpUrl), Severity.Trace);
this.Logger.Write(string.Format("Content Type: {0}", ATOMFEED), Severity.Trace);
//XmlWriter writer;
//tmpSourceFeed.SaveAsAtom10(writer);
//HttpContent httpContent = HttpContent.Create(
respMsg = httpTargetClient.Post(tmpUrl, ATOMFEED, respMsg.Content);
this.Log(respMsg);
// receive the content of the response
respMsg.Content.LoadIntoBuffer();
// handle errors
this.ThrowIfNotStatusCode(HttpStatusCode.Accepted, respMsg);
// check for correct content type of the result
ThrowIfNoXml(respMsg);
// *************************************************************************
// GET the Sync Feed from target application ($syncTarget)
// *************************************************************************
// The helper method used here looks at the header of the response for the Location parameter
// and requests the location url until a Status Code 200(OK) and an sdata feed is returned.
// If an error occurred (No 200 or 202 status) an exception is thown.
this.Logger.Write("Polling target application until retrieving sync feed.", Severity.Info);
respMsg = this.RequestHeaderLocationUntilStatusIs200(respMsg, httpTargetClient);
this.Log(respMsg);
int targetFeedPage = 1;
do
{
// parse target result as a feed
// needed to read a 'next' link, so that we can retrieve and submit the next page.
tmpTargetFeed = respMsg.Content.ReadAsSyndicationFeed();
// Handle error feed
this.ThrowIfDiagnosisFeed(tmpTargetFeed);
// *************************************************************************
// POST the retrieved Sync Feed to the logging application ($syncResults)
// *************************************************************************
if (!logTargetResult)
{
this.Logger.Write("No logging url specified", Severity.Trace);
}
else
{
this.Logger.Write(string.Format("Posting page {0} of the Sync Feed from target application to the logging application.", targetFeedPage), Severity.Info);
tmpUrl = string.Format("{0}/{1}?runName={2}&runStamp={3}", SyncInfo.Logging.GetResourceUri(resource), "$syncResults", this.RunName, this.RunStamp.ToUniversalTime());
this.Logger.Write(string.Format("HTTP POST: {0}", tmpUrl), Severity.Trace);
this.Logger.Write(string.Format("Content Type: {0}", ATOMFEED), Severity.Trace);
respMsg = httpLoggingClient.Post(tmpUrl, ATOMFEED, respMsg.Content);
this.Log(respMsg);
}
// receive the content of the response
respMsg.Content.LoadIntoBuffer();
// handle errors
this.ThrowIfNotStatusCode(HttpStatusCode.OK, respMsg);
// *************************************************************************
// GET the next page of the Sync Feed of the target application($syncTarget)
// *************************************************************************
tmpTargetNextLink = tmpTargetFeed.GetNextPageLink();
if (null != tmpTargetNextLink)
{
// Todo: LOG
respMsg = httpTargetClient.Get(tmpTargetNextLink.Uri.ToString());
this.Log(respMsg);
// validate
respMsg.Content.LoadIntoBuffer();
targetFeedPage++;
}
} while (null != tmpTargetNextLink);
// *************************************************************************
// DELETE the batching context of the source application($syncSource)
// *************************************************************************
this.Logger.Write("Deleting batching context from target application.", Severity.Info);
tmpUrl = GetSyncTargetDeleteUrl(targetClientTrackingId, resource);
this.Logger.Write(string.Format("HTTP DELETE: {0}", tmpUrl), Severity.Trace);
respMsg = httpTargetClient.Delete(tmpUrl);
this.Log(respMsg);
// receive the content of the response
respMsg.Content.LoadIntoBuffer();
// handle errors
//this.ThrowIfNotStatusCode(HttpStatusCode.OK, respMsg);
// *************************************************************************
// GET the next page of the Sync Feed of the source application($syncSource)
// *************************************************************************
tmpSourceNextLink = tmpSourceFeed.GetNextPageLink();
if (null != tmpSourceNextLink)
{
// Todo: LOG
respMsg = httpSourceClient.Get(tmpSourceNextLink.Uri);
this.Log(respMsg);
// validate
respMsg.Content.LoadIntoBuffer();
sourceFeedPage++;
}
} while (null != tmpSourceNextLink);
// *************************************************************************
// DELETE the batching context of the source application($syncSource)
// *************************************************************************
this.Logger.Write("Deleting batching context from source application.", Severity.Info);
tmpUrl = GetSyncSourceDeleteUrl(sourceClientTrackingId, resource);
this.Logger.Write(string.Format("HTTP DELETE: {0}", tmpUrl), Severity.Trace);
respMsg = httpSourceClient.Delete(tmpUrl);
this.Log(respMsg);
// receive the content of the response
respMsg.Content.LoadIntoBuffer();
// handle errors
//this.ThrowIfNotStatusCode(HttpStatusCode.OK, respMsg);
this.Logger.Write("Synchronization succeeded.", Severity.Info);
}
catch (SdataException sdataException)
{
this.Logger.Write(sdataException.Diagnosis);
return(false);
}
catch (Exception exception)
{
this.Logger.Write(exception);
return(false);
}
return(true);
}
public static AtomLink Link(this SyndicationLink link)
{
return(new AtomLink(link.Uri, link.RelationshipType, link.MediaType, link.Title));
}
private void RssFeedForNews(HttpContext context)
{
context.Response.ContentType = "application/rss+xml";
// Create the feed and specify the feed's attributes
var myFeed = new SyndicationFeed
{
Title =
SyndicationContent.CreatePlaintextContent(
"admissionjankari.com- Education News - news"),
Description =
SyndicationContent.CreatePlaintextContent(
"admissionjankari.com- Education News - news"),
Copyright = SyndicationContent.CreatePlaintextContent("© " + DateTime.Now.Year.ToString(CultureInfo.InvariantCulture) + " Copyright | www.AdmissionJankari.com"),
Language = "en-us",
ImageUrl = new Uri(Utils.AbsoluteWebRoot + "image.axd?Common=logo.png")
};
myFeed.Links.Add(new SyndicationLink(new Uri("http://www.admissionjankari.com/latest-news/"), "alternate", "Education-news", "text/html", 1000));
myFeed.LastUpdatedTime = DateTimeOffset.Now;
var feedItems = new List<SyndicationItem>();
foreach (
var newsList in
NewsArticleNoticeProvider.Instance.GetLatestNews()
.Where(result => result.NewsStatus)
.ToList()
.Take(10).OrderByDescending(result => result.NewsDate))
{
var item = new SyndicationItem
{
Title = SyndicationContent.CreatePlaintextContent(newsList.NewsSubject)
};
item.Links.Add(
SyndicationLink.CreateAlternateLink(
new Uri(
Utils.AbsoluteWebRoot +
("news-details/" + Utils.RemoveIllegalCharacters(Convert.ToString(newsList.NewsSubject)))
.ToLower())));
item.Summary = SyndicationContent.CreatePlaintextContent(newsList.NewsDesc);
item.Categories.Add(new SyndicationCategory(newsList.NewsSubject));
item.PublishDate = newsList.NewsDate;
feedItems.Add(item);
}
myFeed.Items = feedItems;
var outputSettings = new XmlWriterSettings
{
Indent = true
};
var feedWriter = XmlWriter.Create(context.Response.OutputStream, outputSettings);
// Emit RSS 2.0
var rssFormatter = new Rss20FeedFormatter(myFeed);
rssFormatter.WriteTo(feedWriter);
feedWriter.Close();
}
SyndicationFeed GetFeed()
{
#region -- Create Feed --
SyndicationFeed feed = new SyndicationFeed();
// set the feed ID to the main URL of your Website
feed.Id = baseUrl;
// set some properties on the feed
feed.Title = new TextSyndicationContent("Блог VsyachePuz-а");
/*feed.Description = new TextSyndicationContent("описание первого фида");*/
//feed.Copyright = new TextSyndicationContent("Steve");
feed.LastUpdatedTime = new DateTimeOffset(DateTime.Now);
// since you are writing your own custom feed generator, you get to
// name it! Although this is not required.
feed.Generator = "Руки";
/*
* // add your site or feed logo url
* string imageUrl = baseUrl + "/images/mylogo.gif";
* feed.ImageUrl = new Uri(imageUrl);
*/
// Add the URL that will link to your published feed when it's done
SyndicationLink link = new SyndicationLink(new Uri("https://raw.githubusercontent.com/VsyachePuz/blog/gh-pages/notifications/for-irc.atom"));
link.RelationshipType = "self";
link.MediaType = "text/html";
link.Title = "VsyachePuz's blog feed";
feed.Links.Add(link);
// Add your site link
link = new SyndicationLink(new Uri(baseUrl));
link.MediaType = "text/html";
link.Title = "Site link";
feed.Links.Add(link);
#endregion
List <SyndicationItem> items = new List <SyndicationItem> ();
int maxArticles = 15;
for (int i = 0; i < listView1.Items.Count; i++)
{
var it = listView1.Items [i];
Uri urlOfArticle = new Uri(GetColumnValue(it, "URL"));
string titleOfArticle = GetColumnValue(it, "Title");
DateTime published = DateTime.Parse(GetColumnValue(it, "Published"));
DateTime updated = DateTime.Parse(GetColumnValue(it, "Updated"));
string summary = GetColumnValue(it, "Summary");
// create new entry for feed
SyndicationItem item = new SyndicationItem();
// set the entry id to the URL for the item
string url = urlOfArticle.AbsoluteUri; // TODO: create the GetArticleUrl method
item.Id = url;
// Add the URL for the item as a link
link = new SyndicationLink(urlOfArticle);
item.Links.Add(link);
// Fill some properties for the item
item.Title = new TextSyndicationContent(titleOfArticle);
item.LastUpdatedTime = published;
item.PublishDate = updated;
item.Summary = new TextSyndicationContent(WebUtility.HtmlEncode(summary));
/*
* // Fill the item content
* string html = String.Empty; // TODO: create the GetFeedEntryHtml method
* TextSyndicationContent content
* = new TextSyndicationContent(html, TextSyndicationContentKind.Html);
* item.Content = content;
*/
// Finally add this item to the item collection
items.Add(item);
// Stop after adding the max desired number of items
if (items.Count >= maxArticles)
{
break;
}
}
feed.Items = items;
return(feed);
}
public async Task <IActionResult> Feed()
{
// Get posts
var posts = await _context.Posts
.Include(q => q.User)
.Include(q => q.PostCategories).ThenInclude(q => q.Category)
.ToListAsync();
// Create feed items
var feedItems = new List <SyndicationItem>();
foreach (var post in posts.Take(SiteSettings.FeedSize))
{
var feedItem = new SyndicationItem
{
Title = SyndicationContent.CreatePlaintextContent(post.Title),
Summary = SyndicationContent.CreatePlaintextContent(post.Summary),
Content = SyndicationContent.CreateHtmlContent(post.Content),
Authors = { new SyndicationPerson(post.User.Name) },
Links =
{
SyndicationLink.CreateAlternateLink(new Uri(Url.Action("Post", "Blog", new
{
year = post.DateCreated.Year,
month = post.DateCreated.Month,
slug = post.Slug
}, HttpContext.Request.Scheme)))
},
PublishDate = post.DateCreated
};
foreach (var postCategory in post.PostCategories)
{
feedItem.Categories.Add(new SyndicationCategory(postCategory.Category.Name));
}
feedItems.Add(feedItem);
}
// Create feed
var feed = new SyndicationFeed
{
Title = SyndicationContent.CreatePlaintextContent(SiteSettings.Title),
Description = SyndicationContent.CreatePlaintextContent(SiteSettings.Tagline),
Links = { SyndicationLink.CreateAlternateLink(new Uri(Url.Action("Index", "Blog", null, HttpContext.Request.Scheme))) },
Items = feedItems
};
// Serve the feed
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"));
}
}
public static SyndicationLink FromDictionnary(Dictionary<string, object> link, string prefix = "")
{
if (link.ContainsKey("@" + prefix + "href")) {
long length = 0;
string rel = null;
string title = null;
string type = null;
Uri href = new Uri((string)link["@" + prefix + "href"]);
object r = null;
if (link.TryGetValue("@" + prefix + "rel", out r))
rel = (string)r;
if (link.TryGetValue("@" + prefix + "title", out r))
title = (string)r;
if (link.TryGetValue("@" + prefix + "type", out r))
type = (string)r;
if (link.TryGetValue("@" + prefix + "", out r))
if (r is string)
long.TryParse((string)r, out length);
else
length = (long)r;
SyndicationLink slink = new SyndicationLink(href, rel, title, type, length);
return slink;
}
throw new ArgumentException("Not a link");
}
public static void Snippet5()
{
// <Snippet5>
SyndicationLink link = SyndicationLink.CreateAlternateLink(new Uri("http://server/link"), "text/html");
// </Snippet5>
}
public string GetUserPostsRss(long UserID)
{
var User = _context.Users.Find(UserID);
SyndicationFeed feed = new SyndicationFeed("Feed Title", "Feed Description", new Uri("http://jamespritts.com"), "FeedID", DateTime.Now);
// Add a custom attribute.
XmlQualifiedName xqName = new XmlQualifiedName("GameBeOkKey");
feed.AttributeExtensions.Add(xqName, "codeHard1");
SyndicationPerson sp = new SyndicationPerson(User.Email, User.UserName, $"http://jamespritts.com/u/{User.UserName}");
feed.Authors.Add(sp);
SyndicationCategory category = new SyndicationCategory("FeedCategory", "CategoryScheme", "CategoryLabel");
feed.Categories.Add(category);
feed.Contributors.Add(new SyndicationPerson("*****@*****.**", "James Pritts", "http://jamespritts.com"));
feed.Copyright = new TextSyndicationContent($"Copyright {DateTime.Now.Year}");
feed.Description = new TextSyndicationContent("Personal Post Feed");
// Add a custom element.
XmlDocument doc = new XmlDocument();
XmlElement feedElement = doc.CreateElement("CustomElement");
feedElement.InnerText = "Some text";
feed.ElementExtensions.Add(feedElement);
feed.Generator = "GameBeOk User Rss Feed";
feed.Id = "FeedID";
feed.ImageUrl = new Uri("http://server/image.jpg");
var userPosts = _context.Posts.Where(x => x.Sender == User.Email);
List <SyndicationItem> items = new List <SyndicationItem>();
foreach (var v in userPosts)
{
TextSyndicationContent textContent = new TextSyndicationContent(v.Content);
SyndicationItem item = new SyndicationItem("User Post", textContent, new Uri("http://server/items"), "ItemID", DateTime.Now);
items.Add(item);
}
feed.Items = items;
feed.Language = "en-us";
feed.LastUpdatedTime = DateTime.Now;
SyndicationLink link = new SyndicationLink(new Uri("http://server/link"), "alternate", "Link Title", "text/html", 1000);
feed.Links.Add(link);
XmlWriter atomWriter = XmlWriter.Create("atom.xml");
Atom10FeedFormatter atomFormatter = new Atom10FeedFormatter(feed);
atomFormatter.WriteTo(atomWriter);
atomWriter.Close();
using (XmlWriter rssWriter = XmlWriter.Create("rss.xml"))
{
Rss20FeedFormatter rssFormatter = new Rss20FeedFormatter(feed);
rssFormatter.WriteTo(rssWriter);
return(rssWriter.ToString());
}
}
public static void Snippet6()
{
// <Snippet6>
SyndicationLink link = SyndicationLink.CreateMediaEnclosureLink(new Uri("http://server/link"), "audio/mpeg", 100000);
// </Snippet6>
}
public void NegativeLength()
{
SyndicationLink link = new SyndicationLink(new Uri("http://mono-project.com/index.rss"));
link.Length = -1;
}
public static void Snippet7()
{
// <Snippet7>
SyndicationLink link = SyndicationLink.CreateSelfLink(new Uri("http://server/link"));
// </Snippet7>
}
public AtomResourceLink(SyndicationLink l)
{
this.atomLink = l;
}
public static void Snippet8()
{
// <Snippet8>
SyndicationLink link = SyndicationLink.CreateSelfLink(new Uri("http://server/link"), "text/html");
// </Snippet8>
}
public void CreateMediaEnclosureLink_NegativeLength_ThrowsArgumentOutOfRangeException()
{
AssertExtensions.Throws <ArgumentOutOfRangeException>("length", () => SyndicationLink.CreateMediaEnclosureLink(null, null, -1));
}
/// <summary>Applies the information from a link to the specified resource.</summary>
/// <param name='link'>LinkDescriptor with information to apply.</param>
/// <param name="resourceSet">Set for the target resource.</param>
/// <param name='resourceType'>Type for the target resource.</param>
/// <param name='resource'>Target resource to which information will be applied.</param>
/// <param name="propertyName">Name of the property that this link represents.</param>
private void ApplyLink(SyndicationLink link, ResourceSetWrapper resourceSet, ResourceType resourceType, object resource, string propertyName)
{
Debug.Assert(link != null, "link != null");
Debug.Assert(resourceType != null, "resourceType != null");
Debug.Assert(resource != null, "resource != null");
ResourceProperty property = resourceType.TryResolvePropertyName(propertyName);
if (property == null)
{
// Open navigation properties are not supported on OpenTypes
throw DataServiceException.CreateBadRequestError(Strings.OpenNavigationPropertiesNotSupportedOnOpenTypes(propertyName));
}
if (property.TypeKind != ResourceTypeKind.EntityType)
{
throw DataServiceException.CreateBadRequestError(Strings.BadRequest_InvalidNavigationPropertyName(propertyName, resourceType.FullName));
}
string typeParameterValue = ValidateTypeParameterForNonOpenTypeProperties(link.MediaType, property);
LinkContent linkContent = this.HandleLinkContent(link, resource, resourceSet, resourceType, property, typeParameterValue, propertyName);
#region Handle bind/unbind operation
// If the href was specified empty or an empty inline element was specified, then we will set the
// reference to null - this helps in overrriding if there was a default non-value for this property
// else if only link element was specified, and then href points to a single result, then we will
// perform a bind operation
if ((linkContent == LinkContent.NoInlineElementSpecified && link.Uri != null && String.IsNullOrEmpty(link.Uri.OriginalString)) ||
linkContent == LinkContent.EmptyInlineElementSpecified)
{
// update the object count when you are performing a bind operation
this.CheckAndIncrementObjectCount();
if (property != null && property.Kind == ResourcePropertyKind.ResourceSetReference)
{
throw DataServiceException.CreateBadRequestError(Strings.BadRequest_CannotSetCollectionsToNull(propertyName));
}
// For open properties, we will assume that this is a reference property and set it to null
this.Updatable.SetReference(resource, propertyName, null);
}
else if (linkContent == LinkContent.NoInlineElementSpecified && link.Uri != null && !String.IsNullOrEmpty(link.Uri.OriginalString))
{
// update the object count when you are performing a bind operation
this.CheckAndIncrementObjectCount();
// If the link points to a reference navigation property, then update the link
Uri referencedUri = RequestUriProcessor.GetAbsoluteUriFromReference(link.Uri.OriginalString, this.Service.OperationContext);
RequestDescription description = RequestUriProcessor.ProcessRequestUri(referencedUri, this.Service);
if (!description.IsSingleResult)
{
if (property != null && property.Kind == ResourcePropertyKind.ResourceReference)
{
throw DataServiceException.CreateBadRequestError(Strings.BadRequest_LinkHrefMustReferToSingleResource(propertyName));
}
return;
}
// no need to check for null. For collection properties, they can never be null and that
// check has been added below. For reference properties, if they are null, it means unbind
// and hence no need to check for null.
// Get the resource
object targetResource = this.Service.GetResource(description, description.SegmentInfos.Length - 1, null);
if (property.Kind == ResourcePropertyKind.ResourceReference)
{
this.Updatable.SetReference(resource, propertyName, targetResource);
}
else
{
WebUtil.CheckResourceExists(targetResource != null, description.LastSegmentInfo.Identifier);
this.Updatable.AddReferenceToCollection(resource, propertyName, targetResource);
}
}
#endregion Handle bind/unbind operation
}
public SyndicationLinkSubclass(SyndicationLink source) : base(source)
{
}
/// <summary>
/// Handle the contents under the link element
/// </summary>
/// <param name="link">syndication link element</param>
/// <param name="parentResource">parent resource which contains the link.</param>
/// <param name="parentResourceSet">resource set of the parent resource</param>
/// <param name="parentResourceType">resource type of the parent resource</param>
/// <param name="property">property representing the link.</param>
/// <param name="typeParameterValue">type parameter value as specified in the type attribute.</param>
/// <param name="propertyName">name of the property that this link represents.</param>
/// <returns>returns whether there are child elements under link element.</returns>
private LinkContent HandleLinkContent(
SyndicationLink link,
object parentResource,
ResourceSetWrapper parentResourceSet,
ResourceType parentResourceType,
ResourceProperty property,
string typeParameterValue,
string propertyName)
{
Debug.Assert(parentResource != null, "parent resource cannot be null");
Debug.Assert(property != null, "property != null");
Debug.Assert(link != null, "link != null");
LinkContent linkContent = LinkContent.NoInlineElementSpecified;
foreach (var e in link.ElementExtensions)
{
// link can contain other elements apart from the inline elements.
if (e.OuterNamespace != XmlConstants.DataWebMetadataNamespace ||
e.OuterName != XmlConstants.AtomInlineElementName)
{
continue;
}
// Deep payload cannot be specified for update
if (this.Update)
{
throw DataServiceException.CreateBadRequestError(Strings.BadRequest_DeepUpdateNotSupported);
}
linkContent = LinkContent.EmptyInlineElementSpecified;
using (XmlReader linkReader = e.GetReader())
{
while (linkReader.Read())
{
if (linkReader.NodeType == XmlNodeType.Element)
{
string elementName = linkReader.LocalName;
string namespaceUri = linkReader.NamespaceURI;
if (namespaceUri != XmlConstants.AtomNamespace)
{
throw DataServiceException.CreateBadRequestError(
Strings.BadRequest_InlineElementMustContainValidElement(
elementName,
XmlConstants.AtomInlineElementName,
XmlConstants.AtomFeedElementName,
XmlConstants.AtomEntryElementName));
}
ResourceSetWrapper targetSet = this.Service.Provider.GetContainer(parentResourceSet, parentResourceType, property);
if (targetSet == null)
{
throw DataServiceException.CreateBadRequestError(Strings.BadRequest_InvalidPropertyNameSpecified(propertyName, parentResourceType.FullName));
}
// FeatureVersion needs to be 2.0 if any of the property in the types contained in the resource set has KeepInContent false
this.RequestDescription.UpdateAndCheckEpmFeatureVersion(targetSet, this.Service);
linkContent = LinkContent.InlineElementContainsData;
if (elementName == XmlConstants.AtomEntryElementName)
{
if (property.Kind != ResourcePropertyKind.ResourceReference)
{
throw DataServiceException.CreateBadRequestError(Strings.Syndication_EntryElementForReferenceProperties(e.OuterName, propertyName));
}
// Make sure if the media type is specified. If its specified, it should better be link
SyndicationItem propertyItem;
propertyItem = ReadSyndicationItem(this.factory.CreateSyndicationItemFormatter(), linkReader);
SegmentInfo propertySegment = CreateSegment(property, propertyName, targetSet, true /* singleResult */);
Debug.Assert(propertySegment.TargetKind != RequestTargetKind.OpenProperty, "Open navigation properties are not supported on OpenTypes.");
object propertyValue = this.CreateObject(propertySegment, false /* topLevel */, propertyItem);
this.Updatable.SetReference(parentResource, propertyName, propertyValue);
}
else if (elementName == XmlConstants.AtomFeedElementName)
{
if (property.Kind != ResourcePropertyKind.ResourceSetReference)
{
throw DataServiceException.CreateBadRequestError(Strings.Syndication_FeedElementForCollections(e.OuterName, propertyName));
}
SyndicationFeed propertyFeed;
propertyFeed = ReadSyndicationFeed(this.factory.CreateSyndicationFeedFormatter(), linkReader);
SegmentInfo propertySegment = CreateSegment(property, propertyName, targetSet, false /* singleResult */);
Debug.Assert(propertySegment.TargetKind != RequestTargetKind.OpenProperty, "Open navigation properties are not supported on OpenTypes.");
foreach (SyndicationItem item in propertyFeed.Items)
{
object propertyValue = this.CreateObject(propertySegment, false /* topLevel */, item);
if (propertyValue == null)
{
if (propertySegment.ProjectedProperty != null &&
propertySegment.ProjectedProperty.Kind == ResourcePropertyKind.ResourceSetReference)
{
throw DataServiceException.CreateBadRequestError(
Strings.BadRequest_CannotSetCollectionsToNull(propertyName));
}
}
Debug.Assert(
propertySegment.TargetSource == RequestTargetSource.Property &&
propertySegment.TargetKind == RequestTargetKind.Resource &&
propertySegment.SingleResult == false,
"Must be navigation set property.");
this.Updatable.AddReferenceToCollection(parentResource, propertyName, propertyValue);
}
}
else
{
throw DataServiceException.CreateBadRequestError(
Strings.BadRequest_InlineElementMustContainValidElement(
elementName,
XmlConstants.AtomInlineElementName,
XmlConstants.AtomFeedElementName,
XmlConstants.AtomEntryElementName));
}
}
}
}
}
return(linkContent);
}
protected void Page_Load(object sender, EventArgs e)
{
ContentQuery contentQuery = new ContentQuery
{
ContentTypeID = (int)SueetieContentType.BlogPost,
CacheMinutes = 5,
SueetieContentViewTypeID = (int)SueetieContentViewType.AggregateBlogPostList
};
List <SueetieBlogPost> sueetieBlogPosts = SueetieBlogs.GetSueetieBlogPostList(contentQuery);
var dataItems = from post in sueetieBlogPosts
orderby post.DateCreated descending
select post;
const int maxItemsInFeed = 10;
// Determine whether we're outputting an Atom or RSS feed
bool outputAtom = (Request.QueryString["Type"] == "ATOM");
bool outputRss = !outputAtom;
if (outputRss)
{
Response.ContentType = "application/rss+xml";
}
else if (outputAtom)
{
Response.ContentType = "application/atom+xml";
}
// Create the feed and specify the feed's attributes
SyndicationFeed myFeed = new SyndicationFeed();
myFeed.Title = TextSyndicationContent.CreatePlaintextContent("Most Recent Posts on " + SiteSettings.Instance.SiteName);
myFeed.Description = TextSyndicationContent.CreatePlaintextContent("A syndication of the most recently published posts on " + SiteSettings.Instance.SiteName);
myFeed.Links.Add(SyndicationLink.CreateAlternateLink(new Uri(GetFullyQualifiedUrl("~/Default.aspx"))));
myFeed.Links.Add(SyndicationLink.CreateSelfLink(new Uri(GetFullyQualifiedUrl(Request.RawUrl))));
myFeed.Copyright = TextSyndicationContent.CreatePlaintextContent("Copyright " + SiteSettings.Instance.SiteName);
myFeed.Language = "en-us";
List <SyndicationItem> feedItems = new List <SyndicationItem>();
foreach (SueetieBlogPost p in dataItems.Take(maxItemsInFeed))
{
if (outputAtom && p.Author == null)
{
continue;
}
SyndicationItem item = new SyndicationItem();
item.Title = TextSyndicationContent.CreatePlaintextContent(p.BlogTitle + " - " + p.Title);
item.Links.Add(SyndicationLink.CreateAlternateLink(new Uri(GetFullyQualifiedUrl(p.Permalink))));
item.Summary = TextSyndicationContent.CreateHtmlContent(p.PostContent);
item.Categories.Add(new SyndicationCategory(p.BlogTitle));
item.PublishDate = p.DateCreated;
item.Id = GetFullyQualifiedUrl(p.Permalink);
SyndicationPerson authInfo = new SyndicationPerson();
authInfo.Email = p.Email;
authInfo.Name = p.DisplayName;
item.Authors.Add(authInfo);
feedItems.Add(item);
}
myFeed.Items = feedItems;
XmlWriterSettings outputSettings = new XmlWriterSettings();
outputSettings.Indent = true;
XmlWriter feedWriter = XmlWriter.Create(Response.OutputStream, outputSettings);
if (outputAtom)
{
Atom10FeedFormatter atomFormatter = new Atom10FeedFormatter(myFeed);
atomFormatter.WriteTo(feedWriter);
}
else if (outputRss)
{
Rss20FeedFormatter rssFormatter = new Rss20FeedFormatter(myFeed);
rssFormatter.WriteTo(feedWriter);
}
feedWriter.Close();
}
private void GenerateFeed()
{
CertificateTableAdapter certificateAdapter = new CertificateTableAdapter();
String description = "";
String siteUrl = "http://" + EnvDomain;
String homePageUrl = siteUrl + ResolveUrl("~/Default.aspx") + "?station_id=" + StationId;
//mainFeed.Title = TextSyndicationContent.CreatePlaintextContent(Station.SiteNamePlainText);
//mainFeed.Links.Add(SyndicationLink.CreateSelfLink(new Uri(homePageUrl)));
List <DollarSaverDB.CertificateRow> listCertificates = new List <DollarSaverDB.CertificateRow>();
if (Station.StationSiteType == SiteType.Standard)
{
SpecialSettingsTableAdapter specialSettingsAdapter = new SpecialSettingsTableAdapter();
DollarSaverDB.SpecialSettingsDataTable specialSettingsTable = specialSettingsAdapter.GetSpecialSettings(StationId);
bool dailyHeader = false;
if (specialSettingsTable.Count == 1)
{
dailyHeader = specialSettingsTable[0].DailyHeader;
}
if (dailyHeader)
{
description = "Daily Deal";
}
else
{
description = "Weekly Deal";
}
DollarSaverDB.CertificateDataTable daily = certificateAdapter.GetSpecial(StationId, 1);
if (daily.Count == 1)
{
listCertificates.Add(daily[0]);
}
}
else
{
description = "Deal of the Week";
DollarSaverDB.CertificateDataTable certificateTable = certificateAdapter.GetCurrentDeal(StationId);
if (certificateTable.Count == 1)
{
listCertificates.Add(certificateTable[0]);
}
}
List <SyndicationItem> items = new List <SyndicationItem>();
foreach (DollarSaverDB.CertificateRow certificate in listCertificates)
{
SyndicationItem item = new SyndicationItem();
item.Title = TextSyndicationContent.CreatePlaintextContent(certificate.AdvertiserName);
String advertiserUrl = siteUrl + ResolveUrl("~/Advertiser.aspx?advertiser_id=" + certificate.AdvertiserId);
item.Links.Add(SyndicationLink.CreateAlternateLink(new Uri(advertiserUrl)));
StringBuilder content = new StringBuilder();
if (certificate.Advertiser.LogoUrl != String.Empty)
{
String logoUrl = siteUrl + ResolveUrl(certificate.Advertiser.LogoUrl);
int logoWidth = 125;
int logoHeight = 75;
if (certificate.Advertiser.IsLogoImageVertical)
{
logoWidth = 75;
logoHeight = 125;
}
content.Append("<div>");
content.Append("<a href=\"" + advertiserUrl + "\">");
content.Append("<img src=\"" + logoUrl + "\" alt=\"" + Server.HtmlEncode(certificate.AdvertiserName) + "\" style=\"border-color:#404040;border-width:1px;border-style:solid;height:" + logoHeight + "px;width:" + logoWidth + "px;\">");
content.Append("</a>");
content.Append("</div>");
}
content.Append("<div style=\"font-family: Arial;\">");
//content.Append("<a href=\"" + advertiserUrl + "\" style=\"font-weight: bold; font-size: 1.3em; line-height: 1.7em;\">" + Server.HtmlEncode(certificate.AdvertiserName) + "</a>");
content.Append("<p>");
content.Append(certificate.Advertiser.Description);
content.Append("</p>");
content.Append("<a href=\"" + advertiserUrl + "\" style=\"font-weight: bold; font-size: 1.1em; line-height: 1.5em;\">" + Server.HtmlEncode(certificate.ShortName) + "<a>");
content.Append("<p> ");
content.Append(certificate.Description);
content.Append("</p>");
content.Append("<p style=\"font-weight: bold;\"> ");
content.Append("Certificate Value: " + certificate.FaceValue.ToString("$0.00") + "<br />");
content.Append("Price: <span style=\"color: red;\">" + certificate.DiscountValue.ToString("$0.00") + "</span><br />");
content.Append("Your Savings: " + certificate.Savings + "<br />");
content.Append("</p>");
content.Append("<a href=\"" + advertiserUrl + "\" style=\"font-weight: bold; font-size: 1.1em; line-height: 1.5em;\">BUY NOW</a>");
content.Append("</div>");
content.Append("<div style=\"clear: both;\"></div>");
item.Content = SyndicationContent.CreateHtmlContent(content.ToString());
items.Add(item);
}
SyndicationFeed mainFeed = new SyndicationFeed(Station.SiteNamePlainText, description, new Uri(homePageUrl));
mainFeed.Description = TextSyndicationContent.CreatePlaintextContent(description);
mainFeed.Items = items;
Response.ContentType = "application/rss+xml";
using (XmlWriter xmlWriter = XmlWriter.Create(Response.OutputStream)) {
Rss20FeedFormatter rssFeed = new Rss20FeedFormatter(mainFeed);
rssFeed.WriteTo(xmlWriter);
}
}
/// <summary>
/// Gets the collection of <see cref="SyndicationItem"/>'s that represent the atom entries.
/// </summary>
/// <param name="cancellationToken">A <see cref="CancellationToken"/> signifying if the request is cancelled.</param>
/// <returns>A collection of <see cref="SyndicationItem"/>'s.</returns>
private async Task <List <SyndicationItem> > GetItems(CancellationToken cancellationToken)
{
List <SyndicationItem> items = new List <SyndicationItem>();
for (int i = 1; i < 4; ++i)
{
SyndicationItem item = new SyndicationItem()
{
// id (Required) - Identifies the entry using a universally unique and permanent URI. Two entries
// in a feed can have the same value for id if they represent the same entry at
// different points in time.
Id = FeedId + i,
// title (Required) - Contains a human readable title for the entry. This value should not be blank.
Title = SyndicationContent.CreatePlaintextContent("Item " + i),
// description (Recommended) - A summary of the entry.
Summary = SyndicationContent.CreatePlaintextContent("A summary of item " + i),
// updated (Optional) - Indicates the last time the entry was modified in a significant way. This
// value need not change after a typo is fixed, only after a substantial
// modification. Generally, different entries in a feed will have different
// updated timestamps.
LastUpdatedTime = DateTimeOffset.Now,
// published (Optional) - Contains the time of the initial creation or first availability of the entry.
PublishDate = DateTimeOffset.Now,
// rights (Optional) - Conveys information about rights, e.g. copyrights, held in and over the entry.
Copyright = new TextSyndicationContent(
string.Format("© {0} - {1}", DateTime.Now.Year, Application.Name)),
};
// link (Recommended) - Identifies a related Web page. An entry must contain an alternate link if there
// is no content element.
item.Links.Add(SyndicationLink.CreateAlternateLink(
new Uri(this.urlHelper.AbsoluteRouteUrl(HomeControllerRoute.GetIndex)),
ContentType.Html));
// AND/OR
// Text content (Optional) - Contains or links to the complete content of the entry. Content must be
// provided if there is no alternate link.
// item.Content = SyndicationContent.CreatePlaintextContent("The actual plain text content of the entry");
// HTML content (Optional) - Content can be plain text or HTML. Here is a HTML example.
// item.Content = SyndicationContent.CreateHtmlContent("The actual HTML content of the entry");
// author (Optional) - Names one author of the entry. An entry may have multiple authors. An entry must
// contain at least one author element unless there is an author element in the
// enclosing feed, or there is an author element in the enclosed source element.
item.Authors.Add(this.GetPerson());
// contributor (Optional) - Names one contributor to the entry. An entry may have multiple contributor elements.
item.Contributors.Add(this.GetPerson());
// category (Optional) - Specifies a category that the entry belongs to. A entry may have multiple
// category elements.
item.Categories.Add(new SyndicationCategory("CategoryName"));
// link - Add additional links to related images, audio or video like so.
item.Links.Add(SyndicationLink.CreateMediaEnclosureLink(
new Uri(this.urlHelper.AbsoluteContent("~/content/icons/atom-icon-48x48.png")),
ContentType.Png,
0));
// media:thumbnail - Add a Yahoo Media thumbnail for the entry. See http://www.rssboard.org/media-rss
// for more information.
item.SetThumbnail(this.urlHelper.AbsoluteContent("~/content/icons/atom-icon-48x48.png"), 48, 48);
items.Add(item);
}
return(items);
}
public Atom10FeedFormatter GetFragmentsFeed(string collectionId, DateTime since, DateTime before, int page = 1)
{
Logging.LogInfo("GetFragments Feed {0} {1}", page, since);
var collectionProvider = ConfigurationReader.Configuration.CollectionProviders.Where(cp => cp.Name.Equals(collectionId)).FirstOrDefault();
if (collectionProvider == null)
{
return(null);
}
const int pageSize = 1000;
IList <SyndicationItem> feedItems = new List <SyndicationItem>();
IEnumerable <IFragment> fragments = collectionProvider.GetFragments(since, before);
var skip = (page - 1) * pageSize;
var fragmentWritten = false;
foreach (var fragment in fragments.Skip(skip).Take(pageSize))
{
fragmentWritten = true;
// create snapshot item
var fragmentUri = new Uri("fragment?id=" + fragment.ResourceId, UriKind.Relative);
var item = new SyndicationItem
{
Title = new TextSyndicationContent(fragment.ResourceName),
Id = fragmentUri.ToString(),
LastUpdatedTime = fragment.PublishDate
};
var sl = new SyndicationLink(new Uri(fragmentUri + "&format=xml", UriKind.Relative))
{
RelationshipType = "http://www.sdshare.org/2012/core/fragment",
MediaType = "application/rdf+xml"
};
item.Links.Add(sl);
sl = new SyndicationLink(new Uri(fragmentUri + "&format=xml", UriKind.Relative))
{
RelationshipType = "alternate",
MediaType = "application/rdf+xml"
};
item.Links.Add(sl);
item.ElementExtensions.Add("TopicSI", "http://www.egovpt.org/sdshare", fragment.ResourceUri);
item.ElementExtensions.Add("ResourceUri", SdShareNamespace, fragment.ResourceUri);
feedItems.Add(item);
}
var feed = new SyndicationFeed(feedItems)
{
Title = new TextSyndicationContent(collectionId + " Fragments"),
LastUpdatedTime = DateTime.UtcNow
};
// make feed paging links
var firstPageLink = new SyndicationLink(new Uri("fragments?page=1", UriKind.Relative))
{
RelationshipType = "first",
MediaType = "application/atom+xml"
};
feed.Links.Add(firstPageLink);
if (fragmentWritten)
{
var nextPageLink = new SyndicationLink(new Uri("fragments?page=" + (page + 1), UriKind.Relative))
{
RelationshipType = "next",
MediaType = "application/atom+xml"
};
feed.Links.Add(nextPageLink);
}
if (page > 1)
{
var prevPageLink = new SyndicationLink(new Uri("fragments?page=" + (page - 1), UriKind.Relative))
{
RelationshipType = "prev",
MediaType = "application/atom+xml"
};
feed.Links.Add(prevPageLink);
}
return(new Atom10FeedFormatter(feed));
}
public static SyndicationLink FromJTokenList(JToken link, string prefix = "")
{
if (link.SelectToken("@" + prefix + "href") != null) {
long length = 0;
string rel = null;
string title = null;
string type = null;
Uri href = new Uri((string)link.SelectToken("@" + prefix + "href").ToString());
object r = null;
if (link.SelectToken("@" + prefix + "rel") != null)
rel = link.SelectToken("@" + prefix + "rel").ToString();
if (link.SelectToken("@" + prefix + "title") != null)
title = link.SelectToken("@" + prefix + "title").ToString();
if (link.SelectToken("@" + prefix + "type") != null)
type = link.SelectToken("@" + prefix + "type").ToString();
if (link.SelectToken("@" + prefix + "size") != null)
long.TryParse(link.SelectToken("@" + prefix + "size").ToString(), out length);
else
length = 0;
SyndicationLink slink = new SyndicationLink(href, rel, title, type, length);
return slink;
}
throw new ArgumentException("Not a link");
}
public Atom10FeedFormatter GetCollectionFeed(string collectionId)
{
var collectionProvider = ConfigurationReader.Configuration.CollectionProviders.Where(cp => cp.Name.Equals(collectionId)).FirstOrDefault();
if (collectionProvider == null)
{
return(null);
}
IList <SyndicationItem> feedItems = new List <SyndicationItem>();
// create snapshotfeed link
var item = new SyndicationItem
{
Title = new TextSyndicationContent("Snapshot feed for " + collectionId),
Id = Guid.NewGuid().ToString(),
LastUpdatedTime = DateTime.UtcNow
};
var sl = new SyndicationLink(new Uri(collectionId + "/snapshots", UriKind.Relative))
{
RelationshipType = SdShareNamespace + "snapshotsfeed",
MediaType = "application/atom+xml"
};
item.Links.Add(sl);
item.Links.Add(new SyndicationLink(new Uri(collectionId + "/snapshots", UriKind.Relative))
{
RelationshipType = "alternate", MediaType = "application/atom+xml"
});
feedItems.Add(item);
// create fragments link
item = new SyndicationItem
{
Title = new TextSyndicationContent("Fragments feed for " + collectionId),
Id = Guid.NewGuid().ToString(),
LastUpdatedTime = DateTime.UtcNow
};
var fl = new SyndicationLink(new Uri(collectionId + "/fragments", UriKind.Relative))
{
RelationshipType = SdShareNamespace + "fragmentsfeed",
MediaType = "application/atom+xml"
};
item.Links.Add(fl);
item.Links.Add(new SyndicationLink(new Uri(collectionId + "/fragments", UriKind.Relative))
{
RelationshipType = "alternate", MediaType = "application/atom+xml"
});
feedItems.Add(item);
var feed = new SyndicationFeed(feedItems)
{
Title = new TextSyndicationContent(collectionId + " Feed"),
LastUpdatedTime = DateTime.UtcNow
};
return(new Atom10FeedFormatter(feed));
}
internal static SyndicationLink SyndicationLinkFromXElement(XElement elem) {
var atom = XNamespace.Get("http://www.w3.org/2005/Atom");
SyndicationLink link = new SyndicationLink(new Uri(elem.Attribute(atom + "href").Value));
if (elem.Attribute(atom + "rel") != null)
link.RelationshipType = elem.Attribute(atom + "rel").Value;
if (elem.Attribute(atom + "title") != null)
link.Title = elem.Attribute(atom + "title").Value;
if (elem.Attribute(atom + "type") != null)
link.MediaType = elem.Attribute(atom + "type").Value;
if (elem.Attribute(atom + "length") != null)
link.Length = long.Parse(elem.Attribute(atom + "length").Value);
return link;
}
public FileResult Index(string path, bool recursive = false, string title = null)
{
path = ValidatePath(path);
var baseDirInfo = new DirectoryInfo(path);
var feed = new SyndicationFeed(
title ?? baseDirInfo.Name,
$"{(recursive ? "Recursive " : "")}Filefeed generated feed for {baseDirInfo.FullName}",
new Uri($"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.Value}")
);
var folderImage = baseDirInfo.GetFiles("folder.*").FirstOrDefault();
if (folderImage != null)
{
feed.ImageUrl = new Uri($"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.Value}" + Url.Action("GetFile", new { Path = folderImage.FullName }));
}
var files = baseDirInfo.EnumerateFiles(
"*",
new EnumerationOptions {
RecurseSubdirectories = recursive
})
.Where(x => !x.Attributes.HasFlag(FileAttributes.Hidden) && !x.Name.ToLower().StartsWith("folder."))
.Take(100)
.OrderBy(x => x.FullName);
var items = new List <SyndicationItem>(files.Count());
//We fake the date to get a publish date in the same order as alphabetical
var pubDate = new DateTime(DateTime.Now.Year - 1, 1, 1, 12, 0, 0);
foreach (var file in files)
{
if (!_contentTypeProvider.TryGetContentType(file.Name, out var type))
{
type = System.Net.Mime.MediaTypeNames.Application.Octet;
}
var item = new SyndicationItem
{
Title = new TextSyndicationContent(file.Name),
Id = Url.Action("GetFile", new { Path = file.FullName }),
PublishDate = pubDate,
};
item.Links.Add(SyndicationLink.CreateMediaEnclosureLink(
new Uri($"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.Value}" + Url.Action("GetFile", new { Path = file.FullName })),
type,
file.Length));
pubDate = pubDate.AddDays(1);
items.Add(item);
}
feed.Items = items;
var settings = new XmlWriterSettings
{
Encoding = System.Text.Encoding.UTF8,
NewLineHandling = NewLineHandling.Entitize,
NewLineOnAttributes = true,
Indent = true
};
Rss20FeedFormatter rssFormatter = new Rss20FeedFormatter(feed);
rssFormatter.SerializeExtensionsAsAtom = false;
using (var stream = new MemoryStream())
{
using (var writer = XmlWriter.Create(stream, settings))
{
rssFormatter.WriteTo(writer);
writer.Flush();
return(File(stream.ToArray(), "application/rss+xml; charset=utf-8"));
}
}
}
