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

[CHANGE] Reworking Result monads

Browse Source
This commit is contained in:
max 2025-04-07 14:59:37 +02:00
parent bb010b0cea
commit 0a5950cfa2
24 changed files with 390 additions and 322 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
DotBased.ASP.Auth/AuthDataCache.cs
View File

@ -15,26 +15,26 @@ public class AuthDataCache
private readonly AuthStateCacheCollection<AuthenticationStateModel, AuthenticationState> _authenticationStateCollection = [];
public Result PurgeSessionState(string id) => _authenticationStateCollection.Remove(id) ? Result.Ok() : Result.Failed("Failed to purge session state from cache! Or the session was not cached...");
public ResultOld PurgeSessionState(string id) => _authenticationStateCollection.Remove(id) ? ResultOld.Ok() : ResultOld.Failed("Failed to purge session state from cache! Or the session was not cached...");
public void CacheSessionState(AuthenticationStateModel stateModel, AuthenticationState? state = null) => _authenticationStateCollection[stateModel.Id] =
new AuthStateCacheNode<AuthenticationStateModel, AuthenticationState>(stateModel, state);
public Result<Tuple<AuthenticationStateModel, AuthenticationState?>> RequestSessionState(string id)
public ResultOld<Tuple<AuthenticationStateModel, AuthenticationState?>> RequestSessionState(string id)
{
if (!_authenticationStateCollection.TryGetValue(id, out var node))
return Result<Tuple<AuthenticationStateModel, AuthenticationState?>>.Failed("No cached object found!");
return ResultOld<Tuple<AuthenticationStateModel, AuthenticationState?>>.Failed("No cached object found!");
string failedMsg;
if (node.StateModel != null)
{
if (node.IsValidLifespan(_configuration.CachedAuthSessionLifespan))
return Result<Tuple<AuthenticationStateModel, AuthenticationState?>>.Ok(new Tuple<AuthenticationStateModel, AuthenticationState?>(node.StateModel, node.State));
return ResultOld<Tuple<AuthenticationStateModel, AuthenticationState?>>.Ok(new Tuple<AuthenticationStateModel, AuthenticationState?>(node.StateModel, node.State));
failedMsg = $"Session has invalid lifespan, removing entry: [{id}] from cache!";
}
else
failedMsg = $"Returned object is null, removing entry: [{id}] from cache!";
_authenticationStateCollection.Remove(id);
return Result<Tuple<AuthenticationStateModel, AuthenticationState?>>.Failed(failedMsg);
return ResultOld<Tuple<AuthenticationStateModel, AuthenticationState?>>.Failed(failedMsg);
}
}

28
DotBased.ASP.Auth/IAuthDataRepository.cs
View File

@ -5,18 +5,18 @@ namespace DotBased.ASP.Auth;
public interface IAuthDataRepository
{
public Task<Result> CreateUserAsync(UserModel user);
public Task<Result> UpdateUserAsync(UserModel user);
public Task<Result> DeleteUserAsync(UserModel user);
public Task<Result<UserModel>> GetUserAsync(string id, string email, string username);
public Task<ListResult<UserItemModel>> GetUsersAsync(int start = 0, int amount = 30, string search = "");
public Task<Result> CreateGroupAsync(GroupModel group);
public Task<Result> UpdateGroupAsync(GroupModel group);
public Task<Result> DeleteGroupAsync(GroupModel group);
public Task<Result<GroupModel>> GetGroupAsync(string id);
public Task<ListResult<GroupItemModel>> GetGroupsAsync(int start = 0, int amount = 30, string search = "");
public Task<Result> CreateAuthenticationStateAsync(AuthenticationStateModel authenticationState);
public Task<Result> UpdateAuthenticationStateAsync(AuthenticationStateModel authenticationState);
public Task<Result> DeleteAuthenticationStateAsync(AuthenticationStateModel authenticationState);
public Task<Result<AuthenticationStateModel>> GetAuthenticationStateAsync(string id);
public Task<ResultOld> CreateUserAsync(UserModel user);
public Task<ResultOld> UpdateUserAsync(UserModel user);
public Task<ResultOld> DeleteUserAsync(UserModel user);
public Task<ResultOld<UserModel>> GetUserAsync(string id, string email, string username);
public Task<ListResultOld<UserItemModel>> GetUsersAsync(int start = 0, int amount = 30, string search = "");
public Task<ResultOld> CreateGroupAsync(GroupModel group);
public Task<ResultOld> UpdateGroupAsync(GroupModel group);
public Task<ResultOld> DeleteGroupAsync(GroupModel group);
public Task<ResultOld<GroupModel>> GetGroupAsync(string id);
public Task<ListResultOld<GroupItemModel>> GetGroupsAsync(int start = 0, int amount = 30, string search = "");
public Task<ResultOld> CreateAuthenticationStateAsync(AuthenticationStateModel authenticationState);
public Task<ResultOld> UpdateAuthenticationStateAsync(AuthenticationStateModel authenticationState);
public Task<ResultOld> DeleteAuthenticationStateAsync(AuthenticationStateModel authenticationState);
public Task<ResultOld<AuthenticationStateModel>> GetAuthenticationStateAsync(string id);
}

4
DotBased.ASP.Auth/ISessionStateProvider.cs
View File

@ -3,6 +3,6 @@ namespace DotBased.ASP.Auth;
public interface ISessionStateProvider
{
public const string SessionStateName = "BasedServerSession";
public Task<Result<string>> GetSessionStateAsync();
public Task<Result> SetSessionStateAsync(string state);
public Task<ResultOld<string>> GetSessionStateAsync();
public Task<ResultOld> SetSessionStateAsync(string state);
}

48
DotBased.ASP.Auth/MemoryAuthDataRepository.cs
View File

@ -10,28 +10,28 @@ namespace DotBased.ASP.Auth;
[SuppressMessage("ReSharper", "CollectionNeverUpdated.Local")]
public class MemoryAuthDataRepository : IAuthDataRepository
{
public async Task<Result> CreateUserAsync(UserModel user)
public async Task<ResultOld> CreateUserAsync(UserModel user)
{
if (MemoryData.users.Any(x => x.Id == user.Id || x.Email == user.Email))
return Result.Failed("User already exists.");
return ResultOld.Failed("User already exists.");
MemoryData.users.Add(user);
return Result.Ok();
return ResultOld.Ok();
}
public async Task<Result> UpdateUserAsync(UserModel user)
public async Task<ResultOld> UpdateUserAsync(UserModel user)
{
if (MemoryData.users.All(x => x.Id != user.Id))
return Result.Failed("User does not exist!");
return ResultOld.Failed("User does not exist!");
return Result.Ok();
return ResultOld.Ok();
}
public Task<Result> DeleteUserAsync(UserModel user)
public Task<ResultOld> DeleteUserAsync(UserModel user)
{
throw new NotImplementedException();
}
public async Task<Result<UserModel>> GetUserAsync(string id, string email, string username)
public async Task<ResultOld<UserModel>> GetUserAsync(string id, string email, string username)
{
UserModel? userModel = null;
if (!id.IsNullOrEmpty())
@ -40,62 +40,62 @@ public class MemoryAuthDataRepository : IAuthDataRepository
userModel = MemoryData.users.FirstOrDefault(u => u.Email.Equals(email, StringComparison.OrdinalIgnoreCase));
if (!username.IsNullOrEmpty())
userModel = MemoryData.users.FirstOrDefault(u => u.UserName.Equals(username, StringComparison.OrdinalIgnoreCase));
return userModel != null ? Result<UserModel>.Ok(userModel) : Result<UserModel>.Failed("No user found!");
return userModel != null ? ResultOld<UserModel>.Ok(userModel) : ResultOld<UserModel>.Failed("No user found!");
}
public Task<ListResult<UserItemModel>> GetUsersAsync(int start = 0, int amount = 30, string search = "")
public Task<ListResultOld<UserItemModel>> GetUsersAsync(int start = 0, int amount = 30, string search = "")
{
throw new NotImplementedException();
}
public Task<Result> CreateGroupAsync(GroupModel group)
public Task<ResultOld> CreateGroupAsync(GroupModel group)
{
throw new NotImplementedException();
}
public Task<Result> UpdateGroupAsync(GroupModel group)
public Task<ResultOld> UpdateGroupAsync(GroupModel group)
{
throw new NotImplementedException();
}
public Task<Result> DeleteGroupAsync(GroupModel group)
public Task<ResultOld> DeleteGroupAsync(GroupModel group)
{
throw new NotImplementedException();
}
public Task<Result<GroupModel>> GetGroupAsync(string id)
public Task<ResultOld<GroupModel>> GetGroupAsync(string id)
{
throw new NotImplementedException();
}
public Task<ListResult<GroupItemModel>> GetGroupsAsync(int start = 0, int amount = 30, string search = "")
public Task<ListResultOld<GroupItemModel>> GetGroupsAsync(int start = 0, int amount = 30, string search = "")
{
throw new NotImplementedException();
}
public async Task<Result> CreateAuthenticationStateAsync(AuthenticationStateModel authenticationState)
public async Task<ResultOld> CreateAuthenticationStateAsync(AuthenticationStateModel authenticationState)
{
if (MemoryData.AuthenticationStates.Contains(authenticationState)) return Result.Failed("Item already exists!");
if (MemoryData.AuthenticationStates.Contains(authenticationState)) return ResultOld.Failed("Item already exists!");
MemoryData.AuthenticationStates.Add(authenticationState);
return Result.Ok();
return ResultOld.Ok();
}
public Task<Result> UpdateAuthenticationStateAsync(AuthenticationStateModel authenticationState)
public Task<ResultOld> UpdateAuthenticationStateAsync(AuthenticationStateModel authenticationState)
{
throw new NotImplementedException();
}
public async Task<Result> DeleteAuthenticationStateAsync(AuthenticationStateModel authenticationState)
public async Task<ResultOld> DeleteAuthenticationStateAsync(AuthenticationStateModel authenticationState)
{
MemoryData.AuthenticationStates.Remove(authenticationState);
return Result.Ok();
return ResultOld.Ok();
}
public async Task<Result<AuthenticationStateModel>> GetAuthenticationStateAsync(string id)
public async Task<ResultOld<AuthenticationStateModel>> GetAuthenticationStateAsync(string id)
{
var item = MemoryData.AuthenticationStates.FirstOrDefault(x => x.Id == id);
if (item == null) return Result<AuthenticationStateModel>.Failed("Could not get the session state!");
return Result<AuthenticationStateModel>.Ok(item);
if (item == null) return ResultOld<AuthenticationStateModel>.Failed("Could not get the session state!");
return ResultOld<AuthenticationStateModel>.Ok(item);
}
}

48
DotBased.ASP.Auth/SecurityService.cs
View File

@ -24,10 +24,10 @@ public class SecurityService
private readonly ProtectedLocalStorage _localStorage;
private readonly ILogger _logger;
public async Task<Result<AuthenticationState>> GetAuthenticationStateFromSessionAsync(string id)
public async Task<ResultOld<AuthenticationState>> GetAuthenticationStateFromSessionAsync(string id)
{
if (id.IsNullOrEmpty())
return Result<AuthenticationState>.Failed("No valid id!");
return ResultOld<AuthenticationState>.Failed("No valid id!");
AuthenticationStateModel? authStateModel = null;
var stateCache = _dataCache.RequestSessionState(id);
if (!stateCache.Success || stateCache.Value == null)
@ -42,16 +42,16 @@ public class SecurityService
else
{
if (stateCache.Value.Item2 != null)
return Result<AuthenticationState>.Ok(stateCache.Value.Item2);
return ResultOld<AuthenticationState>.Ok(stateCache.Value.Item2);
authStateModel = stateCache.Value.Item1;
}
if (authStateModel == null)
return Result<AuthenticationState>.Failed("Failed to get auth state!");
return ResultOld<AuthenticationState>.Failed("Failed to get auth state!");
var userResult = await _authDataRepository.GetUserAsync(authStateModel.UserId, string.Empty, string.Empty);
if (userResult is not { Success: true, Value: not null })
return Result<AuthenticationState>.Failed("Failed to get user from state!");
return ResultOld<AuthenticationState>.Failed("Failed to get user from state!");
var claims = new List<Claim>()
{
new(ClaimTypes.Sid, userResult.Value.Id),
@ -66,56 +66,56 @@ public class SecurityService
var claimsIdentity = new ClaimsIdentity(claims, BasedAuthDefaults.AuthenticationScheme);
var authState = new AuthenticationState(new ClaimsPrincipal(claimsIdentity));
_dataCache.CacheSessionState(authStateModel, authState);
return Result<AuthenticationState>.Ok(authState);
return ResultOld<AuthenticationState>.Ok(authState);
}
public async Task<Result<AuthenticationStateModel>> LoginAsync(LoginModel login)
public async Task<ResultOld<AuthenticationStateModel>> LoginAsync(LoginModel login)
{
try
{
UserModel? user = null;
Result<UserModel> usrResult;
ResultOld<UserModel> usrResultOld;
if (!login.UserName.IsNullOrEmpty())
{
usrResult = await _authDataRepository.GetUserAsync(string.Empty, string.Empty, login.UserName);
if (usrResult is { Success: true, Value: not null })
user = usrResult.Value;
usrResultOld = await _authDataRepository.GetUserAsync(string.Empty, string.Empty, login.UserName);
if (usrResultOld is { Success: true, Value: not null })
user = usrResultOld.Value;
}
else if (!login.Email.IsNullOrEmpty())
{
usrResult = await _authDataRepository.GetUserAsync(string.Empty, login.Email, string.Empty);
if (usrResult is { Success: true, Value: not null })
user = usrResult.Value;
usrResultOld = await _authDataRepository.GetUserAsync(string.Empty, login.Email, string.Empty);
if (usrResultOld is { Success: true, Value: not null })
user = usrResultOld.Value;
}
else
return Result<AuthenticationStateModel>.Failed("Username & Email is empty, cannot login!");
return ResultOld<AuthenticationStateModel>.Failed("Username & Email is empty, cannot login!");
if (user == null || !usrResult.Success)
return Result<AuthenticationStateModel>.Failed("No user found!");
if (user == null || !usrResultOld.Success)
return ResultOld<AuthenticationStateModel>.Failed("No user found!");
if (user.PasswordHash != login.Password) //TODO: Hash password and compare
return Result<AuthenticationStateModel>.Failed("Login failed, invalid password.");
return ResultOld<AuthenticationStateModel>.Failed("Login failed, invalid password.");
var state = new AuthenticationStateModel(user);
var authResult = await _authDataRepository.CreateAuthenticationStateAsync(state);
if (!authResult.Success)
return Result<AuthenticationStateModel>.Failed("Failed to store session to database!");
return ResultOld<AuthenticationStateModel>.Failed("Failed to store session to database!");
_dataCache.CacheSessionState(state);
await _localStorage.SetAsync(BasedAuthDefaults.StorageKey, state.Id);
return Result<AuthenticationStateModel>.Ok(state);
return ResultOld<AuthenticationStateModel>.Ok(state);
}
catch (Exception e)
{
_logger.Error(e, "Failed to login!");
return Result<AuthenticationStateModel>.Failed("Login failed, exception thrown!");
return ResultOld<AuthenticationStateModel>.Failed("Login failed, exception thrown!");
}
}
public async Task<Result> LogoutAsync(string state)
public async Task<ResultOld> LogoutAsync(string state)
{
try
{
if (state.IsNullOrEmpty())
return Result.Failed($"Argument {nameof(state)} is empty!");
return ResultOld.Failed($"Argument {nameof(state)} is empty!");
var stateResult = await _authDataRepository.GetAuthenticationStateAsync(state);
if (!stateResult.Success || stateResult.Value == null)
@ -131,7 +131,7 @@ public class SecurityService
catch (Exception e)
{
_logger.Error(e, "Failed to logout!");
return Result.Failed("Failed to logout, exception thrown!");
return ResultOld.Failed("Failed to logout, exception thrown!");
}
}
}

28
DotBased.AspNet.Authority.EFCore/Repositories/AttributeRepository.cs
View File

@ -6,7 +6,7 @@ namespace DotBased.AspNet.Authority.EFCore.Repositories;
public class AttributeRepository(IDbContextFactory<AuthorityContext> contextFactory) : RepositoryBase, IAttributeRepository
{
public async Task<ListResult<AuthorityAttributeItem>> GetAttributesAsync(int limit = 20, int offset = 0, string search = "",
public async Task<ListResultOld<AuthorityAttributeItem>> GetAttributesAsync(int limit = 20, int offset = 0, string search = "",
CancellationToken cancellationToken = default)
{
try
@ -25,7 +25,7 @@ public class AttributeRepository(IDbContextFactory<AuthorityContext> contextFact
AttributeKey = a.AttributeKey,
AttributeValue = a.AttributeValue
}).ToListAsync(cancellationToken);
return ListResult<AuthorityAttributeItem>.Ok(select, total, limit, offset);
return ListResultOld<AuthorityAttributeItem>.Ok(select, total, limit, offset);
}
catch (Exception e)
{
@ -33,13 +33,13 @@ public class AttributeRepository(IDbContextFactory<AuthorityContext> contextFact
}
}
public async Task<Result<AuthorityAttribute>> GetAttributeByKeyAsync(string key, CancellationToken cancellationToken = default)
public async Task<ResultOld<AuthorityAttribute>> GetAttributeByKeyAsync(string key, CancellationToken cancellationToken = default)
{
try
{
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
var attribute = await context.Attributes.FirstOrDefaultAsync(a => a.AttributeKey == key, cancellationToken);
return attribute == null ? Result<AuthorityAttribute>.Failed("Attribute not found") : Result<AuthorityAttribute>.Ok(attribute);
return attribute == null ? ResultOld<AuthorityAttribute>.Failed("Attribute not found") : ResultOld<AuthorityAttribute>.Ok(attribute);
}
catch (Exception e)
{
@ -47,18 +47,18 @@ public class AttributeRepository(IDbContextFactory<AuthorityContext> contextFact
}
}
public async Task<Result<AuthorityAttribute>> CreateAttributeAsync(AuthorityAttribute attribute, CancellationToken cancellationToken = default)
public async Task<ResultOld<AuthorityAttribute>> CreateAttributeAsync(AuthorityAttribute attribute, CancellationToken cancellationToken = default)
{
try
{
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
if (string.IsNullOrWhiteSpace(attribute.AttributeKey) || attribute.ForeignKey == Guid.Empty)
{
return Result<AuthorityAttribute>.Failed("Attribute key and/or bound id is empty");
return ResultOld<AuthorityAttribute>.Failed("Attribute key and/or bound id is empty");
}
var entry = context.Attributes.Add(attribute);
var saveResult = await context.SaveChangesAsync(cancellationToken);
return saveResult <= 0 ? Result<AuthorityAttribute>.Failed("Failed to create attribute") : Result<AuthorityAttribute>.Ok(entry.Entity);
return saveResult <= 0 ? ResultOld<AuthorityAttribute>.Failed("Failed to create attribute") : ResultOld<AuthorityAttribute>.Ok(entry.Entity);
}
catch (Exception e)
{
@ -66,7 +66,7 @@ public class AttributeRepository(IDbContextFactory<AuthorityContext> contextFact
}
}
public async Task<Result<AuthorityAttribute>> UpdateAttributeAsync(AuthorityAttribute attribute, CancellationToken cancellationToken = default)
public async Task<ResultOld<AuthorityAttribute>> UpdateAttributeAsync(AuthorityAttribute attribute, CancellationToken cancellationToken = default)
{
try
{
@ -74,17 +74,17 @@ public class AttributeRepository(IDbContextFactory<AuthorityContext> contextFact
var currentAttribute = await context.Attributes.FirstOrDefaultAsync(a => a.AttributeKey == attribute.AttributeKey, cancellationToken);
if (currentAttribute == null)
{
return Result<AuthorityAttribute>.Failed("Attribute not found");
return ResultOld<AuthorityAttribute>.Failed("Attribute not found");
}
if (currentAttribute.Version != attribute.Version)
{
return Result<AuthorityAttribute>.Failed("Attribute version doesn't match");
return ResultOld<AuthorityAttribute>.Failed("Attribute version doesn't match");
}
var entry = context.Attributes.Update(currentAttribute);
var saveResult = await context.SaveChangesAsync(cancellationToken);
return saveResult <= 0 ? Result<AuthorityAttribute>.Failed("Failed to update attribute") : Result<AuthorityAttribute>.Ok(entry.Entity);
return saveResult <= 0 ? ResultOld<AuthorityAttribute>.Failed("Failed to update attribute") : ResultOld<AuthorityAttribute>.Ok(entry.Entity);
}
catch (Exception e)
{
@ -92,7 +92,7 @@ public class AttributeRepository(IDbContextFactory<AuthorityContext> contextFact
}
}
public async Task<Result> DeleteAttributeAsync(AuthorityAttribute attribute, CancellationToken cancellationToken = default)
public async Task<ResultOld> DeleteAttributeAsync(AuthorityAttribute attribute, CancellationToken cancellationToken = default)
{
try
{
@ -100,11 +100,11 @@ public class AttributeRepository(IDbContextFactory<AuthorityContext> contextFact
var currentAttribute = await context.Attributes.FirstOrDefaultAsync(a => a.AttributeKey == attribute.AttributeKey, cancellationToken);
if (currentAttribute == null)
{
return Result.Failed("Attribute not found");
return ResultOld.Failed("Attribute not found");
}
context.Attributes.Remove(currentAttribute);
var saveResult = await context.SaveChangesAsync(cancellationToken);
return saveResult <= 0 ? Result.Failed("Failed to delete attribute") : Result.Ok();
return saveResult <= 0 ? ResultOld.Failed("Failed to delete attribute") : ResultOld.Ok();
}
catch (Exception e)
{

34
DotBased.AspNet.Authority.EFCore/Repositories/GroupRepository.cs
View File

@ -6,7 +6,7 @@ namespace DotBased.AspNet.Authority.EFCore.Repositories;
public class GroupRepository(IDbContextFactory<AuthorityContext> contextFactory) : RepositoryBase, IGroupRepository
{
public async Task<ListResult<AuthorityGroupItem>> GetGroupsAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default)
public async Task<ListResultOld<AuthorityGroupItem>> GetGroupsAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default)
{
try
{
@ -22,7 +22,7 @@ public class GroupRepository(IDbContextFactory<AuthorityContext> contextFactory)
Id = g.Id,
Name = g.Name
}).ToListAsync(cancellationToken);
return ListResult<AuthorityGroupItem>.Ok(select, total, limit, offset);
return ListResultOld<AuthorityGroupItem>.Ok(select, total, limit, offset);
}
catch (Exception e)
{
@ -30,17 +30,17 @@ public class GroupRepository(IDbContextFactory<AuthorityContext> contextFactory)
}
}
public async Task<Result<AuthorityGroup>> GetGroupByIdAsync(string id, CancellationToken cancellationToken = default)
public async Task<ResultOld<AuthorityGroup>> GetGroupByIdAsync(string id, CancellationToken cancellationToken = default)
{
try
{
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
if (!Guid.TryParse(id, out var groupId))
{
return Result<AuthorityGroup>.Failed("Invalid group id");
return ResultOld<AuthorityGroup>.Failed("Invalid group id");
}
var group = await context.Groups.Where(g => g.Id == groupId).Include(g => g.Attributes).FirstOrDefaultAsync(cancellationToken: cancellationToken);
return Result<AuthorityGroup>.HandleResult(group, "Group not found");
return ResultOld<AuthorityGroup>.HandleResult(group, "Group not found");
}
catch (Exception e)
{
@ -48,14 +48,14 @@ public class GroupRepository(IDbContextFactory<AuthorityContext> contextFactory)
}
}
public async Task<ListResult<AuthorityGroup>> GetUserGroupsAsync(AuthorityUser user, CancellationToken cancellationToken = default)
public async Task<ListResultOld<AuthorityGroup>> GetUserGroupsAsync(AuthorityUser user, CancellationToken cancellationToken = default)
{
try
{
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
var userJoinGroups = context.UserGroups.Where(ug => ug.UserId == user.Id).Select(ug => ug.GroupId);
var userGroups = context.Groups.Where(g => userJoinGroups.Contains(g.Id));
return ListResult<AuthorityGroup>.Ok(userGroups, userGroups.Count());
return ListResultOld<AuthorityGroup>.Ok(userGroups, userGroups.Count());
}
catch (Exception e)
{
@ -63,18 +63,18 @@ public class GroupRepository(IDbContextFactory<AuthorityContext> contextFactory)
}
}
public async Task<Result<AuthorityGroup>> CreateGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default)
public async Task<ResultOld<AuthorityGroup>> CreateGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default)
{
try
{
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
if (group.Id == Guid.Empty)
{
return Result<AuthorityGroup>.Failed("Id cannot be empty.");
return ResultOld<AuthorityGroup>.Failed("Id cannot be empty.");
}
var entry = context.Groups.Add(group);
var saveResult = await context.SaveChangesAsync(cancellationToken);
return saveResult <= 0 ? Result<AuthorityGroup>.Failed("Failed to create group.") : Result<AuthorityGroup>.Ok(entry.Entity);
return saveResult <= 0 ? ResultOld<AuthorityGroup>.Failed("Failed to create group.") : ResultOld<AuthorityGroup>.Ok(entry.Entity);
}
catch (Exception e)
{
@ -82,7 +82,7 @@ public class GroupRepository(IDbContextFactory<AuthorityContext> contextFactory)
}
}
public async Task<Result<AuthorityGroup>> UpdateGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default)
public async Task<ResultOld<AuthorityGroup>> UpdateGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default)
{
try
{
@ -90,17 +90,17 @@ public class GroupRepository(IDbContextFactory<AuthorityContext> contextFactory)
var currentGroup = await context.Groups.FirstOrDefaultAsync(g => g.Id == group.Id ,cancellationToken);
if (currentGroup == null)
{
return Result<AuthorityGroup>.Failed("Group not found.");
return ResultOld<AuthorityGroup>.Failed("Group not found.");
}
if (currentGroup.Version != group.Version)
{
return Result<AuthorityGroup>.Failed("Group version does not match, version validation failed!");
return ResultOld<AuthorityGroup>.Failed("Group version does not match, version validation failed!");
}
var entry = context.Groups.Update(group);
var saveResult = await context.SaveChangesAsync(cancellationToken);
return saveResult <= 0 ? Result<AuthorityGroup>.Failed("Failed to update group.") : Result<AuthorityGroup>.Ok(entry.Entity);
return saveResult <= 0 ? ResultOld<AuthorityGroup>.Failed("Failed to update group.") : ResultOld<AuthorityGroup>.Ok(entry.Entity);
}
catch (Exception e)
{
@ -108,7 +108,7 @@ public class GroupRepository(IDbContextFactory<AuthorityContext> contextFactory)
}
}
public async Task<Result> DeleteGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default)
public async Task<ResultOld> DeleteGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default)
{
try
{
@ -116,11 +116,11 @@ public class GroupRepository(IDbContextFactory<AuthorityContext> contextFactory)
var currentGroup = await context.Groups.FirstOrDefaultAsync(g => g.Id == group.Id, cancellationToken);
if (currentGroup == null)
{
return Result.Failed("Group not found, cannot delete group!");
return ResultOld.Failed("Group not found, cannot delete group!");
}
context.Groups.Remove(currentGroup);
var saveResult = await context.SaveChangesAsync(cancellationToken);
return saveResult <= 0 ? Result.Failed("Failed to delete group.") : Result.Ok();
return saveResult <= 0 ? ResultOld.Failed("Failed to delete group.") : ResultOld.Ok();
}
catch (Exception e)
{

10
DotBased.AspNet.Authority.EFCore/Repositories/RepositoryBase.cs
View File

@ -2,18 +2,18 @@ namespace DotBased.AspNet.Authority.EFCore.Repositories;
public abstract class RepositoryBase
{
protected Result<T> HandleExceptionResult<T>(string message, Exception ex) => new(HandleException(message, ex));
protected ResultOld<T> HandleExceptionResult<T>(string message, Exception ex) => new(HandleException(message, ex));
protected ListResult<T> HandleExceptionListResult<T>(string message, Exception ex) =>
protected ListResultOld<T> HandleExceptionListResult<T>(string message, Exception ex) =>
new(HandleException(message, ex));
protected Result HandleException(string message, Exception ex)
protected ResultOld HandleException(string message, Exception ex)
{
if (ex is OperationCanceledException oce)
{
return Result.Failed("Operation cancelled.", oce);
return ResultOld.Failed("Operation cancelled.", oce);
}
return Result.Failed(message, ex);
return ResultOld.Failed(message, ex);
}
}

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

@ -1,6 +1,8 @@
using DotBased.AspNet.Authority.EFCore.Models;
using DotBased.AspNet.Authority.Models;
using DotBased.AspNet.Authority.Models.Authority;
using DotBased.AspNet.Authority.Repositories;
using DotBased.Monads;
using Microsoft.EntityFrameworkCore;
namespace DotBased.AspNet.Authority.EFCore.Repositories;
@ -8,7 +10,7 @@ namespace DotBased.AspNet.Authority.EFCore.Repositories;
public class RoleRepository(IDbContextFactory<AuthorityContext> contextFactory) : RepositoryBase, IRoleRepository
{
public async Task<ListResult<AuthorityRoleItem>> GetRolesAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default)
public async Task<Result<QueryItems<AuthorityRoleItem>>> GetRolesAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default)
{
try
{
@ -26,29 +28,29 @@ public class RoleRepository(IDbContextFactory<AuthorityContext> contextFactory)
Id = r.Id,
Name = r.Name
}).ToListAsync(cancellationToken: cancellationToken);
return ListResult<AuthorityRoleItem>.Ok(select, total, limit, offset);
return QueryItems<AuthorityRoleItem>.Create(select, total, limit, offset);
}
catch (Exception e)
{
return HandleExceptionListResult<AuthorityRoleItem>("Failed to get roles.", e);
return e;
}
}
public async Task<Result<AuthorityRole>> GetRoleByIdAsync(string id, CancellationToken cancellationToken = default)
public async Task<Result<AuthorityRole>> GetRoleByIdAsync(Guid id, CancellationToken cancellationToken = default)
{
try
{
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
if (!Guid.TryParse(id, out var guid))
var role = await context.Roles.Where(r => r.Id == id).Include(r => r.Attributes).FirstOrDefaultAsync(cancellationToken: cancellationToken);
if (role != null)
{
return Result<AuthorityRole>.Failed("Invalid id!");
return role;
}
var role = await context.Roles.Where(r => r.Id == guid).Include(r => r.Attributes).FirstOrDefaultAsync(cancellationToken: cancellationToken);
return Result<AuthorityRole>.HandleResult(role, "Role not found!");
return ResultError.Fail("Role not found!");
}
catch (Exception e)
{
return HandleExceptionResult<AuthorityRole>("Failed to get role!", e);
return e;
}
}
@ -59,15 +61,15 @@ public class RoleRepository(IDbContextFactory<AuthorityContext> contextFactory)
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
if (role.Id == Guid.Empty)
{
return Result<AuthorityRole>.Failed("Id cannot be empty!");
return ResultError.Fail("Id cannot be empty!");
}
var entity = context.Roles.Add(role);
var saveResult = await context.SaveChangesAsync(cancellationToken);
return saveResult <= 0 ? Result<AuthorityRole>.Failed("Failed to create role!") : Result<AuthorityRole>.Ok(entity.Entity);
return saveResult <= 0 ? ResultError.Fail("Failed to create role!") : entity.Entity;
}
catch (Exception e)
{
return HandleExceptionResult<AuthorityRole>("Failed to create role!", e);
return e;
}
}
@ -79,21 +81,21 @@ public class RoleRepository(IDbContextFactory<AuthorityContext> contextFactory)
var currentRole = await context.Roles.FirstOrDefaultAsync(r => r.Id == role.Id, cancellationToken: cancellationToken);
if (currentRole == null)
{
return Result<AuthorityRole>.Failed("Role not found!");
return ResultError.Fail("Role not found!");
}
if (role.Version != currentRole.Version)
{
return Result<AuthorityRole>.Failed("Role version does not match, version validation failed!");
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 ? Result<AuthorityRole>.Failed("Failed to update role!") : Result<AuthorityRole>.Ok(entity.Entity);
return saveResult <= 0 ? ResultError.Fail("Failed to update role!") : entity.Entity;
}
catch (Exception e)
{
return HandleExceptionResult<AuthorityRole>("Failed to update role!", e);
return e;
}
}
@ -107,16 +109,16 @@ public class RoleRepository(IDbContextFactory<AuthorityContext> contextFactory)
context.Roles.RemoveRange(roles);
context.RoleLinks.RemoveRange(context.RoleLinks.Where(rg => roleIds.Contains(rg.RoleId)));
var saveResult = await context.SaveChangesAsync(cancellationToken);
return saveResult <= 0 ? Result.Failed("Failed to delete roles!") : Result.Ok();
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 HandleException("Failed to delete role!", e);
return e;
}
}
public async Task<ListResult<AuthorityRoleItem>> GetUserRolesAsync(AuthorityUser user, int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default)
public async Task<ListResultOld<AuthorityRoleItem>> GetUserRolesAsync(AuthorityUser user, int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default)
{
try
{
@ -133,7 +135,7 @@ public class RoleRepository(IDbContextFactory<AuthorityContext> contextFactory)
Id = r.Id,
Name = r.Name
});
return ListResult<AuthorityRoleItem>.Ok(roles, limit, offset);
return ListResultOld<AuthorityRoleItem>.Ok(roles, limit, offset);
}
catch (Exception e)
{
@ -151,26 +153,26 @@ public class RoleRepository(IDbContextFactory<AuthorityContext> contextFactory)
context.RoleLinks.Add(new RoleLink() { LinkId = linkId, RoleId = role.Id });
}
var saveResult = await context.SaveChangesAsync(cancellationToken);
return saveResult <= 0 ? Result.Failed("Failed to ad role link!") : Result.Ok();
return saveResult == roles.Count ? Result.Success() : ResultError.Fail($"Not all roles have been linked! {saveResult} of {roles.Count} roles linked!");
}
catch (Exception e)
{
return HandleException("Failed to add role link!", e);
return e;
}
}
public async Task<ListResult<AuthorityRole>> GetLinkedRolesAsync(List<Guid> linkIds, CancellationToken cancellationToken = default)
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 ListResult<AuthorityRole>.Ok(roleList.DistinctBy(r => r.Id));
return roleList.DistinctBy(r => r.Id).ToList();
}
catch (Exception e)
{
return HandleExceptionListResult<AuthorityRole>("Failed to get linked roles!", e);
return e;
}
}
@ -182,25 +184,25 @@ public class RoleRepository(IDbContextFactory<AuthorityContext> contextFactory)
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 <= 0 ? Result.Failed("Failed to delete role links!") : Result.Ok();
return saveResult == roles.Count ? Result.Success() : ResultError.Fail($"Not all roles have been unlinked! {saveResult} of {roles.Count} roles unlinked!");
}
catch (Exception e)
{
return HandleException("Failed to delete role link!", e);
return e;
}
}
public async Task<ListResult<Guid>> HasRolesAsync(Guid linkId, List<AuthorityRole> roles, CancellationToken cancellationToken = default)
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 ListResult<Guid>.Ok(hasRoles);
return hasRoles;
}
catch (Exception e)
{
return HandleExceptionListResult<Guid>("Failed to determine role for user!", e);
return e;
}
}
}

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

@ -6,7 +6,7 @@ namespace DotBased.AspNet.Authority.EFCore.Repositories;
public class UserRepository(IDbContextFactory<AuthorityContext> contextFactory) : RepositoryBase, IUserRepository
{
public async Task<ListResult<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)
{
try
{
@ -26,7 +26,7 @@ public class UserRepository(IDbContextFactory<AuthorityContext> contextFactory)
EmailAddress = u.EmailAddress,
PhoneNumber = u.PhoneNumber
}).ToListAsync(cancellationToken: cancellationToken);
return ListResult<AuthorityUserItem>.Ok(selected, totalCount, limit, offset);
return ListResultOld<AuthorityUserItem>.Ok(selected, totalCount, limit, offset);
}
catch (Exception e)
{
@ -34,18 +34,18 @@ public class UserRepository(IDbContextFactory<AuthorityContext> contextFactory)
}
}
public async Task<Result<AuthorityUser>> GetAuthorityUserByIdAsync(string id, CancellationToken cancellationToken = default)
public async Task<ResultOld<AuthorityUser>> GetAuthorityUserByIdAsync(string id, CancellationToken cancellationToken = default)
{
try
{
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
if (!Guid.TryParse(id, out var guid))
{
return Result<AuthorityUser>.Failed("Invalid id!");
return ResultOld<AuthorityUser>.Failed("Invalid id!");
}
var user = await context.Users.Where(u => u.Id == guid).Include(u => u.Attributes).FirstOrDefaultAsync(cancellationToken: cancellationToken);
return Result<AuthorityUser>.HandleResult(user, "User not found.");
return ResultOld<AuthorityUser>.HandleResult(user, "User not found.");
}
catch (Exception e)
{
@ -53,18 +53,18 @@ public class UserRepository(IDbContextFactory<AuthorityContext> contextFactory)
}
}
public async Task<Result<AuthorityUser>> CreateUserAsync(AuthorityUser user, CancellationToken cancellationToken = default)
public async Task<ResultOld<AuthorityUser>> CreateUserAsync(AuthorityUser user, CancellationToken cancellationToken = default)
{
try
{
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
if (user.Id == Guid.Empty)
{
return Result<AuthorityUser>.Failed("Id cannot be empty!");
return ResultOld<AuthorityUser>.Failed("Id cannot be empty!");
}
var entity = context.Users.Add(user);
var saveResult = await context.SaveChangesAsync(cancellationToken);
return saveResult <= 0 ? Result<AuthorityUser>.Failed("Failed to create user!") : Result<AuthorityUser>.Ok(entity.Entity);
return saveResult <= 0 ? ResultOld<AuthorityUser>.Failed("Failed to create user!") : ResultOld<AuthorityUser>.Ok(entity.Entity);
}
catch (Exception e)
{
@ -72,7 +72,7 @@ public class UserRepository(IDbContextFactory<AuthorityContext> contextFactory)
}
}
public async Task<Result<AuthorityUser>> UpdateUserAsync(AuthorityUser user, CancellationToken cancellationToken = default)
public async Task<ResultOld<AuthorityUser>> UpdateUserAsync(AuthorityUser user, CancellationToken cancellationToken = default)
{
try
{
@ -80,17 +80,17 @@ public class UserRepository(IDbContextFactory<AuthorityContext> contextFactory)
var usr = await context.Users.FirstOrDefaultAsync(u => u.Id == user.Id, cancellationToken: cancellationToken);
if (usr == null)
{
return Result<AuthorityUser>.Failed("User not found!");
return ResultOld<AuthorityUser>.Failed("User not found!");
}
if (usr.Version != user.Version || usr.SecurityVersion != user.SecurityVersion)
{
return Result<AuthorityUser>.Failed("Version validation failed!");
return ResultOld<AuthorityUser>.Failed("Version validation failed!");
}
var entity = context.Users.Update(user);
var saveResult = await context.SaveChangesAsync(cancellationToken);
return saveResult <= 0 ? Result<AuthorityUser>.Failed("Failed to save updated user!") : Result<AuthorityUser>.Ok(entity.Entity);
return saveResult <= 0 ? ResultOld<AuthorityUser>.Failed("Failed to save updated user!") : ResultOld<AuthorityUser>.Ok(entity.Entity);
}
catch (Exception e)
{
@ -98,7 +98,7 @@ public class UserRepository(IDbContextFactory<AuthorityContext> contextFactory)
}
}
public async Task<Result> DeleteUserAsync(AuthorityUser user, CancellationToken cancellationToken = default)
public async Task<ResultOld> DeleteUserAsync(AuthorityUser user, CancellationToken cancellationToken = default)
{
try
{
@ -106,11 +106,11 @@ public class UserRepository(IDbContextFactory<AuthorityContext> contextFactory)
var usr = await context.Users.FirstOrDefaultAsync(u => u.Id == user.Id, cancellationToken: cancellationToken);
if (usr == null)
{
return Result.Failed("User not found!");
return ResultOld.Failed("User not found!");
}
context.Users.Remove(usr);
var saveResult = await context.SaveChangesAsync(cancellationToken);
return saveResult <= 0 ? Result.Failed("Failed to delete user!") : Result.Ok();
return saveResult <= 0 ? ResultOld.Failed("Failed to delete user!") : ResultOld.Ok();
}
catch (Exception e)
{
@ -118,13 +118,13 @@ public class UserRepository(IDbContextFactory<AuthorityContext> contextFactory)
}
}
public async Task<Result<AuthorityUser>> GetUserByEmailAsync(string email, CancellationToken cancellationToken = default)
public async Task<ResultOld<AuthorityUser>> GetUserByEmailAsync(string email, CancellationToken cancellationToken = default)
{
try
{
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
var usr = await context.Users.Where(u => u.EmailAddress == email).Include(u => u.Attributes).FirstOrDefaultAsync(cancellationToken: cancellationToken);
return Result<AuthorityUser>.HandleResult(usr, "User not found by given email address.");
return ResultOld<AuthorityUser>.HandleResult(usr, "User not found by given email address.");
}
catch (Exception e)
{
@ -132,7 +132,7 @@ public class UserRepository(IDbContextFactory<AuthorityContext> contextFactory)
}
}
public async Task<Result> SetVersionAsync(AuthorityUser user, long version, CancellationToken cancellationToken = default)
public async Task<ResultOld> SetVersionAsync(AuthorityUser user, long version, CancellationToken cancellationToken = default)
{
try
{
@ -140,18 +140,18 @@ public class UserRepository(IDbContextFactory<AuthorityContext> contextFactory)
var usr = await context.Users.FirstOrDefaultAsync(u => u.Id == user.Id, cancellationToken);
if (usr == null)
{
return Result.Failed("Failed to find user with given id!");
return ResultOld.Failed("Failed to find user with given id!");
}
if (usr.Version != user.Version)
{
return Result.Failed("Stored user version doesn't match current 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 ? Result.Failed("Failed to update user!") : Result.Ok();
return saveResult <= 0 ? ResultOld.Failed("Failed to update user!") : ResultOld.Ok();
}
catch (Exception e)
{
@ -159,13 +159,13 @@ public class UserRepository(IDbContextFactory<AuthorityContext> contextFactory)
}
}
public async Task<Result<long>> GetVersionAsync(AuthorityUser user, CancellationToken cancellationToken = default)
public async Task<ResultOld<long>> GetVersionAsync(AuthorityUser user, CancellationToken cancellationToken = default)
{
try
{
await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
var usrVersion = await context.Users.Where(u => u.Id == user.Id).Select(u => u.Version).FirstOrDefaultAsync(cancellationToken);
return Result<long>.HandleResult(usrVersion, "Failed to get user version!");
return ResultOld<long>.HandleResult(usrVersion, "Failed to get user version!");
}
catch (Exception e)
{
@ -173,7 +173,7 @@ public class UserRepository(IDbContextFactory<AuthorityContext> contextFactory)
}
}
public async Task<Result> SetSecurityVersionAsync(AuthorityUser user, long securityVersion, CancellationToken cancellationToken = default)
public async Task<ResultOld> SetSecurityVersionAsync(AuthorityUser user, long securityVersion, CancellationToken cancellationToken = default)
{
try
{
@ -181,18 +181,18 @@ public class UserRepository(IDbContextFactory<AuthorityContext> contextFactory)
var usr = await context.Users.FirstOrDefaultAsync(u => u.Id == user.Id, cancellationToken);
if (usr == null)
{
return Result.Failed("Failed to find user with given id!");
return ResultOld.Failed("Failed to find user with given id!");
}
if (usr.SecurityVersion != user.SecurityVersion)
{
return Result.Failed("Stored user version doesn't match current user version!");
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 ? Result.Failed("Failed to update user!") : Result.Ok();
return saveResult <= 0 ? ResultOld.Failed("Failed to update user!") : ResultOld.Ok();
}
catch (Exception e)
{
@ -200,13 +200,13 @@ public class UserRepository(IDbContextFactory<AuthorityContext> contextFactory)
}
}
public async Task<Result<long>> GetSecurityVersionAsync(AuthorityUser user, CancellationToken cancellationToken = default)
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 Result<long>.HandleResult(usrVersion, "Failed to get user security version!");
return ResultOld<long>.HandleResult(usrVersion, "Failed to get user security version!");
}
catch (Exception e)
{

2
DotBased.AspNet.Authority/Managers/AuthorityGroupManager.cs
View File

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

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

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

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

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

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

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

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/QueryItems.cs Normal file
View File

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

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

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

10
DotBased.AspNet.Authority/Repositories/IAttributeRepository.cs
View File

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

12
DotBased.AspNet.Authority/Repositories/IGroupRepository.cs
View File

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

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

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

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

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

55
DotBased/Monads/Result.cs
View File

@ -10,27 +10,39 @@ public class Result
protected Result(Exception exception)
{
IsSuccess = false;
Information = ResultInformation.Error(exception);
Error = ResultError.Error(exception);
}
protected Result(ResultInformation information)
protected Result(ResultError error)
{
IsSuccess = false;
Information = information;
Error = error;
}
public bool IsSuccess { get; }
public ResultInformation? Information { get; set; }
public ResultError? Error { get; set; }
public static implicit operator Result(Exception exception) => new(exception);
public static implicit operator Result(ResultInformation information) => new(information);
public static implicit operator Result(ResultError error) => new(error);
public static Result Success() => new();
public static Result Error(ResultInformation information) => new(information);
public static Result Fail(Exception exception) => new(exception);
public static Result Fail(ResultError error) => new(error);
public static Result Exception(Exception exception) => new(exception);
public TMatch Match<TMatch>(Func<TMatch> success, Func<ResultInformation, TMatch> failure) => IsSuccess ? success() : failure(Information!);
public TMatch Match<TMatch>(Func<TMatch> success, Func<ResultError, TMatch> failure) => IsSuccess ? success() : failure(Error!);
public void Match(Action success, Action<ResultError> failure)
{
if (IsSuccess)
{
success();
}
else
{
failure(Error!);
}
}
}
public class Result<TResult> : Result
@ -45,7 +57,7 @@ public class Result<TResult> : Result
_result = default;
}
protected Result(ResultInformation information) : base(information)
protected Result(ResultError error) : base(error)
{
_result = default;
}
@ -55,30 +67,27 @@ public class Result<TResult> : Result
public static implicit operator Result<TResult>(TResult result) => new(result);
public static implicit operator Result<TResult>(Exception exception) => new(exception);
public static implicit operator Result<TResult>(ResultInformation information) => new(information);
public static implicit operator Result<TResult>(ResultError error) => new(error);
public static Result<TResult> Success(TResult result) => new(result);
public new static Result<TResult> Error(ResultInformation information) => new(information);
public new static Result<TResult> Fail(Exception exception) => new(exception);
public new static Result<TResult> Fail(ResultError error) => new(error);
public new static Result<TResult> Exception(Exception exception) => new(exception);
public TMatch Match<TMatch>(Func<TResult, TMatch> success, Func<ResultInformation, TMatch> failure)
{
return IsSuccess && _result != null ? success(_result) : failure(Information ?? ResultInformation.Fail("No error and value is null!"));
}
public TMatch Match<TMatch>(Func<TResult, TMatch> success, Func<ResultError, TMatch> failure) =>
IsSuccess && Value != null ? success(Value) : failure(Error ?? ResultError.Fail("No error and value is null!"));
}
public class ResultInformation
public class ResultError
{
private ResultInformation(string message, Exception? exception)
private ResultError(string description, Exception? exception)
{
Message = message;
Description = description;
Exception = exception;
}
public string Message { get; }
public string Description { get; }
public Exception? Exception { get; }
public static ResultInformation Info(string message) => new(message, null);
public static ResultInformation Fail(string message) => new(message, null);
public static ResultInformation Error(Exception exception, string message = "") => new(message, exception);
public static ResultError Fail(string description) => new(description, null);
public static ResultError Error(Exception exception, string description = "") => new(description, exception);
}

32
DotBased/Result.cs → DotBased/ResultOld.cs
View File

@ -3,16 +3,16 @@ namespace DotBased;
/// <summary>
/// Simple result class for returning a result state or a message and an exception.
/// </summary>
public class Result
public class ResultOld
{
public Result(bool success, string message, Exception? exception)
public ResultOld(bool success, string message, Exception? exception)
{
Success = success;
Message = message;
Exception = exception;
}
public Result(Result bObj)
public ResultOld(ResultOld bObj)
{
Success = bObj.Success;
Message = bObj.Message;
@ -23,36 +23,36 @@ public class Result
public string Message { get; set; }
public Exception? Exception { get; set; }
public static Result Ok() => new(true, string.Empty, null);
public static Result Failed(string message, Exception? exception = null) => new(false, message, exception);
public static ResultOld Ok() => new(true, string.Empty, null);
public static ResultOld Failed(string message, Exception? exception = null) => new(false, message, exception);
}
public class Result<TValue> : Result
public class ResultOld<TValue> : ResultOld
{
public Result(bool success, string message, TValue? value, Exception? exception) : base(success, message, exception)
public ResultOld(bool success, string message, TValue? value, Exception? exception) : base(success, message, exception)
{
Value = value;
}
public Result(Result bObj) : base(bObj)
public ResultOld(ResultOld bObj) : base(bObj)
{
}
public TValue? Value { get; set; }
public static Result<TValue> Ok(TValue value) => new(true, string.Empty, value, null);
public static ResultOld<TValue> Ok(TValue value) => new(true, string.Empty, value, null);
public new static Result<TValue> Failed(string message, Exception? exception = null) =>
public new static ResultOld<TValue> Failed(string message, Exception? exception = null) =>
new(false, message, default, exception);
public static Result<TValue> HandleResult(TValue? value, string failedMessage, Exception? exception = null)
public static ResultOld<TValue> HandleResult(TValue? value, string failedMessage, Exception? exception = null)
{
return value == null ? Failed(failedMessage, exception) : Ok(value);
}
}
public class ListResult<TItem> : Result
public class ListResultOld<TItem> : ResultOld
{
public ListResult(bool success, string message, int totalCount, IEnumerable<TItem>? items, int limit = -1, int offset = -1, Exception? exception = null) : base(success, message, exception)
public ListResultOld(bool success, string message, int totalCount, IEnumerable<TItem>? items, int limit = -1, int offset = -1, Exception? exception = null) : base(success, message, exception)
{
Items = items != null ? new List<TItem>(items) : new List<TItem>();
TotalCount = totalCount;
@ -60,7 +60,7 @@ public class ListResult<TItem> : Result
Offset = offset;
}
public ListResult(Result bObj) : base(bObj)
public ListResultOld(ResultOld bObj) : base(bObj)
{
Items = new List<TItem>();
}
@ -86,9 +86,9 @@ public class ListResult<TItem> : Result
/// </summary>
public int Offset { get; }
public static ListResult<TItem> Ok(IEnumerable<TItem> items, int totalCount = -1, int limit = -1, int offset = -1) =>
public static ListResultOld<TItem> Ok(IEnumerable<TItem> items, int totalCount = -1, int limit = -1, int offset = -1) =>
new(true, string.Empty, totalCount, items, limit, offset);
public new static ListResult<TItem> Failed(string message, Exception? exception = null) =>
public new static ListResultOld<TItem> Failed(string message, Exception? exception = null) =>
new(false, message, -1, null, exception: exception);
}

6
DotBased/Utilities/Cryptography.cs
View File

@ -7,12 +7,12 @@ public static class Cryptography
/*
* https://gist.github.com/therightstuff/aa65356e95f8d0aae888e9f61aa29414
*/
public static Result<string> ExportPublicKeyToPem(RSACryptoServiceProvider csp)
public static ResultOld<string> ExportPublicKeyToPem(RSACryptoServiceProvider csp)
{
var outputStream = new StringWriter();
var parameters = csp.ExportParameters(false);
if (parameters.Exponent == null || parameters.Modulus == null)
return Result<string>.Failed("RSAParameters are empty!");
return ResultOld<string>.Failed("RSAParameters are empty!");
using (var stream = new MemoryStream())
{
var writer = new BinaryWriter(stream);
@ -66,7 +66,7 @@ public static class Cryptography
outputStream.Write("-----END PUBLIC KEY-----");
}
return Result<string>.Ok(outputStream.ToString());
return ResultOld<string>.Ok(outputStream.ToString());
}
private static void EncodeLength(BinaryWriter stream, int length)