Merge branch 'main' into feature-whiteboard-query-getall

# Conflicts:
#	dotnet/AipsWebApi/Controllers/WhiteboardController.cs

dotnet/AipsCore/Application/Abstract/UserContext/IUserContext.cs

@@ -0,0 +1,8 @@
+using AipsCore.Domain.Models.User.ValueObjects;
+
+namespace AipsCore.Application.Abstract.UserContext;
+
+public interface IUserContext
+{
+    UserId GetCurrentUserId();
+}

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

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

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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,55 @@
+using AipsCore.Application.Abstract.Command;
+using AipsCore.Application.Abstract.UserContext;
+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.ValueObjects;
+using AipsCore.Domain.Models.WhiteboardMembership.External;
+
+namespace AipsCore.Application.Models.Whiteboard.Command.BanUserFromWhiteboard;
+
+public class BanUserFromWhiteboardCommandHandler : ICommandHandler<BanUserFromWhiteboardCommand>
+{
+    private readonly IWhiteboardRepository _whiteboardRepository;
+    private readonly IWhiteboardMembershipRepository _whiteboardMembershipRepository;
+    private readonly IUserContext _userContext;
+    private readonly IUnitOfWork _unitOfWork;
+    
+    public BanUserFromWhiteboardCommandHandler(
+        IWhiteboardRepository whiteboardRepository,
+        IWhiteboardMembershipRepository whiteboardMembershipRepository, 
+        IUserContext userContext,
+        IUnitOfWork unitOfWork)
+    {
+        _whiteboardMembershipRepository = whiteboardMembershipRepository;
+        _userContext = userContext;
+        _unitOfWork = unitOfWork;
+        _whiteboardRepository = whiteboardRepository;
+    }
+
+    public async Task Handle(BanUserFromWhiteboardCommand command, CancellationToken cancellationToken = default)
+    {
+        var whiteboardId = new WhiteboardId(command.WhiteboardId);
+        var userId = new UserId(command.UserId);
+
+        var whiteboard = await _whiteboardRepository.GetByIdAsync(whiteboardId, cancellationToken);
+
+        if (whiteboard is null)
+        {
+            throw new ValidationException(BanUserFromWhiteboardCommandErrors.WhiteboardNotFound(whiteboardId));
+        }
+        
+        var membership = await _whiteboardMembershipRepository.GetByWhiteboardAndUserAsync(whiteboardId, userId, cancellationToken);
+
+        if (membership is null)
+        {
+            throw new ValidationException(BanUserFromWhiteboardCommandErrors.WhiteboardMembershipNotFound(whiteboardId, userId));
+        }
+        
+        whiteboard.BanUser(_userContext.GetCurrentUserId(), membership);
+        
+        await _whiteboardMembershipRepository.SaveAsync(membership, cancellationToken);
+        await _unitOfWork.SaveChangesAsync(cancellationToken);
+    }
+}

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

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

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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,55 @@
+using AipsCore.Application.Abstract.Command;
+using AipsCore.Application.Abstract.UserContext;
+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.ValueObjects;
+using AipsCore.Domain.Models.WhiteboardMembership.External;
+
+namespace AipsCore.Application.Models.Whiteboard.Command.KickUserFromWhiteboard;
+
+public class KickUserFromWhiteboardCommandHandler : ICommandHandler<KickUserFromWhiteboardCommand>
+{
+    private readonly IWhiteboardRepository _whiteboardRepository;
+    private readonly IWhiteboardMembershipRepository _whiteboardMembershipRepository;
+    private readonly IUserContext _userContext;
+    private readonly IUnitOfWork _unitOfWork;
+    
+    public KickUserFromWhiteboardCommandHandler(
+        IWhiteboardRepository whiteboardRepository, 
+        IWhiteboardMembershipRepository whiteboardMembershipRepository, 
+        IUserContext userContext,
+        IUnitOfWork unitOfWork)
+    {
+        _whiteboardMembershipRepository = whiteboardMembershipRepository;
+        _userContext = userContext;
+        _unitOfWork = unitOfWork;
+        _whiteboardRepository = whiteboardRepository;
+    }
+    
+    public async Task Handle(KickUserFromWhiteboardCommand command, CancellationToken cancellationToken = default)
+    {
+        var whiteboardId = new WhiteboardId(command.WhiteboardId);
+        var userId = new UserId(command.UserId);
+
+        var whiteboard = await _whiteboardRepository.GetByIdAsync(whiteboardId, cancellationToken);
+
+        if (whiteboard is null)
+        {
+            throw new ValidationException(KickUserFromWhiteboardCommandErrors.WhiteboardNotFound(whiteboardId));
+        }
+        
+        var membership = await _whiteboardMembershipRepository.GetByWhiteboardAndUserAsync(whiteboardId, userId, cancellationToken);
+
+        if (membership is null)
+        {
+            throw new ValidationException(KickUserFromWhiteboardCommandErrors.WhiteboardMembershipNotFound(whiteboardId, userId));
+        }
+        
+        whiteboard.KickUser(_userContext.GetCurrentUserId(), membership);
+        
+        await _whiteboardMembershipRepository.SaveAsync(membership, cancellationToken);
+        await _unitOfWork.SaveChangesAsync(cancellationToken);
+    }
+}

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

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

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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,55 @@
+using AipsCore.Application.Abstract.Command;
+using AipsCore.Application.Abstract.UserContext;
+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.ValueObjects;
+using AipsCore.Domain.Models.WhiteboardMembership.External;
+
+namespace AipsCore.Application.Models.Whiteboard.Command.UnbanUserFromWhiteboard;
+
+public class UnbanUserFromWhiteboardCommandHandler : ICommandHandler<UnbanUserFromWhiteboardCommand>
+{
+    private readonly IWhiteboardRepository _whiteboardRepository;
+    private readonly IWhiteboardMembershipRepository _whiteboardMembershipRepository;
+    private readonly IUserContext _userContext;
+    private readonly IUnitOfWork _unitOfWork;
+
+    public UnbanUserFromWhiteboardCommandHandler(
+        IWhiteboardRepository whiteboardRepository, 
+        IWhiteboardMembershipRepository whiteboardMembershipRepository, 
+        IUserContext userContext, 
+        IUnitOfWork unitOfWork)
+    {
+        _whiteboardRepository = whiteboardRepository;
+        _whiteboardMembershipRepository = whiteboardMembershipRepository;
+        _userContext = userContext;
+        _unitOfWork = unitOfWork;
+    }
+    
+    public async Task Handle(UnbanUserFromWhiteboardCommand command, CancellationToken cancellationToken = default)
+    {
+        var whiteboardId = new WhiteboardId(command.WhiteboardId);
+        var userId = new UserId(command.UserId);
+
+        var whiteboard = await _whiteboardRepository.GetByIdAsync(whiteboardId, cancellationToken);
+
+        if (whiteboard is null)
+        {
+            throw new ValidationException(UnbanUserFromWhiteboardCommandErrors.WhiteboardNotFound(whiteboardId));
+        }
+        
+        var membership = await _whiteboardMembershipRepository.GetByWhiteboardAndUserAsync(whiteboardId, userId, cancellationToken);
+
+        if (membership is null)
+        {
+            throw new ValidationException(UnbanUserFromWhiteboardCommandErrors.WhiteboardMembershipNotFound(whiteboardId, userId));
+        }
+        
+        whiteboard.UnbanUser(_userContext.GetCurrentUserId(), membership);
+        
+        await _whiteboardMembershipRepository.SaveAsync(membership, cancellationToken);
+        await _unitOfWork.SaveChangesAsync(cancellationToken);
+    }
+}

dotnet/AipsCore/Domain/Common/ValueObjects/DomainId.cs

@@ -22,9 +22,4 @@ public record DomainId : AbstractValueObject
             new MinLengthRule(IdValue, 5)
         ];
     }
-
-    public override string ToString()
-    {
-        return IdValue;
-    }
 }

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

@@ -14,5 +14,28 @@ public class WhiteboardErrors : AbstractErrors<Whiteboard, WhiteboardId>
 
         return CreateValidationError(code, message);
     }
+
+    public static ValidationError OnlyOwnerCanBanOtherUsers(UserId currentUserId)
+    {
+        string code = "only_owner_can_ban_other_users";
+        string message = $"Only owner of whiteboard can ban other users. Current user id: '{currentUserId}' is not the owner.";
         
+        return CreateValidationError(code, message);
+    }
+     
+    public static ValidationError OnlyOwnerCanUnbanOtherUsers(UserId currentUserId)
+    {
+        string code = "only_owner_can_unban_other_users";
+        string message = $"Only owner of whiteboard can unban other users. Current user id: '{currentUserId}' is not the owner.";
+        
+        return CreateValidationError(code, message);
+    }
+    
+    public static ValidationError OnlyOwnerCanKickOtherUsers(UserId currentUserId)
+    {
+        string code = "only_owner_can_unban_other_users";
+        string message = $"Only owner of whiteboard can kick other users. Current user id: '{currentUserId}' is not the owner.";
+        
+        return CreateValidationError(code, message);
+    }
 }

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

@@ -0,0 +1,18 @@
+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.KickUser.cs

@@ -0,0 +1,18 @@
+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.UnbanUser.cs

@@ -0,0 +1,18 @@
+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/WhiteboardMembership.Ban.cs

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,11 @@
+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.Unban.cs

@@ -0,0 +1,11 @@
+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

@@ -5,7 +5,7 @@ using AipsCore.Domain.Models.WhiteboardMembership.ValueObjects;
 
 namespace AipsCore.Domain.Models.WhiteboardMembership;
 
-public class WhiteboardMembership : DomainModel<WhiteboardMembershipId>
+public partial class WhiteboardMembership : DomainModel<WhiteboardMembershipId>
 {
     public WhiteboardId WhiteboardId { get; private set; }
     public UserId UserId { get; private set; }

dotnet/AipsCore/Infrastructure/DI/AipsRegistrationExtensions.cs

@@ -1,8 +1,5 @@
 using AipsCore.Application.Abstract;
-using AipsCore.Application.Abstract.Command;
 using AipsCore.Application.Common.Dispatcher;
-using AipsCore.Application.Models.User.Command.CreateUser;
-using AipsCore.Domain.Models.User.ValueObjects;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -16,6 +13,8 @@ public static class AipsRegistrationExtensions
         services.AddTransient<IDispatcher, Dispatcher>();
 
         services.AddPersistence(configuration);
+
+        services.AddUserContext();
         
         return services;
     }

dotnet/AipsCore/Infrastructure/DI/UserContextRegistrationExtension.cs

@@ -0,0 +1,14 @@
+using AipsCore.Application.Abstract.UserContext;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace AipsCore.Infrastructure.DI;
+
+public static class UserContextRegistrationExtension
+{
+    public static IServiceCollection AddUserContext(this IServiceCollection services)
+    {
+        services.AddTransient<IUserContext, UserContext>();
+        
+        return services;
+    }
+}

dotnet/AipsCore/Infrastructure/Persistence/WhiteboardMembership/WhiteboardMembershipRepository.cs

@@ -57,8 +57,8 @@ public class WhiteboardMembershipRepository
     {
         var whiteboardMembership = await Context.WhiteboardMemberships
             .FirstOrDefaultAsync((entity) =>
-                    entity.WhiteboardId.ToString() == whiteboardId.ToString() &&
+                    entity.WhiteboardId.ToString() == whiteboardId.IdValue &&
-                    entity.UserId.ToString() == userId.ToString(),
+                    entity.UserId.ToString() == userId.IdValue,
                 cancellationToken);
 
         if (whiteboardMembership is null) return null;

dotnet/AipsCore/Infrastructure/UserContext.cs

@@ -0,0 +1,14 @@
+using AipsCore.Application.Abstract.UserContext;
+using AipsCore.Domain.Models.User.ValueObjects;
+
+namespace AipsCore.Infrastructure;
+
+public class UserContext : IUserContext
+{
+    public UserId GetCurrentUserId()
+    {
+        return new UserId(new Guid("52a1810c-802f-48b0-a74c-7b517807e392").ToString());
+    }
+}
+
+//Ovo je samo trenutno resenje

dotnet/AipsWebApi/Controllers/WhiteboardController.cs

@@ -1,6 +1,9 @@
 using AipsCore.Application.Abstract;
 using AipsCore.Application.Models.Whiteboard.Command.AddUserToWhiteboard;
+using AipsCore.Application.Models.Whiteboard.Command.BanUserFromWhiteboard;
 using AipsCore.Application.Models.Whiteboard.Command.CreateWhiteboard;
+using AipsCore.Application.Models.Whiteboard.Command.KickUserFromWhiteboard;
+using AipsCore.Application.Models.Whiteboard.Command.UnbanUserFromWhiteboard;
 using AipsCore.Application.Models.Whiteboard.Query.GetRecentWhiteboards;
 using AipsCore.Domain.Models.Whiteboard;
 using Microsoft.AspNetCore.Mvc;
@@ -40,4 +43,25 @@ public class WhiteboardController : ControllerBase
 
         return Ok(result);
     }
+    
+    [HttpPut("banUser")]
+    public async Task<ActionResult> BanUserFromWhiteboard(BanUserFromWhiteboardCommand command, IDispatcher dispatcher, CancellationToken cancellationToken)
+    {
+        await dispatcher.Execute(command, cancellationToken);
+        return Ok();
+    }
+    
+    [HttpPut("unbanUser")]
+    public async Task<ActionResult> UnbanUserFromWhiteboard(UnbanUserFromWhiteboardCommand command, IDispatcher dispatcher, CancellationToken cancellationToken)
+    {
+        await dispatcher.Execute(command, cancellationToken);
+        return Ok();
+    }
+    
+    [HttpPut("kickUser")]
+    public async Task<ActionResult> KickUserFromWhiteboard(KickUserFromWhiteboardCommand command, IDispatcher dispatcher, CancellationToken cancellationToken)
+    {
+        await dispatcher.Execute(command, cancellationToken);
+        return Ok();
+    }
 }