StewKI/AIPS
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

Refactored

Browse Source
This commit is contained in:
Veljko Tosic
2026-03-04 23:12:08 +01:00
parent 88442f22dd
commit ef6305919d
31 changed files with 296 additions and 338 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
dotnet/AipsCore/Application/Models/Whiteboard/Command/AcceptUserRequestToJoin/AcceptUserRequestToJoinCommand.cs Normal file
View File

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

40
dotnet/AipsCore/Application/Models/Whiteboard/Command/AcceptUserRequestToJoin/AcceptUserRequestToJoinCommandHandler.cs Normal file
View File

@@ -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);
}
}

11
dotnet/AipsCore/Application/Models/Whiteboard/Command/AddUserToWhiteboard/AddUserToWhiteboardCommand.cs
View File

@@ -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;

12
dotnet/AipsCore/Application/Models/Whiteboard/Command/AddUserToWhiteboard/AddUserToWhiteboardCommandErrors.cs
View File

@@ -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.");
}

65
dotnet/AipsCore/Application/Models/Whiteboard/Command/AddUserToWhiteboard/AddUserToWhiteboardCommandHandler.cs
View File

@@ -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)));
}
}
}

18
dotnet/AipsCore/Application/Models/Whiteboard/Command/BanUserFromWhiteboard/BanUserFromWhiteboardCommandErrors.cs
View File

@@ -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.");
}

6
dotnet/AipsCore/Application/Models/Whiteboard/Command/BanUserFromWhiteboard/BanUserFromWhiteboardCommandHandler.cs
View File

@@ -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);

18
dotnet/AipsCore/Application/Models/Whiteboard/Command/KickUserFromWhiteboard/KickUserFromWhiteboardCommandErrors.cs
View File

@@ -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.");
}

6
dotnet/AipsCore/Application/Models/Whiteboard/Command/KickUserFromWhiteboard/KickUserFromWhiteboardCommandHandler.cs
View File

@@ -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);

5
dotnet/AipsCore/Application/Models/Whiteboard/Command/RejectUserRequestToJoin/RejectUserRequestToJoinCommand.cs Normal file
View File

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

40
dotnet/AipsCore/Application/Models/Whiteboard/Command/RejectUserRequestToJoin/RejectUserRequestToJoinCommandHandler.cs Normal file
View File

@@ -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);
}
}

18
dotnet/AipsCore/Application/Models/Whiteboard/Command/UnbanUserFromWhiteboard/UnbanUserFromWhiteboardCommandErrors.cs
View File

@@ -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.");
}

6
dotnet/AipsCore/Application/Models/Whiteboard/Command/UnbanUserFromWhiteboard/UnbanUserFromWhiteboardCommandHandler.cs
View File

@@ -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);

3
dotnet/AipsCore/Domain/Models/Whiteboard/External/IWhiteboardRepository.cs vendored
View File

@@ -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);
}

32
dotnet/AipsCore/Domain/Models/Whiteboard/Validation/WhiteboardErrors.cs
View File

@@ -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";

2
dotnet/AipsCore/Domain/Models/Whiteboard/ValueObjects/WhiteboardCode.cs
View File

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

59
dotnet/AipsCore/Domain/Models/Whiteboard/Whiteboard.AddUser.cs
View File

@@ -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.External;
using AipsCore.Domain.Models.WhiteboardMembership.Enums;
namespace AipsCore.Domain.Models.Whiteboard;
public partial class Whiteboard : DomainModel<WhiteboardId>
public partial class Whiteboard
{
public async Task AddUserAsync(
User.User user,
IWhiteboardMembershipRepository membershipRepository,
CancellationToken cancellationToken = default)
public WhiteboardMembership.WhiteboardMembership RequestJoin(UserId userId)
{
var membership
= await membershipRepository.GetByWhiteboardAndUserAsync(this.Id, user.Id, cancellationToken);
return WhiteboardMembership.WhiteboardMembership.Create(
Id.IdValue,
userId.IdValue,
false,
DetermineJoinStatus(),
DateTime.UtcNow);
}
if (membership is not null)
public void RequestReJoin(WhiteboardMembership.WhiteboardMembership membership)
{
switch (membership.Status)
{
throw new ValidationException(WhiteboardErrors.UserAlreadyAdded(user.Id));
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;
}
membership = WhiteboardMembership.WhiteboardMembership.Create(
this.Id.IdValue,
user.Id.IdValue,
false,
false,
this.GetCanJoin(),
DateTime.UtcNow
);
await membershipRepository.AddAsync(membership, cancellationToken);
}
private bool GetCanJoin()
private WhiteboardMembershipStatus DetermineJoinStatus()
{
return this.JoinPolicy == WhiteboardJoinPolicy.FreeToJoin;
return JoinPolicy switch
{
WhiteboardJoinPolicy.FreeToJoin => WhiteboardMembershipStatus.Accepted,
WhiteboardJoinPolicy.RequestToJoin => WhiteboardMembershipStatus.Pending,
WhiteboardJoinPolicy.Private => throw new ValidationException(WhiteboardErrors.CannotJoin(Code)),
_ => throw new ArgumentOutOfRangeException()
};
}
}
}

18
dotnet/AipsCore/Domain/Models/Whiteboard/Whiteboard.BanUser.cs
View File

@@ -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();
}
}

7
dotnet/AipsCore/Domain/Models/Whiteboard/Whiteboard.CanUserDelete.cs
View File

@@ -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);
}
}

18
dotnet/AipsCore/Domain/Models/Whiteboard/Whiteboard.KickUser.cs
View File

@@ -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();
}
}

43
dotnet/AipsCore/Domain/Models/Whiteboard/Whiteboard.ManageUsers.cs Normal file
View File

@@ -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;
}
}

18
dotnet/AipsCore/Domain/Models/Whiteboard/Whiteboard.UnbanUser.cs
View File

@@ -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();
}
}

13
dotnet/AipsCore/Domain/Models/WhiteboardMembership/Enums/WhiteboardMembershipStatus.cs Normal file
View File

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

18
dotnet/AipsCore/Domain/Models/WhiteboardMembership/Validation/WhiteboardMembershipErrors.cs Normal file
View File

@@ -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);
}
}

20
dotnet/AipsCore/Domain/Models/WhiteboardMembership/ValueObjects/WhiteboardMembershipCanJoin.cs
View File

@@ -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 [];
}
}

20
dotnet/AipsCore/Domain/Models/WhiteboardMembership/ValueObjects/WhiteboardMembershipIsBanned.cs
View File

@@ -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 [];
}
}

11
dotnet/AipsCore/Domain/Models/WhiteboardMembership/WhiteboardMembership.Ban.cs
View File

@@ -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);
}
}

11
dotnet/AipsCore/Domain/Models/WhiteboardMembership/WhiteboardMembership.Kick.cs
View File

@@ -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);
}
}

26
dotnet/AipsCore/Domain/Models/WhiteboardMembership/WhiteboardMembership.Status.cs Normal file
View File

@@ -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;
}
}

11
dotnet/AipsCore/Domain/Models/WhiteboardMembership/WhiteboardMembership.Unban.cs
View File

@@ -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);
}
}

54
dotnet/AipsCore/Domain/Models/WhiteboardMembership/WhiteboardMembership.cs
View File

@@ -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,
userIdVo,
isBannedVo,
whiteboardIdVo,
userIdVo,
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);
}
}