public override PlayerAchievementViewModel Map(PlayerAchievement source)
{
var result = base.Map(source);
var achievement = AchievementFactory.GetAchievementById(source.AchievementId);
result.Achievement = _achievementToAchievementViewModelMapper.Map(achievement);
result.PlayerProgress = achievement.IsAwardedForThisPlayer(result.PlayerId).PlayerProgress;
switch (achievement.Group)
{
case AchievementGroup.Game:
result.RelatedGameDefinitions =
_gameDefinitionRetriever.GetGameDefinitionSummaries(source.RelatedEntities)
.Select(g => _gameDefinitionSummaryToGameDefinitionSummaryListViewModelMapper.Map(g))
.ToList();
break;
case AchievementGroup.Player:
result.RelatedPlayers =
_playerRetriever.GetPlayers(source.RelatedEntities)
.Select(g => _playerToPlayerListSummaryViewModelMapper.Map(g))
.ToList();
break;
case AchievementGroup.PlayedGame:
result.RelatedPlayedGames =
_playedGameRetriever.GetPlayedGamesQuickStats(source.RelatedEntities)
.Select(g => _playedGameQuickStatsToPlayedGameQuickStatsViewModelMapper.Map(g))
.ToList();
break;
}
return(result);
}
private Dictionary <Category, IEnumerable <Achievement> > createAchievements()
{
IEnumerable <Type> factoryTypes = getAchievementFactoryTypes();
Dictionary <Category, IEnumerable <Achievement> > achievements = new Dictionary <Category, IEnumerable <Achievement> >();
foreach (Type type in factoryTypes)
{
try {
AchievementFactory factory = (AchievementFactory)type.GetConstructor(Type.EmptyTypes).Invoke(null);
Category category = factory.getCategory();
List <Achievement> categoryAchievements;
if (achievements.ContainsKey(category))
{
categoryAchievements = (List <Achievement>)achievements[category];
}
else
{
categoryAchievements = new List <Achievement>();
achievements.Add(category, categoryAchievements);
}
IEnumerable <Achievement> factoryAchievements = factory.getAchievements();
categoryAchievements.AddRange(factoryAchievements);
} catch (Exception e) {
Debug.LogException(e);
}
}
Debug.Log("number of achievements: " + achievements.getValuesCount() + " in " + achievements.Keys.Count() + " categories");
return(achievements);
}
public bool Handle(PlayedGameCreatedEvent @event)
{
bool noExceptions = true;
//--this is a weak solution to duplicate key exceptions getting logged when multiple games are recorded in quick succession. A better solution
// would be to only lock at the playerId level instead of locking across the board
lock (GlobalLockObject)
{
var players =
DataContext.GetQueryable <PlayerGameResult>().Where(p => p.PlayedGameId == @event.TriggerEntityId)
.Select(p => p.Player)
.Include(p => p.PlayerAchievements);
foreach (var player in players.ToList())
{
foreach (var achievement in AchievementFactory.GetAchievements())
{
try
{
ProcessAchievement(player, achievement);
}
catch (Exception ex)
{
_rollbarClient.SendException(ex);
noExceptions = false;
}
}
}
}
return(noExceptions);
}
public bool ProcessAchievements(int playedGameId)
{
bool noExceptions = true;
var players =
_dataContext.GetQueryable <PlayerGameResult>().Where(p => p.PlayedGameId == playedGameId)
.Select(p => p.Player)
.Include(p => p.PlayerAchievements);
foreach (var player in players.ToList())
{
foreach (var achievement in AchievementFactory.GetAchievements())
{
try
{
ProcessAchievementForPlayer(player, achievement);
}
catch (Exception ex)
{
_rollbarClient.SendException(ex);
ex.ToExceptionless();
noExceptions = false;
}
}
}
return(noExceptions);
}
public override PlayerAchievementWinnerViewModel Map(PlayerAchievement source)
{
var model = base.Map(source);
model.Achievement =
_achievementSummaryViewModelMapper.Map(AchievementFactory.GetAchievementById(source.AchievementId));
return(model);
}
public override PlayerAchievementSummaryViewModel Map(PlayerAchievement source)
{
var result = base.Map(source);
var achievement = AchievementFactory.GetAchievementById(source.AchievementId);
result.Achievement = _achievementToAchievementViewModelMapper.Map(achievement);
return(result);
}
public virtual ActionResult Index(ApplicationUser currentUser)
{
var achievements = AchievementFactory.GetAchievements();
var model = new AchievementListViewModel
{
CurrentUserId = currentUser?.Id,
Achievements = achievements.Select(a => _mapperFactory.GetMapper <IAchievement, AchievementViewModel>().Map(a)).OrderByDescending(a => a.Winners.Count).ThenBy(a => a.Name).ToList()
};
return(View(MVC.Achievement.Views.Index, model));
}
public override IEnumerable <PlayerAchievementWinnerViewModel> Map(IEnumerable <PlayerAchievement> source)
{
var model = base.Map(source);
foreach (var viewmodel in model)
{
viewmodel.Achievement = _achievementSummaryViewModelMapper.Map(AchievementFactory.GetAchievementById(viewmodel.AchievementId));
}
return(model);
}
public IAchievement GetAchievement(AchievementId achievementId)
{
return(AchievementFactory.GetAchievementById(achievementId));
}
internal virtual List <IAchievement> GetAllAchievements()
{
return(AchievementFactory.GetAchievements());
}
