public void It_Should_Be_Able_To_Add_A_New_Player()
{
var id = _repository.Add(TheDude);
var player = _repository.Get(id);
Assert.AreEqual(TheDude, player.Name);
}
/// <summary>
/// Create a new player.
/// </summary>
/// <param name="playerToCreate">A Player to create.</param>
public Player Create(CreatePlayerDto playerToCreate)
{
_authService.CheckAccess(AuthOperations.Players.Create);
if (playerToCreate == null)
{
throw new ArgumentNullException(nameof(playerToCreate));
}
return(_playerRepository.Add(playerToCreate));
}
/// <summary>
/// Create a new player.
/// </summary>
/// <param name="playerToCreate">A Player to create.</param>
public void Create(Player playerToCreate)
{
_authService.CheckAccess(AuthOperations.Players.Create);
if (playerToCreate == null)
{
throw new ArgumentNullException("playerToCreate");
}
_playerRepository.Add(playerToCreate);
_playerRepository.UnitOfWork.Commit();
}
public string AddPlayer(string type, string username)
{
if (type == "Beginner")
{
IPlayer player = new Beginner(cardRepository, username);
playerRepository.Add(player);
}
else if (type == "Advanced")
{
IPlayer player = new Advanced(cardRepository, username);
playerRepository.Add(player);
}
return(string.Format(ConstantMessages.SuccessfullyAddedPlayer, type, username));
}
public string AddPlayer(string type, string username)
{
IPlayer player = playerFactory.CreatePlayer(type, username);
playerRepo.Add(player);
return($"Successsfully added card: {type} to user {username}");
}
public ValidationResult <Player> Create(string name)
{
if (repo.GetByName(name) != null)
{
return(ValidationResult <Player> .Failure("User already exists"));
}
var random = new Random();
var player = new Player
{
Name = name,
Id = Guid.NewGuid(),
IsOnline = true,
LastSeen = DateTime.Now,
ApiKey = string.Format("{0}{1}{2}{3}{4}",
random.Next(0, 9),
random.Next(0, 9),
random.Next(0, 9),
random.Next(0, 9),
random.Next(0, 9)),
IsActive = true
};
repo.Add(player);
repo.Save();
return(ValidationResult <Player> .Success.WithData(player));
}
public string AddPlayer(string type, string username)
{
player = playerFactory.CreatePlayer(type, username);
playerRepository.Add(player);
return($"Successfully added player of type {type} with username: {username}");
}
public string AddPlayer(string type, string username)
{
IPlayer player = playerFactory.CreatePlayer(type, username);
playerRepository.Add(player);
return(string.Format(ConstantMessages.SuccessfullyAddedPlayer, type, username));
}
public IActionResult CreatePlayer(RegisterViewModel player)
{
if (_loginManager.IsLoggedIn(HttpContext?.Session))
{
return(RedirectToAction("Index", "Game"));
}
if (GetPlayerByUserName(player.Username) != null)
{
ViewData.ModelState.TryAddModelError("Username", "There is already a user with this name in the system.");
}
if (ModelState.IsValid)
{
_repository.Add(new Player()
{
PassWord = _hashing.GetHashedPassword(player.Password),
UserName = player.Username,
Level = 1
});
_emailSender.SendEmailAsync(player.Email,
"Welcome to the Shadow World",
String.Format(
"Welcome to the shadow world! \n\n" +
" Your username is: {0} \n" +
" Your password is: {1}"
, player.Username, player.Password));
HttpContext?.Session.Clear();
HttpContext?.Session.SetInt32(ContextData.PlayerId.ToString(),
_repository.Read().First(p => p.UserName == player.Username).Id);
HttpContext?.Session.CommitAsync();
return(RedirectToAction("Index", "Game"));
}
return(View());
}
public string AddPlayer(string type, string username)
{
var newPlayer = playerFactory.CreatePlayer(type, username);
playerRepo.Add(newPlayer);
return(string.Format(ConstantMessages.SuccessfullyAddedPlayer, newPlayer.GetType().Name, newPlayer.Username));
}
public IHttpActionResult Post([FromBody] Player player)
{
var result = new Player();
if (ModelState.IsValid)
{
if (player.Club == null)
{
return(Content(HttpStatusCode.BadRequest, "Club is empty"));
}
if (player.Country == null)
{
return(Content(HttpStatusCode.BadRequest, "Country is empty"));
}
if (player.Gender == null)
{
return(Content(HttpStatusCode.BadRequest, "Gender is empty"));
}
result = playerRepository.Add(player);
}
return(Json(result));
}
public void AddPlayer(PlayerModel newPlayer)
{
using (var dbContext = new DatabaseContext())
{
playerRepository.Add(dbContext, newPlayer);
dbContext.Save();
}
}
public JsonResult SignUpPlayer([FromBody] Player player)
{
Console.WriteLine(player.Id);
var p = _repository.Add(player);
return(Json(p));
}
public string AddPlayer(string type, string username)
{
if (type == "Beginner")
{
playerRepository.Add(new Beginner(new CardRepository(), username));
return(string.Format(ConstantMessages.SuccessfullyAddedPlayer, type, username));
}
else if (type == "Advanced")
{
playerRepository.Add(new Advanced(new CardRepository(), username));
return(string.Format(ConstantMessages.SuccessfullyAddedPlayer, type, username));
}
else
{
return(null);
}
}
public DomainPlayer CreateEntity(DomainPlayerUpdateModel player)
{
if (player == null)
{
throw new ArgumentNullException("Player is null");
}
return(playerDB.Add(player));
}
public IActionResult CreatePost(Player model)
{
if (ModelState.IsValid)
{
_playerRepository.Add(model);
return(RedirectToAction("Teams"));
}
return(View("Create"));
}
public void Handle(PlayerCreatedEvent domainEvent)
{
var town = _townRepository.GetSmallestTown();
town.AddCitizen();
_townRepository.Update(town);
domainEvent.Player.SetTown(town.Id);
_playerRepository.Add(domainEvent.Player);
}
public Player AddPlayer(PlayerDto player)
{
var playerEntity = mapper.Map <Player>(player);
playerRepository.Add(playerEntity);
playerRepository.SaveChanges();
var playerToreturn = mapper.Map <Player>(playerEntity);
return(playerToreturn);
}
public PlayerResponse Create(PlayerRequest request)
{
if (request == null)
{
throw new ArgumentNullException("entity");
}
var response = _repository.Add(Mapper.Map <Player>(request));
_unitOfWork.Commit();
return(Mapper.Map <PlayerResponse>(response));
}
public Player JoinGame(string joinKey, string userName)
{
var game = _gameDataService.GetGame(joinKey);
_playerRepository.Add(new Player
{
UserName = userName,
GameId = game.Id
});
return(_playerRepository.GetPlayerByName(userName, game.Id));
}
public async Task <IActionResult> PostPlayer([FromBody] Players player)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await _playerRepository.Add(player);
return(Ok("created_id"));
}
public async Task <IActionResult> Add(Player player)
{
if (ModelState.IsValid)
{
await playerRepo.Add(player);
return(RedirectToAction("index"));
}
return(View(player));
}
public async Task <IActionResult> Post([FromBody] Player player)
{
try
{
return(this.Ok(await _repository.Add(player)));
}
catch (Exception e)
{
return(this.Ok(TranslateError.Convert(e)));
}
}
public IActionResult AddPlayer(int tournamentId, [FromBody] PlayerDto player)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var createdPlayer = playerRepository.Add(tournamentId, player);
return(Ok(createdPlayer.ToPlayerDto()));
}
public TicTacToe.Models.MVC.Game.Player Create(TicTacToe.Models.MVC.Game.Player player, int userId)
{
_playerRepository.Add(new Models.Entity.Player
{
UserId = userId,
GameSideId = (int)player.GameSideEnum,
Name = player.Name
});
_playerRepository.SaveChanges();
return(FindByUserId(userId));
}
public ActionResult Create([Bind(Include = "ID,LastName,FirstMidName")] Player player)
{
if (ModelState.IsValid)
{
_playerRepository.Add(player);
_playerRepository.Save();
return(RedirectToAction("Index"));
}
return(View(player));
}
public string Add(PlayerDTO playerData)
{
var player = new Player(playerData.FirstName,
playerData.LastName,
playerData.EmailAddress,
playerData.Age.HasValue? playerData.Age : null,
playerData.SkillLevel
);
return(playerRepository.Add(player));
}
public TournamentDto CreateTournament(IEnumerable <string> playerNames)
{
Tournament tournament = _tournamentRepository.Add(new Tournament());
// TODO: Check # of players?
foreach (string name in playerNames)
{
_playerRepository.Add(new Player(name, tournament.Id));
}
if (playerNames.Count() % 2 != 0)
{
_playerRepository.Add(new Player("BYE", tournament.Id));
}
_unitOfWork.Commit();
StartTournament(tournament);
return(_mapper.Map <TournamentDto>(tournament));
}
public async Task <IActionResult> Create([Bind("Id,Name,Surname,Number,TeamId,Goal,Assist,RedCard,YellowCard,Position")] Player player)
{
if (ModelState.IsValid)
{
repository.Add(player);
await repository.SaveAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["TeamId"] = new SelectList(team.GetAll(), "Id", "TeamType", player.TeamId);
return(View(player));
}
public bool RegisterPlayer(string email, string password, string firstName, string lastName, string age, IPlayerRepository playerRepository, ITrainerRepository trainerRepository)
{
Player newPlayer = new Player(1, firstName, lastName, email, password, int.Parse(age), false);
Trainer checkEmailInUse = new Trainer(1, firstName, lastName, email, password, false);
if (!playerRepository.CheckPlayerExists(newPlayer) && !trainerRepository.CheckTrainerExists(checkEmailInUse))
{
playerRepository.Add(newPlayer);
return(true);
}
return(false);
}
