Example #1
0
        public async Task <IActionResult> ScoreboardXlsx(
            [FromQuery] int[] affiliations = null,
            [FromQuery] int[] categories   = null)
        {
            if (Contest.RankingStrategy == CcsDefaults.RuleCodeforces)
            {
                return(StatusCode(501));
            }
            if (affiliations != null && affiliations.Length == 0)
            {
                affiliations = null;
            }
            if (categories != null && categories.Length == 0)
            {
                categories = null;
            }

            if (!Contest.StartTime.HasValue)
            {
                return(BadRequest());
            }
            var scb = await Context.GetScoreboardAsync();

            var board = new FullBoardViewModel(scb, false)
            {
                FilteredAffiliations = affiliations?.ToHashSet(),
                FilteredCategories   = categories?.ToHashSet(),
            };

            using var workbook = OpenXmlScoreboard.Create(board, Contest.Name);

            var memoryStream = new MemoryStream();

            workbook.SaveAs(memoryStream);
            memoryStream.Position = 0;

            return(File(
                       fileStream: memoryStream,
                       contentType: OpenXmlScoreboard.MimeType,
                       fileDownloadName: $"c{Contest.Id}-scoreboard.xlsx"));
        }
Example #2
0
            public async Task <JobStatus> ExecuteAsync(string arguments, Job job, ILogger logger)
            {
                var args    = arguments.AsJson <Models.ScoreboardArguments>();
                var context = await _factory.CreateAsync(args.ContestId, _serviceProvider, true);

                if (context == null)
                {
                    logger.LogError("Unknown contest ID specified.");
                    return(JobStatus.Failed);
                }

                var contest = context.Contest;

                if (!contest.StartTime.HasValue ||
                    contest.RankingStrategy == CcsDefaults.RuleCodeforces ||
                    contest.Feature == CcsDefaults.KindProblemset)
                {
                    logger.LogError("Export constraint failed.");
                    return(JobStatus.Failed);
                }

                logger.LogInformation("Calculating scoreboard...");

                DateTimeOffset?endTime = args.IncludeUpsolving
                    ? DateTimeOffset.Now
                    : (contest.StartTime + contest.EndTime);

                var raw = await RankingSolver.Select(contest)
                          .RefreshCache(
                    _scoreboard,
                    new Events.ScoreboardRefreshEvent(context, endTime));

                var rankCaches  = raw.RankCache.ToDictionary(r => r.TeamId);
                var scoreCaches = raw.ScoreCache.ToLookup(r => r.TeamId);
                var teams1      = await((ITeamContext)context).GetScoreboardRowsAsync();
                var teams       = teams1.ToDictionary(
                    k => k.TeamId,
                    v => v.With(rankCaches.GetValueOrDefault(v.TeamId), scoreCaches[v.TeamId]));

                logger.LogInformation("Loading other things from database...");

                var affs = await context.ListAffiliationsAsync();

                var orgs = await context.ListCategoriesAsync();

                var probs = await context.ListProblemsAsync();

                var scb = new ScoreboardModel(contest.Id, teams, orgs, affs, probs, contest, RankingSolver.Select(contest));

                var board = new FullBoardViewModel(scb, false)
                {
                    FilteredAffiliations = args.FilteredAffiliations?.ToHashSet(),
                    FilteredCategories   = args.FilteredCategories?.ToHashSet(),
                };

                logger.LogInformation("Data loaded.");

                using var workbook     = OpenXmlScoreboard.Create(board, contest.Name);
                using var memoryStream = new MemoryStream();
                workbook.SaveAs(memoryStream);
                memoryStream.Position = 0;

                await _files.SaveOutputAsync(job, memoryStream);

                logger.LogInformation("Export succeeded.");
                return(JobStatus.Finished);
            }