public void ItDoesntChangeTheNameIfThePlayerIsActive()
{
string playerName = "some player name";
var result = PlayerNameBuilder.BuildPlayerName(playerName, true);
Assert.That(result, Is.EqualTo(playerName));
}
public void ItAddsAnInactiveSuffixToThePlayerNameIfThePlayerIsInactive()
{
string playerName = "x";
var result = PlayerNameBuilder.BuildPlayerName(playerName, false);
Assert.That(result, Is.EqualTo("x (INACTIVE)"));
}
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 ItPopulatesTheOpposingPlayerName()
{
var expectedPlayer = playerDetails.PlayerVersusPlayersStatistics.First(x => x.OpposingPlayerId == normalPlayer.OpposingPlayerId);
var actualPlayer = playerDetailsViewModel.PlayerVersusPlayers.PlayerSummaries.First(x => x.PlayerId == normalPlayer.OpposingPlayerId);
var expectedPlayerName = PlayerNameBuilder.BuildPlayerName(expectedPlayer.OpposingPlayerName, expectedPlayer.OpposingPlayerActive);
Assert.That(actualPlayer.PlayerName,
Is.EqualTo(expectedPlayerName));
}
public GameDefinitionDetailsViewModel Build(GameDefinitionSummary gameDefinitionSummary, ApplicationUser currentUser)
{
BoardGameGeekInfoViewModel boardGameGeekInfoViewModel = null;
if (gameDefinitionSummary.BoardGameGeekGameDefinitionId.HasValue)
{
boardGameGeekInfoViewModel = _transformer.Transform <BoardGameGeekInfoViewModel>(gameDefinitionSummary.BoardGameGeekInfo);
}
var viewModel = new GameDefinitionDetailsViewModel
{
GameDefinitionId = gameDefinitionSummary.Id,
GameDefinitionName = gameDefinitionSummary.Name,
TotalNumberOfGamesPlayed = gameDefinitionSummary.TotalNumberOfGamesPlayed,
AveragePlayersPerGame = $"{gameDefinitionSummary.AveragePlayersPerGame:0.#}",
GamingGroupId = gameDefinitionSummary.GamingGroupId,
GamingGroupName = gameDefinitionSummary.GamingGroupName,
UserCanEdit = (currentUser != null && gameDefinitionSummary.GamingGroupId == currentUser.CurrentGamingGroupId),
BoardGameGeekInfo = boardGameGeekInfoViewModel
};
if (gameDefinitionSummary.PlayedGames == null)
{
viewModel.PlayedGames = new List <PlayedGameDetailsViewModel>();
}
else
{
viewModel.PlayedGames = (from playedGame in gameDefinitionSummary.PlayedGames
select _playedGameDetailsViewModelBuilder.Build(playedGame, currentUser, true))
.ToList();
}
if (!(gameDefinitionSummary.Champion is NullChampion))
{
viewModel.ChampionName = PlayerNameBuilder.BuildPlayerName(
gameDefinitionSummary.Champion.Player.Name,
gameDefinitionSummary.Champion.Player.Active);
viewModel.ChampionPlayerId = gameDefinitionSummary.Champion.Player.Id;
viewModel.WinPercentage = gameDefinitionSummary.Champion.WinPercentage;
viewModel.NumberOfGamesPlayed = gameDefinitionSummary.Champion.NumberOfGames;
viewModel.NumberOfWins = gameDefinitionSummary.Champion.NumberOfWins;
}
if (!(gameDefinitionSummary.PreviousChampion is NullChampion))
{
viewModel.PreviousChampionName = PlayerNameBuilder.BuildPlayerName(
gameDefinitionSummary.PreviousChampion.Player.Name,
gameDefinitionSummary.PreviousChampion.Player.Active);
viewModel.PreviousChampionPlayerId = gameDefinitionSummary.PreviousChampion.Player.Id;
}
viewModel.GameDefinitionPlayersSummary = gameDefinitionSummary.PlayerWinRecords
.Select(_transformer.Transform <GameDefinitionPlayerSummaryViewModel>)
.ToList();
return(viewModel);
}
private static void SetPreviousChampionStuff(GameDefinitionSummary gameDefinitionSummary,
GameDefinitionDetailsViewModel viewModel)
{
if (!(gameDefinitionSummary.PreviousChampion is NullChampion))
{
viewModel.PreviousChampionName = PlayerNameBuilder.BuildPlayerName(
gameDefinitionSummary.PreviousChampion.Player.Name,
gameDefinitionSummary.PreviousChampion.Player.Active);
viewModel.PreviousChampionPlayerId = gameDefinitionSummary.PreviousChampion.Player.Id;
}
}
private static void SetChampionStuff(GameDefinitionSummary gameDefinitionSummary,
GameDefinitionDetailsViewModel viewModel)
{
if (!(gameDefinitionSummary.Champion is NullChampion))
{
viewModel.ChampionName = PlayerNameBuilder.BuildPlayerName(
gameDefinitionSummary.Champion.Player.Name,
gameDefinitionSummary.Champion.Player.Active);
viewModel.ChampionPlayerId = gameDefinitionSummary.Champion.Player.Id;
viewModel.WinPercentage = gameDefinitionSummary.Champion.WinPercentage;
viewModel.NumberOfGamesPlayed = gameDefinitionSummary.Champion.NumberOfGames;
viewModel.NumberOfWins = gameDefinitionSummary.Champion.NumberOfWins;
}
}
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 static void Configure()
{
Mapper.CreateMap <ApplicationLinkageMessage, ApplicationLinkage>(MemberList.Destination);
Mapper.CreateMap <ApplicationLinkage, ApplicationLinkageMessage>(MemberList.Destination);
Mapper.CreateMap <TopGamingGroupSummary, TopGamingGroupSummaryViewModel>(MemberList.Source);
Mapper.CreateMap <VotableFeature, VotableFeatureViewModel>(MemberList.Destination);
Mapper.CreateMap <NewUserMessage, NewUser>(MemberList.Destination)
.ForMember(x => x.GamingGroupInvitationId, opt => opt.Ignore())
.ForMember(x => x.Source, opt => opt.Ignore());
Mapper.CreateMap <NewlyRegisteredUser, NewlyRegisteredUserMessage>(MemberList.Source);
Mapper.CreateMap <PlayedGameApplicationLinkage, ApplicationLinkage>(MemberList.Destination);
Mapper.CreateMap <PlayedGameSearchResult, PlayedGameSearchResultMessage>(MemberList.Destination)
.ForSourceMember(x => x.PlayerGameResults, opt => opt.Ignore())
.ForMember(x => x.DateLastUpdated, opt => opt.MapFrom(src => src.DateLastUpdated.ToString("yyyy-MM-dd")))
.ForMember(x => x.DatePlayed, opt => opt.MapFrom(src => src.DatePlayed.ToString("yyyy-MM-dd")));
Mapper.CreateMap <PlayerResult, PlayerGameResultMessage>(MemberList.Destination)
.ForMember(x => x.TotalNemeStatsPointsAwarded, opt => opt.MapFrom(src => src.TotalPoints));
Mapper.CreateMap <PlayerGameSummary, PlayerGameSummaryViewModel>(MemberList.Source);
Mapper.CreateMap <PlayerInfoForUser, PlayerInfoForUserMessage>(MemberList.Destination);
Mapper.CreateMap <GamingGroupInfoForUser, GamingGroupInfoForUserMessage>(MemberList.Destination);
Mapper.CreateMap <UserInformation, UserInformationMessage>(MemberList.Destination);
Mapper.CreateMap <PlayerWinRecord, PlayerSummaryViewModel>(MemberList.Destination)
.ForMember(x => x.SpecialBadgeTypes, opt => opt.MapFrom(src => src.MapSpecialBadges()))
.ForMember(x => x.PlayerName, opt => opt.MapFrom(src => PlayerNameBuilder.BuildPlayerName(src.PlayerName, src.PlayerActive)));
Mapper.CreateMap <PlayerWinRecord, GameDefinitionPlayerSummaryViewModel>(MemberList.Destination)
.ForMember(x => x.SpecialBadgeTypes, opt => opt.MapFrom(src => src.MapSpecialBadges()))
.ForMember(x => x.PlayerName, opt => opt.MapFrom(src => PlayerNameBuilder.BuildPlayerName(src.PlayerName, src.PlayerActive)));
Mapper.CreateMap <GameDefinitionTotal, GameDefinitionTotalMessage>(MemberList.Destination);
Mapper.CreateMap <GameDefinitionTotals, GameDefinitionTotalsMessage>(MemberList.Destination);
Mapper.CreateMap <GameDefinition, GameDefinitionEditViewModel>(MemberList.Destination)
.ForMember(x => x.GameDefinitionId, opt => opt.MapFrom(src => src.Id));
Mapper.CreateMap <GameDefinitionEditViewModel, GameDefinitionUpdateRequest>(MemberList.Destination);
Mapper.CreateMap <CreateGameDefinitionViewModel, CreateGameDefinitionRequest>(MemberList.Destination)
//for now, GamingGroupId is optional and only passed from the API
.ForMember(x => x.GamingGroupId, opt => opt.Ignore());
Mapper.CreateMap <PlayerStatistics, PlayerStatisticsMessage>(MemberList.Destination)
.ForMember(x => x.BaseNemePoints, opt => opt.MapFrom(src => src.NemePointsSummary.BaseNemePoints))
.ForMember(x => x.GameDurationBonusNemePoints, opt => opt.MapFrom(src => src.NemePointsSummary.GameDurationBonusNemePoints))
.ForMember(x => x.WeightBonusNemePoints, opt => opt.MapFrom(src => src.NemePointsSummary.WeightBonusNemePoints))
.ForMember(x => x.TotalPoints, opt => opt.MapFrom(src => src.NemePointsSummary.TotalPoints));
Mapper.CreateMap <PlayerQuickStats, PlayerQuickStatsViewModel>(MemberList.Destination);
Mapper.CreateMap <NemePointsSummary, NemePointsSummaryViewModel>(MemberList.Destination)
.ConstructUsing(x => new NemePointsSummaryViewModel(x.BaseNemePoints, x.GameDurationBonusNemePoints, x.WeightBonusNemePoints));
Mapper.CreateMap <TrendingGame, TrendingGameViewModel>(MemberList.Destination);
Mapper.CreateMap <BoardGameGeekGameDefinition, BoardGameGeekGameDefinitionViewModel>()
.ForMember(m => m.BoardGameGeekUri, opt => opt.MapFrom(src => BoardGameGeekUriBuilder.BuildBoardGameGeekGameUri(src.Id)))
.ForMember(m => m.Categories, opt => opt.MapFrom(src => src.Categories.Select(c => c.CategoryName)))
.ForMember(m => m.Mechanics, opt => opt.MapFrom(src => src.Mechanics.Select(c => c.MechanicName)))
.ForMember(m => m.WeightDescription, opt => opt.Ignore());
Mapper.CreateMap <PlayedGameQuickStats, PlayedGameQuickStatsViewModel>(MemberList.Destination);
Mapper.CreateMap <PlayedGameMessage, NewlyCompletedGame>(MemberList.Destination)
.ForMember(m => m.DatePlayed, opt => opt.ResolveUsing(x =>
{
var datePlayed = DateTime.UtcNow;
if (!string.IsNullOrWhiteSpace(x.DatePlayed))
{
datePlayed = DateTime.ParseExact(x.DatePlayed, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None);
}
return(datePlayed);
}));
Mapper.CreateMap <UpdatedPlayedGameMessage, UpdatedGame>(MemberList.Destination)
.ForMember(m => m.DatePlayed, opt => opt.ResolveUsing(x =>
{
var datePlayed = DateTime.UtcNow;
if (!string.IsNullOrWhiteSpace(x.DatePlayed))
{
datePlayed = DateTime.ParseExact(x.DatePlayed, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None);
}
return(datePlayed);
}));
Mapper.CreateMap <PlayedGameFilterMessage, PlayedGameFilter>(MemberList.Source);
Mapper.CreateMap <BoardGameGeekInfo, BoardGameGeekInfoViewModel>()
.ForMember(m => m.HideLinkToGlobalStats, opt => opt.Ignore())
.ForMember(m => m.BoardGameGeekUri,
opt => opt.MapFrom(src => BoardGameGeekUriBuilder.BuildBoardGameGeekGameUri(src.BoardGameGeekGameDefinitionId)))
.ForMember(m => m.BoardGameGeekAverageWeightDescription,
opt => opt.MapFrom(src => new WeightTierCalculator().GetWeightTier(src.BoardGameGeekAverageWeight).ToString()))
.ForMember(m => m.BoardGameGeekWeightPercent,
opt => opt.MapFrom(src => src.BoardGameGeekAverageWeight.HasValue ? ((src.BoardGameGeekAverageWeight.Value * 100) / BoardGameGeekGameDefinitionViewModel.MaxBggWeight).ToString(CultureInfo.InvariantCulture).Replace(",", ".") : "0"))
.ForMember(m => m.AveragePlayTime,
opt =>
opt.MapFrom(
src =>
!src.MaxPlayTime.HasValue
? src.MinPlayTime
: (src.MinPlayTime.HasValue ? (src.MaxPlayTime.Value + src.MinPlayTime.Value) / 2 : src.MaxPlayTime)));
Mapper.CreateMap <UniversalGameStats, UniversalGameStatsViewModel>()
.ForMember(m => m.AveragePlayersPerGame,
opt => opt.MapFrom(src => $"{(src.AveragePlayersPerGame ?? 0):0.#}"));
Mapper.CreateMap <BoardGameGeekGameSummary, UniversalGameDetailsViewModel>(MemberList.Destination)
.ForMember(m => m.GamingGroupGameDefinitionSummary, opt => opt.Ignore());
Mapper.CreateMap <ChampionData, ChampionDataModel>(MemberList.Destination);
}
public void ItCopiesThePlayerName()
{
var expectedName = PlayerNameBuilder.BuildPlayerName(playerDetails.Name, playerDetails.Active);
Assert.AreEqual(expectedName, playerDetailsViewModel.PlayerName);
}
public void ItBuildsThePlayerName()
{
Assert.AreEqual(PlayerNameBuilder.BuildPlayerName(playerGameResult.Player.Name, playerGameResult.Player.Active), playerGameResultDetails.PlayerName);
}
public void ItSetsThePreviousChampionNameWhenThereIsAPreviousChampion()
{
Assert.That(_viewModel.PreviousChampionName, Is.EqualTo(PlayerNameBuilder.BuildPlayerName(_previousChampionPlayer.Name, _previousChampionPlayer.Active)));
}
