Merge pull request #17 from StewKI/feature-command-whiteboard-add-user

Komanda Add user to whiteboard

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

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

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

@@ -0,0 +1,65 @@
+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/Domain/Abstract/DomainModel.cs

@@ -18,6 +18,11 @@ public abstract class DomainModel<TId> where TId : DomainId
         Id = id;
     }
 
+    public string GetModelName()
+    {
+        return this.GetType().Name;
+    }
+
     public IReadOnlyList<IDomainEvent> GetDomainEvents() => _domainEvents.ToList();
     
     public void ClearDomainEvents() => _domainEvents.Clear();

dotnet/AipsCore/Domain/Abstract/Validation/AbstractErrors.cs

@@ -0,0 +1,38 @@
+using AipsCore.Domain.Common.Validation;
+using AipsCore.Domain.Common.ValueObjects;
+using AipsCore.Domain.Models.Whiteboard.ValueObjects;
+
+namespace AipsCore.Domain.Abstract.Validation;
+
+public abstract class AbstractErrors<TModel, TId>
+where TModel : DomainModel<TId> 
+where TId : DomainId
+{
+    public static string GetModelName()
+    {
+        return typeof(TModel).Name;
+    }
+    
+    public static string Prefix()
+    {
+        return GetModelName().ToLower();
+    }
+
+    protected static string GetFullCode(string code)
+    {
+        return $"{Prefix()}_{code}";
+    }
+
+    protected static ValidationError CreateValidationError(string code, string errorMessage)
+    {
+        return new ValidationError(GetFullCode(code), errorMessage);
+    }
+
+    public static ValidationError NotFound(TId id)
+    {
+        const string code = "not_found";
+        string message = $"{GetModelName()} with id '{id}' was not found!";
+        
+        return CreateValidationError(code,message);
+    }
+}

dotnet/AipsCore/Domain/Common/Validation/ValidationException.cs

@@ -10,4 +10,9 @@ public class ValidationException : Exception
     {
         ValidationErrors = validationErrors;
     }
+
+    public ValidationException(ValidationError validationError)
+        : this([validationError])
+    {
+    }
 }

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

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

dotnet/AipsCore/Domain/Models/User/Validation/UserErrors.cs

@@ -0,0 +1,9 @@
+using AipsCore.Domain.Abstract.Validation;
+using AipsCore.Domain.Models.User.ValueObjects;
+
+namespace AipsCore.Domain.Models.User.Validation;
+
+public class UserErrors : AbstractErrors<User, UserId>
+{
+    
+}

dotnet/AipsCore/Domain/Models/Whiteboard/Validation/WhiteboardErrors.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;
+
+namespace AipsCore.Domain.Models.Whiteboard.Validation;
+
+public class WhiteboardErrors : AbstractErrors<Whiteboard, WhiteboardId>
+{
+    public static ValidationError UserAlreadyAdded(UserId userId)
+    {
+        string code = "user_already_added";
+        string message = $"User with id '{userId}' already added to this whiteboard";
+
+        return CreateValidationError(code, message);
+    }
+        
+}

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

@@ -0,0 +1,42 @@
+using System.Runtime.InteropServices.Swift;
+using AipsCore.Domain.Abstract;
+using AipsCore.Domain.Common.Validation;
+using AipsCore.Domain.Models.Whiteboard.Enums;
+using AipsCore.Domain.Models.Whiteboard.Validation;
+using AipsCore.Domain.Models.Whiteboard.ValueObjects;
+using AipsCore.Domain.Models.WhiteboardMembership.External;
+
+namespace AipsCore.Domain.Models.Whiteboard;
+
+public partial class Whiteboard : DomainModel<WhiteboardId>
+{
+    public async Task AddUserAsync(
+        User.User user, 
+        IWhiteboardMembershipRepository membershipRepository, 
+        CancellationToken cancellationToken = default)
+    {
+        var membership 
+            = await membershipRepository.GetByWhiteboardAndUserAsync(this.Id, user.Id, cancellationToken);
+
+        if (membership is not null)
+        {
+            throw new ValidationException(WhiteboardErrors.UserAlreadyAdded(user.Id));
+        }
+
+        membership = WhiteboardMembership.WhiteboardMembership.Create(
+            this.Id.ToString(),
+            user.Id.ToString(),
+            false,
+            false,
+            this.GetCanJoin(),
+            DateTime.Now
+        );
+        
+        await membershipRepository.AddAsync(membership, cancellationToken);
+    }
+
+    private bool GetCanJoin()
+    {
+        return this.JoinPolicy == WhiteboardJoinPolicy.FreeToJoin;
+    }
+}

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

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

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

@@ -1,9 +1,11 @@
 using AipsCore.Domain.Abstract;
+using AipsCore.Domain.Models.User.ValueObjects;
+using AipsCore.Domain.Models.Whiteboard.ValueObjects;
 using AipsCore.Domain.Models.WhiteboardMembership.ValueObjects;
 
 namespace AipsCore.Domain.Models.WhiteboardMembership.External;
 
 public interface IWhiteboardMembershipRepository : IAbstractRepository<WhiteboardMembership, WhiteboardMembershipId>
 {
-    
+    Task<WhiteboardMembership?> GetByWhiteboardAndUserAsync(WhiteboardId whiteboardId, UserId userId, CancellationToken cancellationToken = default);
 }

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

@@ -17,4 +17,10 @@ public record WhiteboardMembershipEditingEnabled : AbstractValueObject
     {
         return [];
     }
+
+    public static WhiteboardMembershipEditingEnabled Enabled
+        => new WhiteboardMembershipEditingEnabled(true);
+    
+    public static WhiteboardMembershipEditingEnabled Disabled
+        => new WhiteboardMembershipEditingEnabled(false);
 }

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

@@ -1,7 +1,10 @@
+using AipsCore.Domain.Models.User.ValueObjects;
+using AipsCore.Domain.Models.Whiteboard.ValueObjects;
 using AipsCore.Domain.Models.WhiteboardMembership.External;
 using AipsCore.Domain.Models.WhiteboardMembership.ValueObjects;
 using AipsCore.Infrastructure.Persistence.Abstract;
 using AipsCore.Infrastructure.Persistence.Db;
+using Microsoft.EntityFrameworkCore;
 
 namespace AipsCore.Infrastructure.Persistence.WhiteboardMembership;
 
@@ -49,4 +52,17 @@ public class WhiteboardMembershipRepository
         entity.CanJoin = model.CanJoin.CanJoinValue;
         entity.LastInteractedAt = model.LastInteractedAt.LastInteractedAtValue;
     }
+
+    public async Task<Domain.Models.WhiteboardMembership.WhiteboardMembership?> GetByWhiteboardAndUserAsync(WhiteboardId whiteboardId, UserId userId, CancellationToken cancellationToken = default)
+    {
+        var whiteboardMembership = await Context.WhiteboardMemberships
+            .FirstOrDefaultAsync((entity) =>
+                    entity.WhiteboardId.ToString() == whiteboardId.ToString() &&
+                    entity.UserId.ToString() == userId.ToString(),
+                cancellationToken);
+
+        if (whiteboardMembership is null) return null;
+        
+        return MapToModel(whiteboardMembership);
+    }
 }