Merge pull request #15 from StewKI/feature-refactored-domain

Feature refactored domain

dotnet/AipsCore/Application/Models/Shape/Command/CreateRectangle/CreateRectangleCommandHandler.cs

@@ -28,7 +28,7 @@ public class CreateRectangleCommandHandler : ICommandHandler<CreateRectangleComm
             command.EndPositionY,
             command.BorderThickness);
 
-        await _shapeRepository.Add(rectangle, cancellationToken);
+        await _shapeRepository.SaveAsync(rectangle, cancellationToken);
         await _unitOfWork.SaveChangesAsync(cancellationToken);
 
         return rectangle.Id;

dotnet/AipsCore/Application/Models/User/Command/CreateUser/CreateUserCommandHandler.cs

@@ -20,7 +20,7 @@ public class CreateUserCommandHandler : ICommandHandler<CreateUserCommand, UserI
     {
         var user = Domain.Models.User.User.Create(command.Email, command.Username, command.CreatedAt, command.DeletedAt); 
         
-        await _userRepository.Save(user, cancellationToken);
+        await _userRepository.SaveAsync(user, cancellationToken);
         await _unitOfWork.SaveChangesAsync(cancellationToken);
 
         return user.Id;

dotnet/AipsCore/Application/Models/Whiteboard/Command/CreateWhiteboard/CreateWhiteboardCommandHandler.cs

@@ -30,7 +30,7 @@ public class CreateWhiteboardCommandHandler : ICommandHandler<CreateWhiteboardCo
             command.JoinPolicy,
             command.State);
 
-        await _whiteboardRepository.Save(whiteboard, cancellationToken);
+        await _whiteboardRepository.SaveAsync(whiteboard, cancellationToken);
         await _unitOfWork.SaveChangesAsync(cancellationToken);
         
         return whiteboard.Id;

dotnet/AipsCore/Application/Models/WhiteboardMembership/Command/CreateWhiteboardMembership/CreateWhiteboardMembershipCommandHandler.cs

@@ -26,7 +26,7 @@ public class CreateWhiteboardMembershipCommandHandler : ICommandHandler<CreateWh
             command.CanJoin, 
             command.LastInteractedAt);
 
-        await _whiteboardMembershipRepository.Save(whiteboardMembership, cancellationToken);
+        await _whiteboardMembershipRepository.SaveAsync(whiteboardMembership, cancellationToken);
         await _unitOfWork.SaveChangesAsync(cancellationToken);
         
         return whiteboardMembership.Id;

dotnet/AipsCore/Domain/Abstract/DomainModel.cs

@@ -0,0 +1,26 @@
+using AipsCore.Domain.Common.ValueObjects;
+
+namespace AipsCore.Domain.Abstract;
+
+public abstract class DomainModel<TId> where TId : DomainId
+{
+    private readonly List<IDomainEvent> _domainEvents = [];
+    
+    public TId Id { get; init; }
+    
+    protected DomainModel()
+    {
+        
+    }
+
+    protected DomainModel(TId id)
+    {
+        Id = id;
+    }
+
+    public IReadOnlyList<IDomainEvent> GetDomainEvents() => _domainEvents.ToList();
+    
+    public void ClearDomainEvents() => _domainEvents.Clear();
+    
+    protected void RaiseDomainEvent(IDomainEvent domainEvent) => _domainEvents.Add(domainEvent);
+}

dotnet/AipsCore/Domain/Abstract/IAbstractRepository.cs

@@ -0,0 +1,12 @@
+using AipsCore.Domain.Common.ValueObjects;
+
+namespace AipsCore.Domain.Abstract;
+
+public interface IAbstractRepository<TModel, in TId>
+    where TModel : DomainModel<TId>
+    where TId : DomainId
+{
+    Task<TModel?> GetByIdAsync(TId id, CancellationToken cancellationToken = default);
+    Task SaveAsync(TModel model, CancellationToken cancellationToken = default);
+    Task AddAsync(TModel model, CancellationToken cancellationToken = default);
+}

dotnet/AipsCore/Domain/Abstract/IDomainEvent.cs

@@ -0,0 +1,6 @@
+namespace AipsCore.Domain.Abstract;
+
+public interface IDomainEvent
+{
+    
+}

dotnet/AipsCore/Domain/Models/Shape/External/IShapeRepository.cs

@@ -1,9 +1,9 @@
+using AipsCore.Domain.Abstract;
 using AipsCore.Domain.Models.Shape.ValueObjects;
 
 namespace AipsCore.Domain.Models.Shape.External;
 
-public interface IShapeRepository
+public interface IShapeRepository : IAbstractRepository<Shape, ShapeId>
 {
-    Task<Shape?> Get(ShapeId id, CancellationToken cancellationToken = default);
+    
-    Task Add(Shape shape, CancellationToken cancellationToken = default);
 }

dotnet/AipsCore/Domain/Models/Shape/Shape.cs

@@ -1,3 +1,4 @@
+using AipsCore.Domain.Abstract;
 using AipsCore.Domain.Common.ValueObjects;
 using AipsCore.Domain.Models.Shape.Enums;
 using AipsCore.Domain.Models.Shape.ValueObjects;
@@ -6,10 +7,8 @@ using AipsCore.Domain.Models.Whiteboard.ValueObjects;
 
 namespace AipsCore.Domain.Models.Shape;
 
-public abstract class Shape
+public abstract class Shape : DomainModel<ShapeId>
 {
-    public ShapeId Id { get; init; }
-    
     public WhiteboardId WhiteboardId { get; private set; }
     
     public UserId AuthorId { get; private set; }
@@ -21,8 +20,8 @@ public abstract class Shape
     public Color Color { get; private set; }
 
     protected Shape(ShapeId id, WhiteboardId whiteboardId, UserId authorId, Position position, Color color)
+        : base(id)
     {
-        Id = id;
         Position = position;
         Color = color;
         AuthorId = authorId;
@@ -35,10 +34,10 @@ public abstract class Shape
         int positionX, int positionY,
         string color, UserId authorId)
     {
-        AuthorId = authorId;
         Id = new ShapeId(id);
         Position = new Position(positionX, positionY);
         Color = new Color(color);
+        AuthorId = authorId;
         WhiteboardId = new WhiteboardId(whiteboardId);
     }
 }

dotnet/AipsCore/Domain/Models/User/External/IUserRepository.cs

@@ -1,9 +1,9 @@
+using AipsCore.Domain.Abstract;
 using AipsCore.Domain.Models.User.ValueObjects;
 
 namespace AipsCore.Domain.Models.User.External;
 
-public interface IUserRepository
+public interface IUserRepository : IAbstractRepository<User, UserId>
 {
-    Task<User?> Get(UserId userId, CancellationToken cancellationToken = default);
+    
-    Task Save(User user, CancellationToken cancellationToken = default);
 }

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

@@ -1,19 +1,19 @@
-using AipsCore.Domain.Common.ValueObjects;
+using AipsCore.Domain.Abstract;
+using AipsCore.Domain.Common.ValueObjects;
 using AipsCore.Domain.Models.User.ValueObjects;
 
 namespace AipsCore.Domain.Models.User;
 
-public class User
+public class User : DomainModel<UserId>
 {
-    public UserId Id { get; private set; }
     public Email Email { get; private set; }
     public Username Username { get; private set; }
     public UserCreatedAt CreatedAt { get; private set; }
     public UserDeletedAt DeletedAt { get; private set; }
 
     public User(UserId id, Email email, Username username, UserCreatedAt createdAt, UserDeletedAt deletedAt)
+        : base(id)
     {
-        Id = id;
         Email = email;
         Username = username;
         CreatedAt = createdAt;

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

@@ -1,11 +1,9 @@
+using AipsCore.Domain.Abstract;
 using AipsCore.Domain.Models.Whiteboard.ValueObjects;
 
 namespace AipsCore.Domain.Models.Whiteboard.External;
 
-public interface IWhiteboardRepository
+public interface IWhiteboardRepository : IAbstractRepository<Whiteboard, WhiteboardId>
 {
-    Task<Whiteboard?> Get(WhiteboardId whiteboardId, CancellationToken cancellationToken = default);
-    Task Save(Whiteboard whiteboard, CancellationToken cancellationToken = default);
     Task<bool> WhiteboardCodeExists(WhiteboardCode whiteboardCode);
-    
 }

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

@@ -1,12 +1,12 @@
-using AipsCore.Domain.Models.User.ValueObjects;
+using AipsCore.Domain.Abstract;
+using AipsCore.Domain.Models.User.ValueObjects;
 using AipsCore.Domain.Models.Whiteboard.Enums;
 using AipsCore.Domain.Models.Whiteboard.ValueObjects;
 
 namespace AipsCore.Domain.Models.Whiteboard;
 
-public class Whiteboard
+public class Whiteboard : DomainModel<WhiteboardId>
 {
-    public WhiteboardId Id { get; private set; }
     public UserId WhiteboardOwnerId { get; private set; }
     public WhiteboardCode Code { get; private set; }
     public WhiteboardTitle Title { get; private set; }
@@ -26,8 +26,8 @@ public class Whiteboard
         WhiteboardMaxParticipants maxParticipants,
         WhiteboardJoinPolicy joinPolicy,
         WhiteboardState state)
+        : base(id)
     {
-        Id = id;
         WhiteboardOwnerId = whiteboardOwner.Id;
         Code = code;
         Title = title;
@@ -48,8 +48,8 @@ public class Whiteboard
         WhiteboardMaxParticipants maxParticipants,
         WhiteboardJoinPolicy joinPolicy,
         WhiteboardState state)
+        : base(id)
     {
-        Id = id;
         WhiteboardOwnerId = whiteboardOwnerId;
         Code = code;
         Title = title;

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

@@ -1,9 +1,9 @@
+using AipsCore.Domain.Abstract;
 using AipsCore.Domain.Models.WhiteboardMembership.ValueObjects;
 
 namespace AipsCore.Domain.Models.WhiteboardMembership.External;
 
-public interface IWhiteboardMembershipRepository
+public interface IWhiteboardMembershipRepository : IAbstractRepository<WhiteboardMembership, WhiteboardMembershipId>
 {
-    Task<WhiteboardMembership?> Get(WhiteboardMembershipId whiteboardMembershipId, CancellationToken cancellationToken = default);
+    
-    Task Save(WhiteboardMembership whiteboardMembership, CancellationToken cancellationToken = default);
 }

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

@@ -1,12 +1,12 @@
+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;
 
-public class WhiteboardMembership
+public class WhiteboardMembership : DomainModel<WhiteboardMembershipId>
 {
-    public WhiteboardMembershipId Id { get; private set; }
     public WhiteboardId WhiteboardId { get; private set; }
     public UserId UserId { get; private set; }
     public WhiteboardMembershipIsBanned IsBanned { get; private set; }
@@ -22,8 +22,8 @@ public class WhiteboardMembership
         WhiteboardMembershipEditingEnabled editingEnabled,
         WhiteboardMembershipCanJoin canJoin,
         WhiteboardMembershipLastInteractedAt lastInteractedAt)
+        : base(id)
     {
-        Id = id;
         WhiteboardId = owner.Id;
         UserId = user.Id;
         IsBanned = isBanned;
@@ -40,8 +40,8 @@ public class WhiteboardMembership
         WhiteboardMembershipEditingEnabled editingEnabled,
         WhiteboardMembershipCanJoin canJoin,
         WhiteboardMembershipLastInteractedAt lastInteractedAt)
+        : base(id)
     {
-        Id = id;
         WhiteboardId = ownerId;
         UserId = userId;
         IsBanned = isBanned;

dotnet/AipsCore/Infrastructure/Persistence/Abstract/AbstractRepository.cs

@@ -0,0 +1,55 @@
+using AipsCore.Domain.Abstract;
+using AipsCore.Domain.Common.ValueObjects;
+using AipsCore.Infrastructure.Persistence.Db;
+using Microsoft.EntityFrameworkCore;
+
+namespace AipsCore.Infrastructure.Persistence.Abstract;
+
+public abstract class AbstractRepository<TModel, TId, TEntity> : IAbstractRepository<TModel, TId>
+    where TModel : DomainModel<TId>
+    where TId : DomainId
+    where TEntity : class
+{
+    protected readonly AipsDbContext Context;
+    protected readonly DbSet<TEntity> DbSet;
+    
+    protected AbstractRepository(AipsDbContext context)
+    {
+        Context = context;
+        DbSet = Context.Set<TEntity>();
+    }
+    
+    public async Task<TModel?> GetByIdAsync(TId id, CancellationToken cancellationToken = default)
+    {
+        var entity = await DbSet.FindAsync([new Guid(id.IdValue)], cancellationToken);
+        
+        return entity != null ? MapToModel(entity) : null;
+    }
+
+    public async Task SaveAsync(TModel model, CancellationToken cancellationToken = default)
+    {
+        var entity = await DbSet.FindAsync([new Guid(model.Id.IdValue)], cancellationToken);
+
+        if (entity == null)
+        {
+            entity = MapToEntity(model);
+            await DbSet.AddAsync(entity, cancellationToken);
+        }
+        else
+        {
+            UpdateEntity(entity, model);
+            DbSet.Update(entity);
+        }
+    }
+
+    public async Task AddAsync(TModel model, CancellationToken cancellationToken = default)
+    {
+        var entity = MapToEntity(model);
+        
+        await DbSet.AddAsync(entity, cancellationToken);
+    }
+
+    protected abstract TModel MapToModel(TEntity entity);
+    protected abstract TEntity MapToEntity(TModel model);
+    protected abstract void UpdateEntity(TEntity entity, TModel model);
+}

dotnet/AipsCore/Infrastructure/Persistence/Shape/Mappers/ShapeMappers.FromEntity.cs

@@ -8,7 +8,7 @@ namespace AipsCore.Infrastructure.Persistence.Shape.Mappers;
 
 public static partial class ShapeMappers
 {
-    public static Domain.Models.Shape.Shape EntityToModel(Shape shape)
+    public static Domain.Models.Shape.Shape MapToEntity(Shape shape)
     {
         return shape.Type switch
         {

dotnet/AipsCore/Infrastructure/Persistence/Shape/Mappers/ShapeMappers.ToEntity.cs

@@ -9,7 +9,7 @@ namespace AipsCore.Infrastructure.Persistence.Shape.Mappers;
 public static partial class ShapeMappers
 {
     
-    public static Shape ModelToEntity(Domain.Models.Shape.Shape model)
+    public static Shape MapToEntity(Domain.Models.Shape.Shape model)
     {
         return model.ShapeType switch
         {
@@ -23,7 +23,7 @@ public static partial class ShapeMappers
 
     public static Shape RectangleToEntity(Rectangle rectangle)
     {
-        return new Shape()
+        return new Shape
         {
             Id = new Guid(rectangle.Id.Value),
             Type = rectangle.ShapeType,
@@ -40,7 +40,7 @@ public static partial class ShapeMappers
 
     public static Shape LineToEntity(Line line)
     {
-        return new Shape()
+        return new Shape
         {
             Id = new Guid(line.Id.Value),
             Type = line.ShapeType,
@@ -57,7 +57,7 @@ public static partial class ShapeMappers
 
     public static Shape ArrowToEntity(Arrow arrow)
     {
-        return new Shape()
+        return new Shape
         {
             Id = new Guid(arrow.Id.Value),
             Type = arrow.ShapeType,
@@ -74,7 +74,7 @@ public static partial class ShapeMappers
 
     public static Shape TextShapeToEntity(TextShape textShape)
     {
-        return new Shape()
+        return new Shape
         {
             Id = new Guid(textShape.Id.Value),
             Type = textShape.ShapeType,

dotnet/AipsCore/Infrastructure/Persistence/Shape/ShapeRepository.cs

@@ -1,42 +1,31 @@
 using AipsCore.Domain.Models.Shape.External;
 using AipsCore.Domain.Models.Shape.ValueObjects;
+using AipsCore.Infrastructure.Persistence.Abstract;
 using AipsCore.Infrastructure.Persistence.Db;
 using AipsCore.Infrastructure.Persistence.Shape.Mappers;
 
 namespace AipsCore.Infrastructure.Persistence.Shape;
 
-public class ShapeRepository : IShapeRepository
+public class ShapeRepository : AbstractRepository<Domain.Models.Shape.Shape, ShapeId, Shape>, IShapeRepository
 {
-    private readonly AipsDbContext _context;
-
     public ShapeRepository(AipsDbContext context) 
+        : base(context)
     {
-        _context = context;
+        
     }
 
-    public async Task<Domain.Models.Shape.Shape?> Get(ShapeId id, CancellationToken cancellationToken = default)
+    protected override Domain.Models.Shape.Shape MapToModel(Shape entity)
     {
-        var entity = await _context.Shapes.FindAsync([new Guid(id.Value)], cancellationToken);
+        return ShapeMappers.MapToEntity(entity);
-        
-        if (entity is null) return null;
-        
-        return ShapeMappers.EntityToModel(entity);
     }
 
-    public async Task Add(Domain.Models.Shape.Shape shape, CancellationToken cancellationToken = default)
+    protected override Shape MapToEntity(Domain.Models.Shape.Shape model)
     {
-        var entity = await _context.Shapes.FindAsync([new Guid(shape.Id.Value)], cancellationToken);
+        return ShapeMappers.MapToEntity(model);
-
+    }
-        if (entity is not null)
-        {
-            ShapeMappers.UpdateEntity(entity, shape);
-        }
-        else
-        {
-            var newEntity = ShapeMappers.ModelToEntity(shape);
-            
-            await _context.Shapes.AddAsync(newEntity, cancellationToken);
-        }
 
+    protected override void UpdateEntity(Shape entity, Domain.Models.Shape.Shape model)
+    {
+        ShapeMappers.UpdateEntity(entity, model);
     }
 }

dotnet/AipsCore/Infrastructure/Persistence/User/UserRepository.cs

@@ -1,58 +1,45 @@
 using AipsCore.Domain.Models.User.External;
 using AipsCore.Domain.Models.User.ValueObjects;
+using AipsCore.Infrastructure.Persistence.Abstract;
 using AipsCore.Infrastructure.Persistence.Db;
 
 namespace AipsCore.Infrastructure.Persistence.User;
 
-public class UserRepository : IUserRepository
+public class UserRepository : AbstractRepository<Domain.Models.User.User, UserId, User>, IUserRepository
 {
-    private readonly AipsDbContext _context;
-
     public UserRepository(AipsDbContext context) 
+        : base(context)
     {
-        _context = context;
     }
 
-    public async Task<Domain.Models.User.User?> Get(UserId userId, CancellationToken cancellationToken = default)
+    protected override Domain.Models.User.User MapToModel(User entity)
     {
-        var userEntity = await _context.Users.FindAsync([new Guid(userId.IdValue), cancellationToken], cancellationToken: cancellationToken);
-
-        if (userEntity is null) return null;
-        
         return Domain.Models.User.User.Create(
-            userEntity.Id.ToString(),
+            entity.Id.ToString(),
-            userEntity.Email,
+            entity.Email,
-            userEntity.Username,
+            entity.Username,
-            userEntity.CreatedAt,
+            entity.CreatedAt,
-            userEntity.DeletedAt);
+            entity.DeletedAt
+        );
     }
 
-    public async Task Save(Domain.Models.User.User user, CancellationToken cancellationToken = default)
+    protected override User MapToEntity(Domain.Models.User.User model)
     {
-        // ReSharper disable once MethodSupportsCancellation
+        return new User
-        var userEntity = await _context.Users.FindAsync(new Guid(user.Id.IdValue));
-
-        if (userEntity is not null)
         {
-            userEntity.Email = user.Email.EmailValue;
+            Id = new Guid(model.Id.IdValue),
-            userEntity.Username = user.Username.UsernameValue;
+            Email = model.Email.EmailValue,
-            userEntity.CreatedAt = user.CreatedAt.CreatedAtValue;
+            Username = model.Username.UsernameValue,
-            userEntity.DeletedAt = user.DeletedAt.DeletedAtValue;
+            CreatedAt = model.CreatedAt.CreatedAtValue,
+            DeletedAt = model.DeletedAt.DeletedAtValue
+        };
+    }
 
-            _context.Users.Update(userEntity);
+    protected override void UpdateEntity(User entity, Domain.Models.User.User model)
-        }
+    {
-        else
+        entity.Email = model.Email.EmailValue;
-        {
+        entity.Username = model.Username.UsernameValue;
-            userEntity = new User()
+        entity.CreatedAt = model.CreatedAt.CreatedAtValue;
-            {
+        entity.DeletedAt = model.DeletedAt.DeletedAtValue;
-                Id = new Guid(user.Id.IdValue),
-                Email = user.Email.EmailValue,
-                Username = user.Username.UsernameValue,
-                CreatedAt = user.CreatedAt.CreatedAtValue,
-                DeletedAt = user.DeletedAt.DeletedAtValue
-            };
-            
-            _context.Users.Add(userEntity);
-        }
     }
 }

dotnet/AipsCore/Infrastructure/Persistence/Whiteboard/WhiteboardRepository.cs

@@ -1,76 +1,64 @@
 using AipsCore.Domain.Models.Whiteboard.External;
 using AipsCore.Domain.Models.Whiteboard.ValueObjects;
+using AipsCore.Infrastructure.Persistence.Abstract;
 using AipsCore.Infrastructure.Persistence.Db;
 using Microsoft.EntityFrameworkCore;
 
 namespace AipsCore.Infrastructure.Persistence.Whiteboard;
 
-public class WhiteboardRepository : IWhiteboardRepository
+public class WhiteboardRepository 
+    : AbstractRepository<Domain.Models.Whiteboard.Whiteboard, WhiteboardId, Whiteboard>, IWhiteboardRepository
 {
-    private readonly AipsDbContext _context;
-    
     public WhiteboardRepository(AipsDbContext context) 
+        : base(context)
     {
-        _context = context;
+        
     }
 
-    public async Task<Domain.Models.Whiteboard.Whiteboard?> Get(WhiteboardId whiteboardId, CancellationToken cancellationToken = default)
+    protected override Domain.Models.Whiteboard.Whiteboard MapToModel(Whiteboard entity)
     {
-        var whiteboardEntity = await _context.Whiteboards.FindAsync([new Guid(whiteboardId.IdValue), cancellationToken], cancellationToken: cancellationToken);
-
-        if (whiteboardEntity is null) return null;
-
         return Domain.Models.Whiteboard.Whiteboard.Create(
-            whiteboardEntity.Id.ToString(),
+            entity.Id.ToString(),
-            whiteboardEntity.OwnerId.ToString(),
+            entity.OwnerId.ToString(),
-            whiteboardEntity.Code,
+            entity.Code,
-            whiteboardEntity.Title,
+            entity.Title,
-            whiteboardEntity.CreatedAt,
+            entity.CreatedAt,
-            whiteboardEntity.DeletedAt,
+            entity.DeletedAt,
-            whiteboardEntity.MaxParticipants,
+            entity.MaxParticipants,
-            whiteboardEntity.JoinPolicy,
+            entity.JoinPolicy,
-            whiteboardEntity.State);
+            entity.State
+        );
     }
 
-    public async Task Save(Domain.Models.Whiteboard.Whiteboard whiteboard, CancellationToken cancellationToken = default)
+    protected override Whiteboard MapToEntity(Domain.Models.Whiteboard.Whiteboard model)
     {
-        var whiteboardEntity = await _context.Whiteboards.FindAsync(new Guid(whiteboard.Id.IdValue));
+        return new Whiteboard
-
-        if (whiteboardEntity is not null)
         {
-            whiteboardEntity.OwnerId = new Guid(whiteboard.WhiteboardOwnerId.IdValue);
+            Id = new Guid(model.Id.IdValue),
-            whiteboardEntity.Code = whiteboard.Code.CodeValue;
+            OwnerId = new Guid(model.WhiteboardOwnerId.IdValue),
-            whiteboardEntity.Title = whiteboard.Title.TitleValue;
+            Code = model.Code.CodeValue,
-            whiteboardEntity.CreatedAt = whiteboard.CreatedAt.CreatedAtValue;
+            Title = model.Title.TitleValue,
-            whiteboardEntity.DeletedAt = whiteboard.DeletedAt.DeletedAtValue;
+            CreatedAt = model.CreatedAt.CreatedAtValue,
-            whiteboardEntity.MaxParticipants = whiteboard.MaxParticipants.MaxParticipantsValue;
+            DeletedAt = model.DeletedAt.DeletedAtValue,
-            whiteboardEntity.JoinPolicy = whiteboard.JoinPolicy;
+            MaxParticipants = model.MaxParticipants.MaxParticipantsValue,
-            whiteboardEntity.State = whiteboard.State;
+            JoinPolicy = model.JoinPolicy,
+            State = model.State
+        };
+    }
 
-            _context.Whiteboards.Update(whiteboardEntity);
+    protected override void UpdateEntity(Whiteboard entity, Domain.Models.Whiteboard.Whiteboard model)
-        }
+    {
-        else
+        entity.Code = model.Code.CodeValue;
-        {
+        entity.Title = model.Title.TitleValue;
-            whiteboardEntity = new Whiteboard()
+        entity.CreatedAt = model.CreatedAt.CreatedAtValue;
-            {
+        entity.DeletedAt = model.DeletedAt.DeletedAtValue;
-                Id = new Guid(whiteboard.Id.IdValue),
+        entity.MaxParticipants = model.MaxParticipants.MaxParticipantsValue;
-                OwnerId = new Guid(whiteboard.WhiteboardOwnerId.IdValue),
+        entity.JoinPolicy = model.JoinPolicy;
-                Code = whiteboard.Code.CodeValue,
+        entity.State = model.State;
-                Title = whiteboard.Title.TitleValue,
-                CreatedAt = whiteboard.CreatedAt.CreatedAtValue,
-                DeletedAt = whiteboard.DeletedAt.DeletedAtValue,
-                MaxParticipants = whiteboard.MaxParticipants.MaxParticipantsValue,
-                JoinPolicy = whiteboard.JoinPolicy,
-                State = whiteboard.State
-            };
-            
-            _context.Whiteboards.Add(whiteboardEntity);
-        }
     }
     
     public async Task<bool> WhiteboardCodeExists(WhiteboardCode whiteboardCode)
     {
-        var codeExists = await _context.Whiteboards.AnyAsync(w => w.Code == whiteboardCode.CodeValue);
+        return await Context.Whiteboards.AnyAsync(w => w.Code == whiteboardCode.CodeValue);
-        return codeExists;
     }
 }

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

@@ -1,63 +1,52 @@
 using AipsCore.Domain.Models.WhiteboardMembership.External;
 using AipsCore.Domain.Models.WhiteboardMembership.ValueObjects;
+using AipsCore.Infrastructure.Persistence.Abstract;
 using AipsCore.Infrastructure.Persistence.Db;
 
 namespace AipsCore.Infrastructure.Persistence.WhiteboardMembership;
 
-public class WhiteboardMembershipRepository : IWhiteboardMembershipRepository
+public class WhiteboardMembershipRepository 
+    : AbstractRepository<Domain.Models.WhiteboardMembership.WhiteboardMembership, WhiteboardMembershipId, WhiteboardMembership>, 
+        IWhiteboardMembershipRepository
 {
-    private readonly AipsDbContext _context;
-    
     public WhiteboardMembershipRepository(AipsDbContext context)
+        : base(context)
     {
-        _context = context;
+        
     }
 
-    public async Task<Domain.Models.WhiteboardMembership.WhiteboardMembership?> Get(WhiteboardMembershipId whiteboardMembershipId, CancellationToken cancellationToken = default)
+    protected override Domain.Models.WhiteboardMembership.WhiteboardMembership MapToModel(WhiteboardMembership entity)
     {
-        var whiteboardMembershipEntity = await _context.WhiteboardMemberships.FindAsync(new Guid(whiteboardMembershipId.IdValue));
-        
-        if (whiteboardMembershipEntity is null) return null;
-
         return Domain.Models.WhiteboardMembership.WhiteboardMembership.Create(
-            whiteboardMembershipEntity.Id.ToString(),
+            entity.Id.ToString(),
-            whiteboardMembershipEntity.WhiteboardId.ToString(),
+            entity.WhiteboardId.ToString(),
-            whiteboardMembershipEntity.UserId.ToString(),
+            entity.UserId.ToString(),
-            whiteboardMembershipEntity.IsBanned,
+            entity.IsBanned,
-            whiteboardMembershipEntity.EditingEnabled,
+            entity.EditingEnabled,
-            whiteboardMembershipEntity.CanJoin,
+            entity.CanJoin,
-            whiteboardMembershipEntity.LastInteractedAt);
+            entity.LastInteractedAt
+        );
     }
 
-    public async Task Save(Domain.Models.WhiteboardMembership.WhiteboardMembership whiteboardMembership, CancellationToken cancellationToken = default)
+    protected override WhiteboardMembership MapToEntity(Domain.Models.WhiteboardMembership.WhiteboardMembership model)
     {
-        var whiteboardMembershipEntity = await _context.WhiteboardMemberships.FindAsync(new Guid(whiteboardMembership.Id.IdValue));
+        return new WhiteboardMembership
-        
-        if (whiteboardMembershipEntity is not null)
         {
-            whiteboardMembershipEntity.IsBanned = whiteboardMembership.IsBanned.IsBannedValue;
+            Id = new Guid(model.Id.IdValue),
-            whiteboardMembershipEntity.EditingEnabled = whiteboardMembership.EditingEnabled.EditingEnabledValue;
+            WhiteboardId = new Guid(model.WhiteboardId.IdValue),
-            whiteboardMembershipEntity.CanJoin = whiteboardMembership.CanJoin.CanJoinValue;
+            UserId = new Guid(model.UserId.IdValue),
-            whiteboardMembershipEntity.LastInteractedAt = whiteboardMembership.LastInteractedAt.LastInteractedAtValue;
+            IsBanned = model.IsBanned.IsBannedValue,
+            EditingEnabled = model.EditingEnabled.EditingEnabledValue,
+            CanJoin = model.CanJoin.CanJoinValue,
+            LastInteractedAt = model.LastInteractedAt.LastInteractedAtValue
+        };
+    }
 
-            _context.Update(whiteboardMembershipEntity);
+    protected override void UpdateEntity(WhiteboardMembership entity, Domain.Models.WhiteboardMembership.WhiteboardMembership model)
-        }
+    {
-        else
+        entity.IsBanned = model.IsBanned.IsBannedValue;
-        {
+        entity.EditingEnabled = model.EditingEnabled.EditingEnabledValue;
-            whiteboardMembershipEntity = new WhiteboardMembership()
+        entity.CanJoin = model.CanJoin.CanJoinValue;
-            {
+        entity.LastInteractedAt = model.LastInteractedAt.LastInteractedAtValue;
-                Id = new Guid(whiteboardMembership.Id.IdValue),
-                WhiteboardId = new Guid(whiteboardMembership.WhiteboardId.IdValue),
-                Whiteboard = null,
-                UserId = new Guid(whiteboardMembership.UserId.IdValue),
-                User = null,
-                IsBanned = whiteboardMembership.IsBanned.IsBannedValue,
-                EditingEnabled = whiteboardMembership.EditingEnabled.EditingEnabledValue,
-                CanJoin = whiteboardMembership.CanJoin.CanJoinValue,
-                LastInteractedAt = whiteboardMembership.LastInteractedAt.LastInteractedAtValue
-            };
-            
-            _context.Add(whiteboardMembershipEntity);
-        }
     }
 }