serverExecutionBase

Source/Modules/Subscriptions/Features/DomainFeatures/StripeSubscriptionAggregate/Application/Commands/CreateTrialingSubscriptionForTenant.cs

@@ -5,6 +5,7 @@
 using Modules.Subscriptions.IntegrationEvents;
 using Shared.Features.CQRS.Command;
 using Shared.Features.CQRS.IntegrationEvent;
+using Shared.Features.Server;
 using Stripe;
 
 namespace Modules.Subscriptions.Features.DomainFeatures.StripeSubscriptionAggregate.Application.Commands
@@ -17,7 +18,7 @@ public class CreateTrialingSubscriptionForTenant : ICommand
         public Stripe.Subscription CreatedStripeSubscription { get; set; }
     }
 
-    public class CreateTrialingSubscriptionCommandHandler : ICommandHandler<CreateTrialingSubscriptionForTenant>
+    public class CreateTrialingSubscriptionCommandHandler : ServerExecutionBase, ICommandHandler<CreateTrialingSubscriptionForTenant>
     {
         private readonly SubscriptionsDbContext subscriptionDbContext;
         private readonly SubscriptionsConfiguration subscriptionConfiguration;
@@ -26,11 +27,10 @@ public class CreateTrialingSubscriptionCommandHandler : ICommandHandler<CreateTr
         public CreateTrialingSubscriptionCommandHandler(
             SubscriptionsDbContext subscriptionDbContext,
             SubscriptionsConfiguration subscriptionConfiguration,
-            IIntegrationEventDispatcher integrationEventDispatcher)
+            IServiceProvider serviceProvider): base(serviceProvider)
         {
             this.subscriptionDbContext = subscriptionDbContext;
             this.subscriptionConfiguration = subscriptionConfiguration;
-            this.integrationEventDispatcher = integrationEventDispatcher;
         }
 
         public async Task HandleAsync(CreateTrialingSubscriptionForTenant command, CancellationToken cancellationToken)

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

@@ -22,11 +22,11 @@ public async Task<ActionResult> RedirectToStripePremiumSubscription([FromRoute]
             var createStripeCheckoutSession = new CreateStripeCheckoutSession 
             { 
                 SubscriptionPlanType = subscriptionPlanType,
-                UserId = ExecutionContext.UserId,
-                TenantId = ExecutionContext.TenantId,
-                RedirectBaseUrl = ExecutionContext.BaseURI.AbsoluteUri
+                UserId = executionContext.UserId,
+                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);
@@ -38,10 +38,10 @@ public async Task<ActionResult> Create()
         {
             var createBillingPortalSession = new CreateStripeBillingPortalSession
             {
-                UserId = ExecutionContext.UserId,
-                RedirectBaseUrl = ExecutionContext.BaseURI.AbsoluteUri,
+                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/Features/DomainFeatures/TenantAggregate/Application/Commands/RemoveUserFromTenant.cs

@@ -14,7 +14,6 @@ public class RemoveUserFromTenant : ICommand
     public class RemoveUserFromTenantommandHandler : ICommandHandler<RemoveUserFromTenant>
     {
         private readonly TenantIdentityDbContext tenantIdentityDbContext;
-        private readonly IExecutionContext executionContext;
 
         public RemoveUserFromTenantommandHandler(TenantIdentityDbContext tenantIdentityDbContext)
         {

Source/Modules/TenantIdentity/Features/DomainFeatures/UserAggregate/Application/Queries/GetClaimsForUser.cs

@@ -1,5 +1,6 @@
 using Modules.TenantIdentity.Features.Infrastructure.EFCore;
 using Shared.Features.CQRS.Query;
+using Shared.Features.Server;
 using Shared.Kernel.BuildingBlocks.Auth.Constants;
 using System.Security.Claims;
 using System.Threading;
@@ -11,14 +12,12 @@ public class GetClaimsForUser : IQuery<IEnumerable<Claim>>
         public Guid UserId { get; set; }
     }
 
-    public class ClaimsForUserQueryHandler : IQueryHandler<GetClaimsForUser, IEnumerable<Claim>>
+    public class ClaimsForUserQueryHandler : ServerExecutionBase, IQueryHandler<GetClaimsForUser, IEnumerable<Claim>>
     {
-        private readonly IQueryDispatcher queryDispatcher;
         private readonly TenantIdentityDbContext tenantIdentityDbContext;
 
-        public ClaimsForUserQueryHandler(IQueryDispatcher queryDispatcher, TenantIdentityDbContext tenantIdentityDbContext)
+        public ClaimsForUserQueryHandler(TenantIdentityDbContext tenantIdentityDbContext, IServiceProvider serviceProvider) : base(serviceProvider)
         {
-            this.queryDispatcher = queryDispatcher;
             this.tenantIdentityDbContext = tenantIdentityDbContext;
         }
         public async Task<IEnumerable<Claim>> HandleAsync(GetClaimsForUser query, CancellationToken cancellation)

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

@@ -31,17 +31,17 @@ public TenantsController(SignInManager<ApplicationUser> signInManager, IServiceP
         [AuthorizeTenantAdmin]
         public async Task<ActionResult<TenantDTO>> GetTenant()
         {
-            var tenantId = ExecutionContext.TenantId;
-            TenantDTO tenant = await QueryDispatcher.DispatchAsync<GetTenantByID, TenantDTO>(new GetTenantByID { TenantId = tenantId });
+            var tenantId = executionContext.TenantId;
+            TenantDTO tenant = await queryDispatcher.DispatchAsync<GetTenantByID, TenantDTO>(new GetTenantByID { TenantId = tenantId });
 
             return Ok(tenant);
         }
 
         [HttpGet("{tenantId}/details")]
         public async Task<ActionResult<TenantDetailDTO>> GetTenantDetail()
         {
-            var tenantId = ExecutionContext.TenantId;
-            TenantDetailDTO tenantDetail = await QueryDispatcher.DispatchAsync<GetTenantDetailsByID, TenantDetailDTO>(new GetTenantDetailsByID { TenantId = tenantId });
+            var tenantId = executionContext.TenantId;
+            TenantDetailDTO tenantDetail = await queryDispatcher.DispatchAsync<GetTenantDetailsByID, TenantDetailDTO>(new GetTenantDetailsByID { TenantId = tenantId });
 
             return Ok(tenantDetail);
         }
@@ -50,25 +50,25 @@ public async Task<ActionResult<TenantDetailDTO>> GetTenantDetail()
         [Authorize(AuthenticationSchemes = AuthConstant.ApplicationAuthenticationScheme)]
         public async Task<ActionResult<IEnumerable<TenantDTO>>> GetAllTenantsWhereUserIsMember()
         {
-            var userId = ExecutionContext.UserId;
-            List<TenantMembershipDTO> teamMemberships = await QueryDispatcher.DispatchAsync<GetAllTenantMembershipsOfUser, List<TenantMembershipDTO>>(null);
+            var userId = executionContext.UserId;
+            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,
+                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,36 +77,36 @@ 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 userId = executionContext.UserId;
+            var user = await queryDispatcher.DispatchAsync<GetUserById, ApplicationUser>(new GetUserById { });
 
             await signInManager.RefreshSignInAsync(user);
         }
 
         [HttpPost("memberships")]
         public async Task<ActionResult> CreateTenantMembership(InviteUserToTenantDTO inviteUserToGroupDTO)
         {
-            var userId = ExecutionContext.UserId;
+            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/ICommandHandler.cs

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

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

@@ -1,9 +1,8 @@
 using Shared.Features.Domain;
-using Shared.Features.Server;
 
 namespace Shared.Features.CQRS.DomainEvent
 {
-    public interface IDomainEventHandler<in TDomainEvent> : ServerExecutionBase where TDomainEvent : IDomainEvent
+    public interface IDomainEventHandler<in TDomainEvent> where TDomainEvent : IDomainEvent
     {
         Task HandleAsync(TDomainEvent query, CancellationToken cancellation);
     }

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

@@ -1,9 +1,8 @@
-using Shared.Features.Server;
-using Shared.Kernel.BuildingBlocks;
+using Shared.Kernel.BuildingBlocks;
 
 namespace Shared.Features.CQRS.IntegrationEvent
 {
-    public interface IIntegrationEventHandler<in TIntegrationEvent> : ServerExecutionBase where TIntegrationEvent : IIntegrationEvent
+    public interface IIntegrationEventHandler<in TIntegrationEvent> where TIntegrationEvent : IIntegrationEvent
     {
         Task HandleAsync(TIntegrationEvent integrationEvent, CancellationToken cancellation);
     }

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

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

Source/Shared/Features/Server/BaseController.cs

@@ -9,23 +9,23 @@
 
 namespace Shared.Features.Server
 {
-    public class BaseController : ControllerBase, ServerExecutionBase
+    public class BaseController : ControllerBase
     {
-        public IExecutionContext ExecutionContext { get; }
-        public ICommandDispatcher CommandDispatcher { get; }
-        public IQueryDispatcher QueryDispatcher { get; }
-        public IIntegrationEventDispatcher IntegrationEventDispatcher { get; }
-        public IDomainEventDispatcher DomainEventDispatcher { get; }
-        public IValidationService ValidationService { get; }
+        protected readonly IExecutionContext executionContext;
+        protected readonly ICommandDispatcher commandDispatcher;
+        protected readonly IQueryDispatcher queryDispatcher;
+        protected readonly IIntegrationEventDispatcher integrationEventDispatcher;
+        protected readonly IDomainEventDispatcher domainEventDispatcher;
+        protected readonly IValidationService validationService;
 
         public BaseController(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>();
+            executionContext = serviceProvider.GetRequiredService<IExecutionContext>();
+            commandDispatcher = serviceProvider.GetRequiredService<ICommandDispatcher>();
+            queryDispatcher = serviceProvider.GetRequiredService<IQueryDispatcher>();
+            integrationEventDispatcher = serviceProvider.GetRequiredService<IIntegrationEventDispatcher>();
+            domainEventDispatcher = serviceProvider.GetRequiredService<IDomainEventDispatcher>();
+            validationService = serviceProvider.GetRequiredService<IValidationService>();
         }
     }
 }