Merge branch 'Nexus-Mods:main' into add-spanish-language

Author: ravelaso

src/NexusMods.Abstractions.GameLocators/GamePath.cs

@@ -52,6 +52,16 @@ public GamePath(LocationId locationId, RelativePath path)
 
     /// <summary/>
     public static bool operator !=(GamePath a, GamePath b) => a.LocationId != b.LocationId || a.Path != b.Path;
+    
+    /// <summary>
+    /// Joins the current path with a relative path.
+    /// </summary>
+    public static GamePath operator /(GamePath a, RelativePath b) => new(a.LocationId, a.Path / b);
+    
+    /// <summary>
+    /// Joins the current path with a string.
+    /// </summary>
+    public static GamePath operator /(GamePath a, string b) => new(a.LocationId, a.Path / b);
 
     /// <inheritdoc />
     public override bool Equals(object? obj) => obj is GamePath other && Equals(other);

src/NexusMods.Abstractions.Games/AGame.cs

@@ -36,7 +36,7 @@ protected AGame(IServiceProvider provider)
         _gameLocators = provider.GetServices<IGameLocator>();
         // In a Lazy so we don't get a circular dependency
         _synchronizer = new Lazy<ILoadoutSynchronizer>(() => MakeSynchronizer(provider));
-        _sortOrderManager = new Lazy<ISortOrderManager>(() => MakeSortOrderManager(provider));
+        _sortOrderManager = new Lazy<ISortOrderManager>(() => MakeSortOrderManager(provider, this));
         _fs = provider.GetRequiredService<IFileSystem>();
     }
 
@@ -48,10 +48,10 @@ protected virtual ILoadoutSynchronizer MakeSynchronizer(IServiceProvider provide
         return new DefaultSynchronizer(provider);
     }
 
-    private ISortOrderManager MakeSortOrderManager(IServiceProvider provider)
+    private ISortOrderManager MakeSortOrderManager(IServiceProvider provider, IGame game)
     {
         var manager = new SortOrderManager(provider);
-        manager.RegisterSortOrderVarieties(GetSortOrderVarieties());
+        manager.RegisterSortOrderVarieties(GetSortOrderVarieties(), game);
         return manager;
     }
 
@@ -87,6 +87,8 @@ private ISortOrderManager MakeSortOrderManager(IServiceProvider provider)
 
     /// <inheritdoc />
     public virtual ILoadoutSynchronizer Synchronizer => _synchronizer.Value;
+    
+    public virtual ISortOrderManager SortOrderManager => _sortOrderManager.Value;
 
     /// <inheritdoc />
     public GameInstallation InstallationFromLocatorResult(GameLocatorResult metadata, EntityId dbId, IGameLocator locator)

src/NexusMods.Abstractions.Games/IGame.cs

@@ -50,6 +50,11 @@ public interface IGame : ILocatableGame
     /// </summary>
     public ILoadoutSynchronizer Synchronizer { get; }
 
+    /// <summary>
+    /// The sort order manager for this game.
+    /// </summary>
+    public ISortOrderManager SortOrderManager { get; }
+    
     /// <summary>
     /// Constructs a <see cref="GameInstallation"/> from the given <see cref="GameLocatorResult"/>, and a unique DB ID,
     /// also marks the installation was sourced from the given <see cref="IGameLocator"/>.

src/NexusMods.Abstractions.Games/NexusMods.Abstractions.Games.csproj

@@ -38,4 +38,9 @@
         <DependentUpon>ISortOrderManager.cs</DependentUpon>
       </Compile>
     </ItemGroup>
+
+    <ItemGroup>
+        <AdditionalFiles Include="**\*.sql" />
+        <UpToDateCheckInput Include="**\*.sql"/>
+    </ItemGroup>
 </Project>

src/NexusMods.Abstractions.Games/Services.cs

@@ -13,6 +13,7 @@ public static class Services
     public static IServiceCollection AddGames(this IServiceCollection services)
     {
         return services
-            .AddSortOrderItemModel();
+            .AddSortOrderItemModel()
+            .AddSortOrderQueriesSql();
     }
 }

src/NexusMods.Abstractions.Games/SortOrder/ASortOrderVariety.cs

@@ -23,23 +23,17 @@ public abstract class ASortOrderVariety<TKey, TSortableItem, TItemLoadoutData, T
     where TItemLoadoutData : ISortItemLoadoutData<TKey>
     where TSortedEntry : ISortItemData<TKey>
 {
-    private readonly ILogger _logger;
+    private readonly ILogger<ASortOrderVariety<TKey, TSortableItem, TItemLoadoutData, TSortedEntry>> _logger;
 
     /// <summary>
     /// Database connection
     /// </summary>
     protected readonly IConnection Connection;
-    
-    /// <summary>
-    /// The game sort order manager that this variety belongs to.
-    /// </summary>
-    protected readonly ISortOrderManager Manager;
-    
-    protected ASortOrderVariety(IServiceProvider serviceProvider, ISortOrderManager manager)
+
+    protected ASortOrderVariety(IServiceProvider serviceProvider)
     {
         Connection = serviceProvider.GetRequiredService<IConnection>();
-        _logger = serviceProvider.GetRequiredService<ILogger>();
-        Manager = manager;
+        _logger = serviceProvider.GetRequiredService<ILogger<ASortOrderVariety<TKey, TSortableItem, TItemLoadoutData, TSortedEntry>>>();
     }
 
 #region public members
@@ -195,19 +189,20 @@ public async ValueTask MoveItemDelta(SortOrderId sortOrderId, TKey sourceItem, i
     }
 
     /// <inheritdoc />
-    public virtual async ValueTask ReconcileSortOrder(SortOrderId sortOrderId, IDb? db = null, CancellationToken token = default)
+    public virtual async ValueTask ReconcileSortOrder(SortOrderId sortOrderId, IDb? referenceDb = null, CancellationToken token = default)
     {
         // If this is passed a specific database, don't retry the reconciliation using the most recent database.
-        var noRetry = db is not null; 
+        var noRetry = referenceDb is not null; 
         var retryCount = 0;
-        var dbToUse = db ?? Connection.Db;
 
         while (retryCount <= 3)
         {
-            var reconciledItems = ReconcileSortOrderCore(sortOrderId, dbToUse);
+            var refDb = referenceDb ?? Connection.Db;
 
-            var succeded = await TryPersistSortOrder(sortOrderId, reconciledItems.Select(tuple => tuple.SortedEntry).ToArray(), dbToUse, token);
-            if (succeded) return;
+            var reconciledItems = ReconcileSortOrderCore(sortOrderId, refDb);
+            
+            var succeeded = await TryPersistSortOrder(sortOrderId, reconciledItems.Select(tuple => tuple.SortedEntry).ToArray(), refDb, token);
+            if (succeeded) return;
 
             if (noRetry)
             {
@@ -222,6 +217,30 @@ public virtual async ValueTask ReconcileSortOrder(SortOrderId sortOrderId, IDb?
         _logger.LogError("Reconciliation of sort order {SortOrderId} failed after 4 attempts", sortOrderId);
     }
 
+    /// <inheritdoc />
+    public virtual async ValueTask DeleteSortOrder(SortOrderId sortOrderId, CancellationToken token = default)
+    {
+        using var tx = Connection.BeginTransaction();
+        
+        // Delete the items
+        foreach (var item in Connection.Db.Datoms(SortOrderItem.ParentSortOrder, sortOrderId))
+        {
+            tx.Delete(item.E, recursive: false);
+        }
+        
+        // Delete the sort order
+        tx.Delete(sortOrderId, recursive: false);
+        
+        try
+        {
+            await tx.Commit();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to delete sort order {SortOrderId}", sortOrderId);
+        }
+    }
+    
 
 #endregion public members
 
@@ -285,17 +304,20 @@ protected abstract void PersistSortOrderCore(
         CancellationToken token = default);
 
 
-    protected virtual IReadOnlyList<(TSortedEntry SortedEntry, TItemLoadoutData ItemLoadoutData)> ReconcileSortOrderCore(SortOrderId sortOrderId, IDb dbToUse)
+    protected virtual IReadOnlyList<(TSortedEntry SortedEntry, TItemLoadoutData ItemLoadoutData)> ReconcileSortOrderCore(SortOrderId sortOrderId, IDb loadoutRevisionDb)
     {
-        var sortOrder = SortOrder.Load(dbToUse, sortOrderId);
+        // Get the most recent sort order data
+        var sortOrder = SortOrder.Load(loadoutRevisionDb.Connection.Db, sortOrderId);
 
         var collectionGroupId = sortOrder.ParentEntity.IsT1 ? 
             sortOrder.ParentEntity.AsT1 : 
             Optional<CollectionGroupId>.None;
 
-        var loadoutData = RetrieveLoadoutData(sortOrder.LoadoutId, collectionGroupId, dbToUse);
+        // Get the loadout data from the revision db
+        var loadoutData = RetrieveLoadoutData(sortOrder.LoadoutId, collectionGroupId, loadoutRevisionDb);
 
-        var currentSortOrder = RetrieveSortOrder(sortOrderId, dbToUse);
+        // Get the most recent sort order data
+        var currentSortOrder = RetrieveSortOrder(sortOrderId, loadoutRevisionDb.Connection.Db);
 
         var reconciledItems = Reconcile(currentSortOrder, loadoutData);
         return reconciledItems;
@@ -304,6 +326,7 @@ protected abstract void PersistSortOrderCore(
     /// <summary>
     /// Returns a collection of loadout-specific TItemLoadoutData for each relevant item found in the provided loadout/collection.
     /// These loadout data items are unsorted and do not have a sort index.
+    /// This already filters out duplicates, currently selecting the most recently added enabled item for each key.
     /// </summary>
     protected abstract IReadOnlyList<TItemLoadoutData> RetrieveLoadoutData(
         LoadoutId loadoutId,

src/NexusMods.Abstractions.Games/SortOrder/ISortItemData.cs

@@ -3,7 +3,7 @@ namespace NexusMods.Abstractions.Games;
 /// <summary>
 /// Represents an entry in a stored sort order.
 /// </summary>
-public interface ISortItemData
+public interface ISortItemData : IComparable<ISortItemData>
 {
     public ISortItemKey Key { get;}
 
@@ -28,7 +28,7 @@ public interface ISortItemData<out TKey> : ISortItemData
 /// This class is used to represent an entry in a stored sort order.
 /// </summary>
 /// <typeparam name="TKey"></typeparam>
-public class SortItemData<TKey> : ISortItemData<TKey>
+public class SortItemData<TKey> : ISortItemData<TKey>, IComparable<SortItemData<TKey>> 
     where TKey : IEquatable<TKey>, ISortItemKey
 {
     public SortItemData(TKey key, int sortIndex)
@@ -40,4 +40,18 @@ public SortItemData(TKey key, int sortIndex)
     public TKey Key { get; }
 
     public int SortIndex { get; set; }
+
+    public int CompareTo(SortItemData<TKey>? other)
+    {
+        if (ReferenceEquals(this, other)) return 0;
+        if (other is null) return 1;
+        return SortIndex.CompareTo(other.SortIndex);
+    }
+
+    public int CompareTo(ISortItemData? other)
+    {
+        if (ReferenceEquals(this, other)) return 0;
+        if (other is null) return 1;
+        return SortIndex.CompareTo(other.SortIndex);
+    }
 }

src/NexusMods.Abstractions.Games/SortOrder/ISortOrderManager.cs

@@ -1,3 +1,4 @@
+using System.Collections.Immutable;
 using DynamicData.Kernel;
 using NexusMods.Abstractions.Loadouts;
 
@@ -21,12 +22,12 @@ public interface ISortOrderManager
     /// One instance of ISortOrderVariety for each variety.
     /// </summary>
     /// <returns></returns>
-    public ReadOnlySpan<ISortOrderVariety> GetSortOrderVarieties();
+    public IReadOnlyList<ISortOrderVariety> GetSortOrderVarieties();
 
     /// <summary>
     /// Sets the sort order varieties for the current game.
     /// Should only be called once during initialization of the game.
     /// </summary>
     /// <param name="sortOrderVarieties"></param>
-    public void RegisterSortOrderVarieties(ISortOrderVariety[] sortOrderVarieties);
+    public void RegisterSortOrderVarieties(ISortOrderVariety[] sortOrderVarieties, IGame game);
 }

src/NexusMods.Abstractions.Games/SortOrder/ISortOrderVariety.cs

@@ -100,7 +100,11 @@ public ValueTask MoveItems(
     [Pure]
     public ValueTask ReconcileSortOrder(SortOrderId sortOrderId, IDb? db = null, CancellationToken token = default);
 
-
+    /// <summary>
+    /// Deletes the SortOrder and all child SortOrderItems. 
+    /// </summary>
+    [Pure]
+    public ValueTask DeleteSortOrder(SortOrderId sortOrderId, CancellationToken token = default);
 
     /// <summary>
     /// Static metadata for the sort order type that can be accessed by derived classes for reuse