Refactor entities and add group creation feature

Refactored several entities to use GUIDs instead of strings for IDs, including updates to the `Certificate`, `Group`, and `Skill` classes. Added new properties and methods to support domain-driven design, such as the `CreateGroupCommandHandler` and `GroupCreated` domain event. Updated `ServiceCollectionExtensions` to register `IUnitOfWork` as a transient service. Introduced a new migration file to handle database schema changes. Added a new API endpoint for group creation in `GroupApi.cs`.

MBS_COMMAND.Application/MBS_COMMAND.Application.csproj

@@ -21,7 +21,6 @@
     </ItemGroup>
 
     <ItemGroup>
-      <Folder Include="UserCases\Commands\" />
       <Folder Include="UserCases\Queries\" />
     </ItemGroup>
 

MBS_COMMAND.Application/UserCases/Commands/Groups/CreateGroupCommandHandler.cs

@@ -0,0 +1,24 @@
+using MBS_COMMAND.Contract.Abstractions.Messages;
+using MBS_COMMAND.Contract.Abstractions.Shared;
+using MBS_COMMAND.Contract.Services.Groups;
+using MBS_COMMAND.Domain.Abstractions.Repositories;
+using MBS_COMMAND.Domain.Entities;
+
+namespace MBS_COMMAND.Application.UserCases.Commands.Groups;
+
+public sealed class CreateGroupCommandHandler : ICommandHandler<Command.CreateGroupCommand>
+{
+    private readonly IRepositoryBase<Group, Guid> _repositoryBase;
+
+    public CreateGroupCommandHandler(IRepositoryBase<Group, Guid> repositoryBase)
+    {
+        _repositoryBase = repositoryBase;
+    }
+
+    public async Task<Result> Handle(Command.CreateGroupCommand request, CancellationToken cancellationToken)
+    {
+        var G = Group.Create(request.Name, request.Stacks, request.MentorId);
+        _repositoryBase.Add(G);
+        return Result.Success();
+    }
+}

MBS_COMMAND.Contract/Services/Groups/Command.cs

@@ -0,0 +1,8 @@
+using MBS_COMMAND.Contract.Abstractions.Messages;
+
+namespace MBS_COMMAND.Contract.Services.Groups;
+
+public static class Command
+{
+    public record CreateGroupCommand(string Name,Guid MentorId,string Stacks) : ICommand;
+}

MBS_COMMAND.Contract/Services/Groups/DomainEvents.cs

@@ -0,0 +1,8 @@
+using MBS_COMMAND.Contract.Abstractions.Messages;
+
+namespace MBS_COMMAND.Contract.Services.Groups;
+
+public static class DomainEvents
+{
+    public record GroupCreated(Guid IdEvent, Guid Id, string Name, Guid? MentorId, string Stacks) : IDomainEvent, ICommand;
+}

MBS_COMMAND.Domain/Entities/Certificate.cs

@@ -7,8 +7,8 @@ public class Certificate : Entity<Guid>,IAuditableEntity
     public string Name { get; set; }
     public string Description { get; set; }
     public string ImageUrl { get; set; }
-    public string SkillId { get; set; }
-    public virtual Skill Skill { get; set; }
+    public Guid SkillId { get; set; }
+    public virtual Skill? Skill { get; set; }
     public DateTimeOffset CreatedOnUtc { get ; set ; }
     public DateTimeOffset? ModifiedOnUtc { get ; set ; }
 }

MBS_COMMAND.Domain/Entities/Group.cs

@@ -1,19 +1,39 @@
 using MBS_AUTHORIZATION.Domain.Entities;
+using MBS_COMMAND.Domain.Abstractions.Aggregates;
 using MBS_COMMAND.Domain.Abstractions.Entities;
 
 namespace MBS_COMMAND.Domain.Entities;
 
-public class Group : Entity<Guid>, IAuditableEntity
+public class Group : AggregateRoot<Guid>, IAuditableEntity
 {
-    public string Name { get; set; }
-    public Guid? MentorId { get; set; }
+    public string Name { get; private set; }
+    public Guid? MentorId { get; private set; }
     public virtual User? Mentor { get; set; }
 
-    public string? LeaderId { get; set; }
+    public Guid? LeaderId { get; set; }
     public virtual User? Leader { get; set; }
-    public string Stack { get; set; }
-    public Guid? ProjectId { get; set; }
+    public string Stack { get; private set; }
+    public Guid? ProjectId { get; private set; }
     public virtual Project? Project { get; set; }
-    public DateTimeOffset CreatedOnUtc { get ; set ; }
-    public DateTimeOffset? ModifiedOnUtc { get ; set ; }
+    public DateTimeOffset CreatedOnUtc { get; set; }
+    public DateTimeOffset? ModifiedOnUtc { get; set; }
+
+
+
+    public Group(string name, string stack, Guid? mentorId)
+    {
+        Name = name;
+        Stack = stack;
+        MentorId = mentorId;
+    }
+
+    public static Group Create(string name, string stack, Guid? mentorId)
+    {
+        var G = new Group(name, stack, mentorId);
+        G.RaiseDomainEvent(new Contract.Services.Groups.DomainEvents.GroupCreated(Guid.NewGuid(), G.Id, G.Name, G.MentorId, G.Stack));
+        return G;
+    }
+
 }
+
+

MBS_COMMAND.Domain/Entities/Skill.cs

@@ -9,6 +9,10 @@ public class Skill : Entity<Guid>, IAuditableEntity
     public virtual Category? Category { get; set; }
     public string Name { get; set; }
     public string Description { get; set; }
+    public string? CertificateId { get; set; }
     public DateTimeOffset CreatedOnUtc { get; set; }
     public DateTimeOffset? ModifiedOnUtc { get; set; }
+
+    public virtual IEnumerable<Certificate>? Certificates { get; set; } = [];
+
 }

MBS_COMMAND.Persistence/DependencyInjection/Extensions/ServiceCollectionExtensions.cs

@@ -1,4 +1,5 @@
 
+using MBS_COMMAND.Domain.Abstractions;
 using MBS_COMMAND.Domain.Abstractions.Repositories;
 using MBS_COMMAND.Persistence.DependencyInjection.Options;
 using MBS_COMMAND.Persistence.Interceptors;
@@ -69,6 +70,7 @@ public static void AddInterceptorPersistence(this IServiceCollection services)
     public static void AddRepositoryPersistence(this IServiceCollection services)
     {
         services.AddTransient(typeof(IRepositoryBase<,>), typeof(RepositoryBase<,>));
+        services.AddTransient(typeof(IUnitOfWork), typeof(EFUnitOfWork));
     }
 
     public static OptionsBuilder<SqlServerRetryOptions> ConfigureSqlServerRetryOptionsPersistence(this IServiceCollection services, IConfigurationSection section)

MBS_COMMAND.Persistence/EFUnitOfWork.cs

@@ -0,0 +1,78 @@
+
+using Microsoft.EntityFrameworkCore.ChangeTracking;
+using Microsoft.EntityFrameworkCore;
+using Newtonsoft.Json;
+using MBS_COMMAND.Domain.Abstractions;
+using MBS_COMMAND.Persistence.Outbox;
+using MBS_COMMAND.Domain.Abstractions.Entities;
+
+namespace MBS_COMMAND.Persistence;
+
+public class EFUnitOfWork : IUnitOfWork
+{
+    private readonly ApplicationDbContext _dbContext;
+
+    public EFUnitOfWork(ApplicationDbContext dbContext)
+        => _dbContext = dbContext;
+
+    public async Task SaveChangesAsync(CancellationToken cancellationToken = default)
+    {
+        //ConvertDomainEventsToOutboxMessages();
+        //UpdateAuditableEntities();
+        await _dbContext.SaveChangesAsync();
+    }
+
+    async ValueTask IAsyncDisposable.DisposeAsync()
+    => await _dbContext.DisposeAsync();
+
+    private void ConvertDomainEventsToOutboxMessages()
+    {
+        var outboxMessages = _dbContext.ChangeTracker
+            .Entries<Domain.Abstractions.Aggregates.AggregateRoot<Guid>>()
+            .Select(x => x.Entity)
+            .SelectMany(aggregateRoot =>
+            {
+                var domainEvents = aggregateRoot.GetDomainEvents();
+
+                aggregateRoot.ClearDomainEvents();
+
+                return domainEvents;
+            })
+            .Select(domainEvent => new OutboxMessage
+            {
+                Id = Guid.NewGuid(),
+                OccurredOnUtc = DateTime.UtcNow,
+                Type = domainEvent.GetType().Name,
+                Content = JsonConvert.SerializeObject(
+                    domainEvent,
+                    new JsonSerializerSettings
+                    {
+                        TypeNameHandling = TypeNameHandling.All
+                    })
+            })
+            .ToList();
+
+        _dbContext.Set<OutboxMessage>().AddRange(outboxMessages);
+    }
+
+    private void UpdateAuditableEntities()
+    {
+        IEnumerable<EntityEntry<IAuditableEntity>> entries =
+            _dbContext
+                .ChangeTracker
+                .Entries<IAuditableEntity>();
+
+        foreach (EntityEntry<IAuditableEntity> entityEntry in entries)
+        {
+            if (entityEntry.State == EntityState.Added)
+            {
+                entityEntry.Property(a => a.CreatedOnUtc).CurrentValue = DateTime.UtcNow;
+            }
+
+            if (entityEntry.State == EntityState.Modified)
+            {
+                entityEntry.Property(a => a.ModifiedOnUtc).CurrentValue = DateTime.UtcNow;
+            }
+        }
+    }
+}