public bool DeleteBookmarkByFilename(string parentFolderId, string fileName)
{
BookmarkFolder parentFolder = GetBookmarkFolderById(_bookmarkContainer.RootFolder, parentFolderId);
if (parentFolder == null)
{
return(false);
}
Bookmark bookmarkToDelete = null;
foreach (Bookmark bookmark in parentFolder.Bookmarks)
{
if (bookmark.FileName == fileName)
{
bookmarkToDelete = bookmark;
break;
}
}
if (bookmarkToDelete != null)
{
parentFolder.Bookmarks.Remove(bookmarkToDelete);
ReindexSortOrder(false, true);
BookmarkUpdated(new BookmarkUpdatedEventArgs(BookmarkActions.DeletedBookmark, typeof(Bookmark)));
return(true);
}
return(false);
}
public void CustomAttributes()
{
var container = new BookmarkFolder
{
new BookmarkLink("a", "b")
{
Attributes = new Dictionary <string, string> {
{ "custom", "1" }
}
},
new BookmarkFolder("folder")
{
Attributes = new Dictionary <string, string> {
{ "custom", "2" }, { "add_date", "ę" }
}
}
};
var writter = new NetscapeBookmarksWritter(container);
var reader = new NetscapeBookmarksReader();
var write1 = writter.ToString();
var readed = reader.Read(write1);
Assert.AreEqual("1", readed.AllLinks.First().Attributes["custom"]);
Assert.AreEqual("2", readed.GetAllItems <BookmarkFolder>().First().Attributes["custom"]);
Assert.IsFalse(readed.GetAllItems <BookmarkFolder>().First().Attributes.ContainsKey("add_date"), "add_date is ignored attribute, it must not be written");
}
public static BookmarkFolder GetSimpleStructure()
{
var bookmarks = new BookmarkFolder
{
new BookmarkFolder("Title1"),
new BookmarkFolder("Title2"),
new BookmarkLink("http://example.com", "Example"),
new BookmarkFolder("Nested")
{
new BookmarkLink("http://example.com", "Example2")
{
LastModified = new DateTime(2000, 01, 01, 12, 12, 12)
},
new BookmarkFolder("Inner folder")
{
new BookmarkLink("http://localhost?foo=bar", "Local example")
{
Added = new DateTime(2000, 01, 01, 12, 12, 12)
}
}
}
};
return(bookmarks);
}
private BookmarkFolder GetBookmarkFolderById(BookmarkFolder rootFolder, string id)
{
BookmarkFolder subFolder = null;
if (rootFolder.Id == id)
{
return(rootFolder);
}
foreach (BookmarkFolder bookmarkFolder in rootFolder.BookmarkFolders)
{
if (bookmarkFolder.Id == id)
{
return(bookmarkFolder);
}
if (bookmarkFolder.BookmarkFolders != null && bookmarkFolder.BookmarkFolders.Count > 0)
{
subFolder = GetBookmarkFolderById(bookmarkFolder, id);
}
if (subFolder != null)
{
return(subFolder);
}
}
return(null);
}
public UpdateResult UpdatePosition(BookmarkFolder folder, int index)
{
List <string> errors = new List <string>();
if (InteractiveFolder.TryGetFolder(Home, folder, out InteractiveFolder thisFolder))
{
if (InteractiveFolder.TryGetFolder(Home, folder.Parent ?? Home, out InteractiveFolder iFolder))
{
return(UpdatePosition(thisFolder, index, iFolder, iFolder));
}
else
{
errors.Add("Failed to get parent folder.");
}
}
else
{
errors.Add("Failed to get folder to update.");
}
return(new UpdateResult()
{
Errors = errors,
Success = false
});
}
private void btnSave_Click(object sender, EventArgs e)
{
BookmarkFolder bookmarkFolder = comboBoxBookmarkFolders.SelectedItem as BookmarkFolder ?? _bookmarkManager.RootFolder;
_bookmarkManager.AddBookmark(bookmarkFolder.Id, txtBookmarkName.Text, _imageReference);
_bookmarkService.SaveBookmarks();
}
public UpdateResult UpdatePosition(FanficBookmark fanfic, int index, BookmarkFolder oldParent)
{
List <string> errors = new List <string>();
if (InteractiveFolder.TryGetFolder(Home, oldParent ?? Home, out InteractiveFolder old))
{
if (InteractiveFolder.TryGetFolder(Home, fanfic.Parent ?? Home, out InteractiveFolder newParent))
{
return(UpdatePosition(fanfic, index, newParent, old));
}
else
{
errors.Add("Failed to get new parent folder.");
}
}
else
{
errors.Add("Failed to get old parent folder");
}
return(new UpdateResult()
{
Success = false,
Errors = errors
});
}
public UpdateResult TryAddFolder(BookmarkFolder folder, out InteractiveFolder iFolder)
{
List <string> errors = new List <string>();
if (InteractiveFolder.TryGetFolder(Home, folder.Parent ?? Home, out InteractiveFolder res))
{
if (res.TryAddFolder(folder, out iFolder))
{
return(new UpdateResult()
{
Success = true,
Message = "Folder added."
});
}
else
{
errors.Add("Failed to add the new folder.");
}
}
else
{
errors.Add("Failed to get the parent folder.");
}
iFolder = null;
return(new UpdateResult()
{
Errors = errors,
Success = false
});
}
// Remove duplicate complete filename bookmark, prioritize tree depth
private int RemoveDuplicates(BookmarkFolder rootFolder)
{
var allBookmarks = GetAllBookmarksIncludingSubfolders(rootFolder).OrderBy(x => x.CompletePath);
var removeQueue = new Queue <Bookmark>();
foreach (var duplicateGroup in allBookmarks.GroupBy(x => x.CompletePath))
{
if (duplicateGroup.Count() > 1)
{
var duplicateList = duplicateGroup.OrderBy(x => x.ParentFolderId).ToList();
var itemToKeep = duplicateList.FirstOrDefault(x => x.ParentFolderId != rootFolder.Id) ?? duplicateList.First();
duplicateList.Remove(itemToKeep);
foreach (var bookmark in duplicateList)
{
removeQueue.Enqueue(bookmark);
}
}
}
int removedItems = removeQueue.Count;
while (removeQueue.Count > 0)
{
DeleteBookmark(removeQueue.Dequeue());
}
return(removedItems);
}
public static bool TryGetFolder(InteractiveFolder start, BookmarkFolder folder, out InteractiveFolder f)
{
if (folder.Id == start.Id)
{
f = start;
return(true);
}
foreach (var item in start.Folders)
{
if (item.Id == folder.Id)
{
f = item;
return(true);
}
if (TryGetFolder(item, folder, out f))
{
return(true);
}
}
f = null;
return(false);
}
private void FolderNodeContextMenu_Popup(object sender, EventArgs e)
{
ContextMenu contextMenu = sender as ContextMenu;
TreeNode treeNode = contextMenu.Tag as TreeNode;
BookmarkFolder folder = treeNode.Tag as BookmarkFolder;
contextMenu.MenuItems.Clear();
contextMenu.MenuItems.Add(new MenuItem(folder == null ? "&Add Folder..." : "&Add Subfolder...", (sender2, e2) =>
{
string dialogResult = PromptBox.Show("Folder path:", folder == null ? "" : (folder.Path + "/"), "Add subfolder", null);
if (dialogResult != null)
{
BookmarksModel.RegisterPath(dialogResult);
}
})
{
Name = "folder_add"
});
if (folder != null)
{
contextMenu.MenuItems.Add(new MenuItem("&Edit Folder...", (sender2, e2) =>
{
string folderPath = GetPathFileName(folder.Path);
string dialogResult = PromptBox.Show("Change name to:", folder.Text, string.Format("Edit Bookmark folder - {0}", folder.Path), (new string[] {
folder.Text,
CultureInfo.CurrentCulture?.TextInfo?.ToTitleCase(folder.Text),
folder.Text.ToLower(),
folder.Text.ToUpper(),
folderPath,
CultureInfo.CurrentCulture?.TextInfo?.ToTitleCase(folderPath),
folderPath.ToLower(),
folderPath.ToUpper(),
}).Distinct().Where(x => !string.IsNullOrEmpty(x)).ToArray());
if (dialogResult != null)
{
folder.Text = dialogResult;
treeNode.Text = dialogResult;
treeView.Sort(treeNode.Parent, treeViewNodeSorter);
}
})
{
Name = "folder_edit"
});
contextMenu.MenuItems.Add(new MenuItem("&Remove Folder", (sender2, e2) =>
{
treeNode.Remove();
BookmarksModel.RemovePath(folder.Path);
})
{
Name = "remove_folder"
});
// TODO: "move to..." command (to change the folder (and its children) path)
}
}
public void VerifyIntegrityOfBookmarFolder(BookmarkFolder bookmarkfolder)
{
try
{
var deleteQueue = new Queue <Bookmark>();
foreach (var bookmark in bookmarkfolder.Bookmarks)
{
if (bookmark.ParentFolderId != bookmarkfolder.Id)
{
bookmark.ParentFolderId = bookmarkfolder.Id;
}
if (string.IsNullOrEmpty(bookmark.FileName) || bookmark.Size == 0 || string.IsNullOrEmpty(bookmark.CompletePath))
{
deleteQueue.Enqueue(bookmark);
}
}
while (deleteQueue.Count > 0)
{
var bookmark = deleteQueue.Dequeue();
DeleteBookmark(bookmark);
}
}
catch (Exception ex)
{
Log.Error(ex, "VerifyIntegrityOfBookmarFolder exception");
}
}
private void RecursiveAdd(BookmarkFolder source, BookmarkFolder appendFrom)
{
foreach (var bookmark in appendFrom.Bookmarks)
{
if (!source.Bookmarks.Any(x => x.CompletePath == bookmark.CompletePath && x.Size == bookmark.Size))
{
bookmark.ParentFolderId = source.Id;
source.Bookmarks.Add(bookmark);
}
}
foreach (var folder in appendFrom.BookmarkFolders)
{
if (source.BookmarkFolders.All(x => x.Name != folder.Name))
{
folder.ParentFolderId = source.Id;
source.BookmarkFolders.Add(folder);
}
if (folder.BookmarkFolders.Any())
{
foreach (var subFolder in folder.BookmarkFolders)
{
var sFolder = source.BookmarkFolders.FirstOrDefault(x => x.Name == folder.Name);
if (sFolder != null)
{
RecursiveAdd(sFolder, subFolder);
}
}
}
}
}
private void ExpandOrCollapseFolderRecursive(TreeNodeCollection nodes)
{
foreach (TreeNode folderNode in nodes)
{
BookmarkFolder folder = folderNode.Tag as BookmarkFolder;
if (folder == null)
{
continue;
}
if (BookmarksListSettings.Collapsed.ContainsKey(folder.Path))
{
if (BookmarksListSettings.Collapsed[folder.Path])
{
folderNode.Collapse();
}
else
{
folderNode.Expand();
}
}
if (folderNode.Nodes != null && folderNode.Nodes.Count > 0)
{
ExpandOrCollapseFolderRecursive(folderNode.Nodes);
}
}
}
private void addFolderToolStripMenuItem_Click(object sender, EventArgs e)
{
if (bookmarksTree.SelectedNode == null)
{
return;
}
var inputFormData = new FormInputRow.InputFormData
{
GroupBoxText = "Bookmark folder name",
LabelText = "Name:",
WindowText = "Add new bookmark folder",
MinimumCharacters = 1,
MaximumCharacters = 50
};
var formInputRow = new FormInputRow(inputFormData);
if (formInputRow.ShowDialog(this) == DialogResult.OK)
{
string folderName = formInputRow.UserInputText;
TreeNode selectedNode = bookmarksTree.SelectedNode;
if (selectedNode.Tag is BookmarkFolder selectedBookmarkfolder)
{
BookmarkFolder newFolder = _bookmarkManager.AddBookmarkFolder(selectedBookmarkfolder.Id, folderName);
AlterTreeViewState(TreeViewFolderStateChange.FolderAdded, newFolder);
}
}
}
public Bookmark AddBookmark(string parentFolderId, string boookmarkName, ImageReferenceElement imgRef)
{
BookmarkFolder parentFolder = GetBookmarkFolderById(_bookmarkContainer.RootFolder, parentFolderId);
if (parentFolder == null)
{
return(null);
}
var bookmark = new Bookmark
{
BoookmarkName = boookmarkName,
CompletePath = imgRef.CompletePath,
CreationTime = imgRef.CreationTime,
Directory = imgRef.Directory,
FileName = imgRef.FileName,
LastAccessTime = imgRef.LastAccessTime,
LastWriteTime = imgRef.LastWriteTime,
Size = imgRef.Size,
SortOrder = parentFolder.Bookmarks.Count,
ParentFolderId = parentFolder.Id
};
parentFolder.Bookmarks.Add(bookmark);
BookmarkUpdated(new BookmarkUpdatedEventArgs(BookmarkActions.CreatedBookmark, typeof(Bookmark)));
return(bookmark);
}
private static void SearchFolder(BookmarkFolder folder, Regex searchReg, List <Bookmark> result)
{
if (Config.SearchUrl)
{
foreach (Bookmark bookmark in folder.Bookmarks)
{
if (searchReg.IsMatch(bookmark.NamePinYin) || searchReg.IsMatch(bookmark.Url))
{
result.Add(bookmark);
}
}
}
else
{
foreach (Bookmark bookmark in folder.Bookmarks)
{
if (searchReg.IsMatch(bookmark.NamePinYin))
{
result.Add(bookmark);
}
}
}
foreach (BookmarkFolder subfolder in folder.Folders)
{
SearchFolder(subfolder, searchReg, result);
}
}
public FolderModel(BookmarkFolder f)
{
Name = f?.DisplayName ?? "";
ParentFolder = f?.Parent?.Id.ToString() ?? Guid.Empty.ToString();
Id = f?.Id ?? default;
}
public FormAddBookmarkWithNewFolder(ImageReferenceElement imageReference, BookmarkService bookmarkService, BookmarkManager bookmarkManager)
{
_imageReference = imageReference;
_bookmarkService = bookmarkService;
_bookmarkManager = bookmarkManager;
rootBookmarkFolder = _bookmarkManager.RootFolder;
InitializeComponent();
}
public NetscapeWritterTests()
{
var emptyContainer = new BookmarkFolder();
_writter = new NetscapeBookmarksWritter(emptyContainer);
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
}
/// <summary>
/// Creates a new instance of the Bookmark class.
/// </summary>
/// <param name="name">The name of the bookmark.</param>
/// <param name="favicon">The favicon of the bookmark source.</param>
/// <param name="source">The URI location of the bookmark.</param>
/// <param name="password">The password of the bookmark to use to encrypt the bookmark file.</param>
/// <param name="parent">The parent BookmarkFolder of the bookmark.</param>
public Bookmark(string name, Image favicon, Uri source, string password = "", BookmarkFolder parent = null)
{
_name = name;
_pass = password;
_source = source;
_favicon = favicon;
_parent = parent;
_id = Guid.NewGuid();
}
public void UpdateSortOrder(BookmarkFolder selectedBookmarkFolder, string sortBy, SortOrder sortOrder)
{
var bookmarks = sortOrder == SortOrder.Ascending ? selectedBookmarkFolder.Bookmarks.OrderBy(o => o.GetType().GetProperty(sortBy)?.GetValue(o, null)).ToList() :
selectedBookmarkFolder.Bookmarks.OrderByDescending(o => o.GetType().GetProperty(sortBy)?.GetValue(o, null)).ToList();
for (int i = 0; i < bookmarks.Count; i++)
{
bookmarks[i].SortOrder = i;
}
}
public void ExpandNode(BookmarkFolder folderToExpand)
{
if (folderToExpand == null)
{
return;
}
BindData();
ExpandNode(_treeView.Nodes, folderToExpand);
}
public void EmptyContainer()
{
var emptyContainer = new BookmarkFolder();
var writter = new NetscapeBookmarksWritter(emptyContainer);
var reader = new NetscapeBookmarksReader();
var write1 = writter.ToString();
var readed = reader.Read(write1);
writter = new NetscapeBookmarksWritter(readed);
var write2 = writter.ToString();
Assert.AreEqual(write1, write2, true);
}
private IEnumerable <Bookmark> GetAllBookmarksIncludingSubfolders(BookmarkFolder rootFolder)
{
var bookmarks = new List <Bookmark>(rootFolder.Bookmarks);
foreach (var folder in rootFolder.BookmarkFolders)
{
bookmarks.AddRange(GetAllBookmarksIncludingSubfolders(folder));
}
return(bookmarks);
}
public IEnumerable <Bookmark> GetAllBookmarksRecursive(BookmarkFolder rootFolder)
{
var bookmarks = rootFolder.Bookmarks;
foreach (var bookmarkFolder in rootFolder.BookmarkFolders)
{
bookmarks.AddRange(GetAllBookmarksRecursive(bookmarkFolder));
}
return(bookmarks);
}
public TreeViewDataContext(TreeView treeView, BookmarkFolder rootFolder)
{
_treeView = treeView;
_rootFolder = rootFolder;
treeView.AfterCheck += TreeView_AfterCheck;
treeView.AfterSelect += TreeView_AfterSelect;
treeView.AfterCollapse += TreeView_AfterCollapse;
treeView.AfterExpand += TreeView_AfterExpand;
treeView.ControlAdded += TreeView_ControlAdded;
}
public void EmptyContainer()
{
var emptyContainer = new BookmarkFolder();
var writter = new NetscapeBookmarksWritter(emptyContainer);
var reader = new NetscapeBookmarksReader();
var write1 = writter.ToString();
var readed = reader.Read(write1);
writter = new NetscapeBookmarksWritter(readed);
var write2 = writter.ToString();
Assert.AreEqual(write1, write2, true);
}
private List <ArticlePDF> getBookMark(string sBookmarkFilePath)
{
List <ArticlePDF> lista = new List <ArticlePDF>();
string bookmarksString = File.ReadAllText(sBookmarkFilePath);
NetscapeBookmarksReader reader = new NetscapeBookmarksReader();
BookmarkFolder bookmarksAll = reader.Read(bookmarksString);
string rootFolder = "Doktorat";
IBookmarkFolder bookmarksDoc = getDoktoratFolder(bookmarksAll, rootFolder); //pobierz wszystkie z bookmark Doktorat
getArticleFromFolder(lista, "", bookmarksDoc);
return(lista);
}
private IBookmarkFolder getDoktoratFolder(BookmarkFolder bookmarksAll, string findPattern)
{
IBookmarkFolder result = null;
foreach (var item in bookmarksAll.AllFolders)
{
if (item.Title == findPattern)
{
result = item;
break;
}
}
return(result);
}
public static BookmarkFolder GetSimpleStructure()
{
var bookmarks = new BookmarkFolder
{
new BookmarkFolder("Title1"),
new BookmarkFolder("Title2"),
new BookmarkLink("http://example.com", "Example"),
new BookmarkFolder("Nested")
{
new BookmarkLink("http://example.com", "Example2") {LastModified = new DateTime(2000, 01, 01, 12, 12, 12)},
new BookmarkFolder("Inner folder") {new BookmarkLink("http://localhost?foo=bar", "Local example") {Added = new DateTime(2000, 01, 01, 12, 12, 12)}}
}
};
return bookmarks;
}
public void CustomAttributes()
{
var container = new BookmarkFolder
{
new BookmarkLink("a", "b") {Attributes = new Dictionary<string, string> {{"custom", "1"}}},
new BookmarkFolder("folder") {Attributes = new Dictionary<string, string> {{"custom", "2"}, {"add_date", "ę"}}}
};
var writter = new NetscapeBookmarksWritter(container);
var reader = new NetscapeBookmarksReader();
var write1 = writter.ToString();
var readed = reader.Read(write1);
Assert.AreEqual("1", readed.AllLinks.First().Attributes["custom"]);
Assert.AreEqual("2", readed.GetAllItems<BookmarkFolder>().First().Attributes["custom"]);
Assert.IsFalse(readed.GetAllItems<BookmarkFolder>().First().Attributes.ContainsKey("add_date"), "add_date is ignored attribute, it must not be written");
}
public bool MoveBookmark(Bookmark bookmark, string destinationFolderId)
{
BookmarkFolder parentFolder = GetBookmarkFolderById(_bookmarkContainer.RootFolder, bookmark.ParentFolderId);
BookmarkFolder destinationFolder = GetBookmarkFolderById(_bookmarkContainer.RootFolder, destinationFolderId);
if ((parentFolder == null) | (destinationFolder == null) || parentFolder == destinationFolder)
{
return(false);
}
parentFolder.Bookmarks.Remove(bookmark);
destinationFolder.Bookmarks.Add(bookmark);
bookmark.ParentFolderId = destinationFolder.Id;
return(true);
}
public NetscapeWritterTests()
{
var emptyContainer = new BookmarkFolder();
_writter = new NetscapeBookmarksWritter(emptyContainer);
}
