public async Task CanAdd()
{
_logger.LogInformation("CanAdd");
var player = new Player
{
Name = "New Player",
Email = "*****@*****.**"
};
var newPlayer = await _playerRepository.AddAsync(player).ConfigureAwait(false);
Assert.Equal("New Player", newPlayer.Name);
}
public async Task <PlayerModel> AddAsync(PlayerModel model)
{
var entity = mapper.Map <PlayerEntity>(model);
var response = await playerRepo.AddAsync(entity);
return(mapper.Map <PlayerModel>(response));
}
private async Task AddPlayersAsync(List <string> players, string clan = null)
{
WotService test = new WotService();
var langs = UrlBuilder.WotLangs;
var count = 0;
foreach (var player in players)
{
foreach (var lang in langs)
{
if (count == 20)
{
Thread.Sleep(1200);
count = 0;
}
count++;
var playerData = await test.LoadPlayerDataAsync(player, lang);
var accountId = playerData.Data?.FirstOrDefault()?.AccountId;
if (!string.IsNullOrEmpty(accountId))
{
await _playerRepository.AddAsync(new Models.Entities.Player
{
Id = Guid.NewGuid(),
WotId = accountId,
Nickname = player,
Lang = lang,
Clan = clan
});
break;
}
}
}
}
public async Task <BalanceResponse> SaveAsync(Balance balance)
{
var existingWallet = await _playerRepository.FindByIdAsync(balance.PlayerId);
if (existingWallet == null)
{
await _playerRepository.AddAsync(new Player()
{
Id = balance.PlayerId
});
await _unitOfWork.CompleteAsync();
}
var existingBalance = await _balanceRepository.FindAsync(balance);
if (existingBalance != null)
{
return(new BalanceResponse("Asset already exist."));
}
try
{
await _balanceRepository.AddAsync(balance);
await _unitOfWork.CompleteAsync();
return(new BalanceResponse(balance));
}
catch (Exception ex)
{
// Do some logging stuff
return(new BalanceResponse($"An error occurred when saving the asset: {ex.Message}"));
}
}
public async Task RegisterAsync(string connectionId, string name, string group)
{
var player = await _playerRepository.GetByNameAsync(name);
if (player == null)
{
throw new Exception($"Player with name: '{0}' already exists.");
}
player = Player.Create(connectionId, name, group);
await _playerRepository.AddAsync(player);
}
public async Task <GenericResponse <Player> > SaveAsync(Player player)
{
try{
await playerRepository.AddAsync(player);
await unityOfWork.CompleteAsync();
return(new GenericResponse <Player>(player));
}
catch (Exception ex) {
return(new GenericResponse <Player>($"Error while saving plaer. Message:{ex.Message}"));
}
}
public IEnumerable Handle(CreatePlayer c)
{
if (_repository.GetByIdAsync(c.Id) != null)
{
throw new PlayerAlreadyCreated();
}
_repository.AddAsync(new Player {
Id = c.Id, Name = c.Name
});
yield return(new PlayerCreated(c.Id, c.Name));
}
public async Task <ActionResult <CreatePlayerResponse> > CreatePlayer([FromBody] CreatePlayerRequest createPlayerRequest, CancellationToken cancellationToken)
{
var player = new Player()
{
Name = createPlayerRequest.Name,
Surname = createPlayerRequest.Surname,
Role = PlayerRole.GetByAcronym(createPlayerRequest.RoleAcronym)
};
await _playersRepository.AddAsync(player, cancellationToken);
var response = new CreatePlayerResponse();
response.Player = _mapper.Map <PlayerDto>(player);
return(Ok(response));
}
public async Task RegisterAsync(Guid id, string nickname, string password)
{
var player = await _playerRepository.GetAsync(nickname);
if (player != null)
{
throw new ServiceException(ErrorCodes.UserExist, "User with this nickname already exists.");
}
var salt = _encrypter.GetSalt(password);
var hash = _encrypter.GetHash(password, salt);
player = new Player(id, nickname, hash, salt);
await _playerRepository.AddAsync(player);
}
public async Task <IActionResult> Create([FromBody] DTO.Player.Input.Player player)
{
var playerResult = await _playerRepository.AddAsync(new Models.Player.Player()
{
DateOfBirth = player.DateOfBirth,
FirstName = player.FirstName,
LastName = player.LastName,
Growth = player.Growth,
Weight = player.Weight
});
var result = AutoMapper.Mapper.Map <DTO.Player.Output.Player>(playerResult);
return(Ok(result));
}
public async Task <PlayerViewModel> Handle(AddPlayerCommand addPlayerCommand, CancellationToken cancellationToken) => await Task.Run(() =>
{
return(ExecuteAsync <PlayerViewModel>(async response =>
{
var playerToAdd = new Player
{
Name = addPlayerCommand.Name,
Surname = addPlayerCommand.Surname,
Height = addPlayerCommand.Height,
EmailAddress = addPlayerCommand.EmailAddress
};
var addedPlayer = await _playerRepository.AddAsync(playerToAdd);
var playerDto = _mapper.Map <PlayerLookupModel>(addedPlayer);
response.PlayerLookupModel = playerDto;
}));
});
private async Task <string> RegisterPlayer(Message message, IPlayerRepository playerRepository)
{
try
{
var existPlayer = await playerRepository.GetAsync(message.From.Id);
var messageForUser = existPlayer.Name == PlayerName(message) ? "Вы уже зарегистрированы" : "Вы уже были зарегистрированы. Имя обновлено.";
existPlayer.Name = PlayerName(message);
await playerRepository.UpdateAsync(existPlayer);
return(messageForUser);
}
catch (UserNotFoundException)
{
await playerRepository.AddAsync(new Player(message.From.Id, PlayerName(message), message.Chat.Id));
return("Регистрация прошла успешно");
}
}
private async Task <Player> CreatePlayerInternalAsync(string username, CancellationToken cancellationToken)
{
using (await padlock.WriterLockAsync(cancellationToken).ConfigureAwait(true))
{
if (await _players.ExistsPlayerWithUsernameAsync(username, cancellationToken).ConfigureAwait(false))
{
throw new DuplicateEntityException($"Duplicate exception. Username '{username}' already exists.");
}
var player = await _players
.AddAsync(new Player { Username = username }, cancellationToken)
.ConfigureAwait(false);
await _wallets
.AddAsync(new Wallet { PlayerId = player.Id, Balance = 0 }, cancellationToken)
.ConfigureAwait(false);
await _unitOfWork.CommitAsync(cancellationToken).ConfigureAwait(false);
_logger.LogDebug("{method} finished. Player with {playerId} id created.", nameof(CreatePlayerAsync), player.Id);
return(player);
}
}
public async Task <PlayerResponse> SaveAsync(Player player)
{
var existingWallet = await _playerRepository.FindByIdAsync(player.Id);
if (existingWallet != null)
{
return(new PlayerResponse("Player already exists."));
}
try
{
await _playerRepository.AddAsync(player);
await _unitOfWork.CompleteAsync();
return(new PlayerResponse(player));
}
catch (Exception ex)
{
// Do some logging stuff
return(new PlayerResponse($"An error occurred when saving the player: {ex.Message}"));
}
}
public async Task <IActionResult> Create([FromBody] PlayerCreateDto player)
{
var team = await _teamRepository.GetByIdAsync(player.TeamId);
if (team == null)
{
return(BadRequest($"Invalid country Id { player.TeamId }"));
}
if (await _playerRepository.ExistAsync(p => p.Email == player.Email))
{
return(BadRequest($"Invalid email - It is already registered in the system"));
}
var completeNameResult = CompleteName.Create(player.FirstName, player.LastName);
if (completeNameResult.IsFailure)
{
return(BadRequest(completeNameResult.Error));
}
var emailResult = Email.Create(player.Email);
if (emailResult.IsFailure)
{
return(BadRequest(emailResult.Error));
}
var newPlayer = new Player(completeNameResult.Value, player.BirthDate, emailResult.Value, player.Phone, team);
await _playerRepository.AddAsync(newPlayer);
await _unitOfWork.Commit();
return(Ok());
}
