removed AggregateRoot base object

Source/Modules/Subscriptions/Features/DomainFeatures/StripeSubscriptionAggregate/StripeSubscription.cs

@@ -4,7 +4,7 @@
 
 namespace Modules.Subscriptions.Features.DomainFeatures.StripeSubscriptionAggregate
 {
-    public class StripeSubscription : AggregateRoot
+    public class StripeSubscription : Entity
     {
         private StripeSubscription() { }
 

Source/Modules/TenantIdentity/Features/DomainFeatures/TenantAggregate/Application/Commands/AddUserToTenant.cs

@@ -18,7 +18,7 @@ public AddUserToTenantCommandHandler(IServiceProvider serviceProvider) : base(se
 
         public async Task HandleAsync(AddUserToTenant command, CancellationToken cancellationToken)
         {
-            var tenant = await module.TenantIdentityDbContext.Tenants.GetAggregateRootAsync(command.TenantId, command.TenantId);
+            var tenant = await module.TenantIdentityDbContext.Tenants.GetEntityAsync(command.TenantId, command.TenantId);
 
             tenant.AddUser(command.UserId, command.Role);
 

Source/Modules/TenantIdentity/Features/DomainFeatures/TenantAggregate/Domain/Tenant.cs

@@ -6,7 +6,7 @@
 
 namespace Modules.TenantIdentity.Features.DomainFeatures.TenantAggregate.Domain
 {
-    public class Tenant : AggregateRoot
+    public class Tenant : Entity
     {
         public Tenant() { }
 

Source/Shared/Features/Domain/Entity.cs

@@ -1,5 +1,9 @@
-using Shared.Kernel.Interfaces;
+using Shared.Kernel.BuildingBlocks.Auth;
+using Shared.Kernel.BuildingBlocks;
+using Shared.Kernel.Interfaces;
 using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using Shared.Kernel.BuildingBlocks.Auth.Exceptions;
 
 namespace Shared.Features.Domain
 {
@@ -8,13 +12,24 @@ public abstract class Entity : IAuditable, IIdentifiable, IConcurrent
         [Key]
         public Guid Id { get; set; }
 
-        public Guid CreatedByUserId { get; set; }
+        public virtual Guid TenantId { get; set; }
 
         [ConcurrencyCheck]
         public byte[] RowVersion { get; set; }
 
         public DateTimeOffset CreatedAt { get; set; }
 
         public DateTimeOffset LastUpdatedAt { get; set; }
+
+        [NotMapped]
+        public IExecutionContext ExecutionContext { get; set; }
+
+        public void ThrowIfCallerIsNotInRole(TenantRole role)
+        {
+            if (ExecutionContext.TenantRole != role)
+            {
+                throw new UnauthorizedException();
+            }
+        }
     }
 }

Source/Shared/Features/EFCore/BaseDbContext.cs

@@ -54,7 +54,6 @@ public override async Task<int> SaveChangesAsync(CancellationToken cancellationT
             ThrowIfMultipleTenants();
             UpdateAutitableEntities();
             SetTenantId();
-            UpdateCreatedByUserEntities(executionContext.UserId);
             return await base.SaveChangesAsync(cancellationToken);
         }
 
@@ -75,14 +74,6 @@ private void UpdateAutitableEntities()
             }
         }
 
-        private void UpdateCreatedByUserEntities(Guid userId)
-        {
-            foreach (var entry in ChangeTracker.Entries<IAuditable>().Where(x => x.State == EntityState.Added))
-            {
-                entry.Entity.CreatedByUserId = userId;
-            }
-        }
-
         private void SetTenantId()
         {
             foreach (var entry in ChangeTracker.Entries<ITenantIdentifiable>().Where(x => x.State == EntityState.Added))
@@ -117,7 +108,7 @@ private void ThrowIfMultipleTenants()
 
         private void ThrowIfDbSetEntityNotTenantIdentifiable(ModelBuilder modelBuilder)
         {
-            foreach (var entityType in modelBuilder.Model.GetEntityTypes().Where(t => t is AggregateRoot))
+            foreach (var entityType in modelBuilder.Model.GetEntityTypes().Where(t => t is Entity))
             {
                 if (typeof(ITenantIdentifiable).IsAssignableFrom(entityType.ClrType) is false)
                 {

Source/Shared/Features/EFCore/DbSetExtensions.cs

@@ -5,9 +5,9 @@ namespace Shared.Features.EFCore
 {
     public static class DbSetExtensions
     {
-        public static async Task<TAggregateRoot> GetAggregateRootAsync<TAggregateRoot>(this DbSet<TAggregateRoot> dbSet, Guid owningTenantId, Guid aggregateRootId) where TAggregateRoot : AggregateRoot
+        public static async Task<TEntity> GetEntityAsync<TEntity>(this DbSet<TEntity> dbSet, Guid owningTenantId, Guid entityId) where TEntity : Entity
         {
-            return await dbSet.FirstAsync(t => t.TenantId == owningTenantId && t.Id == aggregateRootId);
+            return await dbSet.FirstAsync(t => t.TenantId == owningTenantId && t.Id == entityId);
         }
     }
 }

Source/Shared/Features/EFCore/ExecutionContextInterceptor.cs

@@ -11,9 +11,9 @@ public object InitializedInstance(
             MaterializationInterceptionData materializationData,
             object instance)
         {
-            if (instance is AggregateRoot aggregateRoot)
+            if (instance is Entity entity)
             {
-                aggregateRoot.ExecutionContext = materializationData
+                entity.ExecutionContext = materializationData
                     .Context
                     .GetService<IExecutionContext>();
             }

Source/Shared/Features/EFCore/MultiTenancy/MultiTenancyEntityConfiguration.cs

@@ -6,40 +6,25 @@ namespace Shared.Features.EFCore.MultiTenancy
 {
     public static class MultiTenancyEntityConfiguration
     {
-        static void ConfigureAggregateRoot<TAggregateRoot>(ModelBuilder modelBuilder, Guid teamId)
-           where TAggregateRoot : AggregateRoot
-        {
-            modelBuilder.Entity<TAggregateRoot>(builder =>
-            {
-                builder.HasQueryFilter(x => x.TenantId == teamId);
-            });
-        }
-
-        static void ConfigureEntity<TEntity, T>(ModelBuilder modelBuilder)
+        static void ConfigureEntity<TEntity, T>(ModelBuilder modelBuilder, Guid tenantId)
             where TEntity : Entity
         {
             modelBuilder.Entity<TEntity>(builder =>
             {
                 builder.HasKey(x => x.Id);
                 builder.Property(e => e.RowVersion).IsConcurrencyToken();
+                builder.HasQueryFilter(x => x.TenantId == tenantId);
             });
         }
 
-        public static ModelBuilder ApplyBaseEntityConfiguration(this ModelBuilder modelBuilder, Guid teamId)
+        public static ModelBuilder ApplyBaseEntityConfiguration(this ModelBuilder modelBuilder, Guid tenantId)
         {
-            var configureAggregateRootMethod = typeof(MultiTenancyEntityConfiguration).GetTypeInfo().DeclaredMethods
-                .Single(m => m.Name == nameof(ConfigureAggregateRoot));
             var configureEntityMethod = typeof(MultiTenancyEntityConfiguration).GetTypeInfo().DeclaredMethods
                 .Single(m => m.Name == nameof(ConfigureEntity));
 
-
-            foreach (var entityType in modelBuilder.Model.GetEntityTypes().Where(x => x is AggregateRoot))
-            {
-                configureAggregateRootMethod.MakeGenericMethod(entityType.ClrType, entityType.GetType()).Invoke(null, new object[] { modelBuilder, teamId });
-            }
             foreach (var entityType in modelBuilder.Model.GetEntityTypes().Where(x => x is Entity))
             {
-                configureEntityMethod.MakeGenericMethod(entityType.ClrType, entityType.GetType()).Invoke(null, new object[] { modelBuilder });
+                configureEntityMethod.MakeGenericMethod(entityType.ClrType, entityType.GetType()).Invoke(null, new object[] { modelBuilder, tenantId });
             }
 
             return modelBuilder;

Source/Shared/Kernel/Interfaces/IAuditable.cs

@@ -2,7 +2,6 @@
 {
     public interface IAuditable
     {
-        Guid CreatedByUserId { get; set; }
         DateTimeOffset CreatedAt { get; set; }
         DateTimeOffset LastUpdatedAt { get; set; }
     }