public GameResultViewModel Build(PlayerGameResult playerGameResult, bool showPointsScored = false)
{
Validate(playerGameResult);
GameResultViewModel result = new GameResultViewModel
{
PlayerId = playerGameResult.PlayerId,
PlayerName = PlayerNameBuilder.BuildPlayerName(playerGameResult.Player.Name, playerGameResult.Player.Active),
PointsScored = playerGameResult.PointsScored,
GameRank = playerGameResult.GameRank,
NemePointsSummary = new NemePointsSummaryViewModel(playerGameResult.NemeStatsPointsAwarded, playerGameResult.GameDurationBonusPoints, playerGameResult.GameWeightBonusPoints),
GameDefinitionId = playerGameResult.PlayedGame.GameDefinition.Id,
GameDefinitionName = playerGameResult.PlayedGame.GameDefinition.Name,
PlayedGameId = playerGameResult.PlayedGameId,
DatePlayed = playerGameResult.PlayedGame.DatePlayed,
BoardGameGeekUri = BoardGameGeekUriBuilder.BuildBoardGameGeekGameUri(playerGameResult.PlayedGame.GameDefinition.BoardGameGeekGameDefinitionId),
WinnerType = playerGameResult.PlayedGame.WinnerType,
ShowPointsScored = showPointsScored
};
if (playerGameResult.PlayedGame.GameDefinition.BoardGameGeekGameDefinition != null)
{
result.ThumbnailImageUrl = playerGameResult.PlayedGame.GameDefinition.BoardGameGeekGameDefinition.Thumbnail;
result.ImageUrl = playerGameResult.PlayedGame.GameDefinition.BoardGameGeekGameDefinition.Image;
}
return(result);
}
public void SetUp()
{
this.builder = new GameResultViewModelBuilder();
GameDefinition gameDefinition = new GameDefinition()
{
Id = 15131,
Name = "Yodle-masters 2014"
};
PlayedGame playedGame = new PlayedGame()
{
GameDefinition = gameDefinition,
DatePlayed = new DateTime(2014, 09, 15)
};
this.playerGameResult = new PlayerGameResult()
{
GameRank = 1,
NemeStatsPointsAwarded = 2,
Id = 151,
PlayerId = 15135,
Player = new Player()
{
Name = "Test Player"
},
PlayedGameId = 1432,
PlayedGame = playedGame
};
this.playerGameResultDetails = this.builder.Build(this.playerGameResult);
}
private static void ValidatePlayerGameResultsDetailsAreNotNull(GameResultViewModel playerGameResultDetails)
{
if (playerGameResultDetails == null)
{
throw new ArgumentNullException("playerGameResultDetails");
}
}
// GET: Games/Edit/5
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(NotFound());
}
GameResultViewModel viewModel = new GameResultViewModel();
var game = await _context.Games.FindAsync(id);
viewModel.Game = new Game()
{
};
var players = await _context.Players.ToListAsync();
var playerOne = players.SingleOrDefault(p => p.Id == game.PlayerOneId);
var playerTwo = players.SingleOrDefault(p => p.Id == game.PlayerTwoId);
game.PlayerOne = playerOne;
game.PlayerTwo = playerTwo;
if (game == null)
{
return(NotFound());
}
viewModel.Game = game;
ViewData["PhysicalTableId"] = new SelectList(_context.PhysicalTables, "Id", "Id", game.PhysicalTableId);
ViewData["PlayerOneId"] = new SelectList(_context.Players, "Id", "FirstName", game.PlayerOneId);
ViewData["PlayerTwoId"] = new SelectList(_context.Players, "Id", "FirstName", game.PlayerTwoId);
ViewData["RoundId"] = new SelectList(_context.Rounds, "Id", "Id", game.RoundId);
return(View(viewModel));
}
public void SetUp()
{
builder = new GameResultViewModelBuilder();
GameDefinition gameDefinition = new GameDefinition()
{
Id = 15131,
Name = "Yodle-masters 2014"
};
PlayedGame playedGame = new PlayedGame()
{
GameDefinition = gameDefinition,
DatePlayed = new DateTime(2014, 09, 15),
WinnerType = WinnerTypes.TeamWin
};
playerGameResult = new PlayerGameResult()
{
GameRank = 1,
NemeStatsPointsAwarded = 2,
Id = 151,
PlayerId = 15135,
Player = new Player()
{
Name = "Test Player",
Active = false
},
PlayedGameId = 1432,
PlayedGame = playedGame
};
playerGameResultDetails = builder.Build(playerGameResult);
}
public ActionResult CreateResult(GameResultViewModel gameResultViewModel)
{
Answer answer = new Answer()
{
AnimalId = gameResultViewModel.AnimalId,
CountryId = gameResultViewModel.CountryId
};
_answerRepository.Add(answer);
_answerRepository.SaveChanges();
string currentUserId = User.Identity.GetUserId();
var users = HttpContext.GetOwinContext().GetUserManager <ApplicationUserManager>();
var sad = users.Users.FirstOrDefault(x => x.Id == currentUserId);
GameResult gameResult = new GameResult()
{
AnswerId = answer.Id,
Duration = gameResultViewModel.Duration,
Guesses = gameResultViewModel.Guesses,
IsAnswered = gameResultViewModel.IsAnswered,
UserName = sad.UserName,
};
_gameResultRepository.Add(gameResult);
_gameResultRepository.SaveChanges();
return(Json(gameResult, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// Initializes a new instance of the <see cref="GameResultViewModelBuilder"/> class
/// </summary>
public GameResultViewModelBuilder()
{
_gameResultsViewModel = new GameResultViewModel()
{
HomeTeamId = 1,
AwayTeamId = 2,
HomeTeamName = "HomeTeam",
AwayTeamName = "AwayTeam",
GameDate = DateTime.Parse("2016-04-03 10:00"),
Round = 1,
GameNumber = 0,
GameScore = new ScoreViewModel(3, 1),
SetScores = new List <ScoreViewModel>()
{
new ScoreViewModel(27, 25),
new ScoreViewModel(33, 31),
new ScoreViewModel(27, 25),
new ScoreViewModel(24, 26),
new ScoreViewModel(),
},
IsTechnicalDefeat = false,
TournamentId = 1,
UrlToGameVideo = "http://test-url-a.com",
};
}
// GET: Medals
public ActionResult Index()
{
// http://stackoverflow.com/a/13846627
GameResultViewModel viewModel = new GameResultViewModel();
viewModel.GameResultMedals = db.EventCompetitors
.Include(c => c.Competitor)
.GroupBy(c => c.Competitor.competitorCountry)
.Select(r => new GameResultMedals {
Country = r.Key, Gold = r.Count(a => a.competitorMedal == "Gold"),
Silver = r.Count(a => a.competitorMedal == "Silver"),
Bronze = r.Count(a => a.competitorMedal == "Bronze"),
Total = r.Count(a => a.competitorMedal != "None")
})
.OrderByDescending(a => a.Total)
.ThenBy(a => a.Country).ToList();
viewModel.GameResultRecords = db.EventCompetitors
.Include(c => c.Competitor)
.Include(c => c.Event)
.Where(ec => ec.Event.worldRecord == true && ec.competitorMedal == "Gold")
.Select(r => new GameResultRecords {
CompetitorName = r.Competitor.competitorName,
Game = r.Event.Game.gameName
})
.OrderBy(a => a.CompetitorName).ToList();
return(View(viewModel));
}
public GameResultViewModel Add(GameResultViewModel obj)
{
var GameResult = MapperGameResultToModel(obj);
GameResult = _GameResultServico.Add(GameResult);
_GameResultServico.Commit();
return(MapperGameResultToViewModel(GameResult));
}
/// <summary>
/// Renders a view with empty fields of game result for create operation.
/// </summary>
/// <param name="tournamentId">Identifier of the tournament where game result belongs.</param>
/// <returns>View with empty fields of game result.</returns>
public ActionResult Create(int tournamentId)
{
var gameResultViewModel = new GameResultViewModel {
TournamentId = tournamentId,
};
return(View(gameResultViewModel));
}
private GameResult GetGameResultObj(GameResultViewModel gameResultViewModel, Gamer gamer)
{
var result = Mapper.Map <GameResult>(gameResultViewModel);
result.Gamer = _gamerService.GetGamer(Guid.Parse(gameResultViewModel.GamerId));
result.BoardGame = _boardGameService.Get(gameResultViewModel.BoardGameId);
Mapper.Map(gamer, result);
return(result);
}
public void Map_GameResultDtoAsParam_MappedToViewModel()
{
// Arrange
var testViewModel = new GameResultViewModelBuilder()
.WithId(1)
.WithTournamentId(1)
.WithHomeTeamId(1)
.WithAwayTeamId(2)
.WithHomeTeamName("HomeTeam")
.WithAwayTeamName("AwayTeam")
.WithSetsScore(3, 0)
.WithTechnicalDefeat(false)
.WithDate(DateTime.Parse("2016-04-12 12:15"))
.WithRound(1)
.WithSetScores(new List <ScoreViewModel>
{
new ScoreViewModel(25, 20),
new ScoreViewModel(26, 24),
new ScoreViewModel(30, 28),
new ScoreViewModel(0, 0),
new ScoreViewModel(0, 0),
})
.Build();
testViewModel.GameNumber = TEST_GAME_NUMBER;
var testDomainModel = new GameResultDtoBuilder()
.WithId(1)
.WithTournamentId(1)
.WithHomeTeamId(1)
.WithAwayTeamId(2)
.WithHomeTeamName("HomeTeam")
.WithAwayTeamName("AwayTeam")
.WithHomeSetsScore(3)
.WithAwaySetsScore(0)
.WithNoTechnicalDefeat()
.WithHomeSet1Score(25)
.WithHomeSet2Score(26)
.WithHomeSet3Score(30)
.WithHomeSet4Score(0)
.WithHomeSet5Score(0)
.WithAwaySet1Score(20)
.WithAwaySet2Score(24)
.WithAwaySet3Score(28)
.WithAwaySet4Score(0)
.WithAwaySet5Score(0)
.WithDate(DateTime.Parse("2016-04-12 12:15"))
.WithRound(1)
.Build();
testDomainModel.GameNumber = TEST_GAME_NUMBER;
// Act
var actual = GameResultViewModel.Map(testDomainModel);
// Assert
TestHelper.AreEqual <GameResultViewModel>(testViewModel, actual, new GameResultViewModelComparer());
}
public static MvcHtmlString GameResults(this HtmlHelper htmlHelper, GameResultViewModel playerGameResultDetails, WinnerTypes?winnerType)
{
Validate(playerGameResultDetails);
string cssPlace;
string gameRankText;
if (winnerType == WinnerTypes.TeamWin)
{
cssPlace = CSS_CLASS_TEAM_WIN;
gameRankText = PLACE_TEAM_WIN;
}
else if (winnerType == WinnerTypes.TeamLoss)
{
cssPlace = CSS_CLASS_TEAM_LOSS;
gameRankText = PLACE_EVERYONE_LOST;
}
else
{
switch (playerGameResultDetails.GameRank)
{
case 1:
cssPlace = CSS_CLASS_FIRST_PLACE;
gameRankText = PLACE_FIRST;
break;
case 2:
cssPlace = CSS_CLASS_SECOND_PLACE;
gameRankText = PLACE_SECOND;
break;
case 3:
cssPlace = CSS_CLASS_THIRD_PLACE;
gameRankText = PLACE_THIRD;
break;
case 4:
cssPlace = CSS_CLASS_FOURTH_PLACE;
gameRankText = PLACE_FOURTH;
break;
default:
cssPlace = CSS_CLASS_LOSER_PLACE;
gameRankText = PLACE_BIG_LOSER;
break;
}
}
string nemeStatsPointsComponent = string.Format(HTML_GORDON_POINTS_TEMPLATE, playerGameResultDetails.NemeStatsPointsAwarded, htmlHelper.NemePointsIco(showTooltip: true, tooltip: NEMEPOINTICO_TOOLTIP, tooltipPosition: NEMEPOINTSICO_TOOLTIP_POSITION));
return(MvcHtmlString.Create(string.Format(HTML_TEMPLATE,
CSS_CLASS_GAME_RANK,
cssPlace,
gameRankText,
nemeStatsPointsComponent)));
}
public void PlayersNumberPasses(int playersNumber, int place)
{
var gameResult = new GameResultViewModel
{
PlayersNumber = playersNumber,
Place = place
};
_gameResultValidator.ShouldNotHaveValidationErrorFor(x => x.PlayersNumber, gameResult);
}
public static Bet MapGameResultViewModelToBet(GameResultViewModel gameResultViewModel, int userBetId)
{
return(new Bet
{
HomeGoals = gameResultViewModel.HomeGoals,
AwayGoals = gameResultViewModel.AwayGoals,
Result = GetGameResult(gameResultViewModel.HomeGoals, gameResultViewModel.AwayGoals),
GameId = gameResultViewModel.Id,
UserBetId = userBetId
});
}
public JsonResult Edit(GameResultViewModel model)
{
if (!(Session["gamer"] is Gamer))
{
return(Json(Errors.GamerNotLoggedIn, JsonRequestBehavior.AllowGet));
}
var gameResult = Mapper.Map <GameResult>(model);
_gameResultService.EditGameResult(gameResult);
return(Json(null, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> Edit(int id, GameResultViewModel viewModel)
{
//if (id != game.Id)
//{
// return NotFound();
//}
var players = await _context.Players.ToListAsync();
if (viewModel.Result == 1)
{
viewModel.Game.PlayerOneScore = 1;
viewModel.Game.PlayerTwoScore = 0;
}
else if (viewModel.Result == 2)
{
viewModel.Game.PlayerOneScore = 0;
viewModel.Game.PlayerTwoScore = 1;
}
else if (viewModel.Result == 3)
{
viewModel.Game.PlayerOneScore = 0.5;
viewModel.Game.PlayerTwoScore = 0.5;
}
if (ModelState.IsValid)
{
try
{
_context.Update(viewModel.Game);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!GameExists(viewModel.Game.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("IndexUncompleted"));
//return RedirectToAction(nameof(Index));
}
ViewData["PhysicalTableId"] = new SelectList(_context.PhysicalTables, "Id", "Id", viewModel.Game.PhysicalTableId);
ViewData["PlayerOneId"] = new SelectList(_context.Players, "Id", "FirstName", viewModel.Game.PlayerOneId);
ViewData["PlayerTwoId"] = new SelectList(_context.Players, "Id", "FirstName", viewModel.Game.PlayerTwoId);
ViewData["RoundId"] = new SelectList(_context.Rounds, "Id", "Id", viewModel.Game.RoundId);
return(RedirectToAction("IndexUncompleted"));
}
/// <summary>
/// Gets the view for view model of the schedule with specified identifier.
/// </summary>
/// <param name="tournamentId">Identifier of the tournament.</param>
/// <returns>View for view model of the schedule with specified identifier.</returns>
public ActionResult ShowSchedule(int tournamentId)
{
var tournament = _tournamentService.GetTournamentScheduleInfo(tournamentId);
if (tournament == null)
{
ModelState.AddModelError("LoadError", TournamentController.TournamentNotFound);
return(View());
}
var scheduleViewModel = new ScheduleViewModel
{
TournamentId = tournament.Id,
TournamentName = tournament.Name,
TournamentScheme = tournament.Scheme,
MaxNumberOfRounds = tournament.Divisions.Max(d => d.NumberOfRounds),
Rounds = _gameService.GetTournamentGames(tournamentId)
.GroupBy(d => d.Round)
.ToDictionary(
d => d.Key,
c => c.OrderBy(t => t.GameNumber).ThenBy(t => t.GameDate)
.Select(x => GameResultViewModel.Map(x)).ToList()),
AllowedOperations = _authService.GetAllowedOperations(new List <AuthOperation>()
{
AuthOperations.Games.Create,
AuthOperations.Games.Edit,
AuthOperations.Games.Delete,
AuthOperations.Games.SwapRounds,
AuthOperations.Games.EditResult
})
};
if (tournament.Scheme == TournamentSchemeEnum.PlayOff)
{
FillRoundNames(scheduleViewModel);
}
for (byte i = 0; i < scheduleViewModel.Rounds.Count; i++)
{
foreach (var game in scheduleViewModel.Rounds.ElementAt(i).Value)
{
game.AllowedOperations = _authService.GetAllowedOperations(new List <AuthOperation>()
{
AuthOperations.Games.Edit,
AuthOperations.Games.Delete,
AuthOperations.Games.EditResult
});
}
}
return(View(scheduleViewModel));
}
/// <summary>
/// Renders a view with filled in fields of game result for edit operation.
/// </summary>
/// <param name="id">Identifier of the game result.</param>
/// <returns>View with filled in fields of game result.</returns>
public ActionResult Edit(int id)
{
var gameResult = _gameService.Get(id);
if (gameResult == null)
{
return(HttpNotFound());
}
var gameResultsViewModel = GameResultViewModel.Map(gameResult);
return(View(gameResultsViewModel));
}
public void ItRendersTheGameRankInASpanWithTheGameRankClass()
{
HtmlHelper helper = new HtmlHelper(new ViewContext(), new ViewPage());
GameResultViewModel playerGameResultDetails = new GameResultViewModel()
{
GameRank = 1151
};
XElement result = helper.GameResults(playerGameResultDetails, WinnerTypes.PlayerWin).ToXElement();
Assert.AreEqual("span", result.Name.ToString());
Assert.True(result.FirstAttribute.ToString().Contains("class=\"" + PlayedGameHelper.CSS_CLASS_GAME_RANK));
}
public void ItRendersNemeStatsPoints()
{
HtmlHelper helper = new HtmlHelper(new ViewContext(), new ViewPage());
GameResultViewModel playerGameResultDetails = new GameResultViewModel()
{
NemeStatsPointsAwarded = 9
};
XElement result = helper.GameResults(playerGameResultDetails, WinnerTypes.PlayerWin).ToXElement();
string firstNodeText = result.FirstNode.ToString();
Assert.True(firstNodeText.Contains(playerGameResultDetails.NemeStatsPointsAwarded.ToString()));
}
public ActionResult Create(GameResultViewModel gameResultViewModel)
{
var gameResult = gameResultViewModel.ToDomain();
try
{
_gameService.Create(gameResult);
return(RedirectToAction("Details", "Tournaments", new { id = gameResultViewModel.TournamentId }));
}
catch (ArgumentException ex)
{
ModelState.AddModelError("ValidationMessage", ex.Message);
return(View(gameResultViewModel));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ScheduleViewModelBuilder"/> class
/// </summary>
public ScheduleViewModelBuilder()
{
_scheduleViewModel = new ScheduleViewModel()
{
TournamentId = 1,
TournamentName = "Name",
TournamentScheme = TournamentSchemeEnum.One,
MaxNumberOfRounds = 3,
Rounds = new GameServiceTestFixture().TestGameResults()
.Build().GroupBy(d => d.Round)
.ToDictionary(
d => d.Key,
c => c.OrderBy(t => t.GameDate)
.Select(x => GameResultViewModel.Map(x)).ToList())
};
}
public IHttpActionResult Post([FromBody] GameResultViewModel GameResultViewModel)
{
try
{
GameResultViewModel.SetServidorCod(GetIdServidor());
return(Ok(_GameResultAppServico.Add(GameResultViewModel)));
}
catch (Exception e)
{
if (e.InnerException != null)
{
return(BadRequest(e.InnerException.Message));
}
return(BadRequest(e.Message));
}
}
public IActionResult Results(string id)
{
List <GameResultViewModel> gameResultViewModel = new List <GameResultViewModel>();
Poule poule = _pouleRepository.Get(Convert.ToInt32(id));
List <Game> games = poule.Games.Where(a => a.PouleId == Convert.ToInt32(id)).ToList();
foreach (Game g in games)
{
GenerateGameResult(g.Id);
}
foreach (Game g in games)
{
GenerateGameResult(g.Id);
GameResultViewModel gameResult = gameResultViewModel.Find(a => a.TeamId == g.HomeTeamId);
if (gameResult != null)
{
gameResult.Points += (g.HomeScore.Value > g.AwayScore.Value) ? 3 : (g.HomeScore.Value < g.AwayScore.Value) ? 0 : 1;
gameResult.GoalsFor += g.HomeScore.Value;
gameResult.GoalsAgainst += g.AwayScore.Value;
gameResult.GoalDifference += g.HomeScore.Value - g.AwayScore.Value;
}
else
{
gameResultViewModel.Add(
new GameResultViewModel()
{
TeamId = g.HomeTeamId,
TeamName = g.HomeTeam.Name,
Points = (g.HomeScore.Value > g.AwayScore.Value) ? 3 : (g.HomeScore.Value < g.AwayScore.Value) ? 0 : 1,
GoalsFor = g.HomeScore.Value,
GoalsAgainst = g.AwayScore.Value,
GoalDifference = g.HomeScore.Value - g.AwayScore.Value
}
);
}
}
ViewBag.Games = games;
return(View(gameResultViewModel.OrderByDescending(a => a.Points).ThenByDescending(a => a.GoalDifference).ThenByDescending(a => a.GoalsFor).ThenBy(a => a.GoalsAgainst).ToList()));
}
public void CreateGetAction_GameResultViewModelRequested_GameResultViewModelIsReturned()
{
// Arrange
_teamServiceMock.Setup(ts => ts.Get()).Returns(new List <Team>());
var expected = new GameResultViewModel
{
TournamentId = TOURNAMENT_ID
};
var controller = BuildSUT();
// Act
var actual = TestExtensions.GetModel <GameResultViewModel>(controller.Create(TOURNAMENT_ID));
// Assert
TestHelper.AreEqual <GameResultViewModel>(expected, actual, new GameResultViewModelComparer());
}
private void TestRenderingForGivenRank(int gameRank, WinnerTypes winnerType, string expectedCssClass, string expectedRankText)
{
HtmlHelper helper = new HtmlHelper(new ViewContext(), new ViewPage());
GameResultViewModel playerGameResultDetails = new GameResultViewModel()
{
GameRank = gameRank
};
XElement result = helper.GameResults(playerGameResultDetails, winnerType).ToXElement();
string firstAttribute = result.FirstAttribute.ToString();
StringAssert.Contains("class=\"", firstAttribute);
StringAssert.Contains(expectedCssClass, firstAttribute);
string firstNodeText = result.FirstNode.ToString();
StringAssert.StartsWith(expectedRankText, firstNodeText);
}
public JsonResult Add(GameResultViewModel gameResultViewModel)
{
if (ModelState.IsValid)
{
if (!(Session["gamer"] is Gamer gamer))
{
return(Json(Errors.GamerNotLoggedIn, JsonRequestBehavior.AllowGet));
}
var gameResultDto = Mapper.Map <GameResultDto>(gameResultViewModel);
_gameResultService.AddGameResult(gameResultDto, gamer);
return(Json(null, JsonRequestBehavior.AllowGet));
}
var errors = Helpers.GetErrorMessages(ModelState.Values);
return(Json(errors, JsonRequestBehavior.AllowGet));
}
public ActionResult Edit(GameResultViewModel gameResultViewModel)
{
try
{
if (ModelState.IsValid)
{
var gameResult = gameResultViewModel.ToDomain();
_gameService.EditGameResult(gameResult);
return(RedirectToAction("ShowSchedule", "Tournaments", new { tournamentId = gameResultViewModel.TournamentId }));
}
}
catch (MissingEntityException)
{
ModelState.AddModelError(string.Empty, Resources.UI.GameResultsController.GameResultWasDeleted);
}
catch (ArgumentException)
{
ModelState.AddModelError(string.Empty, Resources.UI.GameResultsController.GameResultNotEdited);
}
return(View(gameResultViewModel));
}
public async Task <IHttpActionResult> PostGameResult(GameResultViewModel gameResultData)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = _db.Users.Find(User.Identity.GetUserId());
var network = await _db.NeuralNetworks
.SingleOrDefaultAsync(x => x.Generation == gameResultData.Generation);
var gameResult = new GameResult
{
User = user,
Network = network,
Score = gameResultData.Score
};
_db.GameResults.Add(gameResult);
await _db.SaveChangesAsync();
return(Ok());
}
