public override async Task HandleAsync(IUpdateContext context, UpdateDelegate next, string[] args,
CancellationToken cancellationToken)
{
// ChatHelper.Init(context);
response = new RequestProvider(context);
// var chatId = ChatHelper.Message.Chat.Id.ToString();
// var isAdmin = await ChatHelper.IsAdminGroup();
var chatId = response.Message.Chat.Id.ToString();
var isAdmin = await response.IsAdminGroup();
if (isAdmin || response.IsPrivateChat())
{
#pragma warning disable 4014
Task.Run(async() =>
#pragma warning restore 4014
{
// Thread.CurrentThread.IsBackground = true;
await response.SendTextAsync("Sedang memeriksa RSS feed baru..");
// await "Sedang memeriksa RSS feed baru..".SendTextAsync();
var newRssCount = await RssHelper.ExecBroadcasterAsync(chatId);
if (newRssCount == 0)
{
await response.EditAsync("Tampaknya tidak ada RSS baru saat ini");
// await "Tampaknya tidak ada RSS baru saat ini".EditAsync();
}
// ChatHelper.Close();
}, cancellationToken);
}
}
public static void InitScheduler()
{
Task.Run(async() =>
{
ConsoleHelper.WriteLine("Initializing RSS Scheduler.");
var baseId = "rss-scheduler";
var cronInMinute = 10;
var rssService = new RssService();
ConsoleHelper.WriteLine("Getting list Chat ID");
var listChatId = await rssService.GetListChatIdAsync();
foreach (RssSetting row in listChatId)
{
// var chatId = row["chat_id"].ToString();
var chatId = row.ChatId;
var recurringId = $"{chatId}-{baseId}";
ConsoleHelper.WriteLine($"Creating Jobs for {chatId}");
RecurringJob.RemoveIfExists(recurringId);
RecurringJob.AddOrUpdate(recurringId, ()
=> RssHelper.ExecBroadcasterAsync(chatId), $"*/{cronInMinute} * * * *");
}
ConsoleHelper.WriteLine("Registering RSS Scheduler complete.");
});
}
public void GetItemsForFeedWithRssRdfv091()
{
using (var stream = Resources.Resource.GetResourceAsStream("TestFeeds.rss_rdf_0_91.xml"))
{
NewsFeed f = new NewsFeed();
f.link = TEST_BASE_URL + "rss_rdf_0_91.xml";
var feedInfo = RssParser.GetItemsForFeed(f, stream, false, true);
Assert.IsNotNull(feedInfo);
Assert.IsNotNull(feedInfo.ItemsList);
Assert.AreEqual(40, feedInfo.ItemsList.Count);
Assert.AreEqual(new DateTime(2013, 9, 12, 12, 0, 0, DateTimeKind.Utc), feedInfo.ItemsList[39].Date);
string requestUrl = null;
var xElem = RssHelper.GetOptionalElement(feedInfo.OptionalElements, "image");
if (xElem != null)
{
var urlNode = xElem.SelectSingleNode("url");
if (urlNode != null)
{
requestUrl = urlNode.InnerText;
}
}
Assert.AreEqual("http://www.golem.de/staticrl/images/golem-rss.png", requestUrl);
}
}
/// <summary>
/// Adds the or replace the optional feed reference element.
/// </summary>
/// <param name="newsItem">The news item.</param>
/// <param name="feedUrl">The feed URL.</param>
/// <param name="sourceID">The source ID.</param>
/// <returns></returns>
public static XmlElement AddOrReplaceOriginalFeedReference(INewsItem newsItem, string feedUrl, int sourceID)
{
if (newsItem == null)
{
throw new ArgumentNullException("newsItem");
}
XmlQualifiedName key = AdditionalElements.GetQualifiedName(OriginalFeedRef);
XmlQualifiedName attrKey = AdditionalElements.GetQualifiedName(OriginalSourceID);
if (newsItem.OptionalElements == null)
{
newsItem.OptionalElements = new Dictionary <XmlQualifiedName, string>(2);
}
if (newsItem.OptionalElements.ContainsKey(key))
{
newsItem.OptionalElements.Remove(key);
}
XmlElement element = RssHelper.CreateXmlElement(Prefix, key, feedUrl);
element.Attributes.Append(RssHelper.CreateXmlAttribute(String.Empty, attrKey, sourceID.ToString()));
newsItem.OptionalElements.Add(key, element.OuterXml);
return(element);
}
private void EndGetResponse(IAsyncResult result)
{
try{
var state = result.AsyncState as MainViewModel.RequestState;
WebResponse response = state.Request.EndGetResponse(result);
Rss.Structure.RssFeed rss = RssHelper.ReadRss(response.GetResponseStream());
if (rss.Channel == null)
{
Deployment.Current.Dispatcher.BeginInvoke(() => UrlStatus = invalidRssFeed);
}
else
{
Deployment.Current.Dispatcher.BeginInvoke(() => UrlStatus = validRssFeed);
if (!isolatedStorageSettings.Contains(RssFeedKey))
{
isolatedStorageSettings[RssFeedKey] = new RssFeed();
}
var rssFeed = isolatedStorageSettings[RssFeedKey] as RssFeed;
rssFeed.RssLink = state.Address;
rssFeed.RssTitle = rss.Channel.Title.ToLower();
rssFeed.LastUpdated = DateTime.Now;
rssFeed.Stories = new ObservableCollection <RssStory>(RssFeed.CloneStories(rss));
}
} catch (Exception exception) {
Debug.Assert(exception != null);
Deployment.Current.Dispatcher.BeginInvoke(() => UrlStatus = invalidRssFeed);
}
}
public void Test_RssHelper_Read_From_Torrentz()
{
var target = new RssHelper();
var feed = target.GetFeedFromSite(_popularTorrentzFeed);
Assert.IsInstanceOfType(feed, typeof(SyndicationFeed));
}
/// <summary>
/// Is an update check needed?
/// </summary>
/// <returns>bool true if yes</returns>
public static bool IsUpdateCheckNeeded()
{
lock (LockObject)
{
if (CoreConfig.UpdateCheckInterval == 0)
{
return(false);
}
var checkTime = CoreConfig.LastUpdateCheck;
checkTime = checkTime.AddDays(CoreConfig.UpdateCheckInterval);
if (DateTime.Now.CompareTo(checkTime) < 0)
{
Log.Debug().WriteLine("No need to check RSS feed for updates, feed check will be after {0}", checkTime);
return(false);
}
Log.Debug().WriteLine("Update check is due, last check was {0} check needs to be made after {1} (which is one {2} later)", CoreConfig.LastUpdateCheck, checkTime,
CoreConfig.UpdateCheckInterval);
if (!RssHelper.IsRssModifiedAfter(CoreConfig.LastUpdateCheck))
{
Log.Debug().WriteLine("RSS feed has not been updated since after {0}", CoreConfig.LastUpdateCheck);
return(false);
}
}
return(true);
}
private void CreateTopicRssFeed()
{
var rss = new RssHelper();
var siteUrl = Url();
var writer = new XmlTextWriter(Response.OutputStream, System.Text.Encoding.UTF8);
rss.WriteRssPrologue(writer, Settings.Name, siteUrl);
var maintopics = (from t in Factory.ReturnAllTopicsInCategory(CurrentNode.Id)
select t).Take(Settings.TopicsPerPage);
foreach (var topic in maintopics)
{
var latestPost = topic.GetLatestPost();
rss.AddRssItem(writer, topic.Name, siteUrl + topic.Url, latestPost.Content, latestPost.CreatedOn, true);
}
rss.WriteRssClosing(writer);
writer.Flush();
writer.Close();
Response.ContentEncoding = System.Text.Encoding.UTF8;
Response.ContentType = "text/xml";
Response.Cache.SetCacheability(HttpCacheability.Public);
Response.End();
}
public CurrentConditions GetCurrentConditionFromXDoc(XDocument doc)
{
var returnCondition = new CurrentConditions();
//populate feedItem
foreach (var currentObs in doc.Descendants("current_observation"))
{
if (currentObs == null)
{
continue;
}
returnCondition.SugPickup = RssHelper.GetStringFromValue(currentObs.Element("suggested_pickup"));
returnCondition.SugPickupPeriod = RssHelper.GetStringFromValue(currentObs.Element("suggested_pickup_period"));
returnCondition.StationID = RssHelper.GetStringFromValue(currentObs.Element("station_id"));
returnCondition.Latitude = RssHelper.GetDecimalFromValue(currentObs.Element("latitude"));
returnCondition.Longitude = RssHelper.GetDecimalFromValue(currentObs.Element("longitude"));
returnCondition.ObsTime = RssHelper.GetDateTimeFromValue(currentObs.Element("observation_time_rfc822"));
returnCondition.Weather = RssHelper.GetStringFromValue(currentObs.Element("weather"));
returnCondition.TempF = RssHelper.GetDecimalFromValue(currentObs.Element("temp_f"));
returnCondition.RelHumidity = RssHelper.GetDecimalFromValue(currentObs.Element("relative_humidity"));
returnCondition.WindDir = RssHelper.GetStringFromValue(currentObs.Element("wind_dir"));
returnCondition.WindDegrees = RssHelper.GetIntFromValue(currentObs.Element("wind_degrees"));
returnCondition.WindMPH = RssHelper.GetDecimalFromValue(currentObs.Element("wind_mph"));
returnCondition.PressureIn = RssHelper.GetDecimalFromValue(currentObs.Element("pressure_in"));
returnCondition.DewPointF = RssHelper.GetDecimalFromValue(currentObs.Element("dewpoint_f"));
returnCondition.VisibilityMiles = RssHelper.GetDecimalFromValue(currentObs.Element("visibility_mi"));
break;
}
return(returnCondition);
}
void saveNewCastsToDb(Feed feed, RssHelper rssFeed)
{
int newCasts = 0;
foreach (var rss in rssFeed.RssDnldInfos)
{
//Application.Current.Dispatcher.BeginInvoke(new Action(() => { // new Func<bool>(() => //tu: new Action(() =>
DnLd dl;
if (SaveToDnldRow_IsDnldRequired(feed, rss, out dl))
{
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
if (!CurrentDnLds.Contains(dl))
{
CurrentDnLds.Add(dl);
}
}));
newCasts++;
//? better wait for all feeds check to finish and then move on to dnlding: if (IsAutoNextStep) Dh.StartDownload(db, dl, dgD); //Dh.LaunchIfDownloadRequiredMvvm(dl, ((DataGrid)dgD));
}
//}));
}
feed.CastQntNew = newCasts;
feed.CastQntTtl = rssFeed.RssDnldInfos.Count;
feed.StatusInfo = $"{newCasts} / {rssFeed.RssDnldInfos.Count}"; //update feed with counts of new casts
feed.LastCheckedAt = _now;
}
void DoFeed(Feed feed)
{
feed.StatusInfo = "...";
var rssFeed = RssHelper.DoFeed(feed);
saveNewCastsToDb(feed, rssFeed);
}
public string GenerateRss()
{
var fullurl = this.Url.RouteUrl("Home");
string baseurl = fullurl;
RssHelper r = new RssHelper(_dbhelper, _blogsettings);
return(r.GenerateRss(baseurl));
}
static void Main(string[] args)
{
RssRepository RssRepository = new RssRepository();
RssHelper helper = new RssHelper(RssRepository);
helper.ReadXmlFile("Habr.xml");
Console.ReadLine();
}
private void Bind()
{
var webRequestHelper = new WebRequestHelper();
webRequestHelper.EnableCaching = true;
webRequestHelper.CacheDurationInSeconds = AppSettings.WebRequestCacheDurationInSeconds;
ItemsList.DataSource = RssHelper.GetRssItems(webRequestHelper.MakeWebRequest(feedUrl), numberOfItemsToPull);
ItemsList.DataBind();
}
public void FetchRssFeed()
{
new Thread(new ThreadStart(() => {
try
{
if (MainWindow._current._configClient.GetVar("FirstRun") == "True")
{
MainWindow._current._configClient.SetVar("RSS", JsonConvert.SerializeObject(new string[] { "https://www.cnet.com/rss/news/", "https://www.cnet.com/rss/reviews/" }));
}
RssFeed rs;
foreach (string l in JsonConvert.DeserializeObject <string[]>(MainWindow._current._configClient.GetVar("RSS")))
{
rs = RssHelper.ReadFeed(@l);
foreach (RssItem r in rs.Items)
{
Dispatcher.Invoke(() =>
{
news.Children.Add(new Separator()
{
Width = 8
});
Card t = new Card();
StackPanel Items = new StackPanel();
TextBlock text = new TextBlock();
text.Text = r.Title;
text.FontSize = 16;
text.TextWrapping = TextWrapping.Wrap;
text.FontFamily = new FontFamily(@"pack://application:,,,/MaterialDesignThemes.Wpf;component/Resources/Roboto/#Roboto");
text.Height = 75;
text.Padding = new Thickness(5, 0, 5, 2);
Button b = new Button();
b.Style = (Style)Application.Current.Resources["MaterialDesignFlatButton"];
b.Click += (object sender, RoutedEventArgs e) => { Process.Start(r.Link); };
b.Content = "Read More...";
b.HorizontalAlignment = HorizontalAlignment.Right;
t.Height = news.Height - 15;
news.Width += t.Width;
Items.Width = 200;
Items.Height = 100;
Items.Children.Add(text);
Items.Children.Add(b);
t.Content = Items;
news.Children.Add(t);
});
}
}
}
catch
{
// shall we repeat the code above or what?
}
})).Start();
}
/// <summary>
/// Populates the page with content passed during navigation. Any saved state is also
/// provided when recreating a page from a prior session.
/// </summary>
/// <param name="sender">
/// The source of the event; typically <see cref="NavigationHelper"/>
/// </param>
/// <param name="e">Event data that provides both the navigation parameter passed to
/// <see cref="Frame.Navigate(Type, Object)"/> when this page was initially requested and
/// a dictionary of state preserved by this page during an earlier
/// session. The state will be null the first time a page is visited.</param>
private async void navigationHelper_LoadState(object sender, LoadStateEventArgs e)
{
// TODO: Create an appropriate data model for your problem domain to replace the sample data
var item = await SampleDataSource.GetItemAsync((String)e.NavigationParameter);
//this.DefaultViewModel["Item"] = item;
ResultWebView.NavigateToString(await RssHelper.GetFeedTitleAsync());
}
public RssItem[] EndGetRss(IAsyncResult asyncResult)
{
CustomAsyncResult <WebRequestState> myAsyncResult = (CustomAsyncResult <WebRequestState>)asyncResult;
WebRequestState myState = myAsyncResult.AdditionalData;
var result = RssHelper.ConvertXmlToRss(XElement.Load(new XmlTextReader(CompleteGetUrl(asyncResult))), myState.Count).ToArray();
WebOperationContext.Current.OutgoingResponse.ContentType = "application/json; charset=utf-8";
return(result);
}
public async Task <IActionResult> PreviewRss([FromQuery(Name = "RssUrl")] string rssUrl)
{
var feed = await RssHelper.GetNewsFeed(rssUrl);
// var response = new RssPreviewResponseDto() {
// FeedList = feed
// };
return(Ok(feed));
}
public async Task Execute(IJobExecutionContext context)
{
try
{
var mappedData = context.MergedJobDataMap;
var rss = _userRssService.Get(x => x.Id == mappedData.GetString(ScheduleConsts.RSS_ID));
if (rss == null)
{
return;
}
var subscription = _userSubscribeService.Get(x => x.Id == context.Trigger.Key.Name);
if (subscription == null)
{
return;
}
var latestNews = RssHelper.GetLatestUpdates(_logService, rss.Url, subscription.CheckDate.AddHours(3));
if (latestNews.Any())
{
var user = _userService.Get(x => x.Id == mappedData.GetString(ScheduleConsts.USER_ID));
var group = _telegramGroupService.Get(x => x.Id == mappedData.GetString(ScheduleConsts.GROUP_ID));
foreach (var item in latestNews)
{
string link;
if (item.Links.FirstOrDefault() == null)
{
link = ((TextSyndicationContent)item.Content).Text;
}
else
{
link = item.Links.FirstOrDefault().Uri.AbsoluteUri;
}
_telegramBotClient.SendTextMessageAsync(group.ChatId, link);
_logService.Save(new dal.entities.NotifierLog
{
LogLevel = (short)enums.LogLevel.RSS_SENT_INFO,
Message = string.Concat(rss.UserId, " ", group.ChatId),
StackTrace = link,
});
}
subscription.CheckDate = DateTime.Now;
_userSubscribeService.Save(subscription);
}
}
catch (Exception ex)
{
_logService.InsertLog(ex, enums.LogLevel.RSS_READ_ERROR);
}
}
public IActionResult Index()
{
// string url = "http://feeds.reuters.com/news/artsculture?format=xml";
// ViewBag.itemlist = RssHelper.Read(url);
string url = "https://www.espncricinfo.com/rss/content/story/feeds/2.xml";
var data = RssHelper.CricketRss(url);
ViewBag.itemlist = RssHelper.CricketRss(url);
return(View());
}
public async Task UpdateAsync(string callSign)
{
//download file
var localPath = Path.Combine(Constants.BaseFilePath, "CurrentConditions", callSign);
var url = CurrentConditions.UrlTemplate.Replace("xxxx", callSign);
var result = await RssHelper.GetStreamAsync(url, localPath);
//parse file
var doc = RssHelper.GetXDocFromFile(localPath);
var currentConditions = GetCurrentConditionFromXDoc(doc);
//save to db
}
public static async Task <ObservableCollection <LearningResource> > GetBlogs(string url)
{
try
{
RssFeed feed = null;
await Task.Factory.StartNew(
() =>
{
try
{
feed =
RssHelper.ReadFeed(new Uri(url));
}
catch (Exception ex)
{
}
});
ObservableCollection <LearningResource> learningResources = new ObservableCollection <LearningResource>();
if (feed == null)
{
return(null);
}
foreach (var item in feed.Items)
{
try
{
LearningResource v = new LearningResource();
v.Description = HtmlUtilities.ConvertToText(item.Description)
.Replace("\n", "")
.Replace("\r", "");
v.Link = item.Link;
v.Title = item.Title;
v.PublicationTime = item.PublicationUtcTime;
learningResources.Add(v);
}
catch (Exception)
{
//
}
}
return(learningResources);
}
catch (Exception ex)
{
return(null);
}
}
private static Episode Map(Item item)
{
var description = item.Summary ?? item.Description ?? throw new ArgumentNullException(nameof(Item.Description));
var duration = RssHelper.ConvertDuration(item.Duration);
var @explicit = !string.IsNullOrEmpty(item.Explicit) ? item.Explicit : "no";
var pubDate = RssHelper.ConvertDateTime(item.PubDate).GetValueOrDefault();
var url = item.Enclosure !.Url ?? throw new ArgumentNullException(nameof(Enclosure.Url));
var episode = new Episode(description, duration, @explicit, pubDate, item.Title, url);
return(episode);
}
public void Execute()
{
Session session = SessionHelper.GetSession(_messageEventArgs.Message.From.Id);
if (session.InstructionId.Equals(NextInstruction.None))
{
return;
}
if (session.InstructionId.Equals(NextInstruction.AddRss))
{
if (RssHelper.IsRss(_messageEventArgs.Message.Text.Trim()))
{
Response <RssEntity> Validation = _queryRssService.Get(_messageEventArgs.Message.From.Id, _messageEventArgs.Message.Text.Trim());
if (Validation.ResponseData == null)
{
session.InstructionId = NextInstruction.AddAlias;
_telegramBotClient.SendTextMessageAsync(_messageEventArgs.Message.Chat.Id, $"enter alias name for the rss.").GetAwaiter();
session.Payload = _messageEventArgs.Message.Text.Trim();
}
else
{
_telegramBotClient.SendTextMessageAsync(_messageEventArgs.Message.Chat.Id, "rss is already exist in list.").GetAwaiter();
}
}
else
{
_telegramBotClient.SendTextMessageAsync(_messageEventArgs.Message.Chat.Id, "rss is not found. please enter valid url.").GetAwaiter();
}
}
else if (session.InstructionId.Equals(NextInstruction.AddAlias))
{
Response <int> response = _commandRssService.Add(new RssEntity()
{
Url = session.Payload, AliasName = _messageEventArgs.Message.Text.Trim(), UserId = _messageEventArgs.Message.From.Id
});
if (response.Type.Equals(ResponseType.Success))
{
_telegramBotClient.SendTextMessageAsync(_messageEventArgs.Message.Chat.Id, "rss added to list").GetAwaiter();
session.InstructionId = NextInstruction.None;
}
else if (response.Type.Equals(ResponseType.AlreadyExist))
{
_telegramBotClient.SendTextMessageAsync(_messageEventArgs.Message.Chat.Id, "alias name is already exist. please enter unique name").GetAwaiter();
}
}
else if (session.InstructionId.Equals(NextInstruction.BugReport))
{
RssFeedHelper.SaveBugReport($"bug from {_messageEventArgs.Message.Chat.Id}", _messageEventArgs.Message.Text);
_telegramBotClient.SendTextMessageAsync(_messageEventArgs.Message.Chat.Id, "thank you for your report.").GetAwaiter();
session.InstructionId = NextInstruction.None;
}
}
static void Main(string[] args)
{
foreach (string link in links)
{
RssHelper rssHelper = new RssHelper(link);
channel = rssHelper.Channel;
articles = rssHelper.Articles;
writeToDB();
printInfo();
countOfSavedArticles = 0;
}
Console.Read();
}
private string GetCachedJSON()
{
if (Services.Get <ICache>().Contains(this.Url))
{
var cachedRSS = XElement.Load(new StringReader(Services.Get <ICache>().Get(this.Url) as string));
var rss = RssHelper.ConvertXmlToRss(cachedRSS, this.Count);
string json = new System.Web.Script.Serialization.JavaScriptSerializer().Serialize(rss);
return(json);
}
else
{
return(null);
}
}
private void EndGetResponse(IAsyncResult result)
{
try
{
var state = result.AsyncState as RequestState;
WebResponse response = state.Request.EndGetResponse(result);
Rss.Structure.RssFeed rss = RssHelper.ReadRss(response.GetResponseStream());
Deployment.Current.Dispatcher.BeginInvoke(() => IsDataLoaded = true);
Deployment.Current.Dispatcher.BeginInvoke(() => UpdateRssFeed(rss, state.RssFeed));
} catch (Exception exception) {
Deployment.Current.Dispatcher.BeginInvoke(() => IsDataLoaded = true);
Deployment.Current.Dispatcher.BeginInvoke(() => MessageBox.Show(exception.Message));
}
}
// GET: Rss
public ActionResult CreateExam()
{
if (Session["LogedUserID"] == null)
{
return(RedirectToAction("../Users/Login"));
}
else
{
string url = "https://www.wired.com/category/science/science-blogs/feed/";
var listitems = RssHelper.read(url);
ViewBag.listItem = listitems;
return(View());
}
}
private void RefreshData()
{
if (NetworkInterface.GetIsNetworkAvailable())
{
ThreadPool.QueueUserWorkItem((action) => RssHelper.LoadTwitterFeedIntoListBox(DirectorTweets, RSS_Director));
ThreadPool.QueueUserWorkItem((action) => RssHelper.LoadCalendarFeedIntoListBox(BandEvents, RSS_Band));
ThreadPool.QueueUserWorkItem((action) => RssHelper.LoadCalendarFeedIntoListBox(GuardEvents, RSS_Guard));
ThreadPool.QueueUserWorkItem((action) => RssHelper.LoadTwitterFeedIntoListBox(DistrictFeed, RSS_FriscoISD));
}
else
{
MessengerInstance.Send <NetworkUnavailableMessage>(new NetworkUnavailableMessage());
}
}
public void GetItemsForFeedWithRssv20NoDates()
{
using (var stream = Resources.Resource.GetResourceAsStream("TestFeeds.rss_2_0_no_dates.xml"))
{
// ensure the self-assigned item dates are all older than this:
DateTime utcNow = DateTime.UtcNow + TimeSpan.FromMinutes(1);
NewsFeed f = new NewsFeed();
f.link = TEST_BASE_URL + "rss_2_0_no_dates.xml";
var feedInfo = RssParser.GetItemsForFeed(f, stream, false, true);
Assert.IsNotNull(feedInfo);
Assert.IsNotNull(feedInfo.ItemsList);
Assert.AreEqual(10, feedInfo.ItemsList.Count);
INewsItem recent = null;
foreach (var item in feedInfo.ItemsList)
{
// items ordered newest first:
Assert.IsTrue(item.Date < utcNow);
if (recent != null)
{
Assert.IsTrue(item.Date < recent.Date);
}
recent = item;
}
string optElement = null;
var xElem = RssHelper.GetOptionalElement(feedInfo.OptionalElements, "ttl");
if (xElem != null)
{
optElement = xElem.InnerText;
}
Assert.AreEqual("60", optElement);
optElement = null;
xElem = RssHelper.GetOptionalElement(feedInfo.OptionalElements, "managingEditor");
if (xElem != null)
{
optElement = xElem.InnerText;
}
Assert.AreEqual("*****@*****.**", optElement);
optElement = null;
xElem = RssHelper.GetOptionalElement(feedInfo.OptionalElements, "copyright");
if (xElem != null)
{
optElement = xElem.InnerText;
}
Assert.AreEqual("Copyright 2008 Ziff Davis Media Inc. All Rights Reserved.", optElement);
}
}
