vegasco/src/Vegasco.Server.Api/Consumptions/UpdateConsumption.cs

using FluentValidation;
using FluentValidation.Results;
using Vegasco.Server.Api.Common;
using Vegasco.Server.Api.Persistence;

namespace Vegasco.Server.Api.Consumptions;

public static class UpdateConsumption
{
	public record Request(DateTimeOffset DateTime, double Distance, double Amount);

	public record Response(Guid Id, DateTimeOffset DateTime, double Distance, double Amount, Guid CarId);

	public static RouteHandlerBuilder MapEndpoint(IEndpointRouteBuilder builder)
	{
		return builder
			.MapPut("consumptions/{id:guid}", Endpoint)
			.WithTags("Consumptions")
			.WithDescription("Updates a consumption entry by ID")
			.Produces<Response>()
			.ProducesValidationProblem()
			.Produces(404);
	}

	public class Validator : AbstractValidator<Request>
	{
		public Validator(TimeProvider timeProvider)
		{
			DateTime todayEndOfDay = timeProvider.GetUtcNow()
				.Date
				.AddDays(1)
				.AddTicks(-1);

			RuleFor(x => x.DateTime.ToUniversalTime())
				.LessThanOrEqualTo(todayEndOfDay)
				.WithName(nameof(Request.DateTime));

			RuleFor(x => x.Distance)
				.GreaterThan(0);

			RuleFor(x => x.Amount)
				.GreaterThan(0);
		}
	}

	private static async Task<IResult> Endpoint(
		ApplicationDbContext dbContext,
		Guid id,
		Request request,
		IEnumerable<IValidator<Request>> validators,
		ILoggerFactory loggerFactory,
		CancellationToken cancellationToken)
	{
		ILogger logger = loggerFactory.CreateLogger(nameof(UpdateConsumption));
		
		List<ValidationResult> failedValidations = await validators.ValidateAllAsync(request, cancellationToken);
		if (failedValidations.Count > 0)
		{
			logger.LogDebug(
				"Validation failed for request {@Request} with errors {@Errors}",
				request,
				failedValidations
					.Where(x => !x.IsValid)
					.SelectMany(x => x.Errors)
					.Select(x => x.ErrorMessage));

			return TypedResults.BadRequest(new HttpValidationProblemDetails(failedValidations.ToCombinedDictionary()));
		}

		Consumption? consumption = await dbContext.Consumptions.FindAsync([new ConsumptionId(id)], cancellationToken);
		if (consumption is null)
		{
			return TypedResults.NotFound();
		}

		consumption.DateTime = request.DateTime.ToUniversalTime();
		consumption.Distance = request.Distance;
		consumption.Amount = request.Amount;

		await dbContext.SaveChangesAsync(cancellationToken);

		logger.LogTrace("Updated consumption: {@Consumption}", consumption);

		return TypedResults.Ok(new Response(consumption.Id.Value, consumption.DateTime, consumption.Distance, consumption.Amount, consumption.CarId.Value));
	}
}