Refactored

dotnet/AipsCore/Application/Models/Whiteboard/Command/AcceptUserRequestToJoin/AcceptUserRequestToJoinCommand.cs

@@ -0,0 +1,5 @@
+using AipsCore.Application.Abstract.Command;
+
+namespace AipsCore.Application.Models.Whiteboard.Command.AcceptUserRequestToJoin;
+
+public record AcceptUserRequestToJoinCommand(string WhiteboardId, string UserId): ICommand;

dotnet/AipsCore/Application/Models/Whiteboard/Command/AcceptUserRequestToJoin/AcceptUserRequestToJoinCommandHandler.cs

@@ -0,0 +1,40 @@
+using AipsCore.Application.Abstract.Command;
+using AipsCore.Domain.Abstract;
+using AipsCore.Domain.Common.Validation;
+using AipsCore.Domain.Models.User.ValueObjects;
+using AipsCore.Domain.Models.Whiteboard.ValueObjects;
+using AipsCore.Domain.Models.WhiteboardMembership.Enums;
+using AipsCore.Domain.Models.WhiteboardMembership.External;
+using AipsCore.Domain.Models.WhiteboardMembership.Validation;
+
+namespace AipsCore.Application.Models.Whiteboard.Command.AcceptUserRequestToJoin;
+
+public class AcceptUserRequestToJoinCommandHandler : ICommandHandler<AcceptUserRequestToJoinCommand>
+{
+    private readonly IWhiteboardMembershipRepository _whiteboardMembershipRepository;
+    private readonly IUnitOfWork _unitOfWork;
+
+    public AcceptUserRequestToJoinCommandHandler(IWhiteboardMembershipRepository whiteboardMembershipRepository, IUnitOfWork unitOfWork)
+    {
+        _whiteboardMembershipRepository = whiteboardMembershipRepository;
+        _unitOfWork = unitOfWork;
+    }
+
+    public async Task Handle(AcceptUserRequestToJoinCommand command, CancellationToken cancellationToken = default)
+    {
+        var whiteboardId = new WhiteboardId(command.WhiteboardId);
+        var userId = new UserId(command.UserId);
+
+        var membership = await _whiteboardMembershipRepository.GetByWhiteboardAndUserAsync(whiteboardId, userId, cancellationToken);
+
+        if (membership is null)
+        {
+            throw new ValidationException(WhiteboardMembershipErrors.NotFound(whiteboardId, userId));
+        }
+        
+        membership.UpdateStatus(WhiteboardMembershipStatus.Accepted);
+        
+        await _whiteboardMembershipRepository.SaveAsync(membership, cancellationToken);
+        await _unitOfWork.SaveChangesAsync(cancellationToken);
+    }
+}

dotnet/AipsCore/Application/Models/Whiteboard/Command/AddUserToWhiteboard/AddUserToWhiteboardCommand.cs

@@ -1,11 +0,0 @@
-using AipsCore.Application.Abstract.Command;
-using AipsCore.Domain.Models.User.ValueObjects;
-using AipsCore.Domain.Models.Whiteboard.ValueObjects;
-using AipsCore.Domain.Models.WhiteboardMembership.ValueObjects;
-
-namespace AipsCore.Application.Models.Whiteboard.Command.AddUserToWhiteboard;
-
-public record AddUserToWhiteboardCommand(
-    string UserId, 
-    string WhiteboardId)
-    : ICommand;

dotnet/AipsCore/Application/Models/Whiteboard/Command/AddUserToWhiteboard/AddUserToWhiteboardCommandErrors.cs

@@ -1,12 +0,0 @@
-using AipsCore.Domain.Common.Validation;
-using AipsCore.Domain.Models.Whiteboard.ValueObjects;
-
-namespace AipsCore.Application.Models.Whiteboard.Command.AddUserToWhiteboard;
-
-public static class AddUserToWhiteboardCommandErrors
-{
-    public static ValidationError WhiteboardDoesNotExist(WhiteboardId whiteboardId)
-        => new ValidationError(
-            Code: "whiteboard_not_exists", 
-            Message: $"Whiteboard with id '{whiteboardId}' does not exist.");
-}

dotnet/AipsCore/Application/Models/Whiteboard/Command/AddUserToWhiteboard/AddUserToWhiteboardCommandHandler.cs

@@ -1,65 +0,0 @@
-using AipsCore.Application.Abstract;
-using AipsCore.Application.Abstract.Command;
-using AipsCore.Domain.Abstract;
-using AipsCore.Domain.Common.Validation;
-using AipsCore.Domain.Models.User.External;
-using AipsCore.Domain.Models.User.Validation;
-using AipsCore.Domain.Models.User.ValueObjects;
-using AipsCore.Domain.Models.Whiteboard.External;
-using AipsCore.Domain.Models.Whiteboard.Validation;
-using AipsCore.Domain.Models.Whiteboard.ValueObjects;
-using AipsCore.Domain.Models.WhiteboardMembership.External;
-
-namespace AipsCore.Application.Models.Whiteboard.Command.AddUserToWhiteboard;
-
-public class AddUserToWhiteboardCommandHandler
-    : ICommandHandler<AddUserToWhiteboardCommand>
-{
-    private readonly IWhiteboardRepository _whiteboardRepository;
-    private readonly IWhiteboardMembershipRepository _whiteboardMembershipRepository;
-    private readonly IUserRepository _userRepository;
-    private readonly IUnitOfWork _unitOfWork;
-    private readonly IDispatcher _dispatcher;
-
-    public AddUserToWhiteboardCommandHandler(
-        IWhiteboardRepository whiteboardRepository,
-        IWhiteboardMembershipRepository whiteboardMembershipRepository,
-        IUserRepository userRepository,
-        IUnitOfWork unitOfWork,
-        IDispatcher dispatcher)
-    {
-        _whiteboardRepository = whiteboardRepository;
-        _whiteboardMembershipRepository = whiteboardMembershipRepository;
-        _userRepository = userRepository;
-        _unitOfWork = unitOfWork;
-        _dispatcher = dispatcher;
-    }
-
-    private Domain.Models.Whiteboard.Whiteboard? _whiteboard;
-    private Domain.Models.User.User? _user;
-    
-    public async Task Handle(AddUserToWhiteboardCommand command, CancellationToken cancellationToken = default)
-    {
-        _whiteboard = await _whiteboardRepository.GetByIdAsync(new WhiteboardId(command.WhiteboardId), cancellationToken);
-        _user = await _userRepository.GetByIdAsync(new UserId(command.UserId), cancellationToken);
-        
-        Validate(command);
-        
-        await _whiteboard!.AddUserAsync(_user!, _whiteboardMembershipRepository, cancellationToken);
-
-        await _unitOfWork.SaveChangesAsync(cancellationToken);
-    }
-
-    private void Validate(AddUserToWhiteboardCommand command)
-    {
-        if (_whiteboard is null)
-        {
-            throw new ValidationException(WhiteboardErrors.NotFound(new WhiteboardId(command.WhiteboardId)));
-        }
-
-        if (_user is null)
-        {
-            throw new ValidationException(UserErrors.NotFound(new UserId(command.UserId)));
-        }
-    }
-}

dotnet/AipsCore/Application/Models/Whiteboard/Command/BanUserFromWhiteboard/BanUserFromWhiteboardCommandErrors.cs

@@ -1,18 +0,0 @@
-using AipsCore.Domain.Common.Validation;
-using AipsCore.Domain.Models.User.ValueObjects;
-using AipsCore.Domain.Models.Whiteboard.ValueObjects;
-
-namespace AipsCore.Application.Models.Whiteboard.Command.BanUserFromWhiteboard;
-
-public static class BanUserFromWhiteboardCommandErrors
-{
-    public static ValidationError WhiteboardMembershipNotFound(WhiteboardId whiteboardId, UserId userId)
-        => new ValidationError(
-            Code: "whiteboard_membership_not_found",
-            Message: $"User with id '{userId.IdValue}' is not a member of whiteboard with id '{whiteboardId.IdValue}'");
-    
-    public static ValidationError WhiteboardNotFound(WhiteboardId whiteboardId)
-        => new ValidationError(
-            Code: "whiteboard_not_found",
-            Message: $"Whiteboard with id '{whiteboardId.IdValue}' not found.");
-}

dotnet/AipsCore/Application/Models/Whiteboard/Command/BanUserFromWhiteboard/BanUserFromWhiteboardCommandHandler.cs

@@ -4,8 +4,10 @@ using AipsCore.Domain.Abstract;
 using AipsCore.Domain.Common.Validation;
 using AipsCore.Domain.Models.User.ValueObjects;
 using AipsCore.Domain.Models.Whiteboard.External;
+using AipsCore.Domain.Models.Whiteboard.Validation;
 using AipsCore.Domain.Models.Whiteboard.ValueObjects;
 using AipsCore.Domain.Models.WhiteboardMembership.External;
+using AipsCore.Domain.Models.WhiteboardMembership.Validation;
 
 namespace AipsCore.Application.Models.Whiteboard.Command.BanUserFromWhiteboard;
 
@@ -37,14 +39,14 @@ public class BanUserFromWhiteboardCommandHandler : ICommandHandler<BanUserFromWh
 
         if (whiteboard is null)
         {
-            throw new ValidationException(BanUserFromWhiteboardCommandErrors.WhiteboardNotFound(whiteboardId));
+            throw new ValidationException(WhiteboardErrors.NotFound(whiteboardId));
         }
         
         var membership = await _whiteboardMembershipRepository.GetByWhiteboardAndUserAsync(whiteboardId, userId, cancellationToken);
 
         if (membership is null)
         {
-            throw new ValidationException(BanUserFromWhiteboardCommandErrors.WhiteboardMembershipNotFound(whiteboardId, userId));
+            throw new ValidationException(WhiteboardMembershipErrors.NotFound(whiteboardId, userId));
         }
         
         whiteboard.BanUser(_userContext.GetCurrentUserId(), membership);

dotnet/AipsCore/Application/Models/Whiteboard/Command/KickUserFromWhiteboard/KickUserFromWhiteboardCommandErrors.cs

@@ -1,18 +0,0 @@
-using AipsCore.Domain.Common.Validation;
-using AipsCore.Domain.Models.User.ValueObjects;
-using AipsCore.Domain.Models.Whiteboard.ValueObjects;
-
-namespace AipsCore.Application.Models.Whiteboard.Command.KickUserFromWhiteboard;
-
-public static class KickUserFromWhiteboardCommandErrors
-{
-    public static ValidationError WhiteboardMembershipNotFound(WhiteboardId whiteboardId, UserId userId)
-        => new ValidationError(
-            Code: "whiteboard_membership_not_found",
-            Message: $"User with id '{userId}' is not a member of whiteboard with id '{whiteboardId}'");
-    
-    public static ValidationError WhiteboardNotFound(WhiteboardId whiteboardId)
-        => new ValidationError(
-            Code: "whiteboard_not_found",
-            Message: $"Whiteboard with id '{whiteboardId}' not found.");
-}

dotnet/AipsCore/Application/Models/Whiteboard/Command/KickUserFromWhiteboard/KickUserFromWhiteboardCommandHandler.cs

@@ -4,8 +4,10 @@ using AipsCore.Domain.Abstract;
 using AipsCore.Domain.Common.Validation;
 using AipsCore.Domain.Models.User.ValueObjects;
 using AipsCore.Domain.Models.Whiteboard.External;
+using AipsCore.Domain.Models.Whiteboard.Validation;
 using AipsCore.Domain.Models.Whiteboard.ValueObjects;
 using AipsCore.Domain.Models.WhiteboardMembership.External;
+using AipsCore.Domain.Models.WhiteboardMembership.Validation;
 
 namespace AipsCore.Application.Models.Whiteboard.Command.KickUserFromWhiteboard;
 
@@ -37,14 +39,14 @@ public class KickUserFromWhiteboardCommandHandler : ICommandHandler<KickUserFrom
 
         if (whiteboard is null)
         {
-            throw new ValidationException(KickUserFromWhiteboardCommandErrors.WhiteboardNotFound(whiteboardId));
+            throw new ValidationException(WhiteboardErrors.NotFound(whiteboardId));
         }
         
         var membership = await _whiteboardMembershipRepository.GetByWhiteboardAndUserAsync(whiteboardId, userId, cancellationToken);
 
         if (membership is null)
         {
-            throw new ValidationException(KickUserFromWhiteboardCommandErrors.WhiteboardMembershipNotFound(whiteboardId, userId));
+            throw new ValidationException(WhiteboardMembershipErrors.NotFound(whiteboardId, userId));
         }
         
         whiteboard.KickUser(_userContext.GetCurrentUserId(), membership);

dotnet/AipsCore/Application/Models/Whiteboard/Command/RejectUserRequestToJoin/RejectUserRequestToJoinCommand.cs

@@ -0,0 +1,5 @@
+using AipsCore.Application.Abstract.Command;
+
+namespace AipsCore.Application.Models.Whiteboard.Command.RejectUserRequestToJoin;
+
+public record RejectUserRequestToJoinCommand(string WhiteboardId, string UserId): ICommand;

dotnet/AipsCore/Application/Models/Whiteboard/Command/RejectUserRequestToJoin/RejectUserRequestToJoinCommandHandler.cs

@@ -0,0 +1,40 @@
+using AipsCore.Application.Abstract.Command;
+using AipsCore.Domain.Abstract;
+using AipsCore.Domain.Common.Validation;
+using AipsCore.Domain.Models.User.ValueObjects;
+using AipsCore.Domain.Models.Whiteboard.ValueObjects;
+using AipsCore.Domain.Models.WhiteboardMembership.Enums;
+using AipsCore.Domain.Models.WhiteboardMembership.External;
+using AipsCore.Domain.Models.WhiteboardMembership.Validation;
+
+namespace AipsCore.Application.Models.Whiteboard.Command.RejectUserRequestToJoin;
+
+public class RejectUserRequestToJoinCommandHandler : ICommandHandler<RejectUserRequestToJoinCommand>
+{
+    private readonly IWhiteboardMembershipRepository _whiteboardMembershipRepository;
+    private readonly IUnitOfWork _unitOfWork;
+
+    public RejectUserRequestToJoinCommandHandler(IWhiteboardMembershipRepository whiteboardMembershipRepository, IUnitOfWork unitOfWork)
+    {
+        _whiteboardMembershipRepository = whiteboardMembershipRepository;
+        _unitOfWork = unitOfWork;
+    }
+
+    public async Task Handle(RejectUserRequestToJoinCommand command, CancellationToken cancellationToken = default)
+    {
+        var whiteboardId = new WhiteboardId(command.WhiteboardId);
+        var userId = new UserId(command.UserId);
+        
+        var membership = await _whiteboardMembershipRepository.GetByWhiteboardAndUserAsync(whiteboardId, userId, cancellationToken);
+
+        if (membership is null)
+        {
+            throw new ValidationException(WhiteboardMembershipErrors.NotFound(whiteboardId, userId));
+        }
+        
+        membership.UpdateStatus(WhiteboardMembershipStatus.Rejected);
+        
+        await _whiteboardMembershipRepository.SaveAsync(membership, cancellationToken);
+        await _unitOfWork.SaveChangesAsync(cancellationToken);
+    }
+}

dotnet/AipsCore/Application/Models/Whiteboard/Command/UnbanUserFromWhiteboard/UnbanUserFromWhiteboardCommandErrors.cs

@@ -1,18 +0,0 @@
-using AipsCore.Domain.Common.Validation;
-using AipsCore.Domain.Models.User.ValueObjects;
-using AipsCore.Domain.Models.Whiteboard.ValueObjects;
-
-namespace AipsCore.Application.Models.Whiteboard.Command.UnbanUserFromWhiteboard;
-
-public static class UnbanUserFromWhiteboardCommandErrors
-{
-    public static ValidationError WhiteboardMembershipNotFound(WhiteboardId whiteboardId, UserId userId)
-        => new ValidationError(
-            Code: "whiteboard_membership_not_found",
-            Message: $"User with id '{userId}' is not a member of whiteboard with id '{whiteboardId}'");
-    
-    public static ValidationError WhiteboardNotFound(WhiteboardId whiteboardId)
-        => new ValidationError(
-            Code: "whiteboard_not_found",
-            Message: $"Whiteboard with id '{whiteboardId}' not found.");
-}

dotnet/AipsCore/Application/Models/Whiteboard/Command/UnbanUserFromWhiteboard/UnbanUserFromWhiteboardCommandHandler.cs

@@ -4,8 +4,10 @@ using AipsCore.Domain.Abstract;
 using AipsCore.Domain.Common.Validation;
 using AipsCore.Domain.Models.User.ValueObjects;
 using AipsCore.Domain.Models.Whiteboard.External;
+using AipsCore.Domain.Models.Whiteboard.Validation;
 using AipsCore.Domain.Models.Whiteboard.ValueObjects;
 using AipsCore.Domain.Models.WhiteboardMembership.External;
+using AipsCore.Domain.Models.WhiteboardMembership.Validation;
 
 namespace AipsCore.Application.Models.Whiteboard.Command.UnbanUserFromWhiteboard;
 
@@ -37,14 +39,14 @@ public class UnbanUserFromWhiteboardCommandHandler : ICommandHandler<UnbanUserFr
 
         if (whiteboard is null)
         {
-            throw new ValidationException(UnbanUserFromWhiteboardCommandErrors.WhiteboardNotFound(whiteboardId));
+            throw new ValidationException(WhiteboardErrors.NotFound(whiteboardId));
         }
         
         var membership = await _whiteboardMembershipRepository.GetByWhiteboardAndUserAsync(whiteboardId, userId, cancellationToken);
 
         if (membership is null)
         {
-            throw new ValidationException(UnbanUserFromWhiteboardCommandErrors.WhiteboardMembershipNotFound(whiteboardId, userId));
+            throw new ValidationException(WhiteboardMembershipErrors.NotFound(whiteboardId, userId));
         }
         
         whiteboard.UnbanUser(_userContext.GetCurrentUserId(), membership);

dotnet/AipsCore/Domain/Models/Whiteboard/External/IWhiteboardRepository.cs

@@ -6,5 +6,6 @@ namespace AipsCore.Domain.Models.Whiteboard.External;
 public interface IWhiteboardRepository 
     : IAbstractRepository<Whiteboard, WhiteboardId>, ISoftDeletableRepository<WhiteboardId>
 {
-    Task<bool> WhiteboardCodeExists(WhiteboardCode whiteboardCode);
+    Task<bool> WhiteboardCodeExistsAsync(WhiteboardCode whiteboardCode);
+    Task<Whiteboard?> GetByCodeAsync(WhiteboardCode whiteboardCode, CancellationToken cancellationToken = default);
 }

dotnet/AipsCore/Domain/Models/Whiteboard/Validation/WhiteboardErrors.cs

@@ -7,6 +7,38 @@ namespace AipsCore.Domain.Models.Whiteboard.Validation;
 
 public class WhiteboardErrors : AbstractErrors<Whiteboard, WhiteboardId>
 {
+    public static ValidationError NotFound(WhiteboardCode whiteboardCode)
+    {
+        const string code = "not_found";
+        string message = $"Whiteboard with code '{whiteboardCode.CodeValue}' was not found!";
+        
+        return CreateValidationError(code,message);
+    }
+    
+    public static ValidationError CannotJoin(WhiteboardCode whiteboardCode)
+    {
+        const string code = "cannot_join_whiteboard";
+        string message = $"Cannot join the whiteboard with code '{whiteboardCode.CodeValue}'";
+        
+        return CreateValidationError(code,message);
+    }
+    
+    public static ValidationError UserBanned(UserId userId)
+    {
+        const string code = "user_banned_from_whiteboard";
+        string message = $"User with id '{userId}' is banned from this whiteboard.";
+        
+        return CreateValidationError(code,message);
+    }
+    
+    public static ValidationError UserAlreadyTryingToJoin(UserId userId)
+    {
+        const string code = "user_already_trying_to_join_whiteboard";
+        string message = $"User with id '{userId}' is already trying to join the whiteboard.";
+        
+        return CreateValidationError(code,message);
+    }
+    
     public static ValidationError UserAlreadyAdded(UserId userId)
     {
         string code = "user_already_added";

dotnet/AipsCore/Domain/Models/Whiteboard/ValueObjects/WhiteboardCode.cs

@@ -36,7 +36,7 @@ public record WhiteboardCode : AbstractValueObject
         {
             whiteboardCode = Generate();
 
-            codeExists = await whiteboardRepository.WhiteboardCodeExists(whiteboardCode);
+            codeExists = await whiteboardRepository.WhiteboardCodeExistsAsync(whiteboardCode);
         } while (codeExists);
 
         return whiteboardCode;

dotnet/AipsCore/Domain/Models/Whiteboard/Whiteboard.AddUser.cs

@@ -1,42 +1,47 @@
-using System.Runtime.InteropServices.Swift;
-using AipsCore.Domain.Abstract;
 using AipsCore.Domain.Common.Validation;
+using AipsCore.Domain.Models.User.ValueObjects;
 using AipsCore.Domain.Models.Whiteboard.Enums;
 using AipsCore.Domain.Models.Whiteboard.Validation;
-using AipsCore.Domain.Models.Whiteboard.ValueObjects;
+using AipsCore.Domain.Models.WhiteboardMembership.Enums;
-using AipsCore.Domain.Models.WhiteboardMembership.External;
 
 namespace AipsCore.Domain.Models.Whiteboard;
 
-public partial class Whiteboard : DomainModel<WhiteboardId>
+public partial class Whiteboard 
 {
-    public async Task AddUserAsync(
+    public WhiteboardMembership.WhiteboardMembership RequestJoin(UserId userId)
-        User.User user, 
-        IWhiteboardMembershipRepository membershipRepository, 
-        CancellationToken cancellationToken = default)
     {
-        var membership 
+        return WhiteboardMembership.WhiteboardMembership.Create(
-            = await membershipRepository.GetByWhiteboardAndUserAsync(this.Id, user.Id, cancellationToken);
+            Id.IdValue,
-
+            userId.IdValue,
-        if (membership is not null)
-        {
-            throw new ValidationException(WhiteboardErrors.UserAlreadyAdded(user.Id));
-        }
-
-        membership = WhiteboardMembership.WhiteboardMembership.Create(
-            this.Id.IdValue,
-            user.Id.IdValue,
             false,
-            false,
+            DetermineJoinStatus(),
-            this.GetCanJoin(),
+            DateTime.UtcNow);
-            DateTime.UtcNow
-        );
-        
-        await membershipRepository.AddAsync(membership, cancellationToken);
     }
 
-    private bool GetCanJoin()
+    public void RequestReJoin(WhiteboardMembership.WhiteboardMembership membership)
     {
-        return this.JoinPolicy == WhiteboardJoinPolicy.FreeToJoin;
+        switch (membership.Status)
+        {
+            case WhiteboardMembershipStatus.Banned:
+                throw new ValidationException(WhiteboardErrors.UserBanned(membership.UserId));
+            case WhiteboardMembershipStatus.Pending:
+                throw new ValidationException(WhiteboardErrors.UserAlreadyTryingToJoin(membership.UserId));
+            case WhiteboardMembershipStatus.Accepted:
+                break;
+            default:
+                membership.UpdateStatus(DetermineJoinStatus());
+                break;
+        }
+    }
+
+    private WhiteboardMembershipStatus DetermineJoinStatus()
+    {
+        return JoinPolicy switch
+        {
+            WhiteboardJoinPolicy.FreeToJoin => WhiteboardMembershipStatus.Accepted,
+            WhiteboardJoinPolicy.RequestToJoin => WhiteboardMembershipStatus.Pending,
+            WhiteboardJoinPolicy.Private => throw new ValidationException(WhiteboardErrors.CannotJoin(Code)),
+            _ => throw new ArgumentOutOfRangeException()
+        };
     }
 }  

dotnet/AipsCore/Domain/Models/Whiteboard/Whiteboard.BanUser.cs

@@ -1,18 +0,0 @@
-using AipsCore.Domain.Common.Validation;
-using AipsCore.Domain.Models.User.ValueObjects;
-using AipsCore.Domain.Models.Whiteboard.Validation;
-
-namespace AipsCore.Domain.Models.Whiteboard;
-
-public partial class Whiteboard
-{
-    public void BanUser(UserId currentUserId, WhiteboardMembership.WhiteboardMembership whiteboardMembership)
-    {
-        if (WhiteboardOwnerId != currentUserId)
-        {
-            throw new ValidationException(WhiteboardErrors.OnlyOwnerCanBanOtherUsers(currentUserId));
-        }
-
-        whiteboardMembership.Ban();
-    }
-}

dotnet/AipsCore/Domain/Models/Whiteboard/Whiteboard.CanUserDelete.cs

@@ -6,6 +6,11 @@ public partial class Whiteboard
 {
     public bool CanUserDelete(UserId userId)
     {
-        return WhiteboardOwnerId.IdValue == userId.IdValue;
+        return IsOwner(userId);
+    }
+
+    public bool ShouldRequestToJoin(UserId userId)
+    {
+        return !IsOwner(userId);
     }
 }

dotnet/AipsCore/Domain/Models/Whiteboard/Whiteboard.KickUser.cs

@@ -1,18 +0,0 @@
-using AipsCore.Domain.Common.Validation;
-using AipsCore.Domain.Models.User.ValueObjects;
-using AipsCore.Domain.Models.Whiteboard.Validation;
-
-namespace AipsCore.Domain.Models.Whiteboard;
-
-public partial class Whiteboard
-{
-    public void KickUser(UserId currentUserId, WhiteboardMembership.WhiteboardMembership whiteboardMembership)
-    {
-        if (WhiteboardOwnerId != currentUserId)
-        {
-            throw new ValidationException(WhiteboardErrors.OnlyOwnerCanKickOtherUsers(currentUserId));
-        }
-
-        whiteboardMembership.Kick();
-    }
-}

dotnet/AipsCore/Domain/Models/Whiteboard/Whiteboard.ManageUsers.cs

@@ -0,0 +1,43 @@
+using AipsCore.Domain.Common.Validation;
+using AipsCore.Domain.Models.User.ValueObjects;
+using AipsCore.Domain.Models.Whiteboard.Validation;
+
+namespace AipsCore.Domain.Models.Whiteboard;
+
+public partial class Whiteboard
+{
+    public void BanUser(UserId currentUserId, WhiteboardMembership.WhiteboardMembership whiteboardMembership)
+    {
+        if (IsOwner(currentUserId))
+        {
+            throw new ValidationException(WhiteboardErrors.OnlyOwnerCanBanOtherUsers(currentUserId));
+        }
+
+        whiteboardMembership.Ban();
+    }
+    
+    public void UnbanUser(UserId currentUserId, WhiteboardMembership.WhiteboardMembership whiteboardMembership)
+    {
+        if (IsOwner(currentUserId))
+        {
+            throw new ValidationException(WhiteboardErrors.OnlyOwnerCanUnbanOtherUsers(currentUserId));
+        }
+
+        whiteboardMembership.Unban();
+    }
+    
+    public void KickUser(UserId currentUserId, WhiteboardMembership.WhiteboardMembership whiteboardMembership)
+    {
+        if (IsOwner(currentUserId))
+        {
+            throw new ValidationException(WhiteboardErrors.OnlyOwnerCanKickOtherUsers(currentUserId));
+        }
+
+        whiteboardMembership.Kick();
+    }
+
+    private bool IsOwner(UserId userId)
+    {
+        return WhiteboardOwnerId.IdValue == userId.IdValue;
+    }
+}

dotnet/AipsCore/Domain/Models/Whiteboard/Whiteboard.UnbanUser.cs

@@ -1,18 +0,0 @@
-using AipsCore.Domain.Common.Validation;
-using AipsCore.Domain.Models.User.ValueObjects;
-using AipsCore.Domain.Models.Whiteboard.Validation;
-
-namespace AipsCore.Domain.Models.Whiteboard;
-
-public partial class Whiteboard
-{
-    public void UnbanUser(UserId currentUserId, WhiteboardMembership.WhiteboardMembership whiteboardMembership)
-    {
-        if (WhiteboardOwnerId != currentUserId)
-        {
-            throw new ValidationException(WhiteboardErrors.OnlyOwnerCanUnbanOtherUsers(currentUserId));
-        }
-
-        whiteboardMembership.Unban();
-    }
-}

dotnet/AipsCore/Domain/Models/WhiteboardMembership/Enums/WhiteboardMembershipStatus.cs

@@ -0,0 +1,13 @@
+namespace AipsCore.Domain.Models.WhiteboardMembership.Enums;
+
+public enum WhiteboardMembershipStatus
+{
+    Pending,
+    Accepted,
+    Active,
+    Inactive,
+    Rejected,
+    Cancelled,
+    Kicked,
+    Banned
+}

dotnet/AipsCore/Domain/Models/WhiteboardMembership/Validation/WhiteboardMembershipErrors.cs

@@ -0,0 +1,18 @@
+using AipsCore.Domain.Abstract.Validation;
+using AipsCore.Domain.Common.Validation;
+using AipsCore.Domain.Models.User.ValueObjects;
+using AipsCore.Domain.Models.Whiteboard.ValueObjects;
+using AipsCore.Domain.Models.WhiteboardMembership.ValueObjects;
+
+namespace AipsCore.Domain.Models.WhiteboardMembership.Validation;
+
+public class WhiteboardMembershipErrors : AbstractErrors<WhiteboardMembership, WhiteboardMembershipId>
+{
+    public static ValidationError NotFound(WhiteboardId whiteboardId, UserId userId)
+    {
+        const string code = "whiteboard_membership_not_found";
+        string message = $"Whiteboard membership with whiteboard id {whiteboardId.IdValue} and user id {userId.IdValue} not found.";
+        
+        return CreateValidationError(code, message);
+    }
+}

dotnet/AipsCore/Domain/Models/WhiteboardMembership/ValueObjects/WhiteboardMembershipCanJoin.cs

@@ -1,20 +0,0 @@
-using AipsCore.Domain.Abstract.Rule;
-using AipsCore.Domain.Abstract.ValueObject;
-
-namespace AipsCore.Domain.Models.WhiteboardMembership.ValueObjects;
-
-public record WhiteboardMembershipCanJoin : AbstractValueObject
-{
-    public bool CanJoinValue { get; init; }
-
-    public WhiteboardMembershipCanJoin(bool CanJoinValue)
-    {
-        this.CanJoinValue = CanJoinValue;
-        Validate();
-    }
-    
-    protected override ICollection<IRule> GetValidationRules()
-    {
-        return [];
-    }
-}

dotnet/AipsCore/Domain/Models/WhiteboardMembership/ValueObjects/WhiteboardMembershipIsBanned.cs

@@ -1,20 +0,0 @@
-using AipsCore.Domain.Abstract.Rule;
-using AipsCore.Domain.Abstract.ValueObject;
-
-namespace AipsCore.Domain.Models.WhiteboardMembership.ValueObjects;
-
-public record WhiteboardMembershipIsBanned : AbstractValueObject
-{
-    public bool IsBannedValue { get; init; }
-
-    public WhiteboardMembershipIsBanned(bool IsBannedValue)
-    {
-        this.IsBannedValue = IsBannedValue;
-        Validate();
-    }
-    
-    protected override ICollection<IRule> GetValidationRules()
-    {
-        return [];
-    }
-}

dotnet/AipsCore/Domain/Models/WhiteboardMembership/WhiteboardMembership.Ban.cs

@@ -1,11 +0,0 @@
-using AipsCore.Domain.Models.WhiteboardMembership.ValueObjects;
-
-namespace AipsCore.Domain.Models.WhiteboardMembership;
-
-public partial class WhiteboardMembership
-{
-    public void Ban()
-    {
-        IsBanned = new WhiteboardMembershipIsBanned(true);
-    }
-}

dotnet/AipsCore/Domain/Models/WhiteboardMembership/WhiteboardMembership.Kick.cs

@@ -1,11 +0,0 @@
-using AipsCore.Domain.Models.WhiteboardMembership.ValueObjects;
-
-namespace AipsCore.Domain.Models.WhiteboardMembership;
-
-public partial class WhiteboardMembership
-{
-    public void Kick()
-    {
-        CanJoin = new WhiteboardMembershipCanJoin(false);
-    }
-}

dotnet/AipsCore/Domain/Models/WhiteboardMembership/WhiteboardMembership.Status.cs

@@ -0,0 +1,26 @@
+using AipsCore.Domain.Models.WhiteboardMembership.Enums;
+
+namespace AipsCore.Domain.Models.WhiteboardMembership;
+
+public partial class WhiteboardMembership
+{
+    public void Ban()
+    {
+        Status = WhiteboardMembershipStatus.Banned;
+    }
+    
+    public void Unban()
+    {
+        Status = WhiteboardMembershipStatus.Cancelled;
+    }
+    
+    public void Kick()
+    {
+        Status = WhiteboardMembershipStatus.Kicked;
+    }
+
+    public void UpdateStatus(WhiteboardMembershipStatus newStatus)
+    {
+        Status = newStatus;
+    }
+}

dotnet/AipsCore/Domain/Models/WhiteboardMembership/WhiteboardMembership.Unban.cs

@@ -1,11 +0,0 @@
-using AipsCore.Domain.Models.WhiteboardMembership.ValueObjects;
-
-namespace AipsCore.Domain.Models.WhiteboardMembership;
-
-public partial class WhiteboardMembership
-{
-    public void Unban()
-    {
-        IsBanned = new WhiteboardMembershipIsBanned(false);
-    }
-}

dotnet/AipsCore/Domain/Models/WhiteboardMembership/WhiteboardMembership.cs

@@ -1,6 +1,7 @@
 using AipsCore.Domain.Abstract;
 using AipsCore.Domain.Models.User.ValueObjects;
 using AipsCore.Domain.Models.Whiteboard.ValueObjects;
+using AipsCore.Domain.Models.WhiteboardMembership.Enums;
 using AipsCore.Domain.Models.WhiteboardMembership.ValueObjects;
 
 namespace AipsCore.Domain.Models.WhiteboardMembership;
@@ -9,97 +10,84 @@ public partial class WhiteboardMembership : DomainModel<WhiteboardMembershipId>
 {
     public WhiteboardId WhiteboardId { get; private set; }
     public UserId UserId { get; private set; }
-    public WhiteboardMembershipIsBanned IsBanned { get; private set; }
     public WhiteboardMembershipEditingEnabled EditingEnabled { get; private set; }
-    public WhiteboardMembershipCanJoin CanJoin { get; private set; }
+    public WhiteboardMembershipStatus Status { get; private set; }
     public WhiteboardMembershipLastInteractedAt LastInteractedAt { get; private set; }
 
     public WhiteboardMembership(
         WhiteboardMembershipId id,
-        Whiteboard.Whiteboard owner, 
+        Whiteboard.Whiteboard whiteboard, 
         User.User user,
-        WhiteboardMembershipIsBanned isBanned,
         WhiteboardMembershipEditingEnabled editingEnabled,
-        WhiteboardMembershipCanJoin canJoin,
+        WhiteboardMembershipStatus status,
         WhiteboardMembershipLastInteractedAt lastInteractedAt)
         : base(id)
     {
-        WhiteboardId = owner.Id;
+        WhiteboardId = whiteboard.Id;
         UserId = user.Id;
-        IsBanned = isBanned;
         EditingEnabled = editingEnabled;
-        CanJoin = canJoin;
+        Status = status;
         LastInteractedAt = lastInteractedAt;
     }
     
     public WhiteboardMembership(
         WhiteboardMembershipId id,
-        WhiteboardId ownerId, 
+        WhiteboardId whiteboardId, 
         UserId userId,
-        WhiteboardMembershipIsBanned isBanned,
         WhiteboardMembershipEditingEnabled editingEnabled,
-        WhiteboardMembershipCanJoin canJoin,
+        WhiteboardMembershipStatus status,
         WhiteboardMembershipLastInteractedAt lastInteractedAt)
         : base(id)
     {
-        WhiteboardId = ownerId;
+        WhiteboardId = whiteboardId;
         UserId = userId;
-        IsBanned = isBanned;
         EditingEnabled = editingEnabled;
-        CanJoin = canJoin;
+        Status = status;
         LastInteractedAt = lastInteractedAt;
     }
     
     public static WhiteboardMembership Create(
         string id, 
-        string ownerId,
+        string whiteboardId,
         string userId,
-        bool isBanned,
         bool editingEnabled,
-        bool canJoin,
+        WhiteboardMembershipStatus status,
         DateTime lastInteractedAt)
     {
         var whiteboardMembershipId = new WhiteboardMembershipId(id);
-        var whiteboardId = new WhiteboardId(ownerId);
+        var whiteboardIdVo = new WhiteboardId(whiteboardId);
         var userIdVo = new UserId(userId);
-        var isBannedVo = new WhiteboardMembershipIsBanned(isBanned);
         var editingEnabledVo = new WhiteboardMembershipEditingEnabled(editingEnabled);
-        var canJoinVo = new WhiteboardMembershipCanJoin(canJoin);
         var lastInteractedAtVo = new WhiteboardMembershipLastInteractedAt(lastInteractedAt);
         
         return new WhiteboardMembership(
             whiteboardMembershipId, 
-            whiteboardId, 
+            whiteboardIdVo, 
             userIdVo,
-            isBannedVo, 
             editingEnabledVo, 
-            canJoinVo, 
+            status,
             lastInteractedAtVo);
     }
     
     public static WhiteboardMembership Create(
-        string ownerId,
+        string whiteboardId,
         string userId,
-        bool isBanned,
         bool editingEnabled,
-        bool canJoin,
+        WhiteboardMembershipStatus status,
         DateTime lastInteractedAt)
     {
         var whiteboardMembershipId = WhiteboardMembershipId.Any();
-        var whiteboardId = new WhiteboardId(ownerId);
+        var whiteboardIdVo = new WhiteboardId(whiteboardId);
         var userIdVo = new UserId(userId);
-        var isBannedVo = new WhiteboardMembershipIsBanned(isBanned);
         var editingEnabledVo = new WhiteboardMembershipEditingEnabled(editingEnabled);
-        var canJoinVo = new WhiteboardMembershipCanJoin(canJoin);
         var lastInteractedAtVo = new WhiteboardMembershipLastInteractedAt(lastInteractedAt);
         
         return new WhiteboardMembership(
             whiteboardMembershipId, 
-            whiteboardId, 
+            whiteboardIdVo, 
             userIdVo, 
-            isBannedVo, 
             editingEnabledVo, 
-            canJoinVo, 
+            status,
             lastInteractedAtVo);
     }
 }