use cancellation tokens in many places (#2350)

* use cancellation tokens everywhere

* more cancellation tokens

ErsatzTV.Application/Libraries/Commands/CallLibraryScannerHandler.cs

@@ -169,20 +169,23 @@ public abstract class CallLibraryScannerHandler<TRequest>
         }
     }
 
-    protected abstract Task<DateTimeOffset> GetLastScan(TvContext dbContext, TRequest request);
+    protected abstract Task<DateTimeOffset> GetLastScan(
+        TvContext dbContext,
+        TRequest request,
+        CancellationToken cancellationToken);
     protected abstract bool ScanIsRequired(DateTimeOffset lastScan, int libraryRefreshInterval, TRequest request);
 
-    protected async Task<Validation<BaseError, string>> Validate(TRequest request)
+    protected async Task<Validation<BaseError, string>> Validate(TRequest request, CancellationToken cancellationToken)
     {
         int libraryRefreshInterval = await _configElementRepository
-            .GetValue<int>(ConfigElementKey.LibraryRefreshInterval)
+            .GetValue<int>(ConfigElementKey.LibraryRefreshInterval, cancellationToken)
             .IfNoneAsync(0);
 
         libraryRefreshInterval = Math.Clamp(libraryRefreshInterval, 0, 999_999);
 
-        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync();
+        await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
 
-        DateTimeOffset lastScan = await GetLastScan(dbContext, request);
+        DateTimeOffset lastScan = await GetLastScan(dbContext, request, cancellationToken);
         if (!ScanIsRequired(lastScan, libraryRefreshInterval, request))
         {
             return new ScanIsNotRequired();

ErsatzTV.Application/Libraries/Commands/DeleteLocalLibraryHandler.cs

@@ -25,7 +25,10 @@ public class DeleteLocalLibraryHandler : LocalLibraryHandlerBase,
         CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, LocalLibrary> validation = await LocalLibraryMustExist(dbContext, request);
+        Validation<BaseError, LocalLibrary> validation = await LocalLibraryMustExist(
+            dbContext,
+            request,
+            cancellationToken);
         return await validation.Apply(localLibrary => DoDeletion(dbContext, localLibrary));
     }
 
@@ -77,8 +80,9 @@ public class DeleteLocalLibraryHandler : LocalLibraryHandlerBase,
 
     private static Task<Validation<BaseError, LocalLibrary>> LocalLibraryMustExist(
         TvContext dbContext,
-        DeleteLocalLibrary request) =>
+        DeleteLocalLibrary request,
+        CancellationToken cancellationToken) =>
         dbContext.LocalLibraries
-            .SelectOneAsync(ll => ll.Id, ll => ll.Id == request.LocalLibraryId)
+            .SelectOneAsync(ll => ll.Id, ll => ll.Id == request.LocalLibraryId, cancellationToken)
             .Map(o => o.ToValidation<BaseError>($"Local library {request.LocalLibraryId} does not exist."));
 }

ErsatzTV.Application/Libraries/Commands/MoveLocalLibraryPathHandler.cs

@@ -38,17 +38,17 @@ public class MoveLocalLibraryPathHandler : IRequestHandler<MoveLocalLibraryPath,
         CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
-        return await validation.Apply(parameters => MovePath(dbContext, parameters));
+        Validation<BaseError, Parameters> validation = await Validate(dbContext, request, cancellationToken);
+        return await validation.Apply(parameters => MovePath(dbContext, parameters, cancellationToken));
     }
 
-    private async Task<Unit> MovePath(TvContext dbContext, Parameters parameters)
+    private async Task<Unit> MovePath(TvContext dbContext, Parameters parameters, CancellationToken cancellationToken)
     {
         LibraryPath path = parameters.LibraryPath;
         LocalLibrary newLibrary = parameters.Library;
 
         path.LibraryId = newLibrary.Id;
-        if (await dbContext.SaveChangesAsync() > 0)
+        if (await dbContext.SaveChangesAsync(cancellationToken) > 0)
         {
             List<int> ids = await dbContext.Connection.QueryAsync<int>(
                     @"SELECT MediaItem.Id FROM MediaItem WHERE LibraryPathId = @LibraryPathId",
@@ -57,14 +57,14 @@ public class MoveLocalLibraryPathHandler : IRequestHandler<MoveLocalLibraryPath,
 
             foreach (int id in ids)
             {
-                Option<MediaItem> maybeMediaItem = await _searchRepository.GetItemToIndex(id);
+                Option<MediaItem> maybeMediaItem = await _searchRepository.GetItemToIndex(id, cancellationToken);
                 foreach (MediaItem mediaItem in maybeMediaItem)
                 {
                     _logger.LogInformation("Moving item at {Path}", await GetPath(dbContext, mediaItem));
                     await _searchIndex.UpdateItems(
                         _searchRepository,
                         _fallbackMetadataProvider,
-                        new List<MediaItem> { mediaItem });
+                        [mediaItem]);
                 }
             }
         }
@@ -74,24 +74,28 @@ public class MoveLocalLibraryPathHandler : IRequestHandler<MoveLocalLibraryPath,
 
     private static async Task<Validation<BaseError, Parameters>> Validate(
         TvContext dbContext,
-        MoveLocalLibraryPath request) =>
-        (await LibraryPathMustExist(dbContext, request), await LocalLibraryMustExist(dbContext, request))
+        MoveLocalLibraryPath request,
+        CancellationToken cancellationToken) =>
+        (await LibraryPathMustExist(dbContext, request, cancellationToken),
+            await LocalLibraryMustExist(dbContext, request, cancellationToken))
         .Apply((libraryPath, localLibrary) => new Parameters(libraryPath, localLibrary));
 
     private static Task<Validation<BaseError, LibraryPath>> LibraryPathMustExist(
         TvContext dbContext,
-        MoveLocalLibraryPath request) =>
+        MoveLocalLibraryPath request,
+        CancellationToken cancellationToken) =>
         dbContext.LibraryPaths
             .Include(lp => lp.Library)
-            .SelectOneAsync(c => c.Id, c => c.Id == request.LibraryPathId)
+            .SelectOneAsync(c => c.Id, c => c.Id == request.LibraryPathId, cancellationToken)
             .Map(o => o.ToValidation<BaseError>("LibraryPath does not exist."));
 
     private static Task<Validation<BaseError, LocalLibrary>> LocalLibraryMustExist(
         TvContext dbContext,
-        MoveLocalLibraryPath request) =>
+        MoveLocalLibraryPath request,
+        CancellationToken cancellationToken) =>
         dbContext.LocalLibraries
             .Include(ll => ll.Paths)
-            .SelectOneAsync(a => a.Id, a => a.Id == request.TargetLibraryId)
+            .SelectOneAsync(a => a.Id, a => a.Id == request.TargetLibraryId, cancellationToken)
             .Map(o => o.ToValidation<BaseError>("LocalLibrary does not exist"));
 
     private static async Task<string> GetPath(TvContext dbContext, MediaItem mediaItem) =>

ErsatzTV.Application/Libraries/Commands/QueueLibraryScanByLibraryIdHandler.cs

@@ -25,7 +25,7 @@ public class QueueLibraryScanByLibraryIdHandler(
 
         Option<Library> maybeLibrary = await dbContext.Libraries
             .AsNoTracking()
-            .SelectOneAsync(l => l.Id, l => l.Id == request.LibraryId);
+            .SelectOneAsync(l => l.Id, l => l.Id == request.LibraryId, cancellationToken);
 
         foreach (Library library in maybeLibrary)
         {

ErsatzTV.Application/Libraries/Commands/QueueShowScanByLibraryIdHandler.cs

@@ -24,7 +24,7 @@ public class QueueShowScanByLibraryIdHandler(
 
         Option<Library> maybeLibrary = await dbContext.Libraries
             .AsNoTracking()
-            .SelectOneAsync(l => l.Id, l => l.Id == request.LibraryId);
+            .SelectOneAsync(l => l.Id, l => l.Id == request.LibraryId, cancellationToken);
 
         foreach (Library library in maybeLibrary)
         {

ErsatzTV.Application/Libraries/Commands/UpdateLocalLibraryHandler.cs

@@ -37,7 +37,7 @@ public class UpdateLocalLibraryHandler : LocalLibraryHandlerBase,
         CancellationToken cancellationToken)
     {
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
-        Validation<BaseError, Parameters> validation = await Validate(dbContext, request);
+        Validation<BaseError, Parameters> validation = await Validate(dbContext, request, cancellationToken);
         return await validation.Apply(parameters => UpdateLocalLibrary(dbContext, parameters));
     }
 
@@ -105,18 +105,20 @@ public class UpdateLocalLibraryHandler : LocalLibraryHandlerBase,
 
     private static Task<Validation<BaseError, Parameters>> Validate(
         TvContext dbContext,
-        UpdateLocalLibrary request) =>
-        LocalLibraryMustExist(dbContext, request)
+        UpdateLocalLibrary request,
+        CancellationToken cancellationToken) =>
+        LocalLibraryMustExist(dbContext, request, cancellationToken)
             .BindT(parameters => NameMustBeValid(request, parameters.Incoming).MapT(_ => parameters))
             .BindT(parameters => PathsMustBeValid(dbContext, parameters.Incoming, parameters.Existing.Id)
                 .MapT(_ => parameters));
 
     private static Task<Validation<BaseError, Parameters>> LocalLibraryMustExist(
         TvContext dbContext,
-        UpdateLocalLibrary request) =>
+        UpdateLocalLibrary request,
+        CancellationToken cancellationToken) =>
         dbContext.LocalLibraries
             .Include(ll => ll.Paths)
-            .SelectOneAsync(ll => ll.Id, ll => ll.Id == request.Id)
+            .SelectOneAsync(ll => ll.Id, ll => ll.Id == request.Id, cancellationToken)
             .MapT(existing =>
             {
                 var incoming = new LocalLibrary