[CHANGE] Moved repositories to new monads

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

@@ -1,15 +1,15 @@
+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();
@@ -25,90 +25,62 @@ public class AttributeRepository(IDbContextFactory<AuthorityContext> contextFact
             AttributeKey = a.AttributeKey,
             AttributeValue = a.AttributeValue
         }).ToListAsync(cancellationToken);
-            return ListResultOld<AuthorityAttributeItem>.Ok(select, total, limit, offset);
+        return QueryItems<AuthorityAttributeItem>.Create(select, total, limit, offset);
-        }
-        catch (Exception e)
-        {
-            return HandleExceptionListResult<AuthorityAttributeItem>("Failed to get attributes", e);
-        }
     }
 
-    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 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);
-        }
     }
 
-    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)
         {
-                return ResultOld<AuthorityAttribute>.Failed("Attribute key and/or bound id is empty");
+            throw new Exception($"Attribute {attribute.AttributeKey} not found");
-            }
-            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);
-        }
         }
 
-    public async Task<ResultOld<AuthorityAttribute>> UpdateAttributeAsync(AuthorityAttribute attribute, CancellationToken cancellationToken = default)
+        var entry = context.Attributes.Add(attribute);
-    {
+        var saveResult = await context.SaveChangesAsync(cancellationToken);
-        try
+        return saveResult != 0 ? entry.Entity : null;
+    }
+
+    public async Task<AuthorityAttribute?> UpdateAttributeAsync(AuthorityAttribute attribute, CancellationToken cancellationToken = default)
     {
         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");
+            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);
+        return saveResult != 0 ? entry.Entity : null;
-        }
-        catch (Exception e)
-        {
-            return HandleExceptionResult<AuthorityAttribute>("Failed to update attribute", e);
-        }
     }
 
-    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)
         {
-                return ResultOld.Failed("Attribute not found");
+            logger.LogError("Attribute not found.");
+            return false;
         }
+        
         context.Attributes.Remove(currentAttribute);
         var saveResult = await context.SaveChangesAsync(cancellationToken);
-            return saveResult <= 0 ? ResultOld.Failed("Failed to delete attribute") : ResultOld.Ok();
+        return saveResult != 0;
-        }
-        catch (Exception e)
-        {
-            return HandleException("Failed to delete attribute", e);
-        }
     }
 }

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

@@ -1,14 +1,14 @@
+using DotBased.AspNet.Authority.Models;
 using DotBased.AspNet.Authority.Models.Authority;
 using DotBased.AspNet.Authority.Repositories;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
 
 namespace DotBased.AspNet.Authority.EFCore.Repositories;
 
-public class 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();
@@ -22,109 +22,73 @@ public class GroupRepository(IDbContextFactory<AuthorityContext> contextFactory)
             Id = g.Id,
             Name = g.Name
         }).ToListAsync(cancellationToken);
-            return ListResultOld<AuthorityGroupItem>.Ok(select, total, limit, offset);
+        return QueryItems<AuthorityGroupItem>.Create(select, total, limit, offset);
-        }
-        catch (Exception e)
-        {
-            return HandleExceptionListResult<AuthorityGroupItem>("Failed to get Groups", e);
-        }
     }
 
-    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))
         {
-                return ResultOld<AuthorityGroup>.Failed("Invalid group id");
+            throw new Exception($"Invalid group id: {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);
-        }
         }
         
-    public async Task<ListResultOld<AuthorityGroup>> GetUserGroupsAsync(AuthorityUser user, CancellationToken cancellationToken = default)
+        return await context.Groups.Where(g => g.Id == groupId).Include(g => g.Attributes).FirstOrDefaultAsync(cancellationToken: cancellationToken);
-    {
+    }
-        try
+
+    public async Task<List<AuthorityGroup>> GetUserGroupsAsync(AuthorityUser user, CancellationToken cancellationToken = default)
     {
         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());
+        return userGroups.ToList();
-        }
-        catch (Exception e)
-        {
-            return HandleExceptionListResult<AuthorityGroup>("Failed to get Groups", e);
-        }
     }
 
-    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)
         {
-                return ResultOld<AuthorityGroup>.Failed("Id cannot be empty.");
+            throw new Exception($"Invalid group id: {group.Id}");
         }
         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);
+        return saveResult != 0 ? entry.Entity : null;
-        }
-        catch (Exception e)
-        {
-            return HandleExceptionResult<AuthorityGroup>("Failed to create group!", e);
-        }
     }
 
-    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)
         {
-                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!");
+            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);
+        return saveResult != 0 ? entry.Entity : null;
-        }
-        catch (Exception e)
-        {
-            return HandleExceptionResult<AuthorityGroup>("Failed to update group!", e);
-        }
     }
 
-    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)
         {
-                return ResultOld.Failed("Group not found, cannot delete group!");
+            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 ? ResultOld.Failed("Failed to delete group.") : ResultOld.Ok();
+        return saveResult != 0;
-        }
-        catch (Exception e)
-        {
-            return HandleException("Failed to delete group!", e);
-        }
     }
 }

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)
+    {
+        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<QueryItems<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<AuthorityAttribute?> GetAttributeByKeyAsync(string id, CancellationToken cancellationToken = default);
-    public Task<ResultOld<AuthorityAttribute>> CreateAttributeAsync(AuthorityAttribute attribute, CancellationToken cancellationToken = default);
+    public Task<AuthorityAttribute?> CreateAttributeAsync(AuthorityAttribute attribute, CancellationToken cancellationToken = default);
-    public Task<ResultOld<AuthorityAttribute>> UpdateAttributeAsync(AuthorityAttribute attribute, CancellationToken cancellationToken = default);
+    public Task<AuthorityAttribute?> UpdateAttributeAsync(AuthorityAttribute attribute, CancellationToken cancellationToken = default);
-    public Task<ResultOld> DeleteAttributeAsync(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<QueryItems<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<AuthorityGroup?> GetGroupByIdAsync(string id, CancellationToken cancellationToken = default);
-    public Task<ListResultOld<AuthorityGroup>> GetUserGroupsAsync(AuthorityUser user, CancellationToken cancellationToken = default);
+    public Task<List<AuthorityGroup>> GetUserGroupsAsync(AuthorityUser user, CancellationToken cancellationToken = default);
-    public Task<ResultOld<AuthorityGroup>> CreateGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default);
+    public Task<AuthorityGroup?> CreateGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default);
-    public Task<ResultOld<AuthorityGroup>> UpdateGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default);
+    public Task<AuthorityGroup?> UpdateGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default);
-    public Task<ResultOld> DeleteGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default);
+    public Task<bool> DeleteGroupAsync(AuthorityGroup group, CancellationToken cancellationToken = default);
 }