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");
  }

  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, Contracts.Api.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 interface ISessionRepository
{
  Task CreateMove(string sessionName, MovePieceCommand command);
  Task CreateSession(Session session);
  Task DeleteSession(string name);
  Task<Session?> ReadSession(string name);
}