Merge pull request #65 from InfinityGhost/command-improvements

InfinityGhost · web-flow · commit 862c89b6d5ed · 2022-04-11T18:04:30.000-04:00
Command improvements
diff --git a/TabletBot.Common/Attributes/Bot/CommandAttribute.cs b/TabletBot.Common/Attributes/Bot/CommandAttribute.cs
@@ -4,7 +4,7 @@
 namespace TabletBot.Common.Attributes.Bot
 {
     [AttributeUsage(AttributeTargets.Method)]
-    [MeansImplicitUse(ImplicitUseTargetFlags.Members)]
+    [MeansImplicitUse(ImplicitUseTargetFlags.Itself)]
     public class CommandAttribute : Attribute
     {
         public CommandAttribute(params string[] arguments)
diff --git a/TabletBot.Common/Log.cs b/TabletBot.Common/Log.cs
@@ -12,8 +12,6 @@ public static void Write(string group, string text, LogLevel level = LogLevel.In
             Output?.Invoke(new LogMessage(group, text, level));
         }
 
-        public static async Task WriteAsync(string group, string text, LogLevel level = LogLevel.Info) => await Task.Run(() => Write(group, text, level));
-
         public static void Debug(string group, string text)
         {
             Write(group, text, LogLevel.Debug);
diff --git a/TabletBot.Common/Settings.cs b/TabletBot.Common/Settings.cs
@@ -39,10 +39,10 @@ public sealed class Settings
 
         public async Task Write(FileInfo file)
         {
-            if (!file.Directory.Exists)
+            if (file.Directory is { Exists: false })
                 file.Directory.Create();
             await using (var fs = file.Create())
-                await JsonSerializer.SerializeAsync<Settings>(fs, this, SerializerOptions);
+                await JsonSerializer.SerializeAsync(fs, this, SerializerOptions);
         }
 
         public static async Task<Settings> Read(FileInfo file)
@@ -55,7 +55,7 @@ public async Task<string> ExportAsync()
         {
             await using (var ms = new MemoryStream())
             {
-                await JsonSerializer.SerializeAsync<Settings>(ms, this, SerializerOptions);
+                await JsonSerializer.SerializeAsync(ms, this, SerializerOptions);
                 ms.Position = 0;
                 using (var sr = new StreamReader(ms))
                     return await sr.ReadToEndAsync();
diff --git a/TabletBot.Discord/Commands/ModerationCommands.cs b/TabletBot.Discord/Commands/ModerationCommands.cs
@@ -35,7 +35,7 @@ public async Task ForceSaveSettings()
         {
             await _settings.Write(Platform.SettingsFile);
             await ReplyAsync("Settings force saved.", allowedMentions: AllowedMentions.None);
-            await Log.WriteAsync("Settings", $"{Context.Message.Author.Username} force-saved the configuration to {Platform.SettingsFile.FullName}");
+            Log.Write("Settings", $"{Context.Message.Author.Username} force-saved the configuration to {Platform.SettingsFile.FullName}");
         }
 
         [Command("kill-bot", RunMode = RunMode.Async), Name("Kill Bot"), RequireOwner]
diff --git a/TabletBot.Discord/Formatting.cs b/TabletBot.Discord/Formatting.cs
@@ -1,3 +1,5 @@
+using Discord;
+
 namespace TabletBot.Discord
 {
     public static class Formatting
@@ -8,5 +10,7 @@ public static class Formatting
         public const string CODE_AFFIX = "`";
         public const string QUOTE_PREFIX = "> ";
         public const string CODE_BLOCK = "```";
+
+        public static string UrlString(IAttachment attachment) => $"[{attachment.Filename}]({attachment.Url})";
     }
 }
diff --git a/TabletBot.Discord/LogExtensions.cs b/TabletBot.Discord/LogExtensions.cs
@@ -7,25 +7,29 @@ namespace TabletBot.Discord
 {
     public static class LogExtensions
     {
-        public static async Task WriteAsync(IMessage message)
+        public static Task WriteAsync(IMessage message)
         {
-            await Log.WriteAsync("Message", string.Format(
+            Log.Write("Message", string.Format(
                 "#{1}/{2}#{3}: {0}",
                 message.CleanContent,
                 message.Channel.Name,
                 message.Author.Username,
                 message.Author.Discriminator
             ));
+
+            return Task.CompletedTask;
         }
 
-        public static async Task WriteAsync(LogMessage message)
+        public static Task WriteAsync(LogMessage message)
         {
-            await Log.WriteAsync("Client", string.Format(
+            Log.Write("Client", string.Format(
                 "{1} [{2}]: {0}",
                 message.Message,
                 message.Source,
                 message.Severity
             ));
+
+            return Task.CompletedTask;
         }
     }
 }
diff --git a/TabletBot.Discord/Watchers/Commands/CommandMessageWatcher.cs b/TabletBot.Discord/Watchers/Commands/CommandMessageWatcher.cs
@@ -35,7 +35,7 @@ IEnumerable<Type> commands
 
         public async Task Receive(IMessage message)
         {
-            if (message.Content.StartsWith(_settings.CommandPrefix) && !message.Author.IsBot)
+            if (message.Channel is IGuildChannel && !message.Author.IsBot && message.Content.StartsWith(_settings.CommandPrefix))
             {
                 try
                 {
@@ -70,7 +70,7 @@ public async Task InitializeAsync()
             foreach (var module in _commands)
             {
                 await _commandService.AddModuleAsync(module, _serviceProvider);
-                await Log.WriteAsync("CommandSvc", $"Registered command module '{module.Name}'.", LogLevel.Debug);
+                Log.Write("CommandSvc", $"Registered command module '{module.Name}'.", LogLevel.Debug);
             }
 
             _commandService.CommandExecuted += CommandExecuted;
diff --git a/TabletBot.Discord/Watchers/Commands/SlashCommandInteractionWatcher.cs b/TabletBot.Discord/Watchers/Commands/SlashCommandInteractionWatcher.cs
@@ -64,25 +64,24 @@ public async Task InitializeAsync()
             if (_registered)
                 return;
 
-            await Task.WhenAll(_commands.Select(RegisterCommand));
+            await Task.WhenAll(_commands.Select(RegisterCommandModule));
             _registered = true;
         }
 
-        private async Task RegisterCommand(SlashCommandModule module)
+        private async Task RegisterCommandModule(SlashCommandModule module)
         {
-            module.BuildCommandHandlers();
-
             var moderatorCommands = new List<RestGuildCommand>();
-            foreach (var command in module.CommandHandlers)
+            foreach (var command in module.BuildCommandHandlers())
             {
                 var guildCommand = await _client.Rest.CreateGuildCommand(command.Build(), _settings.GuildID);
                 if (guildCommand.IsDefaultPermission == false)
                     moderatorCommands.Add(guildCommand);
             }
 
             await ApplyCommandPermissions(_client, moderatorCommands);
-
             module.Update += UpdateModule;
+
+            Log.Write("Setup", $"Registered slash command module '{module.GetType().Name}'.");
         }
 
         private async Task ApplyCommandPermissions(DiscordSocketClient client, IEnumerable<RestGuildCommand> moderatorCommands)
diff --git a/TabletBot.Discord/Watchers/DirectMessage/ModMailMessageWatcher.cs b/TabletBot.Discord/Watchers/DirectMessage/ModMailMessageWatcher.cs
@@ -1,3 +1,5 @@
+using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using Discord;
@@ -18,28 +20,62 @@ public ModMailMessageWatcher(DiscordSocketClient client, Settings settings)
             _settings = settings;
         }
 
-        private IMessageChannel? _directMessageLogChannel;
+        private ITextChannel? _directMessageLogChannel;
 
         public async Task Receive(IMessage message)
         {
             if (message.Channel is IDMChannel dmChannel)
             {
-                if (_directMessageLogChannel == null)
+                await DirectMessage(message, dmChannel);
+            }
+        }
+
+        private async Task DirectMessage(IMessage message, IDMChannel dmChannel)
+        {
+            var embed = new EmbedBuilder
+            {
+                Description = message.Content,
+                Timestamp = message.Timestamp,
+                Author = dmChannel.Recipient.ToEmbedAuthor(),
+                Color = Color.Blue,
+                Fields = GetFieldForAttachments(message),
+                Footer = new EmbedFooterBuilder
                 {
-                    var channel = await _client.Rest.GetChannelAsync(_settings.ModMailChannelID);
-                    _directMessageLogChannel = (IMessageChannel) channel;
+                    Text = dmChannel.Id.ToString()
                 }
+            };
 
-                var embed = new EmbedBuilder
-                {
-                    Description = message.Content,
-                    Timestamp = message.Timestamp,
-                    Author = dmChannel.Recipient.ToEmbedAuthor(),
-                    Color = Color.Blue
-                };
+            var existingEmbeds = message.Embeds.Any() ? message.Embeds : Array.Empty<IEmbed>();
 
-                await _directMessageLogChannel.SendMessageAsync(embed: embed.Build());
-            }
+            var embeds = from emb in existingEmbeds.Prepend(embed.Build())
+                where emb is Embed
+                select emb as Embed;
+
+            var channel = await GetModMailChannel();
+            await channel.SendMessageAsync(embeds: embeds.ToArray());
+        }
+
+        private async Task<ITextChannel> GetModMailChannel()
+        {
+            if (_directMessageLogChannel != null)
+                return _directMessageLogChannel;
+
+            var channel = await _client.Rest.GetChannelAsync(_settings.ModMailChannelID);
+            return _directMessageLogChannel = (ITextChannel) channel;
+        }
+
+        private static List<EmbedFieldBuilder> GetFieldForAttachments(IMessage message)
+        {
+            return message.Attachments.Select(GetFieldForAttachment).ToList();
+        }
+
+        private static EmbedFieldBuilder GetFieldForAttachment(IAttachment attachment)
+        {
+            return new EmbedFieldBuilder
+            {
+                Name = attachment.Filename,
+                Value = Formatting.UrlString(attachment)
+            };
         }
 
         public Task Deleted(Cacheable<IMessage, ulong> message, Cacheable<IMessageChannel, ulong> channel) => Task.CompletedTask;
diff --git a/TabletBot.Discord/Watchers/GitHub/IssueMessageWatcher.cs b/TabletBot.Discord/Watchers/GitHub/IssueMessageWatcher.cs
@@ -1,4 +1,3 @@
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text.RegularExpressions;
@@ -7,6 +6,7 @@
 using Octokit;
 using TabletBot.Common;
 using TabletBot.Discord.Embeds;
+using TabletBot.Discord.Commands;
 
 #nullable enable
 
@@ -26,49 +26,55 @@ public IssueMessageWatcher(Settings settings, GitHubClient gitHubClient)
         private const string OWNER = "OpenTabletDriver";
         private const string NAME = "OpenTabletDriver";
 
+        private static readonly Regex IssueRefRegex = new Regex(@" ?#([0-9]+[0-9]) ?");
+
         public async Task Receive(IMessage message)
         {
-            if (message.Author.IsBot)
+            if (message.Author.IsBot || message is not IUserMessage userMessage)
                 return;
 
-            if (TryGetIssueRefNumbers(message.Content, out var refs))
+            var rateLimits = await _gitHubClient.Miscellaneous.GetRateLimits();
+            if (rateLimits.Rate.Remaining < 2)
+                return;
+
+            if (GetIssueRefNumbers(userMessage.Content) is IList<uint> refs)
             {
-                uint refNum = 0;
-                foreach (int issueRef in refs)
+                using (userMessage.Channel.EnterTypingState())
                 {
-                    if (refNum == _settings.GitHubIssueRefLimit)
-                        break;
-
-                    var issues = await _gitHubClient.Issue.GetAllForRepository(OWNER, NAME);
-                    var prs = await _gitHubClient.PullRequest.GetAllForRepository(OWNER, NAME);
-                    if (issues.FirstOrDefault(i => i.Number == issueRef) is Issue issue)
-                    {
-                        var pr = prs.FirstOrDefault(pr => pr.Number == issue.Number);
-                        var embed = pr == null ? GitHubEmbeds.GetIssueEmbed(issue) : GitHubEmbeds.GetPullRequestEmbed(pr);
-                        await message.Channel.SendMessageAsync(embed: embed);
-                    }
-                    refNum++;
+                    await ReplyWithEmbeds(userMessage, refs);
                 }
             }
         }
 
         public Task Deleted(Cacheable<IMessage, ulong> message, Cacheable<IMessageChannel, ulong> channel) => Task.CompletedTask;
 
-        public static bool TryGetIssueRefNumbers(string message, out IEnumerable<int> refNums)
+        private async Task ReplyWithEmbeds(IUserMessage message, IList<uint> refs)
         {
-            refNums = Array.Empty<int>();
+            var issues = await _gitHubClient.Issue.GetAllForRepository(OWNER, NAME);
+            var prs = await _gitHubClient.PullRequest.GetAllForRepository(OWNER, NAME);
+            var embeds = GetEmbedsForRefs(issues, prs, refs).ToArray();
 
-            var matches = IssueRefRegex.Matches(message);
-            if (matches.Count > 0)
+            await message.Channel.SendMessageAsync(embeds: embeds, messageReference: message.ToReference());
+        }
+
+        private IEnumerable<Embed> GetEmbedsForRefs(IReadOnlyList<Issue> issues, IReadOnlyList<PullRequest> prs, IList<uint> refs)
+        {
+            for (var i = 0; i < refs.Count && i < _settings.GitHubIssueRefLimit; i++)
             {
-                refNums = from match in matches
-                    select int.Parse(match.Groups[1].Value);
-                return true;
-            }
+                var issueRef = refs[i];
 
-            return false;
+                if (issues.FirstOrDefault(s => s.Number == issueRef) is Issue issue)
+                {
+                    var pr = prs.FirstOrDefault(pr => pr.Number == issue.Number);
+                    yield return pr == null ? GitHubEmbeds.GetIssueEmbed(issue) : GitHubEmbeds.GetPullRequestEmbed(pr);
+                }
+            }
         }
 
-        private static readonly Regex IssueRefRegex = new Regex(@" ?#([0-9]+[0-9]) ?");
+        private static IEnumerable<uint>? GetIssueRefNumbers(string message)
+        {
+            var matches = IssueRefRegex.Matches(message);
+            return matches.Any() ? matches.Select(m => uint.Parse(m.Groups[1].Value)).ToList() : null;
+        }
     }
 }
diff --git a/TabletBot/Program.Commands.cs b/TabletBot/Program.Commands.cs
@@ -81,7 +81,7 @@ public static void ModifySetting(params string[] args)
         public static async void SaveSettings(params string[] args)
         {
             await Settings!.Write(Platform.SettingsFile);
-            await Log.WriteAsync("Settings", $"Saved to '{Platform.SettingsFile.FullName}'.");
+            Log.Write("Settings", $"Saved to '{Platform.SettingsFile.FullName}'.");
         }
     }
 }
diff --git a/TabletBot/Program.cs b/TabletBot/Program.cs
@@ -56,7 +56,7 @@ private static async Task Main(string[] args)
 
             var config = new DiscordSocketConfig();
             DiscordClient = new DiscordSocketClient(config);
-            var gitHubClient = await AuthenticateGitHub(githubToken);
+            var gitHubClient = AuthenticateGitHub(githubToken);
 
             var serviceCollection = BotServiceCollection.Build(Settings, DiscordClient, gitHubClient!);
             var serviceProvider = serviceCollection.BuildServiceProvider();
@@ -73,27 +73,27 @@ private static async Task Main(string[] args)
                 else
                 {
                     var commandArgs = IO.ReadLine().Split(' ');
-                    await InvokeCommand(commandArgs);
+                    InvokeCommand(commandArgs);
                 }
             }
             await Bot.Logout();
             Console.WriteLine();
         }
 
-        private static async Task InvokeCommand(string[] args)
+        private static void InvokeCommand(string[] args)
         {
             try
             {
                 if (!CommandCollection.Current.Invoke(args))
-                    await Log.WriteAsync("Terminal", $"Invalid command: '{args[0]}'. Execute help for a list of commands.");
+                    Log.Write("Terminal", $"Invalid command: '{args[0]}'. Execute help for a list of commands.");
             }
             catch (Exception ex)
             {
                 Log.Exception(ex);
             }
         }
 
-        private static async Task<GitHubClient?> AuthenticateGitHub(string token)
+        private static GitHubClient? AuthenticateGitHub(string token)
         {
             if (!string.IsNullOrWhiteSpace(token))
             {
@@ -105,7 +105,7 @@ private static async Task InvokeCommand(string[] args)
                         Credentials = new Credentials(token)
                     };
 
-                    await Log.WriteAsync("GitHub", "Authenticated client.");
+                    Log.Write("GitHub", "Authenticated client.");
                     return githubClient;
                 }
                 catch (Exception ex)
@@ -115,7 +115,7 @@ private static async Task InvokeCommand(string[] args)
             }
             else
             {
-                await Log.WriteAsync("GitHub", "API was not authenticated.", LogLevel.Warning);
+                Log.Write("GitHub", "API was not authenticated.", LogLevel.Warning);
             }
 
             return null;

Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@`
`4`	`4`	`namespace TabletBot.Common.Attributes.Bot`
`5`	`5`	`{`
`6`	`6`	`[AttributeUsage(AttributeTargets.Method)]`
`7`		`- [MeansImplicitUse(ImplicitUseTargetFlags.Members)]`
	`7`	`+ [MeansImplicitUse(ImplicitUseTargetFlags.Itself)]`
`8`	`8`	`public class CommandAttribute : Attribute`
`9`	`9`	`{`
`10`	`10`	`public CommandAttribute(params string[] arguments)`
Original file line number	Diff line number	Diff line change
`@@ -12,8 +12,6 @@ public static void Write(string group, string text, LogLevel level = LogLevel.In`
`12`	`12`	`Output?.Invoke(new LogMessage(group, text, level));`
`13`	`13`	`}`
`14`	`14`
`15`		`- public static async Task WriteAsync(string group, string text, LogLevel level = LogLevel.Info) => await Task.Run(() => Write(group, text, level));`
`16`		`-`
`17`	`15`	`public static void Debug(string group, string text)`
`18`	`16`	`{`
`19`	`17`	`Write(group, text, LogLevel.Debug);`
Original file line number	Diff line number	Diff line change
`@@ -39,10 +39,10 @@ public sealed class Settings`
`39`	`39`
`40`	`40`	`public async Task Write(FileInfo file)`
`41`	`41`	`{`
`42`		`- if (!file.Directory.Exists)`
	`42`	`+ if (file.Directory is { Exists: false })`
`43`	`43`	`file.Directory.Create();`
`44`	`44`	`await using (var fs = file.Create())`
`45`		`- await JsonSerializer.SerializeAsync<Settings>(fs, this, SerializerOptions);`
	`45`	`+ await JsonSerializer.SerializeAsync(fs, this, SerializerOptions);`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`public static async Task<Settings> Read(FileInfo file)`
`@@ -55,7 +55,7 @@ public async Task<string> ExportAsync()`
`55`	`55`	`{`
`56`	`56`	`await using (var ms = new MemoryStream())`
`57`	`57`	`{`
`58`		`- await JsonSerializer.SerializeAsync<Settings>(ms, this, SerializerOptions);`
	`58`	`+ await JsonSerializer.SerializeAsync(ms, this, SerializerOptions);`
`59`	`59`	`ms.Position = 0;`
`60`	`60`	`using (var sr = new StreamReader(ms))`
`61`	`61`	`return await sr.ReadToEndAsync();`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ public async Task ForceSaveSettings()`
`35`	`35`	`{`
`36`	`36`	`await _settings.Write(Platform.SettingsFile);`
`37`	`37`	`await ReplyAsync("Settings force saved.", allowedMentions: AllowedMentions.None);`
`38`		`- await Log.WriteAsync("Settings", $"{Context.Message.Author.Username} force-saved the configuration to {Platform.SettingsFile.FullName}");`
	`38`	`+ Log.Write("Settings", $"{Context.Message.Author.Username} force-saved the configuration to {Platform.SettingsFile.FullName}");`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`[Command("kill-bot", RunMode = RunMode.Async), Name("Kill Bot"), RequireOwner]`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,5 @@`
	`1`	`+using Discord;`
	`2`	`+`
`1`	`3`	`namespace TabletBot.Discord`
`2`	`4`	`{`
`3`	`5`	`public static class Formatting`
`@@ -8,5 +10,7 @@ public static class Formatting`
`8`	`10`	public const string CODE_AFFIX = "`";
`9`	`11`	`public const string QUOTE_PREFIX = "> ";`
`10`	`12`	public const string CODE_BLOCK = "```";
	`13`	`+`
	`14`	`+ public static string UrlString(IAttachment attachment) => $"[{attachment.Filename}]({attachment.Url})";`
`11`	`15`	`}`
`12`	`16`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,25 +7,29 @@ namespace TabletBot.Discord`
`7`	`7`	`{`
`8`	`8`	`public static class LogExtensions`
`9`	`9`	`{`
`10`		`- public static async Task WriteAsync(IMessage message)`
	`10`	`+ public static Task WriteAsync(IMessage message)`
`11`	`11`	`{`
`12`		`- await Log.WriteAsync("Message", string.Format(`
	`12`	`+ Log.Write("Message", string.Format(`
`13`	`13`	`"#{1}/{2}#{3}: {0}",`
`14`	`14`	`message.CleanContent,`
`15`	`15`	`message.Channel.Name,`
`16`	`16`	`message.Author.Username,`
`17`	`17`	`message.Author.Discriminator`
`18`	`18`	`));`
	`19`	`+`
	`20`	`+ return Task.CompletedTask;`
`19`	`21`	`}`
`20`	`22`
`21`		`- public static async Task WriteAsync(LogMessage message)`
	`23`	`+ public static Task WriteAsync(LogMessage message)`
`22`	`24`	`{`
`23`		`- await Log.WriteAsync("Client", string.Format(`
	`25`	`+ Log.Write("Client", string.Format(`
`24`	`26`	`"{1} [{2}]: {0}",`
`25`	`27`	`message.Message,`
`26`	`28`	`message.Source,`
`27`	`29`	`message.Severity`
`28`	`30`	`));`
	`31`	`+`
	`32`	`+ return Task.CompletedTask;`
`29`	`33`	`}`
`30`	`34`	`}`
`31`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ IEnumerable<Type> commands`
`35`	`35`
`36`	`36`	`public async Task Receive(IMessage message)`
`37`	`37`	`{`
`38`		`- if (message.Content.StartsWith(_settings.CommandPrefix) && !message.Author.IsBot)`
	`38`	`+ if (message.Channel is IGuildChannel && !message.Author.IsBot && message.Content.StartsWith(_settings.CommandPrefix))`
`39`	`39`	`{`
`40`	`40`	`try`
`41`	`41`	`{`
`@@ -70,7 +70,7 @@ public async Task InitializeAsync()`
`70`	`70`	`foreach (var module in _commands)`
`71`	`71`	`{`
`72`	`72`	`await _commandService.AddModuleAsync(module, _serviceProvider);`
`73`		`- await Log.WriteAsync("CommandSvc", $"Registered command module '{module.Name}'.", LogLevel.Debug);`
	`73`	`+ Log.Write("CommandSvc", $"Registered command module '{module.Name}'.", LogLevel.Debug);`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`_commandService.CommandExecuted += CommandExecuted;`
Original file line number	Diff line number	Diff line change
`@@ -64,25 +64,24 @@ public async Task InitializeAsync()`
`64`	`64`	`if (_registered)`
`65`	`65`	`return;`
`66`	`66`
`67`		`- await Task.WhenAll(_commands.Select(RegisterCommand));`
	`67`	`+ await Task.WhenAll(_commands.Select(RegisterCommandModule));`
`68`	`68`	`_registered = true;`
`69`	`69`	`}`
`70`	`70`
`71`		`- private async Task RegisterCommand(SlashCommandModule module)`
	`71`	`+ private async Task RegisterCommandModule(SlashCommandModule module)`
`72`	`72`	`{`
`73`		`- module.BuildCommandHandlers();`
`74`		`-`
`75`	`73`	`var moderatorCommands = new List<RestGuildCommand>();`
`76`		`- foreach (var command in module.CommandHandlers)`
	`74`	`+ foreach (var command in module.BuildCommandHandlers())`
`77`	`75`	`{`
`78`	`76`	`var guildCommand = await _client.Rest.CreateGuildCommand(command.Build(), _settings.GuildID);`
`79`	`77`	`if (guildCommand.IsDefaultPermission == false)`
`80`	`78`	`moderatorCommands.Add(guildCommand);`
`81`	`79`	`}`
`82`	`80`
`83`	`81`	`await ApplyCommandPermissions(_client, moderatorCommands);`
`84`		`-`
`85`	`82`	`module.Update += UpdateModule;`
	`83`	`+`
	`84`	`+ Log.Write("Setup", $"Registered slash command module '{module.GetType().Name}'.");`
`86`	`85`	`}`
`87`	`86`
`88`	`87`	`private async Task ApplyCommandPermissions(DiscordSocketClient client, IEnumerable<RestGuildCommand> moderatorCommands)`