public void ParseRssFeedTest()
{
var feedItems = FeedParser.ParseRss("http://dopeypodcast.podbean.com/feed/");
Assert.IsTrue(feedItems.Count > 0);
Assert.IsTrue(feedItems.OrderByDescending(i => i.PublishDate).First().Mp3Url.EndsWith("mp3"));
}
public async void UpdateFeed()
{
_rssService = RSSService.Instance;
FeedParser parser = new FeedParser();
IEnumerable <Item> items = null;
try
{
items = await parser.Parse(new Uri("http://aditya-wibisana.blogspot.com/feeds/posts/default?alt=rss"), FeedType.Rss);
}
catch (Exception e)
{
if (e.GetType() == typeof(System.Net.WebException))
{
Xamarin.Forms.MessagingCenter.Send(this, Constants.Constant.NO_INTERNET);
return;
}
}
FeedList = new ObservableCollection <Item>();
foreach (Item item in items)
{
FeedList.Add(item);
}
OnPropertyChanged("FeedList");
}
//[ProducesResponseType(typeof(TodoItem), 201)] // Created
//[ProducesResponseType(typeof(TodoItem), 400)] // BadRequest
public async Task <IList <string> > Get([FromQuery] string q)
{
try
{
var resourceReader = new ResourceReader("https://abcnews.go.com/abcnews/topstories");
FeedParser parser = new FeedParser();
//var items = await parser.Parse("http://cdn.livetvcdn.net/rss/upcoming_it.xml", FeedType.RSS);
var items = await parser.Parse(resourceReader, FeedType.RSS);
var filteredItems = items
.Where(item => item.Title.ToLower().Contains(q.ToLower()));
var result = new List <string>();
filteredItems.ToList().ForEach(item =>
{
var page = FollowLinkContent(item.Link);
result.Add(page.Result.Substring(1, 10));
});
return(result);
}
catch (Exception ex)
{
throw;
}
}
public TestAtom()
{
expectedItems = 25;
_feed = FeedParser.ParseAsync("Samples/testatom.rss", FeedType.Atom)
.Result
.ToList();
}
public TestRSS()
{
expectedItems = 9;
_feed = FeedParser.ParseAsync("Samples/testrss.rss", FeedType.RSS)
.Result
.ToList();
}
public async Task TestStream()
{
var file = File.OpenRead("Samples/testrss.rss");
var feed = await FeedParser.ParseAsync(file, FeedType.RSS);
Assert.AreEqual(expectedItems, feed.Count());
}
private void btnVerifyLinks_Click(object sender, EventArgs e)
{
//Loop through rows that have a Issues URL
foreach (var row in dgvIssuesLists.Rows.Cast <DataGridViewRow>().Where(row => row.Cells["IssuesURL"].Value != null))
{
//Set Atom URL text
setLinkText(row);
var feedtitle = string.Empty;
try
{
//Try parsing the text
var parser = new FeedParser(row.Cells["IssuesURL"].Value.ToString());
feedtitle = parser.FeedTitle;
}
catch
{
//Unable to read feed so it must be invalid
}
if (string.IsNullOrEmpty(feedtitle))
{
//Set Error Text
row.Cells["IssuesURL"].ErrorText = "Verification Failed";
}
}
}
protected void rblFrom_SelectedIndexChanged(object sender, EventArgs e)
{
ddlTemplate.Items.Clear();
if (rblFrom.SelectedIndex == 0) // site
{
var scriptFileSetting = ModuleContext.OpenContentSettings().Template;
ddlTemplate.Items.AddRange(OpenContentUtils.GetTemplates(ModuleContext.PortalSettings, ModuleContext.ModuleId, scriptFileSetting, App.Config.Opencontent).ToArray());
}
else if (rblFrom.SelectedIndex == 1) // web
{
FeedParser parser = new FeedParser();
//var items = parser.Parse("http://www.openextensions.net/templates?agentType=rss&PropertyTypeID=9", FeedType.RSS);
//foreach (var item in items.OrderBy(t => t.Title))
//{
// ddlTemplate.Items.Add(new ListItem(item.Title, item.ZipEnclosure));
//}
//if (ddlTemplate.Items.Count > 0)
//{
// tbTemplateName.Text = Path.GetFileNameWithoutExtension(ddlTemplate.Items[0].Value);
//}
foreach (var item in GithubTemplateUtils.GetTemplateList(ModuleContext.PortalId).Where(t => t.Type == Components.Github.TypeEnum.Dir).OrderBy(t => t.Name))
{
ddlTemplate.Items.Add(new ListItem(item.Name, item.Path));
}
if (ddlTemplate.Items.Count > 0)
{
tbTemplateName.Text = Path.GetFileNameWithoutExtension(ddlTemplate.Items[0].Value);
}
}
ActivateDetailPage();
}
public IEnumerable <Item> ReadRss()
{
FeedParser parser = new FeedParser();
var items = parser.ParseRss("https://www.wired.com/feed");
//var items = parser.ParseRss("https://flipboard.com/@raimoseero/feed-nii8kd0sz?rss");
return(items.ToList());
}
public async Task ItemHandler()
{
var feed = await FeedParser.ParseAsync("Samples/testrss.rss", FeedType.RSS, _ => new
{
Summary = testString
});
Assert.IsTrue(feed.All(f => f.Summary == testString));
}
private AudioController GetAudioController()
{
var feedUrl = Environment.GetEnvironmentVariable("feed");
var feedItems = FeedParser.ParseRss(feedUrl);
_logger.LogLine($"Got {feedItems.Count} items from {feedUrl}.");
return(new AudioController(feedItems, _logger));
}
public IEnumerable <string> GetAllCoreFxPreview1()
{
var packageUrl = FormPackageUrl();
var request = (HttpWebRequest)WebRequest.Create(packageUrl);
var result = GetResultByCallFeed(request);
var lines = FeedParser.SplitResult(result);
return(FeedParser.FindAllCoreFx20Preview1InTheFeedResult(lines));
}
public async Task <FeedDetails> GetFeedDetails(string url)
{
var content = await urlFetcher.Get(url);
var feedParser = FeedParser.Create(content);
var parsed = feedParser.Parse();
return(new FeedDetails
{
Name = parsed.Name
});
}
public async Task FirstCheck()
{
RssFeedParser = new FeedParser();
Directory.CreateDirectory(LastPostDir);
if (File.Exists(Path.Combine(LastPostDir, LastPostFile)))
{
LastPost = await Serialization.Deserialize <RssFeedArticle> .JsonAsync(LastPostDir, LastPostFile);
}
await Check();
}
public async void GivenAValidFeedUrl_ReturnListOfFeed()
{
var parser = new FeedParser();
var resourceReader = new Moq.Mock <IResourceReader>();
resourceReader.Setup((rr) => rr.GetAsync())
.Returns(Task.FromResult <XDocument>(ValidFeedXml()));
var items = await parser.Parse(resourceReader.Object, FeedType.RSS);
Assert.Equal(3, items.Count);
}
public void Execute(IJobExecutionContext context)
{
LuceneIndexer.ClearLuceneIndex();
Console.WriteLine("Search index was cleared successfully!");
var items = FeedParser.GetModels();
LuceneIndexer.AddUpdateLuceneIndex(items);
Console.WriteLine("Search index was created successfully!");
LuceneIndexer.Optimize();
Console.WriteLine("Search index was optimized successfully!");
}
protected void rblAction_SelectedIndexChanged(object sender, EventArgs e)
{
phImport.Visible = false;
phExport.Visible = false;
phImportWeb.Visible = false;
phCopy.Visible = false;
phFullExport.Visible = false;
phFullImport.Visible = false;
if (rblAction.SelectedIndex == 0)
{
return;
}
if (rblAction.SelectedValue == "importfile") // import
{
phImport.Visible = true;
}
else if (rblAction.SelectedValue == "exportfile") // export
{
phExport.Visible = true;
ddlTemplates.Items.Clear();
ddlTemplates.Items.AddRange(OpenContentUtils.GetTemplates(PortalSettings, ModuleId, (TemplateManifest)null, GetModuleSubDir()).ToArray());
}
else if (rblAction.SelectedValue == "importweb") // Import from web
{
phImportWeb.Visible = true;
ddlWebTemplates.Items.Clear();
FeedParser parser = new FeedParser();
var items = parser.Parse("http://www.openextensions.net/templates?agentType=rss&PropertyTypeID=9", FeedType.RSS);
foreach (var item in items)
{
ddlWebTemplates.Items.Add(new ListItem(item.Title, item.ZipEnclosure));
}
}
else if (rblAction.SelectedValue == "copy") // copy
{
phCopy.Visible = true;
ddlCopyTemplate.Items.Clear();
ddlCopyTemplate.Items.AddRange(OpenContentUtils.GetTemplates(PortalSettings, ModuleId, (TemplateManifest)null, GetModuleSubDir()).ToArray());
}
else if (rblAction.SelectedValue == "fullexport") //
{
phFullExport.Visible = true;
}
else if (rblAction.SelectedValue == "fullimport") //
{
phFullImport.Visible = true;
}
}
public async Task FeedHanlder()
{
var feed = await FeedParser.ParseAsync("Samples/testrss.rss", x => x.Root
.Descendants()
.Where(i => i.Name.LocalName == "channel")
.Elements()
.Where(i => i.Name.LocalName == "item"), _ => new FeedItem
{
Content = testString
});
Assert.IsTrue(feed.All(f => f.Content == testString));
Assert.IsTrue(feed.Any());
}
public void Download_Success()
{
var rawFile = File.ReadAllText(Util.GetFullPath("Feed.xml"));
var xmlDocument = XDocument.Parse(rawFile).Root;
var feedParser = new FeedParser();
var feed = feedParser.Parse(xmlDocument);
Assert.NotNull(feed);
Assert.NotEqual(string.Empty, feed.Title);
Assert.NotEqual(string.Empty, feed.Description);
Assert.NotNull(feed.Content);
Assert.True(feed.Category.Count > 0, "Has not loaded categories");
}
public async void FeedConnectionTest()
{
FeedParser parser = new FeedParser();
ConsoleOutPut.Text += Environment.NewLine + "Attmepting RSS Feed Connection Test";
bool result = await parser.ParseRssTest("https://nyaa.si/?page=rss");
if (result)
{
ConsoleOutPut.Text += Environment.NewLine + "Attmepting RSS Feed Connection Success";
StartFeed();
}
else
{
ConsoleOutPut.Text += Environment.NewLine + "Attmepting RSS Feed Connection Failed";
}
}
public void TestRssParser()
{
var validFeeds = new Dictionary <int, Domain.Standard.Feed.AirQuality>();
//use 900 when populating data
for (int j = 1; j < 10; j++)
{
var parser = new FeedParser();
var airQuality = parser.Parse(j, FeedType.Rss);
if (airQuality is NullAirQuality)
{
continue;
}
Assert.IsNotNull(airQuality.Location,
$"Expected a valid location for {j} but nothing was returned.");
validFeeds.Add(j, airQuality);
}
}
private void StartFeed()
{
FeedParser parser = new FeedParser();
if (single)
{
List <ItemDetails> details = new List <ItemDetails>()
{
new ItemDetails
{
EpisodeCount = 7,
EpisodeCountFound = 3,
Name = "JoJo's Bizarre Adventure - Golden Wind",
Quality = "[720p]",
ReferenceName = "JoJo's+Bizarre+Adventure+Golden+Wind",
PageCount = 5
},
new ItemDetails
{
EpisodeCount = 12,
EpisodeCountFound = 5,
Name = "Kaguya-sama wa Kokurasetai",
Quality = "[720p]",
ReferenceName = "Kaguya+sama+wa+Kokurasetai",
PageCount = 5 // Guess the average pages the rss will have
}
};
foreach (var item in details)
{
for (int i = 0; i < item.PageCount; i++)
{
try { parser.ParseSingleRssAsync($"https://nyaa.si/?page=rss&q=+{item.ReferenceName}+&c=0_0&f={i.ToString()}", item); } catch { throw; }
}
}
//var items = parser.Parse("https://nyaa.si/?page=rss&q=Kaguya-sama+wa+Kokurasetai&c=0_0&f=0", FeedType.RSS);
//OpenTorrent();
}
else
{
parser.ParseAllRss("https://nyaa.si/?page=rss");
}
//Console.ReadLine();
}
private IOutcome<FeedModel> GetFeed(XDocument doc)
{
var parser = new FeedParser();
FeedModel result;
try
{
result = parser.Parse(doc);
}
catch (Exception ex)
{
return Outcomes.Failure<FeedModel>()
.WithMessage("Error parsing XDoc")
.FromException(ex);
}
return Outcomes.Success<FeedModel>()
.WithValue(result);
}
public NewsListPage()
{
InitializeComponent();
_feedParser = new FeedParser(_feeds);
_feedParser.OnData.Synchronize().Subscribe(items =>
{
_allItems.AddRange(items);
UpdateList();
});
_feedParser.Update();
_switches
.OnFilterChanged
.Subscribe(_ =>
// Delay by 1ms to force table to update on next
// runloop, otherwise UISwitch animation stutters
Task.Delay(1).ContinueWith(__ => UpdateList())
);
ItemsList.RefreshCommand = RefreshCommand;
FilterTable.Root = new TableRoot {
new TableSection {
_switches.SwitchCells
}
};
ToolbarItems.Add(new ToolbarItem("Filter", null, OnFilterTapped));
_gestureRecognizer = new TapGestureRecognizer
{
Command = new Command(() =>
{
if (FilterTable.IsVisible)
{
HideFilter();
}
})
};
}
static async void MainAsync()
{
const string rss = "https://www.reddit.com/r/csharp.rss";
const string atom = "https://xkcd.com/atom.xml";
const string rdf = "http://planetrdf.com/guide/rss.rdf";
Func <string, Uri> toUri = url => new Uri(url, UriKind.Absolute);
var parser = new FeedParser();
var rssItems = await parser.Parse(toUri(rss), FeedType.Rss);
Console.WriteLine(rssItems.Count());
var atomItems = await parser.Parse(toUri(atom), FeedType.Atom);
Console.WriteLine(atomItems.Count());
var rdfItems = await parser.Parse(toUri(rdf), FeedType.Rdf);
Console.WriteLine(rdfItems.Count());
}
public async Task <IReadOnlyList <ExternalFeedItem> > GetItems(Feed feed)
{
try
{
var content = await urlFetcher.Get(feed.url);
var feedParser = FeedParser.Create(content);
var parsed = feedParser.Parse();
return(parsed.Articles.Select(a => new ExternalFeedItem
{
Title = a.Title,
Content = a.Content,
Link = a.WebUri,
PublishDate = a.Published
}).ToList());
}
catch (Exception exception)
{
Logger.Error("Error attempting to fetch feed items", new { feed, exception.Message });
return(null);
}
}
public static void GetFeeds(int cat, int id)
{
FeedList = new List <Feed>();
UrlList = urlSetter.SetUrlList(cat, id);
foreach (var url in UrlList)
{
FeedParser parser = new FeedParser();
var items = parser.Parse(url, FeedType.RSS);
if (items != null)
{
foreach (var item in items)
{
if (item != null && !string.IsNullOrEmpty(item.Title) &&
!string.IsNullOrEmpty(item.Content))
{
string title = Regex.Replace(item.Title, "<.*?>", string.Empty);
string description = Regex.Replace(item.Content, "<.*?>", string.Empty);
string link = Regex.Replace(item.Link, "unsafe: ", string.Empty).Trim();
Feed feed = new Feed
{
Media_name = Constants.MediaNameList.ElementAt(cat - 1).ElementAt(id),
Title = title,
Description = description,
Link = link,
Published = item.PublishDate.ToString("ddd d MMM yyyy",
CultureInfo.CreateSpecificCulture("fr-FR")),
Image_url = item.Image_url
};
FeedList.Add(feed);
}
}
}
}
}
/// <summary>
/// Loads RSS for Blogs and sync to DB.
/// </summary>
public void Synchronize()
{
Console.WriteLine("Loading URls...");
List <RssUrlInfo> urlInfoList = LoadRSSUrls();
FeedParser parser = new FeedParser();
foreach (var urlInfo in urlInfoList)
{
var items = parser.Parse(urlInfo.Url, RssFeedType.RSS);
RssItem rssIt = null;
// Here for sure there is one object in 'items'.
if (items.Count > 0)
{
List <RssItem> docItemList = new List <RssItem>();
rssIt = items[0];
docItemList.Add(rssIt);
urlInfo.DocItemList = docItemList;
}
}
Console.WriteLine("Saving to DB...");
SaveToDb(urlInfoList);
}
private void btnVerifyLinks_Click(object sender, EventArgs e)
{
//Loop through rows that have a Issues URL
foreach (var row in dgvIssuesLists.Rows.Cast<DataGridViewRow>().Where(row => row.Cells["IssuesURL"].Value != null))
{
//Set Atom URL text
setLinkText(row);
var feedtitle = string.Empty;
try
{
//Try parsing the text
var parser = new FeedParser(row.Cells["IssuesURL"].Value.ToString());
feedtitle = parser.FeedTitle;
}
catch
{
//Unable to read feed so it must be invalid
}
if (string.IsNullOrEmpty(feedtitle))
{
//Set Error Text
row.Cells["IssuesURL"].ErrorText = "Verification Failed";
}
}
}
public async Task TestBadNoPubDate()
{
var feed = await FeedParser.ParseAsync("Samples/badrss.rss", FeedType.RSS);
Assert.IsTrue(feed.All(f => f.PublishDate == DateTime.MinValue));
}
public void Setup()
{
_target = new FeedParser(null, NullLogger.Instance);
}
/// <summary>
/// reads a feed from the bytearray <paramref name="feedContent"/>
/// This could be useful if some special encoding is used.
/// </summary>
/// <param name="feedContent"></param>
/// <returns></returns>
public static Feed ReadFromByteArray(byte[] feedContent)
{
return(FeedParser.GetFeed(feedContent));
}
/// <summary>
/// reads a feed from the <paramref name="feedContent" />
/// </summary>
/// <param name="feedContent">the feed content (xml)</param>
/// <returns>parsed feed</returns>
public static Feed ReadFromString(string feedContent)
{
return(FeedParser.GetFeed(feedContent));
}