public void AddPlayer()
{
//Kod som lägger till spelare för spel
if (IsPlayerAlreadyAdded() == true && IsAddPlayerAvailable() == true)
{
_selectedPlayers.Add(Selected_player);
StartGameCommand.RaiseCanExecuteChanged();
AddPlayerCommand.RaiseCanExecuteChanged();
PropertyChanged(this, new PropertyChangedEventArgs("Selected_players"));
players.Remove(Selected_player);
Available_players = new ObservableCollection <Player>(players.OrderBy(x => x.Nickname).ToList());
OnPropertyChanged(new PropertyChangedEventArgs("Available_players"));
}
else if (Selected_players.Count == 4)
{
MessageBox.Show("Du kan inte lägga till fler spelare \nmax antalet spelare har redan uppnåtts");
}
else
{
MessageBox.Show("Spelaren är redan tillagd för spel");
}
}
public async Task Handle_GivenInvalidRequest_ShouldThrowTeamIsFullException()
{
// Arrange
var command = new AddPlayerCommand {
TeamId = 1, PlayerId = "Foo5"
};
var playerTeamsRepository = new EfDeletableEntityRepository <PlayerTeam>(this.dbContext);
var sut = new AddPlayerCommandHandler(this.deletableEntityRepository, playerTeamsRepository);
for (int i = 0; i < 10; i++)
{
var player = new Player {
UserName = $"Placeholder{i}", Email = "foomail.bg",
};
this.dbContext.Add(player);
this.dbContext.PlayerTeams.Add(new PlayerTeam {
TeamId = 1, PlayerId = player.Id
});
this.dbContext.SaveChanges();
}
// Act & Assert
await Should.ThrowAsync <TeamIsFullException>(sut.Handle(command, It.IsAny <CancellationToken>()));
}
/// <summary>
/// コマンド実行可否判定呼出
/// </summary>
private void RaiseCommandCanExecute()
{
StartGameCommand.RaiseCanExecuteChanged();
StopGameCommand.RaiseCanExecuteChanged();
AddPlayerCommand.RaiseCanExecuteChanged();
DelPlayerCommand.RaiseCanExecuteChanged();
}
public async Task AddPlayerCommand_Can_Add_Player()
{
var dbContext = GetDbContext("AddPlayerCommand_Can_Add_Player");
using (dbContext)
{
var fakeRepo = new PlayerRepository(dbContext);
var fakeLogger = new Mock <ILogger <AddPlayerCommandHandler> >();
var handler = new AddPlayerCommandHandler(fakeRepo, GetMapper(), fakeLogger.Object);
var command = new AddPlayerCommand
{
Name = "FirstName",
Surname = "LastName",
Height = 1.98,
EmailAddress = "*****@*****.**"
};
var result = await handler.Handle(command, default);
Assert.False(result.Notifications.HasErrors());
Assert.Equal(command.Name, result.PlayerLookupModel.Name);
Assert.Equal(command.Surname, result.PlayerLookupModel.Surname);
Assert.Equal(command.Height, result.PlayerLookupModel.Height);
Assert.Equal(command.EmailAddress, result.PlayerLookupModel.EmailAddress);
}
}
public async Task <ApiResponse> Add([FromBody] AddPlayerCommand command)
{
DefaultEntityCommandResponse <Com.BinaryBracket.BowlsResults.Common.Domain.Entities.Player> response = await this._addPlayerCommandHandler.Handle(command);
var apiResponse = this.BuildApiResponse(response);
apiResponse.Result = response.Entity.AssembleDto();
return(apiResponse);
}
public AddPlayerScreenVM(Navigator navigator) : base(navigator)
{
this.players = new List <string>();
GotToIntroductionScreen = new SwitchScreenCommand(() => SwitchTo(new IntroductionPlayScreenVM(navigator, players)));
name = "Name";
added = false;
AddPlayer = new AddPlayerCommand(name, playerLibrary, players, added);
}
public ApplicationArchiVR applicationArchiVR; // TODO: Design defect: this should be 'private' but because of unit testing we cannot make it so!
#endregion
/// <summary>
/// <see cref="Client"/> implementation.
/// </summary>
override protected void OnConnect()
{
_log.Warning(string.Format("{0}.OnConnect: Notify server about my player {1}", LogID, applicationArchiVR.Player.LogID));
// Notify other Clients about existence of your own player.
var addPlayerCommand = new AddPlayerCommand(applicationArchiVR.Player);
SendCommand(addPlayerCommand);
}
public async Task <IHttpActionResult> Save(AddPlayerCommand player)
{
if (player == null)
{
return(BadRequest("Player data is required in body of request."));
}
return(Ok(await _playerPersistence.Save(new Player(player.Name, player.ChampionId, player.ZoneId, player.GameId))));
}
public void AfterEach()
{
var container = TestBootstrapper.BuildContainer();
_controller = container.Resolve <PlayerController>();
_factory = container.Resolve <PlayerFactory>();
_addPlayerCommand = _factory.CreateAddPlayerCommand();
}
public void ConstructorShould_ReturnInstanceOfAddPLayerCommandClass_WhenThePassedValuesAreValid()
{
var providerMock = new Mock <ISqlServerDataProvider>();
var writerMock = new Mock <IWriter>();
var factoryMock = new Mock <IModelsFactory>();
var command = new AddPlayerCommand(providerMock.Object, writerMock.Object, factoryMock.Object);
Assert.IsInstanceOf <AddPlayerCommand>(command);
}
public void AddPlayerCommandValidator_NicknameIsValid_ValidationPassed(string name)
{
var model = new AddPlayerCommand
{
Nickname = name
};
var result = _validator.TestValidate(model);
result.ShouldNotHaveValidationErrorFor(p => p.Nickname);
}
public async Task Handle_GivenInvalidRequest_ShouldThrowPlayerCannotBeAMemeberOfMultipleTeamsWithTheSameFormatException()
{
// Arrange
var command = new AddPlayerCommand {
TeamId = 1, PlayerId = "Foo2"
};
var playerTeamsRepository = new EfDeletableEntityRepository <PlayerTeam>(this.dbContext);
var sut = new AddPlayerCommandHandler(this.deletableEntityRepository, playerTeamsRepository);
// Act & Assert
await Should.ThrowAsync <PlayerCannotBeAMemeberOfMultipleTeamsWithTheSameFormatException>(sut.Handle(command, It.IsAny <CancellationToken>()));
}
public async Task Handle_GivenInvalidRequest_ShouldThrowNotFoundException()
{
// Arrange
var command = new AddPlayerCommand {
TeamId = 313, PlayerId = "Foo5"
};
var playerTeamsRepository = new EfDeletableEntityRepository <PlayerTeam>(this.dbContext);
var sut = new AddPlayerCommandHandler(this.deletableEntityRepository, playerTeamsRepository);
// Act & Assert
await Should.ThrowAsync <NotFoundException>(sut.Handle(command, It.IsAny <CancellationToken>()));
}
public void AddPlayerCommandValidator_NicknameIsInvalid_ValidationErrorThrown(string name, string errorMessage)
{
var model = new AddPlayerCommand
{
Nickname = name
};
var result = _validator.TestValidate(model);
result.ShouldHaveValidationErrorFor(p => p.Nickname)
.WithErrorMessage(errorMessage);
}
public void ExecuteShould_ClearTheScreenOneTIme()
{
var providerMock = new Mock <ISqlServerDataProvider>();
var writerMock = new Mock <IWriter>();
var factoryMock = new Mock <IModelsFactory>();
var command = new AddPlayerCommand(providerMock.Object, writerMock.Object, factoryMock.Object);
command.Execute(new List <string>());
writerMock.Verify(x => x.Clear(), Times.Once);
}
public void ExecuteShould_ReturnNotEnoughParametersWhenNoParametersProvided()
{
var providerMock = new Mock <ISqlServerDataProvider>();
var writerMock = new Mock <IWriter>();
var factoryMock = new Mock <IModelsFactory>();
var command = new AddPlayerCommand(providerMock.Object, writerMock.Object, factoryMock.Object);
string result = command.Execute(new List <string>());
Assert.That(result.Contains("Not enough parameters!"));
}
public void ExecuteShould_ThrowArgumentNullExceptionIfPlayerCannotBeCreated()
{
var providerMock = new Mock <ISqlServerDataProvider>();
var writerMock = new Mock <IWriter>();
var factoryMock = new Mock <IModelsFactory>();
var command = new AddPlayerCommand(providerMock.Object, writerMock.Object, factoryMock.Object);
Assert.Throws <ArgumentNullException>(() => command.Execute(new List <string>()
{
"Novak", "Jokovic"
}));
}
public Client(GameHost host, string playerName, IFactory factory, ICommandSerializer serializer)
{
Factory = factory;
Serializer = serializer;
MessengerSet = Factory.CreatePlayerMessengerSet(host, playerName);
MessengerSet.ServerCommands.MessageReceived += ServerCommands_MessageReceived;
var cmd = new AddPlayerCommand()
{
PlayerName = playerName
};
MessengerSet.ServerCommands.Send(Serializer.Serialize(cmd));
}
public async Task <AddPlayerResponse> Handle(AddPlayerRequest request, CancellationToken cancellationToken)
{
var player = this.mapper.Map <DataAccess.Entities.Player>(request);
var command = new AddPlayerCommand()
{
Parameter = player
};
var playerFromDb = await this.commandExecutor.Execute(command);
return(new AddPlayerResponse()
{
Data = this.mapper.Map <Domain.Models.Player>(playerFromDb)
});
}
public void AddPlayerCommandHandler(object args)
{
AvailablePlayers.Add(
new Player
{
FullName = NewPlayerName,
DCINumber = NewPlayerDCINumber,
EmailAddress = NewPlayerEmailAddress,
PhoneNumber = NewPlayerPhoneNumber
});
AddPlayerCommand.RaiseCanExecuteChanged();
OnPropertyChanged("AvailablePlayers");
OnPropertyChanged("FilteredAvailablePlayers");
}
public ActionResult Add(AddPlayerCommand command)
{
if (ModelState.IsValid)
{
logger.InfoFormat("Add Save {0}", command.Name);
_addPlayerCommand.Handle(command);
return(RedirectToAction("Index"));
}
var model = GetAddData();
model.Command = command;
return(View(model));
}
public async Task Handle_GivenValidRequest_ShouldAddPlayerToTeam()
{
// Arrange
var command = new AddPlayerCommand {
TeamId = 1, PlayerId = "Foo5"
};
var playerTeamsRepository = new EfDeletableEntityRepository <PlayerTeam>(this.dbContext);
var sut = new AddPlayerCommandHandler(this.deletableEntityRepository, playerTeamsRepository);
// Act
var affectedRows = await sut.Handle(command, It.IsAny <CancellationToken>());
// Assert
affectedRows.ShouldBeGreaterThan(0);
var isPlayerPresent = playerTeamsRepository.AllAsNoTracking().Any(x => x.PlayerId == "Foo5" && x.TeamId == 1);
isPlayerPresent.ShouldBe(true);
}
public void ExecuteShould_CallCreatePlayerWhen2OrMoreParametersProvidedProvided()
{
var providerMock = new Mock <ISqlServerDataProvider>();
var writerMock = new Mock <IWriter>();
var factoryMock = new Mock <IModelsFactory>();
var command = new AddPlayerCommand(providerMock.Object, writerMock.Object, factoryMock.Object);
try
{
command.Execute(new List <string>()
{
"Novak", "Jokovic"
});
}
catch { }
factoryMock.Verify(x => x.CreatePlayer("Novak", "Jokovic", "", "", "", "", "", ""), Times.Once);
}
public ActionResult AddPlayer(AddPlayerCommand command)
{
HandleCommand(command, Json("Player added"));
return(RedirectToAction("PlayersManage"));
}
public CommandResult <SwissTournamentContext> ProcessCommand(SwissTournamentContext context, AddPlayerCommand command)
{
// Don't allow the same player to be added twice
if (context.Players.Contains(command.Player))
{
return(new CommandRejectedResult <SwissTournamentContext>(context, "Player already in tournament"));
}
// Update players
return(new CommandAcceptedResult <SwissTournamentContext>(
new SwissTournamentContext(context, players: context.Players.Concat(command.Player))
));
}
public async Task <ActionResult <PlayerViewModel> > Add([FromBody] AddPlayerCommand addPlayerCommand)
{
return(ResolveResult(await Mediator.Send(addPlayerCommand)));
}
public async Task <ActionResult <Guid> > Add([FromBody] AddPlayerCommand command)
{
var id = await _sender.Send(command);
return(CreatedAtAction(nameof(Add), new { id }, id));
}
public async Task <DefaultEntityCommandResponse <Common.Domain.Entities.Player> > Handle(AddPlayerCommand command)
{
this._unitOfWork.Begin();
try
{
this._validationResult = await this._validator.ValidateAsync(command);
if (this._validationResult.IsValid)
{
command.Registration = RegistrationNumberHelper.Format(command.Registration, command.Gender);
}
if (this._validationResult.IsValid && !command.AutoGenerateRegistration)
{
var existing = await this._playerRepository.GetByRegistration(command.Registration);
if (existing != null)
{
this._validationResult.Errors.Add(new ValidationFailure("Registration", $"Registration is already in use by player {existing.DisplayName}."));
}
}
if (this._validationResult.IsValid)
{
var player = new Common.Domain.Entities.Player
{
Forename = command.FirstName,
Surname = command.LastName,
GenderID = command.Gender,
RegistrationID = command.Registration
};
player.SetAuditFields(this._applicationUser.ID);
await this._playerRepository.Save(player);
await this._playerRepository.Flush();
if (command.AutoGenerateRegistration)
{
player.RegistrationID = $"TEMP{player.ID}";
await this._playerRepository.Save(player);
}
this._unitOfWork.SoftCommit();
return(DefaultEntityCommandResponse <Common.Domain.Entities.Player> .Create(this._validationResult, player));
}
else
{
this._unitOfWork.Rollback();
return(DefaultEntityCommandResponse <Common.Domain.Entities.Player> .Create(this._validationResult));
}
}
catch (Exception exception)
{
this._unitOfWork.Rollback();
this._logger.LogError(exception, "Exception in Command Handler");
throw;
}
}
