[REMOVE] Remove old AuthorityResult

DotBased.AspNet.Authority.EFCore/Repositories/RoleRepository.cs

@@ -2,17 +2,15 @@ using DotBased.AspNet.Authority.EFCore.Models;
 using DotBased.AspNet.Authority.Models;
 using DotBased.AspNet.Authority.Models.Authority;
 using DotBased.AspNet.Authority.Repositories;
-using DotBased.Monads;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
 
 namespace DotBased.AspNet.Authority.EFCore.Repositories;
 
 
-public class RoleRepository(IDbContextFactory<AuthorityContext> contextFactory) : RepositoryBase, IRoleRepository
+public class RoleRepository(IDbContextFactory<AuthorityContext> contextFactory, ILogger<RoleRepository> logger) : RepositoryBase, IRoleRepository
 {
-    public async Task<Result<QueryItems<AuthorityRoleItem>>> GetRolesAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default)
+    public async Task<QueryItems<AuthorityRoleItem>> GetRolesAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default)
-    {
-        try
     {
         await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
         var query = context.Roles.AsQueryable();
@@ -30,179 +28,99 @@ public class RoleRepository(IDbContextFactory<AuthorityContext> contextFactory)
         }).ToListAsync(cancellationToken: cancellationToken);
         return QueryItems<AuthorityRoleItem>.Create(select, total, limit, offset);
     }
-        catch (Exception e)
-        {
-            return e;
-        }
-    }
 
-    public async Task<Result<AuthorityRole>> GetRoleByIdAsync(Guid id, CancellationToken cancellationToken = default)
+    public async Task<AuthorityRole?> GetRoleByIdAsync(Guid id, CancellationToken cancellationToken = default)
-    {
-        try
     {
         await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
         var role = await context.Roles.Where(r => r.Id == id).Include(r => r.Attributes).FirstOrDefaultAsync(cancellationToken: cancellationToken);
-            if (role != null)
-            {
         return role;
     }
-            return ResultError.Fail("Role not found!");
-        }
-        catch (Exception e)
-        {
-            return e;
-        }
-    }
 
-    public async Task<Result<AuthorityRole>> CreateRoleAsync(AuthorityRole role, CancellationToken cancellationToken = default)
+    public async Task<AuthorityRole?> CreateRoleAsync(AuthorityRole role, CancellationToken cancellationToken = default)
-    {
-        try
     {
         await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
         if (role.Id == Guid.Empty)
         {
-                return ResultError.Fail("Id cannot be empty!");
+            throw new Exception("Role id is required!");
         }
         var entity = context.Roles.Add(role);
         var saveResult = await context.SaveChangesAsync(cancellationToken);
-            return saveResult <= 0 ? ResultError.Fail("Failed to create role!") : entity.Entity;
+
-        }
+        return saveResult != 0 ? entity.Entity : null;
-        catch (Exception e)
-        {
-            return e;
-        }
     }
 
-    public async Task<Result<AuthorityRole>> UpdateRoleAsync(AuthorityRole role, CancellationToken cancellationToken = default)
+    public async Task<AuthorityRole?> UpdateRoleAsync(AuthorityRole role, CancellationToken cancellationToken = default)
-    {
-        try
     {
         await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
         var currentRole = await context.Roles.FirstOrDefaultAsync(r => r.Id == role.Id, cancellationToken: cancellationToken);
         if (currentRole == null)
         {
-                return ResultError.Fail("Role not found!");
+            throw new Exception($"Role with id {role.Id} not found!");
         }
 
         if (role.Version != currentRole.Version)
         {
-                return ResultError.Fail("Role version does not match, version validation failed!");
+            throw new Exception("Role version does not match!");
         }
             
         var entity = context.Roles.Update(role);
         var saveResult = await context.SaveChangesAsync(cancellationToken);
-            return saveResult <= 0 ? ResultError.Fail("Failed to update role!") : entity.Entity;
+        return saveResult != 0 ? entity.Entity : null;
-        }
-        catch (Exception e)
-        {
-            return e;
-        }
     }
 
-    public async Task<Result> DeleteRolesAsync(List<AuthorityRole> roles, CancellationToken cancellationToken = default)
+    public async Task<bool> DeleteRolesAsync(List<AuthorityRole> roles, CancellationToken cancellationToken = default)
-    {
-        try
     {
         await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
         var roleIds = roles.Select(r => r.Id).ToList();
         
         context.Roles.RemoveRange(roles);
-            context.RoleLinks.RemoveRange(context.RoleLinks.Where(rg => roleIds.Contains(rg.RoleId)));
+        context.RoleLinks.RemoveRange(context.RoleLinks.Where(rl => roleIds.Contains(rl.RoleId)));
         
-            var removeResult = await context.SaveChangesAsync(cancellationToken);
+        var removedRoles = await context.SaveChangesAsync(cancellationToken);
-            return removeResult == roles.Count? Result.Success() : ResultError.Fail($"Not all roles have been removed! {removeResult} of {roles.Count} roles removed!");
+        if (removedRoles != 0) return true;
-        }
+        logger.LogError("Failed to remove roles");
-        catch (Exception e)
+        return false;
-        {
-            return e;
-        }
     }
 
-    public async Task<ListResultOld<AuthorityRoleItem>> GetUserRolesAsync(AuthorityUser user, int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default)
+    public async Task<bool> AddRolesLinkAsync(List<AuthorityRole> roles, Guid linkId, CancellationToken cancellationToken = default)
-    {
-        try
-        {
-            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
-            var roleIds = await context.RoleLinks.Where(r => r.LinkId == user.Id).Select(i => i.RoleId).ToListAsync(cancellationToken: cancellationToken);
-            var rolesQuery = context.Roles.Where(r => roleIds.Contains(r.Id));
-            if (!string.IsNullOrEmpty(search))
-            {
-                rolesQuery = rolesQuery.Where(r => r.Name.Contains(search));
-            }
-
-            var roles = rolesQuery.Where(r => roleIds.Contains(r.Id)).Skip(offset).Take(limit).Select(r => new AuthorityRoleItem()
-            {
-                Id = r.Id,
-                Name = r.Name
-            });
-            return ListResultOld<AuthorityRoleItem>.Ok(roles, limit, offset);
-        }
-        catch (Exception e)
-        {
-            return HandleExceptionListResult<AuthorityRoleItem>("Failed to get user roles.", e);
-        }
-    }
-
-    public async Task<Result> AddRolesLinkAsync(List<AuthorityRole> roles, Guid linkId, CancellationToken cancellationToken = default)
-    {
-        try
     {
         await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
         foreach (var role in roles)
         {
-                context.RoleLinks.Add(new RoleLink() { LinkId = linkId, RoleId = role.Id });
+            context.RoleLinks.Add(new RoleLink { LinkId = linkId, RoleId = role.Id });
         }
-            var saveResult = await context.SaveChangesAsync(cancellationToken);
+        var linkedRoles = await context.SaveChangesAsync(cancellationToken);
-            return saveResult == roles.Count ? Result.Success() : ResultError.Fail($"Not all roles have been linked! {saveResult} of {roles.Count} roles linked!");
+        if (linkedRoles == roles.Count)
-        }
-        catch (Exception e)
         {
-            return e;
+            return true;
-        }
         }
 
-    public async Task<Result<List<AuthorityRole>>> GetLinkedRolesAsync(List<Guid> linkIds, CancellationToken cancellationToken = default)
+        logger.LogError("Failed to link all given roles, {linkedRoles}/{totalRoles} roles linked!", linkedRoles, roles.Count);
-    {
+        return false;
-        try
+    }
+
+    public async Task<List<AuthorityRole>> GetLinkedRolesAsync(List<Guid> linkIds, CancellationToken cancellationToken = default)
     {
         await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
         var linkedRoles = context.RoleLinks.Where(r => linkIds.Contains(r.LinkId)).Select(r => r.RoleId);
         var roleList = await context.Roles.Where(r => linkedRoles.Contains(r.Id)).ToListAsync(cancellationToken);
         return roleList.DistinctBy(r => r.Id).ToList();
     }
-        catch (Exception e)
-        {
-            return e;
-        }
-    }
 
-    public async Task<Result> DeleteRolesLinkAsync(List<AuthorityRole> roles, Guid linkId, CancellationToken cancellationToken = default)
+    public async Task<bool> UnlinkRolesAsync(List<AuthorityRole> roles, Guid linkId, CancellationToken cancellationToken = default)
-    {
-        try
     {
         await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
         var roleIds = roles.Select(r => r.Id).ToList();
         context.RoleLinks.RemoveRange(context.RoleLinks.Where(rg => rg.LinkId == linkId && roleIds.Contains(rg.RoleId)));
-            var saveResult = await context.SaveChangesAsync(cancellationToken);
+        var unlinkedRoles = await context.SaveChangesAsync(cancellationToken);
-            return saveResult == roles.Count ? Result.Success() : ResultError.Fail($"Not all roles have been unlinked! {saveResult} of {roles.Count} roles unlinked!");
+        if (unlinkedRoles != 0) return true;
-        }
+        logger.LogError("Failed to remove linked roles");
-        catch (Exception e)
+        return false;
-        {
-            return e;
-        }
     }
 
-    public async Task<Result<List<Guid>>> HasRolesAsync(Guid linkId, List<AuthorityRole> roles, CancellationToken cancellationToken = default)
+    public async Task<List<Guid>> GetRolesFromLinkAsync(Guid linkId, List<AuthorityRole> roles, CancellationToken cancellationToken = default)
-    {
-        try
     {
         await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
-            var hasRoles = await context.RoleLinks.Where(r => r.LinkId == linkId && roles.Any(ar => ar.Id == r.RoleId)).Select(r => r.RoleId).ToListAsync(cancellationToken);
+        return await context.RoleLinks.Where(r => r.LinkId == linkId && roles.Any(ar => ar.Id == r.RoleId)).Select(r => r.RoleId).ToListAsync(cancellationToken);
-            return hasRoles;
-        }
-        catch (Exception e)
-        {
-            return e;
-        }
     }
 }

DotBased.AspNet.Authority.EFCore/Repositories/UserRepository.cs

@@ -1,14 +1,14 @@
+using DotBased.AspNet.Authority.Models;
 using DotBased.AspNet.Authority.Models.Authority;
 using DotBased.AspNet.Authority.Repositories;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
 
 namespace DotBased.AspNet.Authority.EFCore.Repositories;
 
-public class UserRepository(IDbContextFactory<AuthorityContext> contextFactory) : RepositoryBase, IUserRepository
+public class UserRepository(IDbContextFactory<AuthorityContext> contextFactory, ILogger<UserRepository> logger) : RepositoryBase, IUserRepository
 {
-    public async Task<ListResultOld<AuthorityUserItem>> GetAuthorityUsersAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default)
+    public async Task<QueryItems<AuthorityUserItem>> GetAuthorityUsersAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default)
-    {
-        try
     {
         await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
         var query = context.Users.AsQueryable();
@@ -26,191 +26,122 @@ public class UserRepository(IDbContextFactory<AuthorityContext> contextFactory)
             EmailAddress = u.EmailAddress,
             PhoneNumber = u.PhoneNumber
         }).ToListAsync(cancellationToken: cancellationToken);
-            return ListResultOld<AuthorityUserItem>.Ok(selected, totalCount, limit, offset);
+        return QueryItems<AuthorityUserItem>.Create(selected, totalCount, limit, offset);
-        }
-        catch (Exception e)
-        {
-            return HandleExceptionListResult<AuthorityUserItem>("Failed to get users.", e);
-        }
     }
 
-    public async Task<ResultOld<AuthorityUser>> GetAuthorityUserByIdAsync(string id, CancellationToken cancellationToken = default)
+    public async Task<AuthorityUser?> GetAuthorityUserByIdAsync(Guid id, CancellationToken cancellationToken = default)
-    {
-        try
     {
         await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
-            if (!Guid.TryParse(id, out var guid))
+        if (id == Guid.Empty)
         {
-                return ResultOld<AuthorityUser>.Failed("Invalid id!");
+            throw new Exception("Id is required!");
         }
 
-            var user = await context.Users.Where(u => u.Id == guid).Include(u => u.Attributes).FirstOrDefaultAsync(cancellationToken: cancellationToken);
+        return await context.Users.Where(u => u.Id == id).Include(u => u.Attributes).FirstOrDefaultAsync(cancellationToken: cancellationToken);
-            return ResultOld<AuthorityUser>.HandleResult(user, "User not found.");
-        }
-        catch (Exception e)
-        {
-            return HandleExceptionResult<AuthorityUser>("Failed to get user.", e);
-        }
     }
 
-    public async Task<ResultOld<AuthorityUser>> CreateUserAsync(AuthorityUser user, CancellationToken cancellationToken = default)
+    public async Task<AuthorityUser?> CreateUserAsync(AuthorityUser user, CancellationToken cancellationToken = default)
-    {
-        try
     {
         await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
         if (user.Id == Guid.Empty)
         {
-                return ResultOld<AuthorityUser>.Failed("Id cannot be empty!");
+            throw new Exception("User id is required!");
         }
         var entity = context.Users.Add(user);
         var saveResult = await context.SaveChangesAsync(cancellationToken);
-            return saveResult <= 0 ? ResultOld<AuthorityUser>.Failed("Failed to create user!") : ResultOld<AuthorityUser>.Ok(entity.Entity);
+        return saveResult != 0 ? entity.Entity : null;
-        }
-        catch (Exception e)
-        {
-            return HandleExceptionResult<AuthorityUser>("Failed to create user.", e);
-        }
     }
 
-    public async Task<ResultOld<AuthorityUser>> UpdateUserAsync(AuthorityUser user, CancellationToken cancellationToken = default)
+    public async Task<AuthorityUser?> UpdateUserAsync(AuthorityUser user, CancellationToken cancellationToken = default)
-    {
-        try
     {
         await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
         var usr = await context.Users.FirstOrDefaultAsync(u => u.Id == user.Id, cancellationToken: cancellationToken);
         if (usr == null)
         {
-                return ResultOld<AuthorityUser>.Failed("User not found!");
+            throw new Exception("User not found!");
         }
 
         if (usr.Version != user.Version || usr.SecurityVersion != user.SecurityVersion)
         {
-                return ResultOld<AuthorityUser>.Failed("Version validation failed!");
+            throw new Exception("User does not have the correct security version!");
         }
             
         var entity = context.Users.Update(user);
         var saveResult = await context.SaveChangesAsync(cancellationToken);
-            return saveResult <= 0 ? ResultOld<AuthorityUser>.Failed("Failed to save updated user!") : ResultOld<AuthorityUser>.Ok(entity.Entity);
+        return saveResult != 0 ? entity.Entity : null;
-        }
-        catch (Exception e)
-        {
-            return HandleExceptionResult<AuthorityUser>("Failed to update user!", e);
-        }
     }
 
-    public async Task<ResultOld> DeleteUserAsync(AuthorityUser user, CancellationToken cancellationToken = default)
+    public async Task<bool> DeleteUsersAsync(List<AuthorityUser> users, CancellationToken cancellationToken = default)
-    {
-        try
     {
         await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
-            var usr = await context.Users.FirstOrDefaultAsync(u => u.Id == user.Id, cancellationToken: cancellationToken);
+        var usrIds = users.Select(u => u.Id);
-            if (usr == null)
+        
-            {
+        context.Users.RemoveRange(users);
-                return ResultOld.Failed("User not found!");
+        context.RoleLinks.RemoveRange(context.RoleLinks.Where(rl => usrIds.Contains(rl.LinkId)));
-            }
+        
-            context.Users.Remove(usr);
+        var removedResult = await context.SaveChangesAsync(cancellationToken);
-            var saveResult = await context.SaveChangesAsync(cancellationToken);
+        if (removedResult != 0) return true;
-            return saveResult <= 0 ? ResultOld.Failed("Failed to delete user!") : ResultOld.Ok();
+        logger.LogError("Failed to delete users");
-        }
+        return false;
-        catch (Exception e)
-        {
-            return HandleException("Failed to delete user!", e);
-        }
     }
 
-    public async Task<ResultOld<AuthorityUser>> GetUserByEmailAsync(string email, CancellationToken cancellationToken = default)
+    public async Task<AuthorityUser?> GetUserByEmailAsync(string email, CancellationToken cancellationToken = default)
-    {
-        try
     {
         await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
-            var usr = await context.Users.Where(u => u.EmailAddress == email).Include(u => u.Attributes).FirstOrDefaultAsync(cancellationToken: cancellationToken);
+        return await context.Users.Where(u => u.EmailAddress == email).Include(u => u.Attributes).FirstOrDefaultAsync(cancellationToken: cancellationToken);
-            return ResultOld<AuthorityUser>.HandleResult(usr, "User not found by given email address.");
-        }
-        catch (Exception e)
-        {
-            return HandleExceptionResult<AuthorityUser>("An error occured while getting the user.", e);
-        }
     }
 
-    public async Task<ResultOld> SetVersionAsync(AuthorityUser user, long version, CancellationToken cancellationToken = default)
+    public async Task<bool> SetVersionAsync(AuthorityUser user, long version, CancellationToken cancellationToken = default)
-    {
-        try
     {
         await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
         var usr = await context.Users.FirstOrDefaultAsync(u => u.Id == user.Id, cancellationToken);
         if (usr == null)
         {
-                return ResultOld.Failed("Failed to find user with given id!");
+            throw new Exception("User not found!");
         }
 
         if (usr.Version != user.Version)
         {
-                return ResultOld.Failed("Stored user version doesn't match current user version!");
+            throw new Exception("User does not have the correct security version!");
         }
             
         usr.Version = version;
         context.Users.Update(usr);
         var saveResult = await context.SaveChangesAsync(cancellationToken);
-            return saveResult <= 0 ? ResultOld.Failed("Failed to update user!") : ResultOld.Ok();
+        return saveResult != 0;
-        }
-        catch (Exception e)
-        {
-            return HandleException("An error occured while updating the version.", e);
-        }
     }
 
-    public async Task<ResultOld<long>> GetVersionAsync(AuthorityUser user, CancellationToken cancellationToken = default)
+    public async Task<long> GetVersionAsync(AuthorityUser user, CancellationToken cancellationToken = default)
-    {
-        try
     {
         await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
         var usrVersion = await context.Users.Where(u => u.Id == user.Id).Select(u => u.Version).FirstOrDefaultAsync(cancellationToken);
-            return ResultOld<long>.HandleResult(usrVersion, "Failed to get user version!");
+        return usrVersion;
-        }
-        catch (Exception e)
-        {
-            return HandleExceptionResult<long>("An error occured while getting the user version.", e);
-        }
     }
 
-    public async Task<ResultOld> SetSecurityVersionAsync(AuthorityUser user, long securityVersion, CancellationToken cancellationToken = default)
+    public async Task<bool> SetSecurityVersionAsync(AuthorityUser user, long securityVersion, CancellationToken cancellationToken = default)
-    {
-        try
     {
         await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
         var usr = await context.Users.FirstOrDefaultAsync(u => u.Id == user.Id, cancellationToken);
         if (usr == null)
         {
-                return ResultOld.Failed("Failed to find user with given id!");
+            throw new Exception("User not found!");
         }
 
         if (usr.SecurityVersion != user.SecurityVersion)
         {
-                return ResultOld.Failed("Stored user version doesn't match current user version!");
+            throw new Exception("User does not have the correct security version!");
         }
             
         usr.SecurityVersion = securityVersion;
         context.Users.Update(usr);
         var saveResult = await context.SaveChangesAsync(cancellationToken);
-            return saveResult <= 0 ? ResultOld.Failed("Failed to update user!") : ResultOld.Ok();
+        return saveResult != 0;
-        }
-        catch (Exception e)
-        {
-            return HandleException("An error occured while updating the security version.", e);
-        }
     }
 
-    public async Task<ResultOld<long>> GetSecurityVersionAsync(AuthorityUser user, CancellationToken cancellationToken = default)
+    public async Task<long> GetSecurityVersionAsync(AuthorityUser user, CancellationToken cancellationToken = default)
-    {
-        try
     {
         await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
         var usrVersion = await context.Users.Where(u => u.Id == user.Id).Select(u => u.SecurityVersion).FirstOrDefaultAsync(cancellationToken);
-            return ResultOld<long>.HandleResult(usrVersion, "Failed to get user security version!");
+        return usrVersion;
-        }
-        catch (Exception e)
-        {
-            return HandleExceptionResult<long>("An error occured while getting the user security version.", e);
-        }
     }
 }

DotBased.AspNet.Authority/Managers/AuthorityRoleManager.cs

@@ -10,18 +10,28 @@ public partial class AuthorityManager
     {
         role.Version = GenerateVersion();
         var createResult = await RoleRepository.CreateRoleAsync(role, cancellationToken);
+        if (createResult == null)
+        {
+            return ResultError.Fail("Failed to create new role.");
+        }
+
         return createResult;
     }
 
     public async Task<Result> DeleteRolesAsync(List<AuthorityRole> roles, CancellationToken cancellationToken = default)
     {
-        var result = await RoleRepository.DeleteRolesAsync(roles, cancellationToken);
+        var success = await RoleRepository.DeleteRolesAsync(roles, cancellationToken);
-        return result;
+        return success ? Result.Success() : ResultError.Fail("Failed to delete roles.");
     }
 
     public async Task<Result<AuthorityRole>> UpdateRoleAsync(AuthorityRole role, CancellationToken cancellationToken = default)
     {
         var result = await RoleRepository.UpdateRoleAsync(role, cancellationToken);
+        if (result == null)
+        {
+            return ResultError.Fail("Failed to update role.");
+        }
+
         return result;
     }
 
@@ -31,94 +41,69 @@ public partial class AuthorityManager
         return searchResult;
     }
 
-    public async Task AddRolesToUserAsync(List<AuthorityRole> roles, AuthorityUser user, CancellationToken cancellationToken = default)
+    public async Task<Result> AddRolesToUserAsync(List<AuthorityRole> roles, AuthorityUser user, CancellationToken cancellationToken = default)
     {
         var usrValidation = await IsValidUserAsync(user, cancellationToken);
-        if (!usrValidation.Success)
+        if (!usrValidation.IsSuccess)
         {
-            _logger.Error(usrValidation.Exception ?? new Exception("Validation for user failed!"), "Invalid user!");
+            return usrValidation;
-            return;
         }
         
-        var checkResult = await RoleRepository.HasRolesAsync(user.Id, roles, cancellationToken);
+        var linkedRoles = await RoleRepository.GetRolesFromLinkAsync(user.Id, roles, cancellationToken);
-        var hasRolesList = checkResult.Match<List<Guid>>(success: v => v, (_) => []);
 
         var rolesToAdd = roles;
-        if (hasRolesList.Count != 0)
+        if (linkedRoles.Count != 0)
         {
-            rolesToAdd = roles.Where(r => !hasRolesList.Contains(r.Id)).ToList();
+            rolesToAdd = roles.Where(r => !linkedRoles.Contains(r.Id)).ToList();
         }
 
-        var addResult = await RoleRepository.AddRolesLinkAsync(rolesToAdd, user.Id, cancellationToken);
+        var addSuccess = await RoleRepository.AddRolesLinkAsync(rolesToAdd, user.Id, cancellationToken);
-        addResult.Match(() =>
+        
-        {
+        return addSuccess ? Result.Success() : ResultError.Fail("Failed to add roles.");
-            _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)
+    public async Task<Result> RemoveRolesFromUserAsync(List<AuthorityRole> roles, AuthorityUser user, CancellationToken cancellationToken = default)
     {
         var usrValidation = await IsValidUserAsync(user, cancellationToken);
-        if (!usrValidation.Success)
+        if (!usrValidation.IsSuccess)
         {
-            _logger.Error(usrValidation.Exception ?? new Exception("Validation for user failed!"), "Invalid user!");
+            return usrValidation;
-            return;
         }
         
-        var checkResult = await RoleRepository.HasRolesAsync(user.Id, roles, cancellationToken);
+        var linkedRoles = await RoleRepository.GetRolesFromLinkAsync(user.Id, roles, cancellationToken);
-        var hasRolesList = checkResult.Match<List<Guid>>(success: v => v, (_) => []);
 
         var rolesToRemove = roles;
-        if (hasRolesList.Count != 0)
+        if (linkedRoles.Count != 0)
         {
-            rolesToRemove = roles.Where(r => !hasRolesList.Contains(r.Id)).ToList();
+            rolesToRemove = roles.Where(r => !linkedRoles.Contains(r.Id)).ToList();
         }
         
-        var removeResult = await RoleRepository.DeleteRolesLinkAsync(rolesToRemove, user.Id, cancellationToken);
+        var removeResult = await RoleRepository.UnlinkRolesAsync(rolesToRemove, user.Id, cancellationToken);
-        removeResult.Match(() =>
+        return removeResult ? Result.Success() : ResultError.Fail("Failed to remove roles.");
-        {
-            _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)
+    public async Task<Result> AddRolesToGroupAsync(List<AuthorityRole> roles, AuthorityGroup group, CancellationToken cancellationToken = default)
     {
-        var checkResult = await RoleRepository.HasRolesAsync(group.Id, roles, cancellationToken);
+        var linkedRoles = await RoleRepository.GetRolesFromLinkAsync(group.Id, roles, cancellationToken);
-        var hasRolesList = checkResult.Match<List<Guid>>(success: v => v, (_) => []);
         
         var rolesToAdd = roles;
-        if (hasRolesList.Count != 0)
+        if (linkedRoles.Count != 0)
         {
-            rolesToAdd = roles.Where(r => !hasRolesList.Contains(r.Id)).ToList();
+            rolesToAdd = roles.Where(r => !linkedRoles.Contains(r.Id)).ToList();
         }
         
-        var addResult = await RoleRepository.AddRolesLinkAsync(rolesToAdd, group.Id, cancellationToken);
+        var linkResult = await RoleRepository.AddRolesLinkAsync(rolesToAdd, group.Id, cancellationToken);
-        addResult.Match(() =>
+        return linkResult ? Result.Success() : ResultError.Fail("Failed to add roles.");
-        {
-            _logger.Debug("Added roles to group.");
-        }, e =>
-        {
-            _logger.Error(e.Exception ?? new Exception("Adding roles to group failed!"), e.Description);
-        });
     }
     
-    /// <summary>
+    public async Task<Result<List<AuthorityRole>>> GetAllUserRolesAsync(AuthorityUser user, CancellationToken cancellationToken = default)
-    /// Get all roles (including group roles) that the user has.
+    {
-    /// </summary>
+        try
-    /// <param name="user">The user to get the roles from</param>
-    /// <param name="cancellationToken"></param>
-    public async Task<Result<List<AuthorityRole>>> GetUserRolesAsync(AuthorityUser user, CancellationToken cancellationToken = default)
         {
             var usrValidation = await IsValidUserAsync(user, cancellationToken);
-        if (!usrValidation.Success)
+            if (!usrValidation.IsSuccess)
             {
-            return ResultError.Fail("Invalid user");
+                return usrValidation.Error ?? ResultError.Fail("User validation failed.");
             }
 
             var searchIds = new List<Guid> { user.Id };
@@ -130,20 +115,24 @@ public partial class AuthorityManager
             }
 
             var linkedRolesResult = await RoleRepository.GetLinkedRolesAsync(searchIds, cancellationToken);
-        return linkedRolesResult.Match<List<AuthorityRole>>(roles => roles, e =>
+            return linkedRolesResult;
+        }
+        catch (Exception e)
         {
-            _logger.Error(e.Exception ?? new Exception("Failed to get user roles!"), e.Description);
+            return e;
-            return [];
+        }
-        });
     }
 
     public async Task<Result<List<AuthorityRole>>> GetGroupRolesAsync(List<Guid> groupIds, CancellationToken cancellationToken = default)
     {
-        var linkedRolesResult = await RoleRepository.GetLinkedRolesAsync(groupIds, cancellationToken);
+        try
-        return linkedRolesResult.Match<List<AuthorityRole>>(roles => roles, e =>
         {
-            _logger.Error(e.Exception ?? new Exception("Failed to get group roles!"), e.Description);
+            var linkedRolesResult = await RoleRepository.GetLinkedRolesAsync(groupIds, cancellationToken);
-            return [];
+            return linkedRolesResult;
-        });
+        }
+        catch (Exception e)
+        {
+            return e;
+        }
     }
 }

DotBased.AspNet.Authority/Managers/AuthorityUserManager.cs

@@ -1,6 +1,8 @@
 using DotBased.AspNet.Authority.Models;
 using DotBased.AspNet.Authority.Models.Authority;
 using DotBased.AspNet.Authority.Models.Validation;
+using DotBased.AspNet.Authority.Monads;
+using DotBased.Monads;
 
 namespace DotBased.AspNet.Authority.Managers;
 
@@ -12,12 +14,12 @@ public partial class AuthorityManager
         foreach (var validator in PasswordValidators)
         {
             var validatorResult = await validator.ValidatePasswordAsync(this, user, password);
-            if (!validatorResult.Success)
+            if (!validatorResult.IsSuccess)
             {
-                errors.AddRange(validatorResult.Errors);
+                errors.AddRange(validatorResult.ValidationErrors);
             }
         }
-        return errors.Count > 0 ? ValidationResult.Failed(errors) : ValidationResult.Ok();
+        return errors.Count > 0 ? ValidationResult.Fail(errors) : ValidationResult.Success();
     }
 
     public async Task<ValidationResult> ValidateUserAsync(AuthorityUser user)
@@ -26,45 +28,50 @@ public partial class AuthorityManager
         foreach (var userValidator in UserValidators)
         {
             var validationResult = await userValidator.ValidateUserAsync(this, user);
-            if (!validationResult.Success)
+            if (!validationResult.IsSuccess)
             {
-                errors.AddRange(validationResult.Errors);
+                errors.AddRange(validationResult.ValidationErrors);
             }
         }
-        return errors.Count > 0 ? ValidationResult.Failed(errors) : ValidationResult.Ok();
+        return errors.Count > 0 ? ValidationResult.Fail(errors) : ValidationResult.Success();
     }
 
-    public async Task<ListResultOld<AuthorityUserItem>> SearchUsersAsync(string query, int maxResults = 20, int offset = 0, CancellationToken cancellationToken = default)
+    public async Task<Result<QueryItems<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<AuthorityResultOldOld<AuthorityUser>> UpdatePasswordAsync(AuthorityUser user, string password, CancellationToken cancellationToken = default)
+    public async Task<AuthorityResult<AuthorityUser>> UpdatePasswordAsync(AuthorityUser user, string password, CancellationToken cancellationToken = default)
     {
         var passwordValidation = await ValidatePasswordAsync(user, password);
-        if (!passwordValidation.Success)
+        if (!passwordValidation.IsSuccess)
         {
-            return AuthorityResultOldOld<AuthorityUser>.Failed(passwordValidation.Errors, ResultFailReason.Validation);
+            return passwordValidation.ValidationErrors.ToList();
         }
 
         user.PasswordHash = await PasswordHasher.HashPasswordAsync(password);
         user.SecurityVersion = GenerateVersion();
 
         var updateResult = await UserRepository.UpdateUserAsync(user, cancellationToken);
-        return AuthorityResultOldOld<AuthorityUser>.FromResult(updateResult);
+        if (updateResult == null)
+        {
+            return ResultError.Fail("Failed to update user password.");
         }
 
-    public async Task<AuthorityResultOldOld<AuthorityUser>> CreateUserAsync(AuthorityUser userModel, string password, CancellationToken cancellationToken = default)
+        return updateResult;
+    }
+
+    public async Task<AuthorityResult<AuthorityUser>> CreateUserAsync(AuthorityUser userModel, string password, CancellationToken cancellationToken = default)
     {
         var userValidation = await ValidateUserAsync(userModel);
         var passwordValidation = await ValidatePasswordAsync(userModel, password);
-        if (!userValidation.Success || !passwordValidation.Success)
+        if (!userValidation.IsSuccess || !passwordValidation.IsSuccess)
         {
             List<ValidationError> errors = [];
-            errors.AddRange(userValidation.Errors);
+            errors.AddRange(userValidation.ValidationErrors);
-            errors.AddRange(passwordValidation.Errors);
+            errors.AddRange(passwordValidation.ValidationErrors);
-            return AuthorityResultOldOld<AuthorityUser>.Failed(errors, ResultFailReason.Validation);
+            return errors;
         }
         
         userModel.Version = GenerateVersion();
@@ -73,25 +80,34 @@ public partial class AuthorityManager
         userModel.PasswordHash = hashedPassword;
 
         var userCreationResult = await UserRepository.CreateUserAsync(userModel, cancellationToken);
-        
+        if (userCreationResult == null)
-        return AuthorityResultOldOld<AuthorityUser>.FromResult(userCreationResult);
+        {
+            return ResultError.Fail("Failed to create user.");
         }
 
-    public async Task<ResultOld<AuthorityUser>> UpdateUserAsync(AuthorityUser model, CancellationToken cancellationToken = default)
+        return userCreationResult;
+    }
+
+    public async Task<Result<AuthorityUser>> UpdateUserAsync(AuthorityUser model, CancellationToken cancellationToken = default)
     {
         var updateResult = await UserRepository.UpdateUserAsync(model, cancellationToken);
+        if (updateResult == null)
+        {
+            return ResultError.Fail("Failed to update user.");
+        }
+
         return updateResult;
     }
 
-    public async Task<ResultOld> DeleteUserAsync(AuthorityUser model, CancellationToken cancellationToken = default)
+    public async Task<Result> DeleteUserAsync(AuthorityUser model, CancellationToken cancellationToken = default)
     {
-        var deleteResult = await UserRepository.DeleteUserAsync(model, cancellationToken);
+        var deleteResult = await UserRepository.DeleteUsersAsync([model], cancellationToken);
-        return deleteResult;
+        return deleteResult ? Result.Success() : ResultError.Fail("Failed to delete user.");
     }
 
-    public async Task<ResultOld> IsValidUserAsync(AuthorityUser user, CancellationToken cancellationToken = default)
+    public async Task<Result> IsValidUserAsync(AuthorityUser user, CancellationToken cancellationToken = default)
     {
         var usrResult = await UserRepository.GetVersionAsync(user, cancellationToken);
-        return usrResult;
+        return usrResult == 0 ? ResultError.Fail("Invalid user version detected.") : Result.Success();
     }
 }

DotBased.AspNet.Authority/Models/AuthorityResultOldOld.cs

@@ -1,41 +0,0 @@
-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/Validation/ValidationResult.cs

@@ -1,21 +0,0 @@
-namespace DotBased.AspNet.Authority.Models.Validation;
-
-public class ValidationResult
-{
-    public ValidationResult(bool success, IEnumerable<ValidationError>? errors = null)
-    {
-        if (errors != null)
-        {
-            Errors = errors.ToList();
-        }
-        Success = success;
-    }
-    
-    public bool Success { get; }
-    public IReadOnlyList<ValidationError> Errors { get; } = [];
-
-    public static ValidationResult Failed(IEnumerable<ValidationError> errors) => new(false, errors);
-    public static ValidationResult Ok() => new(true);
-
-    public override string ToString() => Success ? "Success" : $"Failed ({Errors.Count} errors)";
-}

DotBased.AspNet.Authority/Monads/AuthorityResult.cs

@@ -0,0 +1,40 @@
+using DotBased.AspNet.Authority.Models.Validation;
+using DotBased.Monads;
+
+namespace DotBased.AspNet.Authority.Monads;
+
+public class AuthorityResult<TResult> : Result<TResult>
+{
+    protected AuthorityResult(TResult result) : base(result)
+    {
+    }
+
+    protected AuthorityResult(Exception exception) : base(exception)
+    {
+    }
+
+    protected AuthorityResult(ResultError error) : base(error)
+    {
+    }
+
+    protected AuthorityResult(List<ValidationError> validationErrors) : base(ResultError.Fail("Validation failed!"))
+    {
+        _validationErrors = validationErrors;
+    }
+
+    private readonly List<ValidationError> _validationErrors = [];
+    public IReadOnlyList<ValidationError> ValidationErrors => _validationErrors;
+
+    public static implicit operator AuthorityResult<TResult>(TResult result) => new(result);
+    public static implicit operator AuthorityResult<TResult>(Exception exception) => new(exception);
+    public static implicit operator AuthorityResult<TResult>(ResultError error) => new(error);
+    public static implicit operator AuthorityResult<TResult>(List<ValidationError> validationErrors) => new(validationErrors);
+
+    public static AuthorityResult<TResult> FromResult(Result<TResult> result)
+    {
+        var authorityResult = result.Match<AuthorityResult<TResult>>(
+            r => new AuthorityResult<TResult>(r),
+            error => new AuthorityResult<TResult>(error));
+        return authorityResult;
+    }
+}

DotBased.AspNet.Authority/Monads/ValidationResult.cs

@@ -3,9 +3,9 @@ using DotBased.Monads;
 
 namespace DotBased.AspNet.Authority.Monads;
 
-public class ValidationResult<T> : Result<T>
+public class ValidationResult : Result
 {
-    private ValidationResult(T result) : base(result)
+    private ValidationResult()
     {
     }
 
@@ -25,19 +25,19 @@ public class ValidationResult<T> : Result<T>
     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)
+    public static implicit operator ValidationResult(Exception exception) => new(exception);
+    public static implicit operator ValidationResult(ResultError error) => new(error);
+    public static implicit operator ValidationResult(List<ValidationError> validationErrors) => new(validationErrors);
+
+    public static ValidationResult FromResult(Result result)
     {
-        var authorityResult = result.Match<ValidationResult<T>>(
+        var validationResult = result.Match<ValidationResult>(
-            r => new ValidationResult<T>(r),
+            () => new ValidationResult(),
-            error => new ValidationResult<T>(error));
+            error => new ValidationResult(error));
-        return authorityResult;
+        return validationResult;
     }
 
-    public TMatch Match<TMatch>(Func<T, TMatch> success, Func<ResultError, IReadOnlyList<ValidationError>, TMatch> failure) =>
+    public new static ValidationResult Success() => new();
-        IsSuccess && Value != null ? success(Value) : failure(Error ?? ResultError.Fail("No error and value is null!"), ValidationErrors);
+    public static ValidationResult Fail(List<ValidationError> validationErrors) => new(validationErrors);
 }

DotBased.AspNet.Authority/Repositories/IRoleRepository.cs

@@ -1,19 +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<Result<QueryItems<AuthorityRoleItem>>> GetRolesAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default);
+    public Task<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<AuthorityRole?> GetRoleByIdAsync(Guid id, CancellationToken cancellationToken = default);
-    public Task<Result<AuthorityRole>> CreateRoleAsync(AuthorityRole role, CancellationToken cancellationToken = default);
+    public Task<AuthorityRole?> CreateRoleAsync(AuthorityRole role, CancellationToken cancellationToken = default);
-    public Task<Result<AuthorityRole>> UpdateRoleAsync(AuthorityRole role, CancellationToken cancellationToken = default);
+    public Task<AuthorityRole?> UpdateRoleAsync(AuthorityRole role, CancellationToken cancellationToken = default);
-    public Task<Result> DeleteRolesAsync(List<AuthorityRole> roles, CancellationToken cancellationToken = default);
+    public Task<bool> DeleteRolesAsync(List<AuthorityRole> roles, CancellationToken cancellationToken = default);
-    public Task<Result> AddRolesLinkAsync(List<AuthorityRole> roles, Guid linkId, CancellationToken cancellationToken = default);
+    public Task<bool> AddRolesLinkAsync(List<AuthorityRole> roles, Guid linkId, CancellationToken cancellationToken = default);
-    public Task<Result<List<AuthorityRole>>> GetLinkedRolesAsync(List<Guid> linkIds, CancellationToken cancellationToken = default);
+    public Task<List<AuthorityRole>> GetLinkedRolesAsync(List<Guid> linkIds, CancellationToken cancellationToken = default);
-    public Task<Result> DeleteRolesLinkAsync(List<AuthorityRole> roles, Guid linkId, CancellationToken cancellationToken = default);
+    public Task<bool> UnlinkRolesAsync(List<AuthorityRole> roles, Guid linkId, CancellationToken cancellationToken = default);
     
     /// <summary>
     /// Return the role ids the linkId has.
@@ -22,5 +21,5 @@ public interface IRoleRepository
     /// <param name="roles"></param>
     /// <param name="cancellationToken"></param>
     /// <returns></returns>
-    public Task<Result<List<Guid>>> HasRolesAsync(Guid linkId, List<AuthorityRole> roles, CancellationToken cancellationToken = default);
+    public Task<List<Guid>> GetRolesFromLinkAsync(Guid linkId, List<AuthorityRole> roles, CancellationToken cancellationToken = default);
 }

DotBased.AspNet.Authority/Repositories/IUserRepository.cs

@@ -1,17 +1,18 @@
+using DotBased.AspNet.Authority.Models;
 using DotBased.AspNet.Authority.Models.Authority;
 
 namespace DotBased.AspNet.Authority.Repositories;
 
 public interface IUserRepository
 {
-    public Task<ListResultOld<AuthorityUserItem>> GetAuthorityUsersAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default);
+    public Task<QueryItems<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<AuthorityUser?> GetAuthorityUserByIdAsync(Guid id, CancellationToken cancellationToken = default);
-    public Task<ResultOld<AuthorityUser>> CreateUserAsync(AuthorityUser user, CancellationToken cancellationToken = default);
+    public Task<AuthorityUser?> CreateUserAsync(AuthorityUser user, CancellationToken cancellationToken = default);
-    public Task<ResultOld<AuthorityUser>> UpdateUserAsync(AuthorityUser user, CancellationToken cancellationToken = default);
+    public Task<AuthorityUser?> UpdateUserAsync(AuthorityUser user, CancellationToken cancellationToken = default);
-    public Task<ResultOld> DeleteUserAsync(AuthorityUser user, CancellationToken cancellationToken = default);
+    public Task<bool> DeleteUsersAsync(List<AuthorityUser> users, CancellationToken cancellationToken = default);
-    public Task<ResultOld<AuthorityUser>> GetUserByEmailAsync(string email, CancellationToken cancellationToken = default);
+    public Task<AuthorityUser?> GetUserByEmailAsync(string email, CancellationToken cancellationToken = default);
-    public Task<ResultOld> SetVersionAsync(AuthorityUser user, long version, CancellationToken cancellationToken = default);
+    public Task<bool> SetVersionAsync(AuthorityUser user, long version, CancellationToken cancellationToken = default);
-    public Task<ResultOld<long>> GetVersionAsync(AuthorityUser user, CancellationToken cancellationToken = default);
+    public Task<long> GetVersionAsync(AuthorityUser user, CancellationToken cancellationToken = default);
-    public Task<ResultOld> SetSecurityVersionAsync(AuthorityUser user, long securityVersion, CancellationToken cancellationToken = default);
+    public Task<bool> SetSecurityVersionAsync(AuthorityUser user, long securityVersion, CancellationToken cancellationToken = default);
-    public Task<ResultOld<long>> GetSecurityVersionAsync(AuthorityUser user, CancellationToken cancellationToken = default);
+    public Task<long> GetSecurityVersionAsync(AuthorityUser user, CancellationToken cancellationToken = default);
 }

DotBased.AspNet.Authority/Validators/IPasswordValidator.cs

@@ -1,6 +1,6 @@
 using DotBased.AspNet.Authority.Managers;
 using DotBased.AspNet.Authority.Models.Authority;
-using DotBased.AspNet.Authority.Models.Validation;
+using DotBased.AspNet.Authority.Monads;
 
 namespace DotBased.AspNet.Authority.Validators;
 

DotBased.AspNet.Authority/Validators/IUserValidator.cs

@@ -1,6 +1,6 @@
 using DotBased.AspNet.Authority.Managers;
 using DotBased.AspNet.Authority.Models.Authority;
-using DotBased.AspNet.Authority.Models.Validation;
+using DotBased.AspNet.Authority.Monads;
 
 namespace DotBased.AspNet.Authority.Validators;
 

DotBased.AspNet.Authority/Validators/PasswordEqualsValidator.cs

@@ -1,6 +1,7 @@
 using DotBased.AspNet.Authority.Managers;
 using DotBased.AspNet.Authority.Models.Authority;
 using DotBased.AspNet.Authority.Models.Validation;
+using DotBased.AspNet.Authority.Monads;
 
 namespace DotBased.AspNet.Authority.Validators;
 
@@ -17,6 +18,6 @@ public class PasswordEqualsValidator : IPasswordValidator
             errors.Add(new ValidationError(ValidatorId, $"{ValidationBase}.InUse", "User uses this password already!"));
         }
 
-        return errors.Count > 0 ? ValidationResult.Failed(errors) : ValidationResult.Ok();
+        return errors.Count > 0 ? ValidationResult.Fail(errors) : ValidationResult.Success();
     }
 }

DotBased.AspNet.Authority/Validators/PasswordOptionsValidator.cs

@@ -1,6 +1,7 @@
 using DotBased.AspNet.Authority.Managers;
 using DotBased.AspNet.Authority.Models.Authority;
 using DotBased.AspNet.Authority.Models.Validation;
+using DotBased.AspNet.Authority.Monads;
 using DotBased.Extensions;
 
 namespace DotBased.AspNet.Authority.Validators;
@@ -57,7 +58,7 @@ public class PasswordOptionsValidator : IPasswordValidator
             errors.Add(new ValidationError(ValidatorId, $"{ValidationBase}.UniqueChars", $"Password must contain at least {passwordOptions.MinimalUniqueChars} unique chars."));
         }
 
-        return await Task.FromResult(errors.Count > 0 ? ValidationResult.Failed(errors) : ValidationResult.Ok());
+        return await Task.FromResult(errors.Count > 0 ? ValidationResult.Fail(errors) : ValidationResult.Success());
     }
 
     private bool ContainsDigit(string strVal) => strVal.Any(char.IsDigit);

DotBased.AspNet.Authority/Validators/UserValidator.cs

@@ -2,6 +2,7 @@ using DotBased.AspNet.Authority.Managers;
 using DotBased.AspNet.Authority.Models.Authority;
 using DotBased.AspNet.Authority.Models.Options;
 using DotBased.AspNet.Authority.Models.Validation;
+using ValidationResult = DotBased.AspNet.Authority.Monads.ValidationResult;
 
 namespace DotBased.AspNet.Authority.Validators;
 
@@ -53,7 +54,7 @@ public class UserValidator : IUserValidator
                     chars.AddRange(user.UserName.Where(userNameChar => userOptions.UserNameCharacters.Contains(userNameChar)));
                 }
 
-                if (chars.Count <= 0) return errors.Count > 0 ? ValidationResult.Failed(errors) : ValidationResult.Ok();
+                if (chars.Count <= 0) return errors.Count > 0 ? ValidationResult.Fail(errors) : ValidationResult.Success();
                 var errorCode = "";
                 var description = "";
                 switch (userOptions.UserNameCharacterListType)
@@ -76,6 +77,6 @@ public class UserValidator : IUserValidator
             errors.Add(new ValidationError(ValidatorId, $"{ValidationBase}.InvalidUserName", "No username given!"));
         }
 
-        return errors.Count > 0 ? ValidationResult.Failed(errors) : ValidationResult.Ok();
+        return errors.Count > 0 ? ValidationResult.Fail(errors) : ValidationResult.Success();
     }
 }