private async Task DeleteMessages(DiscordMessage response, bool delete, TimeSpan timeout, bool deleteResponse = true) { try { if (delete && !_context.Channel.IsPrivate) { try { await _message.DeleteAsync(); } catch (Exception) { } } if (timeout.TotalMilliseconds == 0 && deleteResponse && !_context.Channel.IsPrivate) { await response.DeleteAsync(); } else if (timeout.TotalMilliseconds > 0 && deleteResponse && !_context.Channel.IsPrivate) { await Task.Delay(timeout).ContinueWith(async(_) => { await response.DeleteAsync(); }); } } catch (Exception ex) when(LogError(ex)) { } }
public async Task Leave(CommandContext ctx) { DiscordMessage tmp = await ctx.RespondAsync("DC"); VoiceNextExtension vnext = ctx.Client.GetVoiceNext(); await tmp.DeleteAsync(); tmp = await ctx.RespondAsync("DC: GVNC"); VoiceNextConnection vnc = vnext.GetConnection(ctx.Guild); await tmp.DeleteAsync(); tmp = await ctx.RespondAsync("DC: CVNC"); if (vnc == null) { throw new InvalidOperationException("Not connected in this guild."); } await tmp.DeleteAsync(); tmp = await ctx.RespondAsync("DC: DCXC"); vnc.Disconnect(); await tmp.DeleteAsync(); await ctx.RespondAsync("👌"); }
private async Task <bool> VerificarAsync(DiscordChannel channel, DiscordUser autor, int time = 30) { DiscordMessage verificacion = await channel.SendMessageAsync(EasyDualLanguageFormatting("¿Estas seguro?", "Are you sure?")); await WoteAsync(verificacion, false); HelperMethods.Delay(1000); for (int i = 0; i < time; i++) { IReadOnlyList <DiscordUser> reaccionesOK = await verificacion.GetReactionsAsync(DiscordEmoji.FromName(Client, ":white_check_mark:")); IReadOnlyList <DiscordUser> reaccionesNOPE = await verificacion.GetReactionsAsync(DiscordEmoji.FromName(Client, ":x:")); if (reaccionesOK.Contains(autor)) { await verificacion.DeleteAsync(); return(true); } if (reaccionesNOPE.Contains(autor)) { await verificacion.DeleteAsync(); return(false); } HelperMethods.Delay(1000); } await verificacion.DeleteAsync(); return(false); }
internal static async Task MessagesUpdateAsync(DiscordMessage mess) { Duel d = duels.Find(cd => mess == cd); if (d != null) { if (d.duel.flag) { await mess.DeleteAsync(); return; } DiscordMessage mess1 = null, mess2 = null; try { mess1 = await mess.Channel.GetMessageAsync(d.duel.message1); } catch { } try { mess2 = await mess.Channel.GetMessageAsync(d.duel.message2); } catch { } if (mess1?.Author.Id == mess.Author.Id) { await mess1.DeleteAsync(); } else if (mess2?.Author.Id == mess.Author.Id) { await mess2.DeleteAsync(); } if (mess.Author.Id == d.duel.duelist1) { d.duel.message1 = mess.Id; } else { d.duel.message2 = mess.Id; } await d.UpdateAsync(); await mess.CreateReactionAsync(await mess.Channel.Guild.GetEmojiAsync(604972398424621066u)); await mess.CreateReactionAsync(await mess.Channel.Guild.GetEmojiAsync(604973811154288660u)); if (!IsDuelReactionAdded) { Program.bot.MessageReactionAdded += DuelReactionsAdded; IsDuelReactionAdded = true; } } else { await mess.DeleteAsync(); } }
public async Task CheckForLeavers(CommandContext ctx, string clanTag) { var roles = ctx.Member.Roles.ToList(); var verification = await IsVerifiedAsync(ctx, true); var clan = await GetClanFromTagOrNameAsync(ctx, clanTag); clanTag = clanTag.ToLower(); if (clan != null && verification == ErrorCode.Qualify && !string.IsNullOrEmpty(clan.details.Tag)) { var discordEmbed = Core.Discord.CreateFancyMessage(DiscordColor.Turquoise, "Checking for leavers..."); DiscordMessage msg = await ctx.RespondAsync(discordEmbed); var leavers = await BungieTools.CheckForLeaves(clan, true); if (leavers.Count > 0) { await msg.DeleteAsync(); var fields = new List <Field>(); Core.Discord.SendFancyListMessage(ctx.Channel, clan, leavers, "Users found leaving " + clan.details.Name + ":"); } else { discordEmbed = Core.Discord.CreateFancyMessage(DiscordColor.SpringGreen, "No leavers found", "No one to remove from sheet <:unipeepo:601277029459034112>"); await msg.ModifyAsync(discordEmbed); } await ThankUsage(ctx, clan, 100); } }
public async Task Disable(CommandContext ctx) { var GuildSettings = await discordUrie.Config.FindGuildSettings(ctx.Guild); if (GuildSettings.BansEnabled) { discordUrie.Config.GuildSettings.Remove(GuildSettings); GuildSettings.BansEnabled = false; discordUrie.Config.GuildSettings.Add(GuildSettings); await GuildSettings.SaveGuild(discordUrie.SQLConn); DiscordMessage ImSoTired = await ctx.RespondAsync("Chat bans disabled..."); await Task.Delay(2070); await ctx.Message.DeleteAsync("Command auto deletion."); await ImSoTired.DeleteAsync("Command auto deletion."); } else { DiscordMessage a = await ctx.RespondAsync("Chat bans are already disabled!"); await Task.Delay(2070); await ctx.Message.DeleteAsync("Command auto deletion."); await a.DeleteAsync("Command auto deletion."); } }
public async Task AddBan(CommandContext ctx, [Description("The user id to add")] DiscordMember user) { var util = new Util(discordUrie); bool success = await util.AddBan(ctx.Client, user.Id, ctx.Guild); if (success == true) { DiscordMessage IWishIWasDeadThanks = await ctx.RespondAsync("Id added sucessfully."); await Task.Delay(2070); await ctx.Message.DeleteAsync("Command auto deletion."); await IWishIWasDeadThanks.DeleteAsync("Command auto deletion."); } else { DiscordMessage IReallyWishIWasDeadThankYou = await ctx.RespondAsync("Id already in list..."); await Task.Delay(2070); await ctx.Message.DeleteAsync("Command auto deletion."); await IReallyWishIWasDeadThankYou.DeleteAsync("Command auto deletion."); } }
public async Task Study(CommandContext ctx) { DiscordMessage mensaje = await ctx.RespondAsync("You need to put a subject!"); System.Threading.Thread.Sleep(5000); await mensaje.DeleteAsync(); }
public async Task Enable(CommandContext ctx) { var GuildSettings = await discordUrie.Config.FindGuildSettings(ctx.Guild); if (GuildSettings.BansEnabled) { DiscordMessage woah = await ctx.RespondAsync("Chat bans are already enabled!"); await Task.Delay(2070); await ctx.Message.DeleteAsync("Command auto deletion."); await woah.DeleteAsync("Command auto deletion."); } else { discordUrie.Config.GuildSettings.Remove(GuildSettings); GuildSettings.BansEnabled = true; discordUrie.Config.GuildSettings.Add(GuildSettings); await GuildSettings.SaveGuild(discordUrie.SQLConn); DiscordMessage woaaah = await ctx.RespondAsync("Chat bans enabled..."); await Task.Delay(2070); await ctx.Message.DeleteAsync("Command auto deletion."); await woaaah.DeleteAsync("Command auto deletion."); } }
private void ManageException(DiscordMessage message, DiscordUser author, DiscordChannel channel, Exception ex, BaseDiscordCommand command) { LogMessage?.Invoke(this, $"\n --- Something's f****d up! --- \n{ex.ToString()}\n"); _telemetryClient?.TrackException(ex, new Dictionary <string, string> { { "command", command.GetType().Name } }); if (!(ex is TaskCanceledException) && !(ex is OperationCanceledException)) { new Task(async() => { try { DiscordMessage msg = await channel.SendMessageAsync( $"Something's gone very wrong executing that command, and an {ex.GetType().Name} occured." + "\r\nThis error has been reported, and should be fixed soon:tm:!" + $"\r\nThis message will be deleted in 10 seconds."); await Task.Delay(10_000); await msg.DeleteAsync(); } catch { } }).Start(); } }
public async Task Sendreactiongear(CommandContext ctx, DiscordMessage embedMessage, bool userSelf) { if (userSelf == true) { DiscordEmoji gearEmoji = DiscordEmoji.FromName(ctx.Client, ":gear:"); await embedMessage.CreateReactionAsync(gearEmoji).ConfigureAwait(false); var interactivity = ctx.Client.GetInteractivity(); try { var ReactionResult = await interactivity.WaitForReactionAsync( x => x.Message == embedMessage && x.User == ctx.User && (x.Emoji == gearEmoji)).ConfigureAwait(false); if (ReactionResult.Result.Emoji == gearEmoji) { await embedMessage.DeleteAsync(null); await SetId(ctx, ctx.Member.Id, userSelf); return; } } catch { await embedMessage.DeleteAllReactionsAsync(null); } } }
public async Task EvaluateAsync(CommandContext ctx, [RemainingText, Description("desc-code")] string code) { if (string.IsNullOrWhiteSpace(code)) { throw new InvalidCommandUsageException(ctx, "cmd-err-cmd-add-cb"); } DiscordMessage msg = await ctx.RespondWithLocalizedEmbedAsync(emb => { emb.WithLocalizedTitle("str-eval"); emb.WithColor(this.ModuleColor); }); Script <object>?snippet = CSharpCompilationService.Compile(code, out ImmutableArray <Diagnostic> diag, out Stopwatch compileTime); if (snippet is null) { await msg.DeleteAsync(); throw new InvalidCommandUsageException(ctx, "cmd-err-cmd-add-cb"); } var emb = new LocalizedEmbedBuilder(this.Localization, ctx.Guild?.Id); if (diag.Any(d => d.Severity == DiagnosticSeverity.Error)) { emb.WithLocalizedTitle("str-eval-fail-compile"); emb.WithLocalizedDescription("fmt-eval-fail-compile", compileTime.ElapsedMilliseconds, diag.Length); emb.WithColor(DiscordColor.Red); foreach (Diagnostic d in diag.Take(3)) { FileLinePositionSpan ls = d.Location.GetLineSpan(); emb.AddLocalizedTitleField("fmt-eval-err", Formatter.InlineCode(d.GetMessage()), titleArgs: new object[] { ls.StartLinePosition.Line, ls.StartLinePosition.Character } ); } if (diag.Length > 3) { emb.AddLocalizedField("str-eval-omit", "fmt-eval-omit", contentArgs: new object[] { diag.Length - 3 }); } await UpdateOrRespondAsync(); return; } Exception? exc = null; ScriptState <object>?res = null; var runTime = Stopwatch.StartNew(); try { res = await snippet.RunAsync(new EvaluationEnvironment(ctx)); } catch (Exception e) { exc = e; } runTime.Stop(); if (exc is { } || res is null)
public async Task UnbanWord(CommandContext ctx, [Description("The word you want to be removed from the list.")] string word) { await ctx.Message.DeleteAsync(); await ctx.TriggerTypingAsync(); string info = ""; DB.DBLists.LoadBannedWords(); var DBEntry = (from bw in DB.DBLists.AMBannedWords where bw.Server_ID == ctx.Guild.Id where bw.Word == word.ToLower() select bw).FirstOrDefault(); if (DBEntry != null) { var context = new DB.AMBannedWordsContext(); context.Remove(DBEntry); context.SaveChanges(); info = $"The word `{word.ToLower()}` has been removed from the list."; } else { info = $"The word `{word.ToLower()}` is not listed for this server."; } DiscordMessage msg = await ctx.RespondAsync(info); await Task.Delay(5000).ContinueWith(t => msg.DeleteAsync()); }
public async Task sil(CommandContext ctx, int miktar) { try { await ctx.TriggerTypingAsync(); await ctx.Message.DeleteAsync(); DiscordChannel kanal = ctx.Channel; int sayi = miktar; do { List <DiscordMessage> messages = (await kanal.GetMessagesAsync(sayi > 100 ? 100 : sayi)).ToList(); await kanal.DeleteMessagesAsync(messages); sayi -= 100; } while (sayi >= 100); DiscordMessage msg = await ctx.RespondAsync($"Son {miktar} Mesaj Başarı İle Silindi."); await Task.Delay(TimeSpan.FromSeconds(3)); await msg.DeleteAsync(); } catch (Exception ex) { Console.WriteLine("HATA : " + ex.Message); } }
private async Task <string?> WaitForFinishingMoveAsync(LocalizationService lcs) { if (this.Winner is null) { return(null); } string fstr = lcs.GetString(this.Channel.GuildId, "fmt-game-duel-f", Emojis.DuelSwords, this.Winner.Mention, Emojis.DuelSwords); DiscordMessage msg = await this.Channel.EmbedAsync(fstr); InteractivityResult <DiscordMessage> mctx = await this.Interactivity.WaitForMessageAsync( m => m.Channel == this.Channel && m.Author == this.Winner, TimeSpan.FromSeconds(15) ); if (mctx.TimedOut || string.IsNullOrWhiteSpace(mctx.Result.Content)) { return(null); } try { await msg.DeleteAsync(); await mctx.Result.DeleteAsync(); } catch (Exception e) when(e is UnauthorizedException or NotFoundException) { // No permissions to delete the messages } return(mctx.Result.Content.Trim()); } }
/// <summary> /// Respond to bulk deletion by bulk deleting the bot’s messages. /// </summary> /// <param name="e">Discord information.</param> static public async Task BulkDelete(DiscordClient sender, MessageBulkDeleteEventArgs e) { // Ignore bots / DMs if (e.Messages?[0]?.Author?.IsBot == true || e.Channel?.Guild == null) { return; } foreach (var item in e.Messages) { // Ignore messages not in cache if (!Cache.ContainsKey(item.Id)) { continue; } ulong id = item.Id; // Delete bot’s message if possible try { DiscordMessage message = await e.Channel.GetMessageAsync(Cache[id]); Cache.Remove(id); await message.DeleteAsync(); } catch (Exception ex) { Program.LogMessage($"Deleting the bot’s message {Cache[id]} returned an exception: {ex}"); } } }
/// <summary> /// Delete the bot’s message if one of the messages in cache was deleted. /// </summary> /// <param name="e">Discord message information.</param> static public async Task Delete(DiscordClient sender, MessageDeleteEventArgs e) { // Ignore other bots / DMs bool isBot = (e.Message?.Author?.IsBot == true); bool isOurBot = (isBot && e.Message?.Author == Program.Client.CurrentUser); if (isBot && !isOurBot || e.Guild == null) { return; } ulong id = e.Message.Id; // Clear cache if bot’s message was deleted if (isOurBot && Cache.ContainsValue(id)) { ulong key = Cache.FirstOrDefault(x => x.Value == id).Key; Cache.Remove(key); return; } // Ignore unknown messages / messages from our bot if (isOurBot || !Cache.ContainsKey(id)) { return; } // Delete message DiscordMessage response = await e.Channel.GetMessageAsync(Cache[id]); Cache.Remove(id); await response.DeleteAsync(); }
public async Task UpdateHub(CommandContext ctx) { TimerMethod.UpdateHubInfo(true); DiscordMessage msg = await ctx.RespondAsync("TCHub info has been force updated."); await Task.Delay(10000).ContinueWith(f => msg.DeleteAsync()); }
public async Task RequestPoints() { DiscordMessageBuilder discordMessage = new DiscordMessageBuilder { Content = $"For this rule you can reduce the users chances by {Rule.MinPoints} - {Rule.MaxPoints}" }; for (int i = 0; i < 3; i++) { List <DiscordButtonComponent> buttons = new List <DiscordButtonComponent>(); for (int index = i * 5; index < (i * 5) + 5; index++) { buttons.Add(new DiscordButtonComponent ( ButtonStyle.Primary, (index + 1).ToString(), (index + 1).ToString(), (index + 1) < Rule.MinPoints || (index + 1) > Rule.MaxPoints) ); } discordMessage.AddComponents(buttons); } DiscordMessage pointsMessage = await WarnChannel.SendMessageAsync(discordMessage); var interactpointsMessage = await Interactivity.WaitForButtonAsync(pointsMessage, Mod, TimeSpan.FromMinutes(2)); PointsDeducted = int.Parse(interactpointsMessage.Result.Id); await pointsMessage.DeleteAsync(); }
public async Task AddNote(CommandContext ctx, DiscordUser user, [RemainingText] string note) { await ctx.Message.DeleteAsync(); await ctx.TriggerTypingAsync(); DB.Warnings newEntry = new() { Server_ID = ctx.Guild.Id, Active = false, Admin_ID = ctx.Message.Author.Id, Type = "note", User_ID = user.Id, Date = DateTime.Now.ToString("yyyy-MM-dd"), Reason = note }; DB.DBLists.InsertWarnings(newEntry); DiscordMessage response = await new DiscordMessageBuilder() .WithContent($"{ctx.User.Mention}, a note has been added to {user.Username}({user.Id})") .WithAllowedMention(new UserMention()) .SendAsync(ctx.Channel); await Task.Delay(10000).ContinueWith(t => response.DeleteAsync()); } }
private async Task <string> WaitForFinishingMoveAsync() { DiscordMessage msg = await this.Channel.EmbedAsync($"{StaticDiscordEmoji.DuelSwords} {this.Winner.Mention}, FINISH HIM! {StaticDiscordEmoji.DuelSwords}"); InteractivityResult <DiscordMessage> mctx = await this.Interactivity.WaitForMessageAsync( m => m.ChannelId == this.Channel.Id && m.Author.Id == this.Winner.Id, TimeSpan.FromSeconds(15) ); if (mctx.TimedOut || string.IsNullOrWhiteSpace(mctx.Result.Content)) { return(null); } try { await msg.DeleteAsync(); await mctx.Result.DeleteAsync(); } catch (Exception e) when(e is UnauthorizedException || e is NotFoundException) { // No permissions to delete the messages } return(mctx.Result.Content.Trim()); }
public static async Task <bool> PromptUserToConfirm(CommandContext Context, string PromptMessage, bool bDeleteOnComplete = true) { var Interactivity = Context.Client.GetExtension <InteractivityExtension>(); await Context.TriggerTypingAsync(); DiscordMessage Msg = await Context.RespondAsync(PromptMessage); await Msg.CreateReactionAsync(DiscordEmoji.FromName(Context.Client, ":white_check_mark:")); await Msg.CreateReactionAsync(DiscordEmoji.FromName(Context.Client, ":x:")); var ReactContext = await Interactivity.WaitForReactionAsync(x => x.Emoji.Name == "✅" || x.Emoji.Name == "❌", Msg, Context.User); if (bDeleteOnComplete) { await Msg.DeleteAsync(); } if (ReactContext.Result != null && ReactContext.Result.Emoji.Name == "✅") { return(true); } return(false); }
public async Task BanWord(CommandContext ctx, [Description("The word that is banned")] string BannedWord, [Description("What the user will be warned with when using such word")][RemainingText] string warning) { await ctx.Message.DeleteAsync(); await ctx.TriggerTypingAsync(); string info = ""; DB.DBLists.LoadBannedWords(); var duplicate = (from bw in DB.DBLists.AMBannedWords where bw.Server_ID == ctx.Guild.Id where bw.Word == BannedWord.ToLower() select bw).FirstOrDefault(); if (duplicate is null) { DB.AMBannedWords newEntry = new() { Word = BannedWord.ToLower(), Offense = warning, Server_ID = ctx.Guild.Id }; DB.DBLists.InsertBannedWords(newEntry); info = $"The word `{BannedWord.ToLower()}` has been added to the list. They will be warned with `{warning}`"; } else { info = $"The word `{BannedWord.ToLower()}` is already in the database for this server."; } DiscordMessage msg = await ctx.RespondAsync(info); await Task.Delay(5000).ContinueWith(t => msg.DeleteAsync()); }
public async Task RemoveServerAsync(IPEndPoint endPoint, ulong guildID) { GameServer serverToRemove = (await _dbContext.GameServers.AsQueryable().ToListAsync()).FirstOrDefault(x => x.ServerIP.Address.ToString() == endPoint.Address.ToString() && x.ServerIP.Port == endPoint.Port && x.GuildID == guildID); if (serverToRemove == null) { throw new ArgumentException("The specified server does not exist"); } if (serverToRemove.MessageID != null) { try { if (!_discordClient.Guilds.TryGetValue(serverToRemove.GuildID, out DiscordGuild guild)) { return; } DiscordChannel channel = guild?.GetChannel(serverToRemove.ChannelID); DiscordMessage msg = await(channel?.GetMessageAsync(serverToRemove.MessageID.Value)); if (msg != null) { await msg.DeleteAsync(); } } catch (Exception e) { _logger.LogError(e, $"Error trying to remove message for game server {endPoint.Address}"); } } _dbContext.GameServers.Remove(serverToRemove); await _dbContext.SaveChangesAsync(); }
public async Task CMDUpdated(CommandContext ctx, [Description("The name of the command you want to change the output of")] string command, [Description("Language tag (e.g. english is gb)")] string language, [Description("Text you want the bot to output for this command")][RemainingText] string BotResponse) { await ctx.TriggerTypingAsync(); await ctx.Message.DeleteAsync(); var BotOutputEntry = DB.DBLists.BotOutputList.FirstOrDefault(w => w.Command.Equals(command) && w.Language.Equals(language)); if (BotOutputEntry is null) { await new DiscordMessageBuilder() .WithContent($"{ctx.Member.Mention}, This combination of command and language tag does not exist in the databse.") .WithAllowedMention(new UserMention()) .SendAsync(ctx.Channel); } else { string completion_response = $"The response for `/{command}` was changed\n**From:** `{BotOutputEntry.Command_Text}`\n**To:** `{BotResponse}`"; BotOutputEntry.Command_Text = BotResponse; DB.DBLists.UpdateBotOutputList(BotOutputEntry); DB.DBLists.LoadBotOutputList(); DiscordMessage OutMSG = await ctx.RespondAsync(completion_response); await Task.Delay(10000).ContinueWith(t => OutMSG.DeleteAsync()); } }
async Task awaitdel(DiscordMessage discordMessage, int ms) { await Task.Delay(ms); try { await discordMessage.DeleteAsync(); } catch (Exception e) { Console.WriteLine($"Deleting message with ID {discordMessage.Id} failed. Reason: {e.Message}"); } }
public async Task approvemimic(CommandContext ctx, [Description("The member in the mimic")] DiscordMember member, [Description("The Id or link of submission message.")] DiscordMessage discordMessage) { await ctx.Message.DeleteAsync().ConfigureAwait(false); int newId = 0; try { newId = Directory.GetFiles($"Resources/Sound/Mimics/{ member.Id }/", "*", SearchOption.AllDirectories).Length; using (WebClient client = new WebClient()) { client.DownloadFile(discordMessage.Attachments.FirstOrDefault().Url, $"Resources/Sound/Mimics/{ member.Id }/{discordMessage.Attachments[0].FileName}.mp3"); } } catch { Directory.CreateDirectory($"Resources/Sound/Mimics/{ member.Id }/"); using (WebClient client = new WebClient()) { client.DownloadFile(discordMessage.Attachments.FirstOrDefault().Url, $"Resources/Sound/Mimics/{ member.Id }/{discordMessage.Attachments[0].FileName}"); } } await discordMessage.DeleteAsync(); await ctx.Channel.SendMessageAsync($"Mimic for {member.Username} was added, Id is {newId}, name is {discordMessage.Attachments[0].FileName}."); }
public async Task FlagMessageAsync(CommandContext ctx, [Description("Message.")] DiscordMessage msg = null, [Description("Voting timespan.")] TimeSpan?timespan = null) { msg = msg ?? (await ctx.Channel.GetMessagesBeforeAsync(ctx.Channel.LastMessageId, 1))?.FirstOrDefault(); if (msg is null) { throw new CommandFailedException("Cannot retrieve the message!"); } if (timespan?.TotalSeconds < 5 || timespan?.TotalMinutes > 5) { throw new InvalidCommandUsageException("Timespan cannot be greater than 5 minutes or lower than 5 seconds."); } IEnumerable <PollEmoji> res = await msg.DoPollAsync(new[] { StaticDiscordEmoji.ArrowUp, StaticDiscordEmoji.ArrowDown }, PollBehaviour.Default, timeout : timespan ?? TimeSpan.FromMinutes(1)); var votes = res.ToDictionary(pe => pe.Emoji, pe => pe.Voted.Count); if (votes.GetValueOrDefault(StaticDiscordEmoji.ArrowDown) > 2 * votes.GetValueOrDefault(StaticDiscordEmoji.ArrowUp)) { string sanitized = FormatterExtensions.Spoiler(FormatterExtensions.StripMarkdown(msg.Content)); await msg.DeleteAsync(); await ctx.RespondAsync($"{msg.Author.Mention} said: {sanitized}"); } else { await this.InformOfFailureAsync(ctx, "Not enough downvotes required for deletion."); } }
public async Task Unbind(CommandContext ctx) { if (ctx.Channel.Get(ConfigManager.Enabled) .And(ctx.Channel.GetMethodEnabled())) { await ctx.TriggerTypingAsync(); (ulong?channel, ulong?message) = ctx.Guild.GetReactionRoleMessage() ?? throw new Exception("Most likely already unbound"); if (!channel.HasValue || !message.HasValue) { await ctx.RespondAsync("Already unbound"); return; } DiscordMessage msg = await(await ctx.Client.GetChannelAsync(channel.Value)).GetMessageAsync(message.Value); if (msg.Author.IsCurrent) { await msg.DeleteAsync(); } ctx.Guild.SetReactionRoleMessage(null); await ctx.RespondAsync("Done."); } }
public async Task Addhours(CommandContext ctx) { DiscordMessage mensaje = await ctx.RespondAsync("You need to put a the number of hours and the subject! *in that order*"); System.Threading.Thread.Sleep(5000); await mensaje.DeleteAsync(); }