Chore updates

Directory.Packages.props

@@ -17,13 +17,13 @@
     <PackageVersion Include="Microsoft.Extensions.Configuration.Json" Version="10.0.0" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
     <PackageVersion Include="Microsoft.Web.LibraryManager.Build" Version="3.0.71" />
-    <PackageVersion Include="Serilog.AspNetCore" Version="9.0.0" />
-    <PackageVersion Include="Serilog.Settings.Configuration" Version="9.0.0" />
+    <PackageVersion Include="Serilog.AspNetCore" Version="10.0.0" />
+    <PackageVersion Include="Serilog.Settings.Configuration" Version="10.0.0" />
     <PackageVersion Include="Serilog.Sinks.File" Version="7.0.0" />
     <PackageVersion Include="Serilog.Sinks.MSSqlServer" Version="9.0.2" />
     <PackageVersion Include="System.IdentityModel.Tokens.Jwt" Version="8.15.0" />
     <PackageVersion Include="Shouldly" Version="4.3.0" />
-    <PackageVersion Include="xunit.v3" Version="3.2.0" />
+    <PackageVersion Include="xunit.v3" Version="3.2.1" />
     <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.5" />
     <PackageVersion Include="coverlet.collector" Version="6.0.2" />
   </ItemGroup>

src/RDMG.Core/Abstractions/Repository/IUserRepository.cs

@@ -4,10 +4,13 @@ namespace RDMG.Core.Abstractions.Repository;
 
 public interface IUserRepository
 {
-    Task<User> CreateAsync(User user);
-    Task<User?> UpdateAsync(User user);
-    Task<User?> GetByUsernameAsync(string username, bool? deleted = false);
-    Task<User?> GetAsync(int id);
-    Task<IEnumerable<User>> ListAsync(bool? deleted = false);
-    Task<bool> DeleteAsync(int id);
+    Task<User> CreateAsync(User user, CancellationToken cancellationToken = default);
+    Task<User?> UpdateAsync(User user, CancellationToken cancellationToken = default);
+
+    Task<User?> GetByUsernameAsync(string username, bool? deleted = false,
+        CancellationToken cancellationToken = default);
+
+    Task<User?> GetAsync(int id, CancellationToken cancellationToken = default);
+    Task<User[]> ListAsync(bool? deleted = false, CancellationToken cancellationToken = default);
+    Task<bool> DeleteAsync(int id, CancellationToken cancellationToken = default);
 }

src/RDMG.Core/Abstractions/Services/IDungeonService.cs

@@ -4,19 +4,28 @@ namespace RDMG.Core.Abstractions.Services;
 
 public interface IDungeonService
 {
-    Task<IEnumerable<DungeonOptionModel>> GetAllDungeonOptionsAsync(CancellationToken cancellationToken);
-    Task<IEnumerable<DungeonOptionModel>> GetAllDungeonOptionsForUserAsync(int userId, CancellationToken cancellationToken);
+    Task<DungeonOptionModel[]> GetAllDungeonOptionsAsync(CancellationToken cancellationToken);
+    Task<DungeonOptionModel[]> GetAllDungeonOptionsForUserAsync(int userId, CancellationToken cancellationToken);
     Task<DungeonOptionModel> GetDungeonOptionAsync(int id, CancellationToken cancellationToken);
-    Task<DungeonOptionModel?> GetDungeonOptionByNameAsync(string dungeonName, int userId, CancellationToken cancellationToken);
+
+    Task<DungeonOptionModel?> GetDungeonOptionByNameAsync(string dungeonName, int userId,
+        CancellationToken cancellationToken);
+
     Task<DungeonModel> GetDungeonAsync(int id, CancellationToken cancellationToken);
-    Task<DungeonModel> CreateOrUpdateDungeonAsync(DungeonOptionModel optionModel, bool addDungeon, int level, CancellationToken cancellationToken);
+
+    Task<DungeonModel> CreateOrUpdateDungeonAsync(DungeonOptionModel optionModel, bool addDungeon, int level,
+        CancellationToken cancellationToken);
+
     Task UpdateDungeonAsync(DungeonModel model, CancellationToken cancellationToken);
     Task<int> CreateDungeonOptionAsync(DungeonOptionModel dungeonOption, CancellationToken cancellationToken);
-    Task<IEnumerable<DungeonModel>> ListUserDungeonsAsync(int userId, CancellationToken cancellationToken);
-    Task<IEnumerable<DungeonModel>> ListUserDungeonsByNameAsync(string dungeonName, int userId, CancellationToken cancellationToken);
+    Task<DungeonModel[]> ListUserDungeonsAsync(int userId, CancellationToken cancellationToken);
+
+    Task<DungeonModel[]> ListUserDungeonsByNameAsync(string dungeonName, int userId,
+        CancellationToken cancellationToken);
+
     Task<int> AddDungeonAsync(DungeonModel savedDungeon, CancellationToken cancellationToken);
     Task<bool> DeleteDungeonOptionAsync(int id, CancellationToken cancellationToken);
     Task<bool> DeleteDungeonAsync(int id, CancellationToken cancellationToken);
-    Task<DungeonModel> GenerateDungeonAsync(DungeonOptionModel model);
+    Task<DungeonModel> GenerateDungeonAsync(DungeonOptionModel model, CancellationToken cancellationToken);
     Task RenameDungeonAsync(int optionId, int userId, string newName, CancellationToken cancellationToken);
 }

src/RDMG.Core/Abstractions/Services/IOptionService.cs

@@ -5,5 +5,5 @@ namespace RDMG.Core.Abstractions.Services;
 
 public interface IOptionService
 {
-    Task<IEnumerable<OptionModel>> ListOptionsAsync(OptionKey? filter = null, CancellationToken cancellationToken = default);
+    Task<OptionModel[]> ListOptionsAsync(OptionKey? filter = null, CancellationToken cancellationToken = default);
 }

src/RDMG.Core/Abstractions/Services/IUserService.cs

@@ -4,11 +4,11 @@ namespace RDMG.Core.Abstractions.Services;
 
 public interface IUserService
 {
-    Task<UserModel> GetAsync(int id);
-    Task UpdateAsync(UserModel model);
-    Task<int> CreateAsync(UserModel model);
-    Task<IEnumerable<UserModel>> ListAsync(bool? deleted = false);
-    Task<bool> DeleteAsync(int id);
-    Task<bool> RestoreAsync(int id);
-    Task ChangePasswordAsync(ChangePasswordModel model);
+    Task<UserModel> GetAsync(int id, CancellationToken cancellationToken = default);
+    Task UpdateAsync(UserModel model, CancellationToken cancellationToken = default);
+    Task<int> CreateAsync(UserModel model, CancellationToken cancellationToken = default);
+    Task<UserModel[]> ListAsync(bool? deleted = false, CancellationToken cancellationToken = default);
+    Task<bool> DeleteAsync(int id, CancellationToken cancellationToken = default);
+    Task<bool> RestoreAsync(int id, CancellationToken cancellationToken = default);
+    Task ChangePasswordAsync(ChangePasswordModel model, CancellationToken cancellationToken = default);
 }

src/RDMG.Core/Services/DungeonService.cs

@@ -110,7 +110,7 @@ public async Task<DungeonModel> CreateOrUpdateDungeonAsync(DungeonOptionModel op
     private async Task<DungeonModel> UpdateExistingDungeonAsync(DungeonOptionModel optionModel,
         DungeonOptionModel existingDungeonOption, DungeonModel oldDungeon, CancellationToken cancellationToken)
     {
-        var dungeon = await GenerateDungeonAsync(optionModel, existingDungeonOption.Id);
+        var dungeon = await GenerateDungeonAsync(optionModel, existingDungeonOption.Id, cancellationToken);
         dungeon.Id = oldDungeon.Id;
         dungeon.Level = oldDungeon.Level;
         await UpdateDungeonAsync(dungeon, cancellationToken);
@@ -121,7 +121,7 @@ private async Task<DungeonModel> CreateOptionAndAddDungeonToItAsync(DungeonOptio
         CancellationToken cancellationToken)
     {
         var createdId = await CreateDungeonOptionAsync(optionModel, cancellationToken);
-        var dungeon = await GenerateDungeonAsync(optionModel, createdId);
+        var dungeon = await GenerateDungeonAsync(optionModel, createdId, cancellationToken);
         dungeon.Level = 1;
         var id = await AddDungeonAsync(dungeon, cancellationToken);
         dungeon.Id = id;
@@ -134,7 +134,7 @@ private async Task<DungeonModel> AddDungeonToExistingOptionAsync(DungeonOptionMo
         var existingDungeons =
             (await ListUserDungeonsByNameAsync(optionModel.DungeonName, optionModel.UserId, cancellationToken))
             .ToList();
-        var dungeon = await GenerateDungeonAsync(optionModel, optionModel.Id);
+        var dungeon = await GenerateDungeonAsync(optionModel, optionModel.Id, cancellationToken);
         dungeon.Level = level;
         if (existingDungeons.Exists(d => d.Level == level))
         {
@@ -149,21 +149,23 @@ private async Task<DungeonModel> AddDungeonToExistingOptionAsync(DungeonOptionMo
         return dungeon;
     }
 
-    private async Task<DungeonModel> GenerateDungeonAsync(DungeonOptionModel optionModel, int optionId)
+    private async Task<DungeonModel> GenerateDungeonAsync(DungeonOptionModel optionModel, int optionId,
+        CancellationToken cancellationToken)
     {
-        var dungeon = await GenerateDungeonAsync(optionModel);
+        var dungeon = await GenerateDungeonAsync(optionModel, cancellationToken);
         dungeon.DungeonOptionId = optionId;
         return dungeon;
     }
 
-    public async Task<DungeonModel> GenerateDungeonAsync(DungeonOptionModel model)
+    public async Task<DungeonModel> GenerateDungeonAsync(DungeonOptionModel model, CancellationToken cancellationToken)
     {
         try
         {
             ValidateModel(model);
             if (model.Corridor)
-                return await Task.FromResult(_dungeon.Generate(model));
-            return await Task.FromResult(_dungeonNcDungeon.Generate(model));
+                return await Task.Run(async () => await Task.FromResult(_dungeon.Generate(model)), cancellationToken);
+            return await Task.Run(async () => await Task.FromResult(_dungeonNcDungeon.Generate(model)),
+                cancellationToken);
         }
         catch (Exception ex)
         {
@@ -172,13 +174,13 @@ public async Task<DungeonModel> GenerateDungeonAsync(DungeonOptionModel model)
         }
     }
 
-    public async Task<IEnumerable<DungeonOptionModel>> GetAllDungeonOptionsAsync(CancellationToken cancellationToken)
+    public async Task<DungeonOptionModel[]> GetAllDungeonOptionsAsync(CancellationToken cancellationToken)
     {
         try
         {
             var options = await _dungeonOptionRepository.GetAllDungeonOptionsAsync(cancellationToken);
 
-            return options.Select(_mapper.Map<DungeonOptionModel>);
+            return [.. options.Select(_mapper.Map<DungeonOptionModel>)];
         }
         catch (Exception ex)
         {
@@ -187,14 +189,14 @@ public async Task<IEnumerable<DungeonOptionModel>> GetAllDungeonOptionsAsync(Can
         }
     }
 
-    public async Task<IEnumerable<DungeonOptionModel>> GetAllDungeonOptionsForUserAsync(int userId,
+    public async Task<DungeonOptionModel[]> GetAllDungeonOptionsForUserAsync(int userId,
         CancellationToken cancellationToken)
     {
         try
         {
             var options = await _dungeonOptionRepository.GetAllDungeonOptionsForUserAsync(userId, cancellationToken);
 
-            return options.Select(_mapper.Map<DungeonOptionModel>);
+            return [.. options.Select(_mapper.Map<DungeonOptionModel>)];
         }
         catch (Exception ex)
         {
@@ -245,12 +247,12 @@ public async Task<bool> DeleteDungeonAsync(int id, CancellationToken cancellatio
         }
     }
 
-    public async Task<IEnumerable<DungeonModel>> ListUserDungeonsAsync(int userId, CancellationToken cancellationToken)
+    public async Task<DungeonModel[]> ListUserDungeonsAsync(int userId, CancellationToken cancellationToken)
     {
         try
         {
             var result = await _dungeonRepository.GetAllDungeonsForUserAsync(userId, cancellationToken);
-            return result.Select(_mapper.Map<DungeonModel>);
+            return [.. result.Select(_mapper.Map<DungeonModel>)];
         }
         catch (Exception ex)
         {
@@ -259,14 +261,14 @@ public async Task<IEnumerable<DungeonModel>> ListUserDungeonsAsync(int userId, C
         }
     }
 
-    public async Task<IEnumerable<DungeonModel>> ListUserDungeonsByNameAsync(string dungeonName, int userId,
+    public async Task<DungeonModel[]> ListUserDungeonsByNameAsync(string dungeonName, int userId,
         CancellationToken cancellationToken)
     {
         try
         {
             var result =
                 await _dungeonRepository.GetAllDungeonByOptionNameForUserAsync(dungeonName, userId, cancellationToken);
-            return result.Select(_mapper.Map<DungeonModel>);
+            return [.. result.Select(_mapper.Map<DungeonModel>)];
         }
         catch (Exception ex)
         {

src/RDMG.Core/Services/OptionService.cs

@@ -19,13 +19,15 @@ public class OptionService(
     private readonly IMapper _mapper = mapper;
     private readonly ILogger _logger = logger;
 
-    public async Task<IEnumerable<OptionModel>> ListOptionsAsync(OptionKey? filter = null,
+    public async Task<OptionModel[]> ListOptionsAsync(OptionKey? filter = null,
         CancellationToken cancellationToken = default)
     {
         try
         {
-            if (_memoryCache.TryGetValue(nameof(ListOptionsAsync), out List<OptionModel>? cacheEntry))
-                return filter.HasValue ? cacheEntry?.Where(o => o.Key == filter.Value) ?? [] : cacheEntry ?? [];
+            if (_memoryCache.TryGetValue(nameof(ListOptionsAsync), out OptionModel[]? cacheEntry))
+                return filter.HasValue
+                    ? cacheEntry?.Where(o => o.Key == filter.Value).ToArray() ?? []
+                    : cacheEntry ?? [];
 
             var options = await _optionRepository.ListAsync(null, cancellationToken);
             cacheEntry = [.. options.Select(_mapper.Map<OptionModel>)];
@@ -35,7 +37,7 @@ public async Task<IEnumerable<OptionModel>> ListOptionsAsync(OptionKey? filter =
 
             _memoryCache.Set(nameof(ListOptionsAsync), cacheEntry, cacheEntryOptions);
 
-            return filter.HasValue ? cacheEntry.Where(o => o.Key == filter.Value) : cacheEntry;
+            return filter.HasValue ? [.. cacheEntry.Where(o => o.Key == filter.Value)] : cacheEntry;
         }
         catch (Exception ex)
         {