private void ScheduleForUpdate(IResource root) { RSSPlugin plug = RSSPlugin.GetInstance(); if (plug == null) { return; } foreach (IResource res in root.GetLinksTo(null, Core.Props.Parent).ValidResources) { if (res.Type == "RSSFeedGroup") { ScheduleForUpdate(res); } else if (res.Type == "RSSFeed" && _oldRSSFeedList.IndexOf(res) == -1) { if (!res.HasProp(Props.UpdateFrequency) || !res.HasProp(Props.UpdatePeriod)) { res.SetProp(Props.UpdateFrequency, 4); res.SetProp(Props.UpdatePeriod, UpdatePeriods.Hourly); } plug.ScheduleFeedUpdate(res); } } }
private static int ConfirmImportRecursive(IResource res) { int count = 0; foreach (IResource child in res.GetLinksTo(null, Core.Props.Parent)) { if (child.Type == "RSSFeedGroup") { int childCount = ConfirmImportRecursive(child); if (childCount == 0) { child.Delete(); } count += childCount; } else if (child.GetIntProp(Props.Transient) == 1) { IResourceList items = child.GetLinksOfType("RSSItem", Props.RSSItem); items.DeleteAll(); child.Delete(); } else { if (RSSPlugin.GetInstance() != null) { RSSPlugin.GetInstance().QueueFeedUpdate(child); } count++; } } return(count); }
private void ProcessUrlDrop(IResource targetResource, IDataObject data, string format, Encoding encoding) { Stream dataStream = (Stream)data.GetData(format); if (dataStream != null) { string url = Utils.StreamToString(dataStream, encoding); RSSPlugin.GetInstance().ShowAddFeedWizard(url, targetResource); } }
internal void ExecuteOperation() { IResource rootGroup = _importRoot; if (_importPreview) { _previewRoot = Core.ResourceStore.NewResource("RSSFeedGroup"); rootGroup = _previewRoot; } bool hasOPML = true; try { hasOPML = OPMLProcessor.Import(new StreamReader(_importStream), rootGroup, !_importPreview); } catch (Exception ex) { MessageBox.Show(Core.MainWindow, "Error importing OPML file " + _importFileName + ":\n" + ex.Message, "Import OPML", MessageBoxButtons.OK); // the import may have been partially successful, and we still want to // update the feeds that were imported successfully } if (!hasOPML) { MessageBox.Show(Core.MainWindow, _importFileName + " is not an OPML file", "Import OPML", MessageBoxButtons.OK); return; } if (_importPreview) { if (_previewRoot.GetLinksOfType(null, "Parent").Count > 0) { Core.UIManager.QueueUIJob(new MethodInvoker(ShowImportPreviewDialog)); } else { _previewRoot.Delete(); } } else { foreach (IResource feed in Core.ResourceStore.GetAllResources("RSSFeed")) { if (!feed.HasProp(Props.LastUpdateTime) && !feed.HasProp(Props.ItemCommentFeed)) { RSSPlugin.GetInstance().QueueFeedUpdate(feed); } } } }
internal OPMLImporter(ImportManager manager, IResource importRoot) { if (manager == null) { RSSPlugin.GetInstance().RegisterFeedImporter("OPML Files", this); } else { _manager = manager; _importRoot = importRoot; } }
/// <summary> /// Import subscription /// </summary> public void DoImport(IResource importRoot, bool addToWorkspace) { if (_login.Length == 0 || _password.Length == 0) { return; } RSSPlugin plugin = RSSPlugin.GetInstance(); string authInfo = Convert.ToBase64String(Encoding.ASCII.GetBytes(_login + ":" + _password)); ImportUtils.UpdateProgress(0, _progressMessage); importRoot = plugin.FindOrCreateGroup("Bloglines Subscriptions", importRoot); ImportUtils.UpdateProgress(10, _progressMessage); WebClient client = new WebClient(); client.Headers.Add("Authorization", "basic " + authInfo); ImportUtils.UpdateProgress(20, _progressMessage); try { Stream stream = client.OpenRead(_ImportURL); ImportUtils.UpdateProgress(30, _progressMessage); OPMLProcessor.Import(new StreamReader(stream), importRoot, addToWorkspace); ImportUtils.UpdateProgress(90, _progressMessage); } catch (Exception ex) { Trace.WriteLine("BlogLines subscrption load failed: '" + ex.Message + "'"); RemoveFeedsAndGroupsAction.DeleteFeedGroup(importRoot); string message = "Import of BlogLines subscription failed:\n" + ex.Message; if (ex is WebException) { WebException e = (WebException)ex; if (e.Status == WebExceptionStatus.ProtocolError && ((HttpWebResponse)e.Response).StatusCode == HttpStatusCode.Unauthorized) { message = "Import of BlogLines subscription failed:\nInvalid login or password."; } } ImportUtils.ReportError("BlogLines Subscription Import", message); } ImportUtils.UpdateProgress(100, _progressMessage); return; }
private void OnSaveFeedImpl() { foreach (IResource feed in _feeds) { feed.BeginUpdate(); } if (!_chkAuthentication.Checked) { _edtUserName.Text = string.Empty; _edtPassword.Text = string.Empty; } _needUpdate = _needUpdate || _udUpdateFrequency.Changed || _cmbUpdatePeriod.Changed; if (!_chkUpdate.Checked) { _cmbUpdatePeriod.SetValue("daily"); _cmbUpdatePeriod.Changed = true; _udUpdateFrequency.Minimum = -1; _udUpdateFrequency.SetValue(-1); _udUpdateFrequency.Changed = true; } SettingSaver.Save(Controls); if (_feeds.Count == 1) { _feed.SetProp(Props.URL, _edtAddress.Text); _feed.SetProp(Core.Props.Name, _edtTitle.Text); _feed.SetProp(Core.Props.Annotation, _edtAnnotation.Text); } foreach (IResource feed in _feeds) { feed.EndUpdate(); } if (_needUpdate) { foreach (IResource feed in _feeds) { RSSPlugin.GetInstance().QueueFeedUpdate(feed); } } }
internal static void DoConfirmImport(IResource previewRoot, IResource importRoot) { foreach (IResource res in previewRoot.GetLinksTo(null, Core.Props.Parent)) { if (res.Type == "RSSFeedGroup") { int count = ConfirmImportRecursive(res); if (count == 0) { res.Delete(); continue; } if (RelinkExistingGroup(res, importRoot)) { continue; } Core.WorkspaceManager.AddToActiveWorkspaceRecursive(res); } if (res.Type == "RSSFeed" && res.GetIntProp(Props.Transient) == 1) { // Delete all items IResourceList items = res.GetLinksOfType("RSSItem", Props.RSSItem); items.DeleteAll(); res.Delete(); } else { res.DeleteProp(Props.Transient); res.SetProp(Core.Props.Parent, importRoot); if (res.Type == "RSSFeed") { Core.WorkspaceManager.AddToActiveWorkspace(res); if (RSSPlugin.GetInstance() != null) { RSSPlugin.GetInstance().QueueFeedUpdate(res); } } } } previewRoot.Delete(); }
public FeedDemonImporter() { bool FeedDemonFound = true; string basePath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData); string daemonPath = Path.Combine(basePath, @"Bradsoft.com\FeedDemon\1.0"); _channelsPath = Path.Combine(daemonPath, "Channels"); _groupsPath = Path.Combine(daemonPath, "Groups"); FeedDemonFound = Directory.Exists(_channelsPath) && Directory.Exists(_groupsPath); if (!FeedDemonFound) { // don't build additional data structures return; } RSSPlugin.GetInstance().RegisterFeedImporter("FeedDemon", this); _flag = Core.ResourceStore.FindUniqueResource("Flag", "FlagId", "RedFlag"); }
internal BloglinesImporter() { RSSPlugin.GetInstance().RegisterFeedImporter("Bloglines", this); }
/// <summary> /// Import subscription /// </summary> public void DoImport(IResource importRoot, bool addToWorkspace) { if (null == FileNames) { return; } int totalFeeds = Math.Max(FileNames.Length, 1); int processedFeeds = 0; ImportUtils.UpdateProgress(processedFeeds / totalFeeds, _progressMessage); IResource currentRoot = null; foreach (string fileName in FileNames) { string defaultName = null; Stream opml = null; if (!File.Exists(fileName)) { defaultName = fileName; // Try to load as URL try { opml = new JetMemoryStream(new WebClient().DownloadData(fileName), true); } catch (Exception ex) { Trace.WriteLine("OPML file '" + fileName + "' can not be load: '" + ex.Message + "'"); opml = null; } } else { defaultName = Path.GetFileName(fileName); // Try to load title from this file try { opml = new FileStream(fileName, FileMode.Open, FileAccess.Read); } catch (Exception ex) { Trace.WriteLine("OPML file '" + fileName + "' can not be load: '" + ex.Message + "'"); opml = null; } } if (null == opml) { continue; } // Try to get name string name = null; try { XmlDocument xml = new XmlDocument(); xml.Load(opml); XmlElement title = xml.SelectSingleNode("/opml/head/title") as XmlElement; name = title.InnerText; } catch (Exception ex) { Trace.WriteLine("OPML file '" + fileName + "' doesn't have title: '" + ex.Message + "'"); } if (name == null || name.Length == 0) { name = defaultName; } try { opml.Seek(0, SeekOrigin.Begin); if (_manager == null || FileNames.Length > 1) { currentRoot = RSSPlugin.GetInstance().FindOrCreateGroup("Subscription from " + name, importRoot); } else { currentRoot = importRoot; } OPMLProcessor.Import(new StreamReader(opml), currentRoot, addToWorkspace); } catch (Exception ex) { Trace.WriteLine("OPML file '" + fileName + "' can not be load: '" + ex.Message + "'"); RemoveFeedsAndGroupsAction.DeleteFeedGroup(currentRoot); ImportUtils.ReportError("OPML File Import", "Import of OPML file '" + fileName + "' failed:\n" + ex.Message); } processedFeeds += 100; ImportUtils.UpdateProgress(processedFeeds / totalFeeds, _progressMessage); } return; }
public override void DisplayResource(IResource rssItem, WordPtr[] wordsToHighlight) { string subject = rssItem.GetPropText(Core.Props.Subject); ShowSubject(subject, wordsToHighlight); IResource feed = rssItem.GetLinkProp(-Props.RSSItem); if (feed != null && feed.HasProp(Props.AutoFollowLink) && rssItem.GetPropText(Props.Link).Length > 0) { AttachWebBrowser(); Core.WebBrowser.NavigateInPlace(rssItem.GetPropText(Props.Link)); } else { StringBuilderDecor decor = new StringBuilderDecor("<html>"); decor.AppendText(GetItemStyle()); decor.AppendText(Core.MessageFormatter.StandardStyledHeader(subject)); string body = rssItem.GetPropText(Core.Props.LongBody); if (_showSummary) { RssBodyConstructor.ConstructSummary(rssItem, SummaryStyle, body, decor); } //------------------------------------------------------------- // Update the search results offsets //------------------------------------------------------------- if (wordsToHighlight != null) { int inc = decor.ToString().Length; // Prepended length for (int a = 0; a < wordsToHighlight.Length; a++) { wordsToHighlight[a].StartOffset += inc; } } ProcessBody(decor, body, rssItem); //------------------------------------------------------------- if (!_useDetailedURLs) { RssBodyConstructor.AppendLink(rssItem, decor, cLinkAlias); } else { RssBodyConstructor.AppendLink(rssItem, decor); } RssBodyConstructor.AppendRelatedPosts(rssItem, decor, _useDetailedURLs); RssBodyConstructor.AppendEnclosure(rssItem, decor); RssBodyConstructor.AppendSourceTag(rssItem, decor); RssBodyConstructor.AppendCommentsTag(rssItem, decor); decor.AppendText("</body></html>"); ShowHtml(decor.ToString(), _ctxRestricted, wordsToHighlight); } IResourceList feeds = rssItem.GetLinksOfType(Props.RSSFeedResource, Props.RSSItem); IResource owner = Core.ResourceBrowser.OwnerResource; if ((owner != null && owner.Type == Props.RSSFeedGroupResource) || (feeds.Count > 0 && owner == feeds [0])) { RSSPlugin.GetInstance().RememberSelection(owner, rssItem); } }
private void OnFinishClick() { Trace.WriteLine("SubscribeToSearchFeeds -- OnFinishClick."); _nextButton.Enabled = false; if (_feedsToSubscribe == null) { throw new InvalidOperationException("Trying to finish wizard with unknown feeds to subscribe"); } if (_feedsToSubscribe.Length == 0) { DoCancel(); Close(); return; } if (_feedsToSubscribe.Length == 1 && RSSPlugin.GetExistingFeed(_feedsToSubscribe [0].Resource.GetStringProp(Props.URL)) != null) { MessageBox.Show(this, "You have already subscribed to this feed.", "Subscribe to Feed"); DoCancel(); return; } IResource parentGroup = _titleGroupPane.SelectedGroup; if (parentGroup == null) { parentGroup = RSSPlugin.RootFeedGroup; } Trace.WriteLine("SubscribeToSearchFeeds -- Starting to link feeds to parent."); foreach (ResourceProxy proxy in _feedsToSubscribe) { if (proxy == _newFeedProxy) { _newFeedProxy = null; } proxy.BeginUpdate(); try { if (_feedsToSubscribe.Length == 1) { proxy.SetProp(Core.Props.Name, _titleGroupPane.FeedTitle); } proxy.DeleteProp(Props.Transient); proxy.SetProp(Core.Props.Parent, parentGroup); Trace.WriteLine("SubscribeToSearchFeeds -- Link feed to parent [" + parentGroup.DisplayName + "]"); } finally { proxy.EndUpdate(); Trace.WriteLine("SubscribeToSearchFeeds -- EndUpdate called for a feed"); } Core.WorkspaceManager.AddToActiveWorkspace(proxy.Resource); Trace.WriteLine("SubscribeToSearchFeeds -- AddToActiveWorkspace called for a feed."); RSSPlugin.GetInstance().QueueFeedUpdate(proxy.Resource); Trace.WriteLine("SubscribeToSearchFeeds -- QueueFeedUpdate called for a feed."); } Core.UIManager.BeginUpdateSidebar(); if (Core.TabManager.ActivateTab("Feeds")) { Core.LeftSidebar.ActivateViewPane("Feeds"); } Core.UIManager.EndUpdateSidebar(); RSSPlugin.RSSTreePane.SelectResource(_feedsToSubscribe [0].Resource); RSSPlugin.SaveSubscription(); _newFeedProxy = null; _feedsToSubscribe = null; Close(); }
/// <summary> /// Import subscription /// </summary> public void DoImport(IResource importRoot, bool addToWorkspace) { RSSPlugin plugin = RSSPlugin.GetInstance(); importRoot = plugin.FindOrCreateGroup("FeedDemon subscriptions", importRoot); // Count full count of resources string[] allFiles = Directory.GetFiles(_groupsPath, "*.opml"); int totalFiles = Math.Max(allFiles.Length, 1); int processedFiles = 0; ImportUtils.UpdateProgress(processedFiles / totalFiles, _progressMessage); foreach (string file in allFiles) { IResource group = null; string name = Path.GetFileNameWithoutExtension(file); group = plugin.FindOrCreateGroup(name, importRoot); try { Hashtable ns = new Hashtable(); Stream stream = new FileStream(file, FileMode.Open, FileAccess.Read); // Fix bugs in OPML ns["fd"] = _fdNS; OPMLProcessor.Import(new StreamReader(stream), group, addToWorkspace, ns); } catch (Exception ex) { RemoveFeedsAndGroupsAction.DeleteFeedGroup(group); ImportUtils.ReportError("FeedDemon Subscription Import", "Import of FeedDemon group '" + name + "' failed:\n" + ex.Message); } processedFiles += 100; ImportUtils.UpdateProgress(processedFiles / totalFiles, _progressMessage); } // Read summary.xml string summary = Path.Combine(_channelsPath, "summary.xml"); if (File.Exists(summary)) { try { XmlDocument xdoc = new XmlDocument(); xdoc.Load(summary); foreach (XmlElement channel in xdoc.GetElementsByTagName("channel")) { string title = null; string url = null; XmlNodeList l = null; l = channel.GetElementsByTagName("title"); if (l.Count < 1) { continue; } title = l[0].InnerText; l = channel.GetElementsByTagName("newsFeed"); if (l.Count < 1) { continue; } url = l[0].InnerText; _name2url.Add(title, url); } } catch (Exception ex) { Trace.WriteLine("FeedDemon subscrption load failed: '" + ex.Message + "'"); } } return; }
/// <summary> /// Import cached items, flags, etc. /// </summary> public void DoImportCache() { RSSPlugin plugin = RSSPlugin.GetInstance(); _readItems = new ArrayList(); // Register us for special tags plugin.RegisterItemElementParser(FeedType.Rss, _fdNS, "state", this); plugin.RegisterItemElementParser(FeedType.Atom, _fdNS, "state", this); string[] allFiles = Directory.GetFiles(_channelsPath, "*.rss"); int totalFiles = Math.Max(allFiles.Length, 1); int processedFiles = 0; foreach (string file in allFiles) { ImportUtils.UpdateProgress(processedFiles / totalFiles, _progressMessageCache); processedFiles += 100; IResource feed = null; string name = HtmlTools.SafeHtmlDecode(Path.GetFileNameWithoutExtension(file)); if (_name2url.ContainsKey(name)) { IResourceList feeds = Core.ResourceStore.FindResources("RSSFeed", Props.URL, _name2url[name]); if (feeds.Count > 0) { feed = feeds[0]; } } if (feed == null) { IResourceList feeds = Core.ResourceStore.FindResources("RSSFeed", Core.Props.Name, name); if (feeds.Count > 0) { feed = feeds[0]; } } // Not found (import of this feed was canceled?) if (feed == null) { continue; } _readItems.Clear(); using (Stream rss = new FileStream(file, FileMode.Open)) { try { RSSParser parser = new RSSParser(feed); parser.Parse(rss, Encoding.UTF8, true); } catch (Exception ex) { Trace.WriteLine("FeedDemon cache '" + file + "' load failed: '" + ex.Message + "'"); } } foreach (IResource r in _readItems) { if (!r.IsDeleted) { r.DeleteProp(Core.Props.IsUnread); } } } ImportUtils.UpdateProgress(processedFiles / totalFiles, _progressMessageCache); }