public ActionResult Edit(GameEditModel game, string tournamentSlug)
{
if (game.HomeTeamId == game.AwayTeamId)
{
ModelState.AddModelError("AwayTeamId", "A team cannot play itself");
}
if (ModelState.IsValid)
{
var dbGame = db.Games.Include(g => g.Teams).FirstOrDefault(g => g.Id == game.Id);
if (dbGame == null)
{
return(HttpNotFound());
}
dbGame.AddTeams(db.Teams.Find(game.HomeTeamId), db.Teams.Find(game.AwayTeamId));
dbGame.GameTime = game.GameTime;
dbGame.FieldId = game.FieldId;
db.SaveChanges();
return(RedirectToAction("Standings", "Home", new { tournamentSlug }));
}
var teams = db.Teams.Where(t => t.Tournament.Slug == tournamentSlug);
ViewBag.HomeTeamId = new SelectList(teams, "Id", "Name", game.HomeTeamId);
ViewBag.AwayTeamId = new SelectList(teams, "Id", "Name", game.AwayTeamId);
return(View(game));
}
public void IncrementAnswered(ApplicationUser player, GameEditModel gameModel, ApplicationDbContext context)
{
switch (gameModel.CategoryColor)
{
case "Blue":
player.BlueAnswered++;
break;
case "Pink":
player.PinkAnswered++;
break;
case "Yellow":
player.YellowAnswered++;
break;
case "Brown":
player.BrownAnswered++;
break;
case "Green":
player.GreenAnswered++;
break;
case "Orange":
player.OrangeAnswered++;
break;
}
context.SaveChanges();
}
public void ShouldConvertToEntity()
{
var localtime = new DateTime(2018, 5, 30, 9, 24, 37);
var viewModelObject = new GameEditModel
{
AwayTeam = "Awayteam",
HomeTeam = "Hometeam",
Date = localtime,
Round = RoundType.First,
FulltimeScore = "3-4",
HalftimeScore = "1-2"
};
var convertor = new GameConverter();
var entity = convertor.ToEntity(viewModelObject, 2);
Assert.AreEqual(viewModelObject.HomeTeam, entity.HomeTeam);
Assert.AreEqual(viewModelObject.AwayTeam, entity.AwayTeam);
Assert.AreEqual(viewModelObject.Round, entity.Round);
Assert.AreEqual(viewModelObject.HalftimeScore, entity.HalftimeScore);
Assert.AreEqual(viewModelObject.FulltimeScore, entity.FulltimeScore);
// Date should be converted from local time to UTC
// localtime is in CEST so -2 hours
Assert.AreEqual(entity.Date, new DateTime(2018, 5, 30, 7, 24, 37));
}
public bool UpdateGame(GameEditModel model)
{
var vsvc = new VersionService();
using (var ctx = new ApplicationDbContext())
{
if (model.GameVersionId == null)
{
var firstEntity =
ctx
.GameBases
.Single(e => e.PlayerId == model.GameBaseId);
firstEntity.GameVersionId = vsvc.GetVersionIdByName(model.GameVersion);
firstEntity.QuestionId = model.QuestionId;
firstEntity.Answer = model.Answer;
firstEntity.NumberOfPlayers = model.NumberOfPlayers;
return(ctx.SaveChanges() == 1);
}
var entity =
ctx
.GameBases
.Single(e => e.PlayerId == model.GameBaseId);
entity.GameVersionId = model.GameVersionId;
entity.QuestionId = model.QuestionId;
entity.Answer = model.Answer;
entity.PlayerTurn = model.PlayerTurn;
return(ctx.SaveChanges() == 1);
}
}
public ActionResult Edit(int id, string tournamentSlug)
{
var game = db.Games.Include(g => g.Teams).FirstOrDefault(g => g.Id == id);
if (game == null)
{
return(HttpNotFound());
}
var model = new GameEditModel
{
Id = game.Id
};
if (game.HomeTeam != null)
{
model.HomeTeamId = game.HomeTeam.Id;
}
if (game.AwayTeam != null)
{
model.AwayTeamId = game.AwayTeam.Id;
}
model.GameTime = game.GameTime;
var teams = db.Teams.Where(t => t.Tournament.Slug == tournamentSlug);
ViewBag.HomeTeamId = new SelectList(teams, "Id", "Name", model.HomeTeamId);
ViewBag.AwayTeamId = new SelectList(teams, "Id", "Name", model.AwayTeamId);
var fields = db.Fields.ToList();
ViewBag.FieldId = new SelectList(fields, "Id", "Name", model.FieldId);
return(View(model));
}
public async Task <ServiceResult> CreateGame(GameEditModel model)
{
var user = await authService.GetCurrentUser();
if (!user.IsSuccess)
{
return(Error(user.ErrorMessage));
}
var game = new Game
{
Name = model.Name,
Description = model.Description,
GameUsers = new List <GameUser> {
new GameUser {
UserId = user.Data.Id, PlayerRole = PlayerRole.Creator
}
},
//MaxPlayersCount = model.MaxPlayersCount,
PlaneStartDate = model.PlaneStartDate
};
context.Games.Add(game);
await context.SaveChangesAsync();
return(Success((object)game.Id));
}
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));
}
public ActionResult Edit(string id)
{
using (var ctx = new ApplicationDbContext())
{
ViewBag.VersionName = new SelectList(ctx.Versions.ToList(), "Name", "Name");
var svc = new GameService();
var detail = svc.GetGameById(id);
if (detail.GameVersionId == null)
{
var firstModel =
new GameEditModel
{
GameBaseId = detail.GameBaseId,
Answer = null
};
return(View(firstModel));
}
var qsvc = new QuestionService();
var questions = qsvc.GetQuestionsByVersionId(detail.GameVersionId);
QuestionDetail question = new QuestionDetail();
while (question.Text == null || _usedQuestions.Contains(question.Id))
{
var index = _random.Next(0, questions.Count());
question = questions[index];
if (_usedQuestions.Count == questions.Count)
{
_usedQuestions = new List <int>();
}
}
detail.QuestionId = question.Id;
detail.Question.Text = question.Text;
detail.Question.Answers = question.Answers;
detail.Question.Category = new Category();
detail.Question.Category.Color = question.Category.Color;
detail.Question.Category.Name = question.Category.Name;
var repeatModel =
new GameEditModel
{
GameBaseId = detail.GameBaseId,
GameVersionId = detail.GameVersionId,
QuestionId = detail.QuestionId,
Question = detail.Question,
CategoryColor = detail.Question.Category.Color,
Answer = "",
CategoryName = detail.Question.Category.Name,
NumberOfPlayers = detail.NumberOfPlayers,
PlayerTurn = detail.PlayerTurn,
PlayerOnePie = detail.PlayerOnePie,
PlayerTwoPie = detail.PlayerTwoPie,
PlayerThreePie = detail.PlayerThreePie,
PlayerFourPie = detail.PlayerFourPie,
DisplayName = detail.DisplayName
};
_usedQuestions.Add(question.Id);
return(View(repeatModel));
}
}
public IActionResult OnGet(int id)
{
Game = _gameConverter.ToEditModel(_gameData.Get(id));
if (Game == null)
{
return(NotFound());
}
return(Page());
}
public IActionResult OnGet(int id)
{
Game = _gameConverter.ToEditModel(_gameData.Get(id));
Id = id;
if (Game == null)
{
return(RedirectToAction("Index", "Home"));
}
return(Page());
}
public ScoreModel GetScoreForUser(GameEditModel game, int user)
{
// return ordered list of predictions for a game
var prediction = Predictions.Where(p => p.Game.Id == game.Id).FirstOrDefault(p => p.User.Id == user);
var score = new ScoreModel();
if (prediction != null)
{
score.HalftimeScore = prediction.HalftimeScore;
score.FulltimeScore = prediction.FulltimeScore;
score.Points = _scoreCalculator.Calculate(game.HalftimeScore, game.FulltimeScore, prediction.HalftimeScore, prediction.FulltimeScore);
}
;
return(score);
}
public async Task <ServiceResult> EditGame(int gameId, GameEditModel model)
{
var game = await GetGameByPlayerRoles(gameId, PlayerRole.Creator);
if (!game.IsSuccess)
{
return(Error(game.ErrorMessage));
}
game.Data.Name = model.Name;
game.Data.Description = model.Description;
//game.Data.MaxPlayersCount =game.Data.GameUsers.Count< model.MaxPlayersCount? model.MaxPlayersCount:game.Data.MaxPlayersCount;
game.Data.PlaneStartDate = model.PlaneStartDate;
await context.SaveChangesAsync();
return(Success((object)game.Data.Id));
}
public Game ToEntity(GameEditModel game, int id)
{
var g = new Game
{
Order = game.Order,
Date = TimeZoneInfo.ConvertTimeToUtc(game.Date, TimeZoneInfo.Local),
Round = game.Round,
HomeTeam = game.HomeTeam,
AwayTeam = game.AwayTeam,
HalftimeScore = game.HalftimeScore,
FulltimeScore = game.FulltimeScore
};
if (id > 0)
{
g.Id = id;
}
return(g);
}
public void UpdateAPie(GameBase gameBase, GameEditModel model, ApplicationDbContext context)
{
switch (model.PlayerTurn)
{
case 1:
UpdateThisPie(gameBase.PlayerOnePie, model.CategoryColor);
break;
case 2:
UpdateThisPie(gameBase.PlayerTwoPie, model.CategoryColor);
break;
case 3:
UpdateThisPie(gameBase.PlayerThreePie, model.CategoryColor);
break;
case 4:
UpdateThisPie(gameBase.PlayerFourPie, model.CategoryColor);
break;
}
context.SaveChanges();
}
public int?UpdatePlayerTurn(GameEditModel model)
{
if (model.NumberOfPlayers == 2)
{
if (model.PlayerTurn == 1)
{
return(2);
}
}
if (model.NumberOfPlayers == 3)
{
if (model.PlayerTurn == 1)
{
return(2);
}
if (model.PlayerTurn == 2)
{
return(3);
}
}
if (model.NumberOfPlayers == 4)
{
if (model.PlayerTurn == 1)
{
return(2);
}
if (model.PlayerTurn == 2)
{
return(3);
}
if (model.PlayerTurn == 3)
{
return(4);
}
}
return(1);
}
public async Task <ObjectControllerResult> EditGame(int id, GameEditModel model)
{
return(Result(await gameService.EditGame(id, model)));
}
public async Task <ObjectControllerResult> CreateRoorm(GameEditModel model)
{
return(Result(await gameService.CreateGame(model)));
}
public ActionResult Edit(string id, GameEditModel model)
{
using (var ctx = new ApplicationDbContext())
{
ViewBag.VersionName = new SelectList(ctx.Versions.ToList(), "Name", "Name");
if (!ModelState.IsValid)
{
return(View(model));
}
if (model.GameBaseId != id)
{
ModelState.AddModelError("", "Id Mismatch");
return(View(model));
}
//successful here
var qsvc = new QuestionService();
var csvc = new CategoryService();
var playerId = User.Identity.GetUserId();
var player = ctx.Users.Single(e => e.Id == playerId);
var game = ctx.GameBases.Single(e => e.PlayerId == playerId);
var gsvc = new GameService();
if (model.Answer != null)
{
var boolean = true;
var question = qsvc.GetQuestionByIdForGame(model.QuestionId);
string correctAnswer = question.Answers.Single(e => e.IsCorrectSpelling == boolean).Text;
model.Question = new Question();
model.Question.IsUserGenerated = question.IsUserGenerated;
bool isCorrect = gsvc.CheckIfCorrect(model.Answer, question.Answers.ToList());
if (model.PlayerTurn == 1 && !model.Question.IsUserGenerated)
{
gsvc.IncrementAnswered(player, model, ctx);
}
if (isCorrect)
{
if (model.PlayerTurn == 1 && !model.Question.IsUserGenerated)
{
gsvc.IncrementCorrect(player, model, ctx);
}
gsvc.UpdateAPie(game, model, ctx);
TempData["Correct"] = "Correct.";
if (gsvc.UpdateGame(model))
{
if (gsvc.CheckWinCondition(game))
{
return(RedirectToAction("Win"));
}
return(RedirectToAction("Edit"));
}
}
if (!isCorrect)
{
model.PlayerTurn = gsvc.UpdatePlayerTurn(model);
if (model.PlayerTurn == 1)
{
TempData["Incorrect"] = $"Incorrect. The correct answer was {correctAnswer}. Turn goes to player {model.PlayerTurn}";
}
else
{
TempData["Incorrect"] = $"Incorrect. The correct answer was {correctAnswer}. Turn goes to {model.DisplayName}";
}
}
}
if (gsvc.UpdateGame(model))
{
return(RedirectToAction("Edit"));
}
ModelState.AddModelError("", "Something went wrong");
model.GameVersion = null;
return(View(model));
}
}
