GymLogAI/GymLogAI.API/Program.cs

using GymLogAI.AI;
using GymLogAI.API.Contracts;
using GymLogAI.Application.Handlers;
using GymLogAI.Application.Interfaces;
using GymLogAI.Persistence;
using Microsoft.EntityFrameworkCore;

namespace GymLogAI.API;

public class Program
{
    public static async Task Main(string[] args)
    {
        var builder = WebApplication.CreateBuilder(args);

        builder.Services.AddProblemDetails();
        builder.Services.AddAuthorization();
        builder.Services.AddOpenApi();
        builder.Services.AddEndpointsApiExplorer();
        builder.Services.AddSwaggerGen();
        builder.Services.AddPersistence(builder.Configuration);
        builder.Services.AddAiServices(builder.Configuration);
        builder.Services.AddScoped<ImportTelegramMessageHandler>();
        builder.Services.AddScoped<ParseTelegramMessageHandler>();
        builder.Services.AddScoped<RecommendWorkoutHandler>();

        var app = builder.Build();

        await using (var scope = app.Services.CreateAsyncScope())
        {
            var dbContext = scope.ServiceProvider.GetRequiredService<AppDbContext>();
            await dbContext.Database.MigrateAsync();
        }

        if (app.Environment.IsDevelopment())
        {
            app.MapOpenApi();
        }

        app.UseExceptionHandler();
        app.UseSwagger();
        app.UseSwaggerUI();
        app.UseHttpsRedirection();
        app.UseAuthorization();

        var api = app.MapGroup("/api");

        api.MapPost("/messages/import", async (
                ImportTelegramMessageRequest request,
                ImportTelegramMessageHandler handler,
                CancellationToken cancellationToken) =>
            {
                var id = await handler.HandleAsync(
                    new ImportTelegramMessageCommand(
                        request.UserId,
                        request.TelegramUserId,
                        request.TelegramChatId,
                        request.TelegramMessageId,
                        request.Text,
                        request.SentAtUtc,
                        request.Username,
                        request.FirstName,
                        request.LastName),
                    cancellationToken);

                return TypedResults.Accepted($"/api/messages/{id}", new ImportTelegramMessageResponse(id));
            })
            .WithName("ImportTelegramMessage");

        api.MapPost("/workouts/recommend", async (
                RecommendWorkoutRequest request,
                RecommendWorkoutHandler handler,
                CancellationToken cancellationToken) =>
            {
                var result = await handler.HandleAsync(
                    new RecommendWorkoutCommand(request.UserId, request.GoalType, request.AdditionalContext),
                    cancellationToken);

                return TypedResults.Ok(result);
            })
            .WithName("RecommendWorkout");

        api.MapGet("/workouts/history", async (
                Guid userId,
                IWorkoutRepository workoutRepository,
                CancellationToken cancellationToken) =>
            {
                var history = await workoutRepository.GetHistoryAsync(userId, cancellationToken);

                var response = history.Select(workout => new WorkoutHistoryItemResponse(
                    workout.Id,
                    workout.PerformedAtUtc,
                    workout.Title,
                    workout.Notes,
                    workout.WorkoutExercises
                        .OrderBy(x => x.Order)
                        .Select(x => new WorkoutHistoryExerciseResponse(
                            x.ExerciseId,
                            x.Exercise?.Name ?? "Unknown exercise",
                            x.Order,
                            x.Notes,
                            x.Sets.OrderBy(s => s.Order)
                                .Select(s => new WorkoutHistorySetResponse(
                                    s.Order,
                                    s.Repetitions,
                                    s.WeightKg,
                                    s.DurationSeconds,
                                    s.DistanceMeters,
                                    s.Notes))
                                .ToArray()))
                        .ToArray()))
                    .ToArray();

                return TypedResults.Ok(response);
            })
            .WithName("GetWorkoutHistory");

        await app.RunAsync();
    }
}