Open_Archival/openarchival
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Got the new ui flow working and the models updated. Need to get changes written to the database.

Browse Source
This commit is contained in:
Vincent Allen
2025-08-11 10:02:45 -04:00
parent a28663441e
commit dd3968f6ef
456 changed files with 17237 additions and 3851 deletions
Download Patch File Download Diff File Expand all files Collapse all files

80
OpenArchival.DataAccess/Providers/ArchiveCategoryProvider.cs Normal file
View File

@@ -0,0 +1,80 @@
using Microsoft.EntityFrameworkCore;
using System.Diagnostics.CodeAnalysis;
namespace OpenArchival.DataAccess;
public class ArchiveCategoryProvider : IArchiveCategoryProvider
{
private Microsoft.EntityFrameworkCore.IDbContextFactory<ArchiveDbContext> _dbFactory;
private ILogger _logger;
[SetsRequiredMembers]
public ArchiveCategoryProvider(Microsoft.EntityFrameworkCore.IDbContextFactory<ArchiveDbContext> dbFactory, ILogger<ArchiveCategoryProvider> logger)
{
_dbFactory = dbFactory;
_logger = logger;
}
public async Task CreateCategoryAsync(ArchiveCategory category)
{
await using var context = await _dbFactory.CreateDbContextAsync();
context.ArchiveCategories.Add(category);
await context.SaveChangesAsync();
}
public async Task UpdateCategoryAsync(ArchiveCategory category)
{
await using var context = await _dbFactory.CreateDbContextAsync();
context.ArchiveCategories.Update(category);
await context.SaveChangesAsync();
}
public async Task DeleteCategoryAsync(ArchiveCategory category)
{
await using var context = await _dbFactory.CreateDbContextAsync();
context.ArchiveCategories.Remove(category);
await context.SaveChangesAsync();
}
public async Task<List<ArchiveCategory>?> GetArchiveCategory(string categoryName)
{
await using var context = await _dbFactory.CreateDbContextAsync();
return await context.ArchiveCategories.Where(a => a.Name == categoryName).ToListAsync();
}
public async Task<ArchiveCategory?> GetArchiveCategory(int id)
{
await using var context = await _dbFactory.CreateDbContextAsync();
return await context.ArchiveCategories.Where(a => a.Id == id).FirstOrDefaultAsync();
}
public async Task<List<ArchiveCategory>?> GetAllArchiveCategories()
{
await using var context = await _dbFactory.CreateDbContextAsync();
return await context.ArchiveCategories.ToListAsync();
}
public async Task<List<ArchiveCategory>?> Search(string query)
{
await using var context = await _dbFactory.CreateDbContextAsync();
return await context.ArchiveCategories
.Where(p => p.Name.ToLower().Contains(query.ToLower())).ToListAsync();
}
public async Task<List<ArchiveCategory>?> Top(int count)
{
await using var context = await _dbFactory.CreateDbContextAsync();
return await context.ArchiveCategories
.OrderBy(p => p.Name)
.Take(count)
.ToListAsync();
}
}

73
OpenArchival.DataAccess/Providers/ArchiveEntryTagProvider.cs Normal file
View File

@@ -0,0 +1,73 @@
using Microsoft.EntityFrameworkCore;
using System.Diagnostics.CodeAnalysis;
namespace OpenArchival.DataAccess;
public class ArchiveEntryTagProvider : IArchiveEntryTagProvider
{
private readonly IDbContextFactory<ArchiveDbContext> _dbFactory;
private readonly ILogger<ArchiveEntryTagProvider> _logger;
[SetsRequiredMembers]
public ArchiveEntryTagProvider(IDbContextFactory<ArchiveDbContext> context, ILogger<ArchiveEntryTagProvider> logger)
{
_dbFactory = context;
_logger = logger;
}
public async Task<ArtifactEntryTag?> GetEntryTagAsync(int id)
{
await using var context = await _dbFactory.CreateDbContextAsync();
return await context.ArtifactEntryTags.Where(t => t.Id == id).FirstOrDefaultAsync();
}
public async Task<List<ArtifactEntryTag>?> GetEntryTagAsync(string name)
{
await using var context = await _dbFactory.CreateDbContextAsync();
return await context.ArtifactEntryTags.Where(t => t.Name == name).ToListAsync();
}
public async Task UpdateEntryTagAsync(ArtifactEntryTag entryTag)
{
await using var context = await _dbFactory.CreateDbContextAsync();
context.ArtifactEntryTags.Update(entryTag);
await context.SaveChangesAsync();
}
public async Task CreateEntryTagAsync(ArtifactEntryTag entryTag)
{
await using var context = await _dbFactory.CreateDbContextAsync();
context.ArtifactEntryTags.Add(entryTag);
await context.SaveChangesAsync();
}
public async Task DeleteEntryTagAsync(ArtifactEntryTag entryTag)
{
await using var context = await _dbFactory.CreateDbContextAsync();
context.ArtifactEntryTags.Remove(entryTag);
await context.SaveChangesAsync();
}
public async Task<List<ArtifactEntryTag>?> Search(string query)
{
await using var context = await _dbFactory.CreateDbContextAsync();
return await context.ArtifactEntryTags
.Where(p => p.Name.ToLower().Contains(query.ToLower())).ToListAsync();
}
public async Task<List<ArtifactEntryTag>?> Top(int count)
{
await using var context = await _dbFactory.CreateDbContextAsync();
return await context.ArtifactEntryTags
.OrderBy(p => p.Name)
.Take(count)
.ToListAsync();
}
}

72
OpenArchival.DataAccess/Providers/ArtifactDefectProvider.cs Normal file
View File

@@ -0,0 +1,72 @@
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using System.Diagnostics.CodeAnalysis;
namespace OpenArchival.DataAccess;
public class ArtifactDefectProvider : IArtifactDefectProvider
{
private readonly IDbContextFactory<ArchiveDbContext> _dbFactory;
private readonly ILogger<ArtifactDefectProvider> _logger;
[SetsRequiredMembers]
public ArtifactDefectProvider(IDbContextFactory<ArchiveDbContext> context, ILogger<ArtifactDefectProvider> logger)
{
_dbFactory = context;
_logger = logger;
}
public async Task<ArtifactDefect?> GetDefectAsync(int id)
{
await using var context = await _dbFactory.CreateDbContextAsync();
return await context.ArtifactDefects.Where(d => d.Id == id).FirstOrDefaultAsync();
}
public async Task<List<ArtifactDefect>?> GetDefectAsync(string description)
{
await using var context = await _dbFactory.CreateDbContextAsync();
return await context.ArtifactDefects.Where(d => d.Description == description).ToListAsync();
}
public async Task UpdateDefectAsync(ArtifactDefect artifactDefect)
{
await using var context = await _dbFactory.CreateDbContextAsync();
context.ArtifactDefects.Update(artifactDefect);
await context.SaveChangesAsync();
}
public async Task CreateDefectAsync(ArtifactDefect artifactDefect)
{
await using var context = await _dbFactory.CreateDbContextAsync();
context.ArtifactDefects.Add(artifactDefect);
await context.SaveChangesAsync();
}
public async Task DeleteDefectAsync(ArtifactDefect artifactDefect)
{
await using var context = await _dbFactory.CreateDbContextAsync();
context.ArtifactDefects.Remove(artifactDefect);
await context.SaveChangesAsync();
}
public async Task<List<ArtifactDefect>?> Search(string query)
{
await using var context = await _dbFactory.CreateDbContextAsync();
return await context.ArtifactDefects
.Where(p => p.Description.ToLower().Contains(query.ToLower())).ToListAsync();
}
public async Task<List<ArtifactDefect>?> Top(int count)
{
await using var context = await _dbFactory.CreateDbContextAsync();
return await context.ArtifactDefects
.OrderBy(p => p.Description)
.Take(count)
.ToListAsync();
}
}

46
OpenArchival.DataAccess/Providers/ArtifactGroupingProvider.cs Normal file
View File

@@ -0,0 +1,46 @@
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using System.Diagnostics.CodeAnalysis;
namespace OpenArchival.DataAccess;
public class ArtifactGroupingProvider : IArtifactGroupingProvider
{
private readonly ArchiveDbContext _context;
private readonly ILogger<ArtifactGroupingProvider> _logger;
[SetsRequiredMembers]
public ArtifactGroupingProvider(ArchiveDbContext context, ILogger<ArtifactGroupingProvider> logger)
{
_context = context;
_logger = logger;
}
public async Task<ArtifactGrouping?> GetGroupingAsync(int id)
{
return await _context.ArtifactGroupings.Where(g => g.Id == id).FirstOrDefaultAsync();
}
public async Task<ArtifactGrouping?> GetGroupingAsync(string artifactGroupingIdentifier)
{
return await _context.ArtifactGroupings.Where(g => g.ArtifactGroupingIdentifier == artifactGroupingIdentifier).FirstOrDefaultAsync();
}
public async Task CreateGroupingAsync(ArtifactGrouping grouping)
{
_context.ArtifactGroupings.Add(grouping);
await _context.SaveChangesAsync();
}
public async Task UpdateGroupingAsync(ArtifactGrouping grouping)
{
_context.ArtifactGroupings.Update(grouping);
await _context.SaveChangesAsync();
}
public async Task DeleteGroupingAsync(ArtifactGrouping grouping)
{
_context.ArtifactGroupings.Remove(grouping);
await _context.SaveChangesAsync();
}
}

84
OpenArchival.DataAccess/Providers/ArtifactSotrageLocationProvider.cs Normal file
View File

@@ -0,0 +1,84 @@
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Threading.Tasks;
namespace OpenArchival.DataAccess;
public class ArtifactStorageLocationProvider : IArtifactStorageLocationProvider
{
private readonly IDbContextFactory<ArchiveDbContext> _dbFactory;
private readonly ILogger _logger;
[SetsRequiredMembers]
public ArtifactStorageLocationProvider(IDbContextFactory<ArchiveDbContext> dbFactory, ILogger<ArtifactStorageLocationProvider> logger)
{
_dbFactory = dbFactory;
_logger = logger;
}
public async Task CreateArtifactStorageLocationAsync(ArtifactStorageLocation location)
{
await using var context = await _dbFactory.CreateDbContextAsync();
context.ArtifactStorageLocations.Add(location);
await context.SaveChangesAsync();
}
public async Task UpdateArtifactStorageLocationAsync(ArtifactStorageLocation location)
{
await using var context = await _dbFactory.CreateDbContextAsync();
context.ArtifactStorageLocations.Update(location);
await context.SaveChangesAsync();
}
public async Task DeleteArtifactStorageLocationAsync(ArtifactStorageLocation location)
{
await using var context = await _dbFactory.CreateDbContextAsync();
context.ArtifactStorageLocations.Remove(location);
await context.SaveChangesAsync();
}
public async Task<List<ArtifactStorageLocation>?> GetArtifactStorageLocation(string locationName)
{
await using var context = await _dbFactory.CreateDbContextAsync();
return await context.ArtifactStorageLocations.Where(a => a.Location == locationName).ToListAsync();
}
public async Task<ArtifactStorageLocation?> GetArtifactStorageLocation(int id)
{
await using var context = await _dbFactory.CreateDbContextAsync();
return await context.ArtifactStorageLocations.Where(a => a.Id == id).FirstOrDefaultAsync();
}
public async Task<List<ArtifactStorageLocation>?> GetAllArtifactStorageLocations()
{
await using var context = await _dbFactory.CreateDbContextAsync();
return await context.ArtifactStorageLocations.ToListAsync();
}
public async Task<List<ArtifactStorageLocation>?> Search(string query)
{
await using var context = await _dbFactory.CreateDbContextAsync();
return await context.ArtifactStorageLocations
.Where(p => p.Location.ToLower().Contains(query.ToLower())).ToListAsync();
}
public async Task<List<ArtifactStorageLocation>?> Top(int count)
{
await using var context = await _dbFactory.CreateDbContextAsync();
return await context.ArtifactStorageLocations
.OrderBy(p => p.Location)
.Take(count)
.ToListAsync();
}
}

74
OpenArchival.DataAccess/Providers/ArtifactTypeProvider.cs Normal file
View File

@@ -0,0 +1,74 @@
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using System.Diagnostics.CodeAnalysis;
namespace OpenArchival.DataAccess;
public class ArtifactTypeProvider : IArtifactTypeProvider
{
private readonly IDbContextFactory<ArchiveDbContext> _dbFactory;
private readonly ILogger<ArtifactTypeProvider> _logger;
[SetsRequiredMembers]
public ArtifactTypeProvider(IDbContextFactory<ArchiveDbContext> dbFactory, ILogger<ArtifactTypeProvider> logger)
{
_dbFactory = dbFactory;
_logger = logger;
}
public async Task CreateArtifactTypeAsync(ArtifactType artifactType)
{
await using var context = await _dbFactory.CreateDbContextAsync();
context.ArtifactTypes.Add(artifactType);
await context.SaveChangesAsync();
}
public async Task UpdateArtifactTypeAsync(ArtifactType artifactType)
{
await using var context = await _dbFactory.CreateDbContextAsync();
context.ArtifactTypes.Update(artifactType);
await context.SaveChangesAsync();
}
public async Task DeleteArtifactTypeAsync(ArtifactType artifactType)
{
await using var context = await _dbFactory.CreateDbContextAsync();
context.ArtifactTypes.Remove(artifactType);
await context.SaveChangesAsync();
}
public async Task<List<ArtifactType>?> GetArtifactType(string name)
{
await using var context = await _dbFactory.CreateDbContextAsync();
return await context.ArtifactTypes.Where(a => a.Name == name).ToListAsync();
}
public async Task<ArtifactType?> GetArtifactType(int id)
{
await using var context = await _dbFactory.CreateDbContextAsync();
return await context.ArtifactTypes.FirstOrDefaultAsync(a => a.Id == id);
}
public async Task<List<ArtifactType>?> GetAllArtifactTypes()
{
await using var context = await _dbFactory.CreateDbContextAsync();
return await context.ArtifactTypes.ToListAsync();
}
public async Task<List<ArtifactType>?> Search(string query)
{
await using var context = await _dbFactory.CreateDbContextAsync();
return await context.ArtifactTypes
.Where(p => p.Name.ToLower().Contains(query.ToLower()))
.ToListAsync();
}
public async Task<List<ArtifactType>?> Top(int count)
{
await using var context = await _dbFactory.CreateDbContextAsync();
return await context.ArtifactTypes
.OrderBy(p => p.Name)
.Take(count)
.ToListAsync();
}
}

61
OpenArchival.DataAccess/Providers/FilePathListingProvider.cs Normal file
View File

@@ -0,0 +1,61 @@
using Microsoft.EntityFrameworkCore;
using System.Diagnostics.CodeAnalysis;
namespace OpenArchival.DataAccess;
public class FilePathListingProvider : IFilePathListingProvider
{
private readonly ArchiveDbContext _context;
private readonly ILogger<FilePathListingProvider> _logger;
[SetsRequiredMembers]
public FilePathListingProvider(ArchiveDbContext context, ILogger<FilePathListingProvider> logger)
{
_context = context;
_logger = logger;
}
public async Task<FilePathListing?> GetFilePathListingAsync(int id)
{
return await _context.ArtifactFilePaths.Where(f => f.Id == id).FirstOrDefaultAsync();
}
public async Task<FilePathListing?> GetFilePathListingByPathAsync(string path)
{
return await _context.ArtifactFilePaths.Where(f => f.Path == path).FirstOrDefaultAsync();
}
public async Task CreateFilePathListingAsync(FilePathListing filePathListing)
{
_context.ArtifactFilePaths.Add(filePathListing);
await _context.SaveChangesAsync();
}
public async Task UpdateFilePathListingAsync(FilePathListing filePathListing)
{
_context.ArtifactFilePaths.Update(filePathListing);
await _context.SaveChangesAsync();
}
public async Task DeleteFilePathListingAsync(FilePathListing filePathListing)
{
_context.ArtifactFilePaths.Remove(filePathListing);
await _context.SaveChangesAsync();
}
public async Task<bool> DeleteFilePathListingAsync(string originalFileName, string diskPath)
{
var listingToDelete = await _context.ArtifactFilePaths
.Where(p => p.OriginalName == originalFileName)
.Where(p => p.Path == diskPath)
.FirstOrDefaultAsync();
if (listingToDelete == null)
{
return false;
}
_context.RemoveRange(listingToDelete);
return true;
}
}

21
OpenArchival.DataAccess/Providers/Interfaces/IArchiveCategoryProvider.cs Normal file
View File

@@ -0,0 +1,21 @@
namespace OpenArchival.DataAccess;
public interface IArchiveCategoryProvider
{
public Task CreateCategoryAsync(ArchiveCategory category);
public Task UpdateCategoryAsync(ArchiveCategory category);
public Task DeleteCategoryAsync(ArchiveCategory category);
public Task<ArchiveCategory?> GetArchiveCategory(int id);
public Task<List<ArchiveCategory>?> GetArchiveCategory(string categoryName);
public Task<List<ArchiveCategory>?> GetAllArchiveCategories();
public Task<List<ArchiveCategory>?> Search(string query);
public Task<List<ArchiveCategory>?> Top(int count);
}

18
OpenArchival.DataAccess/Providers/Interfaces/IArchiveEntryTagProvider.cs Normal file
View File

@@ -0,0 +1,18 @@
namespace OpenArchival.DataAccess;
public interface IArchiveEntryTagProvider
{
public Task<ArtifactEntryTag?> GetEntryTagAsync(int id);
public Task<List<ArtifactEntryTag>?> GetEntryTagAsync(string name);
public Task UpdateEntryTagAsync(ArtifactEntryTag entryTag);
public Task CreateEntryTagAsync(ArtifactEntryTag entryTag);
public Task DeleteEntryTagAsync(ArtifactEntryTag entryTag);
public Task<List<ArtifactEntryTag>?> Search(string query);
public Task<List<ArtifactEntryTag>?> Top(int count);
}

12
OpenArchival.DataAccess/Providers/Interfaces/IArtifactDefectProvider.cs Normal file
View File

@@ -0,0 +1,12 @@
namespace OpenArchival.DataAccess;
public interface IArtifactDefectProvider
{
public Task<ArtifactDefect?> GetDefectAsync(int id);
public Task<List<ArtifactDefect>?> GetDefectAsync(string description);
public Task UpdateDefectAsync(ArtifactDefect artifactDefect);
public Task CreateDefectAsync(ArtifactDefect artifactDefect);
public Task DeleteDefectAsync(ArtifactDefect artifactDefect);
public Task<List<ArtifactDefect>?> Search(string query);
public Task<List<ArtifactDefect>?> Top(int count);
}

10
OpenArchival.DataAccess/Providers/Interfaces/IArtifactGroupingProvider.cs Normal file
View File

@@ -0,0 +1,10 @@
namespace OpenArchival.DataAccess;
public interface IArtifactGroupingProvider
{
Task<ArtifactGrouping?> GetGroupingAsync(int id);
Task<ArtifactGrouping?> GetGroupingAsync(string artifactGroupingIdentifier);
Task CreateGroupingAsync(ArtifactGrouping grouping);
Task UpdateGroupingAsync(ArtifactGrouping grouping);
Task DeleteGroupingAsync(ArtifactGrouping grouping);
}

13
OpenArchival.DataAccess/Providers/Interfaces/IArtifactStorageLocationProvider.cs Normal file
View File

@@ -0,0 +1,13 @@
namespace OpenArchival.DataAccess;
public interface IArtifactStorageLocationProvider
{
Task CreateArtifactStorageLocationAsync(ArtifactStorageLocation location);
Task UpdateArtifactStorageLocationAsync(ArtifactStorageLocation location);
Task DeleteArtifactStorageLocationAsync(ArtifactStorageLocation location);
Task<List<ArtifactStorageLocation>?> GetArtifactStorageLocation(string locationName);
Task<ArtifactStorageLocation?> GetArtifactStorageLocation(int id);
Task<List<ArtifactStorageLocation>?> GetAllArtifactStorageLocations();
Task<List<ArtifactStorageLocation>?> Search(string query);
Task<List<ArtifactStorageLocation>?> Top(int count);
}

13
OpenArchival.DataAccess/Providers/Interfaces/IArtifactTypeProvider.cs Normal file
View File

@@ -0,0 +1,13 @@
namespace OpenArchival.DataAccess;
public interface IArtifactTypeProvider
{
Task CreateArtifactTypeAsync(ArtifactType artifactType);
Task UpdateArtifactTypeAsync(ArtifactType artifactType);
Task DeleteArtifactTypeAsync(ArtifactType artifactType);
Task<List<ArtifactType>?> GetArtifactType(string name);
Task<ArtifactType?> GetArtifactType(int id);
Task<List<ArtifactType>?> GetAllArtifactTypes();
Task<List<ArtifactType>?> Search(string query);
Task<List<ArtifactType>?> Top(int count);
}

11
OpenArchival.DataAccess/Providers/Interfaces/IFilePathListingProvider.cs Normal file
View File

@@ -0,0 +1,11 @@
namespace OpenArchival.DataAccess;
public interface IFilePathListingProvider
{
Task<FilePathListing?> GetFilePathListingAsync(int id);
Task<FilePathListing?> GetFilePathListingByPathAsync(string path);
Task CreateFilePathListingAsync(FilePathListing filePathListing);
Task UpdateFilePathListingAsync(FilePathListing filePathListing);
Task DeleteFilePathListingAsync(FilePathListing filePathListing);
public Task<bool> DeleteFilePathListingAsync(string originalFileName, string diskPath);
}

12
OpenArchival.DataAccess/Providers/Interfaces/IListedNameProvider.cs Normal file
View File

@@ -0,0 +1,12 @@
namespace OpenArchival.DataAccess;
public interface IListedNameProvider
{
Task<ListedName?> GetAssociatedNameAsync(int id);
Task<List<ListedName>?> GetAssociatedNamesAsync(string firstName, string lastName);
Task CreateAssociatedNameAsync(ListedName associatedName);
Task UpdateAssociatedNameAsync(ListedName associatedName);
Task DeleteAssociatedNameAsync(ListedName associatedName);
public Task<List<ListedName>?> Search(string query);
public Task<List<ListedName>?> Top(int count);
}

79
OpenArchival.DataAccess/Providers/ListedNameProvider.cs Normal file
View File

@@ -0,0 +1,79 @@
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using System.Diagnostics.CodeAnalysis;
namespace OpenArchival.DataAccess;
public class ListedNameProvider : IListedNameProvider
{
private readonly IDbContextFactory<ArchiveDbContext> _dbFactory;
private readonly ILogger<ListedNameProvider> _logger;
[SetsRequiredMembers]
public ListedNameProvider(IDbContextFactory<ArchiveDbContext> context, ILogger<ListedNameProvider> logger)
{
_dbFactory = context;
_logger = logger;
}
public async Task<ListedName?> GetAssociatedNameAsync(int id)
{
await using var context = await _dbFactory.CreateDbContextAsync();
return await context.ArtifactAssociatedNames.Where(n => n.Id == id).FirstOrDefaultAsync();
}
public async Task<List<ListedName>?> GetAssociatedNamesAsync(string firstName, string lastName)
{
await using var context = await _dbFactory.CreateDbContextAsync();
return await context.ArtifactAssociatedNames
.Where(n => n.FirstName == firstName && n.LastName == lastName)
.ToListAsync();
}
public async Task CreateAssociatedNameAsync(ListedName associatedName)
{
await using var context = await _dbFactory.CreateDbContextAsync();
context.ArtifactAssociatedNames.Add(associatedName);
await context.SaveChangesAsync();
}
public async Task UpdateAssociatedNameAsync(ListedName associatedName)
{
await using var context = await _dbFactory.CreateDbContextAsync();
context.ArtifactAssociatedNames.Update(associatedName);
await context.SaveChangesAsync();
}
public async Task DeleteAssociatedNameAsync(ListedName associatedName)
{
await using var context = await _dbFactory.CreateDbContextAsync();
context.ArtifactAssociatedNames.Remove(associatedName);
await context.SaveChangesAsync();
}
public async Task<List<ListedName>?> Search(string query)
{
await using var context = await _dbFactory.CreateDbContextAsync();
var lowerCaseQuery = query.ToLower();
return await context.ArtifactAssociatedNames
.Where(p => (p.FirstName + " " + p.LastName).ToLower().Contains(lowerCaseQuery))
.ToListAsync();
}
public async Task<List<ListedName>?> Top(int count)
{
await using var context = await _dbFactory.CreateDbContextAsync();
return await context.ArtifactAssociatedNames
.OrderBy(p => p.FirstName)
.Take(count)
.ToListAsync();
}
}