private static string UpdateFeed(string updateResults, FactFluxEntities db, RSSFeed feed)
{
try
{
int articlesAdded = 0;
if (feed.FeedType == "RSS")
{
articlesAdded = AddNewResourcesFromRSS(ref updateResults, db, feed);
}
if (feed.FeedType == "YouTube")
{
AddNewResourcesFromYouTube(ref updateResults, db, feed, ref articlesAdded);
}
feed.LastUpdated = DateTime.UtcNow;
db.SaveChanges();
updateResults += "\r\n---------------Feed Num: " + feed.FeedTitle.ToString() + " New Articles: " + articlesAdded + Environment.NewLine;
}
catch (Exception ex)
{
updateResults += "\r\n---------------Feed Num: " + feed.FeedTitle.ToString() + " Error: " + ex.Message + Environment.NewLine;
feed.LastUpdated = DateTime.UtcNow;
db.SaveChanges();
}
return(updateResults);
}
public SubscriptionWindow(MapRSS program, RSSFeed feed = null)
{
InitializeComponent();
main = program;
originalFeed = feed;
List <MapRSSItem> chSource = new List <MapRSSItem>(program.Channels);
chSource.Insert(0, new Channel("No Group Selected"));
Groups.ItemsSource = chSource;
Groups.SelectedIndex = 0;
if (feed != null)
{
Title = "Modify a subscription";
Confirm.Content = "Save Changes";
inputAlias.Text = feed.Name;
inputURL.Text = feed.URL;
UpdatePeriod.Text = feed.UpdatePeriod.ToString();
if (feed.Parent != null)
{
Groups.SelectedItem = feed.Parent;
}
}
}
// ref: Building a Windows 8 RSS Reader
// http://visualstudiomagazine.com/articles/2012/01/04/building-a-windows-8-rss-reader.aspx
/// <summary>
/// RSS 주소에서 피드 가져오기.
/// </summary>
/// <param name="url"></param>
/// <param name="maxItems"></param>
/// <returns></returns>
public async Task<RSSFeed> GetFeeds(string url, int maxItems = 10)
{
var feeds = new RSSFeed();
var client = new SyndicationClient();
var feedUri = new Uri(url);
SyndicationFeed feed = await client.RetrieveFeedAsync(feedUri);
var topFeeds = feed.Items.OrderByDescending(x =>
x.PublishedDate).Take(maxItems).ToList();
feeds.Title = feed.Title.Text;
foreach (var item in topFeeds)
{
var feedItem = new RSSItem { Title = item.Title.Text, PublishedOn = item.PublishedDate.DateTime };
var authors = from a in item.Authors
select a.Name;
feedItem.Author =
String.Join(",", authors);
feedItem.Content = item.Content !=
null ? item.Content.Text : String.Empty;
feedItem.Description = item.Summary !=
null ? item.Summary.Text : String.Empty;
var links = from l in item.Links
select new RSSLink(l.Title, l.Uri);
feedItem.Links = links.ToList();
feeds.Items.Add(feedItem);
}
return feeds;
}
private async Task <Item[]> LoadItemsAsync(RSSFeed feed)
{
using (var xmlReader = XmlReader.Create(feed.Uri))
{
var items = new List <Item>();
var feedReader = new RssFeedReader(xmlReader);
while (await feedReader.Read())
{
if (feedReader.ElementType != SyndicationElementType.Item)
{
continue;
}
var feedItem = await feedReader.ReadItem();
items.Add(new Item
{
Title = feedItem.Title,
Link = feedItem.Links.FirstOrDefault()?.Uri?.ToString(),
Description = feedItem.Description,
Author = feedItem.Contributors.FirstOrDefault()?.Email,
PublishedAt = feedItem.Published.DateTime
});
}
return(items.ToArray());
}
}
// Callback method
//
public static void GetFeed_Callback(IAsyncResult result)
{
RSSFeed rs = (RSSFeed)result.AsyncState;
Console.Out.WriteLine(rs.EndGetFeed(result));
bFinished = true;
}
private void Work(RSSFeed feed)
{
try {
using (XmlReader reader = XmlReader.Create(feed.Id)) {
SyndicationFeed sfeed = SyndicationFeed.Load(reader);
List <SyndicationItem> items = new List <SyndicationItem>(sfeed.Items);
int lastUpdateIndex = items.Count;
for (int i = 0; i < items.Count && lastUpdateIndex == items.Count && feed.LastUpdateId != null; i++)
{
if (items[i].Id == feed.LastUpdateId)
{
lastUpdateIndex = i;
}
}
for (int i = lastUpdateIndex - 1; i >= 0; i--)
{
//Only invoke event if update is younger than 24 hours
if ((DateTime.Now.ToLocalTime() - items[i].PublishDate.LocalDateTime) <= TimeSpan.FromHours(24))
{
//If an exception is thrown while publishing we don't mark the update as published
RSSUpdate?.Invoke(this, new RSSUpdateEventArgs(items[i], feed));
feed.LastUpdateId = items[i].Id;
if (_databaseManager.Exists(feed))
{
_databaseManager.Save(feed);
}
}
}
}
}
catch (Exception e) {
Logger.LogError("Error processing a RSS feed: " + e.Message);
}
}
public void miFileOpen_Click(object sender, System.EventArgs e)
{
// Implementation goes here
MyDialog dlgFileOpen = new MyDialog("File Open");
dlgFileOpen.ShowDialog();
if (dlgFileOpen.ChoseOpen)
{
// If the user has asked to OPEN a Feed, we'll add this to the list
// Create RSSFeed container
RSSFeed feed = new RSSFeed();
feed.feedName = dlgFileOpen.txtRssURL.Text;
feed.feedURL = dlgFileOpen.txtRssURL.Text;
// Add it to our list
feeds.Add(feed);
Console.WriteLine("->Added 'feed' to 'feeds' list");
// Refresh our Subscription control
RefreshSubscriptions();
// Set the current channel
if (currentChannel == null)
{
currentChannel = new Channel();
}
currentChannel.InitialiseFromURL(feed.feedURL);
// Read the Threads associated with the current channel
RefreshThreads(currentChannel);
// Debug
Console.Out.WriteLine(dlgFileOpen.txtRssURL.Text);
}
}
/// <summary>
/// Loads the selected RSSFeed to the ListBox when
/// navigated to this page
/// </summary>
/// <param name="e"></param>
protected override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
if (isNewInstance)
{
Items = new ObservableCollection <RSSItem>();
ItemsView = new CollectionViewSource();
feedId = int.Parse(NavigationContext.QueryString["feed"]);
pageId = int.Parse(NavigationContext.QueryString["page"]);
RSSFeed feed = RSSService.GetRSSFeed(pageId, feedId);
foreach (RSSItem item in feed.Items)
{
Items.Add(item);
}
ItemsView.Source = Items;
ItemListBox.ItemsSource = ItemsView.View;
ItemListBox.SelectedIndex = App.NO_SELECTION;
isLoadingFinished = true;
isNewInstance = false;
}
}
public override void ValidateChildren()
{
try {
RefreshUserSettings(Kernel.Instance.GetLocation(Path));
if (Math.Abs((lastUpdated - DateTime.Now).TotalMinutes) < UpdateMinuteInterval)
{
return;
}
lastUpdated = DateTime.Now;
RSSFeed feed = new RSSFeed(Url);
feed.Refresh();
PrimaryImagePath = feed.ImageUrl;
children = feed.Children.Distinct(key => key.Id).ToList();
SetParent();
Overview = feed.Description;
this.OnChildrenChanged(null);
Kernel.Instance.ItemRepository.SaveItem(this);
} catch (Exception e) {
Logger.ReportException("Failed to update podcast!", e);
}
}
public ActionResult RSSFeedsSearch(string filter)
{
try
{
string currentUserId = HttpContext.User.Identity.GetUserId();
if (currentUserId != null)
{
List <RSSFeed> feeds = new List <RSSFeed>();
var posts = _postRepo.Get(x => (x.Body.Contains(filter) || x.Title.Contains(filter) || x.Author.Contains(filter)) && x.CreatedBy == currentUserId);
foreach (var item in posts)
{
RSSFeed feed = new RSSFeed();
feed.Author = item.Author;
feed.Description = item.Body;
feed.PubDate = item.PostDate.ToString();
feed.Title = item.Title;
feed.Link = item.Link;
feed.PubDate = item.PostDate.ToString();
feeds.Add(feed);
}
model.RSSFeeds = feeds;
}
//model.SubscriptionId = id;
return(PartialView("RSSFeeds", model));
}
catch (Exception ex)
{
TempData["Error"] = ex.Message;
model = new FeedViewModel();
//model.SubscriptionId = id;
return(PartialView("RSSFeeds", model));
}
}
private void Page_Load(object sender, System.EventArgs e)
{
//System.Text.StringBuilder sb = new System.Text.StringBuilder(256);
System.Data.SqlClient.SqlDataReader dr;
RSSFeed rssFeed = new RSSFeed("AdamKinney's Blog", "http://www.adamkinney.com/blog/", "GotDotNet Bard");
rssFeed.ImplementsSlash = true;
rssFeed.Language = "en-us";
rssFeed.ManagingEditor = "*****@*****.**";
rssFeed.WebMaster = "*****@*****.**";
rssFeed.TTL = "60";
// dr = Set dr to SQLDataReader that selects posts from database.
RSSItem item;
while (dr.Read())
{
item = new RSSItem(dr[1].ToString(), "<![CDATA[ " + dr[2].ToString() + " ]]>");
item.Author = "Adam Kinney";
item.Categories.Add(new RSSCategory(dr[3].ToString()));
item.Comments = "http://www.adamkinney.com/blog/default.aspx?PostID=" + dr[0].ToString() + "#comments";
item.Slash.Comments = dr[5].ToString();
item.Guid = "http://www.adamkinney.com/blog/default.aspx?PostID=" + dr[0].ToString();
item.GuidIsPermalink = true;
item.PubDate = DateTime.Parse(dr[4].ToString()).ToString("r");
item.SourceUrl = "http://www.adamkinney.com/blog/rss.aspx";
rssFeed.Items.Add(item);
}
Response.ContentType = "text/xml";
Response.Write(rssFeed.ToString());
}
public ActionConfirmation Delete(int id)
{
RSSFeed rSSFeedToDelete = rSSFeedRepository.Get(id);
if (rSSFeedToDelete != null)
{
rSSFeedRepository.Delete(rSSFeedToDelete);
try {
rSSFeedRepository.DbContext.CommitChanges();
return(ActionConfirmation.CreateSuccessConfirmation(
"The rSSFeed was successfully deleted."));
}
catch {
rSSFeedRepository.DbContext.RollbackTransaction();
return(ActionConfirmation.CreateFailureConfirmation(
"A problem was encountered preventing the rSSFeed from being deleted. " +
"Another item likely depends on this rSSFeed."));
}
}
else
{
return(ActionConfirmation.CreateFailureConfirmation(
"The rSSFeed could not be found for deletion. It may already have been deleted."));
}
}
public async Task BaseCommand(string url, string tag)
{
if (url.StartsWith("https://mangadex.org/rss/"))
{
RSSFeed feed = new RSSFeed {
Id = url, Tag = tag
};
if (!Context.Database.Exists <RSSFeed>(feed))
{
Context.Database.Save <RSSFeed>(feed);
EmbedBuilder eb = CreateEmbed(EmbedColor.SalmonPink);
eb.WithAuthor("Added RSS feed.");
eb.WithDescription("RSS feeds are only polled every 60 seconds, be patient if no news appears immediately.");
await ReplyAsync(string.Empty, eb.Build(), false, false);
}
else
{
await DiscordAPIHelper.ReplyWithError(Context.Message,
"I'm already subscribed to that RSS feed.",
Context.HttpServerManager.GetIp + "/images/error.png");
}
}
else
{
await DiscordAPIHelper.ReplyWithError(Context.Message,
"That's not a valid RSS feed URL.",
Context.HttpServerManager.GetIp + "/images/error.png");
}
}
public async void ParseRSS()
{
string feed = null;
RSSFeed.Clear();
using (var client = new HttpClient())
{
try
{
feed = await client.GetStringAsync(Url);
}
catch
{
}
}
if (feed != null)
{
var parser = new RssParser();
var rss = parser.Parse(feed);
foreach (var element in rss)
{
RSSFeed.Add(element);
}
}
}
public EditFeed(RSSFeed feed)
{
this.feed = feed;
InitializeComponent();
this.Show();
}
public static void ValidateFeed(RSSFeed feed)
{
if (feed.URI.ToString().Trim(' ') == string.Empty)
{
throw new ValidationExeption("Feed url kan inte vara tom");
}
return;
}
public async Task CanRetrieveRSSFeed(string feedUrl)
{
var feed = new RSSFeed(feedUrl);
var items = await feed.ItemsAsync();
Assert.That(items.Count(), Is.Not.Zero);
}
public void DeleteFeed(RSSFeed feed, Action onCompleted = null)
{
string path = Path.Combine(_rssFeedPath, feed.Name + ".xml");
File.Delete(path);
_rssFeeds.Remove(feed.Name);
onCompleted?.Invoke();
}
public async static void UpdateFeedPodcasts(RSSFeed feed)
{
var fetcher = new RSSFetcher(feed.URI);
var onlineFeed = fetcher.Fetch();
await Task.Run(() => {
feed.Podcasts = onlineFeed.Podcasts;
});
}
private void TransferFormValuesTo(RSSFeed rSSFeedToUpdate, RSSFeed rSSFeedFromForm)
{
rSSFeedToUpdate.Name = rSSFeedFromForm.Name;
rSSFeedToUpdate.URL = rSSFeedFromForm.URL;
rSSFeedToUpdate.Template = rSSFeedFromForm.Template;
rSSFeedToUpdate.Channel = rSSFeedFromForm.Channel;
rSSFeedToUpdate.SlideFolder = rSSFeedFromForm.SlideFolder;
rSSFeedToUpdate.XSLT = rSSFeedFromForm.XSLT;
}
public RSSFeedFormViewModel CreateFormViewModelFor(RSSFeed rSSFeed)
{
RSSFeedFormViewModel viewModel = CreateFormViewModel();
viewModel.RSSFeed = rSSFeed;
//viewModel.SlideFolders = rSSFeed.Publisher.SlideFolders;
//viewModel.Templates = rSSFeed.Publisher.AssignedTemplates;
//viewModel.Channels = rSSFeed.Publisher.Channels;
return(viewModel);
}
public ActionResult AddNewRssFeed(RSSFeed rssFeed)
{
if(!ModelState.IsValid)
return this.View(rssFeed);
rssFeed.User = UserProfileRepo.Get(u => u.UserName == User.Identity.Name).FirstOrDefault();
RSSFeedRepo.Add(rssFeed);
RSSFeedRepo.CommitChanges();
return RedirectToAction("List");
}
void DeleteSelectedFeed(object sender, EventArgs e)
{
if (RSSFeedHandler.GetInstance.RSSFeeds.Count() < 1)
{
return;
}
RSSFeed feed = GetSelectedFeed();
RSSFeedHandler.GetInstance.DeleteFeed(feed, RefreshFeedToLastItem);
}
private void Run(RSSFeed rssFeed)
{
rssFeed.Run();
foreach (var channelSlide in rssFeed.Channel.AssignedSlides)
{
slideRepository.SaveOrUpdate(channelSlide.Slide);
channelsSlideRepository.SaveOrUpdate(channelSlide);
}
rSSFeedRepository.SaveOrUpdate(rssFeed);
}
public async void LoadNews()
{
RSSFeed rssFeedReader = new RSSFeed();
var news = await rssFeedReader.LoadNewsAsync();
foreach (SyndicationItem syndicationItem in news)
{
News.Add(syndicationItem);
}
}
static async Task Main(string[] args)
{
// we gave two RSS Feed for the sake of the demo
// we generate two object with the feed property
var theBibleInAYear = new RSSFeed
{
FeedId = 1,
FeedName = "The Bible in a Year",
FeedUrl = new Uri("https://feeds.fireside.fm/bibleinayear/rss"),
};
//feed two
var theApologyLine = new RSSFeed
{
FeedId = 2,
FeedName = "The Apology Line",
FeedUrl = new Uri("https://rss.art19.com/apology-line"),
};
// we store all the feed in the listOfRssFeed
var listOfRssFeeds = new RssFeeds()
{
ListOfRssFeeds = new List <RSSFeed>
{
theApologyLine,
theBibleInAYear
}
};
// we instanciate the rssService
ILastPublishedDateServices lastPublishedDateServices = new LastPublishedDateServices();
//we instanciate the rss call service to get the xml from api call
IRssCallServices rssCallServices = new RssCallServices();
// we call the service
var result = await lastPublishedDateServices.NumberOfInactivityDays(listOfRssFeeds, rssCallServices);
foreach (var item in result)
{
var msg = $"Feed {item.FeedName}, a total of {(int)item.InactivityPeriod} days has past since the last publication";
if ((int)item.InactivityPeriod == 0)
{
msg = $"Feed {item.FeedName}, a total of 0 day has past since the last publication. The RSS is current";
}
Console.WriteLine(msg);
}
}
// GET: BlogFeeds
public ActionResult Rss()
{
UmbracoHelper umbracoHelper = new UmbracoHelper(UmbracoContext.Current);
const int NUMBER_OF_FEED_ITEMS = 10;
const string DATE_FORMAT = "ddd, dd MMM yyyy hh:mm:ss zzz";
const string ARTICLE_TITLE_PROPERTY_ALIAS = "pageTitle";
const string ARTICLE_AUTHOR_ALIAS = "CreatorName";
const string ARTICLE_DATE_PROPERTY_ALIAS = "publishedDate";
const int CONTENT_PREVIEW_LENGTH = 500;
var currentPage = Request.Url.ToString();
List <RSSFeedItem> results = new List <RSSFeedItem>();
IPublishedContent homePage = umbracoHelper.TypedContentAtRoot().FirstOrDefault(x => x.ContentType.Alias.Equals("home"));
IPublishedContent blogPage = homePage.Children.Where(x => x.DocumentTypeAlias == "blogHome").FirstOrDefault();
IList <BlogPost> feedItems = blogPage.Descendants <BlogPost>().OrderByDescending(x => x.UpdateDate).Take(NUMBER_OF_FEED_ITEMS).ToList();
DateTime lastBuildDate = feedItems.Max(x => x.UpdateDate);
string siteUrl = homePage.UrlWithDomain();
string feedUrl = Request.Url.PathAndQuery;
var feedParentUrl = blogPage.UrlWithDomain();
foreach (var page in feedItems)
{
// Obsolete. See https://skrift.io/articles/archive/strongly-typed-models-in-the-umbraco-grid/
string articleDescription = umbracoHelper.Truncate(umbraco.library.StripHtml(page.GetGridHtml("gridEditor", "bootstrap3").ToString()), CONTENT_PREVIEW_LENGTH).ToString().Replace("…", "...");
string title = page.HasProperty(ARTICLE_TITLE_PROPERTY_ALIAS) ? page.GetPropertyValue <string>(ARTICLE_TITLE_PROPERTY_ALIAS) : page.Name;
string author = !string.IsNullOrEmpty(page.CreatorName) ? page.CreatorName : "Guest";
string link = umbracoHelper.NiceUrlWithDomain(page.Id);
string publishedDate = ((DateTime)page.GetPropertyValue(ARTICLE_DATE_PROPERTY_ALIAS)).ToString(DATE_FORMAT);
string permaLink = page.UrlWithDomain();
List <string> categoryList = new List <string>();
if (page.HasProperty("category"))
{
foreach (var item in page.Category)
{
categoryList.Add(item);
}
}
results.Add(new RSSFeedItem(articleDescription, title, author, link, categoryList, publishedDate, permaLink));
}
RSSFeed viewModel = new RSSFeed(feedParentUrl, lastBuildDate.ToString(DATE_FORMAT), currentPage, results);
return(View(viewModel));
}
public static void AddFeed(RSSFeed feed)
{
try {
Validation.ValidateFeed(feed);
} catch (ValidationExeption ex) {
throw ex;
}
feed.StartTimer();
feed.TimerTick += OnUpdatedFeed;
PodcastFeeds.Add(feed);
}
public async Task Update(RSSFeedDTO dto)
{
var repoObj = new RSSFeed()
{
Id = dto.Id.Value,
Name = dto.Name,
XMLFileAddress = dto.XMLFileAddress,
CategoryId = dto.Category != null ? dto.Category.Id : null
};
await _repository.Update(repoObj);
}
void ShowFeed(int index)
{
if (RSSFeedHandler.GetInstance.RSSFeeds.Count() < 1)
{
return;
}
lstBoxFeed.SelectedIndex = index;
RSSFeed rssFeed = GetSelectedFeed();
_currentRssFeedItems = RSSFeedXmlDataParser.GetRSSFeedItems(rssFeed.LastFetchedFeed);
SetRSSFeedItems();
}
public void CanCompareRSSFeeds()
{
RSSFeed instance = new RSSFeed();
instance.URL = "http://www.telegraph.co.uk/rss";
RSSFeed instanceToCompareTo = new RSSFeed();
instanceToCompareTo.URL = "http://www.telegraph.co.uk/rss";
instance.ShouldEqual(instanceToCompareTo);
}
public async Task <IActionResult> Get(int numOfDays)
{
Dictionary <string, IEnumerable <string> > companies = new Dictionary <string, IEnumerable <string> >();
companies = companies == null ? new Dictionary <string, IEnumerable <string> >() : companies;
companies.Add("Newyork Times", new string[] { "https://rss.nytimes.com/services/xml/rss/nyt/HomePage.xml", "https://rss.nytimes.com/services/xml/rss/nyt/HomePage.xml" });
companies.Add("NBC News", new string[] { "http://podcastfeeds.nbcnews.com/HL4TzgYC" });
companies.Add("Libsyn", new string[] { "https://lincolnproject.libsyn.com/rss" });
companies.Add("Apology line", new string[] { "https://rss.art19.com/apology-line" });
companies.Add("Unraveled", new string[] { "https://rss.acast.com/unraveled" });
return(Ok(await RSSFeed.FilterNotActiveCompanies(companies, numOfDays)));
}
public static IEnumerable<RSSFeedItem> GetRSSFeedItems(RSSFeed rssFeed, UserProfile userProfile)
{
var feed = SyndicationFeed.Load(XmlReader.Create(rssFeed.RSSFeedUrl));
if (feed == null)
throw new Exception("The Rss Feed URL is not valid");
return feed.Items.Select
(
item => new RSSFeedItem
{
RSSFeedItemId = item.Id,
Title = item.Title.Text,
Summary = item.Summary.Text,
Read = false,
RSSFeed = rssFeed,
User = userProfile
}).ToList();
}
public ActionResult EditFeed(RSSFeed rssFeed)
{
RSSFeedRepo.Update(rssFeed, rssFeed.RSSFeedUrl, rssFeed.UserId);
RSSFeedRepo.CommitChanges();
return RedirectToAction("List");
}
public ActionResult NavigateToRSSFeedItems(RSSFeed firstRssFeed)
{
return RedirectToAction("List", "RSSFeedItems", new { rssFeedUrl = firstRssFeed.RSSFeedUrl });
}
private void TheRelevantRssFeedHasBeenCapturedForASpecificUser()
{
addANewRSSFeedRssFeed = new RSSFeed { RSSFeedTitle = "Title", RSSFeedUrl = "http://Url" };
}
private void TheViewRSSFeedItemsButtonIsClicked()
{
navigateToRSSFeedItemsListResult = RSSFeedPage.List() as ViewResult;
Assert.IsNotNull(navigateToRSSFeedItemsListResult, "The list of feeds could not be retrieved");
navigateToRSSFeedItemsFeeds = (navigateToRSSFeedItemsListResult.Model as IEnumerable<RSSFeed>);
Assert.IsNotNull(navigateToRSSFeedItemsFeeds);
this.rssFeedRssFeedToBeEdited = navigateToRSSFeedItemsFeeds.FirstOrDefault();
Assert.IsNotNull(this.rssFeedRssFeedToBeEdited);
navigateToRSSFeedItemsResult = RSSFeedPage.NavigateToRSSFeedItems(this.rssFeedRssFeedToBeEdited);
}
private void TheUserHasClickedEditOnASpecificFeed()
{
editRSSFeedListResult = RSSFeedPage.List() as ViewResult;
Assert.IsNotNull(editRSSFeedListResult, "The list of feeds could not be retrieved");
editRSSFeedRssFeeds = (editRSSFeedListResult.Model as IEnumerable<RSSFeed>);
Assert.IsNotNull(editRSSFeedRssFeeds);
rssFeedRssFeedToBeEdited = editRSSFeedRssFeeds.FirstOrDefault();
Assert.IsNotNull(rssFeedRssFeedToBeEdited);
editRSSFeedItemResult = RSSFeedPage.EditFeed(rssFeedRssFeedToBeEdited.RSSFeedUrl);
Assert.IsNotNull(editRSSFeedItemResult);
Assert.IsTrue(editRSSFeedItemResult is ViewResult);
}
private void TheUserClicksDeleteOnASpecificFeed()
{
deleteRSSFeedListResult = RSSFeedPage.List() as ViewResult;
Assert.IsNotNull(deleteRSSFeedListResult, "The list of feeds could not be retrieved");
deleteRSSFeedRssFeeds = (deleteRSSFeedListResult.Model as IEnumerable<RSSFeed>);
Assert.IsNotNull(deleteRSSFeedRssFeeds);
deleteRSSFeedRssFeedToBeDeleted = deleteRSSFeedRssFeeds.FirstOrDefault();
Assert.IsNotNull(deleteRSSFeedRssFeedToBeDeleted);
RSSFeedPage.DeleteFeed(deleteRSSFeedRssFeedToBeDeleted.RSSFeedUrl);
}
