hmaxnl/DotBased
1
1
Fork 0
mirror of https://github.com/hmaxnl/DotBased.git synced 2025-04-19 20:18:13 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

Compare commits

base: hmaxnl:0a5950cfa2e1dacc0e3656782eaf06d2ff610c05
Branches Tags
hmaxnl:main
hmaxnl:feature/base_authority
..
compare: hmaxnl:ec7e2605114e105e7dc3e2d58b6355e2611d5b64
Branches Tags
hmaxnl:feature/base_authority
hmaxnl:main

4 Commits
0a5950cfa2 ... ec7e260511

Author SHA1 Message Date
max
ec7e260511 [REMOVE] Remove old AuthorityResult 2025-04-11 21:07:45 +02:00
max
ba0de46068 [REFACTOR] Refactored UserRepository to use new monads 2025-04-11 21:07:08 +02:00
max
21fe08c04f [CHANGE] Updated ValidationResult to monad version 2025-04-11 20:12:53 +02:00
max
f0cb7218ac [CHANGE] Updated role repository tasks 2025-04-11 19:57:20 +02:00
15 changed files with 359 additions and 524 deletions
Show Stats Expand all files Collapse all files

240
DotBased.AspNet.Authority.EFCore/Repositories/RoleRepository.cs
View File

@ -2,207 +2,125 @@ using DotBased.AspNet.Authority.EFCore.Models;
using DotBased.AspNet.Authority.Models; using DotBased.AspNet.Authority.Models;
using DotBased.AspNet.Authority.Models.Authority; using DotBased.AspNet.Authority.Models.Authority;
using DotBased.AspNet.Authority.Repositories; using DotBased.AspNet.Authority.Repositories;
using DotBased.Monads;
using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
namespace DotBased.AspNet.Authority.EFCore.Repositories; 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();
if (!string.IsNullOrWhiteSpace(search))
{ {
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); query = query.Where(r =>
var query = context.Roles.AsQueryable(); $"{r.Name} {r.Id}".Contains(search, StringComparison.CurrentCultureIgnoreCase));
if (!string.IsNullOrWhiteSpace(search)) }
{
query = query.Where(r =>
$"{r.Name} {r.Id}".Contains(search, StringComparison.CurrentCultureIgnoreCase));
}
var total = await query.CountAsync(cancellationToken); var total = await query.CountAsync(cancellationToken);
var select = await query.OrderBy(r => r.Name).Skip(offset).Take(limit).Select(r => new AuthorityRoleItem() var select = await query.OrderBy(r => r.Name).Skip(offset).Take(limit).Select(r => new AuthorityRoleItem()
{
Id = r.Id,
Name = r.Name
}).ToListAsync(cancellationToken: cancellationToken);
return QueryItems<AuthorityRoleItem>.Create(select, total, limit, offset);
}
catch (Exception e)
{ {
return e; Id = r.Id,
} Name = r.Name
}).ToListAsync(cancellationToken: cancellationToken);
return QueryItems<AuthorityRoleItem>.Create(select, total, limit, offset);
} }
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);
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); return role;
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)
{ {
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); throw new Exception("Role id is required!");
if (role.Id == Guid.Empty)
{
return ResultError.Fail("Id cannot be empty!");
}
var entity = context.Roles.Add(role);
var saveResult = await context.SaveChangesAsync(cancellationToken);
return saveResult <= 0 ? ResultError.Fail("Failed to create role!") : entity.Entity;
}
catch (Exception e)
{
return e;
} }
var entity = context.Roles.Add(role);
var saveResult = await context.SaveChangesAsync(cancellationToken);
return saveResult != 0 ? entity.Entity : null;
} }
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)
{ {
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); throw new Exception($"Role with id {role.Id} not found!");
var currentRole = await context.Roles.FirstOrDefaultAsync(r => r.Id == role.Id, cancellationToken: cancellationToken); }
if (currentRole == null)
{
return ResultError.Fail("Role not found!");
}
if (role.Version != currentRole.Version) 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 entity = context.Roles.Update(role);
var saveResult = await context.SaveChangesAsync(cancellationToken); 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();
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(rl => roleIds.Contains(rl.RoleId)));
context.Roles.RemoveRange(roles);
context.RoleLinks.RemoveRange(context.RoleLinks.Where(rg => roleIds.Contains(rg.RoleId))); var removedRoles = await context.SaveChangesAsync(cancellationToken);
if (removedRoles != 0) return true;
var removeResult = await context.SaveChangesAsync(cancellationToken); logger.LogError("Failed to remove roles");
return removeResult == roles.Count? Result.Success() : ResultError.Fail($"Not all roles have been removed! {removeResult} of {roles.Count} roles removed!"); return false;
}
catch (Exception e)
{
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);
foreach (var role in roles)
{ {
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); context.RoleLinks.Add(new RoleLink { LinkId = linkId, RoleId = role.Id });
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)); var linkedRoles = await context.SaveChangesAsync(cancellationToken);
if (!string.IsNullOrEmpty(search)) if (linkedRoles == roles.Count)
{ {
rolesQuery = rolesQuery.Where(r => r.Name.Contains(search)); return true;
} }
var roles = rolesQuery.Where(r => roleIds.Contains(r.Id)).Skip(offset).Take(limit).Select(r => new AuthorityRoleItem() logger.LogError("Failed to link all given roles, {linkedRoles}/{totalRoles} roles linked!", linkedRoles, roles.Count);
{ return false;
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) public async Task<List<AuthorityRole>> GetLinkedRolesAsync(List<Guid> linkIds, CancellationToken cancellationToken = default)
{ {
try await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
{ var linkedRoles = context.RoleLinks.Where(r => linkIds.Contains(r.LinkId)).Select(r => r.RoleId);
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); var roleList = await context.Roles.Where(r => linkedRoles.Contains(r.Id)).ToListAsync(cancellationToken);
foreach (var role in roles) return roleList.DistinctBy(r => r.Id).ToList();
{
context.RoleLinks.Add(new RoleLink() { LinkId = linkId, RoleId = role.Id });
}
var saveResult = await context.SaveChangesAsync(cancellationToken);
return saveResult == roles.Count ? Result.Success() : ResultError.Fail($"Not all roles have been linked! {saveResult} of {roles.Count} roles linked!");
}
catch (Exception e)
{
return e;
}
} }
public async Task<Result<List<AuthorityRole>>> GetLinkedRolesAsync(List<Guid> linkIds, 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();
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); context.RoleLinks.RemoveRange(context.RoleLinks.Where(rg => rg.LinkId == linkId && roleIds.Contains(rg.RoleId)));
var linkedRoles = context.RoleLinks.Where(r => linkIds.Contains(r.LinkId)).Select(r => r.RoleId); var unlinkedRoles = await context.SaveChangesAsync(cancellationToken);
var roleList = await context.Roles.Where(r => linkedRoles.Contains(r.Id)).ToListAsync(cancellationToken); if (unlinkedRoles != 0) return true;
return roleList.DistinctBy(r => r.Id).ToList(); logger.LogError("Failed to remove linked roles");
} return false;
catch (Exception e)
{
return e;
}
} }
public async Task<Result> DeleteRolesLinkAsync(List<AuthorityRole> roles, Guid linkId, 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);
{ return await context.RoleLinks.Where(r => r.LinkId == linkId && roles.Any(ar => ar.Id == r.RoleId)).Select(r => r.RoleId).ToListAsync(cancellationToken);
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);
return saveResult == roles.Count ? Result.Success() : ResultError.Fail($"Not all roles have been unlinked! {saveResult} of {roles.Count} roles unlinked!");
}
catch (Exception e)
{
return e;
}
}
public async Task<Result<List<Guid>>> HasRolesAsync(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 hasRoles;
}
catch (Exception e)
{
return e;
}
} }
} }

257
DotBased.AspNet.Authority.EFCore/Repositories/UserRepository.cs
View File

@ -1,216 +1,147 @@
using DotBased.AspNet.Authority.Models;
using DotBased.AspNet.Authority.Models.Authority; using DotBased.AspNet.Authority.Models.Authority;
using DotBased.AspNet.Authority.Repositories; using DotBased.AspNet.Authority.Repositories;
using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
namespace DotBased.AspNet.Authority.EFCore.Repositories; 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();
if (!string.IsNullOrWhiteSpace(search))
{ {
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); query = query.Where(u =>
var query = context.Users.AsQueryable(); $"{u.Id} {u.Name} {u.UserName} {u.EmailAddress} {u.PhoneNumber}".Contains(search,
if (!string.IsNullOrWhiteSpace(search)) StringComparison.CurrentCultureIgnoreCase));
{
query = query.Where(u =>
$"{u.Id} {u.Name} {u.UserName} {u.EmailAddress} {u.PhoneNumber}".Contains(search,
StringComparison.CurrentCultureIgnoreCase));
}
var totalCount = query.Count();
var selected = await query.OrderBy(u => u.UserName).Skip(offset).Take(limit).Select(u => new AuthorityUserItem()
{
Id = u.Id,
UserName = u.UserName,
EmailAddress = u.EmailAddress,
PhoneNumber = u.PhoneNumber
}).ToListAsync(cancellationToken: cancellationToken);
return ListResultOld<AuthorityUserItem>.Ok(selected, totalCount, limit, offset);
} }
catch (Exception e) var totalCount = query.Count();
var selected = await query.OrderBy(u => u.UserName).Skip(offset).Take(limit).Select(u => new AuthorityUserItem()
{ {
return HandleExceptionListResult<AuthorityUserItem>("Failed to get users.", e); Id = u.Id,
} UserName = u.UserName,
EmailAddress = u.EmailAddress,
PhoneNumber = u.PhoneNumber
}).ToListAsync(cancellationToken: cancellationToken);
return QueryItems<AuthorityUserItem>.Create(selected, totalCount, limit, offset);
} }
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 (id == Guid.Empty)
{ {
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); throw new Exception("Id is required!");
if (!Guid.TryParse(id, out var guid)) }
{
return ResultOld<AuthorityUser>.Failed("Invalid id!");
}
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)
{ {
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); throw new Exception("User id is required!");
if (user.Id == Guid.Empty)
{
return ResultOld<AuthorityUser>.Failed("Id cannot be empty!");
}
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);
}
catch (Exception e)
{
return HandleExceptionResult<AuthorityUser>("Failed to create user.", e);
} }
var entity = context.Users.Add(user);
var saveResult = await context.SaveChangesAsync(cancellationToken);
return saveResult != 0 ? entity.Entity : null;
} }
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)
{ {
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); throw new Exception("User not found!");
var usr = await context.Users.FirstOrDefaultAsync(u => u.Id == user.Id, cancellationToken: cancellationToken); }
if (usr == null)
{
return ResultOld<AuthorityUser>.Failed("User not found!");
}
if (usr.Version != user.Version || usr.SecurityVersion != user.SecurityVersion) 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 entity = context.Users.Update(user);
var saveResult = await context.SaveChangesAsync(cancellationToken); 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 usrIds = users.Select(u => u.Id);
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
var usr = await context.Users.FirstOrDefaultAsync(u => u.Id == user.Id, cancellationToken: cancellationToken); context.Users.RemoveRange(users);
if (usr == null) context.RoleLinks.RemoveRange(context.RoleLinks.Where(rl => usrIds.Contains(rl.LinkId)));
{
return ResultOld.Failed("User not found!"); var removedResult = await context.SaveChangesAsync(cancellationToken);
} if (removedResult != 0) return true;
context.Users.Remove(usr); logger.LogError("Failed to delete users");
var saveResult = await context.SaveChangesAsync(cancellationToken); return false;
return saveResult <= 0 ? ResultOld.Failed("Failed to delete user!") : ResultOld.Ok();
}
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);
{ return await context.Users.Where(u => u.EmailAddress == email).Include(u => u.Attributes).FirstOrDefaultAsync(cancellationToken: cancellationToken);
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 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)
{ {
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); throw new Exception("User not found!");
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!");
}
if (usr.Version != user.Version) 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; usr.Version = version;
context.Users.Update(usr); context.Users.Update(usr);
var saveResult = await context.SaveChangesAsync(cancellationToken); 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);
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); return usrVersion;
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!");
}
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)
{ {
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); throw new Exception("User not found!");
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!");
}
if (usr.SecurityVersion != user.SecurityVersion) 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; usr.SecurityVersion = securityVersion;
context.Users.Update(usr); context.Users.Update(usr);
var saveResult = await context.SaveChangesAsync(cancellationToken); 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);
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); return usrVersion;
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!");
}
catch (Exception e)
{
return HandleExceptionResult<long>("An error occured while getting the user security version.", e);
}
} }
} }

139
DotBased.AspNet.Authority/Managers/AuthorityRoleManager.cs
View File

@ -10,18 +10,28 @@ public partial class AuthorityManager
{ {
role.Version = GenerateVersion(); role.Version = GenerateVersion();
var createResult = await RoleRepository.CreateRoleAsync(role, cancellationToken); var createResult = await RoleRepository.CreateRoleAsync(role, cancellationToken);
if (createResult == null)
{
return ResultError.Fail("Failed to create new role.");
}
return createResult; return createResult;
} }
public async Task<Result> DeleteRolesAsync(List<AuthorityRole> roles, CancellationToken cancellationToken = default) 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) public async Task<Result<AuthorityRole>> UpdateRoleAsync(AuthorityRole role, CancellationToken cancellationToken = default)
{ {
var result = await RoleRepository.UpdateRoleAsync(role, cancellationToken); var result = await RoleRepository.UpdateRoleAsync(role, cancellationToken);
if (result == null)
{
return ResultError.Fail("Failed to update role.");
}
return result; return result;
} }
@ -31,119 +41,98 @@ public partial class AuthorityManager
return searchResult; 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); 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; 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); 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; 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; 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>
/// <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); try
if (!usrValidation.Success)
{ {
return ResultError.Fail("Invalid user"); var usrValidation = await IsValidUserAsync(user, cancellationToken);
if (!usrValidation.IsSuccess)
{
return usrValidation.Error ?? ResultError.Fail("User validation failed.");
}
var searchIds = new List<Guid> { user.Id };
var usrGroups = await GetUserGroupsAsync(user, cancellationToken);
if (usrGroups.Success)
{
searchIds.AddRange(usrGroups.Items.Select(g => g.Id).ToList());
}
var linkedRolesResult = await RoleRepository.GetLinkedRolesAsync(searchIds, cancellationToken);
return linkedRolesResult;
} }
catch (Exception e)
var searchIds = new List<Guid> { user.Id };
var usrGroups = await GetUserGroupsAsync(user, cancellationToken);
if (usrGroups.Success)
{ {
searchIds.AddRange(usrGroups.Items.Select(g => g.Id).ToList()); return e;
} }
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<Result<List<AuthorityRole>>> GetGroupRolesAsync(List<Guid> groupIds, CancellationToken cancellationToken = default) 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;
}
} }
} }

64
DotBased.AspNet.Authority/Managers/AuthorityUserManager.cs
View File

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

41
DotBased.AspNet.Authority/Models/AuthorityResultOldOld.cs
View File

@ -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
}

21
DotBased.AspNet.Authority/Models/Validation/ValidationResult.cs
View File

@ -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)";
}

40
DotBased.AspNet.Authority/Monads/AuthorityResult.cs Normal file
View File

@ -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;
}
}

26
DotBased.AspNet.Authority/Monads/ValidationResult.cs
View File

@ -3,9 +3,9 @@ using DotBased.Monads;
namespace DotBased.AspNet.Authority.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 = []; private readonly List<ValidationError> _validationErrors = [];
public IReadOnlyList<ValidationError> ValidationErrors => _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(Exception exception) => new(exception);
public static implicit operator ValidationResult<T>(ResultError error) => new(error); public static implicit operator ValidationResult(ResultError error) => new(error);
public static implicit operator ValidationResult<T>(List<ValidationError> validationErrors) => new(validationErrors); public static implicit operator ValidationResult(List<ValidationError> validationErrors) => new(validationErrors);
public static ValidationResult<T> FromResult(Result<T> result) 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);
} }

19
DotBased.AspNet.Authority/Repositories/IRoleRepository.cs
View File

@ -1,19 +1,18 @@
using DotBased.AspNet.Authority.Models; using DotBased.AspNet.Authority.Models;
using DotBased.AspNet.Authority.Models.Authority; using DotBased.AspNet.Authority.Models.Authority;
using DotBased.Monads;
namespace DotBased.AspNet.Authority.Repositories; namespace DotBased.AspNet.Authority.Repositories;
public interface IRoleRepository 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> /// <summary>
/// Return the role ids the linkId has. /// Return the role ids the linkId has.
@ -22,5 +21,5 @@ public interface IRoleRepository
/// <param name="roles"></param> /// <param name="roles"></param>
/// <param name="cancellationToken"></param> /// <param name="cancellationToken"></param>
/// <returns></returns> /// <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);
} }

21
DotBased.AspNet.Authority/Repositories/IUserRepository.cs
View File

@ -1,17 +1,18 @@
using DotBased.AspNet.Authority.Models;
using DotBased.AspNet.Authority.Models.Authority; using DotBased.AspNet.Authority.Models.Authority;
namespace DotBased.AspNet.Authority.Repositories; namespace DotBased.AspNet.Authority.Repositories;
public interface IUserRepository 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);
} }

2
DotBased.AspNet.Authority/Validators/IPasswordValidator.cs
View File

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

2
DotBased.AspNet.Authority/Validators/IUserValidator.cs
View File

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

3
DotBased.AspNet.Authority/Validators/PasswordEqualsValidator.cs
View File

@ -1,6 +1,7 @@
using DotBased.AspNet.Authority.Managers; using DotBased.AspNet.Authority.Managers;
using DotBased.AspNet.Authority.Models.Authority; using DotBased.AspNet.Authority.Models.Authority;
using DotBased.AspNet.Authority.Models.Validation; using DotBased.AspNet.Authority.Models.Validation;
using DotBased.AspNet.Authority.Monads;
namespace DotBased.AspNet.Authority.Validators; 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!")); 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();
} }
} }

3
DotBased.AspNet.Authority/Validators/PasswordOptionsValidator.cs
View File

@ -1,6 +1,7 @@
using DotBased.AspNet.Authority.Managers; using DotBased.AspNet.Authority.Managers;
using DotBased.AspNet.Authority.Models.Authority; using DotBased.AspNet.Authority.Models.Authority;
using DotBased.AspNet.Authority.Models.Validation; using DotBased.AspNet.Authority.Models.Validation;
using DotBased.AspNet.Authority.Monads;
using DotBased.Extensions; using DotBased.Extensions;
namespace DotBased.AspNet.Authority.Validators; 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.")); 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); private bool ContainsDigit(string strVal) => strVal.Any(char.IsDigit);

5
DotBased.AspNet.Authority/Validators/UserValidator.cs
View File

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