public async Task <CommandResponse> Process(IDiscordBotContext context) { if (SettingsConfig.Instance.CreateEndpoint != null && context.GuildChannel != null) { var guildName = WebUtility.UrlEncode(context.GuildChannel.Guild.Name); var req = WebRequest.Create($"{SettingsConfig.Instance.CreateEndpoint}?id={context.GuildChannel.Guild.Id}&name={guildName}"); try { await req.GetResponseAsync(); return(new CommandResponse { Text = $"Manage from {SettingsConfig.Instance.ManagementEndpoint}" }); } catch (Exception ex) { Log.Error(ex, "Failure in admin command"); return(new CommandResponse { Text = "Settings creation failed, report this to the support server" }); } } return(null); }
public override async Task <ModuleResult> ProcessDiscordModule(IDiscordBotContext context) { // check for word censors if (context.Message != null && context.Settings.TriggersCensor(context.Message.Content, out string offendingWord)) { offendingWord = offendingWord != null ? $"`{offendingWord}`" : "*FANCY lanuage filters*"; await context.Message.DeleteAsync(); if (!this.blockedDMUsers.Contains(context.Message.Author.Id)) { var dmChannel = await context.Message.Author.GetOrCreateDMChannelAsync(); try { await dmChannel.SendMessageAsync($"hi uh sorry but your most recent message was tripped up by {offendingWord} and thusly was deleted. complain to management, i'm just the enforcer"); } catch (HttpException) { this.blockedDMUsers.Add(context.Message.Author.Id); } } return(ModuleResult.Stop); } return(ModuleResult.Continue); }
public Task <CommandResponse> Process(IDiscordBotContext context) { var channel = (context.Message.Author as SocketGuildUser)?.VoiceChannel; if (channel == null) { return(Task.FromResult(new CommandResponse { Text = "Join a voice channel first" })); } Task.Run(async() => { try { if (await context.AudioManager.JoinAudioAsync(channel)) { await context.Message.Channel.SendMessageAsync($"[Joined {channel.Name}]"); } } catch (Exception ex) { Log.Error(ex, "Failure in voice join command"); } }).Forget(); return(Task.FromResult((CommandResponse)null)); }
public async Task <CommandResponse> Process(IDiscordBotContext context) { var guildChannel = context.GuildChannel; if (guildChannel == null) { return(null); } var parts = context.Message.Content.Split(new[] { ' ' }, 2); if (parts.Length == 1) { return(new CommandResponse { Text = "Ask a question for your poll, jeez" }); } if (!(guildChannel as ITextChannel).GetCurrentUserPermissions().AddReactions) { return(new CommandResponse { Text = "oy barfbag I don't have permissions to add reactions in here." }); } await context.Message.AddReactionAsync(Emote.Parse("<:check:363764608969867274>")); await context.Message.AddReactionAsync(Emote.Parse("<:xmark:363764632160043008>")); return(null); }
public Task <CommandResponse> Process(IDiscordBotContext context) { var channel = (context.Message.Author as SocketGuildUser)?.VoiceChannel; if (channel == null) { return(Task.FromResult(new CommandResponse { Text = "Join a voice channel first" })); } Task.Run(async() => { try { await context.AudioManager.JoinAudioAsync(channel); } catch (Exception ex) { // TODO: proper logging Console.WriteLine(ex); } }).Forget(); return(Task.FromResult((CommandResponse)null)); }
public async Task <CommandResponse> Process(IDiscordBotContext context) { if (context.GuildChannel != null) { var settings = SettingsConfig.GetSettings(context.GuildChannel.Guild.Id.ToString()); string[] parts = context.Message.Content.Split(new[] { ' ' }, 3); if (parts.Length != 3) { return(new CommandResponse { Text = "Usage: .remove type #; valid types are timer, wc, user, or bday" }); } var type = parts[1].ToLowerInvariant(); var id = parts[2]; context.MessageData.Content = $"{settings.Prefix}remove {CommandsConfig.Instance.HelperKey} {type} {id}"; var response = (await context.BotApi.IssueRequestAsync(context.MessageData)).Responses.FirstOrDefault(); if (response != null) { return(new CommandResponse { Text = response }); } } return(null); }
public override Task <ModuleResult> ProcessDiscordModule(IDiscordBotContext context) { if (context.Settings.AprilFoolsEnabled && BotConfig.Instance.AprilFools.Chance > 0 && random.Next(1, 100) <= BotConfig.Instance.AprilFools.Chance && context.GuildChannel != null) { Task.Run(async() => { await Task.Delay(BotConfig.Instance.AprilFools.Delay); try { await context.GuildChannel.Guild.DownloadUsersAsync(); var bots = context.GuildChannel.Guild.Users.Where(u => u.IsBot && !u.IsWebhook && u.Id != BotConfig.Instance.Discord.BotId && !BotConfig.Instance.AprilFools.IgnoreIds.Contains(u.Id)); if (bots.Any()) { var botMention = bots.Select(b => b.Mention).ToArray().Random(); var botInsult = BotConfig.Instance.AprilFools.Responses.Random().Replace("{bot}", botMention).Replace("{author}", context.Message.Author.UserOrNickname()); Log.Verbose($"[AF] [{context.GuildChannel.Guild.Id}]: {botInsult}"); await context.Message.Channel.SendMessageAsync(botInsult); } } catch (Exception ex) { Log.Warning(ex, "Failure in AF module send"); } }).Forget(); } return(Task.FromResult(ModuleResult.Continue)); }
public override async Task <ModuleResult> ProcessDiscordModule(IDiscordBotContext context) { // special case FAQ channel var message = context.Message; if (message.Channel.Id == BotConfig.Instance.FaqChannel && message.Content.EndsWith("?") && BotConfig.Instance.FaqEndpoint != null) { string content = message.Content.Replace("<@85614143951892480>", "ub3r-b0t"); var result = await BotConfig.Instance.FaqEndpoint.ToString().WithHeader("Ocp-Apim-Subscription-Key", BotConfig.Instance.FaqKey).PostJsonAsync(new { question = content }); if (result.IsSuccessStatusCode) { var response = await result.Content.ReadAsStringAsync(); var qnaData = JsonConvert.DeserializeObject <QnAMakerData>(response); var score = Math.Floor(qnaData.Score); var answer = System.Net.WebUtility.HtmlDecode(qnaData.Answer); await message.Channel.SendMessageAsync($"{answer} ({score}% match)"); } else { await message.Channel.SendMessageAsync("An error occurred while fetching data"); } return(ModuleResult.Stop); } return(ModuleResult.Continue); }
public async Task <CommandResponse> Process(IDiscordBotContext context) { var guildChannel = context.Message.Channel as SocketGuildChannel; var textChannel = context.Message.Channel as SocketTextChannel; var botGuildUser = guildChannel.GetUser(context.Client.CurrentUser.Id); var existingNickname = botGuildUser.Nickname; await botGuildUser.ModifyAsync(x => x.Nickname = "Kwame"); await textChannel.SendMessageAsync("EARTH!"); await Task.Delay(1100); await botGuildUser.ModifyAsync(x => x.Nickname = "Wheeler"); await textChannel.SendMessageAsync("FIRE!"); await Task.Delay(1100); await botGuildUser.ModifyAsync(x => x.Nickname = "Linka"); await textChannel.SendMessageAsync("WIND!"); await Task.Delay(1100); await botGuildUser.ModifyAsync(x => x.Nickname = "Gi"); await textChannel.SendMessageAsync("WATER!"); await Task.Delay(1100); await botGuildUser.ModifyAsync(x => x.Nickname = "Ma-ti"); await textChannel.SendMessageAsync("HEART!"); await Task.Delay(1100); await botGuildUser.ModifyAsync(x => x.Nickname = "anonymous"); await textChannel.SendMessageAsync("by your powers combined..."); await Task.Delay(1100); await botGuildUser.ModifyAsync(x => x.Nickname = "Captain Planet"); await textChannel.SendMessageAsync("I AM CAPTAIN PLANET!"); await Task.Delay(1100); await botGuildUser.ModifyAsync(x => x.Nickname = "Everyone"); await textChannel.SendMessageAsync("GOOOO PLANET!"); await Task.Delay(5000); await botGuildUser.ModifyAsync(x => x.Nickname = existingNickname); return(null); }
public async Task <CommandResponse> Process(IDiscordBotContext context) { var guildChannel = context.GuildChannel; if (guildChannel == null) { return(null); } var parts = context.Message.Content.Split(new[] { ' ' }, 2); if (parts.Length == 1) { return(new CommandResponse { Text = "Ask a question for your poll, jeez... (add --options # to use a numbered list instead of yes/no)" }); } var currentPermissions = (guildChannel as ITextChannel).GetCurrentUserPermissions(); if (!currentPermissions.AddReactions) { return(new CommandResponse { Text = "oy barfbag I don't have permissions to add reactions in here." }); } var match = optionsRx.Match(parts[1]); if (match.Success && int.TryParse(match.Groups["count"].Value, out int optionCount)) { if (optionCount > 10) { return(new CommandResponse { Text = "sorry i can only count to 10. math is HARD especially for computers ok?" }); } for (var i = 0; i < optionCount; i++) { var codepoint = i < 9 ? $"{(char)(49 + i)}\U000020e3" : "\U0001f51f"; await context.Message.AddReactionAsync(new Emoji($"{codepoint}")); } } else if (currentPermissions.UseExternalEmojis) { await context.Message.AddReactionAsync(Emote.Parse("<:check:363764608969867274>")); await context.Message.AddReactionAsync(Emote.Parse("<:xmark:363764632160043008>")); } else { await context.Message.AddReactionAsync(new Emoji("✅")); await context.Message.AddReactionAsync(new Emoji("❌")); } return(null); }
public override async Task <ModuleResult> ProcessDiscordModule(IDiscordBotContext context) { // special case FAQ channel var message = context.Message; var messageCommand = context.Interaction as SocketMessageCommand; if (message != null && BotConfig.Instance.FaqEndpoints != null && BotConfig.Instance.FaqEndpoints.TryGetValue(message.Channel.Id, out var faq) && faq.Endpoint != null && (context.Reaction == faq.Reaction || messageCommand != null && messageCommand.CommandName.IEquals(faq.Command) || string.IsNullOrEmpty(context.Reaction) && !string.IsNullOrEmpty(faq.EndsWith) && message.Content.EndsWith(faq.EndsWith))) { if (messageCommand != null) { await messageCommand.DeferAsync(); } await message.AddReactionAsync(new Emoji(faq.Reaction)); string content = message.Content.Replace("<@85614143951892480>", "ub3r-b0t"); var result = await faq.Endpoint.ToString().WithHeader("Authorization", BotConfig.Instance.FaqKey).PostJsonAsync(new { question = content, top = 2 }); if (result.IsSuccessStatusCode()) { var response = await result.GetStringAsync(); var qnaData = JsonConvert.DeserializeObject <QnAMakerData>(response); var responses = new List <string>(); foreach (var answer in qnaData.Answers) { var score = Math.Floor(answer.Score); var answerText = WebUtility.HtmlDecode(answer.Answer); responses.Add($"{answerText} ({score}% match)"); } if (messageCommand != null) { await messageCommand.FollowupAsync(string.Join("\n\n", responses)); } else { await message.Channel.SendMessageAsync(string.Join("\n\n", responses)); } } else { if (messageCommand != null) { await messageCommand.FollowupAsync("An error occurred while fetching data"); } else { await message.Channel.SendMessageAsync("An error occurred while fetching data"); } } return(ModuleResult.Stop); } return(ModuleResult.Continue); }
public async Task <CommandResponse> Process(IDiscordBotContext context) { if (context.Message.Channel is IGuildChannel guildChannel) { var settings = SettingsConfig.GetSettings(guildChannel.GuildId.ToString()); if (!settings.SeenEnabled) { return(new CommandResponse { Text = "Seen data is not being tracked for this server. Enable it in the admin settings panel." }); } string[] parts = context.Message.Content.Split(new[] { ' ' }, 2); if (parts.Length != 2) { return(new CommandResponse { Text = "Usage: .seen username" }); } var targetUser = (await guildChannel.Guild.GetUsersAsync()).Find(parts[1]).FirstOrDefault(); if (targetUser != null) { if (targetUser.Id == context.Client.CurrentUser.Id) { return(new CommandResponse { Text = $"I was last seen...wait...seriously? Ain't no one got time for your shit, {context.Message.Author.Username}." }); } if (targetUser.Id == context.Message.Author.Id) { return(new CommandResponse { Text = $"You were last seen now, saying: ... god DAMN it {context.Message.Author.Username}, quit wasting my time" }); } context.MessageData.Content = $"{settings.Prefix}seen {targetUser.Id} {targetUser.Username}"; var response = (await context.BotApi.IssueRequestAsync(context.MessageData)).Responses.FirstOrDefault(); if (response != null) { return(new CommandResponse { Text = response }); } } return(new CommandResponse { Text = $"I...omg...I have not seen {parts[1]} in this channel :X I AM SOOOOOO SORRY" }); } return(null); }
public Task <CommandResponse> Process(IDiscordBotContext context) { var serverId = context.GuildChannel?.Guild.Id.ToString() ?? "n/a"; var botVersion = Assembly.GetEntryAssembly().GetName().Version.ToString(); var response = new CommandResponse { Text = $"```Server ID: {serverId} | Channel ID: {context.Channel.Id} | Your ID: {context.Author.Id} | Shard ID: {context.Client.ShardId} | Version: {botVersion} | Discord.NET Version: {DiscordSocketConfig.Version}```" }; return(Task.FromResult(response)); }
public override Task <ModuleResult> ProcessDiscordModule(IDiscordBotContext context) { // if the user is blocked based on role, return var botlessRoleId = context.GuildChannel?.Guild.Roles?.FirstOrDefault(r => r.Name?.ToLowerInvariant() == BotlessRole)?.Id; if (botlessRoleId != null && ((context.Message.Author as SocketGuildUser)?.Roles.Any(r => r.Id == botlessRoleId.Value) ?? false)) { return(Task.FromResult(ModuleResult.Stop)); } return(Task.FromResult(ModuleResult.Continue)); }
public Task <CommandResponse> Process(IDiscordBotContext context) { if (context.Message.Channel is SocketGuildChannel guildChannel) { var settings = SettingsConfig.GetSettings(guildChannel.Guild.Id.ToString()); var roles = guildChannel.Guild.Roles.Where(r => settings.SelfRoles.Contains(r.Id)).Select(r => $"``{r.Name.Replace("`", @"\`")}``"); return(Task.FromResult(new CommandResponse { Text = "The following roles are available to self-assign: " + string.Join(", ", roles) })); } return(Task.FromResult(new CommandResponse { Text = "role command does not work in private channels" })); }
public override bool CheckPermissions(IDiscordBotContext context) { var guildUser = context.Message.Author as SocketGuildUser; if (this.GuildPermission.HasValue) { return(guildUser?.GuildPermissions.Has(this.GuildPermission.Value) ?? false); } if (this.ChannelPermission.HasValue) { var textChannel = context.Message.Channel as ITextChannel; return(guildUser?.GetPermissions(textChannel).Has(this.ChannelPermission.Value) ?? false); } return(false); }
public override bool CheckPermissions(IDiscordBotContext context) { var botGuildUser = context.CurrentUser; if (this.GuildPermission.HasValue) { return(botGuildUser?.GuildPermissions.Has(this.GuildPermission.Value) ?? false); } if (this.ChannelPermission.HasValue) { var textChannel = context.Channel as ITextChannel; return(botGuildUser?.GetPermissions(textChannel).Has(this.ChannelPermission.Value) ?? false); } return(false); }
public Task <CommandResponse> Process(IDiscordBotContext context) { CommandResponse response = null; string[] parts = context.MessageData.Content.Split(new[] { ' ' }, 3); if (parts.Length >= 3 && (parts[1].IEquals("del") || parts[1].IEquals("delete") || parts[1].IEquals("remove"))) { var guildUser = context.Message.Author as SocketGuildUser; if (guildUser == null || !guildUser.GuildPermissions.Has(GuildPermission.ManageMessages)) { response = new CommandResponse { Text = "sorry boss but removing quotes requires manage message permissions. ask management to remove it. and be a jerk about it. trust me it works every time" }; } } return(Task.FromResult(response)); }
public async Task <CommandResponse> Process(IDiscordBotContext context) { var message = context.Message; // grab the message being referenced var parts = message.Content.Split(new[] { ' ' }, 3); if (parts.Length != 3) { return(new CommandResponse { Text = ".fr id message" }); } if (!ulong.TryParse(parts[1], out ulong targetMessageId)) { return(new CommandResponse { Text = "invalid message id" }); } var targetMessage = await context.Channel.GetMessageAsync(targetMessageId); if (targetMessage == null) { return(new CommandResponse { Text = "message not found" }); } var match = FeedbackMessageRx.Match(targetMessage.Content); context.MessageData.Content = $"{context.Settings.Prefix}feedback reply {match.Groups[1]} {match.Groups[2]} {match.Groups[3]} {parts[2]}"; var response = (await context.BotApi.IssueRequestAsync(context.MessageData)).Responses.FirstOrDefault(); if (response != null) { return(new CommandResponse { Text = response }); } return(null); }
public Task <CommandResponse> Process(IDiscordBotContext context) { if (context.Message.Channel is SocketGuildChannel channel) { Task.Run(async() => { try { await context.AudioManager.LeaveAudioAsync(channel); } catch (Exception ex) { Log.Error(ex, "Failure in voice leave command"); } }).Forget(); } return(Task.FromResult((CommandResponse)null)); }
public Task <CommandResponse> Process(IDiscordBotContext context) { if (context.Message.Channel is SocketGuildChannel channel) { Task.Run(async() => { try { await context.AudioManager.LeaveAudioAsync(channel); } catch (Exception ex) { // TODO: proper logging Console.WriteLine(ex); } }).Forget(); } return(Task.FromResult((CommandResponse)null)); }
private async Task <bool> CheckPermissions(IDiscordBotContext context, TypeInfo typeInfo) { var attributes = typeInfo.GetCustomAttributes().Where(a => a is PermissionsAttribute); var attributeChecksPassed = true; foreach (PermissionsAttribute attr in attributes) { if (!attr.CheckPermissions(context)) { if (!string.IsNullOrEmpty(attr.FailureMessage)) { await this.RespondAsync(context.Message, attr.FailureMessage); } attributeChecksPassed = false; } } return(attributeChecksPassed); }
public async Task <CommandResponse> Process(IDiscordBotContext context) { var messageParts = context.Message.Content.Split(new[] { ' ' }, 2); var fileName = "moar.jpeg"; var url = string.Empty; if (messageParts.Length == 2 && Uri.IsWellFormedUriString(messageParts[1], UriKind.Absolute)) { url = messageParts[1]; } else { Attachment img = context.Message.Attachments.FirstOrDefault(); if (img != null || DiscordBot.imageUrls.TryGetValue(context.Message.Channel.Id.ToString(), out img)) { url = img.Url; fileName = img.Filename; } } if (!string.IsNullOrEmpty(url)) { using (var httpClient = new HttpClient()) { var response = await httpClient.GetAsync(CommandsConfig.Instance.JpegEndpoint.AppendQueryParam("url", url)); var stream = await response.Content.ReadAsStreamAsync(); return(new CommandResponse { Attachment = new FileResponse { Name = fileName, Stream = stream, } }); } } return(null); }
public override async Task <ModuleResult> ProcessDiscordModule(IDiscordBotContext context) { // check for word censors; ignore if we can't delete messages var canDeleteMessages = (context.GuildChannel as ITextChannel).GetCurrentUserPermissions().ManageMessages; if (context.Message != null && context.Settings.TriggersCensor(context.Message.Content, out string offendingWord) && canDeleteMessages) { offendingWord = offendingWord != null ? $"`{offendingWord}`" : "*FANCY lanuage filters*"; bool messageDeleted = false; try { await context.Message.DeleteAsync(); messageDeleted = true; } catch (HttpException ex) when(ex.HttpCode == HttpStatusCode.NotFound) { // ignore if the message isn't found (may have been deleted already) } if (!this.blockedDMUsers.Contains(context.Message.Author.Id) && messageDeleted) { var dmChannel = await context.Message.Author.CreateDMChannelAsync(); try { await dmChannel.SendMessageAsync($"hi uh sorry but your most recent message was tripped up by {offendingWord} and thusly was deleted. complain to management, i'm just the enforcer"); } catch (HttpException) { this.blockedDMUsers.Add(context.Message.Author.Id); } } return(ModuleResult.Stop); } return(ModuleResult.Continue); }
public override bool CheckPermissions(IDiscordBotContext context) { var guildUser = context.Author as SocketGuildUser; if (guildUser.Id == BotConfig.Instance.Discord.OwnerId) { return(true); } if (this.GuildPermission.HasValue) { return(guildUser?.GuildPermissions.Has(this.GuildPermission.Value) ?? false); } if (this.ChannelPermission.HasValue) { var textChannel = context.Channel as ITextChannel; return(guildUser?.GetPermissions(textChannel).Has(this.ChannelPermission.Value) ?? false); } return(false); }
public async Task <CommandResponse> Process(IDiscordBotContext context) { var script = context.Message.Content.Split(new[] { ' ' }, 2)[1]; string result; try { var evalResult = await CSharpScript.EvaluateAsync <object>(script, scriptOptions, globals : new ScriptHost { Message = context.Message, Client = context.Client }); result = evalResult.ToString(); } catch (Exception ex) { result = ex.ToString().SubstringUpTo(800); } return(new CommandResponse { Text = $"``{result}``" }); }
public async Task <CommandResponse> Process(IDiscordBotContext context) { var serversStatus = await Utilities.GetApiResponseAsync <HeartbeatData[]>(BotConfig.Instance.HeartbeatEndpoint); var dataSb = new StringBuilder(); dataSb.Append("```cs\n" + "type shard server count users voice count\n"); int serverTotal = 0; int userTotal = 0; int voiceTotal = 0; foreach (HeartbeatData heartbeat in serversStatus) { serverTotal += heartbeat.ServerCount; userTotal += heartbeat.UserCount; voiceTotal += heartbeat.VoiceChannelCount; var botType = heartbeat.BotType.PadRight(11); var shard = heartbeat.Shard.ToString().PadLeft(4); var servers = heartbeat.ServerCount.ToString().PadLeft(13); var users = heartbeat.UserCount.ToString().PadLeft(10); var voice = heartbeat.VoiceChannelCount.ToString().PadLeft(13); dataSb.Append($"{botType} {shard} {servers} {users} {voice}\n"); } // add up totals dataSb.Append($"-------\n"); dataSb.Append($"Total: {serverTotal.ToString().PadLeft(13)} {userTotal.ToString().PadLeft(10)} {voiceTotal.ToString().PadLeft(13)}\n"); dataSb.Append("```"); return(new CommandResponse { Text = dataSb.ToString() }); }
public async Task <CommandResponse> Process(IDiscordBotContext context) { if (SettingsConfig.Instance.CreateEndpoint != null && context.GuildChannel != null) { var guildName = WebUtility.UrlEncode(context.GuildChannel.Guild.Name); var req = WebRequest.Create($"{SettingsConfig.Instance.CreateEndpoint}?id={context.GuildChannel.Guild.Id}&name={guildName}"); try { await req.GetResponseAsync(); return(new CommandResponse { Text = $"Manage from {SettingsConfig.Instance.ManagementEndpoint}" }); } catch (Exception ex) { // TODO: proper logging Console.WriteLine(ex); } } return(null); }
public Task <CommandResponse> Process(IDiscordBotContext context) { if (context.Message.Channel is SocketGuildChannel guildChannel) { var settings = SettingsConfig.GetSettings(guildChannel.Guild.Id.ToString()); var roles = guildChannel.Guild.Roles.Where(r => settings.SelfRoles.Contains(r.Id)).Select(r => $"``{r.Name.Replace("`", @"\`")}``").OrderBy(r => r); var multiText = new List <string>(); var sb = new StringBuilder(); sb.Append("The following roles are available to self-assign: "); foreach (var role in roles) { if (sb.Length + role.Length + 2 < Discord.DiscordConfig.MaxMessageSize) { sb.Append($"{role}, "); } else { multiText.Add(sb.ToString()); sb.Clear(); sb.Append($"{role}, "); } } multiText.Add(sb.ToString()); return(Task.FromResult(new CommandResponse { MultiText = multiText })); } return(Task.FromResult(new CommandResponse { Text = "role command does not work in private channels" })); }
public async Task <CommandResponse> Process(IDiscordBotContext context) { var guildChannel = context.GuildChannel; if (guildChannel == null) { return(null); } var parts = context.Message.Content.Split(new[] { ' ' }, 2); if (parts.Length == 1) { return(new CommandResponse { Text = "Ask a question for your poll, jeez" }); } await context.Message.AddReactionAsync(Emote.Parse("<:check:363764608969867274>")); await context.Message.AddReactionAsync(Emote.Parse("<:xmark:363764632160043008>")); return(null); }