ServerExecutionBase

Source/Modules/Subscriptions/Web/Server/Controllers/StripeSessionController.cs

@@ -26,7 +26,7 @@ public async Task<ActionResult> RedirectToStripePremiumSubscription([FromRoute]
                 TenantId = ExecutionContext.TenantId,
                 RedirectBaseUrl = ExecutionContext.BaseURI.AbsoluteUri
             };
-            var checkoutSession = await commandDispatcher.DispatchAsync<CreateStripeCheckoutSession, Stripe.Checkout.Session>(createStripeCheckoutSession);
+            var checkoutSession = await CommandDispatcher.DispatchAsync<CreateStripeCheckoutSession, Stripe.Checkout.Session>(createStripeCheckoutSession);
 
             Response.Headers.Add("Location", checkoutSession.Url);
             return new StatusCodeResult(303);
@@ -41,7 +41,7 @@ public async Task<ActionResult> Create()
                 UserId = ExecutionContext.UserId,
                 RedirectBaseUrl = ExecutionContext.BaseURI.AbsoluteUri,
             };
-            var billingPortalSession = await commandDispatcher.DispatchAsync<CreateStripeBillingPortalSession, Stripe.BillingPortal.Session>(createBillingPortalSession);
+            var billingPortalSession = await CommandDispatcher.DispatchAsync<CreateStripeBillingPortalSession, Stripe.BillingPortal.Session>(createBillingPortalSession);
 
             Response.Headers.Add("Location", billingPortalSession.Url);
             return new StatusCodeResult(303);

Source/Modules/TenantIdentity/Web/Server/Controllers/Aggregates/TenantsController.cs

@@ -32,7 +32,7 @@ public TenantsController(SignInManager<ApplicationUser> signInManager, IServiceP
         public async Task<ActionResult<TenantDTO>> GetTenant()
         {
             var tenantId = ExecutionContext.TenantId;
-            TenantDTO tenant = await ExecutionContext.QueryDispatcher.DispatchAsync<GetTenantByID, TenantDTO>(new GetTenantByID { TenantId = tenantId });
+            TenantDTO tenant = await QueryDispatcher.DispatchAsync<GetTenantByID, TenantDTO>(new GetTenantByID { TenantId = tenantId });
 
             return Ok(tenant);
         }
@@ -41,7 +41,7 @@ public async Task<ActionResult<TenantDTO>> GetTenant()
         public async Task<ActionResult<TenantDetailDTO>> GetTenantDetail()
         {
             var tenantId = ExecutionContext.TenantId;
-            TenantDetailDTO tenantDetail = await queryDispatcher.DispatchAsync<GetTenantDetailsByID, TenantDetailDTO>(new GetTenantDetailsByID { TenantId = tenantId });
+            TenantDetailDTO tenantDetail = await QueryDispatcher.DispatchAsync<GetTenantDetailsByID, TenantDetailDTO>(new GetTenantDetailsByID { TenantId = tenantId });
 
             return Ok(tenantDetail);
         }
@@ -51,24 +51,24 @@ public async Task<ActionResult<TenantDetailDTO>> GetTenantDetail()
         public async Task<ActionResult<IEnumerable<TenantDTO>>> GetAllTenantsWhereUserIsMember()
         {
             var userId = ExecutionContext.UserId;
-            List<TenantMembershipDTO> teamMemberships = await queryDispatcher.DispatchAsync<GetAllTenantMembershipsOfUser, List<TenantMembershipDTO>>(null);
+            List<TenantMembershipDTO> teamMemberships = await QueryDispatcher.DispatchAsync<GetAllTenantMembershipsOfUser, List<TenantMembershipDTO>>(null);
 
             return Ok(teamMemberships);
         }
 
         [HttpPost]
         public async Task<ActionResult<TenantDTO>> CreateTenant(CreateTenantDTO createTenantDTO)
         {
-            validationService.ThrowIfInvalidModel(createTenantDTO);
+            ValidationService.ThrowIfInvalidModel(createTenantDTO);
 
             var createTenant = new CreateTenantWithAdmin
             {
                 AdminId = ExecutionContext.UserId,
                 Name = createTenantDTO.Name
             };
-            var createdTenant = await commandDispatcher.DispatchAsync<CreateTenantWithAdmin, TenantDTO>(null);
+            var createdTenant = await CommandDispatcher.DispatchAsync<CreateTenantWithAdmin, TenantDTO>(null);
 
-            var user = await queryDispatcher.DispatchAsync<GetUserById, ApplicationUser>(new GetUserById { });
+            var user = await QueryDispatcher.DispatchAsync<GetUserById, ApplicationUser>(new GetUserById { });
             await signInManager.RefreshSignInAsync(user);
 
             return CreatedAtAction(nameof(CreateTenant), createdTenant);
@@ -77,10 +77,10 @@ public async Task<ActionResult<TenantDTO>> CreateTenant(CreateTenantDTO createTe
         [HttpDelete("{id}")]
         public async Task DeleteTenant(Guid id)
         {
-            await commandDispatcher.DispatchAsync<DeleteTenant>(new DeleteTenant { });
+            await CommandDispatcher.DispatchAsync<DeleteTenant>(new DeleteTenant { });
 
             var userId = ExecutionContext.UserId;
-            var user = await queryDispatcher.DispatchAsync<GetUserById, ApplicationUser>(new GetUserById { });
+            var user = await QueryDispatcher.DispatchAsync<GetUserById, ApplicationUser>(new GetUserById { });
 
             await signInManager.RefreshSignInAsync(user);
         }
@@ -90,23 +90,23 @@ public async Task<ActionResult> CreateTenantMembership(InviteUserToTenantDTO inv
         {
             var userId = ExecutionContext.UserId;
 
-            await commandDispatcher.DispatchAsync<AddUserToTenant>(null);
+            await CommandDispatcher.DispatchAsync<AddUserToTenant>(null);
 
             return Ok();
         }
 
         [HttpPut("memberships")]
         public async Task<ActionResult> UpdateTenantMembership(ChangeRoleOfTenantMemberDTO changeRoleOfTeamMemberDTO)
         {
-            await commandDispatcher.DispatchAsync<UpdateTenantMembership>(new UpdateTenantMembership { });
+            await CommandDispatcher.DispatchAsync<UpdateTenantMembership>(new UpdateTenantMembership { });
 
             return Ok();
         }
 
         [HttpDelete("memberships/{userId}")]
         public async Task<ActionResult> DeleteTenantMembership(Guid id)
         {
-            await commandDispatcher.DispatchAsync<RemoveUserFromTenant>(new RemoveUserFromTenant { });
+            await CommandDispatcher.DispatchAsync<RemoveUserFromTenant>(new RemoveUserFromTenant { });
 
             return Ok();
         }

Source/Shared/Features/CQRS/Command/BaseCommandHandler.cs

@@ -0,0 +1,30 @@
+using Microsoft.Extensions.DependencyInjection;
+using Shared.Features.CQRS.DomainEvent;
+using Shared.Features.CQRS.IntegrationEvent;
+using Shared.Features.CQRS.Query;
+using Shared.Kernel.BuildingBlocks.ModelValidation;
+using Shared.Kernel.BuildingBlocks;
+using Shared.Features.Server;
+
+namespace Shared.Features.CQRS.Command
+{
+    public class BaseCommandHandler : ServerExecutionBase
+    {
+        public IExecutionContext ExecutionContext { get; }
+        public ICommandDispatcher CommandDispatcher { get; }
+        public IQueryDispatcher QueryDispatcher { get; }
+        public IIntegrationEventDispatcher IntegrationEventDispatcher { get; }
+        public IDomainEventDispatcher DomainEventDispatcher { get; }
+        public IValidationService ValidationService { get; }
+
+        public BaseCommandHandler(IServiceProvider serviceProvider)
+        {
+            ExecutionContext = serviceProvider.GetRequiredService<IExecutionContext>();
+            CommandDispatcher = serviceProvider.GetRequiredService<ICommandDispatcher>();
+            QueryDispatcher = serviceProvider.GetRequiredService<IQueryDispatcher>();
+            IntegrationEventDispatcher = serviceProvider.GetRequiredService<IIntegrationEventDispatcher>();
+            DomainEventDispatcher = serviceProvider.GetRequiredService<IDomainEventDispatcher>();
+            ValidationService = serviceProvider.GetRequiredService<IValidationService>();
+        }
+    }
+}

Source/Shared/Features/CQRS/Command/ICommandHandler.cs

@@ -2,11 +2,11 @@
 
 namespace Shared.Features.CQRS.Command
 {
-    public interface ICommandHandler<in TCommand> : IInServerExecutionScope where TCommand : ICommand
+    public interface ICommandHandler<in TCommand> : ServerExecutionBase where TCommand : ICommand
     {
         Task HandleAsync(TCommand command, CancellationToken cancellationToken);
     }
-    public interface ICommandHandler<in TCommand, TResult> : IInServerExecutionScope where TCommand : ICommand<TResult>
+    public interface ICommandHandler<in TCommand, TResult> : ServerExecutionBase where TCommand : ICommand<TResult>
     {
         Task<TResult> HandleAsync(TCommand command, CancellationToken cancellationToken);
     }

Source/Shared/Features/CQRS/DomainEvent/BaseDomainEventHandler.cs

@@ -0,0 +1,30 @@
+using Microsoft.Extensions.DependencyInjection;
+using Shared.Features.CQRS.Command;
+using Shared.Features.CQRS.IntegrationEvent;
+using Shared.Features.CQRS.Query;
+using Shared.Kernel.BuildingBlocks.ModelValidation;
+using Shared.Kernel.BuildingBlocks;
+using Shared.Features.Server;
+
+namespace Shared.Features.CQRS.DomainEvent
+{
+    public class BaseDomainEventHandler : ServerExecutionBase
+    {
+        public IExecutionContext ExecutionContext { get; }
+        public ICommandDispatcher CommandDispatcher { get; }
+        public IQueryDispatcher QueryDispatcher { get; }
+        public IIntegrationEventDispatcher IntegrationEventDispatcher { get; }
+        public IDomainEventDispatcher DomainEventDispatcher { get; }
+        public IValidationService ValidationService { get; }
+
+        public BaseDomainEventHandler(IServiceProvider serviceProvider)
+        {
+            ExecutionContext = serviceProvider.GetRequiredService<IExecutionContext>();
+            CommandDispatcher = serviceProvider.GetRequiredService<ICommandDispatcher>();
+            QueryDispatcher = serviceProvider.GetRequiredService<IQueryDispatcher>();
+            IntegrationEventDispatcher = serviceProvider.GetRequiredService<IIntegrationEventDispatcher>();
+            DomainEventDispatcher = serviceProvider.GetRequiredService<IDomainEventDispatcher>();
+            ValidationService = serviceProvider.GetRequiredService<IValidationService>();
+        }
+    }
+}

Source/Shared/Features/CQRS/DomainEvent/IDomainEventHandler.cs

@@ -3,7 +3,7 @@
 
 namespace Shared.Features.CQRS.DomainEvent
 {
-    public interface IDomainEventHandler<in TDomainEvent> : IInServerExecutionScope where TDomainEvent : IDomainEvent
+    public interface IDomainEventHandler<in TDomainEvent> : ServerExecutionBase where TDomainEvent : IDomainEvent
     {
         Task HandleAsync(TDomainEvent query, CancellationToken cancellation);
     }

Source/Shared/Features/CQRS/IntegrationEvent/BaseIntegrationEventHandler.cs

@@ -0,0 +1,30 @@
+using Microsoft.Extensions.DependencyInjection;
+using Shared.Features.CQRS.Command;
+using Shared.Features.CQRS.DomainEvent;
+using Shared.Features.CQRS.Query;
+using Shared.Kernel.BuildingBlocks.ModelValidation;
+using Shared.Kernel.BuildingBlocks;
+using Shared.Features.Server;
+
+namespace Shared.Features.CQRS.IntegrationEvent
+{
+    public class BaseIntegrationEventHandler : ServerExecutionBase
+    {
+        public IExecutionContext ExecutionContext { get; }
+        public ICommandDispatcher CommandDispatcher { get; }
+        public IQueryDispatcher QueryDispatcher { get; }
+        public IIntegrationEventDispatcher IntegrationEventDispatcher { get; }
+        public IDomainEventDispatcher DomainEventDispatcher { get; }
+        public IValidationService ValidationService { get; }
+
+        public BaseIntegrationEventHandler(IServiceProvider serviceProvider)
+        {
+            ExecutionContext = serviceProvider.GetRequiredService<IExecutionContext>();
+            CommandDispatcher = serviceProvider.GetRequiredService<ICommandDispatcher>();
+            QueryDispatcher = serviceProvider.GetRequiredService<IQueryDispatcher>();
+            IntegrationEventDispatcher = serviceProvider.GetRequiredService<IIntegrationEventDispatcher>();
+            DomainEventDispatcher = serviceProvider.GetRequiredService<IDomainEventDispatcher>();
+            ValidationService = serviceProvider.GetRequiredService<IValidationService>();
+        }
+    }
+}

Source/Shared/Features/CQRS/IntegrationEvent/IIntegrationEventHandler.cs

@@ -3,7 +3,7 @@
 
 namespace Shared.Features.CQRS.IntegrationEvent
 {
-    public interface IIntegrationEventHandler<in TIntegrationEvent> : IInServerExecutionScope where TIntegrationEvent : IIntegrationEvent
+    public interface IIntegrationEventHandler<in TIntegrationEvent> : ServerExecutionBase where TIntegrationEvent : IIntegrationEvent
     {
         Task HandleAsync(TIntegrationEvent integrationEvent, CancellationToken cancellation);
     }

Source/Shared/Features/CQRS/Query/BaseQueryHandler.cs

@@ -1,9 +1,17 @@
-using Shared.Features.Server;
+using Microsoft.Extensions.DependencyInjection;
+using Shared.Features.CQRS.Command;
+using Shared.Features.CQRS.DomainEvent;
+using Shared.Features.CQRS.IntegrationEvent;
+using Shared.Features.Server;
+using Shared.Kernel.BuildingBlocks;
+using Shared.Kernel.BuildingBlocks.ModelValidation;
 
 namespace Shared.Features.CQRS.Query
 {
-    public class BaseQueryHandler : IInServerExecutionScope
+    public class BaseQueryHandler : ServerExecutionBase
     {
-        public IServerExecutionContext ExecutionContext { get; private set; }
+        public BaseQueryHandler(IServiceProvider serviceProvider) : base(serviceProvider)
+        {
+        }
     }
 }

Source/Shared/Features/CQRS/Query/IQueryHandler.cs

@@ -2,7 +2,7 @@
 
 namespace Shared.Features.CQRS.Query
 {
-    public interface IQueryHandler<in TQuery, TQueryResult> : IInServerExecutionScope where TQuery : IQuery<TQueryResult>
+    public interface IQueryHandler<in TQuery, TQueryResult> : ServerExecutionBase where TQuery : IQuery<TQueryResult>
     {
         Task<TQueryResult> HandleAsync(TQuery query, CancellationToken cancellation);
     }

Source/Shared/Features/Server/BaseController.cs

@@ -1,19 +1,31 @@
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.Extensions.DependencyInjection;
+using Shared.Features.CQRS.Command;
+using Shared.Features.CQRS.DomainEvent;
+using Shared.Features.CQRS.IntegrationEvent;
+using Shared.Features.CQRS.Query;
+using Shared.Kernel.BuildingBlocks;
 using Shared.Kernel.BuildingBlocks.ModelValidation;
 
 namespace Shared.Features.Server
 {
-    public class BaseController : ControllerBase, InServerExecutionScopeBase
+    public class BaseController : ControllerBase, ServerExecutionBase
     {
-        public IServerExecutionContext ExecutionContext { get; }
-
-        protected readonly IValidationService validationService;
+        public IExecutionContext ExecutionContext { get; }
+        public ICommandDispatcher CommandDispatcher { get; }
+        public IQueryDispatcher QueryDispatcher { get; }
+        public IIntegrationEventDispatcher IntegrationEventDispatcher { get; }
+        public IDomainEventDispatcher DomainEventDispatcher { get; }
+        public IValidationService ValidationService { get; }
 
         public BaseController(IServiceProvider serviceProvider)
         {
-            ExecutionContext = serviceProvider.GetRequiredService<IServerExecutionContext>();
-            validationService = serviceProvider.GetRequiredService<IValidationService>();
+            ExecutionContext = serviceProvider.GetRequiredService<IExecutionContext>();
+            CommandDispatcher = serviceProvider.GetRequiredService<ICommandDispatcher>();
+            QueryDispatcher = serviceProvider.GetRequiredService<IQueryDispatcher>();
+            IntegrationEventDispatcher = serviceProvider.GetRequiredService<IIntegrationEventDispatcher>();
+            DomainEventDispatcher = serviceProvider.GetRequiredService<IDomainEventDispatcher>();
+            ValidationService = serviceProvider.GetRequiredService<IValidationService>();
         }
     }
 }

Source/Shared/Features/Server/ExecutionContext/Registrator.cs

@@ -11,21 +11,21 @@ public static class Registrator
         public static IServiceCollection AddServerExecutionContext(this IServiceCollection services)
         {
             services.AddHttpContextAccessor();
-            services.AddScoped<ServiceExecutionContextMiddleware>();
-            services.AddScoped<IServerExecutionContext, ServerExecutionContext>(ServerExecutionContext.CreateInstance);
+            services.AddScoped<ServerExecutionContextMiddleware>();
+            services.AddScoped<IExecutionContext, ServerExecutionContext>(ServerExecutionContext.CreateInstance);
             return services;
         }
 
         public static IApplicationBuilder UseServerExecutionContextMiddleware(this IApplicationBuilder app)
         {
-            app.UseMiddleware<ServiceExecutionContextMiddleware>();
+            app.UseMiddleware<ServerExecutionContextMiddleware>();
 
             return app;
         }
     }
 
 
-    public class ServiceExecutionContextMiddleware : IMiddleware
+    public class ServerExecutionContextMiddleware : IMiddleware
     {
         public async Task InvokeAsync(HttpContext context, RequestDelegate next)
         {

Source/Shared/Features/Server/ExecutionContext/ServerExecutionContext.cs

@@ -56,10 +56,6 @@ public void InitializeInstance(HttpContext httpContext)
             TenantId = httpContext.User.GetTenantId<Guid>();
             TenantPlan = httpContext.User.GetTenantSubscriptionPlanType();
             TenantRole = httpContext.User.GetTenantRole();
-            CommandDispatcher = httpContext.RequestServices.GetRequiredService<ICommandDispatcher>();
-            QueryDispatcher = httpContext.RequestServices.GetRequiredService<IQueryDispatcher>();
-            IntegrationEventDispatcher = httpContext.RequestServices.GetRequiredService<IIntegrationEventDispatcher>();
-            DomainEventDispatcher = httpContext.RequestServices.GetRequiredService<IDomainEventDispatcher>();
         }
     }
 }