// GET: Players/Details/5
public async Task <IActionResult> Details(int?id)
{
if (id == null)
{
return(NotFound());
}
var viewModel = new PlayerDetailsViewModel()
{
Player = await _playersService.GetPlayerAsync(id.Value)
};
if (viewModel.Player == null)
{
return(NotFound());
}
viewModel.Games = await _gamesService.GetFinalGamesByTeamAsync(viewModel.Player.TeamID);
viewModel.GameLogs = new List <PlayerGameStats>();
foreach (Game g in viewModel.Games)
{
var log = _playerGameStatsService.GetPlayerGameStatsByGameAsync(viewModel.Player.PlayerID, g.GameID);;
viewModel.GameLogs.Add(await log);
}
return(View(viewModel));
}
public async Task <IActionResult> Details(Guid id)
{
if (id == null)
{
return(NotFound());
}
var player = await _context.ApplicationUsers.FirstOrDefaultAsync(t => t.Id == id.ToString());
if (player == null)
{
return(NotFound());
}
var team = await _context.Team
.FirstOrDefaultAsync(t => t.Id == player.TeamId);
var position = await _context.Position
.FirstOrDefaultAsync(p => p.Id == player.PositionId);
var currentUser = await GetCurrentUserAsync();
PlayerDetailsViewModel viewModel = new PlayerDetailsViewModel
{
Player = player,
PlayerTeam = team == null ? "" : team.Name,
Position = position.Name,
IsOnTeam = (player.TeamId == currentUser.TeamId &&
currentUser.TeamId != null &&
player.TeamId != null) ? true : false
};
return(View(viewModel));
}
public PlayerDetailsViewModel RetrievePlayer(int id)
{
var playerProcessor = new PlayerProcessor();
var player = new PlayerDetailsViewModel();
player.player = new Person();
player.contract = new Contract();
player.healthCheck = new HealthCheckEvidention();
try
{
var myPlayer = playerProcessor.RetrievePlayerDetails(id);
player.player = playerProcessor.RetrievePlayer(myPlayer.Id);
if (myPlayer.ContractId != 0 && myPlayer.ContractId != null)
{
player.contract = playerProcessor.RetrieveContract(myPlayer.ContractId);
}
if (myPlayer.HealthCheckId != 0 && myPlayer.HealthCheckId != null)
{
player.healthCheck = playerProcessor.RetrieveHealthCheck(myPlayer.HealthCheckId);
}
}
catch (Exception e)
{
player = null;
}
return(player);
}
public void ItSetsThePlayerRegisteredFlagToFalseIfThereIsNoApplicationUserIdOnThePlayer()
{
_playerDetails.ApplicationUserId = null;
_playerDetailsViewModel = _autoMocker.ClassUnderTest.Build(_playerDetails, _expectedPlayerIdToRegisteredEmailDictionary, _twitterMinionBraggingUrl, _currentUser);
Assert.AreEqual(false, _playerDetailsViewModel.PlayerRegistered);
}
public void ItSetsThePlayerDetailsViewModelForTheFoundPlayer()
{
PlayerDetails playerDetails = new PlayerDetails()
{
Id = playerId, PlayerGameResults = new List <PlayerGameResult>()
};
autoMocker.Get <IPlayerRetriever>().Expect(playerLogic => playerLogic.GetPlayerDetails(playerId, PlayerController.NUMBER_OF_RECENT_GAMES_TO_RETRIEVE))
.Repeat.Once()
.Return(playerDetails);
PlayerDetailsViewModel playerDetailsViewModel = new PlayerDetailsViewModel()
{
PlayerId = playerId,
PlayerGameResultDetails = new List <GameResultViewModel>()
};
autoMocker.Get <IPlayerDetailsViewModelBuilder>().Expect(viewModelBuilder => viewModelBuilder.Build(playerDetails, expectedMinionUrl, currentUser))
.Repeat
.Once()
.Return(playerDetailsViewModel);
ViewResult viewResult = autoMocker.ClassUnderTest.Details(playerId, currentUser) as ViewResult;
Assert.AreEqual(playerDetailsViewModel, viewResult.Model);
}
public void ItPutsTheRecentGamesMessageOnTheViewbag()
{
PlayerDetails playerDetails = new PlayerDetails()
{
PlayerGameResults = new List <PlayerGameResult>()
};
autoMocker.Get <IPlayerRetriever>().Expect(playerLogic => playerLogic.GetPlayerDetails(
playerId,
PlayerController.NUMBER_OF_RECENT_GAMES_TO_RETRIEVE))
.Repeat.Once()
.Return(playerDetails);
PlayerDetailsViewModel playerDetailsViewModel = new PlayerDetailsViewModel()
{
PlayerId = playerId,
PlayerGameResultDetails = new List <GameResultViewModel>()
};
autoMocker.Get <IPlayerDetailsViewModelBuilder>().Expect(viewModelBuilder => viewModelBuilder.Build(playerDetails, expectedMinionUrl, currentUser))
.Repeat
.Once()
.Return(playerDetailsViewModel);
string expectedMessage = "expected message";
autoMocker.Get <IShowingXResultsMessageBuilder>().Expect(mock => mock.BuildMessage(
PlayerController.NUMBER_OF_RECENT_GAMES_TO_RETRIEVE,
playerDetailsViewModel.PlayerGameResultDetails.Count))
.Return(expectedMessage);
autoMocker.ClassUnderTest.Details(playerId, currentUser);
Assert.AreEqual(expectedMessage, autoMocker.ClassUnderTest.ViewBag.RecentGamesMessage);
}
// GET: Players/Details/5
public async Task <IActionResult> Details(int?id)
{
if (id == null)
{
return(NotFound());
}
var player = await _context.Players
.FirstOrDefaultAsync(m => m.Id == id);
if (player == null)
{
return(NotFound());
}
var model = new PlayerDetailsViewModel()
{
Name = player.Name,
DateOfBirth = player.DateOfBirth,
Email = player.Email,
Id = player.Id,
Nickname = player.Nickname,
IsAdmin = User.Identity.Name != null && player.Email == User.Identity.Name
};
return(View(model));
}
public void ItSetsThePlayerRegisteredFlagToFalseIfThereIsNoApplicationUserIdOnThePlayer()
{
playerDetails.ApplicationUserId = null;
playerDetailsViewModel = _autoMocker.ClassUnderTest.Build(playerDetails, twitterMinionBraggingUrl, currentUser);
Assert.AreEqual(false, playerDetailsViewModel.PlayerRegistered);
}
public ActionResult PlayerDetails(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
PlayerModel playerModel = repository.SelectByID(id);
if (playerModel == null)
{
return(HttpNotFound());
}
var playerDetailsViewModel = new PlayerDetailsViewModel();
playerDetailsViewModel.Player = playerModel;
var teamMates = repository.getTeamMates(playerModel.ClubId, playerModel.PlayerId);
playerDetailsViewModel.Players = teamMates.ToList();
playerDetailsViewModel.Players.ForEach(p => System.Diagnostics.Debug.WriteLine(p.PlayerName));
System.Diagnostics.Debug.WriteLine(playerDetailsViewModel.Player.PlayerName);
return(View(playerDetailsViewModel));
}
public PlayerDetailsPage(PlayersClub player)
{
InitializeComponent();
BindingContext = model = new PlayerDetailsViewModel()
{
Player = player
};
}
public void ItSetsTheAveragePointsPerGameToZeroIfNoGamesHaveBeenPlayed()
{
_playerDetails.PlayerStats.TotalGames = 0;
_playerDetailsViewModel = _autoMocker.ClassUnderTest.Build(_playerDetails, _expectedPlayerIdToRegisteredEmailDictionary, _twitterMinionBraggingUrl, _currentUser);
Assert.AreEqual(0, _playerDetailsViewModel.AveragePointsPerGame);
}
public void ItSetsTheAveragePointsPerGameToZeroIfNoGamesHaveBeenPlayed()
{
playerDetails.PlayerStats.TotalGames = 0;
playerDetailsViewModel = _autoMocker.ClassUnderTest.Build(playerDetails, twitterMinionBraggingUrl, currentUser);
Assert.AreEqual(0, playerDetailsViewModel.AveragePointsPerGame);
}
public PlayerDetailsViewModel Build(
PlayerDetails playerDetails,
Dictionary <int, string> playerIdToRegisteredUserEmailAddressDictionary,
string urlForMinionBragging,
ApplicationUser currentUser = null)
{
Validate(playerDetails);
ValidatePlayerIdToRegisteredUserEmailAddressDictionary(playerIdToRegisteredUserEmailAddressDictionary);
var currentUserEmail = playerIdToRegisteredUserEmailAddressDictionary.ContainsKey(playerDetails.Id)
? playerIdToRegisteredUserEmailAddressDictionary[playerDetails.Id]
: null;
var playerDetailsViewModel = new PlayerDetailsViewModel
{
PlayerId = playerDetails.Id,
PlayerName = playerDetails.Name,
PlayerRegistered = playerDetails.ApplicationUserId != null,
RegisteredUserEmailAddress = currentUserEmail,
Active = playerDetails.Active,
GamingGroupName = playerDetails.GamingGroupName,
GamingGroupId = playerDetails.GamingGroupId,
TotalGamesPlayed = playerDetails.PlayerStats.TotalGames,
NemePointsSummary = new NemePointsSummaryViewModel(playerDetails.NemePointsSummary),
TotalGamesWon = playerDetails.PlayerStats.TotalGamesWon,
TotalGamesLost = playerDetails.PlayerStats.TotalGamesLost,
WinPercentage = playerDetails.PlayerStats.WinPercentage,
TotalChampionedGames = playerDetails.ChampionedGames.Count,
LongestWinningStreak = playerDetails.LongestWinningStreak,
PlayerAchievements = playerDetails.Achievements.Select(x => _transformer.Transform <PlayerAchievementSummaryViewModel>(x))
.OrderByDescending(a => a.AchievementLevel)
.ThenByDescending(a => a.LastUpdatedDate)
.ToList()
};
PopulatePlayerVersusPlayersViewModel(playerDetails, playerIdToRegisteredUserEmailAddressDictionary, playerDetailsViewModel);
SetTwitterBraggingUrlIfThePlayerIsTheCurrentlyLoggedInUser(playerDetails, urlForMinionBragging, currentUser, playerDetailsViewModel);
SetAveragePointsPerGame(playerDetails, playerDetailsViewModel);
playerDetailsViewModel.AveragePlayersPerGame = playerDetails.PlayerStats.AveragePlayersPerGame;
SetAveragePointsPerPlayer(playerDetails, playerDetailsViewModel);
SetUserCanEditFlag(playerDetails, currentUser, playerDetailsViewModel);
PopulatePlayerGameResults(playerDetails, playerDetailsViewModel);
PopulateNemesisData(playerDetails.CurrentNemesis, playerDetailsViewModel);
playerDetailsViewModel.Minions = (from Player player in playerDetails.Minions
select _minionViewModelBuilder.Build(player)).ToList();
playerDetailsViewModel.PlayerGameSummaries = playerDetails.PlayerGameSummaries.Select(Mapper.Map <PlayerGameSummaryViewModel>).ToList();
SetChampionedGames(playerDetails, playerDetailsViewModel);
SetFormerChampionedGames(playerDetails, playerDetailsViewModel);
return(playerDetailsViewModel);
}
public void It_Sets_The_RegisteredUserEmailAddress_If_It_Is_In_The_Dictionary()
{
//--arrange
_playerDetails.Id = _expectedPlayerIdToRegisteredEmailDictionary.Keys.First();
//--act
_playerDetailsViewModel = _autoMocker.ClassUnderTest.Build(_playerDetails, _expectedPlayerIdToRegisteredEmailDictionary, _twitterMinionBraggingUrl, _currentUser);
//--assert
_playerDetailsViewModel.RegisteredUserEmailAddress.ShouldBe(_expectedPlayerIdToRegisteredEmailDictionary[_playerDetails.Id]);
}
private static void PopulateNemesisData(Nemesis nemesis, PlayerDetailsViewModel playerDetailsViewModel)
{
playerDetailsViewModel.HasNemesis = !(nemesis is NullNemesis);
if (playerDetailsViewModel.HasNemesis)
{
playerDetailsViewModel.NemesisPlayerId = nemesis.NemesisPlayerId;
playerDetailsViewModel.NemesisName = nemesis.NemesisPlayer.Name;
playerDetailsViewModel.NumberOfGamesLostVersusNemesis = nemesis.NumberOfGamesLost;
playerDetailsViewModel.LossPercentageVersusPlayer = nemesis.LossPercentage;
}
}
public async Task <IActionResult> Details(int id)
{
var viewModel = new PlayerDetailsViewModel
{
Player = await _service.GetPlayer(id),
};
viewModel.FormTable = _service.GetFormTable(viewModel.Player);
return(View(viewModel));
}
private void PopulatePlayerGameResults(PlayerDetails playerDetails, PlayerDetailsViewModel playerDetailsViewModel)
{
playerDetailsViewModel.PlayerGameResultDetails = new List <GameResultViewModel>();
GameResultViewModel gameResultViewModel;
foreach (PlayerGameResult playerGameResult in playerDetails.PlayerGameResults)
{
gameResultViewModel = gameResultViewModelBuilder.Build(playerGameResult);
playerDetailsViewModel.PlayerGameResultDetails.Add(gameResultViewModel);
}
}
public void It_Doesnt_Set_The_RegisteredUserEmailAddress_If_It_Is_Not_In_The_Dictionary()
{
//--arrange
var emptyDictionary = new Dictionary <int, string>();
//--act
_playerDetailsViewModel = _autoMocker.ClassUnderTest.Build(_playerDetails, emptyDictionary, _twitterMinionBraggingUrl, _currentUser);
//--assert
_playerDetailsViewModel.RegisteredUserEmailAddress.ShouldBeNull();
}
private static void SetAveragePointsPerGame(PlayerDetails playerDetails, PlayerDetailsViewModel playerDetailsViewModel)
{
if (playerDetails.PlayerStats.TotalGames == 0)
{
playerDetailsViewModel.AveragePointsPerGame = 0;
}
else
{
playerDetailsViewModel.AveragePointsPerGame = (float)playerDetails.PlayerStats.TotalPoints / (float)playerDetails.PlayerStats.TotalGames;
}
}
public PlayerDetails()
{
InitializeComponent();
_vm = new PlayerDetailsViewModel();
this.DataContext = _vm;
LoadingPopup ovr = new LoadingPopup();
loadingGrid.Visibility = System.Windows.Visibility.Collapsed;
loadingGrid.Children.Add(ovr);
}
private static void SetAveragePointsPerPlayer(PlayerDetails playerDetails, PlayerDetailsViewModel playerDetailsViewModel)
{
if (playerDetails.PlayerStats.AveragePlayersPerGame == 0)
{
playerDetailsViewModel.AveragePointsPerPlayer = 0;
}
else
{
playerDetailsViewModel.AveragePointsPerPlayer
= playerDetailsViewModel.AveragePointsPerGame / playerDetails.PlayerStats.AveragePlayersPerGame;
}
}
public async Task <IActionResult> Details(string id)
{
PlayerDetailsViewModel playerDetailsViewModel = (await this.footballPlayerService.GetById(id)).To <PlayerDetailsViewModel>();
if (playerDetailsViewModel == null)
{
//TODO: Error Handling
return(this.Redirect("/"));
}
return(this.View(playerDetailsViewModel));
}
private void SetFormerChampionedGames(PlayerDetails playerDetails, PlayerDetailsViewModel playerDetailsViewModel)
{
if (playerDetails.PlayerGameSummaries == null)
{
return;
}
playerDetailsViewModel.PlayerGameSummaries
.Where(summary => playerDetails.FormerChampionedGames.Select(fcg => fcg.Id).Contains(summary.GameDefinitionId)
//take the current champion out of the former champions list
&& !summary.IsChampion)
.ToList()
.ForEach(x => x.IsFormerChampion = true);
}
private void SetChampionedGames(PlayerDetails playerDetails, PlayerDetailsViewModel playerDetailsViewModel)
{
if (playerDetails.PlayerGameSummaries == null)
{
return;
}
playerDetailsViewModel.PlayerGameSummaries
.Where(summary => playerDetails.ChampionedGames
.Select(championedGame => championedGame.GameDefinitionId)
.Contains(summary.GameDefinitionId))
.ToList()
.ForEach(x => x.IsChampion = true);
}
public ActionResult EndPlayerContract(int id, PlayerDetailsViewModel model, FormCollection collection)
{
var playerProcessor = new PlayerProcessor();
try
{
playerProcessor.DeleteContract(model.contract);
return(RedirectToAction("Index"));
}
catch (Exception e)
{
return(View());
}
}
private static void PopulatePlayerVersusPlayersViewModel(PlayerDetails playerDetails,
Dictionary <int, string> playerIdToRegisteredUserEmailAddressDictionary,
PlayerDetailsViewModel playerDetailsViewModel)
{
var playerVersusPlayers = new PlayersSummaryViewModel
{
WinLossHeader = "Win - Loss Record vs. Player"
};
foreach (var playerVersusPlayerStatistics in playerDetails.PlayerVersusPlayersStatistics)
{
var winPercentage = GetWinPercentage(playerVersusPlayerStatistics);
string registeredUserEmail;
playerIdToRegisteredUserEmailAddressDictionary.TryGetValue(
playerVersusPlayerStatistics.OpposingPlayerId, out registeredUserEmail);
var playerSummaryViewModel = new PlayerSummaryViewModel
{
PlayerName = PlayerNameBuilder.BuildPlayerName(playerVersusPlayerStatistics.OpposingPlayerName, playerVersusPlayerStatistics.OpposingPlayerActive),
PlayerId = playerVersusPlayerStatistics.OpposingPlayerId,
RegisteredUserEmailAddress = registeredUserEmail,
GamesWon = playerVersusPlayerStatistics.NumberOfGamesWonVersusThisPlayer,
GamesLost = playerVersusPlayerStatistics.NumberOfGamesLostVersusThisPlayer,
WinPercentage = (int)winPercentage
};
if (playerDetails.CurrentNemesis != null &&
playerDetails.CurrentNemesis.NemesisPlayerId == playerVersusPlayerStatistics.OpposingPlayerId)
{
playerSummaryViewModel.SpecialBadgeTypes.Add(new NemesisBadgeViewModel());
}
if (playerDetails.PreviousNemesis?.NemesisPlayerId == playerVersusPlayerStatistics.OpposingPlayerId)
{
playerSummaryViewModel.SpecialBadgeTypes.Add(new PreviousNemesisBadgeViewModel());
}
if (playerDetails.Minions.Any(x => x.Id == playerVersusPlayerStatistics.OpposingPlayerId))
{
playerSummaryViewModel.SpecialBadgeTypes.Add(new MinionBadgeViewModel());
}
playerVersusPlayers.PlayerSummaries.Add(playerSummaryViewModel);
}
playerDetailsViewModel.PlayerVersusPlayers = playerVersusPlayers;
}
public ActionResult Details(int id)
{
var playerInDb = context.Players.SingleOrDefault(p => p.ID == id);
if (playerInDb == null)
{
return(HttpNotFound());
}
var stats = context.PlayerStats.Where(ps => ps.Player.ID == playerInDb.ID).ToList();
PlayerDetailsViewModel viewModel = new PlayerDetailsViewModel();
viewModel.AddStat(stats);
return(View(viewModel));
}
public ActionResult RegisterPlayer(PlayerDetailsViewModel model, FormCollection collection)
{
var idClub = 2;
var playerProcessor = new PlayerProcessor();
var organization = RetrieveOrganization(idClub);
DateTime testDate;
Decimal testDec;
if (!DateTime.TryParse(model.player.BirthDate.ToString(), out testDate))
{
TempData["Error"] = "Datum rođenja je krivog formata. Ispravan format je dd.MM.yyyy";
return(View(model));
}
if (!DateTime.TryParse(model.contract.DateFrom.ToString(), out testDate) || !DateTime.TryParse(model.contract.DateTo.ToString(), out testDate))
{
TempData["Error"] = "Datum ugovora je krivog formata. Ispravan format je dd.MM.yyyy";
return(View(model));
}
if (!DateTime.TryParse(model.healthCheck.FromDate.ToString(), out testDate) || !DateTime.TryParse(model.healthCheck.ToDate.ToString(), out testDate))
{
TempData["Error"] = "Datum liječničkog je krivog formata. Ispravan format je dd.MM.yyyy";
return(View(model));
}
if (!Decimal.TryParse(model.contract.AnnualSalary.ToString(), out testDec))
{
TempData["Error"] = "Iznos plaće je krivog formata. Ispravan format je XX.YY";
return(View(model));
}
try
{
if (ModelState.IsValid)
{
playerProcessor.StorePlayerDetailsChanges(model.player, model.contract, model.healthCheck, organization);
return(RedirectToAction("Index"));
}
}
catch (Exception e)
{
return(View());
}
return(View());
}
public ActionResult RegisterPlayer(int id = 0)
{
PlayerProcessor playerProcessor = new PlayerProcessor();
// Initialize new player, contract and healthCheck
PlayerDetailsViewModel player = new PlayerDetailsViewModel();
player.player = new Person();
player.contract = new Contract();
player.healthCheck = new HealthCheckEvidention();
if (id != 0)
{
player.player = playerProcessor.RetrievePlayer(id);
}
return(View(player));
}
public PlayerDetailsViewModel Build(PlayerDetails playerDetails, string urlForMinionBragging, ApplicationUser currentUser = null)
{
Validate(playerDetails);
var playerDetailsViewModel = new PlayerDetailsViewModel
{
PlayerId = playerDetails.Id,
PlayerName = playerDetails.Name,
PlayerRegistered = playerDetails.ApplicationUserId != null,
Active = playerDetails.Active,
GamingGroupName = playerDetails.GamingGroupName,
GamingGroupId = playerDetails.GamingGroupId,
TotalGamesPlayed = playerDetails.PlayerStats.TotalGames,
TotalPoints = playerDetails.PlayerStats.TotalPoints,
TotalGamesWon = playerDetails.PlayerStats.TotalGamesWon,
TotalGamesLost = playerDetails.PlayerStats.TotalGamesLost,
WinPercentage = playerDetails.PlayerStats.WinPercentage,
TotalChampionedGames = playerDetails.ChampionedGames.Count,
LongestWinningStreak = playerDetails.LongestWinningStreak
};
PopulatePlayerVersusPlayersViewModel(playerDetails, playerDetailsViewModel);
SetTwitterBraggingUrlIfThePlayerIsTheCurrentlyLoggedInUser(playerDetails, urlForMinionBragging, currentUser, playerDetailsViewModel);
SetAveragePointsPerGame(playerDetails, playerDetailsViewModel);
playerDetailsViewModel.AveragePlayersPerGame = playerDetails.PlayerStats.AveragePlayersPerGame;
SetAveragePointsPerPlayer(playerDetails, playerDetailsViewModel);
SetUserCanEditFlag(playerDetails, currentUser, playerDetailsViewModel);
this.PopulatePlayerGameResults(playerDetails, playerDetailsViewModel);
PopulateNemesisData(playerDetails.CurrentNemesis, playerDetailsViewModel);
playerDetailsViewModel.Minions = (from Player player in playerDetails.Minions
select minionViewModelBuilder.Build(player)).ToList();
playerDetailsViewModel.PlayerGameSummaries = playerDetails.PlayerGameSummaries.Select(Mapper.Map <PlayerGameSummaryViewModel>).ToList();
SetChampionedGames(playerDetails, playerDetailsViewModel);
SetFormerChampionedGames(playerDetails, playerDetailsViewModel);
return(playerDetailsViewModel);
}
