Skip to content

Privacy-first password manager with built-in email aliasing. Fully encrypted and self-hostable.

Add subfolder support to import logic, update tests (#1695)

Leendert de Borst3d1463e43b56
diff --git a/apps/server/AliasVault.Client/Main/Pages/Settings/ImportExport/Components/ImportServiceCard.razor b/apps/server/AliasVault.Client/Main/Pages/Settings/ImportExport/Components/ImportServiceCard.razor
index a1c0bc142..aa9fab915 100644
--- a/apps/server/AliasVault.Client/Main/Pages/Settings/ImportExport/Components/ImportServiceCard.razor
+++ b/apps/server/AliasVault.Client/Main/Pages/Settings/ImportExport/Components/ImportServiceCard.razor
@@ -326,7 +326,7 @@
private bool ExtractFavicons { get; set; } = true;
private bool ImportFolders { get; set; } = true;
private int DetectedFolderCount { get; set; } = 0;
- private HashSet<string> DetectedFolderNames { get; set; } = new();
+ private List<string> DetectedFolderPaths { get; set; } = new();
private bool IsExtractingFavicons { get; set; }
private int FaviconExtractionProgress { get; set; }
private int TotalFaviconsToExtract { get; set; }
@@ -746,32 +746,130 @@
}
/// <summary>
- /// Creates folders that don't exist and returns a mapping of folder names to folder IDs.
+ /// Creates folders that don't exist and returns a mapping of folder paths to folder IDs.
+ /// Handles hierarchical folder structures by creating parent folders first.
/// </summary>
private async Task<Dictionary<string, Guid>> CreateOrGetFolders()
{
- var folderNameToId = new Dictionary<string, Guid>(StringComparer.OrdinalIgnoreCase);
- var existingFolders = await FolderService.GetAllWithCountsAsync();
+ var folderPathToId = new Dictionary<string, Guid>(StringComparer.OrdinalIgnoreCase);
+ var context = await DbService.GetDbContextAsync();
+
+ // Load all existing folders with their parent relationships
+ var existingFolders = await context.Folders
+ .Where(f => !f.IsDeleted)
+ .ToListAsync();
+
+ // Build a lookup of existing folders by full path
+ var existingFoldersByPath = new Dictionary<string, Folder>(StringComparer.OrdinalIgnoreCase);
+ foreach (var folder in existingFolders)
+ {
+ var fullPath = GetFolderFullPath(folder, existingFolders);
+ existingFoldersByPath[fullPath] = folder;
+ }
+
+ // Process folders in order (they're already sorted by depth, parents before children)
+ foreach (var folderPath in DetectedFolderPaths)
+ {
+ // Check if folder already exists at this path
+ if (existingFoldersByPath.TryGetValue(folderPath, out var existingFolder))
+ {
+ folderPathToId[folderPath] = existingFolder.Id;
+ }
+ else
+ {
+ // Extract folder name from the path (last segment after last /)
+ var lastSlashIndex = folderPath.LastIndexOf('/');
+ var folderName = lastSlashIndex >= 0 ? folderPath.Substring(lastSlashIndex + 1) : folderPath;
+
+ // Determine parent folder ID
+ Guid? parentFolderId = null;
+ if (lastSlashIndex >= 0)
+ {
+ // Parent path is everything before the last /
+ var parentPath = folderPath.Substring(0, lastSlashIndex);
+ if (folderPathToId.TryGetValue(parentPath, out var parentId))
+ {
+ parentFolderId = parentId;
+ }
+ }
+
+ // Create new folder with parent relationship
+ var newFolderId = await FolderService.CreateAsync(folderName, parentFolderId);
+ folderPathToId[folderPath] = newFolderId;
+ }
+ }
+
+ return folderPathToId;
+ }
+
+ /// <summary>
+ /// Collects all unique folder paths from imported credentials, including intermediate paths.
+ /// For example, if credentials have "Root/Business/Banking" and "Root/Personal", this returns:
+ /// ["Root", "Root/Business", "Root/Business/Banking", "Root/Personal"] in hierarchical order.
+ /// </summary>
+ private List<string> CollectHierarchicalFolderPaths(List<ImportedCredential> credentials)
+ {
+ var folderPathSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+ var folderPathsWithDepth = new List<(string path, int depth)>();
+
+ foreach (var credential in credentials)
+ {
+ if (string.IsNullOrWhiteSpace(credential.FolderPath))
+ {
+ continue;
+ }
+
+ // Parse into individual folder names
+ var parts = BaseImporter.ParseFolderPath(credential.FolderPath);
+
+ // Build all hierarchical paths (parent, parent/child, parent/child/grandchild, etc.)
+ for (int i = 0; i < parts.Count; i++)
+ {
+ var path = string.Join("/", parts.Take(i + 1));
+
+ // Only add if we haven't seen this path before (case-insensitive)
+ if (!folderPathSet.Contains(path))
+ {
+ folderPathSet.Add(path);
+ folderPathsWithDepth.Add((path, i)); // i is the depth
+ }
+ }
+ }
+
+ // Sort by depth first (so parents are created before children), then by path
+ return folderPathsWithDepth
+ .OrderBy(f => f.depth)
+ .ThenBy(f => f.path, StringComparer.OrdinalIgnoreCase)
+ .Select(f => f.path)
+ .ToList();
+ }
+
+ /// <summary>
+ /// Gets the full path of a folder by traversing up the parent hierarchy.
+ /// </summary>
+ /// <param name="folder">The folder to get the path for.</param>
+ /// <param name="allFolders">All folders in the database.</param>
+ /// <returns>The full path (e.g., "Root/Business/Banking").</returns>
+ private string GetFolderFullPath(Folder folder, List<Folder> allFolders)
+ {
+ var path = new List<string>();
+ var current = folder;
- foreach (var folderName in DetectedFolderNames)
+ while (current != null)
{
- // Check if folder already exists (case-insensitive)
- var existingFolder = existingFolders.FirstOrDefault(f =>
- f.Name.Equals(folderName, StringComparison.OrdinalIgnoreCase));
+ path.Insert(0, current.Name ?? string.Empty);
- if (existingFolder != null)
+ if (current.ParentFolderId.HasValue)
{
- folderNameToId[folderName] = existingFolder.Id;
+ current = allFolders.FirstOrDefault(f => f.Id == current.ParentFolderId.Value);
}
else
{
- // Create new folder
- var newFolderId = await FolderService.CreateAsync(folderName);
- folderNameToId[folderName] = newFolderId;
+ current = null;
}
}
- return folderNameToId;
+ return string.Join("/", path);
}
/// <summary>
@@ -1076,9 +1174,9 @@
// Remove duplicates from the import list
ImportedCredentials = ImportedCredentials.Except(duplicates).ToList();
- // Detect folders in the import
- DetectedFolderNames = BaseImporter.CollectUniqueFolderNames(ImportedCredentials);
- DetectedFolderCount = DetectedFolderNames.Count;
+ // Detect folders in the import (hierarchical)
+ DetectedFolderPaths = CollectHierarchicalFolderPaths(ImportedCredentials);
+ DetectedFolderCount = DetectedFolderPaths.Count;
}
/// <summary>
diff --git a/apps/server/Tests/AliasVault.UnitTests/TestData/Exports/bitwarden.csv b/apps/server/Tests/AliasVault.UnitTests/TestData/Exports/bitwarden.csv
index 0df58c249..210166ac3 100644
--- a/apps/server/Tests/AliasVault.UnitTests/TestData/Exports/bitwarden.csv
+++ b/apps/server/Tests/AliasVault.UnitTests/TestData/Exports/bitwarden.csv
@@ -7,3 +7,7 @@ Business,,login,Aliasvault.net,,,0,https://www.aliasvault.net,root,toor,
Business,,login,TutaNota3,,,0,"https://www.aliasvault.net,https://app.aliasvault.net,https://downloads.aliasvault.net",[email protected],blabla,otpauth://totp/Test%20name%3Atest%40test.org?secret=PLW4SB3PQ7MKVXY2MXF4NEXS6Y&issuer=Alias%20Vault
Business,,login,TutaNota4,,,0,,[email protected],blabla,otpauth://totp/[email protected]?secret=TEST!INVALID&issuer=Alias%20Vault&algorithm=SHA1&digits=6&period=30
Business,,login,TutaNota5,,,0,,[email protected],blabla,incorrectstring
+Work/Projects,,login,ProjectItem,,,0,https://project.example.com,projectuser,projectpass,
+Work/Projects/Active,,login,ActiveProjectItem,,,0,https://active.example.com,activeuser,activepass,
+Personal/Finance/Banking,,login,BankAccount,,,0,https://bank.example.com,bankuser,bankpass,
+Personal/Finance/Banking/Savings,,login,SavingsAccount,,,0,https://savings.example.com,savingsuser,savingspass,
diff --git a/apps/server/Tests/AliasVault.UnitTests/Utilities/ImportExportTests.cs b/apps/server/Tests/AliasVault.UnitTests/Utilities/ImportExportTests.cs
index 1dd548a19..c00704a96 100644
--- a/apps/server/Tests/AliasVault.UnitTests/Utilities/ImportExportTests.cs
+++ b/apps/server/Tests/AliasVault.UnitTests/Utilities/ImportExportTests.cs
@@ -93,7 +93,7 @@ public class ImportExportTests
var importedCredentials = await BitwardenImporter.ImportFromCsvAsync(fileContent);
// Assert
- Assert.That(importedCredentials, Has.Count.EqualTo(8));
+ Assert.That(importedCredentials, Has.Count.EqualTo(12));
// There is one entry which has an invalid TOTP code ("! in the secret), we ensure this logic does not throw a fatal error.
var convertedItems = BaseImporter.ConvertToItem(importedCredentials);
@@ -152,6 +152,33 @@ public class ImportExportTests
Assert.That(multiUrlItemTotpCode!.SecretKey, Is.EqualTo("PLW4SB3PQ7MKVXY2MXF4NEXS6Y"));
Assert.That(multiUrlItemTotpCode.Name, Is.EqualTo("Alias Vault: Test name:[email protected]"), "TOTP name should be URL-decoded from the otpauth URI");
});
+
+ // Test multi-depth folder paths
+ var workProjectItem = importedCredentials.First(c => c.ServiceName == "ProjectItem");
+ Assert.That(workProjectItem.FolderPath, Is.EqualTo("Work/Projects"));
+
+ var activeProjectItem = importedCredentials.First(c => c.ServiceName == "ActiveProjectItem");
+ Assert.That(activeProjectItem.FolderPath, Is.EqualTo("Work/Projects/Active"));
+
+ var bankAccountItem = importedCredentials.First(c => c.ServiceName == "BankAccount");
+ Assert.That(bankAccountItem.FolderPath, Is.EqualTo("Personal/Finance/Banking"));
+
+ var savingsAccountItem = importedCredentials.First(c => c.ServiceName == "SavingsAccount");
+ Assert.That(savingsAccountItem.FolderPath, Is.EqualTo("Personal/Finance/Banking/Savings"));
+
+ // Test hierarchical folder path parsing with ParseFolderPath
+ var workProjectsActiveParts = BaseImporter.ParseFolderPath("Work/Projects/Active");
+ Assert.That(workProjectsActiveParts, Has.Count.EqualTo(3));
+ Assert.That(workProjectsActiveParts[0], Is.EqualTo("Work"));
+ Assert.That(workProjectsActiveParts[1], Is.EqualTo("Projects"));
+ Assert.That(workProjectsActiveParts[2], Is.EqualTo("Active"));
+
+ var savingsParts = BaseImporter.ParseFolderPath("Personal/Finance/Banking/Savings");
+ Assert.That(savingsParts, Has.Count.EqualTo(4));
+ Assert.That(savingsParts[0], Is.EqualTo("Personal"));
+ Assert.That(savingsParts[1], Is.EqualTo("Finance"));
+ Assert.That(savingsParts[2], Is.EqualTo("Banking"));
+ Assert.That(savingsParts[3], Is.EqualTo("Savings"));
}
/// <summary>
@@ -1111,7 +1138,7 @@ public class ImportExportTests
var folderMapping = new Dictionary<string, Guid>
{
- { "Projects", Guid.NewGuid() }, // Deepest folder from "Work/Projects"
+ { "Work/Projects", Guid.NewGuid() },
{ "Personal", Guid.NewGuid() },
};
@@ -1119,7 +1146,7 @@ public class ImportExportTests
var items = BaseImporter.ConvertToItem(credentials, folderMapping);
// Assert
- Assert.That(items[0].FolderId, Is.EqualTo(folderMapping["Projects"]), "Should assign Projects folder");
+ Assert.That(items[0].FolderId, Is.EqualTo(folderMapping["Work/Projects"]), "Should assign Work/Projects folder using full path");
Assert.That(items[1].FolderId, Is.EqualTo(folderMapping["Personal"]), "Should assign Personal folder");
Assert.That(items[2].FolderId, Is.Null, "Should have no folder");
}
diff --git a/apps/server/Utilities/AliasVault.ImportExport/Importers/BaseImporter.cs b/apps/server/Utilities/AliasVault.ImportExport/Importers/BaseImporter.cs
index d09ab9aca..0aefe4b89 100644
--- a/apps/server/Utilities/AliasVault.ImportExport/Importers/BaseImporter.cs
+++ b/apps/server/Utilities/AliasVault.ImportExport/Importers/BaseImporter.cs
@@ -193,8 +193,8 @@ public static class BaseImporter
// Handle folder assignment if folder mapping is provided
if (folderNameToId != null && !string.IsNullOrWhiteSpace(importedCredential.FolderPath))
{
- var folderName = ExtractDeepestFolderName(importedCredential.FolderPath);
- if (!string.IsNullOrWhiteSpace(folderName) && folderNameToId.TryGetValue(folderName, out var folderId))
+ // Use the full folder path for lookup (handles multi-level folders)
+ if (folderNameToId.TryGetValue(importedCredential.FolderPath, out var folderId))
{
item.FolderId = folderId;
}
@@ -396,6 +396,38 @@ public static class BaseImporter
return folderNames;
}
+ /// <summary>
+ /// Parses a folder path into individual folder names.
+ /// For example: "Root/Business/Banking" returns ["Root", "Business", "Banking"].
+ /// Supports depth up to 5 levels (0-4, where 0 is root level).
+ /// </summary>
+ /// <param name="folderPath">The folder path, potentially with hierarchy separators.</param>
+ /// <returns>A list of folder names in order, or empty list if invalid.</returns>
+ public static List<string> ParseFolderPath(string? folderPath)
+ {
+ if (string.IsNullOrWhiteSpace(folderPath))
+ {
+ return new List<string>();
+ }
+
+ // Handle common hierarchy separators: / and \
+ var separators = new[] { '/', '\\' };
+ var parts = folderPath.Split(separators, StringSplitOptions.RemoveEmptyEntries)
+ .Select(p => p.Trim())
+ .Where(p => !string.IsNullOrEmpty(p))
+ .ToList();
+
+ // Enforce maximum depth of 5 levels (depth 0-4)
+ const int maxDepth = 5;
+ if (parts.Count > maxDepth)
+ {
+ parts = parts.Take(maxDepth).ToList();
+ }
+
+ return parts;
+ }
+
+
/// <summary>
/// Adds credit card fields to an item from the ImportedCreditcard model.
/// Each importer is responsible for populating the Creditcard property.