[IMPL] Added base user repository implementation

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

@@ -6,67 +6,212 @@ namespace DotBased.AspNet.Authority.EFCore.Repositories;
 
 public class UserRepository(IDbContextFactory<AuthorityContext> contextFactory) : IUserRepository
 {
-    public async Task<ListResult<AuthorityUserItem>> GetAuthorityUsersAsync(int limit = 20, int offset = 0, string search = "", CancellationToken? cancellationToken = null)
+    public async Task<ListResult<AuthorityUserItem>> GetAuthorityUsersAsync(int limit = 20, int offset = 0, string search = "", CancellationToken cancellationToken = default)
     {
-        await using var context = await contextFactory.CreateDbContextAsync();
+        try
-        var query = context.Users.AsQueryable();
-        if (!string.IsNullOrWhiteSpace(search))
         {
-            query = query.Where(u => $"{u.Id} {u.Name} {u.UserName} {u.EmailAddress} {u.PhoneNumber}".Contains(search, StringComparison.CurrentCultureIgnoreCase));
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+            var query = context.Users.AsQueryable();
+            if (!string.IsNullOrWhiteSpace(search))
+            {
+                query = query.Where(u =>
+                    $"{u.Id} {u.Name} {u.UserName} {u.EmailAddress} {u.PhoneNumber}".Contains(search,
+                        StringComparison.CurrentCultureIgnoreCase));
+            }
+
+            var totalCount = query.Count();
+            var selected = query.Skip(offset).Take(limit).Select(u => new AuthorityUserItem()
+            {
+                Id = u.Id,
+                UserName = u.UserName,
+                EmailAddress = u.EmailAddress,
+                PhoneNumber = u.PhoneNumber
+            });
+            return ListResult<AuthorityUserItem>.Ok(selected, totalCount, limit, offset);
         }
-        var totalCount = query.Count();
+        catch (Exception e)
-        var selected = query.Skip(offset).Take(limit).Select(u => new AuthorityUserItem()
         {
-            Id = u.Id,
+            return ListResult<AuthorityUserItem>.Failed("Failed to get users.", e);
-            UserName = u.UserName,
+        }
-            EmailAddress = u.EmailAddress,
-            PhoneNumber = u.PhoneNumber
-        });
-        return ListResult<AuthorityUserItem>.Ok(selected, totalCount, limit, offset);
     }
 
-    public Task<Result<AuthorityUser>> GetAuthorityUserByIdAsync(string id, CancellationToken? cancellationToken = null)
+    public async Task<Result<AuthorityUser>> GetAuthorityUserByIdAsync(string id, CancellationToken cancellationToken = default)
     {
-        throw new NotImplementedException();
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+            if (!Guid.TryParse(id, out var guid))
+            {
+                return Result<AuthorityUser>.Failed("Invalid id!");
+            }
+
+            var user = await context.Users.FirstOrDefaultAsync(u => u.Id == guid, cancellationToken: cancellationToken);
+            return Result<AuthorityUser>.HandleResult(user, "User not found.");
+        }
+        catch (Exception e)
+        {
+            return Result<AuthorityUser>.Failed("Failed to get user.", e);
+        }
     }
 
-    public Task<Result<AuthorityUser>> CreateUserAsync(AuthorityUser user, CancellationToken? cancellationToken = null)
+    public async Task<Result<AuthorityUser>> CreateUserAsync(AuthorityUser user, CancellationToken cancellationToken = default)
     {
-        throw new NotImplementedException();
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+            if (user.Id == Guid.Empty)
+            {
+                return Result<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);
+        }
+        catch (Exception e)
+        {
+            return Result<AuthorityUser>.Failed("Failed to create user.", e);
+        }
     }
 
-    public Task<Result<AuthorityUser>> UpdateUserAsync(AuthorityUser user, CancellationToken? cancellationToken = null)
+    public async Task<Result<AuthorityUser>> UpdateUserAsync(AuthorityUser user, CancellationToken cancellationToken = default)
     {
-        throw new NotImplementedException();
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+            var usr = await context.Users.FirstOrDefaultAsync(u => u.Id == user.Id, cancellationToken: cancellationToken);
+            if (usr == null)
+            {
+                return Result<AuthorityUser>.Failed("User not found!");
+            }
+
+            if (usr.Version != user.Version || usr.SecurityVersion != user.SecurityVersion)
+            {
+                return Result<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);
+        }
+        catch (Exception e)
+        {
+            return Result<AuthorityUser>.Failed("Failed to update user!", e);
+        }
     }
 
-    public Task<Result> DeleteUserAsync(AuthorityUser user, CancellationToken? cancellationToken = null)
+    public async Task<Result> DeleteUserAsync(AuthorityUser user, CancellationToken cancellationToken = default)
     {
-        throw new NotImplementedException();
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+            var usr = await context.Users.FirstOrDefaultAsync(u => u.Id == user.Id, cancellationToken: cancellationToken);
+            if (usr == null)
+            {
+                return Result.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();
+        }
+        catch (Exception e)
+        {
+            return Result.Failed("Failed to delete user!", e);
+        }
     }
 
-    public Task<Result<AuthorityUser>> GetUserByEmailAsync(string email, CancellationToken? cancellationToken = null)
+    public async Task<Result<AuthorityUser>> GetUserByEmailAsync(string email, CancellationToken cancellationToken = default)
     {
-        throw new NotImplementedException();
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+            var usr = await context.Users.FirstOrDefaultAsync(u => u.EmailAddress == email, cancellationToken: cancellationToken);
+            return Result<AuthorityUser>.HandleResult(usr, "User not found by given email address.");
+        }
+        catch (Exception e)
+        {
+            return Result<AuthorityUser>.Failed("An error occured while getting the user.", e);
+        }
     }
 
-    public Task<Result> SetVersionAsync(AuthorityUser user, long version, CancellationToken? cancellationToken = null)
+    public async Task<Result> SetVersionAsync(AuthorityUser user, long version, CancellationToken cancellationToken = default)
     {
-        throw new NotImplementedException();
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+            var usr = await context.Users.FirstOrDefaultAsync(u => u.Id == user.Id, cancellationToken);
+            if (usr == null)
+            {
+                return Result.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!");
+            }
+            
+            usr.Version = version;
+            context.Users.Update(usr);
+            var saveResult = await context.SaveChangesAsync(cancellationToken);
+            return saveResult <= 0 ? Result.Failed("Failed to update user!") : Result.Ok();
+        }
+        catch (Exception e)
+        {
+            return Result.Failed("An error occured while updating the version.", e);
+        }
     }
 
-    public Task<Result<long>> GetVersionAsync(AuthorityUser user, CancellationToken? cancellationToken = null)
+    public async Task<Result<long>> GetVersionAsync(AuthorityUser user, CancellationToken cancellationToken = default)
     {
-        throw new NotImplementedException();
+        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!");
+        }
+        catch (Exception e)
+        {
+            return Result<long>.Failed("An error occured while getting the user version.", e);
+        }
     }
 
-    public Task<Result> SetSecurityVersionAsync(AuthorityUser user, long version, CancellationToken? cancellationToken = null)
+    public async Task<Result> SetSecurityVersionAsync(AuthorityUser user, long securityVersion, CancellationToken cancellationToken = default)
     {
-        throw new NotImplementedException();
+        try
+        {
+            await using var context = await contextFactory.CreateDbContextAsync(cancellationToken);
+            var usr = await context.Users.FirstOrDefaultAsync(u => u.Id == user.Id, cancellationToken);
+            if (usr == null)
+            {
+                return Result.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!");
+            }
+            
+            usr.SecurityVersion = securityVersion;
+            context.Users.Update(usr);
+            var saveResult = await context.SaveChangesAsync(cancellationToken);
+            return saveResult <= 0 ? Result.Failed("Failed to update user!") : Result.Ok();
+        }
+        catch (Exception e)
+        {
+            return Result.Failed("An error occured while updating the security version.", e);
+        }
     }
 
-    public Task<Result<long>> GetSecurityVersionAsync(AuthorityUser user, CancellationToken? cancellationToken = null)
+    public async Task<Result<long>> GetSecurityVersionAsync(AuthorityUser user, CancellationToken cancellationToken = default)
     {
-        throw new NotImplementedException();
+        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!");
+        }
+        catch (Exception e)
+        {
+            return Result<long>.Failed("An error occured while getting the user security version.", e);
+        }
     }
 }

DotBased.AspNet.Authority/Managers/AuthorityUserManager.cs

@@ -34,13 +34,13 @@ 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 = null)
+    public async Task<ListResult<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 = null)
+    public async Task<AuthorityResult<AuthorityUser>> UpdatePasswordAsync(AuthorityUser user, string password, CancellationToken cancellationToken = default)
     {
         var passwordValidation = await ValidatePasswordAsync(user, password);
         if (!passwordValidation.Success)
@@ -57,7 +57,7 @@ public partial class AuthorityManager
         return AuthorityResult<AuthorityUser>.FromResult(updateResult);
     }
 
-    public async Task<AuthorityResult<AuthorityUser>> CreateUserAsync(AuthorityUser userModel, string password, CancellationToken? cancellationToken = null)
+    public async Task<AuthorityResult<AuthorityUser>> CreateUserAsync(AuthorityUser userModel, string password, CancellationToken cancellationToken = default)
     {
         var userValidation = await ValidateUserAsync(userModel);
         var passwordValidation = await ValidatePasswordAsync(userModel, password);
@@ -79,13 +79,13 @@ public partial class AuthorityManager
         return AuthorityResult<AuthorityUser>.FromResult(userCreationResult);
     }
 
-    public async Task<Result<AuthorityUser>> UpdateUserAsync(AuthorityUser model, CancellationToken? cancellationToken = null)
+    public async Task<Result<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 = null)
+    public async Task<Result> DeleteUserAsync(AuthorityUser model, CancellationToken cancellationToken = default)
     {
         var deleteResult = await UserRepository.DeleteUserAsync(model, cancellationToken);
         return deleteResult;

DotBased.AspNet.Authority/Repositories/IUserRepository.cs

@@ -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 = null);
+    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 = null);
+    public Task<Result<AuthorityUser>> GetAuthorityUserByIdAsync(string id, CancellationToken cancellationToken = default);
-    public Task<Result<AuthorityUser>> CreateUserAsync(AuthorityUser user, CancellationToken? cancellationToken = null);
+    public Task<Result<AuthorityUser>> CreateUserAsync(AuthorityUser user, CancellationToken cancellationToken = default);
-    public Task<Result<AuthorityUser>> UpdateUserAsync(AuthorityUser user, CancellationToken? cancellationToken = null);
+    public Task<Result<AuthorityUser>> UpdateUserAsync(AuthorityUser user, CancellationToken cancellationToken = default);
-    public Task<Result> DeleteUserAsync(AuthorityUser user, CancellationToken? cancellationToken = null);
+    public Task<Result> DeleteUserAsync(AuthorityUser user, CancellationToken cancellationToken = default);
-    public Task<Result<AuthorityUser>> GetUserByEmailAsync(string email, CancellationToken? cancellationToken = null);
+    public Task<Result<AuthorityUser>> GetUserByEmailAsync(string email, CancellationToken cancellationToken = default);
-    public Task<Result> SetVersionAsync(AuthorityUser user, long version, CancellationToken? cancellationToken = null);
+    public Task<Result> SetVersionAsync(AuthorityUser user, long version, CancellationToken cancellationToken = default);
-    public Task<Result<long>> GetVersionAsync(AuthorityUser user, CancellationToken? cancellationToken = null);
+    public Task<Result<long>> GetVersionAsync(AuthorityUser user, CancellationToken cancellationToken = default);
-    public Task<Result> SetSecurityVersionAsync(AuthorityUser user, long version, CancellationToken? cancellationToken = null);
+    public Task<Result> SetSecurityVersionAsync(AuthorityUser user, long securityVersion, CancellationToken cancellationToken = default);
-    public Task<Result<long>> GetSecurityVersionAsync(AuthorityUser user, CancellationToken? cancellationToken = null);
+    public Task<Result<long>> GetSecurityVersionAsync(AuthorityUser user, CancellationToken cancellationToken = default);
 }

DotBased/Result.cs

@@ -43,6 +43,11 @@ public class Result<TValue> : Result
 
     public new static Result<TValue> Failed(string message, Exception? exception = null) =>
         new(false, message, default, exception);
+
+    public new static Result<TValue> HandleResult(TValue? value, string failedMessage, Exception? exception = null)
+    {
+        return value == null ? Failed(failedMessage, exception) : Ok(value);
+    }
 }
 
 public class ListResult<TItem> : Result