Welcome to CleanArchitecture Discussions!

[cbcrouse]

👋 Welcome!

We’re using Discussions as a place to connect with other members of our community. We hope that you:

• Ask questions you’re wondering about.
• Share ideas.
• Engage with other community members.
• Welcome others and are open-minded. Remember that this is a community we
  build together 💪.

To get started, comment below with an introduction of yourself and tell us about what you do with this community.

[DoubleDP]

I have started using this template and like the clean architecture and code. I am a newbie and this seems very advanced, but think this is
the best way for me to learn how to do things properly.

I am using this for an Azure Function App that will act as an API. I have a problem in terms of the validations where validation throws an exception, can't see to figure out how to return the validations to the function and keeping the "controller" thin.

Is this project still actively maintained?

[cbcrouse]

Hi @DoubleDP, I'm glad you found the template useful. It is a bit advanced, but nothing you can't tackle.

I'm not sure that I fully understand your question, are you referring to how the controllers in the API utilize the IMediator service to send requests to the application?

Yes, the project is actively maintained.

[DoubleDP]

Hi @cbcrouse, I am glad to hear that this is still maintained. I will try to explain this a bit better, by showing you the code that have for the creation of an entity.

Azure function

    public class CreateBroker
    {
        private readonly IMapper _mapper;
        private readonly IMediator _mediator;

        /// <summary>
        /// Default Constructor
        /// </summary>
        /// <param name="mapper">An abstraction for mapping one object to another.</param>
        /// <param name="mediator">An abstraction for accessing the application layer.</param>
        public CreateBroker(IMapper mapper, IMediator mediator)
        {
            _mapper = mapper;
            _mediator = mediator;
        }

        [FunctionName("CreateBroker")]
        [OpenApiOperation(operationId: "CreateBroker", tags: new[] { "Brokers" })]
        [OpenApiSecurity("function_key", SecuritySchemeType.ApiKey, Name = "code", In = OpenApiSecurityLocationType.Query)]
        [OpenApiRequestBody(contentType: "application/json", bodyType: typeof(CreateBrokerRequest), Required = true)]
        [OpenApiResponseWithoutBody(statusCode: HttpStatusCode.Created, Description = "Broker successfull created response")]
        [OpenApiResponseWithBody(statusCode: HttpStatusCode.BadRequest, contentType: "application/json", bodyType: typeof(ErrorResponse), Description = "The request is not valid, please see response for explanation")]
        public async Task<IActionResult> Run(
            [HttpTrigger(AuthorizationLevel.Function, "post", Route = "brokers")] HttpRequest req,
            ILogger log)
        {
            log.LogInformation("C# HTTP trigger function processed a request.");

            string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
            CreateBrokerRequest data = JsonConvert.DeserializeObject<CreateBrokerRequest>(requestBody);

            var command = _mapper.Map<CreateBrokerCommand>(data);
            var result = await _mediator.Send(command, CancellationToken.None);
            var location = Path.Join($"{req.Scheme}://{req.Host}", req.Path, result.ToString());
            var locationUri = new Uri(location);
                
            return new CreatedResult(locationUri, result.ToString());
        }

Command

    /// <summary>
    /// The <see cref="IRequest"/> object used to create a <see cref="Domain.Entities.Broker"/>.
    /// </summary>
    public class CreateBrokerCommand : IRequest<Guid>
    {
        /// <summary>
        /// Gets or sets the name of the broker.
        /// </summary>
        public string Name { get; set; }
    }

Handler

    /// <summary>
    /// The <see cref="IRequestHandler{T}"/> responsible for creating a <see cref="Domain.Entities.Broker"/>.
    /// </summary>
    public class CreateBrokerHandler : IRequestHandler<CreateBrokerCommand, Guid>
    {
        private readonly IBrokerCommandDataAccess _commands;
        private readonly IMapper _mapper;

        /// <summary>
        /// Default constructor.
        /// </summary>
        /// <param name="commands">An abstraction for running task commands.</param>
        /// <param name="mapper">An abstraction for mapping on object to another.</param>
        public CreateBrokerHandler(IBrokerCommandDataAccess commands, IMapper mapper)
        {
            _commands = commands;
            _mapper = mapper;
        }

        /// <summary>
        /// Handles the request to create a <see cref="Domain.Entities.Broker"/>
        /// </summary>
        /// <param name="request">The <see cref="IRequest"/> object used to create a <see cref="Domain.Entities.Broker"/>.</param>
        /// <param name="cancellationToken">Propagates notification that operations should be cancelled.</param>
        /// <returns></returns>
        public async Task<Guid> Handle(CreateBrokerCommand request, CancellationToken cancellationToken)
        {
            var entity = _mapper.Map<Domain.Entities.Broker>(request);
            await _commands.Create(entity, cancellationToken);
            return entity.Id;
        }
    }

Validator

    /// <summary>
    /// Creates the business rules for the <see cref="CreateBrokerCommand"/>.
    /// </summary>
    public class CreateBrokerCommandValidator : AbstractValidator<CreateBrokerCommand>
    {
        /// <summary>
        /// Default contstructor
        /// </summary>
        public CreateBrokerCommandValidator()
        {
            RuleFor(b => b.Name)
                .NotEmpty()
                .MinimumLength(3)
                .MaximumLength(50);
        }
    }

Running this code, results in an exception being thrown from the RequestValidationBehaviour class as per below:

I have tried catching the exception from within the handler, but that doesn't seem to work.

What I would like to happen, is for the validation errors to be returned to the calling Azure function, so that it in turn returns the errors as a BadRequestObjectResult object

[cbcrouse]

Hey @DoubleDP - thanks for the descriptive explanation. I understand what you would like to do. I do not believe that Azure Functions support middleware in dotnet core 3.1 and below, but here's an article on how to do it with .NET 5. I still need to update this template to .NET 5 and will work on this soon - it's not super difficult. For now, if you are not able to use middleware, I recommend writing an exception handler or simply putting a try/catch in the Azure Function itself around the initial mediator request block. Let me know if this makes sense or not.

[DoubleDP]

Hey @cbcrouse,

I fully understand about the middleware route not being available within Azure Functions. I've tried the try-catch route, but it doesn't seem to work. I've added a try-catch to the Azure Function, as well as the Handler method, but it's still throwing the exception within RequestValidatorBehaviour class even though I am trying the handle the exception upstream in the stack.

It appears to hit the validator logic before it executes the handler logic based on the breakpoints I have set.

FYI - It appears to behave in the same manner on the Presentation.API project.

Any ideas?

[cbcrouse]

Hey @DoubleDP - The flow for Mediator is: Mediator.Send(request) -> Validator -> MediatorMiddleware/Behaviors -> Handler
What you mentioned about hitting the RequestValidationBehavior before hitting the handler, that is expected.

Here is an example of me adding a try-catch to the console application, sending the mediator request, and modifying the handler to throw a simple exception: