Privacy-first password manager with built-in email aliasing. Fully encrypted and self-hostable.
Add FolderTreeUtilitie.cs helper (#1695)
Leendert de Borst60fe8e9bdbc4
diff --git a/apps/server/AliasVault.Client/Main/Models/FolderTreeNode.cs b/apps/server/AliasVault.Client/Main/Models/FolderTreeNode.csnew file mode 100644index 000000000..89cdc0c8e--- /dev/null+++ b/apps/server/AliasVault.Client/Main/Models/FolderTreeNode.cs@@ -0,0 +1,41 @@+//-----------------------------------------------------------------------+// <copyright file="FolderTreeNode.cs" company="aliasvault">+// Copyright (c) aliasvault. All rights reserved.+// Licensed under the AGPLv3 license. See LICENSE.md file in the project root for full license information.+// </copyright>+//-----------------------------------------------------------------------++namespace AliasVault.Client.Main.Models;++using AliasClientDb;++/// <summary>+/// Folder tree node with hierarchical structure.+/// </summary>+public class FolderTreeNode+{+ /// <summary>+ /// Gets or sets the folder entity.+ /// </summary>+ public required Folder Folder { get; set; }++ /// <summary>+ /// Gets or sets the child folder nodes.+ /// </summary>+ public List<FolderTreeNode> Children { get; set; } = new();++ /// <summary>+ /// Gets or sets the depth of this folder in the hierarchy (0 = root).+ /// </summary>+ public int Depth { get; set; }++ /// <summary>+ /// Gets or sets the array of folder IDs from root to this folder.+ /// </summary>+ public List<Guid> Path { get; set; } = new();++ /// <summary>+ /// Gets the folder name with indentation based on depth.+ /// </summary>+ public string IndentedName => new string(' ', Depth * 2) + Folder.Name;+}diff --git a/apps/server/AliasVault.Client/Main/Models/FolderWithCount.cs b/apps/server/AliasVault.Client/Main/Models/FolderWithCount.csindex de3844d89..c1ff65825 100644--- a/apps/server/AliasVault.Client/Main/Models/FolderWithCount.cs+++ b/apps/server/AliasVault.Client/Main/Models/FolderWithCount.cs@@ -25,7 +25,17 @@ public sealed class FolderWithCountpublic string Name { get; set; } = string.Empty;/// <summary>- /// Gets or sets the number of items in this folder.+ /// Gets or sets the parent folder ID (null for root folders).+ /// </summary>+ public Guid? ParentFolderId { get; set; }++ /// <summary>+ /// Gets or sets the folder weight for sorting.+ /// </summary>+ public int Weight { get; set; }++ /// <summary>+ /// Gets or sets the number of items in this folder (including subfolders recursively)./// </summary>public int ItemCount { get; set; }}diff --git a/apps/server/AliasVault.Client/Main/Utilities/FolderTreeUtilities.cs b/apps/server/AliasVault.Client/Main/Utilities/FolderTreeUtilities.csnew file mode 100644index 000000000..a4458c908--- /dev/null+++ b/apps/server/AliasVault.Client/Main/Utilities/FolderTreeUtilities.cs@@ -0,0 +1,312 @@+//-----------------------------------------------------------------------+// <copyright file="FolderTreeUtilities.cs" company="aliasvault">+// Copyright (c) aliasvault. All rights reserved.+// Licensed under the AGPLv3 license. See LICENSE.md file in the project root for full license information.+// </copyright>+//-----------------------------------------------------------------------++namespace AliasVault.Client.Main.Utilities;++using AliasClientDb;+using AliasVault.Client.Main.Models;++/// <summary>+/// Utilities for working with folder hierarchies and trees.+/// </summary>+public static class FolderTreeUtilities+{+ /// <summary>+ /// Maximum allowed folder nesting depth.+ /// Structure: Root (0) > Level 1 (1) > Level 2 (2) > Level 3 (3) > Level 4 (4).+ /// Folders at depth 4 cannot have subfolders.+ /// </summary>+ public const int MaxFolderDepth = 4;++ /// <summary>+ /// Build a hierarchical tree from a flat array of folders.+ /// </summary>+ /// <param name="folders">Flat array of folders.</param>+ /// <returns>Array of root-level folder tree nodes.</returns>+ public static List<FolderTreeNode> BuildFolderTree(IEnumerable<Folder> folders)+ {+ var folderList = folders.ToList();++ // Create a map for quick lookup+ var folderMap = new Dictionary<Guid, FolderTreeNode>();++ // Initialize all folders as tree nodes+ foreach (var folder in folderList)+ {+ folderMap[folder.Id] = new FolderTreeNode+ {+ Folder = folder,+ Children = new List<FolderTreeNode>(),+ Depth = 0,+ Path = new List<Guid>(),+ };+ }++ // Build the tree structure+ var rootFolders = new List<FolderTreeNode>();++ foreach (var folder in folderList)+ {+ var node = folderMap[folder.Id];++ if (folder.ParentFolderId == null)+ {+ // Root folder+ node.Depth = 0;+ node.Path = new List<Guid> { folder.Id };+ rootFolders.Add(node);+ }+ else+ {+ // Child folder+ if (folderMap.TryGetValue(folder.ParentFolderId.Value, out var parent))+ {+ node.Depth = parent.Depth + 1;+ node.Path = new List<Guid>(parent.Path) { folder.Id };+ parent.Children.Add(node);+ }+ else+ {+ // Parent not found or deleted - treat as root+ node.Depth = 0;+ node.Path = new List<Guid> { folder.Id };+ rootFolders.Add(node);+ }+ }+ }++ // Sort children recursively+ SortChildren(rootFolders);++ return rootFolders;+ }++ /// <summary>+ /// Get folder depth in the hierarchy.+ /// </summary>+ /// <param name="folderId">The folder ID to check.</param>+ /// <param name="folders">Flat array of all folders.</param>+ /// <returns>Depth (0 = root, 1 = one level deep, etc.) or null if folder not found.</returns>+ public static int? GetFolderDepth(Guid folderId, IEnumerable<Folder> folders)+ {+ var folderList = folders.ToList();+ var folder = folderList.FirstOrDefault(f => f.Id == folderId);+ if (folder == null)+ {+ return null;+ }++ int depth = 0;+ Guid? currentId = folderId;++ // Traverse up to root, counting levels+ while (currentId.HasValue)+ {+ var current = folderList.FirstOrDefault(f => f.Id == currentId.Value);+ if (current == null || current.ParentFolderId == null)+ {+ break;+ }++ depth++;+ currentId = current.ParentFolderId;++ // Prevent infinite loops+ if (depth > MaxFolderDepth)+ {+ break;+ }+ }++ return depth;+ }++ /// <summary>+ /// Get the full path of folder names from root to the specified folder.+ /// </summary>+ /// <param name="folderId">The folder ID.</param>+ /// <param name="folders">Flat array of all folders.</param>+ /// <returns>Array of folder names from root to current folder, or empty array if not found.</returns>+ public static List<string> GetFolderPath(Guid? folderId, IEnumerable<Folder> folders)+ {+ if (!folderId.HasValue)+ {+ return new List<string>();+ }++ var path = new List<string>();+ var folderList = folders.ToList();+ Guid? currentId = folderId;+ int iterations = 0;++ // Build path by traversing up to root+ while (currentId.HasValue && iterations < MaxFolderDepth + 1)+ {+ var folder = folderList.FirstOrDefault(f => f.Id == currentId.Value);+ if (folder == null)+ {+ break;+ }++ path.Insert(0, folder.Name); // Add to beginning of array+ currentId = folder.ParentFolderId;+ iterations++;+ }++ return path;+ }++ /// <summary>+ /// Get the full path of folder IDs from root to the specified folder.+ /// </summary>+ /// <param name="folderId">The folder ID.</param>+ /// <param name="folders">Flat array of all folders.</param>+ /// <returns>Array of folder IDs from root to current folder, or empty array if not found.</returns>+ public static List<Guid> GetFolderIdPath(Guid? folderId, IEnumerable<Folder> folders)+ {+ if (!folderId.HasValue)+ {+ return new List<Guid>();+ }++ var path = new List<Guid>();+ var folderList = folders.ToList();+ Guid? currentId = folderId;+ int iterations = 0;++ // Build path by traversing up to root+ while (currentId.HasValue && iterations < MaxFolderDepth + 1)+ {+ var folder = folderList.FirstOrDefault(f => f.Id == currentId.Value);+ if (folder == null)+ {+ break;+ }++ path.Insert(0, folder.Id); // Add to beginning of array+ currentId = folder.ParentFolderId;+ iterations++;+ }++ return path;+ }++ /// <summary>+ /// Format folder path for display with separator.+ /// </summary>+ /// <param name="pathSegments">Array of folder names.</param>+ /// <param name="separator">Separator string (default: " > ").</param>+ /// <returns>Formatted folder path string.</returns>+ public static string FormatFolderPath(List<string> pathSegments, string separator = " > ")+ {+ return string.Join(separator, pathSegments);+ }++ /// <summary>+ /// Flatten a folder tree into a sorted array suitable for dropdowns.+ /// Includes visual indentation in the name.+ /// </summary>+ /// <param name="tree">Root-level folder tree nodes.</param>+ /// <param name="excludeId">Optional folder ID to exclude (useful when moving folders).</param>+ /// <returns>Flat array of tree nodes with indented names.</returns>+ public static List<FolderTreeNode> FlattenFolderTree(+ List<FolderTreeNode> tree,+ Guid? excludeId = null)+ {+ var result = new List<FolderTreeNode>();++ void Traverse(List<FolderTreeNode> nodes)+ {+ foreach (var node in nodes)+ {+ if (excludeId.HasValue && node.Folder.Id == excludeId.Value)+ {+ continue; // Skip excluded folder and its children+ }++ result.Add(node);+ Traverse(node.Children);+ }+ }++ Traverse(tree);+ return result;+ }++ /// <summary>+ /// Check if a folder can have subfolders (not at max depth).+ /// </summary>+ /// <param name="folderId">The folder ID to check.</param>+ /// <param name="folders">Flat array of all folders.</param>+ /// <returns>True if folder can have children, false otherwise.</returns>+ public static bool CanHaveSubfolders(Guid folderId, IEnumerable<Folder> folders)+ {+ var depth = GetFolderDepth(folderId, folders);+ return depth.HasValue && depth.Value < MaxFolderDepth;+ }++ /// <summary>+ /// Get all descendant folder IDs (children, grandchildren, etc.).+ /// </summary>+ /// <param name="folderId">The parent folder ID.</param>+ /// <param name="folders">Flat array of all folders.</param>+ /// <returns>Array of descendant folder IDs.</returns>+ public static List<Guid> GetDescendantFolderIds(Guid folderId, IEnumerable<Folder> folders)+ {+ var descendants = new List<Guid>();+ var folderList = folders.ToList();++ void Traverse(Guid parentId)+ {+ var children = folderList.Where(f => f.ParentFolderId == parentId).ToList();+ foreach (var child in children)+ {+ descendants.Add(child.Id);+ Traverse(child.Id);+ }+ }++ Traverse(folderId);+ return descendants;+ }++ /// <summary>+ /// Get all direct child folder IDs.+ /// </summary>+ /// <param name="parentFolderId">The parent folder ID (null for root).</param>+ /// <param name="folders">Flat array of all folders.</param>+ /// <returns>Array of direct child folder IDs.</returns>+ public static List<Guid> GetDirectChildFolderIds(Guid? parentFolderId, IEnumerable<Folder> folders)+ {+ return folders+ .Where(f => f.ParentFolderId == parentFolderId)+ .Select(f => f.Id)+ .ToList();+ }++ /// <summary>+ /// Sort children of a folder tree node recursively.+ /// </summary>+ private static void SortChildren(List<FolderTreeNode> nodes)+ {+ nodes.Sort((a, b) =>+ {+ // Sort by weight first, then by name (case-insensitive)+ if (a.Folder.Weight != b.Folder.Weight)+ {+ return a.Folder.Weight.CompareTo(b.Folder.Weight);+ }++ return string.Compare(a.Folder.Name, b.Folder.Name, StringComparison.OrdinalIgnoreCase);+ });++ foreach (var node in nodes)+ {+ SortChildren(node.Children);+ }+ }+}