public override void ExecuteResult(ControllerContext context)
{
context.HttpContext.Response.ContentType = "application/atom+xml";
var formatter = new Atom10FeedFormatter(Feed);
using (XmlWriter writer = XmlWriter.Create(context.HttpContext.Response.Output))
formatter.WriteTo(writer);
}
public void fload(string namefile)
{
var lines = System.IO.File.ReadAllLines(namefile);
feed.Title = new TextSyndicationContent(lines[1]);
feed.Copyright = new TextSyndicationContent(lines[2]);
feed.Description = new TextSyndicationContent(lines[3]);
feed.Generator = lines[4];
SyndicationLink link = new SyndicationLink();
link.Uri = new Uri(lines[5]);
feed.Links.Add(link);
feed.Items = txtgotolv("feedinfo.txt");
Response.Clear();
Response.ContentEncoding = System.Text.Encoding.UTF8;
Response.ContentType = "text/xml";
XmlWriter Writer = XmlWriter.Create
(Response.Output);
if (lines[0] == "rss")
{
Rss20FeedFormatter Formatter = new Rss20FeedFormatter(feed);
Formatter.WriteTo(Writer);
}
else
{
if (lines[0] == "atom")
{
Atom10FeedFormatter Formatter = new Atom10FeedFormatter(feed);
Formatter.WriteTo(Writer);
}
}
Writer.Close();
Response.End();
}
public string Build(FeedData dataFeed, Uri baseUri)
{
var feed = new SyndicationFeed
{
Id = dataFeed.Id.ToString(),
LastUpdatedTime = dataFeed.DateCreated,
Items = dataFeed.Messages.Select(x => new SyndicationItem
{
Content = new RawSyndicationContent(x.Body),
Id = x.Id.ToString(),
LastUpdatedTime = x.CreatedAt
})
};
if (!string.IsNullOrEmpty(dataFeed.NextUri))
feed.Links.Add(new SyndicationLink(new Uri(baseUri, dataFeed.NextUri), NextInArchiveRelationshipType,
"Next In Archive", ContentType, 0));
if (!string.IsNullOrEmpty(dataFeed.PreviousUri))
feed.Links.Add(new SyndicationLink(new Uri(baseUri, dataFeed.PreviousUri), PrevInArchiveRelationshipType,
"Previous In Archive", ContentType, 0));
var formatter = new Atom10FeedFormatter(feed);
var sw = new StringWriter();
using (var writer = XmlWriter.Create(sw))
{
formatter.WriteTo(writer);
}
return sw.ToString();
}
public override void ExecuteResult(ControllerContext context)
{
context.HttpContext.Response.ContentType = "application/atom+xml";
//check request is for Atom or RSS
if (context.HttpContext.Request.QueryString["type"] != null && context.HttpContext.Request.QueryString["type"].ToString().ToLower() == "atom")
{
//Atom Feed
context.HttpContext.Response.ContentType = "application/atom+xml";
var rssFormatter = new Atom10FeedFormatter(FeedData);
using (XmlWriter writer = XmlWriter.Create(context.HttpContext.Response.Output, new XmlWriterSettings { Indent = true }))
{
rssFormatter.WriteTo(writer);
}
}
else
{
//RSS Feed
context.HttpContext.Response.ContentType = "application/rss+xml";
var rssFormatter = new Rss20FeedFormatter(FeedData);
using (XmlWriter writer = XmlWriter.Create(context.HttpContext.Response.Output, new XmlWriterSettings { Indent = true }))
{
rssFormatter.WriteTo(writer);
}
}
}
//var formatter = new Rss20FeedFormatter(feed);
// Atom10FeedFormatter formatter = new Atom10FeedFormatter(feed);
//using (var writer = XmlWriter.Create(response.Output, new XmlWriterSettings { Indent = true }))
//{
// formatter.WriteTo(writer);
//}
protected override void WriteFile(HttpResponseBase response)
{
Atom10FeedFormatter formatter = new Atom10FeedFormatter(_feed);
using (XmlWriter writer = XmlWriter.Create(response.OutputStream, new XmlWriterSettings { Indent = true }))
{
formatter.WriteTo(writer);
}
}
private static Action<Stream> GetXmlContents(SyndicationFeed feed)
{
return stream =>
{
var writer = new XmlTextWriter(stream, Encoding.UTF8);
var atomFormatter = new Atom10FeedFormatter(feed);
atomFormatter.WriteTo(writer);
};
}
public override void OnWriteToStream(Type type, object value, Stream stream, HttpContentHeaders contentHeaders, TransportContext context)
{
var formatter = new Atom10FeedFormatter((SyndicationFeed) value);
using (var xmlWriter = XmlWriter.Create(stream))
{
formatter.WriteTo(xmlWriter);
xmlWriter.Close();
}
}
public static StreamContent CreateContentFromAtom10SyndicationFeed(SyndicationFeed feed)
{
SyndicationFeedFormatter formatter = new Atom10FeedFormatter<SyndicationFeed>(feed);
var memoryStream = new MemoryStream();
var settings = new XmlWriterSettings { Encoding = Encoding.UTF8, ConformanceLevel = ConformanceLevel.Document, Indent = true };
using (var xmlWriter = XmlWriter.Create(memoryStream, settings))
{
formatter.WriteTo(xmlWriter);
xmlWriter.Flush();
xmlWriter.Close();
}
memoryStream.Seek(0, SeekOrigin.Begin);
return new StreamContent(memoryStream);
}
protected override void WriteFile(HttpResponseBase response)
{
_isRssFeed = _feedType == FeedType.Rss;
// Creates Xml file.
string xmlFile = HttpContext.Current.Server.MapPath("~/feed.xml");
using (var fileStream = new FileStream(xmlFile, FileMode.Create))
{
using (var streamWriter = new StreamWriter(fileStream, Encoding.UTF8))
{
var xs = new XmlWriterSettings { Indent = true };
using (var xmlWriter = XmlWriter.Create(streamWriter, xs))
{
xmlWriter.WriteStartDocument();
if (_isCssStyles)
{
const string strPi = "type='text/css' href='/Contents/Styles/feedStyle.css'";
// Write processor information
xmlWriter.WriteProcessingInstruction("xml-stylesheet", strPi);
}
if (_isRssFeed)
{
// RSS 2.0
var rssFormatter = new Rss20FeedFormatter(_feed, true);
rssFormatter.WriteTo(xmlWriter);
}
else
{
// Atom 1.0
var atomFormatter = new Atom10FeedFormatter(_feed);
atomFormatter.WriteTo(xmlWriter);
}
}
}
}
//Display Xml file in browser.
response.Clear();
response.Buffer = true;
response.Charset = "";
response.Cache.SetCacheability(HttpCacheability.NoCache);
response.ContentType = "text/xml";
response.WriteFile(HttpContext.Current.Server.MapPath("~/feed.xml"));
response.Flush();
response.End();
}
/// <summary>
/// Executes the call to the ActionResult method and returns the created feed to the output response.
/// </summary>
/// <param name="context">The context in which the result is executed. The context information includes the
/// controller, HTTP content, request context, and route data.</param>
public override void ExecuteResult(ControllerContext context)
{
context.HttpContext.Response.ContentType = ContentType.Atom;
var feedFormatter = new Atom10FeedFormatter(this._syndicationFeed);
var xmlWriterSettings = new XmlWriterSettings {Encoding = Encoding.UTF8};
if (HttpContext.Current.IsDebuggingEnabled)
{
// Indent the XML for easier viewing but only in Debug mode. In Release mode, everything is output on
// one line for best performance.
xmlWriterSettings.Indent = true;
}
using (var xmlWriter = XmlWriter.Create(context.HttpContext.Response.Output, xmlWriterSettings))
{
feedFormatter.WriteTo(xmlWriter);
}
}
protected override void WriteFile(HttpResponseBase response)
{
_isRssFeed = _feedType == FeedType.Rss;
// Creates Xml file.
string xmlFile = HttpContext.Current.Server.MapPath("~/feed.xml");
using (var fileStream = new FileStream(xmlFile, FileMode.Create))
{
using (var streamWriter = new StreamWriter(fileStream, Encoding.UTF8))
{
var xs = new XmlWriterSettings { Indent = true };
using (var xmlWriter = XmlWriter.Create(streamWriter, xs))
{
xmlWriter.WriteStartDocument();
if (_isRssFeed)
{
// RSS 2.0
var rssFormatter = new Rss20FeedFormatter(_feed);
rssFormatter.WriteTo(xmlWriter);
}
else
{
// Atom 1.0
var atomFormatter = new Atom10FeedFormatter(_feed);
atomFormatter.WriteTo(xmlWriter);
}
}
}
}
XslTransform myXslTransform = new XslTransform();
myXslTransform.Load(HttpContext.Current.Server.MapPath("~/feed.xslt"));
myXslTransform.Transform(HttpContext.Current.Server.MapPath("~/feed.xml"), HttpContext.Current.Server.MapPath("~/newFeed.xml"));
//Display Xml file in browser.
response.Clear();
response.Buffer = true;
response.Charset = "";
response.Cache.SetCacheability(HttpCacheability.NoCache);
response.ContentType = "application/xml";
response.WriteFile(HttpContext.Current.Server.MapPath("~/newFeed.xml"));
response.Flush();
response.End();
}
/// <summary>
/// Executes the call to the ActionResult method and returns the created feed to the output response.
/// </summary>
/// <param name="context">The context in which the result is executed. The context information includes the
/// controller, HTTP content, request context, and route data.</param>
public override void ExecuteResult(ActionContext context)
{
context.HttpContext.Response.ContentType = ContentType.Atom;
Atom10FeedFormatter feedFormatter = new Atom10FeedFormatter(this.syndicationFeed);
XmlWriterSettings xmlWriterSettings = new XmlWriterSettings();
xmlWriterSettings.Encoding = Encoding.UTF8;
if (Context.Environment.IsDevelopment())
{
// Indent the XML for easier viewing but only in Debug mode. In Release mode, everything is output on
// one line for best performance.
xmlWriterSettings.Indent = true;
}
using (XmlWriter xmlWriter = XmlWriter.Create(context.HttpContext.Response.Body, xmlWriterSettings))
{
feedFormatter.WriteTo(xmlWriter);
}
}
public ActionResult Index()
{
var syndicationItems =
this.DB.Themes.Select(ToSyndicationItem)
.Concat(this.DB.Votes.Include("Theme").Select(ToSyndicationItem))
.OrderByDescending(s => s.LastUpdatedTime);
var feed = new SyndicationFeed(_Localize.SiteTitle, "", this.GetAppUrl(), syndicationItems.ToArray());
var formatter = new Atom10FeedFormatter(feed);
return new LamdaResult(context =>
{
var response = context.HttpContext.Response;
response.ContentType = "application/xml";
var xmlWriter = XmlWriter.Create(response.OutputStream);
formatter.WriteTo(xmlWriter);
xmlWriter.Flush();
});
}
public void try_it_out()
{
var doc = new XmlDocument().WithRoot("root").WithAtt("a", "1");
var feed = new SyndicationFeed("some feed", "cool feed", new Uri("http://elsewere.com"));
var item = new SyndicationItem("the title", "some content", new Uri("http://somewhere.com"));
item.ElementExtensions.Add(doc);
feed.Items = new SyndicationItem[]{item};
var builder = new StringBuilder();
var writer = XmlWriter.Create(builder);
var formatter = new Atom10FeedFormatter(feed);
formatter.WriteTo(writer);
writer.Close();
Debug.WriteLine(builder);
}
public override void ExecuteResult(ControllerContext context)
{
_isRssFeed = _feedType == FeedType.Rss;
context.HttpContext.Response.ContentType = _isRssFeed
? "application/rss+xml"
: "application/atom+xml";
var writerSettings = new XmlWriterSettings { Indent = true };
using (var feedWriter = XmlWriter.Create(context.HttpContext.Response.OutputStream, writerSettings))
{
if (_isRssFeed)
{
// RSS 2.0
var rssFormatter = new Rss20FeedFormatter(_feed);
rssFormatter.WriteTo(feedWriter);
}
else
{
var atomFormatter = new Atom10FeedFormatter(_feed);
atomFormatter.WriteTo(feedWriter);
}
}
}
public override void ExecuteResult(ControllerContext context)
{
SyndicationFeedFormatter formatter = null;
switch (Type) {
default:
case "rss":
context.HttpContext.Response.ContentType = "application/rss+xml";
formatter = new Rss20FeedFormatter(this.Feed);
break;
case "atom":
context.HttpContext.Response.ContentType = "application/atom+xml";
formatter = new Atom10FeedFormatter(this.Feed);
break;
}
using (XmlWriter writer = XmlWriter.Create(context.HttpContext.Response.Output)) {
formatter.WriteTo(writer);
}
}
private void BuildSyndicationFeed(object models, Stream stream, string contenttype)
{
List<SyndicationItem> items = new List<SyndicationItem>();
var feed = new SyndicationFeed()
{
Title = new TextSyndicationContent("My Feed")
};
if (models is IEnumerable<Product>)
{
var enumerator = ((IEnumerable<Product>)models).GetEnumerator();
while (enumerator.MoveNext())
{
items.Add(BuildSyndicationItem(enumerator.Current));
}
}
else
{
items.Add(BuildSyndicationItem((Product)models));
}
feed.Items = items;
using (XmlWriter writer = XmlWriter.Create(stream))
{
if (string.Equals(contenttype, atom))
{
Atom10FeedFormatter atomformatter = new Atom10FeedFormatter(feed);
atomformatter.WriteTo(writer);
}
else
{
Rss20FeedFormatter rssformatter = new Rss20FeedFormatter(feed);
rssformatter.WriteTo(writer);
}
}
}
private void BuildSyndicationFeed(Feed model, Stream stream, string contenttype)
{
XmlQualifiedName n = new XmlQualifiedName("media", "http://www.w3.org/2000/xmlns/");
List<SyndicationItem> items = new List<SyndicationItem>();
var feed = new SyndicationFeed()
{
Title = new TextSyndicationContent(model.Title),
};
feed.Links.Add(new SyndicationLink(new Uri(model.Url)));
feed.Authors.Add(new SyndicationPerson { Name = model.Host, Uri = String.Format("http://{0}", model.Host) });
feed.Categories.Add(new SyndicationCategory { Name = model.Category });
feed.AttributeExtensions.Add(n, medians);
var enumerator = model.Items.GetEnumerator();
while (enumerator.MoveNext())
{
items.Add(BuildSyndicationItem(enumerator.Current));
}
feed.Items = items;
using (XmlWriter writer = XmlWriter.Create(stream))
{
if (string.Equals(contenttype, atom))
{
Atom10FeedFormatter atomformatter = new Atom10FeedFormatter(feed);
atomformatter.WriteTo(writer);
}
else
{
Rss20FeedFormatter rssformatter = new Rss20FeedFormatter(feed);
rssformatter.WriteTo(writer);
}
}
}
public void ProcessRequest(HttpContext context)
{
if (!ProcessAuthorization(context))
{
AccessDenied(context);
return;
}
var productId = ParseGuid(context.Request[ProductParam]);
var product = WebItemManager.Instance[productId.GetValueOrDefault()];
var products = WebItemManager.Instance.GetItemsAll<IProduct>().ToDictionary(p => p.GetSysName());
var title = context.Request[TitleParam] ?? Resources.Resource.RecentActivity;
var lastModified = GetLastModified(context);
var feeds = FeedAggregateDataProvider.GetFeeds(new FeedApiFilter
{
Product = product != null ? product.GetSysName() : null,
From = lastModified ?? DateTime.UtcNow.AddDays(-14),
To = DateTime.UtcNow,
OnlyNew = true
})
.OrderByDescending(f => f.CreateOn)
.Take(100)
.Select(f => f.ToFeedMin())
.ToList();
if (lastModified != null && feeds.Count == 0)
{
context.Response.StatusCode = (int)HttpStatusCode.NotModified;
context.Response.StatusDescription = "Not Modified";
}
var feedItems = feeds.Select(f =>
{
var item = new SyndicationItem(
HttpUtility.HtmlDecode((products.ContainsKey(f.Product) ? products[f.Product].Name + ": " : string.Empty) + f.Title),
string.Empty,
new Uri(CommonLinkUtility.GetFullAbsolutePath(f.ItemUrl)),
f.Id,
new DateTimeOffset(TenantUtil.DateTimeToUtc(f.Date)))
{
PublishDate = f.Date,
};
if (f.Author != null && f.Author.UserInfo != null)
{
var u = f.Author.UserInfo;
item.Authors.Add(new SyndicationPerson(u.Email, u.DisplayUserName(false), CommonLinkUtility.GetUserProfile(u.ID)));
}
return item;
});
var lastUpdate = DateTime.UtcNow;
if (feeds.Count > 0)
{
lastUpdate = feeds.Max(x => x.Date);
}
var feed = new SyndicationFeed(
CoreContext.TenantManager.GetCurrentTenant().Name,
string.Empty,
new Uri(context.Request.GetUrlRewriter(), VirtualPathUtility.ToAbsolute("~/feed.aspx")),
TenantProvider.CurrentTenantID.ToString(),
new DateTimeOffset(lastUpdate),
feedItems);
var tenantSettings = SettingsManager.Instance.LoadSettings<TenantInfoSettings>(TenantProvider.CurrentTenantID);
var url = tenantSettings.GetAbsoluteCompanyLogoPath();
if (!string.IsNullOrEmpty(url))
{
feed.ImageUrl = new Uri(CommonLinkUtility.GetFullAbsolutePath(url));
}
var rssFormatter = new Atom10FeedFormatter(feed);
var settings = new XmlWriterSettings
{
CheckCharacters = false,
ConformanceLevel = ConformanceLevel.Document,
Encoding = Encoding.UTF8,
Indent = true,
};
using (var writer = XmlWriter.Create(context.Response.Output, settings))
{
rssFormatter.WriteTo(writer);
}
context.Response.Charset = Encoding.UTF8.WebName;
context.Response.ContentType = "application/atom+xml";
context.Response.AddHeader("ETag", DateTime.UtcNow.ToString("yyyyMMddHHmmss"));
context.Response.AddHeader("Last-Modified", DateTime.UtcNow.ToString("R"));
}
/// <summary>
/// The page_ load.
/// </summary>
/// <param name="sender">
/// The sender.
/// </param>
/// <param name="e">
/// The e.
/// </param>
protected void Page_Load([NotNull] object sender, [NotNull] EventArgs e)
{
// Put user code to initialize the page here
if (!(this.Get<YafBoardSettings>().ShowRSSLink || this.Get<YafBoardSettings>().ShowAtomLink))
{
YafBuildLink.RedirectInfoPage(InfoMessage.AccessDenied);
}
// Atom feed as variable
bool atomFeedByVar = this.Request.QueryString.GetFirstOrDefault("ft")
== YafSyndicationFormats.Atom.ToInt().ToString();
YafSyndicationFeed feed = null;
// var syndicationItems = new List<SyndicationItem>();
string lastPostIcon = BaseUrlBuilder.BaseUrl
+ this.PageContext.CurrentForumPage.GetThemeContents("ICONS", "ICON_NEWEST");
string lastPostName = this.GetText("DEFAULT", "GO_LAST_POST");
YafRssFeeds feedType;
try
{
feedType = this.Get<HttpRequestBase>().QueryString.GetFirstOrDefault("pg").ToEnum<YafRssFeeds>(true);
}
catch
{
// default to Forum Feed.
feedType = YafRssFeeds.Forum;
}
switch (feedType)
{
// Latest posts feed
case YafRssFeeds.LatestPosts:
if (
!(this.Get<YafBoardSettings>().ShowActiveDiscussions
&& this.Get<IPermissions>().Check(this.Get<YafBoardSettings>().PostLatestFeedAccess)))
{
YafBuildLink.AccessDenied();
}
this.GetPostLatestFeed(ref feed, feedType, atomFeedByVar, lastPostIcon, lastPostName);
break;
// Latest Announcements feed
case YafRssFeeds.LatestAnnouncements:
if (!this.Get<IPermissions>().Check(this.Get<YafBoardSettings>().ForumFeedAccess))
{
YafBuildLink.AccessDenied();
}
this.GetLatestAnnouncementsFeed(ref feed, feedType, atomFeedByVar);
break;
// Posts Feed
case YafRssFeeds.Posts:
if (
!(this.PageContext.ForumReadAccess
&& this.Get<IPermissions>().Check(this.Get<YafBoardSettings>().PostsFeedAccess)))
{
YafBuildLink.AccessDenied();
}
if (this.Get<HttpRequestBase>().QueryString.GetFirstOrDefault("t") != null)
{
int topicId;
if (int.TryParse(this.Get<HttpRequestBase>().QueryString.GetFirstOrDefault("t"), out topicId))
{
this.GetPostsFeed(ref feed, feedType, atomFeedByVar, topicId);
}
}
break;
// Forum Feed
case YafRssFeeds.Forum:
if (!this.Get<IPermissions>().Check(this.Get<YafBoardSettings>().ForumFeedAccess))
{
YafBuildLink.AccessDenied();
}
object categoryId = null;
if (this.Get<HttpRequestBase>().QueryString.GetFirstOrDefault("c") != null)
{
int icategoryId;
if (int.TryParse(
this.Get<HttpRequestBase>().QueryString.GetFirstOrDefault("c"), out icategoryId))
{
categoryId = icategoryId;
}
}
this.GetForumFeed(ref feed, feedType, atomFeedByVar, categoryId);
break;
// Topics Feed
case YafRssFeeds.Topics:
if (
!(this.PageContext.ForumReadAccess
&& this.Get<IPermissions>().Check(this.Get<YafBoardSettings>().TopicsFeedAccess)))
{
YafBuildLink.AccessDenied();
}
if (this.Get<HttpRequestBase>().QueryString.GetFirstOrDefault("f") != null)
{
int forumId;
if (int.TryParse(this.Get<HttpRequestBase>().QueryString.GetFirstOrDefault("f"), out forumId))
{
this.GetTopicsFeed(ref feed, feedType, atomFeedByVar, lastPostIcon, lastPostName, forumId);
}
}
break;
// Active Topics
case YafRssFeeds.Active:
if (!this.Get<IPermissions>().Check(this.Get<YafBoardSettings>().ActiveTopicFeedAccess))
{
YafBuildLink.AccessDenied();
}
int categoryActiveIntId;
object categoryActiveId = null;
if (this.Get<HttpRequestBase>().QueryString.GetFirstOrDefault("f") != null
&&
int.TryParse(
this.Get<HttpRequestBase>().QueryString.GetFirstOrDefault("f"), out categoryActiveIntId))
{
categoryActiveId = categoryActiveIntId;
}
this.GetActiveFeed(ref feed, feedType, atomFeedByVar, lastPostIcon, lastPostName, categoryActiveId);
break;
case YafRssFeeds.Favorite:
if (!this.Get<IPermissions>().Check(this.Get<YafBoardSettings>().FavoriteTopicFeedAccess))
{
YafBuildLink.AccessDenied();
}
int categoryFavIntId;
object categoryFavId = null;
if (this.Get<HttpRequestBase>().QueryString.GetFirstOrDefault("f") != null
&&
int.TryParse(
this.Get<HttpRequestBase>().QueryString.GetFirstOrDefault("f"), out categoryFavIntId))
{
categoryFavId = categoryFavIntId;
}
this.GetFavoriteFeed(ref feed, feedType, atomFeedByVar, lastPostIcon, lastPostName, categoryFavId);
break;
default:
YafBuildLink.AccessDenied();
break;
}
// update the feed with the item list...
// the list should be added after all other feed properties are set
if (feed != null)
{
var writer = new XmlTextWriter(this.Response.OutputStream, Encoding.UTF8);
writer.WriteStartDocument();
// write the feed to the response writer);
if (!atomFeedByVar)
{
var rssFormatter = new Rss20FeedFormatter(feed);
rssFormatter.WriteTo(writer);
this.Response.ContentType = "application/rss+xml";
}
else
{
var atomFormatter = new Atom10FeedFormatter(feed);
atomFormatter.WriteTo(writer);
this.Response.ContentType = "application/atom+xml";
}
writer.WriteEndDocument();
writer.Close();
this.Response.ContentEncoding = Encoding.UTF8;
this.Response.Cache.SetCacheability(HttpCacheability.Public);
this.Response.End();
}
else
{
YafBuildLink.RedirectInfoPage(InfoMessage.AccessDenied);
}
}
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 void WriteAtomFeed(IPublicationFeed feed, Stream writeStream)
{
var formatter = new Atom10FeedFormatter(feed.Syndicate());
using (var writer = XmlWriter.Create(writeStream))
{
formatter.WriteTo(writer);
}
}
public static void PublishFeed()
{
string baseUrl = "http://dealschain.com";
SyndicationFeed feed = new SyndicationFeed();
feed.Id = "http://dealschain.com";
// set some properties on the feed
feed.Title = new TextSyndicationContent("Feed Research");
feed.Description = new TextSyndicationContent("Example Feed");
feed.Copyright = new TextSyndicationContent("Sted");
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 = "Deals Chain";
// Add the URL that will link to your published feed when it's done
SyndicationLink link = new SyndicationLink(new Uri("http://dealschain.com" + "Feeds/myfeed.xml"));
link.RelationshipType = "self";
link.MediaType = "text/html";
link.Title = "Test Feed";
feed.Links.Add(link);
// Add your site link
link = new SyndicationLink(new Uri(baseUrl));
link.MediaType = "text/html";
link.Title = "Deals Chain";
feed.Links.Add(link);
List<SyndicationItem> items = new List<SyndicationItem>();
int maxItems = 3;
for (int i = 0; i < maxItems; i++)
{
// create new entry for feed
SyndicationItem item = new SyndicationItem();
// set the entry id to the URL for the item
string url = "http://google.com";
item.Id = url;
// Add the URL for the item as a link
link = new SyndicationLink(new Uri(url));
item.Links.Add(link);
// Fill some properties for the item
item.Title = new TextSyndicationContent("This is a tile");
item.LastUpdatedTime = DateTime.Now;
item.PublishDate = DateTime.Now;
// Fill the item content
string html = "<b>Hi There<b/>"; // 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);
}
feed.Items = items;
string mainFile = HttpContext.Current.Server.MapPath("~/Feeds/TestFeed.xml");
using (FileStream fs = new FileStream(mainFile, FileMode.OpenOrCreate))
{
using (StreamWriter w = new StreamWriter(fs, Encoding.UTF8))
{
XmlWriterSettings xs = new XmlWriterSettings();
xs.Indent = true;
using (XmlWriter xw = XmlWriter.Create(w, xs))
{
xw.WriteStartDocument();
Atom10FeedFormatter formatter = new Atom10FeedFormatter(feed);
//Rss20FeedFormatter formatter = new Rss20FeedFormatter(feed);
formatter.WriteTo(xw);
xw.Close();
}
}
}
}
/// <summary>
/// Prints the rules to an XML file called rules.xml in the current dir.
/// This was a real pain to get working correctly.
/// </summary>
/// <param name="rules"></param>
public static void PrintXML(List<MyRule> rules, string filename)
{
SyndicationFeed feed = new SyndicationFeed();
XmlQualifiedName key = new XmlQualifiedName("apps", "http://www.w3.org/2000/xmlns/");
String googleNs = "http://schemas.google.com/apps/2006";
feed.AttributeExtensions.Add(key, googleNs);
List<SyndicationItem> feedItems = new List<SyndicationItem>();
foreach (MyRule r in rules)
{
SyndicationItem atom = new SyndicationItem();
atom.Title = new TextSyndicationContent(r.FromAddress, TextSyndicationContentKind.Plaintext);
atom.Categories.Add(new SyndicationCategory("filter"));
atom.Content = new TextSyndicationContent(String.Empty);
//atom.ElementExtensions.Add(new SyndicationElementExtension("property", googleNs, ""));
XName n = XName.Get("property", googleNs);
// conditions
bool conditionSet = false;
if (!String.IsNullOrEmpty(r.FromAddress))
{
XElement el1a = new XElement(n);
XAttribute at1a = new XAttribute("name", "from");
el1a.Add(at1a);
XAttribute at1b = new XAttribute("value", r.FromAddress);
el1a.Add(at1b);
atom.ElementExtensions.Add(el1a);
conditionSet = true;
}
if (!String.IsNullOrEmpty(r.Subject))
{
XElement el4a = new XElement(n);
XAttribute at4a = new XAttribute("name", "subject");
el4a.Add(at4a);
XAttribute at4b = new XAttribute("value", r.Subject);
el4a.Add(at4b);
atom.ElementExtensions.Add(el4a);
conditionSet = true;
}
if (!String.IsNullOrEmpty(r.HasTheWord))
{
XElement el4a = new XElement(n);
XAttribute at4a = new XAttribute("name", "hasTheWord");
el4a.Add(at4a);
XAttribute at4b = new XAttribute("value", r.HasTheWord);
el4a.Add(at4b);
atom.ElementExtensions.Add(el4a);
conditionSet = true;
}
// actions - only apply if a condition has been set
if (conditionSet)
{
if (!String.IsNullOrEmpty(r.Label))
{
XElement el2a = new XElement(n);
XAttribute at2a = new XAttribute("name", "label");
el2a.Add(at2a);
XAttribute at2b = new XAttribute("value", r.Label);
el2a.Add(at2b);
atom.ElementExtensions.Add(el2a);
}
if (r.ShouldArchive)
{
XElement el3a = new XElement(n);
XAttribute at3a = new XAttribute("name", "shouldArchive");
el3a.Add(at3a);
XAttribute at3b = new XAttribute("value", r.ShouldArchive.ToString());
el3a.Add(at3b);
atom.ElementExtensions.Add(el3a);
}
feedItems.Add(atom);
}
}
feed.Items = feedItems;
StreamWriter sw = new StreamWriter(filename);
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
settings.IndentChars = "\t";
XmlWriter xw = XmlWriter.Create(sw, settings);
Atom10FeedFormatter atomFormatter = new Atom10FeedFormatter(feed);
atomFormatter.WriteTo(xw);
xw.Flush();
xw.Close();
}
/// <summary>
/// Handles the Load event of the Page control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
protected void Page_Load(object sender, EventArgs e)
{
var channelId = 0;
// Determine the maximum number of items to show in the feed
if (Request.QueryString["pid"] != null)
_projectId = Convert.ToInt32(Request.Params["pid"]);
//get feed id
if (Request.QueryString["channel"] != null)
channelId = Convert.ToInt32(Request.Params["channel"]);
if (!User.Identity.IsAuthenticated && _projectId == 0)
{
throw new HttpException(403, "Access Denied");
}
if (_projectId != 0)
{
//Security Checks
if (!User.Identity.IsAuthenticated &&
ProjectManager.GetById(_projectId).AccessType == ProjectAccessType.Private)
{
throw new HttpException(403, "Access Denied");
}
if (User.Identity.IsAuthenticated &&
ProjectManager.GetById(_projectId).AccessType == ProjectAccessType.Private &&
!ProjectManager.IsUserProjectMember(User.Identity.Name, _projectId))
{
throw new HttpException(403, "Access Denied");
}
}
// Determine whether we're outputting an Atom or RSS feed
var outputRss = (Request.QueryString["Type"] == "RSS");
var outputAtom = !outputRss;
// Output the appropriate ContentType
Response.ContentType = outputRss ? "application/rss+xml" : "application/atom+xml";
// Create the feed and specify the feed's attributes
var myFeed = new SyndicationFeed();
myFeed.Links.Add(SyndicationLink.CreateAlternateLink(new Uri(GetFullyQualifiedUrl("~/Default.aspx"))));
myFeed.Links.Add(SyndicationLink.CreateSelfLink(new Uri(GetFullyQualifiedUrl(Request.RawUrl))));
myFeed.Language = "en-us";
switch (channelId)
{
case 1:
MilestoneFeed(ref myFeed);
break;
case 2:
CategoryFeed(ref myFeed);
break;
case 3:
StatusFeed(ref myFeed);
break;
case 4:
PriorityFeed(ref myFeed);
break;
case 5:
TypeFeed(ref myFeed);
break;
case 6:
AssigneeFeed(ref myFeed);
break;
case 7:
FilteredIssuesFeed(ref myFeed);
break;
case 8:
RelevantFeed(ref myFeed);
break;
case 9:
AssignedFeed(ref myFeed);
break;
case 10:
OwnedFeed(ref myFeed);
break;
case 11:
CreatedFeed(ref myFeed);
break;
case 12:
AllIssuesFeed(ref myFeed);
break;
case 13:
QueryFeed(ref myFeed);
break;
case 14:
OpenIssueFeed(ref myFeed);
break;
case 15:
MonitoredFeed(ref myFeed);
break;
case 16:
ClosedFeed(ref myFeed);
break;
}
// Return the feed's XML content as the response
var outputSettings = new XmlWriterSettings {Indent = true};
//(Uncomment for readability during testing)
var feedWriter = XmlWriter.Create(Response.OutputStream, outputSettings);
if (outputAtom)
{
// Use Atom 1.0
var atomFormatter = new Atom10FeedFormatter(myFeed);
atomFormatter.WriteTo(feedWriter);
}
else
{
// Emit RSS 2.0
var rssFormatter = new Rss20FeedFormatter(myFeed);
rssFormatter.WriteTo(feedWriter);
}
feedWriter.Close();
}
private void BuildSyndicationFeed(IFeed feed, Stream stream, String contenttype)
{
var atomFeed = new SyndicationFeed()
{
Title = new TextSyndicationContent(feed.Link.Title),
Id = feed.Link.Href,
LastUpdatedTime = new DateTimeOffset(DateTime.UtcNow)
};
var feedUri = new Uri(feed.Link.Href);
atomFeed.Links.Add(
new SyndicationLink
{
Title = feed.Link.Title,
Uri = feedUri,
RelationshipType = feed.Link.Rel,
MediaType = ATOM_CONTENT_TYPE
});
// Add parent, related, tag links to AtomFeed
var navigationLinks = new List<LinkItem>();
// if (feed.Parent != null) { navigationLinks.Add(feed.Parent); }
// if (feed.Related != null) { navigationLinks.AddRange(feed.Related); }
// if (feed.Tags != null) { navigationLinks.AddRange(feed.Tags); }
// if (feed.Children != null) { navigationLinks.AddRange(feed.Children); }
// if (feed.Static != null) { navigationLinks.AddRange(feed.Static); }
// Add pagination information if exist
if (feed is IPaginatedFeed)
{
var paginatedFeed = feed as IPaginatedFeed;
if (paginatedFeed.FirstLink != null) { navigationLinks.Add(paginatedFeed.FirstLink); }
if (paginatedFeed.LastLink != null) { navigationLinks.Add(paginatedFeed.LastLink); }
if (paginatedFeed.NextLink != null) { navigationLinks.Add(paginatedFeed.NextLink); }
if (paginatedFeed.PreviousLink != null) { navigationLinks.Add(paginatedFeed.PreviousLink); }
}
foreach (var link in navigationLinks)
{
atomFeed.Links.Add(
new SyndicationLink
{
Title = link.Title,
Uri = new Uri(link.Href),
RelationshipType = link.Rel,
MediaType = ATOM_CONTENT_TYPE
});
}
var items = new List<SyndicationItem>();
if (feed.Entries is IEnumerable)
{
foreach (var item in feed.Entries)
{
var syndicationItem = _switchOnType[item.Content.GetType()](item.Content, item.Link, null);
items.Add(syndicationItem);
}
}
else
{
var syndicationItem = _switchOnType[feed.Entries.GetType()](feed.Entries, feed.Link, null);
items.Add(syndicationItem);
}
atomFeed.Items = items;
using (var writer = XmlWriter.Create(stream))
{
Atom10FeedFormatter atomformatter = new Atom10FeedFormatter(atomFeed);
atomformatter.WriteTo(writer);
}
}
/// <summary>
/// Returns and rss or atom feed
/// </summary>
/// <param name="instance"></param>
/// <returns></returns>
protected internal ActionResult GetFeed(object instance)
{
try
{
string title = "CodePaste.NET";
string action = RouteData.Values["listAction"] as string;
if (string.IsNullOrEmpty(action))
action = RouteData.Values["Action"] as string ?? string.Empty;
action = action.ToLower();
if (action == "recent")
title = "CodePaste.NET Recent Snippets";
else if (action == "mysnippets")
title = "CodePaste.NET - My Snippets";
SyndicationFeed feed = new SyndicationFeed(title, "Paste and Link .NET Code", new Uri(Request.Url.AbsoluteUri));
feed.BaseUri = new Uri("http://codepaste.net/recent");
feed.LastUpdatedTime = DateTime.Now;
List<SyndicationItem> feedItems = new List<SyndicationItem>();
foreach (CodeSnippetListItem item in (IEnumerable)instance)
{
// remove lower ascii characters (< 32 exclude 9,10,13)
string code = Regex.Replace(item.Code, @"[\u0000-\u0008,\u000B,\u000C,\u000E-\u001F]", "");
SyndicationItem rssItem = new SyndicationItem()
{
Id = item.Id,
Title = SyndicationContent.CreateHtmlContent(item.Title),
Content = SyndicationContent.CreateHtmlContent(
//"<link href=\"" + WebUtils.ResolveServerUrl("~/css/csharp.css") + "\" rel=\"stylesheet\" type=\"text/css\">\r\n <style type='text/css'>.kwrd { color: blue; font-weight: bold }</style>\r\n" +
"<pre>\r\n" +
HtmlUtils.HtmlEncode(code) +
//snippet.GetFormattedCode(item.Code, item.Language, item.ShowLineNumbers) +
"</pre>"),
PublishDate = item.Entered,
};
if (!string.IsNullOrEmpty(item.Author))
rssItem.Authors.Add(new SyndicationPerson("", item.Author, null));
rssItem.Links.Add(new SyndicationLink(new Uri(WebUtils.GetFullApplicationPath() + "/" + item.Id),
"alternate", item.Title, "text/html", 1000));
feedItems.Add(rssItem);
}
feed.Items = feedItems;
MemoryStream ms = new MemoryStream();
var settings = new XmlWriterSettings()
{
CheckCharacters = false
};
XmlWriter writer = XmlWriter.Create(ms,settings);
if (Format == "rss")
{
Rss20FeedFormatter rssFormatter = new Rss20FeedFormatter(feed);
rssFormatter.WriteTo(writer);
}
else
{
Atom10FeedFormatter atomFormatter = new Atom10FeedFormatter(feed);
atomFormatter.WriteTo(writer);
}
writer.Flush();
ms.Position = 0;
return Content(Encoding.UTF8.GetString(ms.ToArray()), "application/xml");
}
catch (Exception ex)
{
Response.Write(HtmlUtils.DisplayMemo("Error: " + ex.GetBaseException().Message + "\r\n" + ex.StackTrace));
Response.End();
return null;
}
return null;
}
/// <summary>
/// Builds the syndication feed.
/// </summary>
/// <param name="models">Object or list of objects to be serialized.</param>
/// <param name="stream">Output stream</param>
/// <param name="contentType">Determines if the output should be formatted as Atom or RSS.</param>
public void BuildSyndicationFeed(object models, Stream stream, string contentType)
{
if (null == models)
{
Trace.WriteLine("No Models supplied. Feed is empty.");
return;
}
if (null == stream)
throw new ArgumentNullException("stream");
List<SyndicationItem> items = new List<SyndicationItem>();
var feed = new SyndicationFeed
{
Title = new TextSyndicationContent("Reports")
};
if (models is IEnumerable<ISyndicationItemSerializable>)
{
var enumerator = ((IEnumerable<ISyndicationItemSerializable>)models).GetEnumerator();
while (enumerator.MoveNext())
{
items.Add(enumerator.Current.BuildSyndicationItem());
}
}
else if (models is ISyndicationItemSerializable)
{
items.Add(((ISyndicationItemSerializable)models).BuildSyndicationItem());
}
var xModels = models as XElement;
if (models != null)
{
foreach(var child in xModels.Elements() )
{
var item = new SyndicationItem();
foreach (var node in child.Elements())
{
item.ElementExtensions.Add(node);
}
items.Add(item);
//items.Add(new SyndicationItem { Content = new TextSyndicationContent( child.ToString()), Title = new TextSyndicationContent( child.Elements().First().Value)});
}
}
feed.Items = items;
using (XmlWriter writer = XmlWriter.Create(stream))
{
if (string.Equals(contentType, atom))
{
Atom10FeedFormatter atomFormatter = new Atom10FeedFormatter(feed);
atomFormatter.WriteTo(writer);
}
else
{
Rss20FeedFormatter rssFormatter = new Rss20FeedFormatter(feed);
rssFormatter.WriteTo(writer);
}
}
}
/// <summary>
/// Builds the syndication feed from the specified <paramref name="album" /> and write it to the <paramref name="stream" />.
/// </summary>
/// <param name="album">The album from which to build the syndication feed.</param>
/// <param name="stream">The <see cref="T:System.IO.Stream" /> to which to write.</param>
/// <param name="contentType">Type of the requested content. Examples: "application/atom+xml", "application/rss+xml"</param>
/// <param name="moBuilderOptions">The options that direct the creation of HTML and URLs for a media object.</param>
private static void BuildSyndicationFeed(IAlbum album, Stream stream, string contentType, MediaObjectHtmlBuilderOptions moBuilderOptions)
{
var fb = new AlbumSyndicationFeedBuilder(album, moBuilderOptions);
var feed = fb.Generate();
using (var writer = XmlWriter.Create(stream))
{
if (String.Equals(contentType, AtomMediaType, StringComparison.InvariantCultureIgnoreCase))
{
var atomFormatter = new Atom10FeedFormatter(feed);
atomFormatter.WriteTo(writer);
}
else
{
var rssFormatter = new Rss20FeedFormatter(feed);
rssFormatter.WriteTo(writer);
}
}
}
private static void WriteToAtomFormatter(ControllerContext context, SyndicationFeed feed)
{
var atomFormatter = new Atom10FeedFormatter(feed);
using (var writer = XmlWriter.Create(context.HttpContext.Response.Output))
{
atomFormatter.WriteTo(writer);
}
}
