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