Refactor state transitions into workflow service

Endpoints/StateEndpoints.cs

@@ -1,7 +1,4 @@
 using GameList.Data;
-using GameList.Domain;
-using GameList.Contracts;
-using Microsoft.EntityFrameworkCore;
 
 namespace GameList.Endpoints;
 
@@ -11,111 +8,41 @@ public static class StateEndpoints
     {
         var group = app.MapGroup("/api").RequireAuthorization();
 
-        group.MapGet("/state", async (HttpContext ctx, AppDbContext db) =>
+        group.MapGet("/state", async (HttpContext ctx, AppDbContext db, StateWorkflowService service) =>
         {
             var player = await EndpointHelpers.GetAuthenticatedPlayer(ctx, db);
             if (player is null)
                 return EndpointHelpers.UnauthorizedError();
 
-            var state = await db.AppState.AsNoTracking().FirstAsync();
+            return await service.GetStateAsync(player);
-            var phase = EndpointHelpers.GetCurrentPhase(player.CurrentPhase, state.ResultsOpen);
-            var summary = new StateSummaryResponse(
-                phase,
-                player.VotesFinal,
-                player.HasJoker,
-                state.ResultsOpen,
-                state.UpdatedAt,
-                await db.Players.CountAsync(),
-                await db.Suggestions.CountAsync(),
-                await db.Votes.CountAsync()
-            );
-            return Results.Ok(summary);
         });
 
-        group.MapGet("/me", async (HttpContext ctx, AppDbContext db) =>
+        group.MapGet("/me", async (HttpContext ctx, AppDbContext db, StateWorkflowService service) =>
         {
             var player = await EndpointHelpers.GetAuthenticatedPlayer(ctx, db);
             if (player is null)
                 return EndpointHelpers.UnauthorizedError();
 
-            var state = await db.AppState.AsNoTracking().FirstAsync();
+            return await service.GetMeAsync(player);
-            var phase = EndpointHelpers.GetCurrentPhase(player.CurrentPhase, state.ResultsOpen);
-            return Results.Ok(new MeResponse(
-                player.Id,
-                player.Username,
-                player.DisplayName,
-                player.IsAdmin,
-                phase,
-                player.VotesFinal,
-                player.HasJoker
-            ));
         });
 
-        group.MapPost("/me/phase/next", async (HttpContext ctx, AppDbContext db) =>
+        group.MapPost("/me/phase/next", async (HttpContext ctx, AppDbContext db, StateWorkflowService service) =>
         {
             var player = await EndpointHelpers.GetAuthenticatedPlayer(ctx, db);
             if (player is null)
                 return EndpointHelpers.UnauthorizedError();
 
-            var appState = await db.AppState.FirstAsync();
+            return await service.NextPhaseAsync(player);
-            var reconciled = EndpointHelpers.ReconcilePlayerPhase(player, appState.ResultsOpen);
-            var next = NextPhase(player.CurrentPhase);
-
-            if (next == Phase.Vote)
-            {
-                var hasSuggestions = await db.Suggestions.AnyAsync(s => s.PlayerId == player.Id);
-                if (!hasSuggestions)
-                {
-                    if (reconciled)
-                        await db.SaveChangesAsync();
-                    return EndpointHelpers.BadRequestError("Add at least one suggestion before entering the Vote phase.");
-                }
-            }
-
-            if (next == Phase.Results && !appState.ResultsOpen)
-            {
-                if (reconciled)
-                    await db.SaveChangesAsync();
-                return EndpointHelpers.BadRequestError("Results are locked until the admin enables them.");
-            }
-
-            player.CurrentPhase = next;
-            player.VotesFinal = false; // moving forward clears any prior finalize
-            await db.SaveChangesAsync();
-            return Results.Ok(new PhaseTransitionResponse(player.CurrentPhase, appState.ResultsOpen));
         });
 
-        group.MapPost("/me/phase/prev", async (HttpContext ctx, AppDbContext db) =>
+        group.MapPost("/me/phase/prev", async (HttpContext ctx, AppDbContext db, StateWorkflowService service) =>
         {
             var player = await EndpointHelpers.GetAuthenticatedPlayer(ctx, db);
             if (player is null)
                 return EndpointHelpers.UnauthorizedError();
 
-            var isAdmin = await EndpointHelpers.IsAdmin(ctx, db);
+            return await service.PrevPhaseAsync(player);
-            if (!isAdmin)
-            {
-                return EndpointHelpers.BadRequestError("Only admins can move backward.");
-            }
-
-            var appState = await db.AppState.FirstAsync();
-            EndpointHelpers.ReconcilePlayerPhase(player, appState.ResultsOpen);
-            player.CurrentPhase = PrevPhase(player.CurrentPhase);
-            player.VotesFinal = false;
-            await db.SaveChangesAsync();
-            return Results.Ok(new PhaseTransitionResponse(player.CurrentPhase, appState.ResultsOpen));
         });
 
     }
-
-    private static Phase NextPhase(Phase current) => current switch
-    {
-        Phase.Suggest => Phase.Vote,
-        _             => Phase.Results
-    };
-
-    private static Phase PrevPhase(Phase current) => current switch
-    {
-        Phase.Results => Phase.Vote,
-        _             => Phase.Suggest
-    };
 }

Endpoints/StateWorkflowService.cs

@@ -0,0 +1,106 @@
+using GameList.Contracts;
+using GameList.Data;
+using GameList.Domain;
+using Microsoft.EntityFrameworkCore;
+
+namespace GameList.Endpoints;
+
+internal sealed class StateWorkflowService(AppDbContext db)
+{
+    public async Task<IResult> GetStateAsync(Player player)
+    {
+        var state = await db.AppState.AsNoTracking().FirstAsync();
+        var phase = EndpointHelpers.GetCurrentPhase(player.CurrentPhase, state.ResultsOpen);
+        var summary = new StateSummaryResponse(
+            phase,
+            player.VotesFinal,
+            player.HasJoker,
+            state.ResultsOpen,
+            state.UpdatedAt,
+            await db.Players.CountAsync(),
+            await db.Suggestions.CountAsync(),
+            await db.Votes.CountAsync()
+        );
+        return Results.Ok(summary);
+    }
+
+    public async Task<IResult> GetMeAsync(Player player)
+    {
+        var state = await db.AppState.AsNoTracking().FirstAsync();
+        var phase = EndpointHelpers.GetCurrentPhase(player.CurrentPhase, state.ResultsOpen);
+        return Results.Ok(new MeResponse(
+            player.Id,
+            player.Username,
+            player.DisplayName,
+            player.IsAdmin,
+            phase,
+            player.VotesFinal,
+            player.HasJoker
+        ));
+    }
+
+    public async Task<IResult> NextPhaseAsync(Player player)
+    {
+        var appState = await db.AppState.FirstAsync();
+        var shouldSave = EndpointHelpers.ReconcilePlayerPhase(player, appState.ResultsOpen);
+
+        try
+        {
+            var next = NextPhase(player.CurrentPhase);
+
+            if (next == Phase.Vote)
+            {
+                var hasSuggestions = await db.Suggestions.AnyAsync(s => s.PlayerId == player.Id);
+                if (!hasSuggestions)
+                    return EndpointHelpers.BadRequestError("Add at least one suggestion before entering the Vote phase.");
+            }
+
+            if (next == Phase.Results && !appState.ResultsOpen)
+                return EndpointHelpers.BadRequestError("Results are locked until the admin enables them.");
+
+            player.CurrentPhase = next;
+            player.VotesFinal = false; // moving forward clears any prior finalize
+            shouldSave = true;
+            return Results.Ok(new PhaseTransitionResponse(player.CurrentPhase, appState.ResultsOpen));
+        }
+        finally
+        {
+            if (shouldSave)
+                await db.SaveChangesAsync();
+        }
+    }
+
+    public async Task<IResult> PrevPhaseAsync(Player player)
+    {
+        if (!player.IsAdmin)
+            return EndpointHelpers.BadRequestError("Only admins can move backward.");
+
+        var appState = await db.AppState.FirstAsync();
+        var shouldSave = EndpointHelpers.ReconcilePlayerPhase(player, appState.ResultsOpen);
+
+        try
+        {
+            player.CurrentPhase = PrevPhase(player.CurrentPhase);
+            player.VotesFinal = false;
+            shouldSave = true;
+            return Results.Ok(new PhaseTransitionResponse(player.CurrentPhase, appState.ResultsOpen));
+        }
+        finally
+        {
+            if (shouldSave)
+                await db.SaveChangesAsync();
+        }
+    }
+
+    private static Phase NextPhase(Phase current) => current switch
+    {
+        Phase.Suggest => Phase.Vote,
+        _             => Phase.Results
+    };
+
+    private static Phase PrevPhase(Phase current) => current switch
+    {
+        Phase.Results => Phase.Vote,
+        _             => Phase.Suggest
+    };
+}

Program.cs

@@ -39,6 +39,7 @@ builder.Services.AddScoped<SuggestionWorkflowService>();
 builder.Services.AddScoped<VoteWorkflowService>();
 builder.Services.AddScoped<AdminWorkflowService>();
 builder.Services.AddScoped<ResultsWorkflowService>();
+builder.Services.AddScoped<StateWorkflowService>();
 
 builder.Services.ConfigureHttpJsonOptions(options => { options.SerializerOptions.Converters.Add(new JsonStringEnumConverter()); });