public async Task <IUserMessage> SendPaginatedMessageAsync(QuiccbanContext context, PaginatedMessage pager, ICriterion <SocketReaction> criterion = null) { var callback = new PaginatedMessageCallback(this, context, pager, criterion); await callback.DisplayAsync().ConfigureAwait(false); return(callback.Message); }
public PaginatedMessageCallback(InteractiveService interactive, QuiccbanContext sourceContext, PaginatedMessage pager, ICriterion <SocketReaction> criterion = null) { Interactive = interactive; Context = sourceContext; _criterion = criterion ?? new EmptyCriterion <SocketReaction>(); _pager = pager; pages = _pager.Pages.Count(); }
public async Task <bool> JudgeAsync(QuiccbanContext sourceContext, T parameter) { foreach (var criterion in _critiera) { var result = await criterion.JudgeAsync(sourceContext, parameter).ConfigureAwait(false); if (!result) { return(false); } } return(true); }
public async Task <IUserMessage> ReplyAndDeleteAsync(QuiccbanContext context, string content, bool isTTS = false, Embed embed = null, TimeSpan?timeout = null, RequestOptions options = null) { timeout = timeout ?? _defaultTimeout; var message = await context.Channel.SendMessageAsync(content, isTTS, embed, options).ConfigureAwait(false); _ = Task.Delay(timeout.Value) .ContinueWith(_ => message.DeleteAsync().ConfigureAwait(false)) .ConfigureAwait(false); return(message); }
public Task <SocketMessage> NextMessageAsync(QuiccbanContext context, bool fromSourceUser = true, bool inSourceChannel = true, TimeSpan?timeout = null, CancellationToken token = default(CancellationToken)) { var criterion = new Criteria <SocketMessage>(); if (fromSourceUser) { criterion.AddCriterion(new EnsureSourceUserCriterion()); } if (inSourceChannel) { criterion.AddCriterion(new EnsureSourceChannelCriterion()); } return(NextMessageAsync(context, criterion, timeout, token)); }
public async Task <SocketMessage> NextMessageAsync(QuiccbanContext context, ICriterion <SocketMessage> criterion, TimeSpan?timeout = null, CancellationToken token = default(CancellationToken)) { timeout = timeout ?? _defaultTimeout; var eventTrigger = new TaskCompletionSource <SocketMessage>(); var cancelTrigger = new TaskCompletionSource <bool>(); token.Register(() => cancelTrigger.SetResult(true)); async Task Handler(SocketMessage message) { var result = await criterion.JudgeAsync(context, message).ConfigureAwait(false); if (result) { eventTrigger.SetResult(message); } } context.Client.MessageReceived += Handler; var trigger = eventTrigger.Task; var cancel = cancelTrigger.Task; var delay = Task.Delay(timeout.Value); var task = await Task.WhenAny(trigger, delay, cancel).ConfigureAwait(false); context.Client.MessageReceived -= Handler; if (task == trigger) { return(await trigger.ConfigureAwait(false)); } else { return(null); } }
public Task <bool> JudgeAsync(QuiccbanContext sourceContext, SocketReaction parameter) { bool ok = parameter.UserId == sourceContext.User.Id; return(Task.FromResult(ok)); }
public Task <bool> JudgeAsync(QuiccbanContext sourceContext, IMessage parameter) { var ok = sourceContext.Channel.Id == parameter.Channel.Id; return(Task.FromResult(ok)); }
private async Task StartAsync() { async Task LoginRoutine() { await discordClient.LoginAsync(TokenType.Bot, _config.DiscordToken); await discordClient.StartAsync(); await Task.Delay(-1); } discordClient.Ready += async() => { if (!IsReady) { ApplicationInfo = await discordClient.GetApplicationInfoAsync(); _logger.LogInformation($"Logged into Discord as \"{discordClient.CurrentUser}\" in {discordClient.Guilds.Count} guild{(discordClient.Guilds.Count > 1 ? "s" : "")}."); LoadCommands(); var guildStorage = _serviceProvider.GetService <GuildStorage>(); var dbGuilds = await guildStorage.GetAllGuildsAsync(); foreach (var guild in dbGuilds) { var unexpiredCases = guild.Cases.Where(x => (x.GetEndingTime() > DateTimeOffset.UtcNow && x.ActionType != ActionType.Warn) || (x.ActionType == ActionType.Warn && x.GetWarnEndingTime() > DateTimeOffset.UtcNow)); int failedCaseAdds = 0; foreach (var guildCase in unexpiredCases) { if (!_caseHandlingService.TryAdd(guildCase)) { failedCaseAdds++; } } if (failedCaseAdds > 0) { _logger.LogWarning($"Failed to add {failedCaseAdds} cases to in-memory cache."); } //resolve all cases that had expired var unresolvedExpiredCases = guild.Cases.Where(x => !x.Resolved && ((x.ActionType != ActionType.Warn && x.GetEndingTime() <= DateTimeOffset.UtcNow) || (x.GetWarnEndingTime() <= DateTimeOffset.UtcNow && x.ActionType == ActionType.Warn))); foreach (var guildCase in unresolvedExpiredCases) { await _caseHandlingService.ResolveAsync(guildCase, null, null, false, false); } } IsReady = true; } }; discordClient.MessageReceived += async(m) => { if (m.Channel is IDMChannel) { return; } if (!(m is SocketUserMessage msg)) { return; } if (CommandUtilities.HasAnyPrefix(msg.Content, _prefixes, StringComparison.OrdinalIgnoreCase, out string pfx, out string output)) { var context = new QuiccbanContext(discordClient, msg, _serviceProvider); var result = await _commands.ExecuteAsync(output, context, _serviceProvider); if (result is QuiccbanSuccessResult success && !string.IsNullOrWhiteSpace(success.ReplyValue)) { await context.Channel.SendMessageAsync(success.ReplyValue); } if (result is QuiccbanFailResult inCommandFail) { await context.Channel.SendMessageAsync(inCommandFail.Reason); } if (result is ChecksFailedResult checkFail) { await context.Channel.SendMessageAsync(checkFail.FailedChecks.FirstOrDefault().Error); } if (result is ParameterChecksFailedResult paramCheckFail) { await context.Channel.SendMessageAsync(paramCheckFail.FailedChecks.FirstOrDefault().Error); } } }; discordClient.UserBanned += async(u, g) => { await Task.Delay(500); var auditLogs = await g.GetAuditLogsAsync(20).FlattenAsync(); var auditLog = auditLogs.FirstOrDefault(a => a.Data is BanAuditLogData ban && ban.Target.Id == u.Id); if (auditLog == null) { return; } if (auditLog.User.Id == discordClient.CurrentUser.Id) { return; } var data = auditLog.Data as BanAuditLogData; var dbService = _serviceProvider.GetService <DatabaseService>(); await dbService.CreateNewCaseAsync(g, auditLog.Reason, ActionType.Ban, 0, auditLog.User, data.Target); }; discordClient.UserUnbanned += async(u, g) => { await Task.Delay(500); var auditLogs = await g.GetAuditLogsAsync(20).FlattenAsync(); var auditLog = auditLogs.FirstOrDefault(a => a.Data is UnbanAuditLogData unban && unban.Target.Id == u.Id); if (auditLog == null) { return; } if (auditLog.User.Id == discordClient.CurrentUser.Id) { return; } var data = auditLog.Data as UnbanAuditLogData; var dbService = _serviceProvider.GetService <DatabaseService>(); var caseService = _serviceProvider.GetService <CaseHandlingService>(); var tempcase = caseService.GetCases().FirstOrDefault(x => x.GuildId == g.Id && x.TargetId == data.Target.Id && x.ActionType == ActionType.TempBan && !x.Resolved); if (tempcase != null) { await _caseHandlingService.ResolveAsync(tempcase, auditLog.User, auditLog.Reason, true, false); } else { await dbService.CreateNewCaseAsync(g, auditLog.Reason, ActionType.Ban, 0, auditLog.User, data.Target); } }; discordClient.UserLeft += async(u) => { await Task.Delay(500); var auditLogs = await u.Guild.GetAuditLogsAsync(20).FlattenAsync(); var auditLog = auditLogs.FirstOrDefault(a => a.Data is KickAuditLogData kick && kick.Target.Id == u.Id); if (auditLog == null) { return; } if (auditLog.User.Id == discordClient.CurrentUser.Id) { return; } var data = auditLog.Data as KickAuditLogData; var dbService = _serviceProvider.GetService <DatabaseService>(); await dbService.CreateNewCaseAsync(u.Guild, auditLog.Reason, ActionType.Kick, 0, auditLog.User, data.Target); }; discordClient.GuildMemberUpdated += async(u_before, u_after) => { await Task.Delay(500); var auditLogs = await u_after.Guild.GetAuditLogsAsync(20).FlattenAsync(); var auditLog = auditLogs.FirstOrDefault(a => a.Data is MemberRoleAuditLogData role && role.Target.Id == u_after.Id); if (auditLog == null) { return; } if (auditLog.User.Id == discordClient.CurrentUser.Id) { return; } var data = auditLog.Data as MemberRoleAuditLogData; var dbService = _serviceProvider.GetService <DatabaseService>(); var caseService = _serviceProvider.GetService <CaseHandlingService>(); var dbGuild = await dbService.GetOrCreateGuildAsync(u_after.Guild); if (data.Roles.Any(x => x.RoleId == dbGuild.MuteRoleId && x.Added)) { await dbService.CreateNewCaseAsync(u_after.Guild, auditLog.Reason, ActionType.Mute, 0, auditLog.User, data.Target); } else if (data.Roles.Any(x => x.RoleId == dbGuild.MuteRoleId && !x.Added)) { var tempcase = caseService.GetCases().FirstOrDefault(x => x.TargetId == data.Target.Id && x.ActionType == ActionType.TempMute && !x.Resolved); if (tempcase != null) { await _caseHandlingService.ResolveAsync(tempcase, auditLog.User, auditLog.Reason, true, false); } else { await dbService.CreateNewCaseAsync(u_after.Guild, auditLog.Reason, ActionType.Unmute, 0, auditLog.User, data.Target); } } }; _logger.LogInformation("Attempting to log into Discord..."); try { await LoginRoutine(); } catch { _logger.LogError("Failed to log into Discord. Attempting reconnect in 10 seconds."); await Task.Delay(10000); try { await LoginRoutine(); } catch { _logger.LogError("Reconnection failed. Exiting."); Environment.Exit(0); } } }
public Task <bool> JudgeAsync(QuiccbanContext sourceContext, T parameter) => Task.FromResult(true);
public Task <bool> JudgeAsync(QuiccbanContext sourceContext, SocketMessage parameter) { bool ok = int.TryParse(parameter.Content, out _); return(Task.FromResult(ok)); }