[CHANGE] Reworking Result monads

DotBased.AspNet.Authority/Managers/AuthorityGroupManager.cs

@@ -4,7 +4,7 @@ namespace DotBased.AspNet.Authority.Managers;
 
 public partial class AuthorityManager
 {
-    public async Task<ListResult<AuthorityGroup>> GetUserGroupsAsync(AuthorityUser user, CancellationToken cancellationToken = default)
+    public async Task<ListResultOld<AuthorityGroup>> GetUserGroupsAsync(AuthorityUser user, CancellationToken cancellationToken = default)
     {
         return await GroupRepository.GetUserGroupsAsync(user, cancellationToken);
     }

DotBased.AspNet.Authority/Managers/AuthorityRoleManager.cs

@@ -1,15 +1,16 @@
 using DotBased.AspNet.Authority.Models;
 using DotBased.AspNet.Authority.Models.Authority;
+using DotBased.Monads;
 
 namespace DotBased.AspNet.Authority.Managers;
 
 public partial class AuthorityManager
 {
-    public async Task<AuthorityResult<AuthorityRole>> CreateRoleAsync(AuthorityRole role, CancellationToken cancellationToken = default)
+    public async Task<Result<AuthorityRole>> CreateRoleAsync(AuthorityRole role, CancellationToken cancellationToken = default)
     {
         role.Version = GenerateVersion();
         var createResult = await RoleRepository.CreateRoleAsync(role, cancellationToken);
-        return AuthorityResult<AuthorityRole>.FromResult(createResult);
+        return createResult;
     }
 
     public async Task<Result> DeleteRolesAsync(List<AuthorityRole> roles, CancellationToken cancellationToken = default)
@@ -24,7 +25,7 @@ public partial class AuthorityManager
         return result;
     }
 
-    public async Task<ListResult<AuthorityRoleItem>> GetRolesAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default)
+    public async Task<Result<QueryItems<AuthorityRoleItem>>> GetRolesAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default)
     {
         var searchResult = await RoleRepository.GetRolesAsync(limit, offset, search, cancellationToken);
         return searchResult;
@@ -40,22 +41,22 @@ public partial class AuthorityManager
         }
         
         var checkResult = await RoleRepository.HasRolesAsync(user.Id, roles, cancellationToken);
-        if (!checkResult.Success)
-        {
-            return;
-        }
+        var hasRolesList = checkResult.Match<List<Guid>>(success: v => v, (_) => []);
 
         var rolesToAdd = roles;
-        if (checkResult.Count != 0)
+        if (hasRolesList.Count != 0)
         {
-            rolesToAdd = roles.Where(r => !checkResult.Items.Contains(r.Id)).ToList();
+            rolesToAdd = roles.Where(r => !hasRolesList.Contains(r.Id)).ToList();
         }
 
         var addResult = await RoleRepository.AddRolesLinkAsync(rolesToAdd, user.Id, cancellationToken);
-        if (!addResult.Success)
+        addResult.Match(() =>
         {
-            _logger.Error(addResult.Exception ?? new Exception("Adding role to user failed!, No further information available!"),"Failed to add role to user!");
-        }
+            _logger.Debug("Role links successfully added!");
+        }, e =>
+        {
+            _logger.Error(e.Exception ?? new Exception("Match failed!"), e.Description);
+        });
     }
 
     public async Task RemoveRolesFromUserAsync(List<AuthorityRole> roles, AuthorityUser user, CancellationToken cancellationToken = default)
@@ -68,43 +69,43 @@ public partial class AuthorityManager
         }
         
         var checkResult = await RoleRepository.HasRolesAsync(user.Id, roles, cancellationToken);
-        if (!checkResult.Success)
-        {
-            return;
-        }
+        var hasRolesList = checkResult.Match<List<Guid>>(success: v => v, (_) => []);
 
         var rolesToRemove = roles;
-        if (checkResult.Count != 0)
+        if (hasRolesList.Count != 0)
         {
-            rolesToRemove = roles.Where(r => !checkResult.Items.Contains(r.Id)).ToList();
+            rolesToRemove = roles.Where(r => !hasRolesList.Contains(r.Id)).ToList();
         }
         
         var removeResult = await RoleRepository.DeleteRolesLinkAsync(rolesToRemove, user.Id, cancellationToken);
-        if (!removeResult.Success)
+        removeResult.Match(() =>
         {
-            _logger.Error(removeResult.Exception ?? new Exception("Removing roles from user failed!"), "Failed to remove roles from user!");
-        }
+            _logger.Debug("Removed roles from user!");
+        }, e =>
+        {
+            _logger.Error(e.Exception ?? new Exception("Removing roles from user failed!"), e.Description);
+        });
     }
 
     public async Task AddRolesToGroupAsync(List<AuthorityRole> roles, AuthorityGroup group, CancellationToken cancellationToken = default)
     {
         var checkResult = await RoleRepository.HasRolesAsync(group.Id, roles, cancellationToken);
-        if (!checkResult.Success)
-        {
-            return;
-        }
+        var hasRolesList = checkResult.Match<List<Guid>>(success: v => v, (_) => []);
         
         var rolesToAdd = roles;
-        if (checkResult.Count != 0)
+        if (hasRolesList.Count != 0)
         {
-            rolesToAdd = roles.Where(r => !checkResult.Items.Contains(r.Id)).ToList();
+            rolesToAdd = roles.Where(r => !hasRolesList.Contains(r.Id)).ToList();
         }
         
         var addResult = await RoleRepository.AddRolesLinkAsync(rolesToAdd, group.Id, cancellationToken);
-        if (!addResult.Success)
+        addResult.Match(() =>
         {
-            _logger.Error(addResult.Exception ?? new Exception("Adding roles to group failed!"), "Failed to add roles to group!");
-        }
+            _logger.Debug("Added roles to group.");
+        }, e =>
+        {
+            _logger.Error(e.Exception ?? new Exception("Adding roles to group failed!"), e.Description);
+        });
     }
 
     /// <summary>
@@ -112,12 +113,12 @@ public partial class AuthorityManager
     /// </summary>
     /// <param name="user">The user to get the roles from</param>
     /// <param name="cancellationToken"></param>
-    public async Task<ListResult<AuthorityRole>> GetUserRolesAsync(AuthorityUser user, CancellationToken cancellationToken = default)
+    public async Task<Result<List<AuthorityRole>>> GetUserRolesAsync(AuthorityUser user, CancellationToken cancellationToken = default)
     {
         var usrValidation = await IsValidUserAsync(user, cancellationToken);
         if (!usrValidation.Success)
         {
-            return ListResult<AuthorityRole>.Failed("Invalid user");
+            return ResultError.Fail("Invalid user");
         }
         
         var searchIds = new List<Guid> { user.Id };
@@ -128,11 +129,21 @@ public partial class AuthorityManager
             searchIds.AddRange(usrGroups.Items.Select(g => g.Id).ToList());
         }
         
-        return await RoleRepository.GetLinkedRolesAsync(searchIds, cancellationToken);
+        var linkedRolesResult = await RoleRepository.GetLinkedRolesAsync(searchIds, cancellationToken);
+        return linkedRolesResult.Match<List<AuthorityRole>>(roles => roles, e =>
+        {
+            _logger.Error(e.Exception ?? new Exception("Failed to get user roles!"), e.Description);
+            return [];
+        });
     }
 
-    public async Task<ListResult<AuthorityRole>> GetGroupRolesAsync(List<Guid> groupIds, CancellationToken cancellationToken = default)
+    public async Task<Result<List<AuthorityRole>>> GetGroupRolesAsync(List<Guid> groupIds, CancellationToken cancellationToken = default)
     {
-        return await RoleRepository.GetLinkedRolesAsync(groupIds, cancellationToken);
+        var linkedRolesResult = await RoleRepository.GetLinkedRolesAsync(groupIds, cancellationToken);
+        return linkedRolesResult.Match<List<AuthorityRole>>(roles => roles, e =>
+        {
+            _logger.Error(e.Exception ?? new Exception("Failed to get group roles!"), e.Description);
+            return [];
+        });
     }
 }

DotBased.AspNet.Authority/Managers/AuthorityUserManager.cs

@@ -34,28 +34,28 @@ public partial class AuthorityManager
         return errors.Count > 0 ? ValidationResult.Failed(errors) : ValidationResult.Ok();
     }
 
-    public async Task<ListResult<AuthorityUserItem>> SearchUsersAsync(string query, int maxResults = 20, int offset = 0, CancellationToken cancellationToken = default)
+    public async Task<ListResultOld<AuthorityUserItem>> SearchUsersAsync(string query, int maxResults = 20, int offset = 0, CancellationToken cancellationToken = default)
     {
         var result = await UserRepository.GetAuthorityUsersAsync(maxResults, offset, query, cancellationToken);
         return result;
     }
 
-    public async Task<AuthorityResult<AuthorityUser>> UpdatePasswordAsync(AuthorityUser user, string password, CancellationToken cancellationToken = default)
+    public async Task<AuthorityResultOldOld<AuthorityUser>> UpdatePasswordAsync(AuthorityUser user, string password, CancellationToken cancellationToken = default)
     {
         var passwordValidation = await ValidatePasswordAsync(user, password);
         if (!passwordValidation.Success)
         {
-            return AuthorityResult<AuthorityUser>.Failed(passwordValidation.Errors, ResultFailReason.Validation);
+            return AuthorityResultOldOld<AuthorityUser>.Failed(passwordValidation.Errors, ResultFailReason.Validation);
         }
 
         user.PasswordHash = await PasswordHasher.HashPasswordAsync(password);
         user.SecurityVersion = GenerateVersion();
 
         var updateResult = await UserRepository.UpdateUserAsync(user, cancellationToken);
-        return AuthorityResult<AuthorityUser>.FromResult(updateResult);
+        return AuthorityResultOldOld<AuthorityUser>.FromResult(updateResult);
     }
 
-    public async Task<AuthorityResult<AuthorityUser>> CreateUserAsync(AuthorityUser userModel, string password, CancellationToken cancellationToken = default)
+    public async Task<AuthorityResultOldOld<AuthorityUser>> CreateUserAsync(AuthorityUser userModel, string password, CancellationToken cancellationToken = default)
     {
         var userValidation = await ValidateUserAsync(userModel);
         var passwordValidation = await ValidatePasswordAsync(userModel, password);
@@ -64,7 +64,7 @@ public partial class AuthorityManager
             List<ValidationError> errors = [];
             errors.AddRange(userValidation.Errors);
             errors.AddRange(passwordValidation.Errors);
-            return AuthorityResult<AuthorityUser>.Failed(errors, ResultFailReason.Validation);
+            return AuthorityResultOldOld<AuthorityUser>.Failed(errors, ResultFailReason.Validation);
         }
         
         userModel.Version = GenerateVersion();
@@ -74,22 +74,22 @@ public partial class AuthorityManager
 
         var userCreationResult = await UserRepository.CreateUserAsync(userModel, cancellationToken);
         
-        return AuthorityResult<AuthorityUser>.FromResult(userCreationResult);
+        return AuthorityResultOldOld<AuthorityUser>.FromResult(userCreationResult);
     }
 
-    public async Task<Result<AuthorityUser>> UpdateUserAsync(AuthorityUser model, CancellationToken cancellationToken = default)
+    public async Task<ResultOld<AuthorityUser>> UpdateUserAsync(AuthorityUser model, CancellationToken cancellationToken = default)
     {
         var updateResult = await UserRepository.UpdateUserAsync(model, cancellationToken);
         return updateResult;
     }
 
-    public async Task<Result> DeleteUserAsync(AuthorityUser model, CancellationToken cancellationToken = default)
+    public async Task<ResultOld> DeleteUserAsync(AuthorityUser model, CancellationToken cancellationToken = default)
     {
         var deleteResult = await UserRepository.DeleteUserAsync(model, cancellationToken);
         return deleteResult;
     }
 
-    public async Task<Result> IsValidUserAsync(AuthorityUser user, CancellationToken cancellationToken = default)
+    public async Task<ResultOld> IsValidUserAsync(AuthorityUser user, CancellationToken cancellationToken = default)
     {
         var usrResult = await UserRepository.GetVersionAsync(user, cancellationToken);
         return usrResult;

DotBased.AspNet.Authority/Models/AuthorityResult.cs

@@ -1,41 +0,0 @@
-using DotBased.AspNet.Authority.Models.Validation;
-
-namespace DotBased.AspNet.Authority.Models;
-
-public class AuthorityResult<TResultValue> : Result<TResultValue>
-{
-    public static AuthorityResult<TResultValue> FromResult(Result<TResultValue> result) => new AuthorityResult<TResultValue>(result);
-    
-    public AuthorityResult(Result<TResultValue> result) : base(result)
-    {
-        Reason = ResultFailReason.Unknown;
-    }
-    
-    public AuthorityResult(bool success, string errorMessage = "", TResultValue? value = default, ResultFailReason reason = ResultFailReason.None, IReadOnlyList<ValidationError>? errors = null) : base(success, errorMessage, value, null)
-    {
-        Success = success;
-        Message = errorMessage;
-        Value = value;
-        Reason = reason;
-        ValidationErrors = errors;
-    }
-    public ResultFailReason Reason { get; }
-    public IReadOnlyList<ValidationError>? ValidationErrors { get; }
-    
-
-    public new static AuthorityResult<TResultValue> Ok(TResultValue? value) => new AuthorityResult<TResultValue>(true, value:value);
-
-    public static AuthorityResult<TResultValue> Error(string errorMessage, ResultFailReason reason = ResultFailReason.Error) =>
-        new AuthorityResult<TResultValue>(false, errorMessage, reason:reason);
-
-    public static AuthorityResult<TResultValue> Failed(IReadOnlyList<ValidationError> errors, ResultFailReason reason = ResultFailReason.None)
-        => new AuthorityResult<TResultValue>(false, errors:errors, reason:reason);
-}
-
-public enum ResultFailReason
-{
-    None,
-    Unknown,
-    Validation,
-    Error
-}

DotBased.AspNet.Authority/Models/AuthorityResultOldOld.cs

@@ -0,0 +1,41 @@
+using DotBased.AspNet.Authority.Models.Validation;
+
+namespace DotBased.AspNet.Authority.Models;
+
+public class AuthorityResultOldOld<TResultValue> : ResultOld<TResultValue>
+{
+    public static AuthorityResultOldOld<TResultValue> FromResult(ResultOld<TResultValue> resultOld) => new AuthorityResultOldOld<TResultValue>(resultOld);
+    
+    public AuthorityResultOldOld(ResultOld<TResultValue> resultOld) : base(resultOld)
+    {
+        Reason = ResultFailReason.Unknown;
+    }
+    
+    public AuthorityResultOldOld(bool success, string errorMessage = "", TResultValue? value = default, ResultFailReason reason = ResultFailReason.None, IReadOnlyList<ValidationError>? errors = null) : base(success, errorMessage, value, null)
+    {
+        Success = success;
+        Message = errorMessage;
+        Value = value;
+        Reason = reason;
+        ValidationErrors = errors;
+    }
+    public ResultFailReason Reason { get; }
+    public IReadOnlyList<ValidationError>? ValidationErrors { get; }
+    
+
+    public new static AuthorityResultOldOld<TResultValue> Ok(TResultValue? value) => new AuthorityResultOldOld<TResultValue>(true, value:value);
+
+    public static AuthorityResultOldOld<TResultValue> Error(string errorMessage, ResultFailReason reason = ResultFailReason.Error) =>
+        new AuthorityResultOldOld<TResultValue>(false, errorMessage, reason:reason);
+
+    public static AuthorityResultOldOld<TResultValue> Failed(IReadOnlyList<ValidationError> errors, ResultFailReason reason = ResultFailReason.None)
+        => new AuthorityResultOldOld<TResultValue>(false, errors:errors, reason:reason);
+}
+
+public enum ResultFailReason
+{
+    None,
+    Unknown,
+    Validation,
+    Error
+}

DotBased.AspNet.Authority/Models/QueryItems.cs

@@ -0,0 +1,21 @@
+namespace DotBased.AspNet.Authority.Models;
+
+public class QueryItems<TItem>
+{
+    private QueryItems(IEnumerable<TItem> items, int totalCount, int limit, int offset)
+    {
+        Items = items.ToList();
+        TotalCount = totalCount;
+        Limit = limit;
+        Offset = offset;
+    }
+    
+    public readonly IReadOnlyCollection<TItem> Items;
+
+    public int Count => Items.Count;
+    public int TotalCount { get; }
+    public int Limit { get; }
+    public int Offset { get; }
+
+    public static QueryItems<TItem> Create(IEnumerable<TItem> items, int totalCount, int limit, int offset) => new(items, totalCount, limit, offset);
+}

DotBased.AspNet.Authority/Monads/ValidationResult.cs

@@ -1,8 +1,9 @@
+using DotBased.AspNet.Authority.Models.Validation;
 using DotBased.Monads;
 
 namespace DotBased.AspNet.Authority.Monads;
 
-public class ValidationResult<T> : DotBased.Monads.Result<T>
+public class ValidationResult<T> : Result<T>
 {
     private ValidationResult(T result) : base(result)
     {
@@ -12,9 +13,31 @@ public class ValidationResult<T> : DotBased.Monads.Result<T>
     {
     }
 
-    private ValidationResult(ResultInformation information) : base(information)
+    private ValidationResult(ResultError error) : base(error)
     {
     }
+
+    private ValidationResult(List<ValidationError> validationErrors) : base(ResultError.Fail("Validation failed!"))
+    {
+        _validationErrors = validationErrors;
+    }
+
+    private readonly List<ValidationError> _validationErrors = [];
+    public IReadOnlyList<ValidationError> ValidationErrors => _validationErrors;
     
-    
+    public static implicit operator ValidationResult<T>(T result) => new(result);
+    public static implicit operator ValidationResult<T>(Exception exception) => new(exception);
+    public static implicit operator ValidationResult<T>(ResultError error) => new(error);
+    public static implicit operator ValidationResult<T>(List<ValidationError> validationErrors) => new(validationErrors);
+
+    public static ValidationResult<T> FromResult(Result<T> result)
+    {
+        var authorityResult = result.Match<ValidationResult<T>>(
+            r => new ValidationResult<T>(r),
+            error => new ValidationResult<T>(error));
+        return authorityResult;
+    }
+
+    public TMatch Match<TMatch>(Func<T, TMatch> success, Func<ResultError, IReadOnlyList<ValidationError>, TMatch> failure) =>
+        IsSuccess && Value != null ? success(Value) : failure(Error ?? ResultError.Fail("No error and value is null!"), ValidationErrors);
 }

DotBased.AspNet.Authority/Repositories/IAttributeRepository.cs

@@ -4,9 +4,9 @@ namespace DotBased.AspNet.Authority.Repositories;
 
 public interface IAttributeRepository
 {
-    public Task<ListResult<AuthorityAttributeItem>> GetAttributesAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default);
-    public Task<Result<AuthorityAttribute>> GetAttributeByKeyAsync(string id, CancellationToken cancellationToken = default);
-    public Task<Result<AuthorityAttribute>> CreateAttributeAsync(AuthorityAttribute attribute, CancellationToken cancellationToken = default);
-    public Task<Result<AuthorityAttribute>> UpdateAttributeAsync(AuthorityAttribute attribute, CancellationToken cancellationToken = default);
-    public Task<Result> DeleteAttributeAsync(AuthorityAttribute attribute, CancellationToken cancellationToken = default);
+    public Task<ListResultOld<AuthorityAttributeItem>> GetAttributesAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default);
+    public Task<ResultOld<AuthorityAttribute>> GetAttributeByKeyAsync(string id, CancellationToken cancellationToken = default);
+    public Task<ResultOld<AuthorityAttribute>> CreateAttributeAsync(AuthorityAttribute attribute, CancellationToken cancellationToken = default);
+    public Task<ResultOld<AuthorityAttribute>> UpdateAttributeAsync(AuthorityAttribute attribute, CancellationToken cancellationToken = default);
+    public Task<ResultOld> DeleteAttributeAsync(AuthorityAttribute attribute, CancellationToken cancellationToken = default);
 }

DotBased.AspNet.Authority/Repositories/IGroupRepository.cs

@@ -4,10 +4,10 @@ namespace DotBased.AspNet.Authority.Repositories;
 
 public interface IGroupRepository
 {
-    public Task<ListResult<AuthorityGroupItem>> GetGroupsAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default);
-    public Task<Result<AuthorityGroup>> GetGroupByIdAsync(string id, CancellationToken cancellationToken = default);
-    public Task<ListResult<AuthorityGroup>> GetUserGroupsAsync(AuthorityUser user, CancellationToken cancellationToken = default);
-    public Task<Result<AuthorityGroup>> CreateGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default);
-    public Task<Result<AuthorityGroup>> UpdateGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default);
-    public Task<Result> DeleteGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default);
+    public Task<ListResultOld<AuthorityGroupItem>> GetGroupsAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default);
+    public Task<ResultOld<AuthorityGroup>> GetGroupByIdAsync(string id, CancellationToken cancellationToken = default);
+    public Task<ListResultOld<AuthorityGroup>> GetUserGroupsAsync(AuthorityUser user, CancellationToken cancellationToken = default);
+    public Task<ResultOld<AuthorityGroup>> CreateGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default);
+    public Task<ResultOld<AuthorityGroup>> UpdateGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default);
+    public Task<ResultOld> DeleteGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default);
 }

DotBased.AspNet.Authority/Repositories/IRoleRepository.cs

@@ -1,16 +1,18 @@
+using DotBased.AspNet.Authority.Models;
 using DotBased.AspNet.Authority.Models.Authority;
+using DotBased.Monads;
 
 namespace DotBased.AspNet.Authority.Repositories;
 
 public interface IRoleRepository
 {
-    public Task<ListResult<AuthorityRoleItem>> GetRolesAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default);
-    public Task<Result<AuthorityRole>> GetRoleByIdAsync(string id, CancellationToken cancellationToken = default);
+    public Task<Result<QueryItems<AuthorityRoleItem>>> GetRolesAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default);
+    public Task<Result<AuthorityRole>> GetRoleByIdAsync(Guid id, CancellationToken cancellationToken = default);
     public Task<Result<AuthorityRole>> CreateRoleAsync(AuthorityRole role, CancellationToken cancellationToken = default);
     public Task<Result<AuthorityRole>> UpdateRoleAsync(AuthorityRole role, CancellationToken cancellationToken = default);
     public Task<Result> DeleteRolesAsync(List<AuthorityRole> roles, CancellationToken cancellationToken = default);
     public Task<Result> AddRolesLinkAsync(List<AuthorityRole> roles, Guid linkId, CancellationToken cancellationToken = default);
-    public Task<ListResult<AuthorityRole>> GetLinkedRolesAsync(List<Guid> linkIds, CancellationToken cancellationToken = default);
+    public Task<Result<List<AuthorityRole>>> GetLinkedRolesAsync(List<Guid> linkIds, CancellationToken cancellationToken = default);
     public Task<Result> DeleteRolesLinkAsync(List<AuthorityRole> roles, Guid linkId, CancellationToken cancellationToken = default);
     
     /// <summary>
@@ -20,5 +22,5 @@ public interface IRoleRepository
     /// <param name="roles"></param>
     /// <param name="cancellationToken"></param>
     /// <returns></returns>
-    public Task<ListResult<Guid>> HasRolesAsync(Guid linkId, List<AuthorityRole> roles, CancellationToken cancellationToken = default);
+    public Task<Result<List<Guid>>> HasRolesAsync(Guid linkId, List<AuthorityRole> roles, CancellationToken cancellationToken = default);
 }

DotBased.AspNet.Authority/Repositories/IUserRepository.cs

@@ -4,14 +4,14 @@ namespace DotBased.AspNet.Authority.Repositories;
 
 public interface IUserRepository
 {
-    public Task<ListResult<AuthorityUserItem>> GetAuthorityUsersAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default);
-    public Task<Result<AuthorityUser>> GetAuthorityUserByIdAsync(string id, CancellationToken cancellationToken = default);
-    public Task<Result<AuthorityUser>> CreateUserAsync(AuthorityUser user, CancellationToken cancellationToken = default);
-    public Task<Result<AuthorityUser>> UpdateUserAsync(AuthorityUser user, CancellationToken cancellationToken = default);
-    public Task<Result> DeleteUserAsync(AuthorityUser user, CancellationToken cancellationToken = default);
-    public Task<Result<AuthorityUser>> GetUserByEmailAsync(string email, CancellationToken cancellationToken = default);
-    public Task<Result> SetVersionAsync(AuthorityUser user, long version, CancellationToken cancellationToken = default);
-    public Task<Result<long>> GetVersionAsync(AuthorityUser user, CancellationToken cancellationToken = default);
-    public Task<Result> SetSecurityVersionAsync(AuthorityUser user, long securityVersion, CancellationToken cancellationToken = default);
-    public Task<Result<long>> GetSecurityVersionAsync(AuthorityUser user, CancellationToken cancellationToken = default);
+    public Task<ListResultOld<AuthorityUserItem>> GetAuthorityUsersAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default);
+    public Task<ResultOld<AuthorityUser>> GetAuthorityUserByIdAsync(string id, CancellationToken cancellationToken = default);
+    public Task<ResultOld<AuthorityUser>> CreateUserAsync(AuthorityUser user, CancellationToken cancellationToken = default);
+    public Task<ResultOld<AuthorityUser>> UpdateUserAsync(AuthorityUser user, CancellationToken cancellationToken = default);
+    public Task<ResultOld> DeleteUserAsync(AuthorityUser user, CancellationToken cancellationToken = default);
+    public Task<ResultOld<AuthorityUser>> GetUserByEmailAsync(string email, CancellationToken cancellationToken = default);
+    public Task<ResultOld> SetVersionAsync(AuthorityUser user, long version, CancellationToken cancellationToken = default);
+    public Task<ResultOld<long>> GetVersionAsync(AuthorityUser user, CancellationToken cancellationToken = default);
+    public Task<ResultOld> SetSecurityVersionAsync(AuthorityUser user, long securityVersion, CancellationToken cancellationToken = default);
+    public Task<ResultOld<long>> GetSecurityVersionAsync(AuthorityUser user, CancellationToken cancellationToken = default);
 }