Atualização de versão e melhorias na verificação de e-mail

* Atualização de versão
  - Atualizados `DomainVer` e `PersistVer` para novos números de versão.

* Testes e configuração do UnitOfWork
  - Adicionada nova função de teste para configurar o UnitOfWork.
  - Simplificada a lógica de adição de repositórios no `IUnitOfWorkBuilder`.
  - Introduzido método para adicionar repositórios de entidades.

* Estrutura de e-mail e verificação
  - Atualizada a classe `Author` para incluir verificações de e-mail.
  - Criada a classe `EmailVerificationMapping` para configuração de entidades.
  - Desenvolvida a classe `EmailVerification` com lógica de validação.
  - Adicionada nova classe `VerifyEmail` para futuras implementações.

Author: eglauko

RoyalCode.EnterprisePatterns/Directory.Build.props

@@ -9,7 +9,7 @@
 		<DomainVer>0.8.0</DomainVer>
 		<DomainPreview></DomainPreview>
 
-		<PersistVer>0.8.4</PersistVer>
+		<PersistVer>0.8.5</PersistVer>
 		<PersistPreview></PersistPreview>
 
 		<CommandVer>0.1.0</CommandVer>

RoyalCode.EnterprisePatterns/RoyalCode.Persistence.Tests/UnitOfWork/UnitOfWorkBuilderTests.cs

@@ -3,6 +3,7 @@
 using RoyalCode.Persistence.Tests.Entities;
 using RoyalCode.Repositories;
 using RoyalCode.UnitOfWork;
+using RoyalCode.UnitOfWork.EntityFramework;
 using Xunit;
 
 namespace RoyalCode.Persistence.Tests.UnitOfWork;
@@ -38,6 +39,36 @@ public void ConfigureUnitOfWorkContextAndRepository()
 
         scope.Dispose();
     }
+
+    [Fact]
+    public void ConfigureUnitOfWorkFromAssembly()
+    {
+        ServiceCollection services = new();
+
+        services.AddUnitOfWorkDefault()
+            .ConfigureOptions(builder => builder.UseSqlite("DataSource=:memory:"))
+            .ConfigureMappingsFromAssembly(typeof(UnitOfWorkBuilderTests).Assembly, true);
+
+        var root = services.BuildServiceProvider();
+        var scope = root.CreateScope();
+        var sp = scope.ServiceProvider;
+
+        var db = sp.GetService<DefaultDbContext>();
+        Assert.NotNull(db);
+
+        db!.Database.EnsureCreated();
+
+        var uow = sp.GetService<IUnitOfWork>();
+        Assert.NotNull(uow);
+
+        var repo = sp.GetService<IRepository<Person>>();
+        Assert.NotNull(repo);
+
+        var set = db.Set<Person>();
+        Assert.NotNull(set);
+
+        scope.Dispose();
+    }
 }
 
 #region Test classes

RoyalCode.EnterprisePatterns/RoyalCode.UnitOfWork.EntityFramework/Configurations/IUnitOfWorkBuilder.cs

@@ -250,14 +250,11 @@ public TBuilder UseLoggerFactoryAndEnableSensitiveDataLogging(bool isDevelopment
     /// <returns>The same instance.</returns>
     public TBuilder ConfigureMappingsFromAssembly(Assembly assembly, bool addRepositories)
     {
+        if (addRepositories)
+            AddRepositories(assembly);
         return ConfigureModel(modelBuilder =>
         {
-            if (addRepositories)
-                modelBuilder.ApplyConfigurationsFromAssembly(
-                    assembly,
-                    type => AddRepositories(type));
-            else
-                modelBuilder.ApplyConfigurationsFromAssembly(assembly);
+            modelBuilder.ApplyConfigurationsFromAssembly(assembly);
         });
     }
 
@@ -276,32 +273,36 @@ public TBuilder ConfigureMappingsFromAssembly<TTypeFromAssembly>(bool addReposit
         return ConfigureMappingsFromAssembly(typeof(TTypeFromAssembly).Assembly, addRepositories);
     }
 
-    private bool AddRepositories(Type type)
+    /// <summary>
+    /// <para>
+    ///     Adds repositories for all entity types found in the specified assembly.
+    /// </para>
+    /// <para>
+    ///     Will scan the assembly for types that implement <see cref="IEntityTypeConfiguration{TEntity}"/>,
+    ///     so the entity type will be the generic type argument of the interface.
+    /// </para>
+    /// <para>
+    ///     For each entity type found, it will be added a repository related to the unit of work.
+    /// </para>
+    /// </summary>
+    /// <param name="assembly"></param>
+    /// <returns></returns>
+    public TBuilder AddRepositories(Assembly assembly)
     {
-        // checks if it is an entity configuration and gets the type of the configured entity
-        Type? entityType = null;
-        foreach (var @interface in type.GetInterfaces())
+        // gets all entities types from the assembly getting the configurations (IEntityTypeConfiguration<>)
+        var entityTypes = assembly.GetTypes()
+            .Where(type => type.IsClass && !type.IsAbstract)
+            .SelectMany(type => type.GetInterfaces())
+            .Where(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IEntityTypeConfiguration<>))
+            .Select(i => i.GetGenericArguments()[0]);
+
+        // adds repositories for each entity type
+        foreach (var type in entityTypes)
         {
-            if (!@interface.IsGenericType)
-            {
-                continue;
-            }
-
-            if (@interface.GetGenericTypeDefinition() == typeof(IEntityTypeConfiguration<>))
-            {
-                entityType = @interface.GetGenericArguments()[0];
-            }
+            ConfigureRepositories(r => r.Add(type));
         }
 
-        // if it is not an entity configuration, ignore
-        if (entityType is null)
-            return false;
-
-        // adds the repository for the configured entity
-        ConfigureRepositories(r => r.Add(entityType));
-
-        // finally returns true to indicate that the configuration has been added
-        return true;
+        return (TBuilder)this;
     }
 }
 

RoyalCode.Examples/RoyalCode.Examples.Blogs/Contracts/Authors/VerifyEmail.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace RoyalCode.Examples.Blogs.Contracts.Authors
+{
+    internal class VerifyEmail
+    {
+    }
+}

RoyalCode.Examples/RoyalCode.Examples.Blogs/Core/Support/Author.cs

@@ -10,6 +10,7 @@ public Author(string name, string email)
         Name = name;
         Email = email;
         CreatedAt = DateTime.UtcNow;
+        EmailVerifications = [new EmailVerification(this)];
     }
 
 #nullable disable
@@ -29,6 +30,8 @@ public Author() { }
 
     public DateTime? LastModifiedDate { get; set; }
 
+    public ICollection<EmailVerification> EmailVerifications { get; set; }
+
     public void ConfirmAuthor() 
     {
         IsConfirmed = true;

RoyalCode.Examples/RoyalCode.Examples.Blogs/Core/Support/EmailVerification.cs

@@ -0,0 +1,68 @@
+using RoyalCode.Entities;
+using RoyalCode.SmartProblems;
+using System.Text;
+
+namespace RoyalCode.Examples.Blogs.Core.Support;
+
+public class EmailVerification : Entity<Guid>
+{
+
+    public EmailVerification(Author author)
+    {
+        Id = Guid.CreateVersion7();
+        LinkCode = Guid.NewGuid().ToString("N");
+
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < 6; i++)
+        {
+            sb.Append(Random.Shared.Next(0, 10));
+        }
+        UICode = sb.ToString();
+
+        Author = author;
+        CreatedAt = DateTimeOffset.UtcNow;
+        ValidUntil = CreatedAt.AddDays(1);
+    }
+
+#nullable disable
+    /// <summary>
+    /// Constructor for deserialization purposes.
+    /// </summary>
+    public EmailVerification() { }
+#nullable enable
+
+    public string LinkCode { get; set; }
+
+    public string UICode { get; set; }
+
+    public Author Author { get; set; }
+
+    public DateTimeOffset CreatedAt { get; set; }
+
+    public DateTimeOffset ValidUntil { get; set; }
+
+    public DateTimeOffset? ValidatedAt { get; set; }
+
+    public Result TryValidate(string code)
+    {
+        if (ValidatedAt.HasValue)
+        {
+            return Problems.InvalidState("Email already validated.");
+        }
+        
+        if (UICode != code)
+        {
+            return Problems.InvalidParameter("Invalid verification code.");
+        }
+        
+        if (DateTimeOffset.UtcNow > ValidUntil)
+        {
+            return Problems.InvalidState("Verification code expired.");
+        }
+
+        ValidatedAt = DateTimeOffset.UtcNow;
+        Author.ConfirmAuthor();
+        
+        return Result.Ok();
+    }
+}

RoyalCode.Examples/RoyalCode.Examples.Blogs/Infra/Persistence/ConfigureWorkContext.cs

@@ -22,7 +22,8 @@ public static IWorkContextBuilder<TDbContext> ConfigureBlogs<TDbContext>(this IW
                     .Add<Post>()
                     .Add<Core.Blogs.Thread>()
                     .Add<Comment>()
-                    .Add<Author>();
+                    .Add<Author>()
+                    .Add<EmailVerification>();
             })
             .ConfigureSearches(b =>
             {
@@ -102,4 +103,16 @@ public void Configure(EntityTypeBuilder<Author> builder)
     {
 
     }
+}
+
+public class EmailVerificationMapping : IEntityTypeConfiguration<EmailVerification>
+{
+    public void Configure(EntityTypeBuilder<EmailVerification> builder)
+    {
+        builder
+            .HasOne(ev => ev.Author)
+            .WithMany(a => a.EmailVerifications)
+            .HasForeignKey("AuthorId")
+            .OnDelete(DeleteBehavior.Cascade);
+    }
 }