public List<BannerItem> FbItems()
{
Atom10FeedFormatter formatter = new Atom10FeedFormatter();
using (XmlReader reader = XmlReader.Create(ConfigurationManager.AppSettings["FacebookFeed"]))
{
formatter.ReadFrom(reader);
}
var bannerItems = new List<BannerItem>();
foreach (var e in formatter.Feed.Items)
{
if (!e.Title.Text.StartsWith("Wallflux"))
{
BannerItem le = new BannerItem();
le.title = e.Title.Text;
le.content = new entryContent
{
Value = ((TextSyndicationContent)e.Content).Text
};
le.link = new entryLink
{
href = e.Id,
target = "_blank"
};
le.updated = e.LastUpdatedTime.DateTime.ToShortDateString();
le.published = "Published on facebook "+e.PublishDate.DateTime.ToShortDateString();
le.TypeOfContent = Enum.GetName(typeof(TypeOfContent), TypeOfContent.FacebookPost);
bannerItems.Add(le);
}
}
return bannerItems;
/* sparas, extrahera bilder
List<RssFeedItem> rssItems = new List<RssFeedItem>();
Stream stream = e.Result;
XmlReader response = XmlReader.Create(stream);
SyndicationFeed feeds = SyndicationFeed.Load(response);
foreach (SyndicationItem f in feeds.Items)
{
RssFeedItem rssItem = new RssFeedItem();
rssItem.Description = f.Summary.Text;
const string rx = @"(?<=img\s+src\=[\x27\x22])(?<Url>[^\x27\x22]*)(?=[\x27\x22])";
foreach (Match m in Regex.Matches(f.Summary.Text, rx, RegexOptions.IgnoreCase | RegexOptions.Multiline))
{
string src = m.Groups[1].Value;
if (src.StartsWith("//")) // Google RSS has it
{
src = src.Replace("//", "http://");
}
rssItem.ImageLinks.Add(src);
}
*/
}
public FeedData Build(string data, string url)
{
var formatter = new Atom10FeedFormatter();
using (var reader = new StringReader(data))
{
using (var xmlReader = XmlReader.Create(reader))
{
formatter.ReadFrom(xmlReader);
var feed = formatter.Feed;
return new FeedData
{
Id = Guid.Parse(feed.Id),
DateCreated = feed.LastUpdatedTime.UtcDateTime,
PreviousUri = GetUriFromLink(PrevInArchiveRelationshipType, feed),
NextUri = GetUriFromLink(NextInArchiveRelationshipType, feed),
Messages = feed.Items.Select(x =>
{
return new Message
{
Body = GetXmlString(x),
CreatedAt = x.LastUpdatedTime.UtcDateTime,
Id = Guid.Parse(x.Id),
FeedUri = url
};
}).ToArray()
};
}
}
}
public static IList<Feed> GetFeeds()
{
var urls = new[]
{
"http://www.simplyvinay.com/GetBlogRss.aspx", "http://www.bbc.co.uk/blogs/formula1/rss.xml",
"http://feeds.feedburner.com/AyendeRahien"
};
var list = new List<Feed>();
foreach (var url in urls)
{
using (var reader = new CustomXmlReader(url))
{
if (reader.ReadState == ReadState.Initial)
reader.MoveToContent();
var atom = new Atom10FeedFormatter();
if (atom.CanRead(reader))
{
atom.ReadFrom(reader);
list.AddRange(GenerateFeed(atom.Feed, true));
}
var rss = new Rss20FeedFormatter();
if (rss.CanRead(reader))
{
rss.ReadFrom(reader);
list.AddRange(GenerateFeed(rss.Feed, false));
}
}
}
return list;
}
private static UpdateCheck CheckForUpdates(string feedUrl, Version currentVersion)
{
var r = new UpdateCheck();
r.Message = "";
// NOTE: Requires a reference to System.ServiceModel.dll
var formatter = new Atom10FeedFormatter();
try
{
// Read the feed
using (var reader = System.Xml.XmlReader.Create(feedUrl))
{
formatter.ReadFrom(reader);
var latest = (from i in formatter.Feed.Items
where i.Categories.Any(c => IsStable(c.Name))
orderby i.LastUpdatedTime descending
select i).FirstOrDefault();
if (latest != null)
{
var u = latest.Links.Single().Uri.AbsoluteUri;
r.Message += String.Format("The latest release is: {0}\n", u);
var update = (from i in formatter.Feed.Items
where ExtractVersion(i.Title.Text) > currentVersion &&
i.Categories.Any(c => IsStable(c.Name))
orderby i.LastUpdatedTime descending
select i).FirstOrDefault();
if (update != null)
{
// TODO: Notify user of available download
var downloadUrl = update.Links.Single().Uri.AbsoluteUri;
r.Message += String.Format("There is an available update: {0}",
update.Title.Text);
r.UpdateAvailable = true;
}
else
{
r.Message += "There is no later version.";
}
}
else
{
r.Message += "Could not find a later version.";
}
}
}
catch (System.Exception exc1)
{
r.Message += "Cannot check for updates. " + exc1.ToString();
}
return r;
}
public static void AtomFeed()
{
Atom10FeedFormatter formatter = new Atom10FeedFormatter();
using (XmlReader reader = XmlReader.Create("https://www.wunschliste.de/xml/atom.pl?user_id=1125047&key=1355167046072"))
{
formatter.ReadFrom(reader);
}
foreach (SyndicationItem item in formatter.Feed.Items)
{
//Console.WriteLine("[{0}][{1}] {2}", item.PublishDate, item.Title.Text, ((TextSyndicationContent)item.Content).Text);
}
Console.ReadLine();
}
internal static TSyndicationFeed LoadFeed <TSyndicationFeed> (XmlReader reader) where TSyndicationFeed : SyndicationFeed, new()
{
switch (DetectVersion(reader, ReaderKind.Feed))
{
case SyndicationVersions.Atom10:
Atom10FeedFormatter af = new Atom10FeedFormatter <TSyndicationFeed> ();
af.ReadFrom(reader);
return((TSyndicationFeed)af.Feed);
case SyndicationVersions.Rss20:
default: // anything else are rejected by DetectVersion
Rss20FeedFormatter rf = new Rss20FeedFormatter <TSyndicationFeed> ();
rf.ReadFrom(reader);
return((TSyndicationFeed)rf.Feed);
}
}
public async Task<Update> CheckForUpdatesAsync(string updateUrl, UpdateFilter updateFilter)
{
Contract.Requires(!String.IsNullOrWhiteSpace(updateUrl));
var reader = XmlReader.Create(updateUrl);
var formatter = new Atom10FeedFormatter();
await Task.Factory.StartNew(() => formatter.ReadFrom(reader));
return (from i in formatter.Feed.Items
let u = UpdateHelper.FromSyndicationItem(i)
where u.Version > Assembly.GetExecutingAssembly().GetName().Version
&& ((int)updateFilter & (int)u.ReleaseStatus) != 0
orderby u.LastUpdatedTime descending
select u).FirstOrDefault();
}
SyndicationFeed ReadSourceFeed(XmlReader reader)
{
SyndicationFeed feed = null;
if (!reader.IsEmptyElement)
{
reader.Read();
Atom10FeedFormatter ff = new Atom10FeedFormatter();
ff.ReadFrom(reader);
feed = ff.Feed;
}
else
{
feed = new SyndicationFeed();
}
reader.Read(); // </source> or <source ... />
return(feed);
}
private static void ReadFeed(string feedUrl)
{
Atom10FeedFormatter formatter = new Atom10FeedFormatter();
using (XmlReader reader = XmlReader.Create(feedUrl))
{
formatter.ReadFrom(reader);
}
foreach (SyndicationItem item in formatter.Feed.Items)
{
Console.WriteLine("[{0}][{1}]", item.PublishDate, item.Title.Text);
}
var prevArchive = formatter.Feed.Links.FirstOrDefault(l => l.RelationshipType == "prev-archive");
if (prevArchive != null)
{
ReadFeed(prevArchive.Uri.ToString());
}
}
public static TSyndicationFeed Load <TSyndicationFeed>(XmlReader reader) where TSyndicationFeed : SyndicationFeed, new()
{
if (reader == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader");
}
Atom10FeedFormatter <TSyndicationFeed> formatter = new Atom10FeedFormatter <TSyndicationFeed>();
if (formatter.CanRead(reader))
{
formatter.ReadFrom(reader);
return(formatter.Feed as TSyndicationFeed);
}
Rss20FeedFormatter <TSyndicationFeed> formatter2 = new Rss20FeedFormatter <TSyndicationFeed>();
if (!formatter2.CanRead(reader))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(System.ServiceModel.SR.GetString("UnknownFeedXml", new object[] { reader.LocalName, reader.NamespaceURI })));
}
formatter2.ReadFrom(reader);
return(formatter2.Feed as TSyndicationFeed);
}
public static TSyndicationFeed Load <TSyndicationFeed>(XmlReader reader)
where TSyndicationFeed : SyndicationFeed, new()
{
if (reader == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader");
}
Atom10FeedFormatter <TSyndicationFeed> atomSerializer = new Atom10FeedFormatter <TSyndicationFeed>();
if (atomSerializer.CanRead(reader))
{
atomSerializer.ReadFrom(reader);
return(atomSerializer.Feed as TSyndicationFeed);
}
Rss20FeedFormatter <TSyndicationFeed> rssSerializer = new Rss20FeedFormatter <TSyndicationFeed>();
if (rssSerializer.CanRead(reader))
{
rssSerializer.ReadFrom(reader);
return(rssSerializer.Feed as TSyndicationFeed);
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.Format(SR.UnknownFeedXml, reader.LocalName, reader.NamespaceURI)));
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
var MemCache = MemoryCache.Default;
var Tasks = (IEnumerable<ServiceTask>)MemCache.Get("TaskList");
if (Tasks == null)
{
var formatter = new Atom10FeedFormatter();
using (XmlReader reader = XmlReader.Create(ConfigurationManager.AppSettings["ServiceApiUrl"]))
{
formatter.ReadFrom(reader);
}
MemCache.Add("Organisation", formatter.Feed.Authors.First().Name, new CacheItemPolicy {});
var Items = formatter.Feed.Items.Select(i => new ServiceTask
{
CategoryId = i.Categories.First().Name,
CategoryName = i.Categories.First().Label,
Content = ((TextSyndicationContent)i.Content).Text,
Details = i.Links.Where(l => l.RelationshipType == "self" && l.MediaType == "application/atom+xml").SingleOrDefault().Uri,
Id = i.Id,
Summary = i.Summary.Text,
Title = i.Title.Text,
Updated = i.LastUpdatedTime.DateTime
});
MemCache.Add("TaskList", Items, new CacheItemPolicy { });
}
}
public void ReadFrom_WrongDate ()
{
Atom10FeedFormatter f = new Atom10FeedFormatter ();
f.ReadFrom (CreateReader ("<feed xmlns='http://www.w3.org/2005/Atom'><updated>2000-01-01T00:00:00</updated></feed>"));
}
static SyndicationFeed GetFeed(Uri feedUri,string token)
{
if(feedUri.Scheme != "http" && feedUri.Scheme != "https")
{
return null;
}
HttpWebRequest getFeedRequest = WebRequest.Create(feedUri) as HttpWebRequest;
getFeedRequest.Method = "GET";
getFeedRequest.Headers.Add("X-MS-Identity-Token",token);
Atom10FeedFormatter atomFormatter = new Atom10FeedFormatter();
try
{
using(HttpWebResponse getFeedResponse = getFeedRequest.GetResponse() as HttpWebResponse)
{
atomFormatter.ReadFrom(new XmlTextReader(getFeedResponse.GetResponseStream()));
}
}
catch
{
}
return atomFormatter.Feed;
}
private void Read(Stream stream, Channel c, RssViewModel m)
{
var feedFormatter = new Atom10FeedFormatter();
var rssFormater = new Rss20FeedFormatter();
XmlReader atomReader = XmlReader.Create(stream);
SyndicationFeedFormatter f = null;
if (feedFormatter.CanRead(atomReader))
{
feedFormatter.ReadFrom(atomReader);
atomReader.Close();
f = feedFormatter;
}
else
if (rssFormater.CanRead(atomReader))
{
rssFormater.ReadFrom(atomReader);
atomReader.Close();
f = rssFormater;
}
if (f == null) return;
SyndicationFeed feed = f.Feed;
c.Title = feed.Title.Text;
Article[] articles = feed.Items.Select(item => new Article
{
PubDate = item.PublishDate.DateTime,
Description = item.Summary.Text,
Link = item.Links[0].Uri.OriginalString,
Title = item.Title.Text,
}).Select(art => m.AddArticle(art, c)).ToArray();
m.DeleteArticle(c.Articles.Where(x => !x.IsStared).Except(articles).ToArray(), c);
c.LastUpdate = DateTime.Now;
}
SyndicationFeed ReadSourceFeed (XmlReader reader)
{
SyndicationFeed feed = null;
if (!reader.IsEmptyElement) {
reader.Read ();
Atom10FeedFormatter ff = new Atom10FeedFormatter ();
ff.ReadFrom (reader);
feed = ff.Feed;
}
else
feed = new SyndicationFeed ();
reader.Read (); // </source> or <source ... />
return feed;
}
public override object OnReadFromStream(Type type, Stream stream, HttpContentHeaders contentHeaders)
{
stream.Seek(0, SeekOrigin.Begin);
if (type.Equals(typeof(SyndicationItem)))
{
var entryFormatter = new Atom10ItemFormatter();
entryFormatter.ReadFrom(XmlReader.Create(stream));
return entryFormatter.Item;
}
if (type.Equals(typeof(SyndicationFeed)))
{
var feedFormatter = new Atom10FeedFormatter();
feedFormatter.ReadFrom(XmlReader.Create(stream));
return feedFormatter.Feed;
}
throw new InvalidOperationException("Expected to be called with type SyndicationItem or SyndicationFeed.");
}
private SyndicationFeed GetFeed(string url)
{
using (XmlReader reader = XmlReader.Create(url))
{
Rss20FeedFormatter rss = new Rss20FeedFormatter();
if (rss.CanRead(reader))
{
rss.ReadFrom(reader);
return rss.Feed;
}
Atom10FeedFormatter atom = new Atom10FeedFormatter();
if (atom.CanRead(reader))
{
atom.ReadFrom(reader);
return atom.Feed;
}
}
return null;
}
public static Contact FromEmail(NetworkCredential credentials, String email)
{
int delimiterPosition = credentials.UserName.IndexOf('%');
if (delimiterPosition <= 0)
throw new ArgumentException("Specified username is missing the '%' delimiter", "credentials");
var customerName = credentials.UserName.Substring(delimiterPosition + 1);
const String uriFormat = "{0}/ws/customers/{1}/contacts?email={2}";
var requestUri = new Uri(String.Format(uriFormat, Constants.ApiEndpoint, customerName, email));
var request = WebRequest.Create(requestUri) as HttpWebRequest;
if (request != null)
{
request.Credentials = credentials;
request.Method = "GET";
request.ContentType = "application/atom+xml";
// Get response
using (var webResponse = request.GetResponse() as HttpWebResponse)
{
// Get the response stream
if (webResponse != null)
{
var xmlReader = XmlReader.Create(webResponse.GetResponseStream());
if (webResponse.StatusCode == HttpStatusCode.OK)
{
var atomResponse = new Atom10FeedFormatter();
if (atomResponse.CanRead(xmlReader))
{
atomResponse.ReadFrom(xmlReader);
return new ContactContent(atomResponse.Feed.Items.First()).Contact;
}
}
}
}
}
return Empty;
}
protected static IEnumerable<Contact> GetContacts(ConstantContactCredential credential, Uri requestUri)
{
var request = WebRequest.Create(requestUri) as HttpWebRequest;
if (request == null)
{
throw new WebException("Failed to create WebRequest");
}
request.Credentials = credential;
request.Method = "GET";
request.ContentType = "application/atom+xml";
var contacts = new List<Contact>();
// Get response
using (var webResponse = request.GetResponse() as HttpWebResponse)
{
if (webResponse == null)
{
throw new WebException("Failed to create WebRequest");
}
// Get the response stream
XmlReader xmlReader = XmlReader.Create(webResponse.GetResponseStream());
if (webResponse.StatusCode != HttpStatusCode.OK)
throw new WebException(webResponse.StatusDescription);
var atomResponse = new Atom10FeedFormatter();
if (atomResponse.CanRead(xmlReader))
{
atomResponse.ReadFrom(xmlReader);
foreach (SyndicationItem item in atomResponse.Feed.Items)
{
contacts.Add(new ContactContent(item).Contact);
}
}
}
return contacts;
}
public void ReadFrom_ImageUrl ()
{
Atom10FeedFormatter f = new Atom10FeedFormatter ();
f.ReadFrom (CreateReader ("<feed xmlns='http://www.w3.org/2005/Atom'><logo>http://mono-project.com/images/mono.png</logo></feed>"));
Assert.IsNotNull (f.Feed.ImageUrl, "#1");
Assert.AreEqual ("http://mono-project.com/images/mono.png", f.Feed.ImageUrl.ToString (), "#2");
}
public void ReadFrom_Language ()
{
Atom10FeedFormatter f = new Atom10FeedFormatter ();
f.ReadFrom (CreateReader ("<feed xmlns='http://www.w3.org/2005/Atom' xml:lang='ar-AR'></feed>"));
Assert.AreEqual ("ar-AR", f.Feed.Language, "#1");
}
public void ReadFrom_Link ()
{
Atom10FeedFormatter f = new Atom10FeedFormatter ();
f.ReadFrom (CreateReader ("<feed xmlns='http://www.w3.org/2005/Atom'><link href='urn:foo' rel='enclosure' length='50' type='text/html' wcf='wtf'><extended /></link></feed>"));
Assert.AreEqual (1, f.Feed.Links.Count, "#1");
SyndicationLink link = f.Feed.Links [0];
Assert.AreEqual (50, link.Length, "#2");
Assert.AreEqual ("urn:foo", link.Uri.ToString (), "#3");
Assert.AreEqual ("text/html", link.MediaType, "#4");
Assert.AreEqual ("enclosure", link.RelationshipType, "#5");
Assert.AreEqual (1, link.AttributeExtensions.Count, "#6");
Assert.AreEqual (1, link.ElementExtensions.Count, "#7");
}
public void ReadFrom_Extension ()
{
Atom10FeedFormatter f = new Atom10FeedFormatter ();
f.ReadFrom (CreateReader ("<feed xmlns='http://www.w3.org/2005/Atom'><icon>http://www.mono-project.com/icons/mono.png</icon></feed>"));
Assert.IsNotNull (f.Feed, "#1");
// 'icon' is treated as an extension ...
Assert.AreEqual (1, f.Feed.ElementExtensions.Count, "#2");
}
private SyndicationFeed GetFeedForMessage(Message message)
{
var messageId = message.Id.Value;
var topicId = message.TopicId;
var feedEntry = new FeedEntry() { MessageId = messageId, TimeStamp = DateTime.UtcNow };
var feed = new Feed()
{
Entries = new List<FeedEntry>(new[] { feedEntry }),
Id = Identity.Random(),
TopicId = topicId,
Updated = DateTime.UtcNow
};
var topic = new Topic()
{
Id = topicId,
Name = "Topic Name",
Description = "Topic Description",
GroupId = Identity.Random()
};
var key = new MessageKey { MessageId = messageId, TopicId = topicId };
messageByMessageKey
.Setup(r => r.Get(It.Is<MessageKey>(k => k.TopicId == key.TopicId && k.MessageId == key.MessageId)))
.Returns(message);
getWorkingFeedForTopic
.Setup(r => r.Execute(topicId))
.Returns(feed);
entityById
.Setup(r => r.Get<Topic>(topicId))
.Returns(topic);
var client = new HttpClient(baseUri);
var response = client.Get(topicId.ToString());
var formatter = new Atom10FeedFormatter();
using (var rdr = XmlReader.Create(response.Content.ContentReadStream))
{
formatter.ReadFrom(rdr);
return formatter.Feed;
}
}
public void ReadFrom_EmptyDate ()
{
// strangely, it is checked while 'entry' is not checked
Atom10FeedFormatter f = new Atom10FeedFormatter ();
f.ReadFrom (CreateReader ("<feed xmlns='http://www.w3.org/2005/Atom'><updated /></feed>"));
}
public void ReadFrom1 ()
{
Atom10FeedFormatter f = new Atom10FeedFormatter ();
Assert.IsNull (f.Feed, "#1");
f.ReadFrom (CreateReader ("<feed xmlns='http://www.w3.org/2005/Atom'><title>test</title></feed>"));
SyndicationFeed feed1 = f.Feed;
Assert.IsNotNull (f.Feed.Title, "#2");
Assert.AreEqual ("test", f.Feed.Title.Text, "#3");
f.ReadFrom (CreateReader ("<feed xmlns='http://www.w3.org/2005/Atom'><title>test</title></feed>"));
Assert.IsFalse (object.ReferenceEquals (feed1, f.Feed), "#4");
}
