Changed handlers from interface to class and changed dependency injection (#77)

* Moved from interfaces to abstract class for handlers and changed depejdency injection

* Changed CancellationContext from interfaces to sealed class

* Refactored code

Author: adimiko

samples/EasyWay.Samples/Commands/ErrorCommandHandler.cs

@@ -2,9 +2,9 @@
 
 namespace EasyWay.Samples.Commands
 {
-    public class ErrorCommandHandler : ICommandHandler<ErrorCommand>
+    public sealed class ErrorCommandHandler : CommandHandler<ErrorCommand>
     {
-        public Task<CommandResult> Handle(ErrorCommand command)
+        public sealed override Task<CommandResult> Handle(ErrorCommand command)
         {
             var x = new SampleAggregateRoot();
 

samples/EasyWay.Samples/Commands/SampleCommandHandler.cs

@@ -3,9 +3,9 @@
 
 namespace EasyWay.Samples.Commands
 {
-    internal sealed class SampleCommandHandler : ICommandHandler<SampleCommand>
+    internal sealed class SampleCommandHandler : CommandHandler<SampleCommand>
     {
-        private readonly ICancellationContext _cancellationContext;
+        private readonly CancellationContext _cancellationContext;
 
         private readonly ISampleAggragateRootRepository _repository;
 
@@ -20,7 +20,7 @@ internal sealed class SampleCommandHandler : ICommandHandler<SampleCommand>
         private readonly IUserContext _userContext;
 
         public SampleCommandHandler(
-            ICancellationContext cancellationContext,
+            CancellationContext cancellationContext,
             ISampleAggragateRootRepository repository,
             SampleAggregateRootFactory factory,
             SampleDomainService domainService,
@@ -37,7 +37,7 @@ public SampleCommandHandler(
             _userContext = userContext;
         }
 
-        public async Task<CommandResult> Handle(SampleCommand command)
+        public sealed override async Task<CommandResult> Handle(SampleCommand command)
         {
             var userId = _userContext.UserId;
 

samples/EasyWay.Samples/Commands/WithResult/SampleCommandWithResultHandler.cs

@@ -1,9 +1,9 @@
 
 namespace EasyWay.Samples.Commands.WithResult
 {
-    public sealed class SampleCommandWithResultHandler : ICommandHandler<SampleCommandWithResult, SampleCommandResult>
+    public sealed class SampleCommandWithResultHandler : CommandHandler<SampleCommandWithResult, SampleCommandResult>
     {
-        public Task<CommandResult<SampleCommandResult>> Handle(SampleCommandWithResult command)
+        public sealed override Task<CommandResult<SampleCommandResult>> Handle(SampleCommandWithResult command)
         {
             return Task.FromResult(CommandResult<SampleCommandResult>.Ok(new SampleCommandResult()));
         }

samples/EasyWay.Samples/Events/SampleEventHandler1.cs

@@ -2,9 +2,9 @@
 
 namespace EasyWay.Samples.Events
 {
-    public class SampleEventHandler1 : IDomainEventHandler<CreatedSampleAggragete>
+    public sealed class SampleEventHandler1 : DomainEventHandler<CreatedSampleAggragete>
     {
-        public Task Handle(CreatedSampleAggragete @event)
+        public sealed override Task Handle(CreatedSampleAggragete domainEvent)
         {
             return Task.CompletedTask;
         }

samples/EasyWay.Samples/Events/SampleEventHandler2.cs

@@ -2,9 +2,9 @@
 
 namespace EasyWay.Samples.Events
 {
-    public class SampleEventHandler2 : IDomainEventHandler<CreatedSampleAggragete>
+    public sealed class SampleEventHandler2 : DomainEventHandler<CreatedSampleAggragete>
     {
-        public Task Handle(CreatedSampleAggragete @event)
+        public sealed override Task Handle(CreatedSampleAggragete domainEvent)
         {
             return Task.CompletedTask;
         }

samples/EasyWay.Samples/Program.cs

@@ -1,6 +1,7 @@
 using EasyWay.Samples;
 using EasyWay.Samples.Commands;
 using EasyWay.Samples.Commands.WithResult;
+using EasyWay.Samples.Domain.Policies;
 using EasyWay.Samples.Queries;
 using Microsoft.AspNetCore.Mvc;
 
@@ -40,7 +41,9 @@ await kernel
 
 app.MapPost("/command", async ([FromBody] SampleCommand command, IModuleExecutor<SampleModule> executor, IWebApiResultMapper mapper) =>
 {
-    return  await executor.Command(command);
+    var x = await executor.Command(command);
+
+    return mapper.Map(x);
 });
 
 app.MapPost("/commandwithresult", async ([FromBody] SampleCommandWithResult command, IModuleExecutor<SampleModule> executor, IWebApiResultMapper mapper) =>

samples/EasyWay.Samples/Queries/SampleQueryHandler.cs

@@ -1,11 +1,9 @@
 namespace EasyWay.Samples.Queries
 {
-    public class SampleQueryHandler : IQueryHandler<SampleQuery, SampleQueryResult>
+    internal sealed class SampleQueryHandler : QueryHandler<SampleQuery, SampleQueryResult>
     {
-        public Task<QueryResult<SampleQueryResult>> Handle(SampleQuery query)
+        public sealed override Task<QueryResult<SampleQueryResult>> Handle(SampleQuery query)
         {
-            //return Task.FromResult(QueryResult<SampleQueryResult>.Forbidden);
-
             return Task.FromResult(QueryResult<SampleQueryResult>.Ok(new SampleQueryResult()));
         }
     }

source/EasyWay/CancellationContext.cs

@@ -0,0 +1,9 @@
+namespace EasyWay
+{
+    public sealed class CancellationContext
+    {
+        public CancellationToken Token { get; private set; }
+
+        internal void Set(CancellationToken token) => Token = token;
+    }
+}

source/EasyWay/ICommandHandler.cs source/EasyWay/CommandHandler.cssource/EasyWay/ICommandHandler.cs renamed to source/EasyWay/CommandHandler.cs

@@ -4,20 +4,20 @@
     /// Defines a handler for a command
     /// </summary>
     /// <typeparam name="TCommand">The type of command being handled</typeparam>
-    public interface ICommandHandler<TCommand>
+    public abstract class CommandHandler<TCommand>
         where TCommand : Command
     {
         /// <summary>
         /// Handles a command
         /// </summary>
         /// <param name="command">Command</param>
-        Task<CommandResult> Handle(TCommand command);
+        public abstract Task<CommandResult> Handle(TCommand command);
     }
 
-    public interface ICommandHandler<TCommand, TOperationResult>
+    public abstract class CommandHandler<TCommand, TOperationResult>
         where TCommand : Command<TOperationResult>
         where TOperationResult : OperationResult
     {
-        Task<CommandResult<TOperationResult>> Handle(TCommand command);
+        public abstract Task<CommandResult<TOperationResult>> Handle(TCommand command);
     }
 }

source/EasyWay/IDomainEventHandler.cs source/EasyWay/DomainEventHandler.cssource/EasyWay/IDomainEventHandler.cs renamed to source/EasyWay/DomainEventHandler.cs

@@ -4,13 +4,13 @@
     /// Defines a handler for an event
     /// </summary>
     /// <typeparam name="TDomainEvent">The type of event being handled</typeparam>
-    public interface IDomainEventHandler<TDomainEvent>
+    public abstract class DomainEventHandler<TDomainEvent>
         where TDomainEvent : DomainEvent
     {
         /// <summary>
         /// Handles an event
         /// </summary>
         /// <param name="domainEvent">Event</param>
-        Task Handle(TDomainEvent domainEvent);
+        public abstract Task Handle(TDomainEvent domainEvent);
     }
 }