public void CreateGame(string name)
{
var actorRef = _actorSystem.ActorOf(Props.Create <PlayBoardActor>());
var playerObject = new Player(name, ConnectionId);
var gameRequest = new CreateNewGame(playerObject);
actorRef.Tell(gameRequest);
/// Accesing to the game
SelectExistingsGames(playerObject, gameRequest.Id);
}
public void UserCreateNewGame()
{
var probe = CreateTestProbe();
var playboard = Sys.ActorOf(PlayBoardActor.Props();
var game = new CreateNewGame(new Player( "Edgar Leonardo", ""));
playboard.Tell(game, probe.Ref);
var received = probe.ExpectMsg<GameRegister>();
Assert.Equal(game.Id, received.GameEventDashboard.GameId);
}
public async Task When_creating_a_game_with_a_name_valid_then_a_new_game_should_be_created()
{
var gamesRepository = Substitute.For <IGamesRepository>();
gamesRepository.AnyAsync(Arg.Any <Expression <Func <Game, bool> > >(), default).Returns(Task.FromResult(false));
var createNewGame = new CreateNewGame(gamesRepository);
var result = await createNewGame.Execute(NAME, default);
result.Should().NotBeNull();
}
public void When_creating_a_game_with_existing_name_then_a_domain_exception_should_be_thrown()
{
var gamesRepository = Substitute.For <IGamesRepository>();
gamesRepository.AnyAsync(Arg.Any <Expression <Func <Game, bool> > >(), default).Returns(Task.FromResult(true));
var createNewGame = new CreateNewGame(gamesRepository);
Func <Task <Game> > action = async() => await createNewGame.Execute(NAME, default);
action.Should().Throw <DomainException>().WithMessage(Game.NAME_MUST_UNIQUE);
}
private void CreateNewGameMethod(CreateNewGame message)
{
IActorRef actor = null;
if (_game.ContainsKey(message.Id))
{
actor = _game[message.Id];;
}
else
{
actor = Context.ActorOf(Akka.Actor.Props.Create <GameActor>(), "Game" + message.Id);
_game.Add(message.Id, actor);
}
actor.Tell(new StartNewGame(message));
Console.WriteLine("PlayBoardActor CreateNewGameMethod: Created With ID {0} With Ower {1}", message.Id, message.PlayerInfo.Name);
}
public void UserWithCreatedNewGameMustBeOwnerOfGame()
{
var probe = CreateTestProbe();
var connectionId = Guid.NewGuid().ToString();
var ownerGame = new Player( "Edgar Leonardo", connectionId);
var game = new CreateNewGame(ownerGame);
var playboard = Sys.ActorOf(PlayBoardActor.Props());
playboard.Tell(game, probe.Ref);
var received = probe.ExpectMsg<GameRegister>();
Assert.Equal(game.Id, received.GameEventDashboard.GameId);
Assert.Equal(ownerGame.Id, received.GameEventDashboard.PlayerInfo.Id);
}
public bool CreateGame(CreateNewGame model)
{
using (var ctx = new ApplicationDbContext())
{
var entity = new Game()
{
HomeTeam = ctx.Teams.Single(t => t.Name == model.HomeTeam),
AwayTeam = ctx.Teams.Single(t => t.Name == model.AwayTeam),
Date = model.Date,
// HomeTeamScore = model.HomeTeamScore,
// AwayTeamScore = model.AwayTeamScore,
};
ctx.Games.Add(entity);
return(ctx.SaveChanges() == 1);
};
}
/// <summary>Handles the message.</summary>
/// <param name="message">The message.</param>
public void Handle(CreateNewGame message)
{
events.PublishOnUIThread(new SelectedGameChanged(this, null));
Execute.OnUIThread(
() =>
{
Clear();
IsOpen = true;
if (message.ArenaSession != null)
{
ArenaSession = message.ArenaSession;
Hero = message.ArenaSession.Hero;
GameMode = GameMode.Arena;
}
});
}
public IHttpActionResult Post(CreateNewGame model)
{
var service = CreateGameService();
if (model == null)
{
return(BadRequest());
}
else
{
if (!service.CreateGame(model))
{
return(InternalServerError());
}
else
{
return(Ok());
}
}
}
public void OnCreateNewGame()
{
CreateNewGame?.Invoke();
}
public StartNewGame(CreateNewGame createGameRequest)
{
this.CreateGameRequest = createGameRequest;
}
public GameStateController(CreateNewGame createNewGame) => CreateNewGame = createNewGame;
