[CHANGE] Removed old result monad

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

@@ -1,114 +1,86 @@
+using DotBased.AspNet.Authority.Models;
 using DotBased.AspNet.Authority.Models.Authority;
 using DotBased.AspNet.Authority.Repositories;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
 
 namespace DotBased.AspNet.Authority.EFCore.Repositories;
 
-public class AttributeRepository(IDbContextFactory<AuthorityContext> contextFactory) : RepositoryBase, IAttributeRepository
+public class AttributeRepository(IDbContextFactory<AuthorityContext> contextFactory, ILogger<AttributeRepository> logger) : RepositoryBase, IAttributeRepository
 {
-    public async Task<ListResultOld<AuthorityAttributeItem>> GetAttributesAsync(int limit = 20, int offset = 0, string search = "",
+    public async Task<QueryItems<AuthorityAttributeItem>> GetAttributesAsync(int limit = 20, int offset = 0, string search = "",
         CancellationToken cancellationToken = default)
     {
-        try
+        await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+        var query = context.Attributes.AsQueryable();
+        if (!string.IsNullOrEmpty(search))
         {
-            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
-            var query = context.Attributes.AsQueryable();
-            if (!string.IsNullOrEmpty(search))
-            {
-                query = query.Where(a => $"{a.AttributeKey} {a.ForeignKey} {a.AttributeValue}".Contains(search, StringComparison.CurrentCultureIgnoreCase));
-            }
+            query = query.Where(a => $"{a.AttributeKey} {a.ForeignKey} {a.AttributeValue}".Contains(search, StringComparison.CurrentCultureIgnoreCase));
+        }
             
-            var total = await query.CountAsync(cancellationToken);
-            var select = await query.OrderBy(a => a.AttributeKey).Skip(offset).Take(limit).Select(a => new AuthorityAttributeItem()
-            {
-                BoundId = a.ForeignKey,
-                AttributeKey = a.AttributeKey,
-                AttributeValue = a.AttributeValue
-            }).ToListAsync(cancellationToken);
-            return ListResultOld<AuthorityAttributeItem>.Ok(select, total, limit, offset);
-        }
-        catch (Exception e)
+        var total = await query.CountAsync(cancellationToken);
+        var select = await query.OrderBy(a => a.AttributeKey).Skip(offset).Take(limit).Select(a => new AuthorityAttributeItem()
         {
-            return HandleExceptionListResult<AuthorityAttributeItem>("Failed to get attributes", e);
-        }
+            BoundId = a.ForeignKey,
+            AttributeKey = a.AttributeKey,
+            AttributeValue = a.AttributeValue
+        }).ToListAsync(cancellationToken);
+        return QueryItems<AuthorityAttributeItem>.Create(select, total, limit, offset);
     }
 
-    public async Task<ResultOld<AuthorityAttribute>> GetAttributeByKeyAsync(string key, CancellationToken cancellationToken = default)
+    public async Task<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 ? ResultOld<AuthorityAttribute>.Failed("Attribute not found") : ResultOld<AuthorityAttribute>.Ok(attribute);
-        }
-        catch (Exception e)
-        {
-            return HandleExceptionResult<AuthorityAttribute>("Failed to get attribute by id", e);
-        }
+        await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+        return await context.Attributes.FirstOrDefaultAsync(a => a.AttributeKey == key, cancellationToken);
     }
 
-    public async Task<ResultOld<AuthorityAttribute>> CreateAttributeAsync(AuthorityAttribute attribute, CancellationToken cancellationToken = default)
+    public async Task<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)
         {
-            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
-            if (string.IsNullOrWhiteSpace(attribute.AttributeKey) || attribute.ForeignKey == Guid.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 ? ResultOld<AuthorityAttribute>.Failed("Failed to create attribute") : ResultOld<AuthorityAttribute>.Ok(entry.Entity);
-        }
-        catch (Exception e)
-        {
-            return HandleExceptionResult<AuthorityAttribute>("Failed to create attribute", e);
+            throw new Exception($"Attribute {attribute.AttributeKey} not found");
         }
+
+        var entry = context.Attributes.Add(attribute);
+        var saveResult = await context.SaveChangesAsync(cancellationToken);
+        return saveResult != 0 ? entry.Entity : null;
     }
 
-    public async Task<ResultOld<AuthorityAttribute>> UpdateAttributeAsync(AuthorityAttribute attribute, CancellationToken cancellationToken = default)
+    public async Task<AuthorityAttribute?> UpdateAttributeAsync(AuthorityAttribute attribute, CancellationToken cancellationToken = default)
     {
-        try
+        await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+        var currentAttribute = await context.Attributes.FirstOrDefaultAsync(a => a.AttributeKey == attribute.AttributeKey, cancellationToken);
+        if (currentAttribute == null)
         {
-            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
-            var currentAttribute = await context.Attributes.FirstOrDefaultAsync(a => a.AttributeKey == attribute.AttributeKey, cancellationToken);
-            if (currentAttribute == null)
-            {
-                return ResultOld<AuthorityAttribute>.Failed("Attribute not found");
-            }
+            return null;
+        }
 
-            if (currentAttribute.Version != attribute.Version)
-            {
-                return ResultOld<AuthorityAttribute>.Failed("Attribute version doesn't match");
-            }
+        if (currentAttribute.Version != attribute.Version)
+        {
+            logger.LogError("Attribute version validation failed for attribute {attribute}", currentAttribute.AttributeKey);
+            return null;
+        }
             
-            var entry = context.Attributes.Update(currentAttribute);
-            var saveResult = await context.SaveChangesAsync(cancellationToken);
-            return saveResult <= 0 ? ResultOld<AuthorityAttribute>.Failed("Failed to update attribute") : ResultOld<AuthorityAttribute>.Ok(entry.Entity);
-        }
-        catch (Exception e)
-        {
-            return HandleExceptionResult<AuthorityAttribute>("Failed to update attribute", e);
-        }
+        var entry = context.Attributes.Update(currentAttribute);
+        var saveResult = await context.SaveChangesAsync(cancellationToken);
+        return saveResult != 0 ? entry.Entity : null;
     }
 
-    public async Task<ResultOld> DeleteAttributeAsync(AuthorityAttribute attribute, CancellationToken cancellationToken = default)
+    public async Task<bool> DeleteAttributeAsync(AuthorityAttribute attribute, CancellationToken cancellationToken = default)
     {
-        try
+        await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+        var currentAttribute = await context.Attributes.FirstOrDefaultAsync(a => a.AttributeKey == attribute.AttributeKey, cancellationToken);
+        
+        if (currentAttribute == null)
         {
-            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
-            var currentAttribute = await context.Attributes.FirstOrDefaultAsync(a => a.AttributeKey == attribute.AttributeKey, cancellationToken);
-            if (currentAttribute == null)
-            {
-                return ResultOld.Failed("Attribute not found");
-            }
-            context.Attributes.Remove(currentAttribute);
-            var saveResult = await context.SaveChangesAsync(cancellationToken);
-            return saveResult <= 0 ? ResultOld.Failed("Failed to delete attribute") : ResultOld.Ok();
-        }
-        catch (Exception e)
-        {
-            return HandleException("Failed to delete attribute", e);
+            logger.LogError("Attribute not found.");
+            return false;
         }
+        
+        context.Attributes.Remove(currentAttribute);
+        var saveResult = await context.SaveChangesAsync(cancellationToken);
+        return saveResult != 0;
     }
 }

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

@@ -1,130 +1,94 @@
+using DotBased.AspNet.Authority.Models;
 using DotBased.AspNet.Authority.Models.Authority;
 using DotBased.AspNet.Authority.Repositories;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
 
 namespace DotBased.AspNet.Authority.EFCore.Repositories;
 
-public class GroupRepository(IDbContextFactory<AuthorityContext> contextFactory) : RepositoryBase, IGroupRepository
+public class GroupRepository(IDbContextFactory<AuthorityContext> contextFactory, ILogger<GroupRepository> logger) : RepositoryBase, IGroupRepository
 {
-    public async Task<ListResultOld<AuthorityGroupItem>> GetGroupsAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default)
+    public async Task<QueryItems<AuthorityGroupItem>> GetGroupsAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default)
     {
-        try
+        await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+        var query = context.Groups.AsQueryable();
+        if (!string.IsNullOrWhiteSpace(search))
         {
-            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
-            var query = context.Groups.AsQueryable();
-            if (!string.IsNullOrWhiteSpace(search))
-            {
-                query = query.Where(g => $"{g.Name} {g.Id}".Contains(search));
-            }
-            var total = await query.CountAsync(cancellationToken);
-            var select = await query.OrderBy(g => g.Name).Skip(offset).Take(limit).Select(g => new AuthorityGroupItem()
-            {
-                Id = g.Id,
-                Name = g.Name
-            }).ToListAsync(cancellationToken);
-            return ListResultOld<AuthorityGroupItem>.Ok(select, total, limit, offset);
+            query = query.Where(g => $"{g.Name} {g.Id}".Contains(search));
         }
-        catch (Exception e)
+        var total = await query.CountAsync(cancellationToken);
+        var select = await query.OrderBy(g => g.Name).Skip(offset).Take(limit).Select(g => new AuthorityGroupItem()
         {
-            return HandleExceptionListResult<AuthorityGroupItem>("Failed to get Groups", e);
-        }
+            Id = g.Id,
+            Name = g.Name
+        }).ToListAsync(cancellationToken);
+        return QueryItems<AuthorityGroupItem>.Create(select, total, limit, offset);
     }
 
-    public async Task<ResultOld<AuthorityGroup>> GetGroupByIdAsync(string id, CancellationToken cancellationToken = default)
+    public async Task<AuthorityGroup?> GetGroupByIdAsync(string id, CancellationToken cancellationToken = default)
     {
-        try
+        await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+        
+        if (!Guid.TryParse(id, out var groupId))
         {
-            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
-            if (!Guid.TryParse(id, out var groupId))
-            {
-                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 ResultOld<AuthorityGroup>.HandleResult(group, "Group not found");
-        }
-        catch (Exception e)
-        {
-            return HandleExceptionResult<AuthorityGroup>("Failed to get Group", e);
+            throw new Exception($"Invalid group id: {id}");
         }
+        
+        return await context.Groups.Where(g => g.Id == groupId).Include(g => g.Attributes).FirstOrDefaultAsync(cancellationToken: cancellationToken);
     }
 
-    public async Task<ListResultOld<AuthorityGroup>> GetUserGroupsAsync(AuthorityUser user, CancellationToken cancellationToken = default)
+    public async Task<List<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 ListResultOld<AuthorityGroup>.Ok(userGroups, userGroups.Count());
-        }
-        catch (Exception e)
-        {
-            return HandleExceptionListResult<AuthorityGroup>("Failed to get Groups", e);
-        }
+        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 userGroups.ToList();
     }
 
-    public async Task<ResultOld<AuthorityGroup>> CreateGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default)
+    public async Task<AuthorityGroup?> CreateGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default)
     {
-        try
+        await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+        if (group.Id == Guid.Empty)
         {
-            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
-            if (group.Id == Guid.Empty)
-            {
-                return ResultOld<AuthorityGroup>.Failed("Id cannot be empty.");
-            }
-            var entry = context.Groups.Add(group);
-            var saveResult = await context.SaveChangesAsync(cancellationToken);
-            return saveResult <= 0 ? ResultOld<AuthorityGroup>.Failed("Failed to create group.") : ResultOld<AuthorityGroup>.Ok(entry.Entity);
-        }
-        catch (Exception e)
-        {
-            return HandleExceptionResult<AuthorityGroup>("Failed to create group!", e);
+            throw new Exception($"Invalid group id: {group.Id}");
         }
+        var entry = context.Groups.Add(group);
+        var saveResult = await context.SaveChangesAsync(cancellationToken);
+        return saveResult != 0 ? entry.Entity : null;
     }
 
-    public async Task<ResultOld<AuthorityGroup>> UpdateGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default)
+    public async Task<AuthorityGroup?> UpdateGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default)
     {
-        try
+        await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+        var currentGroup = await context.Groups.FirstOrDefaultAsync(g => g.Id == group.Id ,cancellationToken);
+        if (currentGroup == null)
         {
-            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
-            var currentGroup = await context.Groups.FirstOrDefaultAsync(g => g.Id == group.Id ,cancellationToken);
-            if (currentGroup == null)
-            {
-                return ResultOld<AuthorityGroup>.Failed("Group not found.");
-            }
+            logger.LogError("Group with id {groupId} not found.", group.Id);
+            return null;
+        }
 
-            if (currentGroup.Version != group.Version)
-            {
-                return ResultOld<AuthorityGroup>.Failed("Group version does not match, version validation failed!");
-            }
+        if (currentGroup.Version != group.Version)
+        {
+            logger.LogError("Group version validation failed.");
+            return null;
+        }
             
-            var entry = context.Groups.Update(group);
-            var saveResult = await context.SaveChangesAsync(cancellationToken);
-            return saveResult <= 0 ? ResultOld<AuthorityGroup>.Failed("Failed to update group.") : ResultOld<AuthorityGroup>.Ok(entry.Entity);
-        }
-        catch (Exception e)
-        {
-            return HandleExceptionResult<AuthorityGroup>("Failed to update group!", e);
-        }
+        var entry = context.Groups.Update(group);
+        var saveResult = await context.SaveChangesAsync(cancellationToken);
+        return saveResult != 0 ? entry.Entity : null;
     }
 
-    public async Task<ResultOld> DeleteGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default)
+    public async Task<bool> DeleteGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default)
     {
-        try
+        await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+        var currentGroup = await context.Groups.FirstOrDefaultAsync(g => g.Id == group.Id, cancellationToken);
+        if (currentGroup == null)
         {
-            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
-            var currentGroup = await context.Groups.FirstOrDefaultAsync(g => g.Id == group.Id, cancellationToken);
-            if (currentGroup == null)
-            {
-                return ResultOld.Failed("Group not found, cannot delete group!");
-            }
-            context.Groups.Remove(currentGroup);
-            var saveResult = await context.SaveChangesAsync(cancellationToken);
-            return saveResult <= 0 ? ResultOld.Failed("Failed to delete group.") : ResultOld.Ok();
-        }
-        catch (Exception e)
-        {
-            return HandleException("Failed to delete group!", e);
+            logger.LogError("Group with id {groupId} not found.", group.Id);
+            return false;
         }
+        context.Groups.Remove(currentGroup);
+        var saveResult = await context.SaveChangesAsync(cancellationToken);
+        return saveResult != 0;
     }
 }

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

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

DotBased.AspNet.Authority/Managers/AuthorityGroupManager.cs

@@ -1,11 +1,19 @@
 using DotBased.AspNet.Authority.Models.Authority;
+using DotBased.Monads;
 
 namespace DotBased.AspNet.Authority.Managers;
 
 public partial class AuthorityManager
 {
-    public async Task<ListResultOld<AuthorityGroup>> GetUserGroupsAsync(AuthorityUser user, CancellationToken cancellationToken = default)
+    public async Task<Result<List<AuthorityGroup>>> GetUserGroupsAsync(AuthorityUser user, CancellationToken cancellationToken = default)
     {
-        return await GroupRepository.GetUserGroupsAsync(user, cancellationToken);
+        try
+        {
+            return await GroupRepository.GetUserGroupsAsync(user, cancellationToken);
+        }
+        catch (Exception e)
+        {
+            return e;
+        }
     }
 }

DotBased.AspNet.Authority/Managers/AuthorityRoleManager.cs

@@ -109,9 +109,9 @@ public partial class AuthorityManager
             var searchIds = new List<Guid> { user.Id };
 
             var usrGroups = await GetUserGroupsAsync(user, cancellationToken);
-            if (usrGroups.Success)
+            if (usrGroups.IsSuccess)
             {
-                searchIds.AddRange(usrGroups.Items.Select(g => g.Id).ToList());
+                searchIds.AddRange(usrGroups.Value.Select(g => g.Id).ToList());
             }
 
             var linkedRolesResult = await RoleRepository.GetLinkedRolesAsync(searchIds, cancellationToken);

DotBased.AspNet.Authority/Repositories/IAttributeRepository.cs

@@ -1,12 +1,13 @@
+using DotBased.AspNet.Authority.Models;
 using DotBased.AspNet.Authority.Models.Authority;
 
 namespace DotBased.AspNet.Authority.Repositories;
 
 public interface IAttributeRepository
 {
-    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);
+    public Task<QueryItems<AuthorityAttributeItem>> GetAttributesAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default);
+    public Task<AuthorityAttribute?> GetAttributeByKeyAsync(string id, CancellationToken cancellationToken = default);
+    public Task<AuthorityAttribute?> CreateAttributeAsync(AuthorityAttribute attribute, CancellationToken cancellationToken = default);
+    public Task<AuthorityAttribute?> UpdateAttributeAsync(AuthorityAttribute attribute, CancellationToken cancellationToken = default);
+    public Task<bool> DeleteAttributeAsync(AuthorityAttribute attribute, CancellationToken cancellationToken = default);
 }

DotBased.AspNet.Authority/Repositories/IGroupRepository.cs

@@ -1,13 +1,14 @@
+using DotBased.AspNet.Authority.Models;
 using DotBased.AspNet.Authority.Models.Authority;
 
 namespace DotBased.AspNet.Authority.Repositories;
 
 public interface IGroupRepository
 {
-    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);
+    public Task<QueryItems<AuthorityGroupItem>> GetGroupsAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default);
+    public Task<AuthorityGroup?> GetGroupByIdAsync(string id, CancellationToken cancellationToken = default);
+    public Task<List<AuthorityGroup>> GetUserGroupsAsync(AuthorityUser user, CancellationToken cancellationToken = default);
+    public Task<AuthorityGroup?> CreateGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default);
+    public Task<AuthorityGroup?> UpdateGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default);
+    public Task<bool> DeleteGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default);
 }

DotBased/ResultOld.cs

@@ -1,94 +0,0 @@
-namespace DotBased;
-
-/// <summary>
-/// Simple result class for returning a result state or a message and an exception.
-/// </summary>
-public class ResultOld
-{
-    public ResultOld(bool success, string message, Exception? exception)
-    {
-        Success = success;
-        Message = message;
-        Exception = exception;
-    }
-
-    public ResultOld(ResultOld bObj)
-    {
-        Success = bObj.Success;
-        Message = bObj.Message;
-        Exception = bObj.Exception;
-    }
-    
-    public bool Success { get; set; }
-    public string Message { get; set; }
-    public Exception? Exception { get; set; }
-
-    public static ResultOld Ok() => new(true, string.Empty, null);
-    public static ResultOld Failed(string message, Exception? exception = null) => new(false, message, exception);
-}
-
-public class ResultOld<TValue> : ResultOld
-{
-    public ResultOld(bool success, string message, TValue? value, Exception? exception) : base(success, message, exception)
-    {
-        Value = value;
-    }
-    public ResultOld(ResultOld bObj) : base(bObj)
-    {
-        
-    }
-    public TValue? Value { get; set; }
-
-    public static ResultOld<TValue> Ok(TValue value) => new(true, string.Empty, value, null);
-
-    public new static ResultOld<TValue> Failed(string message, Exception? exception = null) =>
-        new(false, message, default, exception);
-
-    public static ResultOld<TValue> HandleResult(TValue? value, string failedMessage, Exception? exception = null)
-    {
-        return value == null ? Failed(failedMessage, exception) : Ok(value);
-    }
-}
-
-public class ListResultOld<TItem> : ResultOld
-{
-    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;
-        Limit = limit;
-        Offset = offset;
-    }
-
-    public ListResultOld(ResultOld bObj) : base(bObj)
-    {
-        Items = new List<TItem>();
-    }
-    
-    public readonly IReadOnlyList<TItem> Items;
-    /// <summary>
-    /// The amount of items that this result contains.
-    /// </summary>
-    public int Count => Items.Count;
-
-    /// <summary>
-    /// The total amount of item that is available.
-    /// </summary>
-    public int TotalCount { get; }
-
-    /// <summary>
-    /// The limit this result contains
-    /// </summary>
-    public int Limit { get; }
-    
-    /// <summary>
-    /// The offset this result has the items from.
-    /// </summary>
-    public int Offset { get; }
-
-    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 ListResultOld<TItem> Failed(string message, Exception? exception = null) =>
-        new(false, message, -1, null, exception: exception);
-}

DotBased/Utilities/Cryptography.cs

@@ -1,4 +1,5 @@
 using System.Security.Cryptography;
+using DotBased.Monads;
 
 namespace DotBased.Utilities;
 
@@ -7,12 +8,12 @@ public static class Cryptography
     /*
      * https://gist.github.com/therightstuff/aa65356e95f8d0aae888e9f61aa29414
      */
-    public static ResultOld<string> ExportPublicKeyToPem(RSACryptoServiceProvider csp)
+    public static Result<string> ExportPublicKeyToPem(RSACryptoServiceProvider csp)
     {
         var outputStream = new StringWriter();
         var parameters = csp.ExportParameters(false);
         if (parameters.Exponent == null || parameters.Modulus == null)
-            return ResultOld<string>.Failed("RSAParameters are empty!");
+            return ResultError.Fail("RSAParameters are empty!");
         using (var stream = new MemoryStream())
         {
             var writer = new BinaryWriter(stream);
@@ -23,7 +24,7 @@ public static class Cryptography
                 innerWriter.Write((byte)0x30); // SEQUENCE
                 EncodeLength(innerWriter, 13);
                 innerWriter.Write((byte)0x06); // OBJECT IDENTIFIER
-                byte[] rsaEncryptionOid = new byte[] { 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01 };
+                var rsaEncryptionOid = new byte[] { 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01 };
                 EncodeLength(innerWriter, rsaEncryptionOid.Length);
                 innerWriter.Write(rsaEncryptionOid);
                 innerWriter.Write((byte)0x05); // NULL
@@ -44,20 +45,20 @@ public static class Cryptography
                         bitStringWriter.Write(paramsStream.GetBuffer(), 0, paramsLength);
                     }
 
-                    int bitStringLength = (int)bitStringStream.Length;
+                    var bitStringLength = (int)bitStringStream.Length;
                     EncodeLength(innerWriter, bitStringLength);
                     innerWriter.Write(bitStringStream.GetBuffer(), 0, bitStringLength);
                 }
 
-                int length = (int)innerStream.Length;
+                var length = (int)innerStream.Length;
                 EncodeLength(writer, length);
                 writer.Write(innerStream.GetBuffer(), 0, length);
             }
 
-            char[] base64 = Convert.ToBase64String(stream.GetBuffer(), 0, (int)stream.Length).ToCharArray();
+            var base64 = Convert.ToBase64String(stream.GetBuffer(), 0, (int)stream.Length).ToCharArray();
             // WriteLine terminates with \r\n, we want only \n
             outputStream.Write("-----BEGIN PUBLIC KEY-----\n");
-            for (int i = 0; i < base64.Length; i += 64)
+            for (var i = 0; i < base64.Length; i += 64)
             {
                 outputStream.Write(base64, i, Math.Min(64, base64.Length - i));
                 outputStream.Write("\n");
@@ -66,7 +67,7 @@ public static class Cryptography
             outputStream.Write("-----END PUBLIC KEY-----");
         }
 
-        return ResultOld<string>.Ok(outputStream.ToString());
+        return outputStream.ToString();
     }
         
     private static void EncodeLength(BinaryWriter stream, int length)
@@ -82,15 +83,15 @@ public static class Cryptography
             default:
             {
                 // Long form
-                int temp = length;
-                int bytesRequired = 0;
+                var temp = length;
+                var bytesRequired = 0;
                 while (temp > 0)
                 {
                     temp >>= 8;
                     bytesRequired++;
                 }
                 stream.Write((byte)(bytesRequired | 0x80));
-                for (int i = bytesRequired - 1; i >= 0; i--)
+                for (var i = bytesRequired - 1; i >= 0; i--)
                 {
                     stream.Write((byte)(length >> (8 * i) & 0xff));
                 }
@@ -102,7 +103,7 @@ public static class Cryptography
     private static void EncodeIntegerBigEndian(BinaryWriter stream, byte[] value, bool forceUnsigned = true)
     {
         stream.Write((byte)0x02); // INTEGER
-        int prefixZeros = value.TakeWhile(t => t == 0).Count();
+        var prefixZeros = value.TakeWhile(t => t == 0).Count();
         if (value.Length - prefixZeros == 0)
         {
             EncodeLength(stream, 1);
@@ -120,7 +121,7 @@ public static class Cryptography
             {
                 EncodeLength(stream, value.Length - prefixZeros);
             }
-            for (int i = prefixZeros; i < value.Length; i++)
+            for (var i = prefixZeros; i < value.Length; i++)
             {
                 stream.Write(value[i]);
             }