Refactored to follow naming convention

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

@@ -5,51 +5,51 @@ using Microsoft.EntityFrameworkCore;
 
 namespace AipsCore.Infrastructure.Persistence.Abstract;
 
-public abstract class AbstractRepository<TEntity, TId, TPersistenceEntity> : IAbstractRepository<TEntity, TId>
-    where TEntity : DomainEntity<TId>
+public abstract class AbstractRepository<TModel, TId, TEntity> : IAbstractRepository<TModel, TId>
+    where TModel : DomainModel<TId>
     where TId : DomainId
-    where TPersistenceEntity : class
+    where TEntity : class
 {
     protected readonly AipsDbContext Context;
-    protected readonly DbSet<TPersistenceEntity> DbSet;
+    protected readonly DbSet<TEntity> DbSet;
     
     protected AbstractRepository(AipsDbContext context)
     {
         Context = context;
-        DbSet = Context.Set<TPersistenceEntity>();
+        DbSet = Context.Set<TEntity>();
     }
     
-    public async Task<TEntity?> GetByIdAsync(TId id, CancellationToken cancellationToken = default)
+    public async Task<TModel?> GetByIdAsync(TId id, CancellationToken cancellationToken = default)
     {
-        var persistenceEntity = await DbSet.FindAsync([new Guid(id.IdValue)], cancellationToken);
+        var entity = await DbSet.FindAsync([new Guid(id.IdValue)], cancellationToken);
         
-        return persistenceEntity != null ? MapToDomainEntity(persistenceEntity) : null;
+        return entity != null ? MapToModel(entity) : null;
     }
 
-    public async Task SaveAsync(TEntity entity, CancellationToken cancellationToken = default)
+    public async Task SaveAsync(TModel model, CancellationToken cancellationToken = default)
     {
-        var persistenceEntity = await DbSet.FindAsync([new Guid(entity.Id.IdValue)], cancellationToken);
+        var entity = await DbSet.FindAsync([new Guid(model.Id.IdValue)], cancellationToken);
 
-        if (persistenceEntity == null)
+        if (entity == null)
         {
-            persistenceEntity = MapToPersistenceEntity(entity);
-            await DbSet.AddAsync(persistenceEntity, cancellationToken);
+            entity = MapToEntity(model);
+            await DbSet.AddAsync(entity, cancellationToken);
         }
         else
         {
-            UpdatePersistenceEntity(persistenceEntity, entity);
-            DbSet.Update(persistenceEntity);
+            UpdateEntity(entity, model);
+            DbSet.Update(entity);
         }
     }
 
-    public async Task AddAsync(TEntity entity, CancellationToken cancellationToken = default)
+    public async Task AddAsync(TModel model, CancellationToken cancellationToken = default)
     {
-        var persistenceEntity = MapToPersistenceEntity(entity);
+        var entity = MapToEntity(model);
         
-        await DbSet.AddAsync(persistenceEntity, cancellationToken);
+        await DbSet.AddAsync(entity, cancellationToken);
     }
 
-    protected abstract TEntity MapToDomainEntity(TPersistenceEntity persistenceEntity);
-    protected abstract TPersistenceEntity MapToPersistenceEntity(TEntity domainEntity);
-    protected abstract void UpdatePersistenceEntity(TPersistenceEntity persistenceEntity, TEntity domainEntity);
+    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,19 +8,19 @@ namespace AipsCore.Infrastructure.Persistence.Shape.Mappers;
 
 public static partial class ShapeMappers
 {
-    public static Domain.Models.Shape.Shape MapToDomainEntity(Shape shape)
+    public static Domain.Models.Shape.Shape MapToEntity(Shape shape)
     {
         return shape.Type switch
         {
-            ShapeType.Rectangle => PersistenceEntityToRectangle(shape),
-            ShapeType.Line => PersistenceEntityToLine(shape),
-            ShapeType.Arrow => PersistenceEntityToArrow(shape),
-            ShapeType.Text => PersistenceEntityToTextShape(shape),
+            ShapeType.Rectangle => EntityToRectangle(shape),
+            ShapeType.Line => EntityToLine(shape),
+            ShapeType.Arrow => EntityToArrow(shape),
+            ShapeType.Text => EntityToTextShape(shape),
             _ => throw new ArgumentOutOfRangeException()
         };
     }
 
-    private static Rectangle PersistenceEntityToRectangle(Shape shape)
+    public static Rectangle EntityToRectangle(Shape shape)
     {
         return Rectangle.Create(
             shape.Id.ToString(),
@@ -31,7 +31,7 @@ public static partial class ShapeMappers
             shape.Thickness!.Value);
     }
 
-    private static Line PersistenceEntityToLine(Shape shape)
+    public static Line EntityToLine(Shape shape)
     {
         return Line.Create(
             shape.Id.ToString(),
@@ -43,7 +43,7 @@ public static partial class ShapeMappers
             shape.Thickness!.Value);
     }
 
-    private static Arrow PersistenceEntityToArrow(Shape shape)
+    public static Arrow EntityToArrow(Shape shape)
     {
         return Arrow.Create(
             shape.Id.ToString(),
@@ -55,7 +55,7 @@ public static partial class ShapeMappers
             shape.Thickness!.Value);
     }
 
-    private static TextShape PersistenceEntityToTextShape(Shape shape)
+    public static TextShape EntityToTextShape(Shape shape)
     {
         return TextShape.Create(
             shape.Id.ToString(),

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

@@ -9,19 +9,19 @@ namespace AipsCore.Infrastructure.Persistence.Shape.Mappers;
 public static partial class ShapeMappers
 {
     
-    public static Shape MapToPersistenceEntity(Domain.Models.Shape.Shape model)
+    public static Shape MapToEntity(Domain.Models.Shape.Shape model)
     {
         return model.ShapeType switch
         {
-            ShapeType.Rectangle => RectangleToPersistenceEntity((Rectangle)model),
-            ShapeType.Line => LineToPersistenceEntity((Line)model),
-            ShapeType.Arrow => ArrowToPersistenceEntity((Arrow)model),
-            ShapeType.Text => TextShapeToPersistenceEntity((TextShape)model),
+            ShapeType.Rectangle => RectangleToEntity((Rectangle)model),
+            ShapeType.Line => LineToEntity((Line)model),
+            ShapeType.Arrow => ArrowToEntity((Arrow)model),
+            ShapeType.Text => TextShapeToEntity((TextShape)model),
             _ => throw new ArgumentOutOfRangeException()
         };
     }
 
-    private static Shape RectangleToPersistenceEntity(Rectangle rectangle)
+    public static Shape RectangleToEntity(Rectangle rectangle)
     {
         return new Shape
         {
@@ -38,7 +38,7 @@ public static partial class ShapeMappers
         };
     }
 
-    private static Shape LineToPersistenceEntity(Line line)
+    public static Shape LineToEntity(Line line)
     {
         return new Shape
         {
@@ -55,7 +55,7 @@ public static partial class ShapeMappers
         };
     }
 
-    private static Shape ArrowToPersistenceEntity(Arrow arrow)
+    public static Shape ArrowToEntity(Arrow arrow)
     {
         return new Shape
         {
@@ -72,7 +72,7 @@ public static partial class ShapeMappers
         };
     }
 
-    private static Shape TextShapeToPersistenceEntity(TextShape textShape)
+    public static Shape TextShapeToEntity(TextShape textShape)
     {
         return new Shape
         {

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

@@ -8,7 +8,7 @@ namespace AipsCore.Infrastructure.Persistence.Shape.Mappers;
 
 public static partial class ShapeMappers
 {
-    public static void UpdatePersistenceEntity(Shape entity, Domain.Models.Shape.Shape model)
+    public static void UpdateEntity(Shape entity, Domain.Models.Shape.Shape model)
     {
         entity.WhiteboardId = new Guid(model.WhiteboardId.IdValue);
         entity.PositionX = model.Position.X;
@@ -32,28 +32,28 @@ public static partial class ShapeMappers
         };
     }
 
-    private static void UpdateEntityFromRectangle(Shape entity, Rectangle rectangle)
+    public static void UpdateEntityFromRectangle(Shape entity, Rectangle rectangle)
     {
         entity.EndPositionX = rectangle.EndPosition.X;
         entity.EndPositionY = rectangle.EndPosition.Y;
         entity.Thickness = rectangle.BorderThickness.Value;
     }
 
-    private static void UpdateEntityFromLine(Shape entity, Line line)
+    public static void UpdateEntityFromLine(Shape entity, Line line)
     {
         entity.EndPositionX = line.EndPosition.X;
         entity.EndPositionY = line.EndPosition.Y;
         entity.Thickness = line.Thickness.Value;
     }
 
-    private static void UpdateEntityFromArrow(Shape entity, Arrow arrow)
+    public static void UpdateEntityFromArrow(Shape entity, Arrow arrow)
     {
         entity.EndPositionX = arrow.EndPosition.X;
         entity.EndPositionY = arrow.EndPosition.Y;
         entity.Thickness = arrow.Thickness.Value;
     }
 
-    private static void UpdateEntityFromTextShape(Shape entity, TextShape textShape)
+    public static void UpdateEntityFromTextShape(Shape entity, TextShape textShape)
     {
         entity.TextValue = textShape.TextShapeValue.Text;
         entity.TextSize = textShape.TextShapeSize.Size;

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

@@ -14,18 +14,18 @@ public class ShapeRepository : AbstractRepository<Domain.Models.Shape.Shape, Sha
         
     }
 
-    protected override Domain.Models.Shape.Shape MapToDomainEntity(Shape persistenceEntity)
+    protected override Domain.Models.Shape.Shape MapToModel(Shape entity)
     {
-        return ShapeMappers.MapToDomainEntity(persistenceEntity);
+        return ShapeMappers.MapToEntity(entity);
     }
 
-    protected override Shape MapToPersistenceEntity(Domain.Models.Shape.Shape domainEntity)
+    protected override Shape MapToEntity(Domain.Models.Shape.Shape model)
     {
-        return ShapeMappers.MapToPersistenceEntity(domainEntity);
+        return ShapeMappers.MapToEntity(model);
     }
 
-    protected override void UpdatePersistenceEntity(Shape persistenceEntity, Domain.Models.Shape.Shape domainEntity)
+    protected override void UpdateEntity(Shape entity, Domain.Models.Shape.Shape model)
     {
-        ShapeMappers.UpdatePersistenceEntity(persistenceEntity, domainEntity);
+        ShapeMappers.UpdateEntity(entity, model);
     }
 }

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

@@ -12,34 +12,34 @@ public class UserRepository : AbstractRepository<Domain.Models.User.User, UserId
     {
     }
 
-    protected override Domain.Models.User.User MapToDomainEntity(User persistenceEntity)
+    protected override Domain.Models.User.User MapToModel(User entity)
     {
         return Domain.Models.User.User.Create(
-            persistenceEntity.Id.ToString(),
-            persistenceEntity.Email,
-            persistenceEntity.Username,
-            persistenceEntity.CreatedAt,
-            persistenceEntity.DeletedAt
+            entity.Id.ToString(),
+            entity.Email,
+            entity.Username,
+            entity.CreatedAt,
+            entity.DeletedAt
         );
     }
 
-    protected override User MapToPersistenceEntity(Domain.Models.User.User domainEntity)
+    protected override User MapToEntity(Domain.Models.User.User model)
     {
         return new User
         {
-            Id = new Guid(domainEntity.Id.IdValue),
-            Email = domainEntity.Email.EmailValue,
-            Username = domainEntity.Username.UsernameValue,
-            CreatedAt = domainEntity.CreatedAt.CreatedAtValue,
-            DeletedAt = domainEntity.DeletedAt.DeletedAtValue
+            Id = new Guid(model.Id.IdValue),
+            Email = model.Email.EmailValue,
+            Username = model.Username.UsernameValue,
+            CreatedAt = model.CreatedAt.CreatedAtValue,
+            DeletedAt = model.DeletedAt.DeletedAtValue
         };
     }
 
-    protected override void UpdatePersistenceEntity(User persistenceEntity, Domain.Models.User.User domainEntity)
+    protected override void UpdateEntity(User entity, Domain.Models.User.User model)
     {
-        persistenceEntity.Email = domainEntity.Email.EmailValue;
-        persistenceEntity.Username = domainEntity.Username.UsernameValue;
-        persistenceEntity.CreatedAt = domainEntity.CreatedAt.CreatedAtValue;
-        persistenceEntity.DeletedAt = domainEntity.DeletedAt.DeletedAtValue;
+        entity.Email = model.Email.EmailValue;
+        entity.Username = model.Username.UsernameValue;
+        entity.CreatedAt = model.CreatedAt.CreatedAtValue;
+        entity.DeletedAt = model.DeletedAt.DeletedAtValue;
     }
 }

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

@@ -15,46 +15,46 @@ public class WhiteboardRepository
         
     }
 
-    protected override Domain.Models.Whiteboard.Whiteboard MapToDomainEntity(Whiteboard persistenceEntity)
+    protected override Domain.Models.Whiteboard.Whiteboard MapToModel(Whiteboard entity)
     {
         return Domain.Models.Whiteboard.Whiteboard.Create(
-            persistenceEntity.Id.ToString(),
-            persistenceEntity.OwnerId.ToString(),
-            persistenceEntity.Code,
-            persistenceEntity.Title,
-            persistenceEntity.CreatedAt,
-            persistenceEntity.DeletedAt,
-            persistenceEntity.MaxParticipants,
-            persistenceEntity.JoinPolicy,
-            persistenceEntity.State
+            entity.Id.ToString(),
+            entity.OwnerId.ToString(),
+            entity.Code,
+            entity.Title,
+            entity.CreatedAt,
+            entity.DeletedAt,
+            entity.MaxParticipants,
+            entity.JoinPolicy,
+            entity.State
         );
     }
 
-    protected override Whiteboard MapToPersistenceEntity(Domain.Models.Whiteboard.Whiteboard domainEntity)
+    protected override Whiteboard MapToEntity(Domain.Models.Whiteboard.Whiteboard model)
     {
         return new Whiteboard
         {
-            Id = new Guid(domainEntity.Id.IdValue),
-            OwnerId = new Guid(domainEntity.WhiteboardOwnerId.IdValue),
-            Code = domainEntity.Code.CodeValue,
-            Title = domainEntity.Title.TitleValue,
-            CreatedAt = domainEntity.CreatedAt.CreatedAtValue,
-            DeletedAt = domainEntity.DeletedAt.DeletedAtValue,
-            MaxParticipants = domainEntity.MaxParticipants.MaxParticipantsValue,
-            JoinPolicy = domainEntity.JoinPolicy,
-            State = domainEntity.State
+            Id = new Guid(model.Id.IdValue),
+            OwnerId = new Guid(model.WhiteboardOwnerId.IdValue),
+            Code = model.Code.CodeValue,
+            Title = model.Title.TitleValue,
+            CreatedAt = model.CreatedAt.CreatedAtValue,
+            DeletedAt = model.DeletedAt.DeletedAtValue,
+            MaxParticipants = model.MaxParticipants.MaxParticipantsValue,
+            JoinPolicy = model.JoinPolicy,
+            State = model.State
         };
     }
 
-    protected override void UpdatePersistenceEntity(Whiteboard persistenceEntity, Domain.Models.Whiteboard.Whiteboard domainEntity)
+    protected override void UpdateEntity(Whiteboard entity, Domain.Models.Whiteboard.Whiteboard model)
     {
-        persistenceEntity.Code = domainEntity.Code.CodeValue;
-        persistenceEntity.Title = domainEntity.Title.TitleValue;
-        persistenceEntity.CreatedAt = domainEntity.CreatedAt.CreatedAtValue;
-        persistenceEntity.DeletedAt = domainEntity.DeletedAt.DeletedAtValue;
-        persistenceEntity.MaxParticipants = domainEntity.MaxParticipants.MaxParticipantsValue;
-        persistenceEntity.JoinPolicy = domainEntity.JoinPolicy;
-        persistenceEntity.State = domainEntity.State;
+        entity.Code = model.Code.CodeValue;
+        entity.Title = model.Title.TitleValue;
+        entity.CreatedAt = model.CreatedAt.CreatedAtValue;
+        entity.DeletedAt = model.DeletedAt.DeletedAtValue;
+        entity.MaxParticipants = model.MaxParticipants.MaxParticipantsValue;
+        entity.JoinPolicy = model.JoinPolicy;
+        entity.State = model.State;
     }
     
     public async Task<bool> WhiteboardCodeExists(WhiteboardCode whiteboardCode)

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

@@ -15,38 +15,38 @@ public class WhiteboardMembershipRepository
         
     }
 
-    protected override Domain.Models.WhiteboardMembership.WhiteboardMembership MapToDomainEntity(WhiteboardMembership persistenceEntity)
+    protected override Domain.Models.WhiteboardMembership.WhiteboardMembership MapToModel(WhiteboardMembership entity)
     {
         return Domain.Models.WhiteboardMembership.WhiteboardMembership.Create(
-            persistenceEntity.Id.ToString(),
-            persistenceEntity.WhiteboardId.ToString(),
-            persistenceEntity.UserId.ToString(),
-            persistenceEntity.IsBanned,
-            persistenceEntity.EditingEnabled,
-            persistenceEntity.CanJoin,
-            persistenceEntity.LastInteractedAt
+            entity.Id.ToString(),
+            entity.WhiteboardId.ToString(),
+            entity.UserId.ToString(),
+            entity.IsBanned,
+            entity.EditingEnabled,
+            entity.CanJoin,
+            entity.LastInteractedAt
         );
     }
 
-    protected override WhiteboardMembership MapToPersistenceEntity(Domain.Models.WhiteboardMembership.WhiteboardMembership domainEntity)
+    protected override WhiteboardMembership MapToEntity(Domain.Models.WhiteboardMembership.WhiteboardMembership model)
     {
         return new WhiteboardMembership
         {
-            Id = new Guid(domainEntity.Id.IdValue),
-            WhiteboardId = new Guid(domainEntity.WhiteboardId.IdValue),
-            UserId = new Guid(domainEntity.UserId.IdValue),
-            IsBanned = domainEntity.IsBanned.IsBannedValue,
-            EditingEnabled = domainEntity.EditingEnabled.EditingEnabledValue,
-            CanJoin = domainEntity.CanJoin.CanJoinValue,
-            LastInteractedAt = domainEntity.LastInteractedAt.LastInteractedAtValue
+            Id = new Guid(model.Id.IdValue),
+            WhiteboardId = new Guid(model.WhiteboardId.IdValue),
+            UserId = new Guid(model.UserId.IdValue),
+            IsBanned = model.IsBanned.IsBannedValue,
+            EditingEnabled = model.EditingEnabled.EditingEnabledValue,
+            CanJoin = model.CanJoin.CanJoinValue,
+            LastInteractedAt = model.LastInteractedAt.LastInteractedAtValue
         };
     }
 
-    protected override void UpdatePersistenceEntity(WhiteboardMembership persistenceEntity, Domain.Models.WhiteboardMembership.WhiteboardMembership domainEntity)
+    protected override void UpdateEntity(WhiteboardMembership entity, Domain.Models.WhiteboardMembership.WhiteboardMembership model)
     {
-        persistenceEntity.IsBanned = domainEntity.IsBanned.IsBannedValue;
-        persistenceEntity.EditingEnabled = domainEntity.EditingEnabled.EditingEnabledValue;
-        persistenceEntity.CanJoin = domainEntity.CanJoin.CanJoinValue;
-        persistenceEntity.LastInteractedAt = domainEntity.LastInteractedAt.LastInteractedAtValue;
+        entity.IsBanned = model.IsBanned.IsBannedValue;
+        entity.EditingEnabled = model.EditingEnabled.EditingEnabledValue;
+        entity.CanJoin = model.CanJoin.CanJoinValue;
+        entity.LastInteractedAt = model.LastInteractedAt.LastInteractedAtValue;
     }
 }