Shogi/Shogi.Api/Repositories/SessionRepository.cs

using Dapper;
using Shogi.Api.Repositories.Dto;
using Shogi.Contracts.Api;
using Shogi.Domain;
using System.Data;
using System.Data.SqlClient;

namespace Shogi.Api.Repositories;

public class SessionRepository : ISessionRepository
{
    private readonly string connectionString;

    public SessionRepository(IConfiguration configuration)
    {
        connectionString = configuration.GetConnectionString("ShogiDatabase") ?? throw new InvalidOperationException("Database connection string not configured.");
    }

    public async Task CreateSession(Session session)
    {
        using var connection = new SqlConnection(connectionString);
        await connection.ExecuteAsync(
          "session.CreateSession",
          new
          {
              session.Name,
              Player1Name = session.Player1,
          },
          commandType: CommandType.StoredProcedure);
    }

    public async Task DeleteSession(string name)
    {
        using var connection = new SqlConnection(connectionString);
        await connection.ExecuteAsync(
          "session.DeleteSession",
          new { Name = name },
          commandType: CommandType.StoredProcedure);
    }

    public async Task<Session?> ReadSession(string name)
    {
        using var connection = new SqlConnection(connectionString);
        var results = await connection.QueryMultipleAsync(
          "session.ReadSession",
          new { Name = name },
          commandType: CommandType.StoredProcedure);

        var sessionDtos = await results.ReadAsync<SessionDto>();
        if (!sessionDtos.Any()) return null;
        var dto = sessionDtos.First();
        var session = new Session(dto.Name, dto.Player1);
        if (!string.IsNullOrWhiteSpace(dto.Player2)) session.AddPlayer2(dto.Player2);

        var moveDtos = await results.ReadAsync<MoveDto>();
        foreach (var move in moveDtos)
        {
            if (move.PieceFromHand.HasValue)
            {
                session.Board.Move(move.PieceFromHand.Value, move.To);
            }
            else if (move.From != null)
            {
                session.Board.Move(move.From, move.To, false);
            }
            else
            {
                throw new InvalidOperationException($"Corrupt data during {nameof(ReadSession)}");
            }
        }
        return session;
    }

    public async Task CreateMove(string sessionName, MovePieceCommand command)
    {
        using var connection = new SqlConnection(connectionString);
        await connection.ExecuteAsync(
          "session.CreateMove",
          new
          {
              command.To,
              command.From,
              command.IsPromotion,
              command.PieceFromHand,
              SessionName = sessionName
          },
          commandType: CommandType.StoredProcedure);
    }

    public async Task SetPlayer2(string sessionName, string player2Name)
    {
        using var connection = new SqlConnection(connectionString);
        await connection.ExecuteAsync(
            "session.SetPlayer2",
            new
            {
                SessionName = sessionName,
                Player2Name = player2Name
            },
            commandType: CommandType.StoredProcedure);
    }
}

public interface ISessionRepository
{
    Task CreateMove(string sessionName, MovePieceCommand command);
    Task CreateSession(Session session);
    Task DeleteSession(string name);
    Task<Session?> ReadSession(string name);
    Task SetPlayer2(string sessionName, string player2Name);
}