public static async Task <Channel> MatchChannel(this Context ctx)
{
if (!MentionUtils.TryParseChannel(ctx.PeekArgument(), out var id))
{
return(null);
}
var channel = await ctx.Cache.TryGetChannel(id);
if (channel == null)
{
channel = await ctx.Rest.GetChannelOrNull(id);
}
if (channel == null)
{
return(null);
}
if (!DiscordUtils.IsValidGuildChannel(channel))
{
return(null);
}
ctx.PopArgument();
return(channel);
}
public override ValueTask <TypeParserResult <SocketTextChannel> > ParseAsync(string value, VolteContext ctx)
{
SocketTextChannel channel = default;
if (ulong.TryParse(value, out var id) || MentionUtils.TryParseChannel(value, out id))
{
channel = ctx.Client.GetChannel(id).Cast <SocketTextChannel>();
}
if (channel is null)
{
var match = ctx.Guild.TextChannels.Where(x => x.Name.EqualsIgnoreCase(value))
.ToList();
if (match.Count > 1)
{
return(Failure(
"Multiple channels found. Try mentioning the channel or using its ID."));
}
channel = match.First();
}
return(channel is null
? Failure("Channel not found.")
: Success(channel));
}
public override Task <TypeParserResult <T> > ParseAsync(Parameter parameter, string value, ICommandContext context, IServiceProvider provider)
{
var _context = context as GuildContext;
var results = new Dictionary <ulong, GenericParseResult <T> >();
var channels = _context.Guild.Channels;
//By Mention (1.0)
if (MentionUtils.TryParseChannel(value, out ulong id))
{
AddResult(results, _context.Guild.GetChannel(id) as T, 1.00f);
}
//By Id (0.9)
if (ulong.TryParse(value, NumberStyles.None, CultureInfo.InvariantCulture, out id))
{
AddResult(results, _context.Guild.GetChannel(id) as T, 0.90f);
}
//By Name (0.7-0.8)
foreach (var channel in channels.Where(x => string.Equals(value, x.Name, StringComparison.OrdinalIgnoreCase)))
{
AddResult(results, channel as T, channel.Name == value ? 0.80f : 0.70f);
}
if (results.Count > 0)
{
return(Task.FromResult(new TypeParserResult <T>(results.Values.OrderBy(a => a.Score).FirstOrDefault()?.Value)));
}
return(Task.FromResult(new TypeParserResult <T>("Channel not found.")));
}
private async void SetLoggingChannelInformation(string value)
{
if (!MentionUtils.TryParseChannel(value, out ulong parserId))
{
await ReplyAsync("Please pass in a valid channel!");
return;
}
var parsedChannel = Context.Guild.GetTextChannel(parserId);
if (parsedChannel == null)
{
await ReplyAsync("Please pass in a valid channel!");
return;
}
await _servers.ModifyLoggingChannel(Context.Guild.Id, parserId);
await ReplyAsync($"Successfully modified the logging channel to {parsedChannel.Mention}");
var perms = Context.Guild.CurrentUser.GetPermissions(parsedChannel);
if (!perms.SendMessages)
{
await ReplyAsync("`Warning` the bot does not have permisson to send messages to the logging channel!");
}
_logger.LogInformation("{user} set the logging channel to {value} for {server}",
Context.User.Username, value, Context.Guild.Name);
}
public async Task AddLimit(string value = null)
{
await Context.Channel.TriggerTypingAsync();
if (value != null)
{
if (!MentionUtils.TryParseChannel(value, out ulong parsedId))
{
await Context.Channel.SendErrorAsync("Channel Limits", "Please pass in a valid channel!");
return;
}
var parsedChannel = Context.Guild.GetTextChannel(parsedId);
if (parsedChannel == null)
{
await Context.Channel.SendErrorAsync("Channel Limits", "Please pass in a valid channel!");
return;
}
await _limits.AddLimitAsync(Context.Guild.Id, parsedId);
await _serverHelper.SendLogAsync(Context.Guild, "Situation Log", $"{Context.User.Mention} added {parsedChannel.Mention} to the list of limited channels!");
await Context.Channel.SendSuccessAsync("Channel Limits", $"Successfully limited the bot to {parsedChannel.Mention}.");
}
}
public override ValueTask <TypeParserResult <SocketTextChannel> > ParseAsync(
Parameter param,
string value,
CommandContext context)
{
var ctx = context.Cast <VolteContext>();
SocketTextChannel channel = default;
if (ulong.TryParse(value, out var id) || MentionUtils.TryParseChannel(value, out id))
{
channel = ctx.Client.GetChannel(id).Cast <SocketTextChannel>();
}
if (channel is null)
{
var match = ctx.Guild.TextChannels.Where(x => x.Name.EqualsIgnoreCase(value))
.ToList();
if (match.Count > 1)
{
return(TypeParserResult <SocketTextChannel> .Failed(
"Multiple channels found. Try mentioning the channel or using its ID."));
}
}
return(channel is null
? TypeParserResult <SocketTextChannel> .Failed("Channel not found.")
: TypeParserResult <SocketTextChannel> .Successful(channel));
}
public override async ValueTask <TypeReaderResponse> Read(IMessageContext context, string input)
{
if (context.Guild != null)
{
var results = new Dictionary <ulong, TypeReaderValue>();
var channels = await context.Guild.GetChannelsAsync();
ulong id;
//By Mention (1.0)
if (MentionUtils.TryParseChannel(input, out id))
{
AddResult(results, channels.Where(c => c.Id == id).FirstOrDefault() as T, 1.0f);
}
//By Id (0.9)
if (ulong.TryParse(input, NumberStyles.None, CultureInfo.InvariantCulture, out id))
{
AddResult(results, channels.Where(c => c.Id == id).FirstOrDefault() as T, 0.90f);
}
//By Name (0.7-0.8)
foreach (var channel in channels.Where(x => string.Equals(input, x.Name, StringComparison.OrdinalIgnoreCase)))
{
AddResult(results, channel as T, channel.Name == input ? 0.80f : 0.70f);
}
if (results.Count > 0)
{
return(TypeReaderResponse.FromSuccess(results.Values));
}
}
return(TypeReaderResponse.FromError(TYPEREADER_ENTITY_NOTFOUND, input, typeof(T)));
}
public override async Task <TypeParserResult <TChannel> > ParseAsync(
Parameter param,
string value,
ICommandContext context,
IServiceProvider provider)
{
var ctx = (DepressedBotContext)context;
TChannel channel = null;
if (ulong.TryParse(value, out var id) || MentionUtils.TryParseChannel(value, out id))
{
channel = (await ctx.Guild.GetTextChannelsAsync()).FirstOrDefault(x => x.Id == id) as TChannel;
}
if (channel is null)
{
var match = (await ctx.Guild.GetTextChannelsAsync()).Where(x => x.Name.EqualsIgnoreCase(value))
.ToList();
if (match.Count > 1)
{
return(TypeParserResult <TChannel> .Unsuccessful(
"Multiple channels found. Try mentioning the channel or using its ID."));
}
}
return(channel is null
? TypeParserResult <TChannel> .Unsuccessful("Channel not found.")
: TypeParserResult <TChannel> .Successful(channel));
}
public async Task <DiscordChannel> MatchChannel()
{
if (!MentionUtils.TryParseChannel(PeekArgument(), out var channel))
{
return(null);
}
try
{
var discordChannel = await _shard.GetChannelAsync(channel);
if (discordChannel.Type != ChannelType.Text)
{
return(null);
}
PopArgument();
return(discordChannel);
}
catch (NotFoundException)
{
return(null);
}
catch (UnauthorizedException)
{
return(null);
}
}
public override ValueTask <TypeParserResult <ITextChannel> > ParseAsync(Parameter param, string value, ScrapContext context)
{
var channels = context.Guild.Channels.OfType <ITextChannel>().ToList();
ITextChannel channel = null;
if (ulong.TryParse(value, out ulong id) || MentionUtils.TryParseChannel(value, out id))
{
channel = context.Client.GetChannel(id) as ITextChannel;
}
if (channel is null)
{
var match = channels.Where(x =>
x.Name.EqualsIgnoreCase(value));
if (match.Count() > 1)
{
return(TypeParserResult <ITextChannel> .Unsuccessful(
"Multiple channels found, try mentioning the channel or using its ID."));
}
channel = match.FirstOrDefault();
}
return(channel is null
? TypeParserResult <ITextChannel> .Unsuccessful("User not found.")
: TypeParserResult <ITextChannel> .Successful(channel));
}
public override async Task <TypeReaderResult> ReadAsync(ICommandContext context, string input, IServiceProvider services)
{
if (context.Guild != null)
{
var results = new Dictionary <ulong, TypeReaderValue>();
var channels = await context.Guild.GetChannelsAsync(CacheMode.CacheOnly).ConfigureAwait(false);
ulong id;
//By Mention (1.0)
if (MentionUtils.TryParseChannel(input, out id))
{
AddResult(results, await context.Guild.GetChannelAsync(id, CacheMode.CacheOnly).ConfigureAwait(false) as T, 1.00f);
}
//By Id (0.9)
if (ulong.TryParse(input, NumberStyles.None, CultureInfo.InvariantCulture, out id))
{
AddResult(results, await context.Guild.GetChannelAsync(id, CacheMode.CacheOnly).ConfigureAwait(false) as T, 0.90f);
}
//By Name (0.7-0.8)
foreach (var channel in channels.Where(x => string.Equals(input, x.Name, StringComparison.OrdinalIgnoreCase)))
{
AddResult(results, channel as T, channel.Name == input ? 0.80f : 0.70f);
}
if (results.Count > 0)
{
return(TypeReaderResult.FromSuccess(results.Values.ToReadOnlyCollection()));
}
}
return(TypeReaderResult.FromError(CommandError.ObjectNotFound, "Channel not found."));
}
public override Task <TypeParserResult <TChannel> > ParseAsync(Parameter parameter, string value, ICommandContext ctx, IServiceProvider provider)
{
var context = (AdminCommandContext)ctx;
if (context.IsPrivate)
{
return(Task.FromResult(TypeParserResult <TChannel> .Unsuccessful("requirecontext_guild")));
}
TChannel channel = null;
IEnumerable <TChannel> channels;
if (typeof(SocketVoiceChannel).IsAssignableFrom(typeof(TChannel)))
{
channels = context.Guild.VoiceChannels.OfType <TChannel>().ToList();
}
else if (typeof(SocketCategoryChannel).IsAssignableFrom(typeof(TChannel)))
{
channels = context.Guild.CategoryChannels.OfType <TChannel>().ToList();
}
else if (typeof(SocketTextChannel).IsAssignableFrom(typeof(TChannel)))
{
channels = context.Guild.TextChannels.OfType <TChannel>().ToList();
}
else
{
channels = context.Guild.Channels.OfType <TChannel>().ToList();
}
// Parse by channel ID (or text channel mention)
if (ulong.TryParse(value, out var id) || MentionUtils.TryParseChannel(value, out id))
{
channel = channels.FirstOrDefault(x => x.Id == id);
}
// Parse by channel name
if (channel is null)
{
var matchingChannels = channels
.Where(x => x.Name.Equals(value, StringComparison.OrdinalIgnoreCase))
.ToList();
if (matchingChannels.Count > 1)
{
return(Task.FromResult(
TypeParserResult <TChannel> .Unsuccessful(context.Localize("channelparser_multiple"))));
}
channel = matchingChannels.FirstOrDefault();
}
return(Task.FromResult(!(channel is null)
? TypeParserResult <TChannel> .Successful(channel)
: TypeParserResult <TChannel> .Unsuccessful(context.Localize("channelparser_notfound"))));
}
public async Task DelLimit(string value = null)
{
await Context.Channel.TriggerTypingAsync();
var limits = await _limits.GetLimitsAsync(Context.Guild.Id);
var hasLimit = await _servers.GetHasLimitAsync(Context.Guild.Id);
try
{
if (hasLimit == true)
{
await ReplyAsync("You can't delete limit channel while limit mode is active!");
return;
}
if (value != null)
{
if (!MentionUtils.TryParseChannel(value, out ulong parsedId))
{
await Context.Channel.SendErrorAsync("Channel Limits", "Please pass in a valid channel!");
return;
}
var parsedChannel = Context.Guild.GetTextChannel(parsedId);
if (parsedChannel == null)
{
await Context.Channel.SendErrorAsync("Channel Limits", "Please pass in a valid channel!");
return;
}
if (limits.All(x => x.ChannelId != parsedChannel.Id))
{
await Context.Channel.TriggerTypingAsync();
await Context.Channel.SendErrorAsync("Channel Limits", "That channel is not a limited channel!");
return;
}
await _limits.RemoveLimitAsync(Context.Guild.Id, parsedId);
await _serverHelper.SendLogAsync(Context.Guild, "Situation Log", $"{Context.User.Mention} removed {parsedChannel.Mention} from the limited channel list!");
await Context.Channel.SendSuccessAsync("Channel Limits", $"Successfully removed {parsedChannel.Mention} from the limited channels.");
}
}
catch (Exception e)
{
await Context.Channel.SendErrorAsync("Error", $"Something went wrong: ```{e.ToString()}```");
}
}
public static async Task <DiscordChannel> MatchChannel(this Context ctx)
{
if (!MentionUtils.TryParseChannel(ctx.PeekArgument(), out var id))
{
return(null);
}
var channel = await ctx.Shard.GetChannel(id);
if (channel == null || channel.Type != ChannelType.Text)
{
return(null);
}
ctx.PopArgument();
return(channel);
}
public async Task AutoClear(string channelName)
{
guild = Context.Guild;
guildName = guild.Name;
ulong channelID;
if (MentionUtils.TryParseChannel(channelName, out channelID))
{
SocketTextChannel channel = guild.GetTextChannel(channelID);
await ToggleChannel(channel);
}
else
{
await ReplyAsync(string.Format(ResponseManager.GetLine("ClearedChannelsNotExist"), guildName, channelName));
}
}
public static IEnumerable <SocketUser> ParseUsers(DiscordSocketClient discord, string text, SocketGuild guild)
{
if (guild != null)
{
ulong roleId;
if (MentionUtils.TryParseRole(text, out roleId))
{
return(guild.Users.Where(u => u.Roles.Any(r => r.Id == roleId)));
}
}
ulong channelId;
if (MentionUtils.TryParseChannel(text, out channelId))
{
return(discord.GetChannel(channelId).Users);
}
var user = ParseUser(discord, text);
return(user != null ? new[] { user } : null);
}
public static async Task <Channel> MatchChannel(this Context ctx)
{
if (!MentionUtils.TryParseChannel(ctx.PeekArgument(), out var id))
{
return(null);
}
if (!ctx.Cache.TryGetChannel(id, out var channel))
{
return(null);
}
if (!(channel.Type == Channel.ChannelType.GuildText || channel.Type == Channel.ChannelType.GuildText))
{
return(null);
}
ctx.PopArgument();
return(channel);
}
public static Task <Channel> MatchChannel(this Context ctx)
{
if (!MentionUtils.TryParseChannel(ctx.PeekArgument(), out var id))
{
return(Task.FromResult <Channel>(null));
}
if (!ctx.Cache.TryGetChannel(id, out var channel))
{
return(Task.FromResult <Channel>(null));
}
if (!DiscordUtils.IsValidGuildChannel(channel))
{
return(Task.FromResult <Channel>(null));
}
ctx.PopArgument();
return(Task.FromResult(channel));
}
public override ValueTask <TypeParserResult <SocketTextChannel> > ParseAsync(Parameter parameter, string value,
SocketCommandContext context, IServiceProvider provider)
{
if (MentionUtils.TryParseChannel(value, out var id))
{
return(context.Guild.GetChannel(id) is SocketTextChannel txCh
? TypeParserResult <SocketTextChannel> .Successful(txCh)
: TypeParserResult <SocketTextChannel> .Unsuccessful("Couldn't parse text channel"));
}
if (ulong.TryParse(value, NumberStyles.None, CultureInfo.InvariantCulture, out id))
{
return(context.Guild.GetTextChannel(id) is SocketTextChannel txCh
? TypeParserResult <SocketTextChannel> .Successful(txCh)
: TypeParserResult <SocketTextChannel> .Unsuccessful("Couldn't parse text channel"));
}
return(context.Guild.TextChannels.FirstOrDefault(x => x.Name == value) is SocketTextChannel txChCheck
? TypeParserResult <SocketTextChannel> .Successful(txChCheck)
: TypeParserResult <SocketTextChannel> .Unsuccessful("Couldn't parse text channel"));
}
/// <summary>
/// Tries to parses a given string as a channel.
/// </summary>
/// <remarks>
/// See flow chart by Still#2876:
/// https://cdn.discordapp.com/attachments/381889909113225237/409209957683036160/ChannelTypeReader.png
/// </remarks>
/// <param name="guild">The guild in which to search for the channel.</param>
/// <param name="input">A string representing a channel by mention, id, or name.</param>
/// <returns>The results of the parse.</returns>
public static async Task <TypeReaderResult> ReadAsync(IGuild guild, string input)
{
if (guild != null)
{
var results = new Dictionary <ulong, TypeReaderValue>();
var channels = await guild.GetChannelsAsync(CacheMode.CacheOnly).ConfigureAwait(false);
ulong id;
// By Mention (1.0)
if (MentionUtils.TryParseChannel(input, out id))
{
AddResult(results, await guild.GetChannelAsync(id, CacheMode.CacheOnly).ConfigureAwait(false) as T,
1.00f);
}
// By Id (0.9)
if (ulong.TryParse(input, NumberStyles.None, CultureInfo.InvariantCulture, out id))
{
AddResult(results, await guild.GetChannelAsync(id, CacheMode.CacheOnly).ConfigureAwait(false) as T,
0.90f);
}
// By Name (0.7-0.8)
// Acounts for name being null because GetChannelsAsync returns categories in 1.0.
foreach (var channel in channels.Where(c =>
c.Name?.Equals(input, StringComparison.OrdinalIgnoreCase) ?? false))
{
AddResult(results, channel as T, channel.Name == input ? 0.80f : 0.70f);
}
if (results.Count > 0)
{
return(TypeReaderResult.FromSuccess(results.Values));
}
}
return(TypeReaderResult.FromError(CommandError.ObjectNotFound, "Channel not found."));
}
public async Task Welcome(string option = null, string value = null)
{
await Context.Channel.TriggerTypingAsync();
if (option == null && value == null)
{
var fetchedChannelId = await _servers.GetWelcomeAsync(Context.Guild.Id);
if (fetchedChannelId == 0)
{
await Context.Channel.SendErrorAsync("Welcome module", "There has not been set a welcome channel yet!");
return;
}
var fetchedChannel = Context.Guild.GetTextChannel(fetchedChannelId);
if (fetchedChannel == null)
{
await Context.Channel.SendErrorAsync("Welcome module", "There has not been set a welcome channel yet!");
await _servers.ClearWelcomeAsync(Context.Guild.Id);
return;
}
var fetchedBackground = await _servers.GetBackgroundAsync(Context.Guild.Id);
if (fetchedBackground != null)
{
await Context.Channel.SendSuccessAsync("Welcome module", $"The channel used for the welcome module is {fetchedChannel.Mention}.\nThe background is set to {fetchedBackground}.");
}
else
{
await Context.Channel.SendSuccessAsync("Welcome module", $"The channel used for the welcome module is {fetchedChannel.Mention}.");
}
return;
}
if (option == "channel" && value != null)
{
if (!MentionUtils.TryParseChannel(value, out ulong parsedId))
{
await Context.Channel.SendErrorAsync("Welcome module", "Please pass in a valid channel!");
return;
}
var parsedChannel = Context.Guild.GetTextChannel(parsedId);
if (parsedChannel == null)
{
await Context.Channel.SendErrorAsync("Welcome module", "Please pass in a valid channel!");
return;
}
await _servers.ModifyWelcomeAsync(Context.Guild.Id, parsedId);
await Context.Channel.SendSuccessAsync("Welcome module", $"Successfully modified the welcome channel to {parsedChannel.Mention}.");
await _serverHelper.SendLogAsync(Context.Guild, "Situation Log", $"{Context.User.Mention} modified the welcome channel to {parsedChannel.Mention}!");
return;
}
if (option == "background" && value != null)
{
if (value == "clear")
{
await _servers.ClearBackgroundAsync(Context.Guild.Id);
await Context.Channel.SendSuccessAsync("Welcome module", "Successfully cleared the background for this server.");
await _serverHelper.SendLogAsync(Context.Guild, "Situation Log", $"{Context.User.Mention} cleared the welcome channel!");
return;
}
await _servers.ModifyBackgroundAsync(Context.Guild.Id, value);
await Context.Channel.SendSuccessAsync("Welcome module", $"Successfully modified the background to {value}.");
return;
}
if (option == "clear" && value == null)
{
await _servers.ClearWelcomeAsync(Context.Guild.Id);
await Context.Channel.SendSuccessAsync("Welcome module", "Successfully cleared the welcome channel.");
return;
}
await Context.Channel.SendErrorAsync("Welcome module", "You did not use this command properly!");
}
public static ImmutableArray <ITag> ParseTags(string text, IMessageChannel channel, IGuild guild, IReadOnlyCollection <IUser> userMentions)
{
var tags = ImmutableArray.CreateBuilder <ITag>();
int index = 0;
var codeIndex = 0;
// checks if the tag being parsed is wrapped in code blocks
bool CheckWrappedCode()
{
// util to check if the index of a tag is within the bounds of the codeblock
bool EnclosedInBlock(Match m)
=> m.Groups[1].Index < index && index < m.Groups[2].Index;
// loop through all code blocks that are before the start of the tag
while (codeIndex < index)
{
var blockMatch = BlockCodeRegex.Match(text, codeIndex);
if (blockMatch.Success)
{
if (EnclosedInBlock(blockMatch))
{
return(true);
}
// continue if the end of the current code was before the start of the tag
codeIndex += blockMatch.Groups[2].Index + blockMatch.Groups[2].Length;
if (codeIndex < index)
{
continue;
}
return(false);
}
var inlineMatch = InlineCodeRegex.Match(text, codeIndex);
if (inlineMatch.Success)
{
if (EnclosedInBlock(inlineMatch))
{
return(true);
}
// continue if the end of the current code was before the start of the tag
codeIndex += inlineMatch.Groups[2].Index + inlineMatch.Groups[2].Length;
if (codeIndex < index)
{
continue;
}
return(false);
}
return(false);
}
return(false);
}
while (true)
{
index = text.IndexOf('<', index);
if (index == -1)
{
break;
}
int endIndex = text.IndexOf('>', index + 1);
if (endIndex == -1)
{
break;
}
if (CheckWrappedCode())
{
break;
}
string content = text.Substring(index, endIndex - index + 1);
if (MentionUtils.TryParseUser(content, out ulong id))
{
IUser mentionedUser = null;
foreach (var mention in userMentions)
{
if (mention.Id == id)
{
mentionedUser = channel?.GetUserAsync(id, CacheMode.CacheOnly).GetAwaiter().GetResult();
if (mentionedUser == null)
{
mentionedUser = mention;
}
break;
}
}
tags.Add(new Tag <IUser>(TagType.UserMention, index, content.Length, id, mentionedUser));
}
else if (MentionUtils.TryParseChannel(content, out id))
{
IChannel mentionedChannel = null;
if (guild != null)
{
mentionedChannel = guild.GetChannelAsync(id, CacheMode.CacheOnly).GetAwaiter().GetResult();
}
tags.Add(new Tag <IChannel>(TagType.ChannelMention, index, content.Length, id, mentionedChannel));
}
else if (MentionUtils.TryParseRole(content, out id))
{
IRole mentionedRole = null;
if (guild != null)
{
mentionedRole = guild.GetRole(id);
}
tags.Add(new Tag <IRole>(TagType.RoleMention, index, content.Length, id, mentionedRole));
}
else if (Emote.TryParse(content, out var emoji))
{
tags.Add(new Tag <Emote>(TagType.Emoji, index, content.Length, emoji.Id, emoji));
}
else //Bad Tag
{
index++;
continue;
}
index = endIndex + 1;
}
index = 0;
codeIndex = 0;
while (true)
{
index = text.IndexOf("@everyone", index);
if (index == -1)
{
break;
}
if (CheckWrappedCode())
{
break;
}
var tagIndex = FindIndex(tags, index);
if (tagIndex.HasValue)
{
tags.Insert(tagIndex.Value, new Tag <IRole>(TagType.EveryoneMention, index, "@everyone".Length, 0, guild?.EveryoneRole));
}
index++;
}
index = 0;
codeIndex = 0;
while (true)
{
index = text.IndexOf("@here", index);
if (index == -1)
{
break;
}
if (CheckWrappedCode())
{
break;
}
var tagIndex = FindIndex(tags, index);
if (tagIndex.HasValue)
{
tags.Insert(tagIndex.Value, new Tag <IRole>(TagType.HereMention, index, "@here".Length, 0, guild?.EveryoneRole));
}
index++;
}
return(tags.ToImmutable());
}
public async Task Logs(string value = null)
{
if (value == null)
{
var fetchedChannelId = await _servers.GetLogsAsync(Context.Guild.Id);
if (fetchedChannelId == 0)
{
await Context.Channel.SendErrorAsync("Error", "There has not been set a logs channel yet!");
return;
}
var fetchedChannel = Context.Guild.GetTextChannel(fetchedChannelId);
if (fetchedChannel == null)
{
await Context.Channel.SendErrorAsync("Error", "There has not been set a logs channel yet!");
await _servers.ClearLogsAsync(Context.Guild.Id);
return;
}
await ReplyAsync($"The channel used for the logs is set to {fetchedChannel.Mention}.");
return;
}
if (value != "clear")
{
if (!MentionUtils.TryParseChannel(value, out var parsedId))
{
await Context.Channel.SendErrorAsync("Error", "Please pass in a valid channel!");
return;
}
var parsedChannel = Context.Guild.GetTextChannel(parsedId);
if (parsedChannel == null)
{
await ReplyAsync("Please pass in a valid channel!");
return;
}
await _servers.ModifyLogsAsync(Context.Guild.Id, parsedId);
await Context.Channel.SendSuccessAsync("Success",
$"Successfully modified the logs channel to {parsedChannel.Mention}.");
return;
}
if (value == "clear")
{
await _servers.ClearLogsAsync(Context.Guild.Id);
await Context.Channel.SendSuccessAsync("Success", "Successfully cleared the logs channel.");
return;
}
await Context.Channel.SendErrorAsync("Error", "You did not use this command properly.");
}
