public ViewResult ManagePlayers(Player player) { repository.AddPlayer(player); ModelState.Clear(); ViewBag.club = clubRepository.Clubs; TempData["message"] = $"{player.FirstName+" "+player.LastName} has been Added to {player.Club}"; return(View()); }
public IActionResult Post([FromBody] PlayerForCreationDto player) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (player == null) { return(BadRequest()); } var playerEntity = Mapper.Map <Player>(player); _playerRepository.AddPlayer(playerEntity); if (!_playerRepository.Save()) { throw new Exception("Creating an Player failed on save."); } var playerToReturn = Mapper.Map <PlayerDto>(playerEntity); return(CreatedAtRoute("GetPlayer", new { id = playerToReturn.PlayerId }, playerToReturn)); }
private static Player GetPlayer(string playerString) { var nickName = GetClearName(playerString.Trim()); var player = _playerRepository.GetPlayerByNickName(nickName); if (player != null) { return(player); } var steamId = GetSteamId(playerString); player = new Player { NickName = nickName, SteamId = steamId, }; var playerId = _playerRepository.AddPlayer(player); return(string.IsNullOrEmpty(playerId) ? null : _playerRepository.GetPlayerById(playerId)); }
public Player AddPlayer(Player playerModel) { playerRepository.AddPlayer(playerModel); playerRepository.SaveChanges(); return(playerModel); }
public Response RegisterPlayer(PlayerRequest request) { var validationResult = validator.Validate(request); if (!validationResult.IsValid) { return(Response.CreateResponse(validationResult.Messages)); } var squad = squadQuery.GetSquad(request.SquadId); if (squad == null) { return(Response.CreateResponse(new EntityNotFoundException("The specified squad does not exist"))); } Player player = MapPlayer(request); try { playerRepository.AddPlayer(player); return(Response.CreateSuccessResponse()); } catch (Exception ex) { return(Response.CreateResponse(ex)); } }
public async Task <Player> AddPlayer(Player player) { await _repository.AddPlayer(player); //await _playerRankService.AddPlayerRankWhenPlayerCreated(player.Id); return(player); }
public AddPlayerResponse AddPlayer(AddPlayerRequest request) { Guid id = _playerService.AddPlayer(request); return(new AddPlayerResponse { Id = id, Message = "Success" }); }
public ActionResult Create(PlayerModel player) { ImageController.ValidateImage(player.AvatarImageFile); playerRepo.AddPlayer(ConvertToDbModel(player)); return(RedirectToAction("Details", "Team", new { ID = player.TeamId })); }
public ActionResult Index() { _repo.AddPlayer(new PlayerModel { FirstName = "123", LastName = "123" }); ViewBag.Title = "Home Page"; return(View()); }
public PlayerService(ILogger <PlayerService> logger, IPlayerRepository playerRepository) { _logger = logger; _playerRepository = playerRepository; _playerRepository.AddPlayer(new Player { PlayerId = 1, PlayerName = "Testing" }); }
public IActionResult AddPlayer([FromBody] Player player) { var wasAdded = _playerRepository.AddPlayer(player); if (!wasAdded) { return(Forbid()); } return(Ok(null)); }
public async Task <ActionResult> AddPlayer(PlayerDto p) { Player pl = new Player(); if (await _playerRepository.AddPlayer(pl)) { return(Ok("A new player was added successfully!")); } return(BadRequest("Oops, something went wrong!")); }
public IHttpActionResult PostPlayerModel(PlayerModel playerModel) { if (playerModel == null) { return(BadRequest(ModelState)); } _playerRepository.AddPlayer(playerModel); _playerRepository.Save(); return(CreatedAtRoute("DefaultApi", new { id = playerModel.Id }, playerModel)); }
public async Task <IActionResult> Create([Bind("PlayerId,Name,Surname,Nickname,Salary,DateOfBirth,TeamId")] Player player) { if (ModelState.IsValid) { _playerRepository.AddPlayer(player); await _playerRepository.Save(); return(RedirectToAction(nameof(Index))); } ViewData["TeamId"] = new SelectList(await _teamRepository.GetTeams(), "TeamId", "Name", player.TeamId); return(View(player)); }
private void CreatePlayer(object state) { var sender = (EndPoint)state; var newPlayer = AbstractFactory.Get <INetworkTypeFactory>().GetNew <INetPlayer>(); newPlayer.EndPoint = sender; newPlayer.LastCommunication = DateTime.Now; _challengedPlayers.AddPlayer(newPlayer); var challengeMessage = AbstractFactory.Get <INetworkTypeFactory>().GetNew <IChallengeMessage>(); networkMediator.MessageBus.SendReliableMessage(challengeMessage, ManagedSocket, sender); }
public void AddPlayerToRepo(Player player) { if (GetAllPlayers().Count != 0) { player.Id = GetAllPlayers().LastOrDefault().Id + 1; } else { player.Id = 1; } _playerRepo.AddPlayer(player); SetToFreeAgent(player); }
public async Task <RegisterResult> Handle(RegisterCommand request, CancellationToken cancellationToken) { Data.Entities.Player player = new Data.Entities.Player(request.Name, request.Surname, request.PhoneNumber, request.Rating); await _playerRepository.AddPlayer(player); await _playerRepository.UnitOfWork.SaveEntitiesAsync(); return(new RegisterResult { ResponseCode = Constant.ResultCode_Success, ResponseMessage = "Success" }); }
public IActionResult AddPlayer([FromBody] Player newPlayer) { if (!TryValidateModel(newPlayer)) { return(BadRequest()); } if (!ModelState.IsValid) { return(BadRequest()); } _playerRepository.AddPlayer(newPlayer); return(Created(Request.Path + newPlayer.Id.ToString(), newPlayer)); }
public RedirectToActionResult AddPlayer(ManagePlayerModel playerModel) { Club club = clubRepository.Clubs.FirstOrDefault(c => c.ClubID == playerModel.Player.ClubID); if (playerModel.Player.Name != null) { if (club != null) { playerRepository.AddPlayer(playerModel.Player); TempData["message"] = $"Player \"{playerModel.Player.Name}\" has been successfully added to \"{club.Name}\""; return(RedirectToAction(nameof(HomeController.ClubDetails), "Home", new { clubid = club.ClubID })); } TempData["warning"] = $"Failed to add Player \"{playerModel.Player.Name}\" as the selected club no longer exists"; return(RedirectToAction(nameof(HomeController.Clubs), "Home")); } if (club != null) { TempData["warning"] = $"Please complete the adding player form"; return(RedirectToAction(nameof(PlayerController.PlayerManagement), new { clubid = club.ClubID })); } TempData["warning"] = $"The club you were adding player to no longer exists"; return(RedirectToAction(nameof(HomeController.Clubs), "Home")); }
public async Task <bool> AddOrUpdatePlayer(Player player) { var p = await _playerRepository.GetAsync(player.PlayerId); if (p is null) { await _playerRepository.AddPlayer(player); return(true); } else { return(await _playerRepository.UpdatePlayer(player)); } }
public async Task <Response <SerializedSecurityToken> > Handle(AddPlayer request, CancellationToken cancellationToken) { var game = await _gameRepository.GetById(request.GameId); if (game.Secret != request.GameSecret) { throw new DomainException(ErrorCode.NotAuthorized, "Game secret does not match"); } await _playerRepository.AddPlayer(request.GameId, request.PlayerId, request.PlayerName, request.Gravatar); var token = _sts.IssueToken(request.GameId, request.PlayerId, new [] { PlayerRoles.Player.ToString() }); return(Response.FromResult(token)); }
public Guid OrderCollection(DebtDetails debtDetails) { var clientId = _playerRepository.GetPlayerId(debtDetails.ClientRealm, debtDetails.ClientName); if (clientId == default(Guid)) { var clientApiResult = _gameApiClient.GetCharacterDetails(debtDetails.ClientRealm, debtDetails.ClientName); if (clientApiResult == null) { throw new ArgumentOutOfRangeException(nameof(debtDetails.ClientName), "Could not find specified character"); } clientId = _playerRepository.AddPlayer(debtDetails.ClientRealm, debtDetails.ClientName); } var debtorId = _playerRepository.GetPlayerId(debtDetails.DebtorRealm, debtDetails.DebtorName); if (debtorId == default(Guid)) { var debtorApiResult = _gameApiClient.GetCharacterDetails(debtDetails.DebtorRealm, debtDetails.DebtorName); if (debtorApiResult == null) { throw new ArgumentOutOfRangeException(nameof(debtDetails.DebtorName), "Could not find specified character"); } debtorId = _playerRepository.AddPlayer(debtDetails.DebtorRealm, debtDetails.DebtorName); } var orderId = _debtRepository.AddDebt(debtorId, clientId, debtDetails.DebtContextId, debtDetails.DebtAmount); var userName = WindowsIdentity.GetCurrent().Name; _debtCollectionRepository.UpdateOrderAssignment(orderId, userName); return(orderId); }
public IActionResult Create(PlayerViewModel model) { if (!ModelState.IsValid) { return(View()); } var player = new Player() { Name = model.Name }; _playerRepository.AddPlayer(player); return(RedirectToAction("Index")); }
public IActionResult CreatePlayer([FromBody] PlayerCreateModel playerCreateModel) { if (playerCreateModel == null) { return(BadRequest()); } if (!ModelState.IsValid) { return(BadRequest()); } var mlbTeam = _mlbTeamRepository.GetMlbTeam(playerCreateModel.MlbTeamAbbreviation); if (mlbTeam == null) { return(BadRequest()); } var position = _positionRepository.GetPosition(playerCreateModel.PositionAbbreviation); if (position == null) { return(BadRequest()); } var playerEntity = _mapper.Map <Player>(playerCreateModel); playerEntity.Position = position; playerEntity.MlbTeam = mlbTeam; _playerRepository.AddPlayer(playerEntity); if (!_mlbDraftRepository.Save()) { throw new Exception("Creating a player failed on save."); } var playerToReturn = _mapper.Map <PlayerModel>(playerEntity); return(CreatedAtRoute("GetPlayer", new Player { Id = playerToReturn.Id }, playerToReturn)); }
public async Task <Response <SerializedSecurityToken> > Handle(CreateGame request, CancellationToken cancellationToken) { await _gameRepo.Upsert(new Game { Id = request.Id, CreatedTimestamp = DateTimeOffset.Now, PublicId = request.PublicId, Secret = request.Secret, DealerId = request.PlayerId, State = GameState.AwaitingPlayers, }); await _playerRepo.AddPlayer(request.Id, request.PlayerId, request.PlayerName, request.Gravatar); var token = _sts.IssueToken(request.Id, request.PlayerId, new [] { PlayerRoles.Dealer.ToString() }); return(Response.FromResult(token)); }
public Player NewCharacter() { if (_playerRepository.PlayerCount() == 10) { _printService.Type("There are too many saves, you need to delete one to cotinue with your creation."); pickPlayerToRemove(); } _printService.ClearConsole(); _printService.Type("Now we are going to create a new character for your adventure."); Thread.Sleep(2000); var playerDto = new PlayerDto(); pickRace(playerDto); pickGender(playerDto); pickName(playerDto); pickClass(playerDto); var startingClass = _classRepository.GetClass(playerDto.Class); var player = new Player(playerDto); loadNewInventory(startingClass, player); _playerRepository.AddPlayer(player); _playerRepository.SavePlayers(); Console.WriteLine($"{Environment.NewLine}Name: {playerDto.Name}"); Console.WriteLine($"Gender: {playerDto.Gender}"); Console.WriteLine($"Race: {playerDto.Race}"); Console.WriteLine($"Class: {playerDto.Class}"); return(player); }
public Guid AddPlayer(AddPlayerRequest addPlayerRequest) { if (addPlayerRequest.ValidateAddPlayerRequest()) { throw new ArgumentException("Invalid request"); } try { var player = new Player( Guid.NewGuid(), addPlayerRequest.Email, addPlayerRequest.Password, addPlayerRequest.Name, EnumPlayerStatus.OnGoing); var response = playerRepository.AddPlayer(player); return(response.Id); } catch (Exception ex) { throw new ArgumentException("Fail to add player", ex.InnerException.Message, ex); } }
public async Task <Player> AddPlayer(Player player) { return(await _playerRepository.AddPlayer(player)); }
public void AddPlayer([FromBody] Player player) { _playerRepository.AddPlayer(player.Name, player.Score); }
public IActionResult Create(Player player) { //FakeClubRepository.AddClub(c); repository.AddPlayer(player); return(RedirectToAction("Index")); }