public virtual IList <GameDefinitionSummary> GetAllGameDefinitions(int gamingGroupId)
{
var returnValue = (from gameDefinition in dataContext.GetQueryable <GameDefinition>()
where gameDefinition.GamingGroupId == gamingGroupId &&
gameDefinition.Active
select new GameDefinitionSummary
{
Active = gameDefinition.Active,
BoardGameGeekGameDefinitionId = gameDefinition.BoardGameGeekGameDefinitionId,
Name = gameDefinition.Name,
Description = gameDefinition.Description,
GamingGroupId = gameDefinition.GamingGroupId,
Id = gameDefinition.Id,
PlayedGames = gameDefinition.PlayedGames,
TotalNumberOfGamesPlayed = gameDefinition.PlayedGames.Count,
Champion = gameDefinition.Champion,
ChampionId = gameDefinition.ChampionId,
PreviousChampion = gameDefinition.PreviousChampion,
PreviousChampionId = gameDefinition.PreviousChampionId,
DateCreated = gameDefinition.DateCreated,
ThumbnailImageUrl = gameDefinition.BoardGameGeekGameDefinition == null ? null : gameDefinition.BoardGameGeekGameDefinition.Thumbnail
})
.OrderBy(game => game.Name)
.ToList();
AddPlayersToChampionData(returnValue);
returnValue.ForEach(summary =>
{
summary.BoardGameGeekUri = BoardGameGeekUriBuilder.BuildBoardGameGeekGameUri(summary.BoardGameGeekGameDefinitionId);
summary.Champion = summary.Champion ?? new NullChampion();
summary.PreviousChampion = summary.PreviousChampion ?? new NullChampion();
});
return(returnValue);
}
private ManageAccountViewModel GetBaseManageAccountViewModel()
{
ManageAccountViewModel viewModel = new ManageAccountViewModel();
string currentUserId = User.Identity.GetUserId();
ApplicationUser user = userManager.FindById(currentUserId);
viewModel.PasswordViewModel = HasPassword() ? (PasswordViewModel) new ChangePasswordViewModel() : new SetPasswordViewModel();
ChangeEmailViewModel emailViewModel = new ChangeEmailViewModel();
emailViewModel.EmailAddress = user.Email;
viewModel.ChangeEmailViewModel = emailViewModel;
var bggUser = _userRetriever.RetrieveUserInformation(user).BoardGameGeekUser;
if (bggUser != null)
{
viewModel.BoardGameGeekIntegrationModel = new BoardGameGeekIntegrationModel
{
BoardGameGeekUserName = bggUser.Name,
AvatarUrl = bggUser.Avatar,
IntegrationComplete = true,
BoardGameGeekUserUrl = BoardGameGeekUriBuilder.BuildBoardGameGeekUserUri(bggUser.Name)
};
}
return(viewModel);
}
internal virtual ManageAccountViewModel GetBaseManageAccountViewModel()
{
var viewModel = new ManageAccountViewModel();
var currentUserId = User.Identity.GetUserId();
var user = _userManager.FindById(currentUserId);
viewModel.PasswordViewModel = HasPassword() ? (PasswordViewModel) new ChangePasswordViewModel() : new SetPasswordViewModel();
var emailViewModel = new ChangeEmailViewModel();
emailViewModel.EmailAddress = user.Email;
viewModel.ChangeEmailViewModel = emailViewModel;
var userInformation = _userRetriever.RetrieveUserInformation(user);
var bggUser = userInformation.BoardGameGeekUser;
if (bggUser != null)
{
viewModel.BoardGameGeekIntegrationModel = new BoardGameGeekIntegrationModel
{
BoardGameGeekUserName = bggUser.Name,
AvatarUrl = bggUser.Avatar,
IntegrationComplete = true,
BoardGameGeekUserUrl = BoardGameGeekUriBuilder.BuildBoardGameGeekUserUri(bggUser.Name)
};
}
viewModel.GamingGroupsSummary = new GamingGroupsSummaryViewModel
{
ShowForEdit = true,
GamingGroups = userInformation.GamingGroups.Select(x => _transformer.Transform <GamingGroupSummaryViewModel>(x)).ToList()
};
return(viewModel);
}
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 ItReturnsTheLastGamingGroupGamePlayed()
{
autoMocker.Get <IDataContext>().Expect(mock => mock.GetQueryable <Player>()).Return(new List <Player>
{
expectedPlayer
}.AsQueryable());
autoMocker.ClassUnderTest.Expect(mock => mock.GetGameDefinitionTotals(expectedPlayer.Id))
.Return(new GameDefinitionTotals());
var expectedBggGameDefinitionId = 2;
var expectedPlayedGame = MockRepository.GeneratePartialMock <PlayedGame>();
expectedPlayedGame.DatePlayed = new DateTime();
expectedPlayedGame.GameDefinitionId = 1;
expectedPlayedGame.GameDefinition = new GameDefinition
{
Name = "some game definition name",
BoardGameGeekGameDefinitionId = expectedBggGameDefinitionId,
BoardGameGeekGameDefinition = new BoardGameGeekGameDefinition
{
Name = "bgg name",
Thumbnail = "some thumbnail",
Id = expectedBggGameDefinitionId
}
};
var playedGames = new List <PlayedGame>
{
expectedPlayedGame
};
var expectedWinnerType = WinnerTypes.PlayerWin;
expectedPlayedGame.Expect(mock => mock.WinnerType).Repeat.Any().Return(expectedWinnerType);
var expectedWinningPlayer = new Player
{
Id = 93,
Name = "some winning player name"
};
expectedPlayedGame.Expect(mock => mock.WinningPlayer).Repeat.Any().Return(expectedWinningPlayer);
autoMocker.Get <IPlayedGameRetriever>().Expect(mock => mock.GetRecentGames(1, expectedPlayer.GamingGroupId))
.Return(playedGames);
var result = autoMocker.ClassUnderTest.GetPlayerQuickStatsForUser(userId, gamingGroupId);
var lastGamingGroupGame = result.LastGamingGroupGame;
Assert.That(lastGamingGroupGame, Is.Not.Null);
Assert.That(lastGamingGroupGame.DatePlayed, Is.EqualTo(expectedPlayedGame.DatePlayed));
Assert.That(lastGamingGroupGame.GameDefinitionId, Is.EqualTo(expectedPlayedGame.GameDefinitionId));
Assert.That(lastGamingGroupGame.GameDefinitionName, Is.EqualTo(expectedPlayedGame.GameDefinition.Name));
Assert.That(lastGamingGroupGame.PlayedGameId, Is.EqualTo(expectedPlayedGame.Id));
var expectedBggUri = BoardGameGeekUriBuilder.BuildBoardGameGeekGameUri(expectedBggGameDefinitionId);
Assert.That(lastGamingGroupGame.BoardGameGeekUri, Is.EqualTo(expectedBggUri));
Assert.That(lastGamingGroupGame.ThumbnailImageUrl, Is.EqualTo(expectedPlayedGame.GameDefinition.BoardGameGeekGameDefinition.Thumbnail));
Assert.That(lastGamingGroupGame.WinnerType, Is.EqualTo(expectedWinnerType));
Assert.That(lastGamingGroupGame.WinningPlayerName, Is.EqualTo(expectedWinningPlayer.Name));
Assert.That(lastGamingGroupGame.WinningPlayerId, Is.EqualTo(expectedWinningPlayer.Id));
}
public void It_Returns_Player_Quick_Stats_Plus_Latest_Played_Game_Info()
{
var expectedBggGameDefinitionId = 2;
var expectedPlayedGame = MockRepository.GeneratePartialMock <PlayedGame>();
expectedPlayedGame.DatePlayed = new DateTime();
expectedPlayedGame.GameDefinitionId = 1;
expectedPlayedGame.WinnerType = WinnerTypes.PlayerWin;
expectedPlayedGame.GameDefinition = new GameDefinition
{
Name = "some game definition name",
BoardGameGeekGameDefinitionId = expectedBggGameDefinitionId,
BoardGameGeekGameDefinition = new BoardGameGeekGameDefinition
{
Name = "bgg name",
Thumbnail = "some thumbnail",
Id = expectedBggGameDefinitionId
}
};
var playedGames = new List <PlayedGame>
{
expectedPlayedGame
};
var expectedWinningPlayer = new Player
{
Id = 93,
Name = "some winning player name"
};
expectedPlayedGame.Expect(mock => mock.WinningPlayer).Repeat.Any().Return(expectedWinningPlayer);
_autoMocker.Get <IPlayedGameRetriever>().Expect(mock => mock.GetRecentGames(1, _gamingGroupId))
.Return(playedGames);
//--act
var result = _autoMocker.ClassUnderTest.GetHomePagePlayerSummaryForUser(_applicationUserId, _gamingGroupId);
_autoMocker.Get <IPlayerRetriever>().AssertWasCalled(mock => mock.GetPlayerQuickStatsForUser(Arg <string> .Is.Equal(_applicationUserId), Arg <int> .Is.Equal(_gamingGroupId)));
_autoMocker.Get <ITransformer>().AssertWasCalled(mock => mock.Transform <HomePagePlayerSummary>(Arg <PlayerQuickStats> .Is.Same(_expectedPlayerQuickStats)));
result.ShouldBeSameAs(_expectedHomePagePlayerSummary);
var lastGamingGroupGame = result.LastGamingGroupPlayedGame;
Assert.That(lastGamingGroupGame, Is.Not.Null);
Assert.That(lastGamingGroupGame.DatePlayed, Is.EqualTo(expectedPlayedGame.DatePlayed));
Assert.That(lastGamingGroupGame.GameDefinitionId, Is.EqualTo(expectedPlayedGame.GameDefinitionId));
Assert.That(lastGamingGroupGame.GameDefinitionName, Is.EqualTo(expectedPlayedGame.GameDefinition.Name));
Assert.That(lastGamingGroupGame.PlayedGameId, Is.EqualTo(expectedPlayedGame.Id));
var expectedBggUri = BoardGameGeekUriBuilder.BuildBoardGameGeekGameUri(expectedBggGameDefinitionId);
Assert.That(lastGamingGroupGame.BoardGameGeekUri, Is.EqualTo(expectedBggUri));
Assert.That(lastGamingGroupGame.ThumbnailImageUrl, Is.EqualTo(expectedPlayedGame.GameDefinition.BoardGameGeekGameDefinition.Thumbnail));
Assert.That(lastGamingGroupGame.WinnerType, Is.EqualTo(expectedPlayedGame.WinnerType));
Assert.That(lastGamingGroupGame.WinningPlayerName, Is.EqualTo(expectedWinningPlayer.Name));
Assert.That(lastGamingGroupGame.WinningPlayerId, Is.EqualTo(expectedWinningPlayer.Id));
}
public virtual PlayerQuickStats GetPlayerQuickStatsForUser(string applicationUserId, int gamingGroupId)
{
var q = dataContext.GetQueryable <Player>().ToList();
int playerIdForCurrentUser = (from player in dataContext.GetQueryable <Player>()
where player.GamingGroupId == gamingGroupId &&
player.ApplicationUserId == applicationUserId
select player.Id)
.FirstOrDefault();
var returnValue = new PlayerQuickStats();
if (playerIdForCurrentUser != 0)
{
returnValue.PlayerId = playerIdForCurrentUser;
returnValue.TotalPoints = GetTotalNemePoints(playerIdForCurrentUser);
var gameDefinitionTotals = GetGameDefinitionTotals(playerIdForCurrentUser);
var topLevelTotals = GetTopLevelTotals(gameDefinitionTotals);
returnValue.TotalGamesPlayed = topLevelTotals.TotalGames;
returnValue.TotalGamesWon = topLevelTotals.TotalGamesWon;
var lastPlayedGameForGamingGroupList = playedGameRetriever.GetRecentGames(1, gamingGroupId);
if (lastPlayedGameForGamingGroupList.Count() == 1)
{
var lastGame = lastPlayedGameForGamingGroupList[0];
returnValue.LastGamingGroupGame = new PlayedGameQuickStats
{
DatePlayed = lastGame.DatePlayed,
GameDefinitionName = lastGame.GameDefinition.Name,
GameDefinitionId = lastGame.GameDefinitionId,
PlayedGameId = lastGame.Id,
WinnerType = lastGame.WinnerType
};
if (lastGame.WinningPlayer != null)
{
returnValue.LastGamingGroupGame.WinningPlayerId = lastGame.WinningPlayer.Id;
returnValue.LastGamingGroupGame.WinningPlayerName = lastGame.WinningPlayer.Name;
}
var bggGameDefinition = lastGame.GameDefinition.BoardGameGeekGameDefinition;
if (bggGameDefinition != null)
{
returnValue.LastGamingGroupGame.BoardGameGeekUri = BoardGameGeekUriBuilder.BuildBoardGameGeekGameUri(bggGameDefinition.Id);
returnValue.LastGamingGroupGame.ThumbnailImageUrl = bggGameDefinition.Thumbnail;
}
}
}
return(returnValue);
}
public virtual PlayerQuickStats GetPlayerQuickStatsForUser(string applicationUserId, int gamingGroupId)
{
var playerForCurrentUser = GetPlayerForCurrentUser(applicationUserId, gamingGroupId);
var returnValue = new PlayerQuickStats();
if (playerForCurrentUser != null)
{
returnValue.PlayerId = playerForCurrentUser.Id;
returnValue.NemePointsSummary = GetNemePointsSummary(playerForCurrentUser.Id);
var gameDefinitionTotals = GetGameDefinitionTotals(playerForCurrentUser.Id);
var topLevelTotals = GetTopLevelTotals(gameDefinitionTotals);
returnValue.TotalGamesPlayed = topLevelTotals.TotalGames;
returnValue.TotalGamesWon = topLevelTotals.TotalGamesWon;
var lastPlayedGameForGamingGroupList = _playedGameRetriever.GetRecentGames(1, gamingGroupId);
if (lastPlayedGameForGamingGroupList.Count() == 1)
{
var lastGame = lastPlayedGameForGamingGroupList[0];
returnValue.LastGamingGroupGame = new PlayedGameQuickStats
{
DatePlayed = lastGame.DatePlayed,
GameDefinitionName = lastGame.GameDefinition.Name,
GameDefinitionId = lastGame.GameDefinitionId,
PlayedGameId = lastGame.Id,
WinnerType = lastGame.WinnerType
};
if (lastGame.WinningPlayer != null)
{
returnValue.LastGamingGroupGame.WinningPlayerId = lastGame.WinningPlayer.Id;
returnValue.LastGamingGroupGame.WinningPlayerName = lastGame.WinningPlayer.Name;
}
var bggGameDefinition = lastGame.GameDefinition.BoardGameGeekGameDefinition;
if (bggGameDefinition != null)
{
returnValue.LastGamingGroupGame.BoardGameGeekUri = BoardGameGeekUriBuilder.BuildBoardGameGeekGameUri(bggGameDefinition.Id);
returnValue.LastGamingGroupGame.ThumbnailImageUrl = bggGameDefinition.Thumbnail;
}
}
}
return(returnValue);
}
public List <PublicGameSummary> GetRecentPublicGames(RecentlyPlayedGamesFilter filter)
{
var query = _dataContext.GetQueryable <PlayedGame>()
.Where(x => x.DatePlayed <= filter.MaxDate);
if (filter.MinDate.HasValue)
{
query = query.Where(x => x.DatePlayed >= filter.MinDate);
}
if (filter.BoardGameGeekGameDefinitionId.HasValue)
{
query = query.Where(x => x.GameDefinition.BoardGameGeekGameDefinitionId == filter.BoardGameGeekGameDefinitionId);
}
var publicGameSummaries = (from playedGame in query group new PublicGameSummary
{
PlayedGameId = playedGame.Id,
GameDefinitionId = playedGame.GameDefinitionId,
GameDefinitionName = playedGame.GameDefinition.Name,
GamingGroupId = playedGame.GamingGroupId,
GamingGroupName = playedGame.GamingGroup.Name,
WinnerType = playedGame.WinnerType,
WinningPlayer = playedGame.PlayerGameResults.FirstOrDefault(player => player.GameRank == 1).Player,
DatePlayed = playedGame.DatePlayed,
ThumbnailImageUrl = playedGame.GameDefinition.BoardGameGeekGameDefinition.Thumbnail,
BoardGameGeekObjectId = playedGame.GameDefinition.BoardGameGeekGameDefinitionId
}
by playedGame.GamingGroupId
into gamingGroups
select gamingGroups
.OrderByDescending(x => x.DatePlayed)
.ThenByDescending(y => y.PlayedGameId)
.FirstOrDefault()
)
.OrderByDescending(x => x.DatePlayed)
.ThenByDescending(y => y.PlayedGameId)
.Take(filter.NumberOfGamesToRetrieve)
.ToList();
foreach (var publicGameSummary in publicGameSummaries)
{
publicGameSummary.BoardGameGeekUri =
BoardGameGeekUriBuilder.BuildBoardGameGeekGameUri(publicGameSummary.BoardGameGeekObjectId);
}
return(publicGameSummaries);
}
public void ItSetsTheCorrectFields()
{
int expectedBoardGameGeekGameDefinitionId1 = 1;
var expectedPlayedGame = new PlayedGame
{
Id = 1
};
var playedGames = new List <PlayedGame>
{
expectedPlayedGame,
expectedPlayedGame
};
string expectedName = "some game definition name";
string expectedThumbnail = "some expected thumbnail";
var boardGameGeekGameDefinitionQueryable = new List <BoardGameGeekGameDefinition>
{
new BoardGameGeekGameDefinition
{
Id = expectedBoardGameGeekGameDefinitionId1,
Name = expectedName,
Thumbnail = expectedThumbnail,
GameDefinitions = new List <GameDefinition>
{
new GameDefinition
{
PlayedGames = playedGames
}
}
}
}.AsQueryable();
autoMocker.Get <IDataContext>().Expect(mock => mock.GetQueryable <BoardGameGeekGameDefinition>()).Return(boardGameGeekGameDefinitionQueryable);
int expectedNumberOfGames = 2;
var results = autoMocker.ClassUnderTest.GetTrendingGames(expectedNumberOfGames, 1);
Assert.That(results[0].BoardGameGeekGameDefinitionId, Is.EqualTo(expectedBoardGameGeekGameDefinitionId1));
Assert.That(results[0].BoardGameGeekUri, Is.EqualTo(BoardGameGeekUriBuilder.BuildBoardGameGeekGameUri(expectedBoardGameGeekGameDefinitionId1)));
Assert.That(results[0].GamingGroupsPlayingThisGame, Is.EqualTo(1));
Assert.That(results[0].GamesPlayed, Is.EqualTo(2));
Assert.That(results[0].Name, Is.EqualTo(expectedName));
Assert.That(results[0].ThumbnailImageUrl, Is.EqualTo(expectedThumbnail));
}
public List <PublicGameSummary> GetRecentPublicGames(int numberOfGames)
{
var publicGameSummaries = (from playedGame in dataContext.GetQueryable <PlayedGame>()
group new PublicGameSummary
{
PlayedGameId = playedGame.Id,
GameDefinitionId = playedGame.GameDefinitionId,
GameDefinitionName = playedGame.GameDefinition.Name,
GamingGroupId = playedGame.GamingGroupId,
GamingGroupName = playedGame.GamingGroup.Name,
WinnerType = (playedGame.PlayerGameResults.All(x => x.GameRank == 1) ? WinnerTypes.TeamWin :
playedGame.PlayerGameResults.All(x => x.GameRank != 1) ? WinnerTypes.TeamLoss :
WinnerTypes.PlayerWin),
WinningPlayer = playedGame.PlayerGameResults.FirstOrDefault(player => player.GameRank == 1).Player,
DatePlayed = playedGame.DatePlayed,
ThumbnailImageUrl = playedGame.GameDefinition.BoardGameGeekGameDefinition == null
? null : playedGame.GameDefinition.BoardGameGeekGameDefinition.Thumbnail,
BoardGameGeekObjectId = playedGame.GameDefinition.BoardGameGeekGameDefinitionId
}
by playedGame.GamingGroupId
into gamingGroups
select gamingGroups
.OrderByDescending(x => x.DatePlayed)
.ThenByDescending(y => y.PlayedGameId)
.FirstOrDefault()
)
.OrderByDescending(x => x.DatePlayed)
.ThenByDescending(y => y.PlayedGameId)
.Take(numberOfGames)
.ToList();
foreach (var publicGameSummary in publicGameSummaries)
{
publicGameSummary.BoardGameGeekUri =
BoardGameGeekUriBuilder.BuildBoardGameGeekGameUri(publicGameSummary.BoardGameGeekObjectId);
}
return(publicGameSummaries);
}
public PlayedGameDetailsViewModel Build(PlayedGame playedGame, ApplicationUser currentUser, bool showPointsScored = false)
{
ValidateArguments(playedGame);
PlayedGameDetailsViewModel summary = new PlayedGameDetailsViewModel();
summary.GameDefinitionName = playedGame.GameDefinition.Name;
summary.GameDefinitionId = playedGame.GameDefinitionId;
summary.PlayedGameId = playedGame.Id;
summary.DatePlayed = playedGame.DatePlayed;
summary.GamingGroupId = playedGame.GamingGroup.Id;
summary.GamingGroupName = playedGame.GamingGroup.Name;
summary.WinnerType = playedGame.WinnerType;
if (playedGame.GameDefinition.BoardGameGeekGameDefinition != null)
{
summary.ThumbnailImageUrl = playedGame.GameDefinition.BoardGameGeekGameDefinition.Thumbnail;
summary.ImageUrl = playedGame.GameDefinition.BoardGameGeekGameDefinition.Image;
}
summary.BoardGameGeekUri =
BoardGameGeekUriBuilder.BuildBoardGameGeekGameUri(playedGame.GameDefinition.BoardGameGeekGameDefinitionId);
if (playedGame.Notes != null)
{
summary.Notes = playedGame.Notes.Replace(Environment.NewLine, NEWLINE_REPLACEMENT_FOR_HTML);
}
summary.UserCanEdit = (currentUser != null && playedGame.GamingGroupId == currentUser.CurrentGamingGroupId);
summary.PlayerResults = new List <GameResultViewModel>();
showPointsScored = showPointsScored && playedGame.PlayerGameResults.All(pgr => pgr.PointsScored.HasValue && pgr.PointsScored > 0);
foreach (PlayerGameResult playerGameResult in playedGame.PlayerGameResults)
{
summary.PlayerResults.Add(playerResultBuilder.Build(playerGameResult, showPointsScored));
}
return(summary);
}
public virtual GameDefinitionSummary GetGameDefinitionDetails(int id, int numberOfPlayedGamesToRetrieve)
{
GameDefinition gameDefinition = dataContext.GetQueryable <GameDefinition>()
.Include(game => game.PlayedGames)
.Include(game => game.Champion)
.Include(game => game.Champion.Player)
.Include(game => game.PreviousChampion)
.Include(game => game.PreviousChampion.Player)
.Include(game => game.GamingGroup)
.Include(game => game.BoardGameGeekGameDefinition)
.SingleOrDefault(game => game.Id == id);
GameDefinitionSummary gameDefinitionSummary = new GameDefinitionSummary
{
Active = gameDefinition.Active,
BoardGameGeekGameDefinitionId = gameDefinition.BoardGameGeekGameDefinitionId,
BoardGameGeekUri = BoardGameGeekUriBuilder.BuildBoardGameGeekGameUri(gameDefinition.BoardGameGeekGameDefinitionId),
Name = gameDefinition.Name,
Description = gameDefinition.Description,
GamingGroup = gameDefinition.GamingGroup,
GamingGroupId = gameDefinition.GamingGroupId,
GamingGroupName = gameDefinition.GamingGroup.Name,
Id = gameDefinition.Id,
ThumbnailImageUrl = gameDefinition.BoardGameGeekGameDefinition == null ? null : gameDefinition.BoardGameGeekGameDefinition.Thumbnail,
TotalNumberOfGamesPlayed = gameDefinition.PlayedGames.Count,
AveragePlayersPerGame = gameDefinition.PlayedGames.Select(item => (decimal)item.NumberOfPlayers).DefaultIfEmpty(0M).Average(),
Champion = gameDefinition.Champion ?? new NullChampion(),
PreviousChampion = gameDefinition.PreviousChampion ?? new NullChampion()
};
IList <PlayedGame> playedGames = AddPlayedGamesToTheGameDefinition(numberOfPlayedGamesToRetrieve, gameDefinitionSummary);
IList <int> distinctPlayerIds = AddPlayerGameResultsToEachPlayedGame(playedGames);
AddPlayersToPlayerGameResults(playedGames, distinctPlayerIds);
gameDefinitionSummary.PlayerWinRecords = playerRepository.GetPlayerWinRecords(id);
return(gameDefinitionSummary);
}
public PlayedGameDetailsViewModel Build(PlayedGame playedGame, ApplicationUser currentUser)
{
ValidateArguments(playedGame);
PlayedGameDetailsViewModel summary = new PlayedGameDetailsViewModel();
summary.GameDefinitionName = playedGame.GameDefinition.Name;
summary.GameDefinitionId = playedGame.GameDefinitionId;
summary.PlayedGameId = playedGame.Id;
summary.DatePlayed = playedGame.DatePlayed;
summary.GamingGroupId = playedGame.GamingGroup.Id;
summary.GamingGroupName = playedGame.GamingGroup.Name;
if (playedGame.GameDefinition.BoardGameGeekGameDefinition != null)
{
summary.ThumbnailImageUrl = playedGame.GameDefinition.BoardGameGeekGameDefinition.Thumbnail;
}
summary.BoardGameGeekUri =
BoardGameGeekUriBuilder.BuildBoardGameGeekGameUri(playedGame.GameDefinition.BoardGameGeekGameDefinitionId);
if (playedGame.Notes != null)
{
summary.Notes = playedGame.Notes.Replace(Environment.NewLine, NEWLINE_REPLACEMENT_FOR_HTML);
}
summary.UserCanEdit = (currentUser != null && playedGame.GamingGroupId == currentUser.CurrentGamingGroupId);
summary.PlayerResults = new List <GameResultViewModel>();
foreach (PlayerGameResult playerGameResult in playedGame.PlayerGameResults)
{
summary.PlayerResults.Add(playerResultBuilder.Build(playerGameResult));
}
var gameRanks = playedGame.PlayerGameResults.Select(x => x.GameRank).ToList();
summary.WinnerType = CalculateWinnerType(gameRanks);
return(summary);
}
public GameResultViewModel Build(PlayerGameResult playerGameResult)
{
Validate(playerGameResult);
GameResultViewModel result = new GameResultViewModel();
result.PlayerId = playerGameResult.PlayerId;
result.PlayerName = playerGameResult.Player.Name;
result.GameRank = playerGameResult.GameRank;
result.NemeStatsPointsAwarded = playerGameResult.NemeStatsPointsAwarded;
result.GameDefinitionId = playerGameResult.PlayedGame.GameDefinition.Id;
result.GameDefinitionName = playerGameResult.PlayedGame.GameDefinition.Name;
result.PlayedGameId = playerGameResult.PlayedGameId;
result.DatePlayed = playerGameResult.PlayedGame.DatePlayed;
result.BoardGameGeekUri =
BoardGameGeekUriBuilder.BuildBoardGameGeekGameUri(
playerGameResult.PlayedGame.GameDefinition.BoardGameGeekGameDefinitionId);
if (playerGameResult.PlayedGame.GameDefinition.BoardGameGeekGameDefinition != null)
{
result.ThumbnailImageUrl = playerGameResult.PlayedGame.GameDefinition.BoardGameGeekGameDefinition.Thumbnail;
}
return(result);
}
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 virtual HomePagePlayerSummary GetHomePagePlayerSummaryForUser(string applicationUserId, int gamingGroupId)
{
var quickStats = _playerRetriever.GetPlayerQuickStatsForUser(applicationUserId, gamingGroupId);
var homePagePlayerSummary = _transformer.Transform <HomePagePlayerSummary>(quickStats);
var lastPlayedGameForGamingGroupList = _playedGameRetriever.GetRecentGames(1, gamingGroupId);
if (lastPlayedGameForGamingGroupList.Count == 1)
{
var lastGame = lastPlayedGameForGamingGroupList[0];
homePagePlayerSummary.LastGamingGroupPlayedGame = new PlayedGameQuickStats
{
DatePlayed = lastGame.DatePlayed,
GameDefinitionName = lastGame.GameDefinition.Name,
GameDefinitionId = lastGame.GameDefinitionId,
PlayedGameId = lastGame.Id,
WinnerType = lastGame.WinnerType
};
if (lastGame.WinningPlayer != null)
{
homePagePlayerSummary.LastGamingGroupPlayedGame.WinningPlayerId = lastGame.WinningPlayer.Id;
homePagePlayerSummary.LastGamingGroupPlayedGame.WinningPlayerName = lastGame.WinningPlayer.Name;
}
var bggGameDefinition = lastGame.GameDefinition.BoardGameGeekGameDefinition;
if (bggGameDefinition != null)
{
homePagePlayerSummary.LastGamingGroupPlayedGame.BoardGameGeekUri = BoardGameGeekUriBuilder.BuildBoardGameGeekGameUri(bggGameDefinition.Id);
homePagePlayerSummary.LastGamingGroupPlayedGame.ThumbnailImageUrl = bggGameDefinition.Thumbnail;
}
}
return(homePagePlayerSummary);
}
