public Task <bool> Handle(AuthorizeNewAccountRequest request, CancellationToken cancellationToken)
{
using (_threadContextSessionProvider.CreateSessionScope())
{
var user = _botUserRepository.ListBySpecification(new UndeletedEntities <BotUser>())
.FirstOrDefault(x =>
!string.IsNullOrEmpty(x.PasswordHash) &&
BCrypt.Net.BCrypt.Verify(request.Password, x.PasswordHash));
if (user == null)
{
return(Task.FromResult(false));
}
if (user.Id == request.CurrentUserId)
{
return(Task.FromResult(true));
}
var currentUser = _botUserRepository.Get(request.CurrentUserId);
foreach (var currentUserUserAccount in currentUser.UserAccounts)
{
currentUserUserAccount.User = user;
user.UserAccounts.Add(currentUserUserAccount);
}
_botUserRepository.Save(user);
currentUser.UserAccounts.Clear();
_botUserRepository.Save(currentUser);
_botUserRepository.Delete(currentUser);
}
return(Task.FromResult(true));
}
public Task <Unit> Handle(AddPlayerToGameRequest request, CancellationToken cancellationToken)
{
using (_threadContextSessionProvider.CreateSessionScope())
{
var game = _gameRepository.Get(request.GameId);
var players = request.PlayerIds.Select(x => _playerRepository.Get(x)).ToList();
if (_serviceConfiguration.PlayersPerTeam * 2 - (game.AcceptedPlayers.Count + game.RequestedPlayers.Count) != players.Count())
{
throw new InvalidInputException($"В игре {game.DateTime} уже достаточное количество игроков");
}
game.RejectedPlayers.RemoveAll(x => players.Any(y => y.Id == x.Id));
game.RequestedPlayers.RemoveAll(x => players.Any(y => y.Id == x.Id));
foreach (var player in players)
{
game.AcceptedPlayers.Add(player);
}
_scheduler.DeleteEvent <PlayerGameAcceptanceTimeoutEventMetadata>(x =>
x.GameId == game.Id && players.Any(y => y.Id == x.PlayerId));
NotifyPlayers(players, game);
_gameRepository.Save(game);
}
return(Task.FromResult(Unit.Value));
}
public Task <Unit> Handle(ScheduledEventRequest <PlayersCollectingDeadlineEventMetadata> message,
CancellationToken cancellationToken)
{
using (_threadContextSessionProvider.CreateSessionScope())
{
var game = _gameRepository.Get(message.MetaData.GameId);
if (game.AcceptedPlayers.Count != _serviceConfiguration.PlayersPerTeam * 2)
{
_mediator.Send(new CancelGameRequest()
{
GameId = game.Id
}, cancellationToken);
}
else
{
_mediator.Send(
new ScheduledEventRequest <PlayersCollectingDeadlineEventMetadata>(
new PlayersCollectingDeadlineEventMetadata()
{
GameId = game.Id
}), cancellationToken);
}
_gameRepository.Save(game);
}
return(Task.FromResult(Unit.Value));
}
private void SetWinnerDialog(Guid gameId)
{
using (_threadContextSessionProvider.CreateSessionScope())
{
var game = _gameRepository.Get(gameId);
var teamsMessage = "Команда 1:\n";
teamsMessage += string.Join("\n",
game.DistributedPlayers.Where(x => x.TeamNumber == 1).Select((x, index) =>
$"{x.Player.User.FirstName} {x.Player.User.LastName}"));
teamsMessage += "\n\nКоманда 2:\n";
teamsMessage += string.Join("\n",
game.DistributedPlayers.Where(x => x.TeamNumber == 2).Select((x, index) =>
$"{x.Player.User.FirstName} {x.Player.User.LastName}"));
Add(teamsMessage);
Add("Введи номер победившей команды:");
Add((message1, data1) =>
{
if (!int.TryParse(message1, out var number1) || (number1 != 1 && number1 != 2))
{
throw new InvalidInputException($"Введи номер команды 1 или 2");
}
data1.TeamWinningNumber = number1;
return(data1);
});
Add("Результат внесен");
}
}
public Task <bool> Handle(PlayerStatusRequest request, CancellationToken cancellationToken)
{
using (_threadContextSessionProvider.CreateSessionScope())
{
return(Task.FromResult(_playerRepository.ListBySpecification(new UndeletedEntities <Player>()).First(x => x.User.Id == request.UserId).IsActive));
}
}
public Task <Unit> Handle(ScheduledEventRequest <DistributionByTeamsEventMetadata> message,
CancellationToken cancellationToken)
{
using (_threadContextSessionProvider.CreateSessionScope())
{
var game = _gameRepository.Get(message.MetaData.GameId);
var administrators = _botUserRepository.ListBySpecification(new UndeletedEntities <BotUser>())
.Where(x => x.Role >= EUserRole.Moderator).ToList();
if (game.AcceptedPlayers.Count != _serviceConfiguration.PlayersPerTeam * 2)
{
NotifyAboutUnsuccessfulCollecting(game, administrators);
}
else
{
DistributePlayersPerTeams(game);
NotifyAboutSuccessfulCollecting(game, game.DistributedPlayers, administrators);
NotifyPlayers(game.DistributedPlayers, game);
}
_scheduler.DeleteEvent <IGameScheduledEventMetadata>(x => x.GameId == game.Id && !(x is PlayerGameAcceptanceTimeoutEventMetadata));
_gameRepository.Save(game);
}
return(Task.FromResult(Unit.Value));
}
public Task <string> Handle(NextGameStatusRequest request, CancellationToken cancellationToken)
{
using (_threadContextSessionProvider.CreateSessionScope())
{
var game = _gameRepository.ListBySpecification(new UndeletedEntities <Game>())
.Where(x => DateTime.Now < x.DateTime && x.IsActive)
.OrderBy(x => x.DateTime)
.FirstOrDefault();
if (game == null)
{
var message = "Нет запланированной игры.";
return(Task.FromResult(message));
}
else
{
var message = $"Игра {game.DateTime}\nСогласившиеся игроки:\n";
message += string.Join("\n",
game.AcceptedPlayers.Select((x, index) =>
$"{index + 1}. {x.User.FirstName} {x.User.LastName}"));
message += "\nЗапрошенные игроки:\n";
message += string.Join("\n",
game.RequestedPlayers.Select((x, index) =>
$"{index + 1}. {x.Player.User.FirstName} {x.Player.User.LastName}"));
message += "\nОтказавшиеся игроки:\n";
message += string.Join("\n",
game.RejectedPlayers.Select((x, index) =>
$"{index + 1}. {x.User.FirstName} {x.User.LastName}"));
return(Task.FromResult(message));
}
}
}
public AddPlayerToGameRequestDialog(IEnumerable <ICommunicator> communicators, Guid userId,
AddPlayerToGameRequest dialogData,
ILogger logger, IMediator mediator, IThreadContextSessionProvider threadContextSessionProvider,
IGameRepository gameRepository, IServiceConfiguration serviceConfiguration) : base(logger, communicators,
userId, dialogData)
{
_mediator = mediator;
_threadContextSessionProvider = threadContextSessionProvider;
_gameRepository = gameRepository;
_serviceConfiguration = serviceConfiguration;
_hasDesicion = false;
using (threadContextSessionProvider.CreateSessionScope())
{
var games = gameRepository.ListBySpecification(new UndeletedEntities <Game>()).ToList();
games = games.Where(x =>
x.AcceptedPlayers.Count + x.RequestedPlayers.Count <serviceConfiguration.PlayersPerTeam * 2 &&
x.IsActive &&
x.DateTime>
DateTime.Now
.Add(
serviceConfiguration
.GameDeadline,
serviceConfiguration
.StartDayTime,
serviceConfiguration
.EndDayTime))
.OrderBy(x => x.DateTime)
.Take(20).ToList();
if (!games.Any())
{
Add($"Нет игр для добавления игроков");
}
else
{
Add($"Введи номер игры, в которую хочешь добавить игроков:");
var gamesMessage = string.Join("\n",
games.Select((x, index) =>
$"{index + 1}. Дата: {x.DateTime.ToString(DateTimeHelper.DateFormat)}"));
Add(gamesMessage);
Add((message, data) =>
{
if (!int.TryParse(message, out var number) || (number < 1 && number > games.Count()))
{
throw new InvalidInputException($"Введи номер игры от 1 до {games.Count()}");
}
data.GameId = games[number - 1].Id;
var game = games[number - 1];
AddPlayerProcessingMessages(game.Id);
return(data);
});
}
}
}
public Task <bool> Handle(CheckUniquePassword request, CancellationToken cancellationToken)
{
using (_threadContextSessionProvider.CreateSessionScope())
{
return(Task.FromResult(_botUserRepository.ListBySpecification(new UndeletedEntities <BotUser>())
.Any(x => !string.IsNullOrEmpty(x.PasswordHash) && BCrypt.Net.BCrypt.Verify(request.Password, x.PasswordHash))));
}
}
public Task <Unit> Handle(ChangePlayerStateRequest request, CancellationToken cancellationToken)
{
using (_threadContextSessionProvider.CreateSessionScope())
{
var player = _playerRepository.ListBySpecification(new UndeletedEntities <Player>()).First(x => x.User.Id == request.UserId);
player.IsActive = request.IsActive;
_playerRepository.Save(player);
}
return(Task.FromResult(Unit.Value));
}
public CancelGameRequestDialog(IEnumerable <ICommunicator> communicators, Guid userId,
CancelGameRequest dialogData,
ILogger logger, IMediator mediator, IThreadContextSessionProvider threadContextSessionProvider,
IGameRepository gameRepository, IServiceConfiguration serviceConfiguration) : base(logger, communicators,
userId, dialogData)
{
_mediator = mediator;
_hasDecision = false;
using (threadContextSessionProvider.CreateSessionScope())
{
var games = gameRepository.ListBySpecification(new UndeletedEntities <Game>()).Where(x => x.IsActive &&
x.DateTime >
DateTime.Now
.Add(
serviceConfiguration
.GameDeadline,
serviceConfiguration
.StartDayTime,
serviceConfiguration
.EndDayTime))
.OrderBy(x => x.DateTime)
.Take(20).ToList();
if (games.Count == 0)
{
Add($"Нет игр для отмены");
}
else
{
Add($"Введи номер игры, которую хочешь отменить:");
var gamesMessage = string.Join("\n",
games.Select((x, index) =>
$"{index + 1}. Дата: {x.DateTime.ToString(DateTimeHelper.DateFormat)}"));
Add(gamesMessage);
Add((message, data) =>
{
if (!int.TryParse(message, out var number) || (number < 1 && number > games.Count()))
{
throw new InvalidInputException($"Введи номер игры от 1 до {games.Count()}");
}
_hasDecision = true;
data.GameId = games[number - 1].Id;
return(data);
});
}
}
}
public Task <Unit> Handle(CancelGameRequest request, CancellationToken cancellationToken)
{
using (_threadContextSessionProvider.CreateSessionScope())
{
var game = _gameRepository.Get(request.GameId);
var administrators = _botUserRepository.ListBySpecification(new UndeletedEntities <BotUser>())
.Where(x => x.Role >= EUserRole.Moderator).ToList();
NotifyAboutUnsuccessfulCollecting(game, administrators);
NotifyPlayers(game);
_scheduler.DeleteEvent <IGameScheduledEventMetadata>(x => x.GameId == game.Id);
game.IsActive = false;
_gameRepository.Save(game);
}
return(Task.FromResult(Unit.Value));
}
public Task <Unit> Handle(ScheduledEventRequest <PlayerGameAcceptanceTimeoutEventMetadata> message,
CancellationToken cancellationToken)
{
using (_threadContextSessionProvider.CreateSessionScope())
{
var player = _playerRepository.Get(message.MetaData.PlayerId);
_userInteractionService.StopDialog(player.User);
_userInteractionService.SendMessage("Ты не успел принять игру", player.User);
}
_mediator.Send(new PlayerGameDecisionRequest()
{
GameId = message.MetaData.GameId, PlayerId = message.MetaData.PlayerId, Decision = false
});
return(Task.FromResult(Unit.Value));
}
public Task <Unit> Handle(ScheduledEventRequest <PrimaryCollectingEventMetadata> message,
CancellationToken cancellationToken)
{
using (_threadContextSessionProvider.CreateSessionScope())
{
var game = _gameRepository.Get(message.MetaData.GameId);
game.SortedPlayersByRating = GetSortedPlayers();
var requestedPlayers = game.SortedPlayersByRating.Take(_serviceConfiguration.PlayersPerTeam * 2);
foreach (var requestedPlayer in requestedPlayers)
{
game.RequestedPlayers.Add(RequestPlayer(requestedPlayer, game.Id));
}
_gameRepository.Save(game);
}
return(Task.FromResult(Unit.Value));
}
public Task <Unit> Handle(BindUserToPlayerRequest request, CancellationToken cancellationToken)
{
using (_threadContextSessionProvider.CreateSessionScope())
{
var user = _botUserRepository.Get(request.UserId);
user.Role = EUserRole.Player;
_botUserRepository.Save(user);
_playerRepository.Save(new Player()
{
Id = Guid.NewGuid(),
User = user,
ParticipationRatio = request.ParticipationRatio,
IsActive = request.IsActive,
SkillValue = request.SkillValue
});
_logger.Info($"[{user.Id}]: Player added");
}
return(Unit.Task);
}
public Task <Unit> Handle(RegisterRequest request, CancellationToken cancellationToken)
{
using (_threadContextSessionProvider.CreateSessionScope())
{
var users = _botUserRepository.ListBySpecification(new UndeletedEntities <BotUser>()).ToList();
if (users.Count() > MaxUsersCount)
{
throw new ArgumentOutOfRangeException("—оздано максимальное количество пользователей");
}
var user = GetUserByCommunicator(request.Communicator, users);
if (user == null)
{
user = new BotUser()
{
Id = Guid.NewGuid(),
FirstName = request.FirstName,
LastName = request.LastName,
Role = EUserRole.User,
UserAccounts = new List <BaseAccount>(),
PasswordHash = BCrypt.Net.BCrypt.HashPassword(request.Password)
};
user.UserAccounts.Add(GetAccount(request.Communicator, user));
_logger.Info("User added");
}
else
{
user.FirstName = request.FirstName;
user.LastName = request.LastName;
if (user.Role == EUserRole.UnregisteredUser)
{
user.Role = EUserRole.User;
}
user.PasswordHash = BCrypt.Net.BCrypt.HashPassword(request.Password);
_logger.Info("User updated");
}
_botUserRepository.Save(user);
}
return(Unit.Task);
}
private void AddPlayerProcessingMessages(Guid gameId)
{
using (_threadContextSessionProvider.CreateSessionScope())
{
var game = _gameRepository.Get(gameId);
var playersForAdd = game.SortedPlayersByRating
.Where(x => game.AcceptedPlayers.All(y => y.User.Id != x.Player.User.Id)).ToList();
var playersMessage = "Игроки:\n" + string.Join("\n",
playersForAdd.Select((x, index) =>
$"{index + 1}. {x.Player.User.FirstName} {x.Player.User.LastName}"));
Add(playersMessage);
Add("Введи номера через запятую без пробела, например \"1,3,2\"");
Add((message, data) =>
{
var stringNumbers = message.Split(',');
var numbers = new List <int>();
foreach (var stringNumber in stringNumbers)
{
if (!int.TryParse(stringNumber, out var number) || (number < 1 && number > playersForAdd.Count))
{
throw new InvalidInputException(
$"Не распознал {stringNumber}. Введи номера через запятую без пробела, например \"1,3,2\"");
}
numbers.Add(number);
}
var freePlacesCount = _serviceConfiguration.PlayersPerTeam * 2 - game.AcceptedPlayers.Count;
if (numbers.Count > freePlacesCount)
{
throw new InvalidInputException($"Свободно {freePlacesCount} мест. Но ты ввел {numbers.Count}");
}
data.PlayerIds = playersForAdd.Where((x, y) => numbers.Contains(y + 1)).Select(x => x.Player.Id)
.ToList();
_hasDesicion = true;
return(data);
});
}
}
public Task <Unit> Handle(PlayerGameDecisionRequest request, CancellationToken cancellationToken)
{
using (_threadContextSessionProvider.CreateSessionScope())
{
var player = _playerRepository.Get(request.PlayerId);
var game = _gameRepository.Get(request.GameId);
if (request.Decision)
{
ProcessAccept(game, player);
}
else
{
ProcessReject(game, player);
}
_gameRepository.Save(game);
}
return(Task.FromResult(Unit.Value));
}
public Task <Unit> Handle(SetGameResultRequest request, CancellationToken cancellationToken)
{
using (_threadContextSessionProvider.CreateSessionScope())
{
var game = _gameRepository.Get(request.GameId);
var notPlayedPlayers = _playerRepository.ListBySpecification(new UndeletedEntities <Player>())
.Where(x => x.IsActive && game.AcceptedPlayers.All(y => y.User.Id != x.User.Id)).ToList();
game.ResultSet = true;
game.GoalDifference = request.GoalDifference;
game.TeamWinnerNumber = request.TeamWinningNumber;
foreach (var player in game.DistributedPlayers)
{
if (player.TeamNumber == request.TeamWinningNumber)
{
player.Player.SkillValue += request.GoalDifference;
}
else
{
player.Player.SkillValue -= request.GoalDifference;
}
player.Player.ParticipationRatio++;
if (player.Player.ParticipationRatio > 20)
{
player.Player.ParticipationRatio = 20;
}
_playerRepository.Save(player.Player);
}
DecreaseParticipation(notPlayedPlayers);
_gameRepository.Save(game);
}
return(Task.FromResult(Unit.Value));
}
public Task <Unit> Handle(ScheduleGameRequest request, CancellationToken cancellationToken)
{
using (_threadContextSessionProvider.CreateSessionScope())
{
_logger.Trace($"Schedule game at {request.DateTime}");
var game = new Game()
{
DateTime = request.DateTime,
IsActive = true
};
game.MarkAsNew();
_gameRepository.Save(game);
_scheduler.AddEvent(new PrimaryCollectingEventMetadata()
{
GameId = game.Id
},
request.DateTime.Subtract(_configuration.StartGameProcess, _configuration.StartDayTime,
_configuration.EndDayTime));
_scheduler.AddEvent(new DistributionByTeamsEventMetadata()
{
GameId = game.Id
},
request.DateTime.Subtract(_configuration.GameScheduleThreshold, _configuration.StartDayTime,
_configuration.EndDayTime));
_scheduler.AddEvent(new PlayersCollectingDeadlineEventMetadata()
{
GameId = game.Id
},
request.DateTime.Subtract(_configuration.GameDeadline, _configuration.StartDayTime,
_configuration.EndDayTime));
_logger.Trace($"Game date - {request.DateTime}");
return(Unit.Task);
}
}
public Task <BotUser> Handle(AuthorizeRequest request, CancellationToken cancellationToken)
{
using (_threadContextSessionProvider.CreateSessionScope())
{
var users = _botUserRepository.ListBySpecification(new UndeletedEntities <BotUser>());
var user = GetUserByCommunicator(request.Communicator,
_botUserRepository.ListBySpecification(new UndeletedEntities <BotUser>()));
if (user == null)
{
user = new BotUser()
{
Id = Guid.NewGuid(),
Role = EUserRole.UnregisteredUser
};
user.UserAccounts.Add(GetAccount(request.Communicator, user));
_logger.Info("User added");
_botUserRepository.Save(user);
}
return(Task.FromResult(user));
}
}
public PlayerGameDecisionRequestDialog(IEnumerable <ICommunicator> communicators, Guid userId, PlayerGameDecisionRequest dialogData,
ILogger logger, IMediator mediator, IThreadContextSessionProvider threadContextSessionProvider,
IGameRepository gameRepository) : base(logger, communicators,
userId, dialogData)
{
_mediator = mediator;
using (threadContextSessionProvider.CreateSessionScope())
{
var game = gameRepository.Get(dialogData.GameId);
Add($"Играешь {game.DateTime}? (Ответь - \"да\" или \"нет\" или отмени диалог командой - /cancel. Если отменишь диалог, то принять решение можно немного позже, используя команды - /accept, /reject)");
Add((message, data) =>
{
if (!message.CaseInsensitiveContains("да") && !message.CaseInsensitiveContains("нет"))
{
throw new InvalidInputException("Введи \"да\" или \"нет\"");
}
if (message.CaseInsensitiveContains("да"))
{
data.Decision = true;
}
if (message.CaseInsensitiveContains("нет"))
{
data.Decision = false;
}
return(data);
});
Add($"Твой ответ учтен");
}
}
public PlayerGameDeferedDecisionRequestDialog(IEnumerable <ICommunicator> communicators, Guid userId,
PlayerGameDecisionRequest dialogData,
ILogger logger, IMediator mediator, IThreadContextSessionProvider threadContextSessionProvider,
IGameRepository gameRepository, IServiceConfiguration serviceConfiguration, bool decision) : base(logger,
communicators,
userId, dialogData)
{
_hasDecision = false;
_mediator = mediator;
using (threadContextSessionProvider.CreateSessionScope())
{
var games = gameRepository.ListBySpecification(new UndeletedEntities <Game>()).ToList();
games = games.Where(x => x.IsActive &&
x.DateTime >
DateTime.Now
.Add(
serviceConfiguration
.GameDeadline,
serviceConfiguration
.StartDayTime,
serviceConfiguration
.EndDayTime))
.OrderBy(x => x.DateTime)
.ToList();
games = decision
? games.Where(x => x.RequestedPlayers.Any(y => y.Player.User.Id == userId)).Take(20).ToList()
: games.Where(x => x.AcceptedPlayers.Any(y => y.User.Id == userId)).Take(20).ToList();
if (games.Count == 0)
{
Add($"Нет игр, по которым ты можешь выбрать решение");
}
else
{
var decisionMessage = decision ? "которую хочешь принять" : "от которой хочешь отказаться";
Add($"Введи номер игры, {decisionMessage}:");
var gamesMessage = string.Join("\n",
games.Select((x, index) =>
$"{index + 1}. Дата: {x.DateTime.ToString(DateTimeHelper.DateFormat)}"));
Add(gamesMessage);
Add((message, data) =>
{
if (!int.TryParse(message, out var number) || (number < 1 && number > games.Count()))
{
throw new InvalidInputException($"Введи номер игры от 1 до {games.Count()}");
}
_hasDecision = true;
data.GameId = games[number - 1].Id;
data.Decision = decision;
data.PlayerId = games[number - 1].AcceptedPlayers.First(x => x.User.Id == userId).Id;
return(data);
});
}
}
}
public SetGameResultRequestDialog(IEnumerable <ICommunicator> communicators, Guid userId,
SetGameResultRequest dialogData,
ILogger logger, IMediator mediator, IThreadContextSessionProvider threadContextSessionProvider,
IGameRepository gameRepository) : base(logger, communicators,
userId, dialogData)
{
_mediator = mediator;
_threadContextSessionProvider = threadContextSessionProvider;
_gameRepository = gameRepository;
using (threadContextSessionProvider.CreateSessionScope())
{
var games = gameRepository.ListBySpecification(new UndeletedEntities <Game>())
.Where(x => DateTime.Now > x.DateTime && !x.ResultSet).ToList();
if (!games.Any())
{
Add($"Нет игр для внесения результата");
}
else
{
var startMessage = $"Игры без результатов:\n";
startMessage += string.Join("\n", games.Select((x, index) => $"{index + 1}. {x.DateTime}"));
Add(startMessage);
Add("Введи номер игры, по которой хочешь внести результат");
Add((message, data) =>
{
if (!int.TryParse(message, out var number) || (number < 1 && number > games.Count()))
{
throw new InvalidInputException($"Введи номер игры от 1 до {games.Count()}");
}
data.GameId = games[number - 1].Id;
return(data);
});
Add("Введи нразницу голов:");
var goalDifference = 0;
Add((message, data) =>
{
if (!int.TryParse(message, out var number) || number < 0)
{
throw new InvalidInputException($"Введи положительное число");
}
data.GoalDifference = number;
goalDifference = number;
if (goalDifference == 0)
{
data.TeamWinningNumber = 1;
}
else
{
SetWinnerDialog(data.GameId);
}
return(data);
});
}
}
}