public ActionResult Stats(ContestFullResultsViewModel viewModel)
{
if (!this.UserHasAccessToContest(viewModel.Id))
{
throw new HttpException((int)HttpStatusCode.Forbidden, Resource.Contest_results_not_available);
}
var maxResult = this.Data.Contests.All().FirstOrDefault(c => c.Id == viewModel.Id).Problems.Sum(p => p.MaximumPoints);
var participantsCount = viewModel.Results.Count();
var statsModel = new ContestStatsViewModel();
statsModel.MinResultsCount = viewModel.Results.Count(r => r.Total == 0);
statsModel.MinResultsPercent = (double)statsModel.MinResultsCount / participantsCount;
statsModel.MaxResultsCount = viewModel.Results.Count(r => r.Total == maxResult);
statsModel.MaxResultsPercent = (double)statsModel.MaxResultsCount / participantsCount;
statsModel.AverageResult = (double)viewModel.Results.Sum(r => r.Total) / participantsCount;
int fromPoints = 0;
int toPoints = 0;
foreach (var problem in viewModel.Problems)
{
var maxResultsForProblem = viewModel.Results.Count(r => r.ProblemResults.Any(pr => pr.ProblemName == problem.Name && pr.BestSubmission != null && pr.BestSubmission.Points == pr.MaximumPoints));
var maxResultsForProblemPercent = (double)maxResultsForProblem / participantsCount;
statsModel.StatsByProblem.Add(new ContestProblemStatsViewModel
{
Name = problem.Name,
MaxResultsCount = maxResultsForProblem,
MaxResultsPercent = maxResultsForProblemPercent,
MaxPossiblePoints = problem.MaximumPoints
});
if (toPoints == 0)
{
toPoints = problem.MaximumPoints;
}
else
{
toPoints += problem.MaximumPoints;
}
var participantsInPointsRange = viewModel.Results.Count(r => r.Total >= fromPoints && r.Total <= toPoints);
var participantsInPointsRangePercent = (double)participantsInPointsRange / participantsCount;
statsModel.StatsByPointsRange.Add(new ContestPointsRangeViewModel
{
PointsFrom = fromPoints,
PointsTo = toPoints,
Participants = participantsInPointsRange,
PercentOfAllParticipants = participantsInPointsRangePercent
});
fromPoints = toPoints + 1;
}
return(this.PartialView("_StatsPartial", statsModel));
}
private ContestFullResultsViewModel GetContestFullResults(Contest contest, bool official)
{
var contestStartTime = official ? contest.StartTime : contest.PracticeStartTime;
var contestFullResults = new ContestFullResultsViewModel
{
Id = contest.Id,
Name = contest.Name,
Problems = contest.Problems
.AsQueryable()
.Where(pr => !pr.IsDeleted)
.Select(ContestProblemViewModel.FromProblem)
.OrderBy(x => x.OrderBy)
.ThenBy(x => x.Name),
Results = this.Data.Participants
.All()
.Where(participant => participant.ContestId == contest.Id && participant.IsOfficial == official)
.Select(participant => new ParticipantFullResultViewModel
{
ParticipantUsername = participant.User.UserName,
ParticipantFirstName = participant.User.UserSettings.FirstName,
ParticipantLastName = participant.User.UserSettings.LastName,
ProblemResults = participant.Contest.Problems
.Where(x => !x.IsDeleted)
.Select(problem => new ProblemFullResultViewModel
{
ProblemName = problem.Name,
ProblemOrderBy = problem.OrderBy,
MaximumPoints = problem.MaximumPoints,
BestSubmission = problem.ParticipantScores
.AsQueryable()
.Where(z => z.ParticipantId == participant.Id && z.IsOfficial == official)
.Select(z => z.Submission)
.Select(SubmissionFullResultsViewModel.FromSubmission)
.FirstOrDefault(),
})
.OrderBy(res => res.ProblemOrderBy)
.ThenBy(res => res.ProblemName)
})
};
contestFullResults.Results = contestFullResults.Results
.OrderByDescending(x => x.ProblemResults.Sum(z => z.BestSubmission?.Points ?? 0))
.ThenByDescending(x => x.ProblemResults
.OrderByDescending(y => y.BestSubmission?.Id)
.Select(y => y.BestSubmission?.Id)
.FirstOrDefault());
return(contestFullResults);
}
public ActionResult Full(int id, bool official)
{
var contest = this.Data.Contests.GetById(id);
if (contest == null)
{
throw new HttpException((int)HttpStatusCode.NotFound, Resource.Contest_not_found);
}
var model = new ContestFullResultsViewModel
{
Id = contest.Id,
Name = contest.Name,
Problems = contest.Problems.AsQueryable().Where(pr => !pr.IsDeleted).Select(ContestProblemViewModel.FromProblem).OrderBy(x => x.OrderBy).ThenBy(x => x.Name),
Results = this.Data.Participants.All()
.Where(participant => participant.ContestId == contest.Id && participant.IsOfficial == official)
.Select(participant => new ParticipantFullResultViewModel
{
ParticipantUsername = participant.User.UserName,
ParticipantFirstName = participant.User.UserSettings.FirstName,
ParticipantLastName = participant.User.UserSettings.LastName,
ProblemResults = participant.Contest.Problems
.Where(x => !x.IsDeleted)
.Select(problem =>
new ProblemFullResultViewModel
{
Id = problem.Id,
ProblemName = problem.Name,
ProblemOrderBy = problem.OrderBy,
MaximumPoints = problem.MaximumPoints,
BestSubmission = problem.Submissions.AsQueryable()
.Where(submission => submission.ParticipantId == participant.Id && !submission.IsDeleted && submission.CreatedOn >= contest.StartTime)
.OrderByDescending(z => z.Points).ThenByDescending(z => z.Id)
.Select(SubmissionFullResultsViewModel.FromSubmission)
.FirstOrDefault(),
})
.OrderBy(res => res.ProblemOrderBy).ThenBy(res => res.ProblemName)
})
.ToList()
.OrderByDescending(x => x.Total).ThenBy(x => x.ParticipantUsername)
};
this.ViewBag.IsOfficial = official;
return(this.View(model));
}
