Created ResultOrientedCommandHandlerDecorator.cs for structured command execution and error handling.

Author: imhmdi

TodoSample/Core/Application.Contracts/Honamic.Todo.Application.Contracts.csproj

@@ -10,6 +10,8 @@
 
 	<ItemGroup>
 
+		<ProjectReference Include="..\..\..\src\Core\Applications.Abstractions\Honamic.Framework.Applications.Abstractions.csproj" />
+
 		<ProjectReference Include="..\..\..\src\Core\Commands.Abstractions\Honamic.Framework.Commands.Abstractions.csproj" />
 	</ItemGroup>
 

TodoSample/Core/Application.Contracts/TodoItems/Commands/CreateTodoItemCommand.cs

@@ -1,5 +1,19 @@
 
+using Honamic.Framework.Applications.Results;
 using Honamic.Framework.Commands;
 
 namespace Honamic.Todo.Application.TodoItems.Commands;
 public record CreateTodoItemCommand(string title, string content, List<string> tags) : ICommand;
+
+
+
+
+public record CreateTodoItem2Command(string title, string content, List<string> tags)
+    : ICommand<Result<CreateTodoItem2ResultCommand>>;
+
+
+
+public class CreateTodoItem2ResultCommand
+{
+    public long Id { get; set; }
+}

TodoSample/Core/Application/Extensions/ApplicationServiceCollectionExtensions.cs

@@ -7,6 +7,7 @@
 using Honamic.Framework.Tools.IdGenerators;
 using Honamic.Todo.Application.TodoItems.EventHandlers;
 using Honamic.IdentityPlus.Domain.Users;
+using Honamic.Framework.Applications.Results;
 
 namespace Honamic.Todo.Application.Extensions;
 
@@ -25,6 +26,11 @@ private static void AddCommandHandlers(this IServiceCollection services)
     {
         services.AddCommandHandler<DeleteTodoItemCommand, DeleteTodoItemCommandHandler>();
         services.AddCommandHandler<CreateTodoItemCommand, CreateTodoItemCommandHandler>();
+        services.AddCommandHandler<
+            CreateTodoItem2Command,
+            CreateTodoItem2CommandHandler,
+            Result<CreateTodoItem2ResultCommand>>();
+
         services.AddCommandHandler<MakeCompletedTodoItemCommand, MakeCompletedTodoItemCommandHandler>();
     }
 

TodoSample/Core/Application/TodoItems/CommandHandlers/CreateTodoItem2CommandHandler.cs

@@ -0,0 +1,33 @@
+using Honamic.Framework.Applications.Results;
+using Honamic.Framework.Commands;
+using Honamic.Framework.Domain;
+using Honamic.Todo.Application.TodoItems.Commands;
+using Honamic.Todo.Domain.TodoItems;
+
+namespace Honamic.Todo.Application.TodoItems.CommandHandlers;
+internal class CreateTodoItem2CommandHandler :
+    ICommandHandler<CreateTodoItem2Command, Result<CreateTodoItem2ResultCommand>>
+{
+    private readonly ITodoItemRepository _todoItemRepository;
+    private readonly IIdGenerator _idGenerator;
+
+    public CreateTodoItem2CommandHandler(ITodoItemRepository todoItemRepository, IIdGenerator idGenerator)
+    {
+        _todoItemRepository = todoItemRepository;
+        _idGenerator = idGenerator;
+    }
+
+    public async Task<Result<CreateTodoItem2ResultCommand>> HandleAsync(CreateTodoItem2Command command, CancellationToken cancellationToken)
+    {
+        var todoItem = new TodoItem(_idGenerator.GetNewId(), command.title, command.content, command.tags);
+        await _todoItemRepository.InsertAsync(todoItem);
+
+        var result = new CreateTodoItem2ResultCommand
+        {
+            Id = todoItem.Id
+        };
+
+        return result;
+    }
+
+}

TodoSample/Endpoints/WebApi/Honamic.Todo.Endpoints.WebApi/TodoItems/TodoItems2Controller.cs

@@ -0,0 +1,30 @@
+using Honamic.Framework.Applications.Results;
+using Honamic.Framework.Commands;
+using Honamic.Todo.Application.TodoItems.Commands;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Honamic.Todo.Endpoints.WebApi.Controllers;
+
+[Route("api/[controller]")]
+[ApiController]
+public class TodoItems2Controller : ControllerBase
+{
+    private readonly ILogger<TodoItemsController> _logger;
+    private readonly ICommandBus _commandBus;
+
+    public TodoItems2Controller(ILogger<TodoItemsController> logger, ICommandBus commandBus)
+    {
+        _logger = logger;
+        _commandBus = commandBus;
+    }
+
+    [HttpPost]
+    public async Task<Result<CreateTodoItem2ResultCommand>> Post([FromBody] CreateTodoItem2Command model, CancellationToken cancellationToken)
+    {
+        return await _commandBus
+            .DispatchAsync<CreateTodoItem2Command, Result<CreateTodoItem2ResultCommand>>
+            (model, cancellationToken);
+    }
+
+
+}

TodoSample/Endpoints/WebApi/Honamic.Todo.Endpoints.WebApi/TodoItems/TodoItemsController.cs

@@ -37,6 +37,12 @@ public Task<Result<TodoItemQuery>> Get(long id, CancellationToken cancellationTo
 
     }
 
+    [HttpPost("Create")]
+    public Task<Result<long>> Create([FromBody] CreateTodoItemCommand model, CancellationToken cancellationToken)
+    {
+        return _todoItemFacade.Create(model, cancellationToken);
+    }
+
     [HttpPost]
     public Task<Result<long>> Post([FromBody] CreateTodoItemCommand model, CancellationToken cancellationToken)
     {

src/Facade/Abstractions/Exceptions/UnauthenticatedException.cs renamed to src/Core/Applications.Abstractions/Exceptions/UnauthenticatedException.cs

@@ -1,4 +1,4 @@
-namespace Honamic.Framework.Facade.Exceptions;
+namespace Honamic.Framework.Applications.Exceptions;
 
 public class UnauthenticatedException : Exception
 {

src/Facade/Abstractions/Exceptions/UnauthorizedException.cs renamed to src/Core/Applications.Abstractions/Exceptions/UnauthorizedException.cs

@@ -1,4 +1,4 @@
-namespace Honamic.Framework.Facade.Exceptions;
+namespace Honamic.Framework.Applications.Exceptions;
 
 public class UnauthorizedException : Exception
 {

src/Core/Applications/CommandHandlerDecorators/ResultOrientedCommandHandlerDecorator.cs

@@ -0,0 +1,107 @@
+using Honamic.Framework.Applications.Exceptions;
+using Honamic.Framework.Applications.Results;
+using Honamic.Framework.Commands;
+using Honamic.Framework.Domain;
+
+namespace Honamic.Framework.Applications.CommandHandlerDecorators;
+
+public class ResultOrientedCommandHandlerDecorator<TCommand, TResponse> : ICommandHandler<TCommand, TResponse>
+    where TCommand : ICommand<TResponse>
+{
+    private readonly ICommandHandler<TCommand, TResponse> _commandHandler;
+
+    public ResultOrientedCommandHandlerDecorator(ICommandHandler<TCommand, TResponse> commandHandler)
+    {
+        _commandHandler = commandHandler;
+    }
+
+    public async Task<TResponse> HandleAsync(TCommand command, CancellationToken cancellationToken)
+    {
+        TResponse result;
+        try
+        {
+            result = await _commandHandler.HandleAsync(command, cancellationToken);
+        }
+        catch (Exception ex)
+        {
+            if (IsResultOriented(typeof(TResponse)))
+            {
+                result = CreateResultWithError(typeof(TResponse), ex);
+                return result;
+            }
+
+            throw;
+        }
+
+        return result;
+    }
+
+    private TResponse CreateResultWithError(Type type, Exception ex)
+    {
+        var resultObject = CreateResult(type);
+
+        if (resultObject is Result result)
+        {
+            switch (ex)
+            {
+                case UnauthenticatedException:
+                    result.SetStatusAsUnauthenticated();
+                    result.AppendError(ex.Message);
+                    break;
+                case UnauthorizedException:
+                    result.SetStatusAsUnauthorized();
+                    result.AppendError(ex.Message);
+                    break;
+                case BusinessException businessException:
+                    result.Status = ResultStatus.ValidationError;
+                    var code = businessException.GetCode();
+                    var message = businessException.GetMessage();
+                    result.AppendError(message, null, code);
+                    break;
+                default:
+                    result.SetStatusAsUnhandledExceptionWithSorryError();
+                    result.AppendError(ex.ToString(), "Exception");
+                    break;
+            }
+            return resultObject;
+        }
+
+        // If we can't cast to Result, we have a serious error
+        throw new ArgumentException($"Expected a Result type but got {type.FullName}");
+    }
+
+    private TResponse CreateResult(Type type)
+    {
+        // For non-generic Result
+        if (type == typeof(Result))
+        {
+            return (TResponse)(object)new Result();
+        }
+
+        // For Result<T>
+        if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Result<>))
+        {
+            var genericArgType = type.GenericTypeArguments[0];
+            var resultType = typeof(Result<>).MakeGenericType(genericArgType);
+            return (TResponse)Activator.CreateInstance(resultType);
+        }
+
+        return default;
+    }
+
+    private bool IsResultOriented(Type type)
+    {
+        if (type == typeof(Result))
+        {
+            return true;
+        }
+
+        if (type.IsGenericType
+            && type.GetGenericTypeDefinition() == typeof(Result<>))
+        {
+            return true;
+        }
+
+        return false;
+    }
+}

src/Core/Applications/Extensions/ServiceCollectionExtensions.cs

@@ -27,6 +27,7 @@ public static void AddCommandHandler<TCommand, TCommandHandler>(this IServiceCol
     {
         services.AddTransient<ICommandHandler<TCommand>, TCommandHandler>();
         services.Decorate<ICommandHandler<TCommand>, TransactionalCommandHandlerDecorator<TCommand>>();
+        // Note: No ResultOriented decorator for non-response commands
     }
 
     public static void AddCommandHandler<TCommand, TCommandHandler, TResponse>(this IServiceCollection services)
@@ -35,6 +36,7 @@ public static void AddCommandHandler<TCommand, TCommandHandler, TResponse>(this
     {
         services.AddTransient<ICommandHandler<TCommand, TResponse>, TCommandHandler>();
         services.Decorate<ICommandHandler<TCommand, TResponse>, TransactionalCommandHandlerDecorator<TCommand, TResponse>>();
+        services.Decorate<ICommandHandler<TCommand, TResponse>, ResultOrientedCommandHandlerDecorator<TCommand, TResponse>>();
     }
 
     public static void AddEventHandler<TEvent, TEventHandler>(this IServiceCollection services)