Before changing Piece[,] to Dictionary<string,Piece>

Gameboard.ShogiUI.Sockets/Services/RequestValidators/CreateGameRequestValidator.cs

@@ -0,0 +1,15 @@
+using FluentValidation;
+using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Messages;
+using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Types;
+
+namespace Gameboard.ShogiUI.Sockets.Services.RequestValidators
+{
+  public class CreateGameRequestValidator : AbstractValidator<CreateGameRequest>
+  {
+    public CreateGameRequestValidator()
+    {
+      RuleFor(_ => _.Action).Equal(ClientAction.CreateGame);
+      RuleFor(_ => _.GameName).NotEmpty();
+    }
+  }
+}

Gameboard.ShogiUI.Sockets/Services/RequestValidators/JoinByCodeRequestValidator.cs

@@ -0,0 +1,15 @@
+using FluentValidation;
+using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Messages;
+using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Types;
+
+namespace Gameboard.ShogiUI.Sockets.Services.RequestValidators
+{
+  public class JoinByCodeRequestValidator : AbstractValidator<JoinByCodeRequest>
+  {
+    public JoinByCodeRequestValidator()
+    {
+      RuleFor(_ => _.Action).Equal(ClientAction.JoinByCode);
+      RuleFor(_ => _.JoinCode).NotEmpty();
+    }
+  }
+}

Gameboard.ShogiUI.Sockets/Services/RequestValidators/JoinGameRequestValidator.cs

@@ -0,0 +1,15 @@
+using FluentValidation;
+using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Messages;
+using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Types;
+
+namespace Gameboard.ShogiUI.Sockets.Services.RequestValidators
+{
+  public class JoinGameRequestValidator : AbstractValidator<JoinGameRequest>
+  {
+    public JoinGameRequestValidator()
+    {
+      RuleFor(_ => _.Action).Equal(ClientAction.JoinGame);
+      RuleFor(_ => _.GameName).NotEmpty();
+    }
+  }
+}

Gameboard.ShogiUI.Sockets/Services/RequestValidators/ListGamesRequestValidator.cs

@@ -0,0 +1,14 @@
+using FluentValidation;
+using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Messages;
+using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Types;
+
+namespace Gameboard.ShogiUI.Sockets.Services.RequestValidators
+{
+  public class ListGamesRequestValidator : AbstractValidator<ListGamesRequest>
+  {
+    public ListGamesRequestValidator()
+    {
+      RuleFor(_ => _.Action).Equal(ClientAction.ListGames);
+    }
+  }
+}

Gameboard.ShogiUI.Sockets/Services/RequestValidators/LoadGameRequestValidator.cs

@@ -0,0 +1,15 @@
+using FluentValidation;
+using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Messages;
+using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Types;
+
+namespace Gameboard.ShogiUI.Sockets.Services.RequestValidators
+{
+  public class LoadGameRequestValidator : AbstractValidator<LoadGameRequest>
+  {
+    public LoadGameRequestValidator()
+    {
+      RuleFor(_ => _.Action).Equal(ClientAction.LoadGame);
+      RuleFor(_ => _.GameName).NotEmpty();
+    }
+  }
+}

Gameboard.ShogiUI.Sockets/Services/RequestValidators/MoveRequestValidator.cs

@@ -0,0 +1,23 @@
+using FluentValidation;
+using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Messages;
+using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Types;
+
+namespace Gameboard.ShogiUI.Sockets.Services.RequestValidators
+{
+  public class MoveRequestValidator : AbstractValidator<MoveRequest>
+  {
+    public MoveRequestValidator()
+    {
+      RuleFor(_ => _.Action).Equal(ClientAction.Move);
+      RuleFor(_ => _.GameName).NotEmpty();
+      RuleFor(_ => _.Move.From)
+        .Null()
+        .When(_ => _.Move.PieceFromCaptured.HasValue)
+        .WithMessage("Move.From and Move.PieceFromCaptured are mutually exclusive properties.");
+      RuleFor(_ => _.Move.From)
+        .NotEmpty()
+        .When(_ => !_.Move.PieceFromCaptured.HasValue)
+        .WithMessage("Move.From and Move.PieceFromCaptured are mutually exclusive properties.");
+    }
+  }
+}

Gameboard.ShogiUI.Sockets/Services/SocketService.cs

@@ -0,0 +1,194 @@
+using FluentValidation;
+using Gameboard.ShogiUI.Sockets.Extensions;
+using Gameboard.ShogiUI.Sockets.Managers;
+using Gameboard.ShogiUI.Sockets.Managers.ClientActionHandlers;
+using Gameboard.ShogiUI.Sockets.Managers.Utility;
+using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Interfaces;
+using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Messages;
+using Gameboard.ShogiUI.Sockets.ServiceModels.Socket.Types;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+using System;
+using System.Linq;
+using System.Net;
+using System.Net.WebSockets;
+using System.Threading.Tasks;
+
+namespace Gameboard.ShogiUI.Sockets.Services
+{
+  public interface ISocketService
+  {
+    Task HandleSocketRequest(HttpContext context);
+  }
+
+  /// <summary>
+  /// Services a single websocket connection. Authenticates the socket connection, accepts messages, and sends messages.
+  /// </summary>
+  public class SocketService : ISocketService
+  {
+    private readonly ILogger<SocketService> logger;
+    private readonly ISocketConnectionManager communicationManager;
+    private readonly ISocketTokenManager tokenManager;
+    private readonly ICreateGameHandler createGameHandler;
+    private readonly IJoinByCodeHandler joinByCodeHandler;
+    private readonly IJoinGameHandler joinGameHandler;
+    private readonly IListGamesHandler listGamesHandler;
+    private readonly ILoadGameHandler loadGameHandler;
+    private readonly IMoveHandler moveHandler;
+    private readonly IValidator<CreateGameRequest> createGameRequestValidator;
+    private readonly IValidator<JoinByCodeRequest> joinByCodeRequestValidator;
+    private readonly IValidator<JoinGameRequest> joinGameRequestValidator;
+    private readonly IValidator<ListGamesRequest> listGamesRequestValidator;
+    private readonly IValidator<LoadGameRequest> loadGameRequestValidator;
+    private readonly IValidator<MoveRequest> moveRequestValidator;
+
+    public SocketService(
+      ILogger<SocketService> logger,
+      ISocketConnectionManager communicationManager,
+      ISocketTokenManager tokenManager,
+      ICreateGameHandler createGameHandler,
+      IJoinByCodeHandler joinByCodeHandler,
+      IJoinGameHandler joinGameHandler,
+      IListGamesHandler listGamesHandler,
+      ILoadGameHandler loadGameHandler,
+      IMoveHandler moveHandler,
+      IValidator<CreateGameRequest> createGameRequestValidator,
+      IValidator<JoinByCodeRequest> joinByCodeRequestValidator,
+      IValidator<JoinGameRequest> joinGameRequestValidator,
+      IValidator<ListGamesRequest> listGamesRequestValidator,
+      IValidator<LoadGameRequest> loadGameRequestValidator,
+      IValidator<MoveRequest> moveRequestValidator
+      ) : base()
+    {
+      this.logger = logger;
+      this.communicationManager = communicationManager;
+      this.tokenManager = tokenManager;
+      this.createGameHandler = createGameHandler;
+      this.joinByCodeHandler = joinByCodeHandler;
+      this.joinGameHandler = joinGameHandler;
+      this.listGamesHandler = listGamesHandler;
+      this.loadGameHandler = loadGameHandler;
+      this.moveHandler = moveHandler;
+      this.createGameRequestValidator = createGameRequestValidator;
+      this.joinByCodeRequestValidator = joinByCodeRequestValidator;
+      this.joinGameRequestValidator = joinGameRequestValidator;
+      this.listGamesRequestValidator = listGamesRequestValidator;
+      this.loadGameRequestValidator = loadGameRequestValidator;
+      this.moveRequestValidator = moveRequestValidator;
+    }
+
+    public async Task HandleSocketRequest(HttpContext context)
+    {
+      var hasToken = context.Request.Query.Keys.Contains("token");
+      if (hasToken)
+      {
+        var oneTimeToken = context.Request.Query["token"][0];
+        var tokenAsGuid = Guid.Parse(oneTimeToken);
+        var userName = tokenManager.GetUsername(tokenAsGuid);
+        if (userName != null)
+        {
+          var socket = await context.WebSockets.AcceptWebSocketAsync();
+
+          communicationManager.SubscribeToBroadcast(socket, userName);
+          while (socket.State == WebSocketState.Open)
+          {
+            try
+            {
+              var message = await socket.ReceiveTextAsync();
+              if (string.IsNullOrWhiteSpace(message)) continue;
+              logger.LogInformation("Request \n{0}\n", message);
+              var request = JsonConvert.DeserializeObject<Request>(message);
+              if (!Enum.IsDefined(typeof(ClientAction), request.Action))
+              {
+                await socket.SendTextAsync("Error: Action not recognized.");
+                continue;
+              }
+              switch (request.Action)
+              {
+                case ClientAction.ListGames:
+                  {
+                    var req = JsonConvert.DeserializeObject<ListGamesRequest>(message);
+                    if (await ValidateRequestAndReplyIfInvalid(socket, listGamesRequestValidator, req))
+                    {
+                      await listGamesHandler.Handle(req, userName);
+                    }
+                    break;
+                  }
+                case ClientAction.CreateGame:
+                  {
+                    var req = JsonConvert.DeserializeObject<CreateGameRequest>(message);
+                    if (await ValidateRequestAndReplyIfInvalid(socket, createGameRequestValidator, req))
+                    {
+                      await createGameHandler.Handle(req, userName);
+                    }
+                    break;
+                  }
+                case ClientAction.JoinGame:
+                  {
+                    var req = JsonConvert.DeserializeObject<JoinGameRequest>(message);
+                    if (await ValidateRequestAndReplyIfInvalid(socket, joinGameRequestValidator, req))
+                    {
+                      await joinGameHandler.Handle(req, userName);
+                    }
+                    break;
+                  }
+                case ClientAction.JoinByCode:
+                  {
+                    var req = JsonConvert.DeserializeObject<JoinByCodeRequest>(message);
+                    if (await ValidateRequestAndReplyIfInvalid(socket, joinByCodeRequestValidator, req))
+                    {
+                      await joinByCodeHandler.Handle(req, userName);
+                    }
+                    break;
+                  }
+                case ClientAction.LoadGame:
+                  {
+                    var req = JsonConvert.DeserializeObject<LoadGameRequest>(message);
+                    if (await ValidateRequestAndReplyIfInvalid(socket, loadGameRequestValidator, req))
+                    {
+                      await loadGameHandler.Handle(req, userName);
+                    }
+                    break;
+                  }
+                case ClientAction.Move:
+                  {
+                    var req = JsonConvert.DeserializeObject<MoveRequest>(message);
+                    if (await ValidateRequestAndReplyIfInvalid(socket, moveRequestValidator, req))
+                    {
+                      await moveHandler.Handle(req, userName);
+                    }
+                    break;
+                  }
+              }
+            }
+            catch (OperationCanceledException ex)
+            {
+              logger.LogError(ex.Message);
+            }
+            catch (WebSocketException ex)
+            {
+              logger.LogInformation($"{nameof(WebSocketException)} in {nameof(SocketConnectionManager)}.");
+              logger.LogInformation("Probably tried writing to a closed socket.");
+              logger.LogError(ex.Message);
+            }
+          }
+          communicationManager.UnsubscribeFromBroadcastAndGames(userName);
+          return;
+        }
+      }
+      context.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
+      return;
+    }
+
+    public async Task<bool> ValidateRequestAndReplyIfInvalid<TRequest>(WebSocket socket, IValidator<TRequest> validator, TRequest request)
+    {
+      var results = validator.Validate(request);
+      if (!results.IsValid)
+      {
+        await socket.SendTextAsync(string.Join('\n', results.Errors.Select(_ => _.ErrorMessage).ToString()));
+      }
+      return results.IsValid;
+    }
+  }
+}