Added aggragate id in domain event context (#99)

Author: adimiko

source/EasyWay.EntityFrameworkCore/Extnsions.cs

@@ -1,5 +1,5 @@
-using EasyWay.Internals.AggregateRoots;
-using EasyWay.Internals.DomainEvents;
+using EasyWay.Internals.DomainEvents;
+using EasyWay.Internals.Entities;
 using EasyWay.Internals.Repositories;
 using EasyWay.Internals.Transactions;
 using Microsoft.EntityFrameworkCore;
@@ -18,8 +18,7 @@ public static void AddEntityFrameworkCore<TContext>(
 
             services.AddScoped((Func<IServiceProvider, DbContext>)(sp => sp.GetRequiredService<TContext>()));
 
-            services.AddScoped<IAggregateRootsContext, EntityFrameworkAggregateRootsContext>();
-            services.AddTransient<IDomainEventsContext, DomainEventsAccessor>();
+            services.AddScoped<IEntitiesContext, EntityFrameworkEntitiesContext>();
 
             services.AddScoped(typeof(IGenericRepository<>), typeof(GenericRepository<>));
 

source/EasyWay.EntityFrameworkCore/Internals/AggregateRoots/EntityFrameworkAggregateRootsContext.cs

@@ -0,0 +1,16 @@
+using EasyWay.Internals.DomainEvents;
+using Microsoft.EntityFrameworkCore;
+
+namespace EasyWay.Internals.Entities
+{
+    internal sealed class EntityFrameworkEntitiesContext : IEntitiesContext
+    {
+        private readonly DbContext _dbContext;
+
+        public EntityFrameworkEntitiesContext(DbContext dbContext) => _dbContext = dbContext;
+
+        public IEnumerable<AggregateRoot> GetAggregateRoots() => _dbContext.ChangeTracker.Entries<AggregateRoot>().Select(x => x.Entity);
+
+        public IEnumerable<Entity> GetEntities() => _dbContext.ChangeTracker.Entries<Entity>().Select(x => x.Entity);
+    }
+}

source/EasyWay.EntityFrameworkCore/Internals/DomainEvents/DomainEventsAccessor.cs

@@ -37,8 +37,7 @@ protected void Add<TDomainEvent>(TDomainEvent domainEvent)
             var domainEventContext = new DomainEventContext()
             {
                 EventId = GuidGenerator.New,
-                AggragetRootId = Id, // TODO what when we have object graph
-                EntityId = Id,
+                Entity = this,
                 OccurrenceOnUtc = InternalClock.UtcNow,
                 DomainEvent = domainEvent,
             };

source/EasyWay.EntityFrameworkCore/Internals/Entities/EntityFrameworkEntitiesContext.cs

@@ -1,18 +1,19 @@
-namespace EasyWay.Internals.AggregateRoots
+using EasyWay.Internals.DomainEvents;
+
+namespace EasyWay.Internals.AggregateRoots
 {
     internal sealed class ConcurrencyTokenUpdater
     {
-        private readonly IAggregateRootsContext _aggragateRootsContext;
+        private readonly IEntitiesContext _context;
 
-        public ConcurrencyTokenUpdater(
-            IAggregateRootsContext aggragateRootsContext)
+        public ConcurrencyTokenUpdater(IEntitiesContext context)
         {
-            _aggragateRootsContext = aggragateRootsContext;
+            _context = context;
         }
 
         public void Update()
         {
-            var aggragateRoots = _aggragateRootsContext.GetAggregateRoots();
+            var aggragateRoots = _context.GetAggregateRoots();
 
             foreach (var aggragateRoot in aggragateRoots)
             {

source/EasyWay/Entity.cs

@@ -0,0 +1,26 @@
+using System.Collections.ObjectModel;
+using System.Reflection;
+
+namespace EasyWay.Internals.Assemblies
+{
+    internal sealed class EntitiesFieldsInfo
+    {
+        internal static ReadOnlyDictionary<Type, FieldInfo[]> Dictionary;
+
+        internal EntitiesFieldsInfo(IEnumerable<Type> types)
+        {
+            var dictionary = new Dictionary<Type, FieldInfo[]>();
+
+            var aggregateRootTypes = types.Where(x => x.IsSubclassOf(typeof(AggregateRoot)));
+
+            foreach (var aggregateRootType in aggregateRootTypes)
+            {
+                var fields = aggregateRootType.GetFields(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public);
+
+                dictionary.Add(aggregateRootType, fields);
+            }
+
+            Dictionary = new ReadOnlyDictionary<Type, FieldInfo[]>(dictionary);
+        }
+    }
+}

source/EasyWay/Internals/AggregateRoots/ConcurrencyTokenUpdater.cs

@@ -0,0 +1,19 @@
+using Microsoft.Extensions.DependencyInjection;
+using System.Reflection;
+
+namespace EasyWay.Internals.Assemblies
+{
+    internal static class Extensions
+    {
+        internal static IServiceCollection AddAssemblies(
+            this IServiceCollection services,
+            IEnumerable<Assembly> assemblies)
+        {
+            var types = assemblies.SelectMany(x => x.GetTypes()).Distinct();
+
+            new EntitiesFieldsInfo(types);
+
+            return services;
+        }
+    }
+}

source/EasyWay/Internals/AggregateRoots/IAggregateRootsContext.cs

@@ -0,0 +1,91 @@
+using EasyWay.Internals.Assemblies;
+using System.Collections;
+using System.Reflection;
+
+namespace EasyWay.Internals.DomainEvents.AggragateRootIds
+{
+    internal sealed class AggrageteRootIdSearcher
+    {
+        private readonly IEntitiesContext _context;
+
+        private readonly RelationshipsBetweenEntityAndAggragaeRoot _relation;
+
+        public AggrageteRootIdSearcher(
+            IEntitiesContext context,
+            RelationshipsBetweenEntityAndAggragaeRoot relation)
+        {
+            _context = context;
+            _relation = relation;
+        }
+
+        public Guid SearchId(Entity entity)
+        {
+            if (entity.GetType().IsSubclassOf(typeof(AggregateRoot)))
+            {
+                return entity.Id;
+            }
+
+            var aggrageteRoots = _context.GetAggregateRoots();
+
+            if (aggrageteRoots.Count() == 1)
+            {
+                return aggrageteRoots.Single().Id;
+            }
+
+            var aggragateRootType = _relation[entity.GetType()];
+
+            var aggragateRoots = _context.GetAggregateRoots().Where(x => x.GetType() == aggragateRootType);
+
+            foreach (var aggregateRoot in aggragateRoots)
+            {
+                var id = SearchInAggragates(entity, aggregateRoot);
+
+                if (id is not null)
+                {
+                    return id.Value;
+                }
+            }
+
+            throw new NotFoundAggragateIdForDomainEvent();
+        }
+
+        private static Guid? SearchInAggragates(Entity entity, AggregateRoot aggregateRoot)
+        {
+            var fields = EntitiesFieldsInfo.Dictionary[aggregateRoot.GetType()];
+
+            foreach (var field in fields)
+            {
+                var isEntity = field.FieldType.IsSubclassOf(typeof(Entity));
+
+                if (isEntity)
+                {
+                    var isEqual = field.GetValue(aggregateRoot).Equals(entity);
+
+                    if (isEqual)
+                    {
+                        return aggregateRoot.Id;
+                    }
+                }
+
+                if (field.FieldType != typeof(string) && typeof(IEnumerable).IsAssignableFrom(field.FieldType))
+                {
+                    if (field.GetValue(aggregateRoot) is IEnumerable enumerable)
+                    {
+                        foreach (var en in enumerable)
+                        {
+                            if (en is Entity entityItem)
+                            {
+                                if (entityItem == entity)
+                                {
+                                    return aggregateRoot.Id;
+                                }
+
+                            }
+                        }
+                    }
+                }
+            }
+            return null;
+        }
+    }
+}