Esempio n. 1
0
            public async Task<JobStatus> ExecuteAsync(string arguments, Job job, ILogger logger)
            {
                var args = arguments.AsJson<Record>();
                var context = await _factory.CreateAsync(args.ContestId);

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

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

                logger.LogInformation("Start generating reports.");
                var report = await context.GenerateReport(args.TeamId);
                if (report == null)
                {
                    logger.LogError("Report generation failed.");
                    return JobStatus.Failed;
                }

                logger.LogInformation("Start generating html.");
                var html = await _view.RenderToStringAsync(_cad, "TeamReportPreview", report);

                logger.LogInformation("Start generating PDF.");
                var pdf = await _pdf.GenerateAsync(html);

                logger.LogInformation("Saving to storage.");
                await _file.SaveOutputAsync(job, pdf);
                return JobStatus.Finished;
            }
Esempio n. 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);
            }