Added new command result errors

samples/EasyWay.Samples/Program.cs

@@ -39,6 +39,13 @@ await kernel
     return mapper.Map(x);
 });
 
+app.MapPost("/commandWithError", async ([FromBody] ErrorCommand command, IModuleExecutor<SampleModule> executor, IWebApiResultMapper mapper) =>
+{
+    var x = await executor.Command(command);
+
+    return mapper.Map(x);
+});
+
 app.MapPost("/command", async ([FromBody] SampleCommand command, IModuleExecutor<SampleModule> executor, IWebApiResultMapper mapper) =>
 {
     var x = await executor.Command(command);

source/EasyWay.WebApi/Internals/WebApiResultMapper.cs

@@ -1,4 +1,5 @@
 using EasyWay.Internals.Commands.CommandsWithResult;
+using EasyWay.Internals.Exceptions;
 using EasyWay.Internals.Queries.Results;
 using Microsoft.AspNetCore.Http;
 
@@ -12,6 +13,9 @@ public IResult Map(CommandResult commandResult)
             {
                 CommandErrorEnum.None => Results.Ok(),
                 CommandErrorEnum.Validation => Results.BadRequest(commandResult.ValidationErrors),
+                CommandErrorEnum.BrokenBusinessRule => Results.Conflict(new BrokenBusinessRuleExceptionResponse(commandResult.BrokenBusinessRuleException)),
+                CommandErrorEnum.NotFound => Results.StatusCode(404),
+                CommandErrorEnum.Forbidden => Results.StatusCode(403),
                 _ => Results.StatusCode(500),
             };
         }
@@ -22,6 +26,9 @@ public IResult Map<TOperationResult>(CommandResult<TOperationResult> commandResu
             {
                 CommandErrorEnum.None => Results.Ok(commandResult.OperationResult),
                 CommandErrorEnum.Validation => Results.BadRequest(commandResult.ValidationErrors),
+                CommandErrorEnum.BrokenBusinessRule => Results.Conflict(new BrokenBusinessRuleExceptionResponse(commandResult.BrokenBusinessRuleException)),
+                CommandErrorEnum.NotFound => Results.StatusCode(404),
+                CommandErrorEnum.Forbidden => Results.StatusCode(403),
                 _ => Results.StatusCode(500),
             };
         }

source/EasyWay/CommandResult.cs

@@ -1,4 +1,5 @@
-using EasyWay.Internals.Commands.CommandsWithResult;
+using EasyWay.Internals.BusinessRules;
+using EasyWay.Internals.Commands.CommandsWithResult;
 
 namespace EasyWay
 {
@@ -8,47 +9,98 @@ public sealed class CommandResult
 
         internal IDictionary<string, string[]> ValidationErrors;
 
+        internal BrokenBusinessRuleException? BrokenBusinessRuleException;
+
         private CommandResult() 
         {
             Error = CommandErrorEnum.None;
             ValidationErrors = new Dictionary<string, string[]>();
+            BrokenBusinessRuleException = null;
+        }
+
+        private CommandResult(CommandErrorEnum error)
+        {
+            Error = error;
+            ValidationErrors = new Dictionary<string, string[]>();
+            BrokenBusinessRuleException = null;
         }
 
         private CommandResult(IDictionary<string, string[]> validationErrors)
         {
             Error = CommandErrorEnum.Validation;
             ValidationErrors = validationErrors;
+            BrokenBusinessRuleException = null;
+        }
+
+        private CommandResult(BrokenBusinessRuleException brokenBusinessRuleException)
+        {
+            Error = CommandErrorEnum.BrokenBusinessRule;
+            ValidationErrors = new Dictionary<string, string[]>();
+            BrokenBusinessRuleException = brokenBusinessRuleException;
         }
 
+        internal static CommandResult BrokenBusinessRule(BrokenBusinessRuleException brokenBusinessRuleException) => new CommandResult(brokenBusinessRuleException);
+
         internal static CommandResult Validation(IDictionary<string, string[]> validationErrors) => new CommandResult(validationErrors);
 
         public static CommandResult Ok => new CommandResult();
+
+        public static CommandResult NotFound => new CommandResult(CommandErrorEnum.NotFound);
+
+        public static CommandResult Forbidden => new CommandResult(CommandErrorEnum.Forbidden);
     }
 
     public sealed class CommandResult<TOperationResult>
         where TOperationResult : OperationResult
     {
-        internal TOperationResult OperationResult { get; }
+        internal TOperationResult? OperationResult { get; }
 
         internal CommandErrorEnum Error { get; }
 
         internal IDictionary<string, string[]> ValidationErrors;
 
+        internal BrokenBusinessRuleException? BrokenBusinessRuleException;
+
         private CommandResult(TOperationResult operationResult)
         {
             OperationResult = operationResult;
             Error = CommandErrorEnum.None;
             ValidationErrors = new Dictionary<string, string[]>();
+            BrokenBusinessRuleException = null;
         }
 
         private CommandResult(IDictionary<string, string[]> validationErrors)
         {
+            OperationResult = null;
             Error = CommandErrorEnum.Validation;
             ValidationErrors = validationErrors;
+            BrokenBusinessRuleException = null;
+        }
+
+        private CommandResult(CommandErrorEnum error)
+        {
+            OperationResult = null;
+            Error = error;
+            ValidationErrors = new Dictionary<string, string[]>();
+            BrokenBusinessRuleException = null;
+        }
+
+        private CommandResult(BrokenBusinessRuleException brokenBusinessRuleException)
+        {
+            OperationResult = null;
+            Error = CommandErrorEnum.BrokenBusinessRule;
+            ValidationErrors = new Dictionary<string, string[]>();
+            BrokenBusinessRuleException = brokenBusinessRuleException;
         }
 
         internal static CommandResult<TOperationResult> Validation(IDictionary<string, string[]> validationErrors) => new CommandResult<TOperationResult>(validationErrors);
 
+        internal static CommandResult<TOperationResult> BrokenBusinessRule(BrokenBusinessRuleException brokenBusinessRuleException) => new CommandResult<TOperationResult>(brokenBusinessRuleException);
+
         public static CommandResult<TOperationResult> Ok(TOperationResult operationResult) => new CommandResult<TOperationResult>(operationResult);
+
+        public static CommandResult<TOperationResult> NotFound => new CommandResult<TOperationResult>(CommandErrorEnum.NotFound);
+
+        public static CommandResult<TOperationResult> Forbidden => new CommandResult<TOperationResult>(CommandErrorEnum.Forbidden);
     }
 }

source/EasyWay/Internals/Commands/Commands/CommandExecutor.cs

@@ -1,4 +1,5 @@
-using EasyWay.Internals.Validation;
+using EasyWay.Internals.BusinessRules;
+using EasyWay.Internals.Validation;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace EasyWay.Internals.Commands.Commands
@@ -39,9 +40,18 @@ public async Task<CommandResult> Execute<TModule, TCommand>(TCommand command, Ca
                 }
             }
 
-            var commandResult = await _serviceProvider
+            CommandResult commandResult;
+
+            try
+            {
+                commandResult = await _serviceProvider
                 .GetRequiredService<CommandHandler<TCommand>>()
                 .Handle(command);
+            }
+            catch (BrokenBusinessRuleException brokenBusinessRuleException)
+            {
+                return CommandResult.BrokenBusinessRule(brokenBusinessRuleException);
+            }
 
             await _unitOfWork.Commit();
 

source/EasyWay/Internals/Commands/CommandsWithResult/CommandErrorEnum.cs

@@ -4,7 +4,7 @@ internal enum CommandErrorEnum
     {
         None,
         Validation,
-        BusinessRule,
+        BrokenBusinessRule,
         NotFound,
         Forbidden,
     }

source/EasyWay/Internals/Commands/CommandsWithResult/CommandWithOperationResultExecutor.cs

@@ -1,4 +1,5 @@
-using EasyWay.Internals.Validation;
+using EasyWay.Internals.BusinessRules;
+using EasyWay.Internals.Validation;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace EasyWay.Internals.Commands.CommandsWithResult
@@ -42,7 +43,16 @@ public async Task<CommandResult<TOperationResult>> Command<TModule, TCommand, TO
 
             var commandHandler = _serviceProvider.GetRequiredService<CommandHandler<TCommand,TOperationResult>>();
 
-            var commandResult = await commandHandler.Handle(command);
+            CommandResult<TOperationResult> commandResult;
+
+            try
+            {
+                commandResult = await commandHandler.Handle(command);
+            }
+            catch (BrokenBusinessRuleException brokenBusinessRuleException)
+            {
+                return CommandResult<TOperationResult>.BrokenBusinessRule(brokenBusinessRuleException);
+            }
 
             await _unitOfWork.Commit();