public async Task Execute(IJobExecutionContext context)
        {
            var schedulerContext = context.Scheduler.Context;
            var client           = (DiscordSocketClient)schedulerContext.Get("client");
            var scopeFactory     = (IServiceScopeFactory)schedulerContext.Get("scopeFactory");

            using var scope = scopeFactory.CreateScope();
            var dbContext = scope.ServiceProvider.GetService <DatabaseContext>();

            await SolvesManager.AnnounceWebsiteSolves(client, dbContext);
        }
Ejemplo n.º 2
0
        public async Task Flag(string flag)
        {
            var challenge = await SharedFlagManager.GetChallByFlag(_context, flag, includeArchived : true);

            var config = await _context.Configuration.AsQueryable().FirstOrDefaultAsync();

            if (config != null && config.IsFinished)
            {
                await ReplyAsync("The competition is already over.");

                return;
            }

            if (challenge == null)
            {
                await ReplyAsync("Your flag is incorrect.");

                if (config != null && config.GuildId != 0 && config.LogsChannelId != 0)
                {
                    var logsChannel = _client.GetGuild(config.GuildId).GetTextChannel(config.LogsChannelId);
                    await logsChannel.SendMessageAsync($"<@{Context.User.Id}> submitted a wrong flag: **{Format.Sanitize(flag).Replace("@", "@\u200B")}**");
                }
                return;
            }

            if (challenge.State == 3)
            {
                await ReplyAsync("You are trying to submit a flag for an archived challenge.");

                if (config != null && config.GuildId != 0 && config.LogsChannelId != 0)
                {
                    var logsChannel = _client.GetGuild(config.GuildId).GetTextChannel(config.LogsChannelId);
                    await logsChannel.SendMessageAsync($"<@{Context.User.Id}> submitted a flag for an archived challenge: **{Format.Sanitize(flag).Replace("@", "@\u200B")}**");
                }
                return;
            }

            var user = await UserManager.GetOrCreateUser(_context, Context.User.Id, Context.User.ToString());

            bool isTeam = (user.Team != null);

            if ((!isTeam && user.Solves.Select(x => x.Challenge).Contains(challenge)) || (isTeam && user.Team.Solves.Select(x => x.Challenge).Contains(challenge)))
            {
                await ReplyAsync("You already solved that challenge!");

                return;
            }

            if (config != null && config.GuildId != 0 && config.TodaysRoleId != 0)
            {
                var lastChall = await _context.Challenges.AsQueryable().OrderByDescending(x => x.ReleaseDate).FirstOrDefaultAsync(x => x.State == 2);

                if (lastChall == challenge)
                {
                    if (isTeam)
                    {
                        foreach (var member in user.Team.Members)
                        {
                            if (member.DiscordId == 0)
                            {
                                continue;
                            }
                            var guildUser = _client.GetGuild(config.GuildId).GetUser(member.DiscordId);
                            if (guildUser != null)
                            {
                                var role = _client.GetGuild(config.GuildId).GetRole(config.TodaysRoleId);
                                await guildUser.AddRoleAsync(role);
                            }
                        }
                    }
                    else
                    {
                        var guildUser = _client.GetGuild(config.GuildId).GetUser(Context.User.Id);
                        if (guildUser != null)
                        {
                            var role = _client.GetGuild(config.GuildId).GetRole(config.TodaysRoleId);
                            await guildUser.AddRoleAsync(role);
                        }
                    }
                }
            }

            if (isTeam)
            {
                user.Team.LastUpdated = DateTime.UtcNow;
            }
            else
            {
                user.LastUpdated = DateTime.UtcNow;
            }

            var solve = new Solve
            {
                User      = user,
                Team      = user.Team,
                Challenge = challenge,
                SolvedAt  = DateTime.UtcNow,
                Announced = true
            };

            await _context.Solves.AddAsync(solve);

            await _context.SaveChangesAsync();

            await ReplyAsync($"Congratulations! You solved **{challenge.Title}** challenge!");

            bool dynamicScoring = _configuration.GetValue <bool>("DynamicScoring");
            await SolvesManager.AnnounceWebsiteSolves(_client, _context, dynamicScoring);

            await SolvesManager.AnnounceSolve(_client, _context, challenge, user);

            await LeaderboardManager.UpdateLeaderboard(_client, _context, dynamicScoring);

            await RolesManager.UpdateRoles(_client, _context);
        }