Rename WebApi project to Vegasco.Server.Api

And update all references including comments etc.

src/Vegasco.Server.Api/Assembly.cs

@@ -0,0 +1,3 @@
+using StronglyTypedIds;
+
+[assembly: StronglyTypedIdDefaults(Template.Guid, "guid-efcore")]

src/Vegasco.Server.Api/Authentication/JwtOptions.cs

@@ -0,0 +1,28 @@
+using FluentValidation;
+
+namespace Vegasco.Server.Api.Authentication;
+
+public class JwtOptions
+{
+	public const string SectionName = "JWT";
+
+	public string ValidAudience { get; set; } = "";
+
+	public string MetadataUrl { get; set; } = "";
+
+	public string? NameClaimType { get; set; }
+
+	public bool AllowHttpMetadataUrl { get; set; }
+}
+
+public class JwtOptionsValidator : AbstractValidator<JwtOptions>
+{
+	public JwtOptionsValidator()
+	{
+		RuleFor(x => x.ValidAudience)
+			.NotEmpty();
+
+		RuleFor(x => x.MetadataUrl)
+			.NotEmpty();
+	}
+}

src/Vegasco.Server.Api/Authentication/UserAccessor.cs

@@ -0,0 +1,78 @@
+using Microsoft.Extensions.Options;
+using System.Diagnostics.CodeAnalysis;
+using System.Security.Claims;
+
+namespace Vegasco.Server.Api.Authentication;
+
+public sealed class UserAccessor
+{
+	private readonly IHttpContextAccessor _httpContextAccessor;
+	private readonly IOptions<JwtOptions> _jwtOptions;
+
+	/// <summary>
+	/// Stores the username upon first retrieval
+	/// </summary>
+	private string? _cachedUsername;
+
+	/// <summary>
+	/// Stores the id upon first retrieval
+	/// </summary>
+	private string? _cachedId;
+
+	public UserAccessor(IHttpContextAccessor httpContextAccessor, IOptions<JwtOptions> jwtOptions)
+	{
+		_httpContextAccessor = httpContextAccessor;
+		_jwtOptions = jwtOptions;
+	}
+
+	public string GetUsername()
+	{
+		if (string.IsNullOrEmpty(_cachedUsername))
+		{
+			_cachedUsername = GetClaimValue(_jwtOptions.Value.NameClaimType ?? ClaimTypes.Name);
+		}
+
+		return _cachedUsername;
+	}
+
+	public string GetUserId()
+	{
+		if (string.IsNullOrEmpty(_cachedId))
+		{
+			_cachedId = GetClaimValue(ClaimTypes.NameIdentifier);
+		}
+
+		return _cachedId;
+	}
+
+	private string GetClaimValue(string claimType)
+	{
+		HttpContext? httpContext = _httpContextAccessor.HttpContext;
+
+		if (httpContext is null)
+		{
+			ThrowForMissingHttpContext();
+		}
+
+		string? claimValue = httpContext.User.FindFirstValue(claimType);
+
+		if (string.IsNullOrWhiteSpace(claimValue))
+		{
+			ThrowForMissingClaim(claimType);
+		}
+
+		return claimValue;
+	}
+
+	[DoesNotReturn]
+	private static void ThrowForMissingHttpContext()
+	{
+		throw new InvalidOperationException("No HttpContext available.");
+	}
+
+	[DoesNotReturn]
+	private static void ThrowForMissingClaim(string claimType)
+	{
+		throw new InvalidOperationException($"No claim of type '{claimType}' found on the current user.");
+	}
+}

src/Vegasco.Server.Api/Cars/Car.cs

@@ -0,0 +1,42 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using Vegasco.Server.Api.Consumptions;
+using Vegasco.Server.Api.Users;
+
+namespace Vegasco.Server.Api.Cars;
+
+public class Car
+{
+	public CarId Id { get; set; } = CarId.New();
+
+	public string Name { get; set; } = "";
+
+	public string UserId { get; set; } = "";
+
+	public virtual User User { get; set; } = null!;
+
+	public virtual ICollection<Consumption> Consumptions { get; set; } = [];
+}
+
+public class CarTableConfiguration : IEntityTypeConfiguration<Car>
+{
+	public const int NameMaxLength = 50;
+
+	public void Configure(EntityTypeBuilder<Car> builder)
+	{
+		builder.HasKey(x => x.Id);
+
+		builder.Property(x => x.Id)
+			.HasConversion<CarId.EfCoreValueConverter>();
+
+		builder.Property(x => x.Name)
+			.IsRequired()
+			.HasMaxLength(NameMaxLength);
+
+		builder.Property(x => x.UserId)
+			.IsRequired();
+
+		builder.HasOne(x => x.User)
+			.WithMany(x => x.Cars);
+	}
+}

src/Vegasco.Server.Api/Cars/CarId.cs

@@ -0,0 +1,6 @@
+using StronglyTypedIds;
+
+namespace Vegasco.Server.Api.Cars;
+
+[StronglyTypedId]
+public partial struct CarId;

src/Vegasco.Server.Api/Cars/CreateCar.cs

@@ -0,0 +1,69 @@
+using FluentValidation;
+using FluentValidation.Results;
+using Vegasco.Server.Api.Authentication;
+using Vegasco.Server.Api.Common;
+using Vegasco.Server.Api.Persistence;
+using Vegasco.Server.Api.Users;
+
+namespace Vegasco.Server.Api.Cars;
+
+public static class CreateCar
+{
+	public record Request(string Name);
+	public record Response(Guid Id, string Name);
+
+	public static RouteHandlerBuilder MapEndpoint(IEndpointRouteBuilder builder)
+	{
+		return builder
+			.MapPost("cars", Endpoint)
+			.WithTags("Cars");
+	}
+
+	public class Validator : AbstractValidator<Request>
+	{
+		public Validator()
+		{
+			RuleFor(x => x.Name)
+				.NotEmpty()
+				.MaximumLength(CarTableConfiguration.NameMaxLength);
+		}
+	}
+
+	public static async Task<IResult> Endpoint(
+		Request request,
+		IEnumerable<IValidator<Request>> validators,
+		ApplicationDbContext dbContext,
+		UserAccessor userAccessor,
+		CancellationToken cancellationToken)
+	{
+		List<ValidationResult> failedValidations = await validators.ValidateAllAsync(request, cancellationToken: cancellationToken);
+		if (failedValidations.Count > 0)
+		{
+			return TypedResults.BadRequest(new HttpValidationProblemDetails(failedValidations.ToCombinedDictionary()));
+		}
+
+		string userId = userAccessor.GetUserId();
+
+		User? user = await dbContext.Users.FindAsync([userId], cancellationToken: cancellationToken);
+		if (user is null)
+		{
+			user = new User
+			{
+				Id = userId
+			};
+			await dbContext.Users.AddAsync(user, cancellationToken);
+		}
+
+		Car car = new()
+		{
+			Name = request.Name,
+			UserId = userId
+		};
+
+		await dbContext.Cars.AddAsync(car, cancellationToken);
+		await dbContext.SaveChangesAsync(cancellationToken);
+
+		Response response = new(car.Id.Value, car.Name);
+		return TypedResults.Created($"/v1/cars/{car.Id}", response);
+	}
+}

src/Vegasco.Server.Api/Cars/DeleteCar.cs

@@ -0,0 +1,31 @@
+using Vegasco.Server.Api.Persistence;
+
+namespace Vegasco.Server.Api.Cars;
+
+public static class DeleteCar
+{
+	public static RouteHandlerBuilder MapEndpoint(IEndpointRouteBuilder builder)
+	{
+		return builder
+			.MapDelete("cars/{id:guid}", Endpoint)
+			.WithTags("Cars");
+	}
+
+	public static async Task<IResult> Endpoint(
+		Guid id,
+		ApplicationDbContext dbContext,
+		CancellationToken cancellationToken)
+	{
+		Car? car = await dbContext.Cars.FindAsync([new CarId(id)], cancellationToken: cancellationToken);
+
+		if (car is null)
+		{
+			return TypedResults.NotFound();
+		}
+
+		dbContext.Cars.Remove(car);
+		await dbContext.SaveChangesAsync(cancellationToken);
+
+		return TypedResults.NoContent();
+	}
+}

src/Vegasco.Server.Api/Cars/GetCar.cs

@@ -0,0 +1,31 @@
+using Vegasco.Server.Api.Persistence;
+
+namespace Vegasco.Server.Api.Cars;
+
+public static class GetCar
+{
+	public record Response(Guid Id, string Name);
+
+	public static RouteHandlerBuilder MapEndpoint(IEndpointRouteBuilder builder)
+	{
+		return builder
+			.MapGet("cars/{id:guid}", Endpoint)
+			.WithTags("Cars");
+	}
+
+	private static async Task<IResult> Endpoint(
+		Guid id,
+		ApplicationDbContext dbContext,
+		CancellationToken cancellationToken)
+	{
+		Car? car = await dbContext.Cars.FindAsync([new CarId(id)], cancellationToken: cancellationToken);
+
+		if (car is null)
+		{
+			return TypedResults.NotFound();
+		}
+
+		var response = new Response(car.Id.Value, car.Name);
+		return TypedResults.Ok(response);
+	}
+}

src/Vegasco.Server.Api/Cars/GetCars.cs

@@ -0,0 +1,46 @@
+using Microsoft.AspNetCore.Http.HttpResults;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Vegasco.Server.Api.Persistence;
+
+namespace Vegasco.Server.Api.Cars;
+
+public static class GetCars
+{
+	public class ApiResponse
+	{
+		public IEnumerable<ResponseDto> Cars { get; set; } = [];
+	}
+	
+	public record ResponseDto(Guid Id, string Name);
+
+	public class Request
+	{
+		[FromQuery(Name = "page")] public int? Page { get; set; }
+		[FromQuery(Name = "pageSize")] public int? PageSize { get; set; }
+	}
+
+	public static RouteHandlerBuilder MapEndpoint(IEndpointRouteBuilder builder)
+	{
+		return builder
+			.MapGet("cars", Endpoint)
+			.WithDescription("Returns all cars")
+			.WithTags("Cars");
+	}
+
+	private static async Task<Ok<ApiResponse>> Endpoint(
+		[AsParameters] Request request,
+		ApplicationDbContext dbContext,
+		CancellationToken cancellationToken)
+	{
+		List<ResponseDto> cars = await dbContext.Cars
+			.Select(x => new ResponseDto(x.Id.Value, x.Name))
+			.ToListAsync(cancellationToken);
+
+		var response = new ApiResponse
+		{
+			Cars = cars
+		};
+		return TypedResults.Ok(response);
+	}
+}

src/Vegasco.Server.Api/Cars/UpdateCar.cs

@@ -0,0 +1,58 @@
+using FluentValidation;
+using FluentValidation.Results;
+using Vegasco.Server.Api.Authentication;
+using Vegasco.Server.Api.Common;
+using Vegasco.Server.Api.Persistence;
+
+namespace Vegasco.Server.Api.Cars;
+
+public static class UpdateCar
+{
+	public record Request(string Name);
+	public record Response(Guid Id, string Name);
+
+	public static RouteHandlerBuilder MapEndpoint(IEndpointRouteBuilder builder)
+	{
+		return builder
+			.MapPut("cars/{id:guid}", Endpoint)
+			.WithTags("Cars");
+	}
+
+	public class Validator : AbstractValidator<Request>
+	{
+		public Validator()
+		{
+			RuleFor(x => x.Name)
+				.NotEmpty()
+				.MaximumLength(CarTableConfiguration.NameMaxLength);
+		}
+	}
+
+	public static async Task<IResult> Endpoint(
+		Guid id,
+		Request request,
+		IEnumerable<IValidator<Request>> validators,
+		ApplicationDbContext dbContext,
+		UserAccessor userAccessor,
+		CancellationToken cancellationToken)
+	{
+		List<ValidationResult> failedValidations = await validators.ValidateAllAsync(request, cancellationToken);
+		if (failedValidations.Count > 0)
+		{
+			return TypedResults.BadRequest(new HttpValidationProblemDetails(failedValidations.ToCombinedDictionary()));
+		}
+
+		Car? car = await dbContext.Cars.FindAsync([new CarId(id)], cancellationToken: cancellationToken);
+
+		if (car is null)
+		{
+			return TypedResults.NotFound();
+		}
+
+		car.Name = request.Name;
+		await dbContext.SaveChangesAsync(cancellationToken);
+
+		Response response = new(car.Id.Value, car.Name);
+		return TypedResults.Ok(response);
+	}
+}

src/Vegasco.Server.Api/Common/Constants.cs

@@ -0,0 +1,9 @@
+namespace Vegasco.Server.Api.Common;
+
+public static class Constants
+{
+	public static class Authorization
+	{
+		public const string RequireAuthenticatedUserPolicy = "RequireAuthenticatedUser";
+	}
+}

src/Vegasco.Server.Api/Common/DependencyInjectionExtensions.cs

@@ -0,0 +1,132 @@
+using Asp.Versioning;
+using FluentValidation;
+using Microsoft.AspNetCore.Authentication.JwtBearer;
+using Microsoft.Extensions.Options;
+using Vegasco.Server.Api.Authentication;
+using Vegasco.Server.Api.Common;
+using Vegasco.Server.Api.Persistence;
+
+namespace Vegasco.Server.Api.Common;
+
+public static class DependencyInjectionExtensions
+{
+	/// <summary>
+	///     Adds all the Api related services to the Dependency Injection container.
+	/// </summary>
+	/// <param name="builder"></param>
+	public static void AddApiServices(this IHostApplicationBuilder builder)
+	{
+		builder.Services
+			.AddMiscellaneousServices()
+			.AddCustomOpenApi()
+			.AddApiVersioning()
+			.AddAuthenticationAndAuthorization(builder.Environment);
+
+		builder.AddDbContext();
+	}
+
+	private static IServiceCollection AddMiscellaneousServices(this IServiceCollection services)
+	{
+		services.AddResponseCompression();
+
+		services.AddValidatorsFromAssemblies(
+		[
+			typeof(IApiMarker).Assembly
+		], ServiceLifetime.Singleton);
+
+		services.AddHealthChecks();
+
+		services.AddHttpContextAccessor();
+
+		services.AddHostedService<ApplyMigrationsService>();
+
+		return services;
+	}
+
+	private static IServiceCollection AddCustomOpenApi(this IServiceCollection services)
+	{
+		services.AddEndpointsApiExplorer();
+		services.AddOpenApi(o =>
+		{
+			o.CreateSchemaReferenceId = jsonTypeInfo =>
+			{
+				if (string.IsNullOrEmpty(jsonTypeInfo.Type.FullName))
+				{
+					return jsonTypeInfo.Type.Name;
+				}
+
+				string? fullClassName = jsonTypeInfo.Type.FullName;
+
+				if (!string.IsNullOrEmpty(jsonTypeInfo.Type.Namespace))
+				{
+					fullClassName = fullClassName
+						.Replace(jsonTypeInfo.Type.Namespace, "")
+						.TrimStart('.');
+				}
+
+				fullClassName = fullClassName.Replace('+', '_');
+				return fullClassName;
+			};
+		});
+
+		return services;
+	}
+
+	private static IServiceCollection AddApiVersioning(this IServiceCollection services)
+	{
+		services.AddApiVersioning(o =>
+		{
+			o.DefaultApiVersion = new ApiVersion(1);
+			o.ApiVersionReader = new UrlSegmentApiVersionReader();
+			o.ReportApiVersions = true;
+		})
+			.AddApiExplorer(o =>
+			{
+				o.GroupNameFormat = "'v'V";
+				o.SubstituteApiVersionInUrl = true;
+			});
+
+		return services;
+	}
+
+	private static IServiceCollection AddAuthenticationAndAuthorization(this IServiceCollection services, IHostEnvironment environment)
+	{
+		services.AddOptions<JwtOptions>()
+			.BindConfiguration(JwtOptions.SectionName)
+			.ValidateFluently()
+			.ValidateOnStart();
+
+		var jwtOptions = services.BuildServiceProvider().GetRequiredService<IOptions<JwtOptions>>();
+
+		services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
+			.AddJwtBearer(JwtBearerDefaults.AuthenticationScheme, o =>
+			{
+				o.MetadataAddress = jwtOptions.Value.MetadataUrl;
+
+				o.TokenValidationParameters.ValidAudience = jwtOptions.Value.ValidAudience;
+				o.TokenValidationParameters.ValidateAudience = true;
+
+				if (!string.IsNullOrWhiteSpace(jwtOptions.Value.NameClaimType))
+				{
+					o.TokenValidationParameters.NameClaimType = jwtOptions.Value.NameClaimType;
+				}
+
+				o.RequireHttpsMetadata = !jwtOptions.Value.AllowHttpMetadataUrl && !environment.IsDevelopment();
+			});
+
+		services.AddAuthorizationBuilder()
+			.AddPolicy(Constants.Authorization.RequireAuthenticatedUserPolicy, p => p
+				.RequireAuthenticatedUser()
+				.AddAuthenticationSchemes(JwtBearerDefaults.AuthenticationScheme));
+
+		services.AddScoped<UserAccessor>();
+
+		return services;
+	}
+
+	private static IHostApplicationBuilder AddDbContext(this IHostApplicationBuilder builder)
+	{
+		builder.AddNpgsqlDbContext<ApplicationDbContext>(AppHost.Shared.Constants.Database.Name);
+		return builder;
+	}
+}

src/Vegasco.Server.Api/Common/FluentValidationOptions.cs

@@ -0,0 +1,37 @@
+using FluentValidation;
+using FluentValidation.Results;
+using Microsoft.Extensions.Options;
+
+namespace Vegasco.Server.Api.Common;
+
+public class FluentValidationOptions<TOptions> : IValidateOptions<TOptions>
+	where TOptions : class
+{
+	private readonly IEnumerable<IValidator<TOptions>> _validators;
+
+	public string? Name { get; set; }
+
+	public FluentValidationOptions(string? name, IEnumerable<IValidator<TOptions>> validators)
+	{
+		Name = name;
+		_validators = validators;
+	}
+
+	public ValidateOptionsResult Validate(string? name, TOptions options)
+	{
+		if (name is not null && name != Name)
+		{
+			return ValidateOptionsResult.Skip;
+		}
+
+		ArgumentNullException.ThrowIfNull(options);
+
+		List<ValidationResult> failedValidations = _validators.ValidateAllAsync(options).Result;
+		if (failedValidations.Count == 0)
+		{
+			return ValidateOptionsResult.Success;
+		}
+
+		return ValidateOptionsResult.Fail(failedValidations.SelectMany(x => x.Errors.Select(x => x.ErrorMessage)));
+	}
+}

src/Vegasco.Server.Api/Common/IApiMarker.cs

@@ -0,0 +1,3 @@
+namespace Vegasco.Server.Api.Common;
+
+public interface IApiMarker;

src/Vegasco.Server.Api/Common/StartupExtensions.cs

@@ -0,0 +1,53 @@
+using Microsoft.AspNetCore.Localization;
+using System.Globalization;
+using Vegasco.Server.Api.Endpoints;
+using Vegasco.Server.ServiceDefaults;
+
+namespace Vegasco.Server.Api.Common;
+
+internal static class StartupExtensions
+{
+	internal static WebApplication ConfigureServices(this WebApplicationBuilder builder)
+	{
+		builder.AddServiceDefaults();
+
+		builder.Configuration.AddEnvironmentVariables("Vegasco_");
+
+		builder.AddApiServices();
+
+		WebApplication app = builder.Build();
+		return app;
+	}
+
+	internal static WebApplication ConfigureRequestPipeline(this WebApplication app)
+	{
+		app.UseRequestLocalization(o =>
+		{
+			o.SupportedCultures =
+			[
+				new CultureInfo("en")
+			];
+
+			o.SupportedUICultures = o.SupportedCultures;
+
+			CultureInfo defaultCulture = o.SupportedCultures[0];
+			o.DefaultRequestCulture = new RequestCulture(defaultCulture);
+		});
+
+		app.UseHttpsRedirection();
+
+		app.MapHealthChecks("/health");
+
+		app.UseAuthentication();
+		app.UseAuthorization();
+
+		app.MapEndpoints();
+
+		if (app.Environment.IsDevelopment())
+		{
+			app.MapOpenApi("/swagger/{documentName}/swagger.json");
+		}
+
+		return app;
+	}
+}

src/Vegasco.Server.Api/Common/ValidatorExtensions.cs

@@ -0,0 +1,62 @@
+using FluentValidation;
+using FluentValidation.Results;
+using Microsoft.Extensions.Options;
+
+namespace Vegasco.Server.Api.Common;
+
+public static class ValidatorExtensions
+{
+	/// <summary>
+	/// Asynchronously validates an instance of <typeparamref name="T"/> against all <see cref="IValidator{T}"/> instances in <paramref name="validators"/>.
+	/// </summary>
+	/// <typeparam name="T"></typeparam>
+	/// <param name="validators"></param>
+	/// <param name="instance"></param>
+	/// <returns>The failed validation results.</returns>
+	public static async Task<List<ValidationResult>> ValidateAllAsync<T>(this IEnumerable<IValidator<T>> validators, T instance, CancellationToken cancellationToken = default)
+	{
+		List<Task<ValidationResult>> validationTasks = validators
+			.Select(validator => validator.ValidateAsync(instance, cancellationToken))
+			.ToList();
+
+		await Task.WhenAll(validationTasks);
+
+		List<ValidationResult> failedValidations = validationTasks
+			.Select(x => x.Result)
+			.Where(x => !x.IsValid)
+			.ToList();
+
+		return failedValidations;
+	}
+
+	public static Dictionary<string, string[]> ToCombinedDictionary(this IEnumerable<ValidationResult> validationResults)
+	{
+		// Use a hash set to avoid duplicate error messages.
+		Dictionary<string, HashSet<string>> combinedErrors = [];
+
+		foreach (ValidationFailure? error in validationResults.SelectMany(x => x.Errors))
+		{
+			if (!combinedErrors.TryGetValue(error.PropertyName, out HashSet<string>? value))
+			{
+				value = [error.ErrorMessage];
+				combinedErrors[error.PropertyName] = value;
+				continue;
+			}
+
+			value.Add(error.ErrorMessage);
+		}
+
+		return combinedErrors.ToDictionary(x => x.Key, x => x.Value.ToArray());
+	}
+
+	public static OptionsBuilder<T> ValidateFluently<T>(this OptionsBuilder<T> builder)
+		where T : class
+	{
+		builder.Services.AddTransient<IValidateOptions<T>>(serviceProvider =>
+		{
+			IEnumerable<IValidator<T>> validators = serviceProvider.GetServices<IValidator<T>>() ?? [];
+			return new FluentValidationOptions<T>(builder.Name, validators);
+		});
+		return builder;
+	}
+}

src/Vegasco.Server.Api/Consumptions/Consumption.cs

@@ -0,0 +1,52 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using Vegasco.Server.Api.Cars;
+
+namespace Vegasco.Server.Api.Consumptions;
+
+public class Consumption
+{
+	public ConsumptionId Id { get; set; } = ConsumptionId.New();
+
+	public DateTimeOffset DateTime { get; set; }
+
+	public double Distance { get; set; }
+
+	public double Amount { get; set; }
+
+	public bool IgnoreInCalculation { get; set; }
+
+	public CarId CarId { get; set; }
+
+	public virtual Car Car { get; set; } = null!;
+}
+
+public class ConsumptionTableConfiguration : IEntityTypeConfiguration<Consumption>
+{
+	public void Configure(EntityTypeBuilder<Consumption> builder)
+	{
+		builder.HasKey(x => x.Id);
+
+		builder.Property(x => x.Id)
+			.HasConversion<ConsumptionId.EfCoreValueConverter>();
+
+		builder.Property(x => x.DateTime)
+			.IsRequired();
+
+		builder.Property(x => x.Distance)
+			.IsRequired();
+
+		builder.Property(x => x.Amount)
+			.IsRequired();
+
+		builder.Property(x => x.IgnoreInCalculation)
+			.IsRequired();
+
+		builder.Property(x => x.CarId)
+			.IsRequired()
+			.HasConversion<CarId.EfCoreValueConverter>();
+
+		builder.HasOne(x => x.Car)
+			.WithMany(x => x.Consumptions);
+	}
+}

src/Vegasco.Server.Api/Consumptions/ConsumptionId.cs

@@ -0,0 +1,7 @@
+using StronglyTypedIds;
+
+namespace Vegasco.Server.Api.Consumptions;
+
+
+[StronglyTypedId]
+public partial struct ConsumptionId;

src/Vegasco.Server.Api/Consumptions/CreateConsumption.cs

@@ -0,0 +1,74 @@
+using FluentValidation;
+using FluentValidation.Results;
+using Vegasco.Server.Api.Cars;
+using Vegasco.Server.Api.Common;
+using Vegasco.Server.Api.Persistence;
+
+namespace Vegasco.Server.Api.Consumptions;
+
+public static class CreateConsumption
+{
+	public record Request(DateTimeOffset DateTime, double Distance, double Amount, bool IgnoreInCalculation, Guid CarId);
+
+	public record Response(Guid Id, DateTimeOffset DateTime, double Distance, double Amount, bool IgnoreInCalculation, Guid CarId);
+
+	public static RouteHandlerBuilder MapEndpoint(IEndpointRouteBuilder builder)
+	{
+		return builder
+			.MapPost("consumptions", Endpoint)
+			.WithTags("Consumptions");
+	}
+
+	public class Validator : AbstractValidator<Request>
+	{
+		public Validator(TimeProvider timeProvider)
+		{
+			RuleFor(x => x.DateTime.ToUniversalTime())
+				.LessThanOrEqualTo(timeProvider.GetUtcNow())
+				.WithName(nameof(Request.DateTime));
+
+			RuleFor(x => x.Distance)
+				.GreaterThan(0);
+
+			RuleFor(x => x.Amount)
+				.GreaterThan(0);
+
+			RuleFor(x => x.CarId)
+				.NotEmpty();
+		}
+	}
+
+	private static async Task<IResult> Endpoint(
+		ApplicationDbContext dbContext,
+		Request request,
+		IEnumerable<IValidator<Request>> validators,
+		CancellationToken cancellationToken)
+	{
+		List<ValidationResult> failedValidations = await validators.ValidateAllAsync(request, cancellationToken);
+		if (failedValidations.Count > 0)
+		{
+			return TypedResults.BadRequest(new HttpValidationProblemDetails(failedValidations.ToCombinedDictionary()));
+		}
+
+		Car? car = await dbContext.Cars.FindAsync([new CarId(request.CarId)], cancellationToken);
+		if (car is null)
+		{
+			return TypedResults.NotFound();
+		}
+
+		var consumption = new Consumption
+		{
+			DateTime = request.DateTime.ToUniversalTime(),
+			Distance = request.Distance,
+			Amount = request.Amount,
+			IgnoreInCalculation = request.IgnoreInCalculation,
+			CarId = new CarId(request.CarId)
+		};
+
+		dbContext.Consumptions.Add(consumption);
+		await dbContext.SaveChangesAsync(cancellationToken);
+
+		return TypedResults.Created($"consumptions/{consumption.Id.Value}",
+			new Response(consumption.Id.Value, consumption.DateTime, consumption.Distance, consumption.Amount, consumption.IgnoreInCalculation, consumption.CarId.Value));
+	}
+}

src/Vegasco.Server.Api/Consumptions/DeleteConsumptions.cs

@@ -0,0 +1,30 @@
+using Vegasco.Server.Api.Persistence;
+
+namespace Vegasco.Server.Api.Consumptions;
+
+public static class DeleteConsumption
+{
+	public static RouteHandlerBuilder MapEndpoint(IEndpointRouteBuilder builder)
+	{
+		return builder
+			.MapDelete("consumptions/{id:guid}", Endpoint)
+			.WithTags("Consumptions");
+	}
+
+	private static async Task<IResult> Endpoint(
+		ApplicationDbContext dbContext,
+		Guid id,
+		CancellationToken cancellationToken)
+	{
+		Consumption? consumption = await dbContext.Consumptions.FindAsync([new ConsumptionId(id)], cancellationToken);
+		if (consumption is null)
+		{
+			return TypedResults.NotFound();
+		}
+
+		dbContext.Consumptions.Remove(consumption);
+		await dbContext.SaveChangesAsync(cancellationToken);
+
+		return TypedResults.NoContent();
+	}
+}

src/Vegasco.Server.Api/Consumptions/GetConsumption.cs

@@ -0,0 +1,32 @@
+using Vegasco.Server.Api.Persistence;
+
+namespace Vegasco.Server.Api.Consumptions;
+
+public static class GetConsumption
+{
+	public record Response(Guid Id, DateTimeOffset DateTime, double Distance, double Amount, bool IgnoreInCalculation, Guid CarId);
+
+	public static RouteHandlerBuilder MapEndpoint(IEndpointRouteBuilder builder)
+	{
+		return builder
+			.MapGet("consumptions/{id:guid}", Endpoint)
+			.WithTags("Consumptions");
+	}
+
+	private static async Task<IResult> Endpoint(
+		ApplicationDbContext dbContext,
+		Guid id,
+		CancellationToken cancellationToken)
+	{
+		Consumption? consumption = await dbContext.Consumptions.FindAsync([new ConsumptionId(id)], cancellationToken);
+
+		if (consumption is null)
+		{
+			return TypedResults.NotFound();
+		}
+
+		var response = new Response(consumption.Id.Value, consumption.DateTime, consumption.Distance,
+			consumption.Amount, consumption.IgnoreInCalculation, consumption.CarId.Value);
+		return TypedResults.Ok(response);
+	}
+}

src/Vegasco.Server.Api/Consumptions/GetConsumptions.cs

@@ -0,0 +1,53 @@
+using Microsoft.AspNetCore.Http.HttpResults;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Vegasco.Server.Api.Persistence;
+
+namespace Vegasco.Server.Api.Consumptions;
+
+public static class GetConsumptions
+{
+    public class ApiResponse
+    {
+        public IEnumerable<ResponseDto> Consumptions { get; set; } = [];
+    }
+
+    public record ResponseDto(
+        Guid Id,
+        DateTimeOffset DateTime,
+        double Distance,
+        double Amount,
+        bool IgnoreInCalculation,
+        Guid CarId);
+
+    public class Request
+    {
+        [FromQuery(Name = "page")] public int? Page { get; set; }
+        [FromQuery(Name = "pageSize")] public int? PageSize { get; set; }
+    }
+
+    public static RouteHandlerBuilder MapEndpoint(IEndpointRouteBuilder builder)
+    {
+        return builder
+            .MapGet("consumptions", Endpoint)
+            .WithDescription("Returns all consumption entries")
+            .WithTags("Consumptions");
+    }
+
+    private static async Task<Ok<ApiResponse>> Endpoint(
+        [AsParameters] Request request,
+        ApplicationDbContext dbContext,
+        CancellationToken cancellationToken)
+    {
+        List<ResponseDto> consumptions = await dbContext.Consumptions
+            .Select(x =>
+                new ResponseDto(x.Id.Value, x.DateTime, x.Distance, x.Amount, x.IgnoreInCalculation, x.CarId.Value))
+            .ToListAsync(cancellationToken);
+
+        var apiResponse = new ApiResponse
+        {
+            Consumptions = consumptions
+        };
+        return TypedResults.Ok(apiResponse);
+    }
+}

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

@@ -0,0 +1,65 @@
+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, bool IgnoreInCalculation);
+
+	public record Response(Guid Id, DateTimeOffset DateTime, double Distance, double Amount, bool IgnoreInCalculation, Guid CarId);
+
+	public static RouteHandlerBuilder MapEndpoint(IEndpointRouteBuilder builder)
+	{
+		return builder
+			.MapPut("consumptions/{id:guid}", Endpoint)
+			.WithTags("Consumptions");
+	}
+
+	public class Validator : AbstractValidator<Request>
+	{
+		public Validator(TimeProvider timeProvider)
+		{
+			RuleFor(x => x.DateTime.ToUniversalTime())
+				.LessThanOrEqualTo(timeProvider.GetUtcNow())
+				.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,
+		CancellationToken cancellationToken)
+	{
+		List<ValidationResult> failedValidations = await validators.ValidateAllAsync(request, cancellationToken);
+		if (failedValidations.Count > 0)
+		{
+			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;
+		consumption.IgnoreInCalculation = request.IgnoreInCalculation;
+
+		await dbContext.SaveChangesAsync(cancellationToken);
+
+		return TypedResults.Ok(new Response(consumption.Id.Value, consumption.DateTime, consumption.Distance, consumption.Amount, consumption.IgnoreInCalculation, consumption.CarId.Value));
+	}
+}

src/Vegasco.Server.Api/Endpoints/EndpointExtensions.cs

@@ -0,0 +1,36 @@
+using Asp.Versioning.Builder;
+using Asp.Versioning.Conventions;
+using Vegasco.Server.Api.Cars;
+using Vegasco.Server.Api.Common;
+using Vegasco.Server.Api.Consumptions;
+using Vegasco.Server.Api.Info;
+
+namespace Vegasco.Server.Api.Endpoints;
+
+public static class EndpointExtensions
+{
+	public static void MapEndpoints(this IEndpointRouteBuilder builder)
+	{
+		ApiVersionSet apiVersionSet = builder.NewApiVersionSet()
+		.HasApiVersion(1.0)
+		.Build();
+
+		RouteGroupBuilder versionedApis = builder.MapGroup("/v{apiVersion:apiVersion}")
+			.WithApiVersionSet(apiVersionSet)
+			.RequireAuthorization(Constants.Authorization.RequireAuthenticatedUserPolicy);
+
+		GetCar.MapEndpoint(versionedApis);
+		GetCars.MapEndpoint(versionedApis);
+		CreateCar.MapEndpoint(versionedApis);
+		UpdateCar.MapEndpoint(versionedApis);
+		DeleteCar.MapEndpoint(versionedApis);
+
+		GetConsumptions.MapEndpoint(versionedApis);
+		GetConsumption.MapEndpoint(versionedApis);
+		CreateConsumption.MapEndpoint(versionedApis);
+		UpdateConsumption.MapEndpoint(versionedApis);
+		DeleteConsumption.MapEndpoint(versionedApis);
+
+		GetServerInfo.MapEndpoint(versionedApis);
+	}
+}

src/Vegasco.Server.Api/Info/GetServerInfo.cs

@@ -0,0 +1,29 @@
+using Microsoft.AspNetCore.Http.HttpResults;
+
+namespace Vegasco.Server.Api.Info;
+
+public class GetServerInfo
+{
+    public record Response(
+        string FullVersion,
+        string CommitId,
+        DateTime CommitDate,
+        string Environment);
+
+    public static RouteHandlerBuilder MapEndpoint(IEndpointRouteBuilder builder)
+    {
+        return builder
+            .MapGet("info/server", Endpoint)
+            .WithTags("Info");
+    }
+
+    private static Ok<Response> Endpoint(
+        IHostEnvironment environment)
+    {
+        return TypedResults.Ok(new Response(
+            ThisAssembly.AssemblyInformationalVersion,
+            ThisAssembly.GitCommitId,
+            ThisAssembly.GitCommitDate,
+            environment.EnvironmentName));
+    }
+}

src/Vegasco.Server.Api/Persistence/ApplicationDbContext.cs

@@ -0,0 +1,22 @@
+using Microsoft.EntityFrameworkCore;
+using Vegasco.Server.Api.Cars;
+using Vegasco.Server.Api.Common;
+using Vegasco.Server.Api.Consumptions;
+using Vegasco.Server.Api.Users;
+
+namespace Vegasco.Server.Api.Persistence;
+
+public class ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : DbContext(options)
+{
+	public DbSet<Car> Cars { get; set; }
+
+	public DbSet<User> Users { get; set; }
+
+	public DbSet<Consumption> Consumptions { get; set; }
+
+	protected override void OnModelCreating(ModelBuilder modelBuilder)
+	{
+		base.OnModelCreating(modelBuilder);
+		modelBuilder.ApplyConfigurationsFromAssembly(typeof(IApiMarker).Assembly);
+	}
+}

src/Vegasco.Server.Api/Persistence/ApplyMigrationsService.cs

@@ -0,0 +1,18 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace Vegasco.Server.Api.Persistence;
+
+public class ApplyMigrationsService(ILogger<ApplyMigrationsService> logger, IServiceScopeFactory scopeFactory)
+    : IHostedService
+{
+    public async Task StartAsync(CancellationToken cancellationToken)
+    {
+        logger.LogInformation("Starting migrations");
+        
+        using IServiceScope scope = scopeFactory.CreateScope();
+        await using var dbContext = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
+        await dbContext.Database.MigrateAsync(cancellationToken);
+    }
+
+    public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+}

src/Vegasco.Server.Api/Persistence/Migrations/20240818105918_Initial.Designer.cs

@@ -0,0 +1,121 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using Vegasco.Server.Api.Persistence;
+
+
+#nullable disable
+
+namespace Vegasco.Server.Api.Persistence.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20240818105918_Initial")]
+    partial class Initial
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.8")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Vegasco.Server.Api.Cars.Car", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Cars");
+                });
+
+            modelBuilder.Entity("Vegasco.Server.Api.Consumptions.Consumption", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<double>("Amount")
+                        .HasColumnType("double precision");
+
+                    b.Property<Guid>("CarId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<double>("Distance")
+                        .HasColumnType("double precision");
+
+                    b.Property<bool>("IgnoreInCalculation")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CarId");
+
+                    b.ToTable("Consumptions");
+                });
+
+            modelBuilder.Entity("Vegasco.Server.Api.Users.User", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("Vegasco.Server.Api.Cars.Car", b =>
+                {
+                    b.HasOne("Vegasco.Server.Api.Users.User", "User")
+                        .WithMany("Cars")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Vegasco.Server.Api.Consumptions.Consumption", b =>
+                {
+                    b.HasOne("Vegasco.Server.Api.Cars.Car", "Car")
+                        .WithMany("Consumptions")
+                        .HasForeignKey("CarId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Car");
+                });
+
+            modelBuilder.Entity("Vegasco.Server.Api.Cars.Car", b =>
+                {
+                    b.Navigation("Consumptions");
+                });
+
+            modelBuilder.Entity("Vegasco.Server.Api.Users.User", b =>
+                {
+                    b.Navigation("Cars");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

src/Vegasco.Server.Api/Persistence/Migrations/20240818105918_Initial.cs

@@ -0,0 +1,89 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Vegasco.Server.Api.Persistence.Migrations
+{
+    /// <inheritdoc />
+    public partial class Initial : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "Users",
+                columns: table => new
+                {
+                    Id = table.Column<string>(type: "text", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Users", x => x.Id);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Cars",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    Name = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: false),
+                    UserId = table.Column<string>(type: "text", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Cars", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Cars_Users_UserId",
+                        column: x => x.UserId,
+                        principalTable: "Users",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "Consumptions",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(type: "uuid", nullable: false),
+                    DateTime = table.Column<DateTimeOffset>(type: "timestamp with time zone", nullable: false),
+                    Distance = table.Column<double>(type: "double precision", nullable: false),
+                    Amount = table.Column<double>(type: "double precision", nullable: false),
+                    IgnoreInCalculation = table.Column<bool>(type: "boolean", nullable: false),
+                    CarId = table.Column<Guid>(type: "uuid", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_Consumptions", x => x.Id);
+                    table.ForeignKey(
+                        name: "FK_Consumptions_Cars_CarId",
+                        column: x => x.CarId,
+                        principalTable: "Cars",
+                        principalColumn: "Id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Cars_UserId",
+                table: "Cars",
+                column: "UserId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_Consumptions_CarId",
+                table: "Consumptions",
+                column: "CarId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "Consumptions");
+
+            migrationBuilder.DropTable(
+                name: "Cars");
+
+            migrationBuilder.DropTable(
+                name: "Users");
+        }
+    }
+}

src/Vegasco.Server.Api/Persistence/Migrations/ApplicationDbContextModelSnapshot.cs

@@ -0,0 +1,118 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using Vegasco.Server.Api.Persistence;
+
+
+#nullable disable
+
+namespace Vegasco.Server.Api.Persistence.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    partial class ApplicationDbContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.8")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Vegasco.Server.Api.Cars.Car", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("character varying(50)");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Cars");
+                });
+
+            modelBuilder.Entity("Vegasco.Server.Api.Consumptions.Consumption", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .HasColumnType("uuid");
+
+                    b.Property<double>("Amount")
+                        .HasColumnType("double precision");
+
+                    b.Property<Guid>("CarId")
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTimeOffset>("DateTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<double>("Distance")
+                        .HasColumnType("double precision");
+
+                    b.Property<bool>("IgnoreInCalculation")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CarId");
+
+                    b.ToTable("Consumptions");
+                });
+
+            modelBuilder.Entity("Vegasco.Server.Api.Users.User", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("Vegasco.Server.Api.Cars.Car", b =>
+                {
+                    b.HasOne("Vegasco.Server.Api.Users.User", "User")
+                        .WithMany("Cars")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Vegasco.Server.Api.Consumptions.Consumption", b =>
+                {
+                    b.HasOne("Vegasco.Server.Api.Cars.Car", "Car")
+                        .WithMany("Consumptions")
+                        .HasForeignKey("CarId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Car");
+                });
+
+            modelBuilder.Entity("Vegasco.Server.Api.Cars.Car", b =>
+                {
+                    b.Navigation("Consumptions");
+                });
+
+            modelBuilder.Entity("Vegasco.Server.Api.Users.User", b =>
+                {
+                    b.Navigation("Cars");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

src/Vegasco.Server.Api/Program.cs

@@ -0,0 +1,6 @@
+using Vegasco.Server.Api.Common;
+
+WebApplication.CreateBuilder(args)
+	.ConfigureServices()
+	.ConfigureRequestPipeline()
+	.Run();

src/Vegasco.Server.Api/Properties/launchSettings.json

@@ -0,0 +1,15 @@
+{
+  "profiles": {
+    "https": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "launchUrl": "swagger",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "dotnetRunMessages": true,
+      "applicationUrl": "https://localhost:7098;http://localhost:5076"
+    }
+  },
+  "$schema": "http://json.schemastore.org/launchsettings.json"
+}

src/Vegasco.Server.Api/Users/User.cs

@@ -0,0 +1,10 @@
+using Vegasco.Server.Api.Cars;
+
+namespace Vegasco.Server.Api.Users;
+
+public class User
+{
+	public string Id { get; set; } = "";
+
+	public virtual IList<Car> Cars { get; set; } = [];
+}

src/Vegasco.Server.Api/Users/UserTableConfiguration.cs

@@ -0,0 +1,12 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Vegasco.Server.Api.Users;
+
+public class UserTableConfiguration : IEntityTypeConfiguration<User>
+{
+	public void Configure(EntityTypeBuilder<User> builder)
+	{
+		builder.HasKey(user => user.Id);
+	}
+}

src/Vegasco.Server.Api/Vegasco.Server.Api.csproj

@@ -0,0 +1,45 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+	<TargetFramework>net9.0</TargetFramework>
+	<Nullable>enable</Nullable>
+	<ImplicitUsings>enable</ImplicitUsings>
+	<UserSecretsId>4bf893d3-0c16-41ec-8b46-2768d841215d</UserSecretsId>
+	<DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
+	<DockerfileContext>..\..</DockerfileContext>
+	<RootNamespace>Vegasco.Server.Api</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+	<PackageReference Include="Asp.Versioning.Http" Version="8.1.0" />
+	<PackageReference Include="Asp.Versioning.Mvc.ApiExplorer" Version="8.1.0" />
+	<PackageReference Include="Aspire.Npgsql.EntityFrameworkCore.PostgreSQL" Version="9.3.0" />
+	<PackageReference Include="FluentValidation.DependencyInjectionExtensions" Version="12.0.0" />
+	<PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="9.0.5" />
+	<PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="9.0.5" />
+	<PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.5" />
+	<PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="9.0.5">
+	  <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+	  <PrivateAssets>all</PrivateAssets>
+	</PackageReference>
+	<PackageReference Include="Microsoft.VisualStudio.Azure.Containers.Tools.Targets" Version="1.21.2" />
+	<PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="9.0.4" />
+	<PackageReference Include="OpenTelemetry" Version="1.12.0" />
+	<PackageReference Include="OpenTelemetry.Exporter.OpenTelemetryProtocol" Version="1.12.0" />
+	<PackageReference Include="OpenTelemetry.Extensions.Hosting" Version="1.12.0" />
+	<PackageReference Include="OpenTelemetry.Instrumentation.AspNetCore" Version="1.12.0" />
+	<PackageReference Include="OpenTelemetry.Instrumentation.Http" Version="1.12.0" />
+	<PackageReference Include="StronglyTypedId" Version="1.0.0-beta08" PrivateAssets="all" ExcludeAssets="runtime" />
+	<PackageReference Include="StronglyTypedId.Templates" Version="1.0.0-beta08" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Vegasco.Server.AppHost.Shared\Vegasco.Server.AppHost.Shared.csproj" />
+    <ProjectReference Include="..\Vegasco.Server.ServiceDefaults\Vegasco.Server.ServiceDefaults.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Update="Nerdbank.GitVersioning" Version="3.7.115" />
+  </ItemGroup>
+
+</Project>

src/Vegasco.Server.Api/appsettings.Development.json

@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  }
+}

src/Vegasco.Server.Api/appsettings.json

@@ -0,0 +1,10 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Warning",
+      "Vegasco": "Information",
+      "Microsoft.Hosting.Lifetime": "Information"
+    }
+  },
+  "AllowedHosts": "*"
+}