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);
}
