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