コード例 #1
0
        public virtual ActionResult Edit([Bind(Include = "Id,Name,Active,GamingGroupId")] Player player, ApplicationUser currentUser)
        {
            if (ModelState.IsValid)
            {
                player.Name = player.Name.Trim();

                var requestedPlayer = new UpdatePlayerRequest
                {
                    PlayerId = player.Id,
                    Active   = player.Active,
                    Name     = player.Name,
                };

                try
                {
                    playerSaver.UpdatePlayer(requestedPlayer, currentUser);
                    return(new RedirectResult(Url.Action(MVC.GamingGroup.ActionNames.Index, MVC.GamingGroup.Name)
                                              + "#" + GamingGroupController.SECTION_ANCHOR_PLAYERS));
                }
                catch (PlayerAlreadyExistsException)
                {
                    ModelState.AddModelError(string.Empty,
                                             $@"A Player with name '{requestedPlayer.Name}' already exists in this Gaming Group. Choose another.");
                }
            }

            var playerEditViewModel = playerEditViewModelBuilder.Build(player);

            return(View(MVC.Player.Views.Edit, playerEditViewModel));
        }
コード例 #2
0
        public UpdatePlayerResponse UpdatePlayer(UpdatePlayerRequest request)
        {
            if (request == null)
            {
                AddNotification("UpdatePlayerRequest", Message.X0_IS_REQUIRED.ToFormat("UpdatePlayerRequest"));
            }

            Player player = _playerRepository.FindPlayerById(request.Id);

            if (player == null)
            {
                AddNotification("Id", "data not found");
                return(null);
            }

            var name  = new Name(request.FirstName, request.LastName);
            var email = new Email(request.Email);

            player.UpdatePlayer(name, email);

            AddNotifications(player);

            if (IsInvalid())
            {
                return(null);
            }

            _playerRepository.UpdatePlayer(player);

            return((UpdatePlayerResponse)player);
        }
コード例 #3
0
        public async Task <IActionResult> PutPlayer([FromRoute] Guid id, [FromBody] UpdatePlayerRequest request)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            // Find our player.
            PlayerDataModel player = await _context.Players.FindAsync(id);

            if (player == null)
            {
                return(NotFound());
            }

            // Update properties.
            player.Name = request.Name;

            try
            {
                await _context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                // If we hit a concurrency exception and the player no longer exists,
                // It must have been deleted while we were working.
                if (!_context.Players.Any(e => e.Id == id))
                {
                    return(NotFound());
                }
                throw;
            }

            return(NoContent());
        }
コード例 #4
0
        public virtual void UpdatePlayer(UpdatePlayerRequest updatePlayerRequest, ApplicationUser applicationUser)
        {
            var player = _dataContext.FindById <Player>(updatePlayerRequest.PlayerId);

            var somethingChanged = false;

            if (updatePlayerRequest.Active.HasValue)
            {
                player.Active = updatePlayerRequest.Active.Value;

                somethingChanged = true;
            }

            if (!string.IsNullOrWhiteSpace(updatePlayerRequest.Name))
            {
                player.Name = updatePlayerRequest.Name.Trim();

                somethingChanged = true;
            }

            if (somethingChanged)
            {
                Save(player, applicationUser);
            }
        }
コード例 #5
0
        public WaitingRoomPlayersResponse UpdatePlayer(UpdatePlayerRequest request)
        {
            WaitingRoom waitingRoom = WaitingRoom.GetWaitingRoom();

            waitingRoom.UpdatePlayer(request);
            waitingRoom.SaveWaitingRoom();
            return(new WaitingRoomPlayersResponse()
            {
                Players = waitingRoom.Players
            });
        }
コード例 #6
0
        public async Task <bool> UpdatePlayerAsync(int id, UpdatePlayerRequest playerRequest)
        {
            var playerToUpdate = await _dbContext.Players.FindAsync(id);

            if (default == playerToUpdate)
            {
                return(false);
            }
            playerToUpdate.NickName = playerRequest.NickName;
            _dbContext.Update(playerToUpdate);
            return(await _dbContext.SaveChangesAsync() > 0);
        }
コード例 #7
0
        public void ItUpdatesThePlayerName()
        {
            var updatePlayerRequest = new UpdatePlayerRequest
            {
                Name     = "a new name",
                PlayerId = PLAYER_ID
            };

            autoMocker.ClassUnderTest.UpdatePlayer(updatePlayerRequest, currentUser);

            autoMocker.ClassUnderTest.AssertWasCalled(
                mock => mock.Save(Arg <Player> .Matches(p => p.Name == updatePlayerRequest.Name),
                                  Arg <ApplicationUser> .Is.Same(currentUser)));
        }
コード例 #8
0
        public void ItUpdatesTheActiveFlag()
        {
            var updatePlayerRequest = new UpdatePlayerRequest
            {
                Active   = true,
                PlayerId = PLAYER_ID
            };

            autoMocker.ClassUnderTest.UpdatePlayer(updatePlayerRequest, currentUser);

            autoMocker.ClassUnderTest.AssertWasCalled(
                mock => mock.Save(Arg <Player> .Matches(p => p.Active == updatePlayerRequest.Active.Value),
                                  Arg <ApplicationUser> .Is.Same(currentUser)));
        }
コード例 #9
0
        public void ItDoesntBotherUpdatingIfNothingChanged()
        {
            var updatePlayerRequest = new UpdatePlayerRequest
            {
                Active   = _player.Active,
                Name     = _player.Name,
                PlayerId = PLAYER_ID
            };

            _autoMocker.ClassUnderTest.UpdatePlayer(updatePlayerRequest, _currentUser);

            _autoMocker.ClassUnderTest.AssertWasNotCalled(
                mock => mock.Save(Arg <Player> .Is.Anything,
                                  Arg <ApplicationUser> .Is.Anything));
        }
コード例 #10
0
        public IActionResult Update(int id, [FromBody] UpdatePlayerRequest request)
        {
            if (!IsPlayerNameValid(ModelState, nameof(request.PlayerName), request.PlayerName))
            {
                return(BadRequest(ModelState));
            }

            var playerToUpdate = Mapper.Map <Player>(request);

            playerToUpdate.Id = id;

            _playerService.Update(playerToUpdate);

            return(Ok( ));
        }
コード例 #11
0
        public async Task <IActionResult> PutPlayerAsync(int id, [FromBody] UpdatePlayerRequest playerRequest)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest());
            }

            var isUpdated = await _playerService.UpdatePlayerAsync(id, playerRequest);

            if (!isUpdated)
            {
                return(NotFound($"PlayerId { id } not found."));
            }
            return(Ok("Record has been updated successfully."));
        }
コード例 #12
0
        public void ItDoesntBotherUpdatingIfNothingWasRequestedToBeUpdated()
        {
            var updatePlayerRequest = new UpdatePlayerRequest
            {
                Name     = null,
                PlayerId = PLAYER_ID,
                Active   = null
            };

            autoMocker.ClassUnderTest.UpdatePlayer(updatePlayerRequest, currentUser);

            autoMocker.ClassUnderTest.AssertWasNotCalled(
                mock => mock.Save(Arg <Player> .Is.Anything,
                                  Arg <ApplicationUser> .Is.Same(currentUser)));
        }
コード例 #13
0
        public void UpdatePlayer(UpdatePlayerRequest request)
        {
            PlayerDetails player = Players.FirstOrDefault(o => o.SocketId == request.SocketId);

            if (player != null)
            {
                PlayerDetails dbPlayer = PlayerRepository.GetPlayer(request.Name);
                if (dbPlayer.DisplayName == "Not Found")
                {
                    throw new Exception("Player not found in database");
                }
                player.DisplayName = dbPlayer.DisplayName;
                player.FirstName   = dbPlayer.FirstName;
                player.Id          = dbPlayer.Id;
                player.LastName    = dbPlayer.LastName;
            }
        }
コード例 #14
0
        public virtual HttpResponseMessage UpdatePlayer([FromBody] UpdatePlayerMessage updatePlayerMessage, [FromUri] int playerId, [FromUri] int gamingGroupId)
        {
            if (updatePlayerMessage == null)
            {
                return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "You must pass at least one valid parameter."));
            }

            var requestedPlayer = new UpdatePlayerRequest
            {
                PlayerId = playerId,
                Active   = updatePlayerMessage.Active,
                Name     = updatePlayerMessage.PlayerName
            };

            _playerSaver.UpdatePlayer(requestedPlayer, CurrentUser);

            return(Request.CreateResponse(HttpStatusCode.NoContent));
        }
コード例 #15
0
        public async Task <Player> Update(string username, UpdatePlayerRequest updateInfo)
        {
            var found = await _repository.GetByUsername(username);

            if (VerifyHashedPassword(updateInfo.currentPassword, found.passwordHash, found.passwordSalt))
            {
                if (found == null)
                {
                    throw new EntityNotFoundException();
                }

                if (!string.IsNullOrWhiteSpace(updateInfo.firstName))
                {
                    found.firstName = updateInfo.firstName;
                }

                if (!string.IsNullOrWhiteSpace(updateInfo.lastName))
                {
                    found.lastName = updateInfo.lastName;
                }

                if (!string.IsNullOrWhiteSpace(updateInfo.email))
                {
                    found.email = updateInfo.email;
                }

                if (!string.IsNullOrWhiteSpace(updateInfo.newPassword))
                {
                    byte[] newHash;
                    byte[] newSalt;
                    HashPassword(updateInfo.newPassword, out newHash, out newSalt);
                    found.passwordSalt = newSalt;
                    found.passwordHash = newHash;
                }

                return(await _repository.Update(found));
            }
            else
            {
                throw new PasswordsDontMatch();
            }
        }
コード例 #16
0
        public async Task <ActionResult <PlayerDTO> > UpdateProfile([FromBody] UpdatePlayerRequest updateInfo)
        {
            try
            {
                Player player = (Player)HttpContext.Items["SessionPlayer"];

                return(Ok(_mapper.Map <PlayerDTO>(await this._service.Update(player.username, updateInfo))));
            }
            catch (EntityNotFoundException)
            {
                return(NotFound(new Error("UserNotFound", "User Not Found.")));
            }
            catch (PasswordsDontMatch e)
            {
                return(BadRequest(new Error("PasswordsDontMatch", e.Message)));;
            }
            catch (Exception e)
            {
                this._logger.LogError(e, e.Message);
                return(StatusCode(500));
            }
        }
コード例 #17
0
        public virtual ActionResult Edit([Bind(Include = "Id,Name,Active,GamingGroupId")] Player player, ApplicationUser currentUser)
        {
            if (ModelState.IsValid)
            {
                player.Name = player.Name.Trim();

                var requestedPlayer = new UpdatePlayerRequest
                {
                    PlayerId = player.Id,
                    Active   = player.Active,
                    Name     = player.Name,
                };

                playerSaver.UpdatePlayer(requestedPlayer, currentUser);

                return(new RedirectResult(Url.Action(MVC.GamingGroup.ActionNames.Index, MVC.GamingGroup.Name)
                                          + "#" + GamingGroupController.SECTION_ANCHOR_PLAYERS));
            }

            var playerEditViewModel = playerEditViewModelBuilder.Build(player);

            return(View(MVC.Player.Views.Edit, playerEditViewModel));
        }
コード例 #18
0
        public async Task <MatchModel> CreateMatch(CreateMatchCommand command)
        {
            Player winner = await playersApiClient.GetPlayer(command.WinnerId);

            Player loser = await playersApiClient.GetPlayer(command.LoserId);

            PlayersRatings ratings = await ratingApiClient.CalculatePlayersRatings(RatingMapper.Map(winner, loser));

            UpdatePlayerRequest updateWinnerRequest = new UpdatePlayerRequest(winner.Id, winner.Name, ratings.WinnerRating.Rating, ratings.WinnerRating.Deviation, ratings.WinnerRating.Volatility);

            winner = await playersApiClient.UpdatePlayer(updateWinnerRequest);

            UpdatePlayerRequest updateLoserRequest = new UpdatePlayerRequest(loser.Id, loser.Name, ratings.LoserRating.Rating, ratings.LoserRating.Deviation, ratings.LoserRating.Volatility);

            loser = await playersApiClient.UpdatePlayer(updateLoserRequest);

            CreateMatchRequest createMatchRequest = new CreateMatchRequest(winner.Id, loser.Id, command.Score);
            Match match = await matchesApiClient.CreateMatch(createMatchRequest);

            return(MatchMapper.Map(match, new List <Player> {
                winner, loser
            }));
        }
コード例 #19
0
        public async Task <ActionResult> UpdatePlayer(UpdatePlayerRequest request)
        {
            if (!await this.IsAPITokenValid(request.ApiToken))
            {
                return(new BadRequestObjectResult("UnAuthorized"));
            }

            string leagueId = await this.GetLeagueId(request.LeagueKey);

            if (leagueId == null)
            {
                return(new BadRequestObjectResult("League Not Found"));
            }

            if (await this.TeamRepository.GetAsync(request.TeamId) == null)
            {
                return(new BadRequestObjectResult("Team Not Found"));
            }

            var player = await this.PlayerRepository.GetAsync(request.PlayerId);

            if (player == null)
            {
                return(new BadRequestObjectResult("Player Not Found"));
            }

            player.PlayerNum = request.PlayerNum;
            player.Position  = request.Position;
            player.FirstName = request.FirstName;
            player.LastName  = request.LastName;
            player.Picture   = String.IsNullOrEmpty(request.Picture) ? Configuration.GetValue <string>("DefaultPlayerLogo") : request.Picture;
            player.TeamId    = request.TeamId;

            var updatedPlayer = await this.PlayerRepository.UpdateAsync(player);

            return(new OkObjectResult(updatedPlayer));
        }
コード例 #20
0
 public Task <IActionResult> UpdateMyInstrument([FromBody] UpdatePlayerRequest request, int playerId)
 {
     request.playerId = playerId;
     return(this.HandleRequest <UpdatePlayerRequest, UpdatePlayerResponse>(request));
 }
コード例 #21
0
        public async Task <ActionResult <CreatePlayerResponse> > UpdatePlayer([FromRoute] int playerId, [FromBody] UpdatePlayerRequest createPlayerRequest, CancellationToken cancellationToken)
        {
            var player = await _playersRepository.GetByIdAsync(playerId, cancellationToken);

            if (player != null)
            {
                player.Name    = createPlayerRequest.Name;
                player.Surname = createPlayerRequest.Surname;
                player.Role    = PlayerRole.GetByAcronym(createPlayerRequest.RoleAcronym);

                await _playersRepository.UpdateAsync(player, cancellationToken);

                var response = new CreatePlayerResponse
                {
                    Player = _mapper.Map <PlayerDto>(player)
                };
                return(Ok(response));
            }
            else
            {
                return(NotFound());
            }
        }