public ActionResult CreateGame()
{
GameCreateModel model = new GameCreateModel();
model.teams = db.Teams.ToList();
return(View(model));
}
public ActionResult Create(GameCreateModel gameModel, string tournamentSlug)
{
if (gameModel.HomeTeamId == gameModel.AwayTeamId)
{
ModelState.AddModelError("AwayTeamId", "A team cannot play itself");
}
if (ModelState.IsValid)
{
var game = new Game
{
RoundId = gameModel.RoundId.Value,
GameTime = gameModel.GameTime
};
db.Games.Add(game);
db.SaveChanges();
var model = new GameEditModel
{
Id = game.Id,
HomeTeamId = gameModel.HomeTeamId,
AwayTeamId = gameModel.AwayTeamId,
GameTime = gameModel.GameTime,
FieldId = gameModel.FieldId
};
return(Edit(model, tournamentSlug));
}
var teams = db.Teams.Where(t => t.Tournament.Slug == tournamentSlug);
ViewBag.HomeTeamId = new SelectList(teams, "Id", "Name");
ViewBag.AwayTeamId = new SelectList(teams, "Id", "Name");
ViewBag.RoundId = new SelectList(db.Rounds, "Id", "Name", gameModel.RoundId);
return(View(gameModel));
}
private void PrepareGameForCreate(GameCreateModel game)
{
//TODO: Fix properly in code and not database defaults
game.Columns = 3;
game.Rows = 3;
game.MaxPlayers = 2;
}
public async Task <ActionResult> Post(GameCreateModel input)
{
var newGame = await GameService.CreateNewGame(input, _userManager);
await DocumentDBRepository <Game> .CreateItemAsync(newGame);
return(CreatedAtAction("Post", newGame));
}
public async Task <IHttpActionResult> Create(GameCreateModel model)
{
IPrincipal principal = RequestContext.Principal;
await validationService.ValidateForCreate(principal, model);
int gameId = await gameService.CreateAsync(model, principal);
return(Ok(gameId));
}
public ActionResult EditGame([Bind(Include = "game,team1ID,team2ID")] GameCreateModel gcm)
{
if (ModelState.IsValid)
{
db.Entry(gcm.game).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View("EditGame", gcm));
}
public async Task <int> CreateAsync(GameCreateModel model, IPrincipal currentPrincipal)
{
IdentityUser user = await context.Users.SingleAsync(x => x.UserName == currentPrincipal.Identity.Name);
Game game = ModelToGame(model.FirstPlayerId, user.Id);
context.Games.Add(game);
await context.SaveChangesAsync();
return(game.Id);
}
public async Task ValidateNewGameAsync_ZeroColumnsAsync()
{
var model = new GameCreateModel
{
Columns = 0,
Rows = 3,
Type = GameType.Standard,
};
await _gameValidator.ValidateNewGameAsync(model);
}
public async Task ValidateNewGameAsync_NegativeColumnsAsync()
{
var model = new GameCreateModel
{
Columns = -1,
Rows = 3,
Type = GameType.Standard,
};
await Assert.ThrowsAsync <ArgumentOutOfRangeException>(() => _gameValidator.ValidateNewGameAsync(model));
}
public async Task ValidateForCreate(IPrincipal currentPrincipal, GameCreateModel model)
{
await ValidateCurrentUser(currentPrincipal, model.SecondPlayerId);
if (!(await ValidateExistingUserId(model.SecondPlayerId)))
{
AddError("There is no such user.");
}
HandleErrors();
}
public ActionResult Create(GameCreateModel parameters)
{
var _teamLogic = new TeamLogic();
ViewBag.Teams = _teamLogic.GetAll(new BL.Models.Core.Filter()).Output;
var opResult = _gameLogic.Add(parameters);
if (opResult.IsSuccess)
{
return(RedirectToAction("index"));
}
return(View(parameters));
}
public static async Task <Game> CreateNewGame(GameCreateModel createGameModel, UserManager <ApplicationUser> userManager)
{
var players = new List <Player>();
players.Add(await GetPlayerFromEmail(createGameModel.Player1, userManager));
players.Add(await GetPlayerFromEmail(createGameModel.Player2, userManager));
players.Add(await GetPlayerFromEmail(createGameModel.Player3, userManager));
var newGame = new Game(players);
newGame.Deals.Add(new Deal());
//var initialDeal = CreateDeal();
//newGame.Deals.Add(initialDeal);
newGame.Description = createGameModel.Description;
return(newGame);
}
public async Task <IActionResult> CreateGame([FromBody] GameCreateModel game)
{
CreateGameDto createdGame = new CreateGameDto()
{
Name = game.Name,
Description = game.Description,
PublisherId = game.PublisherId,
Genres = game.Genres,
Platforms = game.Platforms,
};
await gameService.AddGame(createdGame);
return(StatusCode((int)HttpStatusCode.Created, "Game was added"));
}
public ActionResult CreateGame([Bind(Include = "game,team1ID,team2ID")] GameCreateModel gamecreate)
{
DateTime dat = DateTime.Now;
Game game1 = gamecreate.game;
game1.StartTime = dat;
game1.EndTime = dat.AddMinutes(105);
game1.team1Score = 0;
game1.team2Score = 0;
game1.Team1ID = gamecreate.team1ID;
game1.Team2ID = gamecreate.team2ID;
db.Games.Add(game1);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Create(GameCreateModel game)
{
if (ModelState.IsValid)
{
var newGame = new Game();
newGame.Name = game.Name;
newGame.GameState = GameState.Created;
newGame.First_PlayerId = this.User.Identity.GetUserId();
this.Data.Games.Add(newGame);
this.Data.SaveChanges();
return(RedirectToAction("PickTeam", "GameInfo", new { id = newGame.Id }));
}
return(View(game));
}
public async Task PostAsync_Unauthorized()
{
await RunAsync(async factory =>
{
var game = new GameCreateModel
{
DeckId = 401,
Type = GameType.Standard,
};
var client = factory.CreateClient();
var response = await client.PostJsonAsync("api/games", game);
Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
});
}
public async Task <IActionResult> EditGame(int id, [FromBody] GameCreateModel game)
{
EditGameDto dto = new EditGameDto()
{
Id = id,
Description = game.Description,
Genres = game.Genres,
Name = game.Name,
Platforms = game.Platforms,
PublisherId = game.PublisherId
};
await gameService.EditGame(dto);
return(StatusCode((int)HttpStatusCode.NoContent));
}
public async Task PostAsync_DeckNotEnoughCards_ReturnsBadRequest()
{
await RunAsync(async factory =>
{
await factory.AddDataAsync(
new CardModel
{
Id = IdCard + 1,
}
);
await factory.AddDataAsync(
new DeckData
{
Id = 401,
MaxCards = 5,
UserId = 1,
Cards = new DeckCardData[]
{
new DeckCardData
{
CardCollectionId = IdCardCollection + 1,
CardId = IdCard + 1,
},
new DeckCardData
{
CardCollectionId = IdCardCollection + 2,
CardId = IdCard + 1,
},
}
}
);
var game = new GameCreateModel
{
DeckId = 401,
Type = GameType.Standard,
};
var client = factory.CreateClientWithAuth();
var response = await client.PostJsonAsync("api/games", game);
var model = await response.Content.ReadAsAsync <ErrorViewModel>();
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
Assert.Equal($"Deck 401 needs 5 cards. Currently only has 2.", model.Message);
});
}
public async Task <ActionResult <GameModel> > PostAsync(GameCreateModel model, CancellationToken cancellationToken)
{
var userId = (await GetUserAsync(cancellationToken: cancellationToken)).Id;
var game = new GameCreateModel
{
DeckId = model.DeckId,
Type = model.Type,
Users = new UserModel[] { new UserModel {
Id = userId
} },
};
var newGame = await _gameService.CreateGameAsync(game, cancellationToken : cancellationToken);
return(CreatedAtAction(nameof(GetByIdAsync), new { id = newGame.Id }, newGame));
}
async Task <GameModel> IGameService.CreateGameAsync(GameCreateModel game, CancellationToken cancellationToken)
{
await _gameValidator.ValidateNewGameAsync(game, cancellationToken : cancellationToken);
var newGameCreate = _gameCreateMapper.Map(game);
var newGame = await _gameRepository.AddGameAsync(newGameCreate, cancellationToken : cancellationToken);
if (game.Users != null)
{
foreach (var user in game.Users)
{
await AddUserToGameInternalAsync(newGame.Id, user.Id, game.DeckId, cancellationToken : cancellationToken);
}
}
return(_gameMapper.Map(newGame));
}
public ActionResult Create(string tournamentSlug, int id)
{
ViewBag.RoundId = new SelectList(db.Rounds, "Id", "Name", id);
var teams = db.Teams.Where(t => t.Tournament.Slug == tournamentSlug);
ViewBag.HomeTeamId = new SelectList(teams, "Id", "Name");
ViewBag.AwayTeamId = new SelectList(teams, "Id", "Name");
var fields = db.Fields.ToList();
ViewBag.FieldId = new SelectList(fields, "Id", "Name");
var model = new GameCreateModel
{
RoundId = id
};
return(View(model));
}
public IHttpActionResult CreateGame(GameCreateModel game)
{
if (!this.ModelState.IsValid)
{
return(this.BadRequest("Please input game name and secret number!"));
}
if (!this.ValidNumber(game.Number))
{
return(this.BadRequest("The number isn't valid"));
}
var newGame = new Game
{
Name = game.Name,
Red = this.User.Identity.Name,
RedNumber = game.Number,
Blue = "No blue player yet",
BlueNumber = "0",
Guesses = new HashSet <Guess>(),
GameState = GameState.WaitingForOpponent,
DateCreated = DateTime.Now,
};
this.data.Games.Add(newGame);
this.data.SaveChanges();
var responceModel = new GameModel
{
Id = newGame.Id,
Name = newGame.Name,
Blue = newGame.Blue,
Red = newGame.Red,
GameState = newGame.GameState.ToString(),
DateCreated = newGame.DateCreated.ToString()
};
var location = new Uri(this.Url.Link("DefaultApi", new { id = newGame.Id }));
var response = this.Created(location, responceModel);
return(response);
}
public ActionResult EditGame(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Game game = db.Games.Find(id);
if (game == null)
{
return(HttpNotFound());
}
GameCreateModel gcm = new GameCreateModel();
gcm.team1ID = game.Team1ID;
gcm.team2ID = game.Team2ID;
gcm.game = game;
gcm.teams = db.Teams.ToList();
return(View("EditGame", gcm));
}
public IHttpActionResult Post(GameCreateModel game)
{
if (game == null || !ModelState.IsValid)
{
return(this.BadRequest("Invalid game format!"));
}
Game gameResult = this.games.Create(
this.User.Identity.GetUserId(),
game.Name,
game.Number);
var responseResult = new GameCreateResponseModel
{
Blue = "No blue player yet",
DateCreated = gameResult.DateCreated,
GameState = gameResult.GameState.ToString(),
Id = gameResult.GameId,
Name = gameResult.Name,
Red = gameResult.RedUser.UserName
};
return(this.Ok());
}
Task IGameValidator.ValidateNewGameAsync(GameCreateModel game, CancellationToken cancellationToken)
{
if (game == null)
{
throw new ArgumentNullException(nameof(game));
}
if (game.Rows < 0)
{
throw new ArgumentOutOfRangeException(nameof(game), nameof(game.Rows) + " must be >= 0.");
}
if (game.Columns < 0)
{
throw new ArgumentOutOfRangeException(nameof(game), nameof(game.Columns) + " must be >= 0.");
}
if (!Enum.IsDefined(typeof(GameType), game.Type))
{
throw new ArgumentException(nameof(GameType) + " not valid.", nameof(game));
}
return(Task.CompletedTask);
}
public IHttpActionResult Post(GameCreateModel game)
{
if (game == null || !ModelState.IsValid)
{
return this.BadRequest("Invalid game format!");
}
Game gameResult = this.games.Create(
this.User.Identity.GetUserId(),
game.Name,
game.Number);
var responseResult = new GameCreateResponseModel
{
Blue = "No blue player yet",
DateCreated = gameResult.DateCreated,
GameState = gameResult.GameState.ToString(),
Id = gameResult.GameId,
Name = gameResult.Name,
Red = gameResult.RedUser.UserName
};
return this.Ok();
}
public ActionResult Create(GameCreateModel game, IEnumerable <HttpPostedFileBase> uploads)
{
List <Picture> pictures = new List <Picture>();
foreach (var file in uploads)
{
if (file != null)
{
byte[] imageData = null;
// считываем переданный файл в массив байтов
using (var binaryReader = new BinaryReader(file.InputStream))
{
imageData = binaryReader.ReadBytes(file.ContentLength);
}
pictures.Add(new Picture {
Image = imageData, Name = file.FileName
});
}
}
// установка массива байтов
Game gameNew = new Game()
{
Name = game.Name,
Description = game.Description,
Price = game.Price,
Language = game.Language,
Discount = game.Discount,
Pictures = pictures,
ReleaseDate = game.ReleaseDate
};
if (store.Developer.Find(d => d.Name == game.Developer).FirstOrDefault() == null)
{
gameNew.Developer = new Developer {
Name = game.Developer
}
}
;
else
{
gameNew.Developer = store.Developer.Find(d => d.Name == game.Developer).FirstOrDefault();
}
///
if (store.Genres.Find(g => game.Genres.Contains(g.Name)).FirstOrDefault() == null)
{
ModelState.AddModelError("Genres", "Ошибка");
return(View(game));
}
else
{
gameNew.Genres = store.Genres.Find(g => game.Genres.Contains(g.Name)).ToList();
}
///
if (store.Features.Find(f => game.Features.Contains(f.Name)).FirstOrDefault() == null)
{
ModelState.AddModelError("Features", "Ошибка");
return(View(game));
}
else
{
gameNew.Features = store.Features.Find(f => game.Features.Contains(f.Name)).ToList();
}
///
store.Games.Create(gameNew);
return(View());
}
public async Task PostAsync_ValidDeck_ReturnsSuccess()
{
await RunAsync(async factory =>
{
await factory.AddDataAsync(
new CardModel
{
Id = IdCard + 1,
}
);
await factory.AddDataAsync(
new DeckData
{
Id = 401,
MaxCards = 5,
UserId = 1,
Cards = new DeckCardData[]
{
new DeckCardData
{
CardCollectionId = IdCardCollection + 1,
CardId = IdCard + 1,
},
new DeckCardData
{
CardCollectionId = IdCardCollection + 2,
CardId = IdCard + 1,
},
new DeckCardData
{
CardCollectionId = IdCardCollection + 3,
CardId = IdCard + 1,
},
new DeckCardData
{
CardCollectionId = IdCardCollection + 4,
CardId = IdCard + 1,
},
new DeckCardData
{
CardCollectionId = IdCardCollection + 5,
CardId = IdCard + 1,
},
}
}
);
var game = new GameCreateModel
{
DeckId = 401,
Type = GameType.Standard,
};
var client = factory.CreateClientWithAuth();
var response = await client.PostJsonAsync("api/games", game);
response.EnsureSuccessStatusCode();
var model = await response.Content.ReadAsAsync <GameModel>();
Assert.NotNull(model);
Assert.True(model.Id > 0);
Assert.Null(model.WinnerUserId);
});
}
