public async Task <IViewComponentResult> InvokeAsync(int id)
{
var data = await _context.Histories
.Include(p => p.Player)
.Include(d => d.Drabinka)
.Include(p => p.Player.ConectedSummoners)
.Where(h => h.Drabinka.Tournament_Id == id)
.ToListAsync();
var groupeddata = data.GroupBy(g => g.TeamName).OrderBy(o => o.Key).ToList();
List <TournamentRanking> rankingData = new List <TournamentRanking>();
foreach (var team in groupeddata)
{
TournamentRanking teamstats = new TournamentRanking()
{
Suma_Wygranych = data.Where(s => s.Status == true && s.TeamName == team.Key.ToString()).Count(),
Nazwa_Druzyny = team.Key.ToString(),
Rozegrane_Gry = data.Where(s => s.TeamName == team.Key.ToString()).Count()
};
rankingData.Add(teamstats);
}
return(View(rankingData));
}
public override void Handle([NotNull] GameHttpContext context)
{
var playerName = context.GetStringParam("name");
var version = context.GetOptionalIntParam("version");
var playerVersions = arenaState.PlayersRepo.LoadPlayerVersions(playerName);
var botVersionInfos = playerVersions.Select(p => new BotVersionInfo
{
Name = p.Name,
Version = p.Version,
Timestamp = p.Timestamp
})
.OrderByDescending(x => x.Version)
.ToArray();
TournamentRanking ranking = null;
var playerInfo = new PlayerInfo();
var lastVersion = playerVersions.TryGetLastVersion();
if (lastVersion != null)
{
ArenaPlayer arenaPlayer;
if (version.HasValue)
{
arenaPlayer = playerVersions.FirstOrDefault(p => p.Version == version.Value);
if (arenaPlayer != null)
{
arenaPlayer.Authors = lastVersion.Authors;
var tournamentId = "last";
if (arenaPlayer.Version != lastVersion.Version)
{
var nextVersion = playerVersions.First(p => p.Version > version.Value);
tournamentId = arenaState.GamesRepo.GetAllTournamentIds()
.Select(id => new DateTime(long.Parse(id), DateTimeKind.Utc))
.OrderBy(ts => ts)
.LastOrDefault(ts => ts < nextVersion.Timestamp)
.Ticks.ToString();
}
ranking = arenaState.GamesRepo.TryLoadRanking(tournamentId);
}
}
else
{
arenaPlayer = lastVersion;
ranking = arenaState.GamesRepo.TryLoadRanking("last");
}
if (ranking != null)
{
playerInfo = CreatePlayerInfo(arenaPlayer, ranking, botVersionInfos, context.GodMode || arenaState.EnableDeepNavigation);
}
}
context.SendResponse(playerInfo);
}
//----------------------------------------------------------------------------------------------------------------
//--------------------------------------- [ ZAPISYWANIE RANKINGU W BAZIE ] ---------------------------------------
//----------------------------------------------------------------------------------------------------------------
public void ZapiszRanking(int tournamentId)
{
var data = _context.Histories
.Include(p => p.Player)
.Include(d => d.Drabinka)
.Include(p => p.Player.ConectedSummoners)
.Where(h => h.Drabinka.Tournament_Id == tournamentId)
.ToList();
var groupeddata = data.GroupBy(g => g.TeamName).OrderBy(o => o.Key).ToList();
List <TournamentRanking> rankingData = new List <TournamentRanking>();
foreach (var team in groupeddata)
{
TournamentRanking teamstats = new TournamentRanking()
{
Suma_Wygranych = data.Where(s => s.Status == true && s.TeamName == team.Key.ToString()).Count(),
Nazwa_Druzyny = team.Key.ToString(),
Rozegrane_Gry = data.Where(s => s.TeamName == team.Key.ToString()).Count()
};
rankingData.Add(teamstats);
}
int index = _context.Tournaments.Where(t => t.TournamentId == tournamentId).First().Size;
if (_context.Rankingi.Where(r => r.TournamentId == tournamentId).Count() != _context.Tournaments.Where(t => t.TournamentId == tournamentId).First().Size)
{
while (index > 0)
{
var rankData = rankingData.OrderByDescending(r => r.Rozegrane_Gry).ElementAt(index - 1);
Ranking dbEntry = new Ranking
{
Miejsce = index,
Teams = _context.Teams.Where(t => t.Name == rankData.Nazwa_Druzyny).First(),
Tournament = _context.Tournaments.Where(t => t.TournamentId == tournamentId).First()
};
index--;
_context.Rankingi.Add(dbEntry);
_context.SaveChanges();
}
}
}
private PlayerInfo CreatePlayerInfo([NotNull] ArenaPlayer arenaPlayer, [NotNull] TournamentRanking ranking, [NotNull] BotVersionInfo[] botVersionInfos, bool deepNavigationEnabled)
{
var rankingEntry = ranking.Places.FirstOrDefault(r => r.Name == arenaPlayer.Name && r.Version == arenaPlayer.Version) ?? new RankingEntry
{
Name = arenaPlayer.Name,
Version = arenaPlayer.Version,
};
var games = arenaState.GamesRepo.LoadGames(ranking.TournamentId);
var gamesByEnemy = GetFinishedGamesWithEnemies(games, arenaPlayer.Name, arenaPlayer.Version, deepNavigationEnabled);
var playerInfo = new PlayerInfo
{
RankingEntry = rankingEntry,
Authors = arenaPlayer.Authors,
SubmitTimestamp = arenaPlayer.Timestamp,
GamesByEnemy = gamesByEnemy,
BotVersionInfos = botVersionInfos,
DeepNavigationEnabled = deepNavigationEnabled,
Program = deepNavigationEnabled ? arenaPlayer.Program : null,
};
return(playerInfo);
}
private List <TournamentRanking> OrderTournamentRanking(Task <IEnumerable <MatchRanking> > matchRankingCollection)
{
var lastMatchId = matchRankingCollection.Result.Select(s => s.MatchId).LastOrDefault();
var rankPointAdjustments = _rankPointAdjustments.GetAll("RankPointAdjustments").Result.ToList();
var i = 1;
var tournamentRankingStandings = matchRankingCollection.Result
.GroupBy(g => new { g.TeamName, g.ShortTeamID })
.Select(s => new TournamentRanking()
{
PubGOpenApiTeamId = s.FirstOrDefault().PubGOpenApiTeamId,
TeamName = s.Key.TeamName,
ShortTeamID = s.Key.ShortTeamID,
KillPoints = s.Sum(a => a.KillPoints),
RankPoints = s.Sum(a => a.RankPoints),
TotalPoints = s.Sum(a => a.TotalPoints)
}).OrderByDescending(o => o.TotalPoints).Select(k => new TournamentRanking()
{
PubGOpenApiTeamId = k.PubGOpenApiTeamId,
TeamName = k.TeamName,
ShortTeamID = k.ShortTeamID,
KillPoints = k.KillPoints,
RankPoints = k.RankPoints,
TotalPoints = GetAdjustedTotalPoints(k.TotalPoints, k.ShortTeamID, rankPointAdjustments),
BestKillPoints = GetTheMaxTPoints(matchRankingCollection.Result.Where(cn => cn.TeamName == k.TeamName).Select(s1 => s1.KillPoints).ToArray()),
BestTotalPoints = GetTheMaxTPoints(matchRankingCollection.Result.Where(cn => cn.TeamName == k.TeamName).Select(s1 => s1.TotalPoints).ToArray()),
LastKillPoints = GetLastKillPoints(matchRankingCollection.Result, k.TeamName, lastMatchId),
LastRankPoints = GetLastRankPoints(matchRankingCollection.Result, k.TeamName, lastMatchId),
AdjustedPoints = GetAdjustedPoints(k.ShortTeamID, rankPointAdjustments)
});
var matchStandings = new List <TournamentRanking>();
foreach (var item in tournamentRankingStandings.OrderByDescending(o => o.TotalPoints)
.ThenByDescending(t => t.KillPoints).ThenByDescending(t1 => t1.BestTotalPoints)
.ThenByDescending(t2 => t2.BestKillPoints).ThenByDescending(t3 => t3.LastKillPoints)
.ThenByDescending(t4 => t4.LastRankPoints))
{
var matchRanking = new TournamentRanking();
matchRanking.MatchId = item.MatchId;
matchRanking.TeamId = item.TeamId;
matchRanking.TeamName = item.TeamName;
matchRanking.KillPoints = item.KillPoints;
matchRanking.RankPoints = item.RankPoints;
matchRanking.TotalPoints = item.TotalPoints;
var totalPointsEqual = matchStandings.Where(cn => cn.TotalPoints == item.TotalPoints);
var killPointsEqual = totalPointsEqual.Where(cn => cn.KillPoints == item.KillPoints);
var bestTotalPointsEqual = killPointsEqual.Where(cn => cn.BestTotalPoints == item.BestTotalPoints);
var bestKillPointsEqual = bestTotalPointsEqual.Where(cn => cn.BestKillPoints == item.BestKillPoints);
var lastKillPointsEqual = bestKillPointsEqual.Where(cn => cn.LastKillPoints == item.LastKillPoints);
var lastRankPointsEqual = lastKillPointsEqual.Where(cn => cn.LastRankPoints == item.LastRankPoints);
if (totalPointsEqual.Count() > 0)
{
i = (matchStandings.Count + 1) - totalPointsEqual.Count();
matchRanking.TeamRank = $"{i}";
if (killPointsEqual.Count() > 0)
{
i = (matchStandings.Count + 1) - killPointsEqual.Count();
matchRanking.TeamRank = $"{i}";
if (bestTotalPointsEqual.Count() > 0)
{
i = (matchStandings.Count + 1) - bestTotalPointsEqual.Count();
matchRanking.TeamRank = $"{i}";
if (bestKillPointsEqual.Count() > 0)
{
i = (matchStandings.Count + 1) - bestKillPointsEqual.Count();
matchRanking.TeamRank = $"{i}";
if (lastKillPointsEqual.Count() > 0)
{
i = (matchStandings.Count + 1) - lastKillPointsEqual.Count();
matchRanking.TeamRank = $"{i}";
if (lastRankPointsEqual.Count() > 0)
{
i = (matchStandings.Count + 1) - lastRankPointsEqual.Count();
matchRanking.TeamRank = $"{i}";
}
else
{
matchRanking.TeamRank = $"{matchStandings.Count + 1}";
}
}
else
{
matchRanking.TeamRank = $"{matchStandings.Count + 1}";
}
}
else
{
matchRanking.TeamRank = $"{matchStandings.Count + 1}";
}
}
else
{
matchRanking.TeamRank = $"{matchStandings.Count + 1}";
}
}
else
{
matchRanking.TeamRank = $"{matchStandings.Count + 1}";
}
}
else
{
matchRanking.TeamRank = $"{matchStandings.Count + 1}";
}
matchRanking.PubGOpenApiTeamId = item.PubGOpenApiTeamId;
matchRanking.ShortTeamID = item.ShortTeamID;
matchRanking.BestKillPoints = item.BestKillPoints;
matchRanking.BestTotalPoints = item.BestTotalPoints;
matchRanking.LastKillPoints = item.LastKillPoints;
matchRanking.LastRankPoints = item.LastRankPoints;
matchRanking.AdjustedPoints = item.AdjustedPoints;
matchStandings.Add(matchRanking);
}
return(matchStandings);
}
