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

Compare commits

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

No commits in common. "ec7e2605114e105e7dc3e2d58b6355e2611d5b64" and "0a5950cfa2e1dacc0e3656782eaf06d2ff610c05" have entirely different histories.
ec7e260511 ... 0a5950cfa2

15 changed files with 537 additions and 372 deletions
Show Stats Expand all files Collapse all files

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

@ -2,125 +2,207 @@ 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, ILogger<RoleRepository> logger) : RepositoryBase, IRoleRepository public class RoleRepository(IDbContextFactory<AuthorityContext> contextFactory) : RepositoryBase, IRoleRepository
{ {
public async Task<QueryItems<AuthorityRoleItem>> GetRolesAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default) public async Task<Result<QueryItems<AuthorityRoleItem>>> GetRolesAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default)
{ {
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); try
var query = context.Roles.AsQueryable();
if (!string.IsNullOrWhiteSpace(search))
{ {
query = query.Where(r => await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
$"{r.Name} {r.Id}".Contains(search, StringComparison.CurrentCultureIgnoreCase)); var query = context.Roles.AsQueryable();
if (!string.IsNullOrWhiteSpace(search))
{
query = query.Where(r =>
$"{r.Name} {r.Id}".Contains(search, StringComparison.CurrentCultureIgnoreCase));
}
var total = await query.CountAsync(cancellationToken);
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)
var total = await query.CountAsync(cancellationToken);
var select = await query.OrderBy(r => r.Name).Skip(offset).Take(limit).Select(r => new AuthorityRoleItem()
{ {
Id = r.Id, return e;
Name = r.Name
}).ToListAsync(cancellationToken: cancellationToken);
return QueryItems<AuthorityRoleItem>.Create(select, total, limit, offset);
}
public async Task<AuthorityRole?> GetRoleByIdAsync(Guid id, CancellationToken cancellationToken = default)
{
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);
return role;
}
public async Task<AuthorityRole?> CreateRoleAsync(AuthorityRole role, CancellationToken cancellationToken = default)
{
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
if (role.Id == Guid.Empty)
{
throw new Exception("Role id is required!");
} }
var entity = context.Roles.Add(role);
var saveResult = await context.SaveChangesAsync(cancellationToken);
return saveResult != 0 ? entity.Entity : null;
} }
public async Task<AuthorityRole?> UpdateRoleAsync(AuthorityRole role, CancellationToken cancellationToken = default) public async Task<Result<AuthorityRole>> GetRoleByIdAsync(Guid id, CancellationToken cancellationToken = default)
{ {
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); try
var currentRole = await context.Roles.FirstOrDefaultAsync(r => r.Id == role.Id, cancellationToken: cancellationToken);
if (currentRole == null)
{ {
throw new Exception($"Role with id {role.Id} not found!"); 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)
if (role.Version != currentRole.Version)
{ {
throw new Exception("Role version does not match!"); return e;
} }
var entity = context.Roles.Update(role);
var saveResult = await context.SaveChangesAsync(cancellationToken);
return saveResult != 0 ? entity.Entity : null;
} }
public async Task<bool> DeleteRolesAsync(List<AuthorityRole> roles, CancellationToken cancellationToken = default) public async Task<Result<AuthorityRole>> CreateRoleAsync(AuthorityRole role, CancellationToken cancellationToken = default)
{ {
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); try
var roleIds = roles.Select(r => r.Id).ToList();
context.Roles.RemoveRange(roles);
context.RoleLinks.RemoveRange(context.RoleLinks.Where(rl => roleIds.Contains(rl.RoleId)));
var removedRoles = await context.SaveChangesAsync(cancellationToken);
if (removedRoles != 0) return true;
logger.LogError("Failed to remove roles");
return false;
}
public async Task<bool> AddRolesLinkAsync(List<AuthorityRole> roles, Guid linkId, CancellationToken cancellationToken = default)
{
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
foreach (var role in roles)
{ {
context.RoleLinks.Add(new RoleLink { LinkId = linkId, RoleId = role.Id }); await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
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;
} }
var linkedRoles = await context.SaveChangesAsync(cancellationToken); catch (Exception e)
if (linkedRoles == roles.Count)
{ {
return true; return e;
} }
logger.LogError("Failed to link all given roles, {linkedRoles}/{totalRoles} roles linked!", linkedRoles, roles.Count);
return false;
} }
public async Task<List<AuthorityRole>> GetLinkedRolesAsync(List<Guid> linkIds, CancellationToken cancellationToken = default) public async Task<Result<AuthorityRole>> UpdateRoleAsync(AuthorityRole role, CancellationToken cancellationToken = default)
{ {
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); try
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); await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
return roleList.DistinctBy(r => r.Id).ToList(); 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)
{
return ResultError.Fail("Role version does not match, version validation failed!");
}
var entity = context.Roles.Update(role);
var saveResult = await context.SaveChangesAsync(cancellationToken);
return saveResult <= 0 ? ResultError.Fail("Failed to update role!") : entity.Entity;
}
catch (Exception e)
{
return e;
}
} }
public async Task<bool> UnlinkRolesAsync(List<AuthorityRole> roles, Guid linkId, CancellationToken cancellationToken = default) public async Task<Result> DeleteRolesAsync(List<AuthorityRole> roles, CancellationToken cancellationToken = default)
{ {
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); try
var roleIds = roles.Select(r => r.Id).ToList(); {
context.RoleLinks.RemoveRange(context.RoleLinks.Where(rg => rg.LinkId == linkId && roleIds.Contains(rg.RoleId))); await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
var unlinkedRoles = await context.SaveChangesAsync(cancellationToken); var roleIds = roles.Select(r => r.Id).ToList();
if (unlinkedRoles != 0) return true;
logger.LogError("Failed to remove linked roles"); context.Roles.RemoveRange(roles);
return false; context.RoleLinks.RemoveRange(context.RoleLinks.Where(rg => roleIds.Contains(rg.RoleId)));
var removeResult = await context.SaveChangesAsync(cancellationToken);
return removeResult == roles.Count? Result.Success() : ResultError.Fail($"Not all roles have been removed! {removeResult} of {roles.Count} roles removed!");
}
catch (Exception e)
{
return e;
}
} }
public async Task<List<Guid>> GetRolesFromLinkAsync(Guid linkId, List<AuthorityRole> roles, CancellationToken cancellationToken = default) public async Task<ListResultOld<AuthorityRoleItem>> GetUserRolesAsync(AuthorityUser user, int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default)
{ {
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); try
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 = 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 });
}
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)
{
try
{
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)
{
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);
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;
}
} }
} }

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

@ -1,147 +1,216 @@
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, ILogger<UserRepository> logger) : RepositoryBase, IUserRepository public class UserRepository(IDbContextFactory<AuthorityContext> contextFactory) : RepositoryBase, IUserRepository
{ {
public async Task<QueryItems<AuthorityUserItem>> GetAuthorityUsersAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default) public async Task<ListResultOld<AuthorityUserItem>> GetAuthorityUsersAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default)
{ {
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); try
var query = context.Users.AsQueryable();
if (!string.IsNullOrWhiteSpace(search))
{ {
query = query.Where(u => await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
$"{u.Id} {u.Name} {u.UserName} {u.EmailAddress} {u.PhoneNumber}".Contains(search, var query = context.Users.AsQueryable();
StringComparison.CurrentCultureIgnoreCase)); if (!string.IsNullOrWhiteSpace(search))
{
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);
} }
var totalCount = query.Count(); catch (Exception e)
var selected = await query.OrderBy(u => u.UserName).Skip(offset).Take(limit).Select(u => new AuthorityUserItem()
{ {
Id = u.Id, return HandleExceptionListResult<AuthorityUserItem>("Failed to get users.", e);
UserName = u.UserName, }
EmailAddress = u.EmailAddress,
PhoneNumber = u.PhoneNumber
}).ToListAsync(cancellationToken: cancellationToken);
return QueryItems<AuthorityUserItem>.Create(selected, totalCount, limit, offset);
} }
public async Task<AuthorityUser?> GetAuthorityUserByIdAsync(Guid id, CancellationToken cancellationToken = default) public async Task<ResultOld<AuthorityUser>> GetAuthorityUserByIdAsync(string id, CancellationToken cancellationToken = default)
{ {
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); try
if (id == Guid.Empty)
{ {
throw new Exception("Id is required!"); await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
} if (!Guid.TryParse(id, out var guid))
{
return ResultOld<AuthorityUser>.Failed("Invalid id!");
}
return await context.Users.Where(u => u.Id == id).Include(u => u.Attributes).FirstOrDefaultAsync(cancellationToken: cancellationToken); var user = await context.Users.Where(u => u.Id == guid).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<AuthorityUser?> CreateUserAsync(AuthorityUser user, CancellationToken cancellationToken = default) public async Task<ResultOld<AuthorityUser>> CreateUserAsync(AuthorityUser user, CancellationToken cancellationToken = default)
{ {
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); try
if (user.Id == Guid.Empty)
{ {
throw new Exception("User id is required!"); await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
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<AuthorityUser?> UpdateUserAsync(AuthorityUser user, CancellationToken cancellationToken = default) public async Task<ResultOld<AuthorityUser>> UpdateUserAsync(AuthorityUser user, CancellationToken cancellationToken = default)
{ {
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); try
var usr = await context.Users.FirstOrDefaultAsync(u => u.Id == user.Id, cancellationToken: cancellationToken);
if (usr == null)
{ {
throw new Exception("User not found!"); 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!");
}
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!");
}
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);
}
catch (Exception e)
{ {
throw new Exception("User does not have the correct security version!"); return HandleExceptionResult<AuthorityUser>("Failed to update user!", e);
} }
var entity = context.Users.Update(user);
var saveResult = await context.SaveChangesAsync(cancellationToken);
return saveResult != 0 ? entity.Entity : null;
} }
public async Task<bool> DeleteUsersAsync(List<AuthorityUser> users, CancellationToken cancellationToken = default) public async Task<ResultOld> DeleteUserAsync(AuthorityUser user, CancellationToken cancellationToken = default)
{ {
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); try
var usrIds = users.Select(u => u.Id);
context.Users.RemoveRange(users);
context.RoleLinks.RemoveRange(context.RoleLinks.Where(rl => usrIds.Contains(rl.LinkId)));
var removedResult = await context.SaveChangesAsync(cancellationToken);
if (removedResult != 0) return true;
logger.LogError("Failed to delete users");
return false;
}
public async Task<AuthorityUser?> GetUserByEmailAsync(string email, CancellationToken cancellationToken = default)
{
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
return await context.Users.Where(u => u.EmailAddress == email).Include(u => u.Attributes).FirstOrDefaultAsync(cancellationToken: cancellationToken);
}
public async Task<bool> SetVersionAsync(AuthorityUser user, long version, CancellationToken cancellationToken = default)
{
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
var usr = await context.Users.FirstOrDefaultAsync(u => u.Id == user.Id, cancellationToken);
if (usr == null)
{ {
throw new Exception("User not found!"); 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.Failed("User not found!");
}
context.Users.Remove(usr);
var saveResult = await context.SaveChangesAsync(cancellationToken);
return saveResult <= 0 ? ResultOld.Failed("Failed to delete user!") : ResultOld.Ok();
} }
catch (Exception e)
if (usr.Version != user.Version)
{ {
throw new Exception("User does not have the correct security version!"); return HandleException("Failed to delete user!", e);
} }
usr.Version = version;
context.Users.Update(usr);
var saveResult = await context.SaveChangesAsync(cancellationToken);
return saveResult != 0;
} }
public async Task<long> GetVersionAsync(AuthorityUser user, CancellationToken cancellationToken = default) public async Task<ResultOld<AuthorityUser>> GetUserByEmailAsync(string email, CancellationToken cancellationToken = default)
{ {
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); try
var usrVersion = await context.Users.Where(u => u.Id == user.Id).Select(u => u.Version).FirstOrDefaultAsync(cancellationToken); {
return usrVersion; 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<bool> SetSecurityVersionAsync(AuthorityUser user, long securityVersion, CancellationToken cancellationToken = default) public async Task<ResultOld> SetVersionAsync(AuthorityUser user, long version, CancellationToken cancellationToken = default)
{ {
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); try
var usr = await context.Users.FirstOrDefaultAsync(u => u.Id == user.Id, cancellationToken);
if (usr == null)
{ {
throw new Exception("User not found!"); 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!");
}
if (usr.SecurityVersion != user.SecurityVersion) if (usr.Version != user.Version)
{
return ResultOld.Failed("Stored user version doesn't match current user 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();
}
catch (Exception e)
{ {
throw new Exception("User does not have the correct security version!"); return HandleException("An error occured while updating the version.", e);
} }
usr.SecurityVersion = securityVersion;
context.Users.Update(usr);
var saveResult = await context.SaveChangesAsync(cancellationToken);
return saveResult != 0;
} }
public async Task<long> GetSecurityVersionAsync(AuthorityUser user, CancellationToken cancellationToken = default) public async Task<ResultOld<long>> GetVersionAsync(AuthorityUser user, CancellationToken cancellationToken = default)
{ {
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken); try
var usrVersion = await context.Users.Where(u => u.Id == user.Id).Select(u => u.SecurityVersion).FirstOrDefaultAsync(cancellationToken); {
return usrVersion; 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!");
}
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)
{
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!");
}
if (usr.SecurityVersion != user.SecurityVersion)
{
return ResultOld.Failed("Stored user version doesn't match current user 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();
}
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)
{
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!");
}
catch (Exception e)
{
return HandleExceptionResult<long>("An error occured while getting the user security version.", e);
}
} }
} }

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

@ -10,28 +10,18 @@ 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 success = await RoleRepository.DeleteRolesAsync(roles, cancellationToken); var result = await RoleRepository.DeleteRolesAsync(roles, cancellationToken);
return success ? Result.Success() : ResultError.Fail("Failed to delete roles."); return result;
} }
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;
} }
@ -41,98 +31,119 @@ public partial class AuthorityManager
return searchResult; return searchResult;
} }
public async Task<Result> AddRolesToUserAsync(List<AuthorityRole> roles, AuthorityUser user, CancellationToken cancellationToken = default) public async Task AddRolesToUserAsync(List<AuthorityRole> roles, AuthorityUser user, CancellationToken cancellationToken = default)
{ {
var usrValidation = await IsValidUserAsync(user, cancellationToken); var usrValidation = await IsValidUserAsync(user, cancellationToken);
if (!usrValidation.IsSuccess) if (!usrValidation.Success)
{ {
return usrValidation; _logger.Error(usrValidation.Exception ?? new Exception("Validation for user failed!"), "Invalid user!");
return;
} }
var linkedRoles = await RoleRepository.GetRolesFromLinkAsync(user.Id, roles, cancellationToken); var checkResult = await RoleRepository.HasRolesAsync(user.Id, roles, cancellationToken);
var hasRolesList = checkResult.Match<List<Guid>>(success: v => v, (_) => []);
var rolesToAdd = roles; var rolesToAdd = roles;
if (linkedRoles.Count != 0) if (hasRolesList.Count != 0)
{ {
rolesToAdd = roles.Where(r => !linkedRoles.Contains(r.Id)).ToList(); rolesToAdd = roles.Where(r => !hasRolesList.Contains(r.Id)).ToList();
} }
var addSuccess = await RoleRepository.AddRolesLinkAsync(rolesToAdd, user.Id, cancellationToken); var addResult = 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<Result> RemoveRolesFromUserAsync(List<AuthorityRole> roles, AuthorityUser user, CancellationToken cancellationToken = default) public async Task RemoveRolesFromUserAsync(List<AuthorityRole> roles, AuthorityUser user, CancellationToken cancellationToken = default)
{ {
var usrValidation = await IsValidUserAsync(user, cancellationToken); var usrValidation = await IsValidUserAsync(user, cancellationToken);
if (!usrValidation.IsSuccess) if (!usrValidation.Success)
{ {
return usrValidation; _logger.Error(usrValidation.Exception ?? new Exception("Validation for user failed!"), "Invalid user!");
return;
} }
var linkedRoles = await RoleRepository.GetRolesFromLinkAsync(user.Id, roles, cancellationToken); var checkResult = await RoleRepository.HasRolesAsync(user.Id, roles, cancellationToken);
var hasRolesList = checkResult.Match<List<Guid>>(success: v => v, (_) => []);
var rolesToRemove = roles; var rolesToRemove = roles;
if (linkedRoles.Count != 0) if (hasRolesList.Count != 0)
{ {
rolesToRemove = roles.Where(r => !linkedRoles.Contains(r.Id)).ToList(); rolesToRemove = roles.Where(r => !hasRolesList.Contains(r.Id)).ToList();
} }
var removeResult = await RoleRepository.UnlinkRolesAsync(rolesToRemove, user.Id, cancellationToken); var removeResult = await RoleRepository.DeleteRolesLinkAsync(rolesToRemove, user.Id, cancellationToken);
return removeResult ? Result.Success() : ResultError.Fail("Failed to remove roles."); removeResult.Match(() =>
{
_logger.Debug("Removed roles from user!");
}, e =>
{
_logger.Error(e.Exception ?? new Exception("Removing roles from user failed!"), e.Description);
});
} }
public async Task<Result> AddRolesToGroupAsync(List<AuthorityRole> roles, AuthorityGroup group, CancellationToken cancellationToken = default) public async Task AddRolesToGroupAsync(List<AuthorityRole> roles, AuthorityGroup group, CancellationToken cancellationToken = default)
{ {
var linkedRoles = await RoleRepository.GetRolesFromLinkAsync(group.Id, roles, cancellationToken); var checkResult = await RoleRepository.HasRolesAsync(group.Id, roles, cancellationToken);
var hasRolesList = checkResult.Match<List<Guid>>(success: v => v, (_) => []);
var rolesToAdd = roles; var rolesToAdd = roles;
if (linkedRoles.Count != 0) if (hasRolesList.Count != 0)
{ {
rolesToAdd = roles.Where(r => !linkedRoles.Contains(r.Id)).ToList(); rolesToAdd = roles.Where(r => !hasRolesList.Contains(r.Id)).ToList();
} }
var linkResult = await RoleRepository.AddRolesLinkAsync(rolesToAdd, group.Id, cancellationToken); var addResult = await RoleRepository.AddRolesLinkAsync(rolesToAdd, group.Id, cancellationToken);
return linkResult ? Result.Success() : ResultError.Fail("Failed to add roles."); addResult.Match(() =>
{
_logger.Debug("Added roles to group.");
}, e =>
{
_logger.Error(e.Exception ?? new Exception("Adding roles to group failed!"), e.Description);
});
} }
public async Task<Result<List<AuthorityRole>>> GetAllUserRolesAsync(AuthorityUser user, CancellationToken cancellationToken = default) /// <summary>
/// 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)
{ {
try var usrValidation = await IsValidUserAsync(user, cancellationToken);
if (!usrValidation.Success)
{ {
var usrValidation = await IsValidUserAsync(user, cancellationToken); return ResultError.Fail("Invalid user");
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)
{ {
return e; searchIds.AddRange(usrGroups.Items.Select(g => g.Id).ToList());
} }
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)
{ {
try var linkedRolesResult = await RoleRepository.GetLinkedRolesAsync(groupIds, cancellationToken);
return linkedRolesResult.Match<List<AuthorityRole>>(roles => roles, e =>
{ {
var linkedRolesResult = await RoleRepository.GetLinkedRolesAsync(groupIds, cancellationToken); _logger.Error(e.Exception ?? new Exception("Failed to get group roles!"), e.Description);
return linkedRolesResult; return [];
} });
catch (Exception e)
{
return e;
}
} }
} }

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

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

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

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

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

@ -0,0 +1,21 @@
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
View File

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

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

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

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

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

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

@ -1,7 +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.Models.Validation;
using DotBased.AspNet.Authority.Monads;
namespace DotBased.AspNet.Authority.Validators; namespace DotBased.AspNet.Authority.Validators;
@ -18,6 +17,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.Fail(errors) : ValidationResult.Success(); return errors.Count > 0 ? ValidationResult.Failed(errors) : ValidationResult.Ok();
} }
} }

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

@ -1,7 +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.Models.Validation;
using DotBased.AspNet.Authority.Monads;
using DotBased.Extensions; using DotBased.Extensions;
namespace DotBased.AspNet.Authority.Validators; namespace DotBased.AspNet.Authority.Validators;
@ -58,7 +57,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.Fail(errors) : ValidationResult.Success()); return await Task.FromResult(errors.Count > 0 ? ValidationResult.Failed(errors) : ValidationResult.Ok());
} }
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,7 +2,6 @@ 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;
@ -54,7 +53,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.Fail(errors) : ValidationResult.Success(); if (chars.Count <= 0) return errors.Count > 0 ? ValidationResult.Failed(errors) : ValidationResult.Ok();
var errorCode = ""; var errorCode = "";
var description = ""; var description = "";
switch (userOptions.UserNameCharacterListType) switch (userOptions.UserNameCharacterListType)
@ -77,6 +76,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.Fail(errors) : ValidationResult.Success(); return errors.Count > 0 ? ValidationResult.Failed(errors) : ValidationResult.Ok();
} }
} }