public void AddPlayer(string connectionId) { var player = playerRepository.GetByConnectionId(connectionId); if (player == null) { playerRepository.GetByConnectionId(connectionId); playerRepository.Create(connectionId); } }
public async Task <LoginAccountResponseView> Register(RegisterAccountView model) { var user = new User { UserName = model.Email, Email = model.Email, Year = model.Year, Name = model.Name }; var player = new Player() { Name = user.Name, UserId = user.Id }; var result = await _userManager.CreateAsync(user, model.Password); if (!result.Succeeded) { throw new CustomServiceException("Registration is not complete"); } await _playerRepository.Create(player); var encodedJwt = await _jwtProvider.GenerateJwtToken(user); var response = new LoginAccountResponseView() { Token = encodedJwt }; return(response); }
public async Task <Player> SignUp(Player player, string password) { var found_usrname = await _repository.GetByUsername(player.username); if (found_usrname != null) { throw new AlreadyExistsUsernameException(player.username); } var found_email = await _repository.GetByEmail(player.email); if (found_email != null) { throw new AlreadyExistsEmailException(player.email); } // hash password before saving byte[] hash, salt; HashPassword(password, out hash, out salt); player.passwordHash = hash; player.passwordSalt = salt; player.online = false; return(await _repository.Create(player)); }
public CreateResponse Create(CreateRequest request) { if (request == null) { AddNotification("Adicionar", Message.OBJETO_X0_E_OBRIGATORIO.ToFormat("CreateRequest")); } var namePerson = new NamePerson(request.FirstName, request.LastName); var email = new Email(request.Email); var password = request.PassWord; var player = new Player(namePerson, email, password); AddNotifications(namePerson, email); var playerExist = _playerRepository.Exists(x => x.Email.Adress == request.Email); if (playerExist) { AddNotification("E-mail", Message.JA_EXISTE_UM_X0_CHAMADO_X1.ToFormat("e-mail", request.Email)); } if (IsInvalid()) { return(null); } player = _playerRepository.Create(player); return((CreateResponse)player); }
public Player CreatePlayer(CreatePlayerDTO PlayerDTO) { try { var ExistingTeam = _teamRepository.FindById(new Guid(PlayerDTO.TeamId)); if (ExistingTeam == null) { return(null); } Player newPlayer = PlayerDTO.toPlayer(); _playerRepository.Create(newPlayer); _playerRepository.Save(); NotifyAll(newPlayer); return(newPlayer); } catch (Exception ex) { _logger.LogWarning($"{ex.Message}\r\n{ex.StackTrace}"); return(null); } }
private async Task CreatePlayer(int gameId, CreateNewGameGameView createNewGameGameView) { var player = new Player(); player.NickName = createNewGameGameView.NickName; player.PlayerRole = PlayerRole.Player; player.Coins = createNewGameGameView.CoinsAtStart; await _playerRepository.Create(player); var playerGame = new PlayerGame(); playerGame.GameId = gameId; playerGame.PlayerId = player.Id; await _playerGameRepository.Create(playerGame); }
public Player Create(Player newPlayer) { //counter++; //newPlayer.Id = counter; //players.Add(newPlayer); //return newPlayer; return(playerRepository.Create(newPlayer)); }
public IActionResult Post([FromBody] PlayerDto player) { var entity = mapper.Map <Player>(player); var newPlayer = playerRepository.Create(entity); var result = mapper.Map <PlayerDto>(newPlayer); return(Ok(result)); }
public async Task <CreatePlayerResponse> Handle(CreatePlayerCommand request, CancellationToken cancellationToken) { var response = await _repository.Create(request.FirstName, request.LastName, request.Email, request.UserName, request.Password); return(new CreatePlayerResponse { Id = response }); }
private async Task RegisterNewPlayer(Player player) { if (String.IsNullOrEmpty(player.Name)) { return; } player.PlayerType = PlayerType.User; await _playerRepository.Create(player); }
public async Task CreatePlayer(string name) { Player human = await _playerRepository.SelectByName(name, (int)PlayerType.Human); if (human == null) { human = CustomMapper.GetPlayer(name, PlayerType.Human); await _playerRepository.Create(human); } }
public int?Create(CreatePlayerRequest createPlayerRequest) { var teamDetails = _teamRepository.GetDetails(createPlayerRequest.TeamCode); if (teamDetails != null && teamDetails.ActivePlayers.Count() < 10) { return(_playerRepository.Create(createPlayerRequest)); } return(null); }
public async Task <Player> Create(NewPlayer player) { Player _player = new Player() { _id = Guid.NewGuid(), _Name = player._Name, _Password = player._Password }; return(await _repository.Create(_player)); }
public async Task <IActionResult> RegisterPlayer( [HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req, ILogger log) { log.LogInformation("RegisterPlayer called"); string json = await req.ReadAsStringAsync(); var player = JsonConvert.DeserializeObject <Player>(json); return(new OkObjectResult(await _playerRepository.Create(player))); }
public Player SelectPlayer(string name) { bool isEmptyPlayer = _playerRepository.GetIsEmptyByName(name); if (isEmptyPlayer) { _playerRepository.Create(new Player { Name = name }); } return(_playerRepository.Get(name)); }
public Player CreatePlayer(Player p) { if (p != null) { _repo.Create(p); return(p); } else { return(null); } }
public ActionResult PostPlayer([FromBody] PlayerUniqueKey playerUniqueKey) { try { _repo.Create(playerUniqueKey); return(Ok(playerUniqueKey)); } catch { return(BadRequest(playerUniqueKey)); } }
public Task <Player> Create(NewPlayer player) { Player _player = new Player() { _id = Guid.NewGuid(), _Name = player._Name, _Level = 1, _Score = 0 }; return(_repository.Create(_player)); }
public async Task <PlayerDTO> Create(PlayerDTO dto) { var result = await this.Handler.Execute(_log, async() => { Player player = _playerFactory.CreateDomainObject(dto); player.Validate(); player = await _playerRepository.Create(player); return(_playerMapper.ToDto(player)); }); return(result); }
public IActionResult Create([FromBody] Player player) { try { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } _playerRepository.Create(player); return(Ok(player)); } catch { return(BadRequest()); } }
/// <summary> /// Creates a new player. /// </summary> /// <param name="playerRepository"> /// The player repository. /// </param> /// <returns> /// The newly created player object. /// </returns> private static Player CreatePlayer(IPlayerRepository playerRepository) { var player = playerRepository.Create(); player.TotalNetValue = new NetValue { Iron = 20000, Cash = 50000, Energy = 20000, Food = 10000, Mana = 10000 }; player.ResearchPoints = new ResearchPoints { PlayerID = player.ID }; player.TickValue = new TickValue { PlayerID = player.ID }; player.Race = new Race(); return(player); }
public IActionResult Post([FromBody] PlayerCreateDto playerCreateDto) { if (playerCreateDto == null || ModelState.IsValid == false) { return(BadRequest()); } var savedPlayer = mapper.Map <Player>(playerCreateDto); playerRepository.Create(savedPlayer); if (playerRepository.Save() == false) { return(StatusCode(500, "Unable to Save Player")); } return(CreatedAtRoute("GetPlayer", new { savedPlayer.ID }, savedPlayer));; }
public ICommandResult Handle(CreatePlayerCommand command) { //fail fast Validation command.Validate(); if (command.Invalid) { return(new GenericCommandResult(false, "esse jogador não existe", command.Notifications)); } //Create var player = new Player.Domain.Entities.Player(command.Name, command.Assists, command.Goals); //Save _repository.Create(player); //return the value return(new GenericCommandResult(true, "jogador criado", player)); }
public bool Create(Player entity) { return(_playerRepos.Create(entity)); }
public Guid Create(Player player) { _repository.Create(Mapping.Mapped.Map <Domain.Entities.Player>(player)); return(new Guid(player.UserId)); }
public Player CreatePlayer(string name) { return(repo.Create(name)); }
public IActionResult CreatePlayer(PlayerDto input) { _repository.Create(input); return(Ok("Record inserted Successfully")); }