add architecture skeleton

GymLogAI.API/Program.cs

@@ -1,51 +1,120 @@
-using GymLogAI.TgBot;
+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 void Main(string[] args)
+    public static async Task Main(string[] args)
     {
         var builder = WebApplication.CreateBuilder(args);
 
-        // Add services to the container.
+        builder.Services.AddProblemDetails();
         builder.Services.AddAuthorization();
-        builder.Services.AddTgBot(builder.Configuration);
-
-        // Learn more about configuring OpenAPI at https://aka.ms/aspnet/openapi
         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();
 
-        // Configure the HTTP request pipeline.
+        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 summaries = new[]
-        {
-            "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
-        };
+        var api = app.MapGroup("/api");
 
-        app.MapGet("/weatherforecast", (HttpContext httpContext) =>
+        api.MapPost("/messages/import", async (
+                ImportTelegramMessageRequest request,
+                ImportTelegramMessageHandler handler,
+                CancellationToken cancellationToken) =>
             {
-                var forecast = Enumerable.Range(1, 5).Select(index =>
-                        new WeatherForecast
-                        {
-                            Date = DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
-                            TemperatureC = Random.Shared.Next(-20, 55),
-                            Summary = summaries[Random.Shared.Next(summaries.Length)]
-                        })
-                    .ToArray();
-                return forecast;
-            })
-            .WithName("GetWeatherForecast");
+                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);
 
-        app.Run();
+                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();
     }
 }