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