Add Audit Log Data classes for Threads (#301)

* Add ThreadDeleteAuditLogData

* Add ThreadCreateAuditLogData

* Fix ThreadCreateAuditLogData using old instead of new value

* Create ThreadInfo Class

* Fix Thread not being a property

* Add ThreadUpdateAuditLogData

* Cleanup usings

* Add RateLimit to ThreadAuditLogData classese

Co-authored-by: Playwo <eliaswolf2001@t-online.de>

src/Discord.Net.Rest/Entities/AuditLogs/AuditLogHelper.cs

@@ -52,6 +52,9 @@ namespace Discord.Rest
             [ActionType.MessagePinned] = MessagePinAuditLogData.Create,
             [ActionType.MessageUnpinned] = MessageUnpinAuditLogData.Create,
 
+            [ActionType.ThreadCreate] = ThreadCreateAuditLogData.Create,
+            [ActionType.ThreadUpdate] = ThreadUpdateAuditLogData.Create,
+            [ActionType.ThreadDelete] = ThreadDeleteAuditLogData.Create,
         };
 
         public static IAuditLogData CreateData(BaseDiscordClient discord, Model log, EntryModel entry)

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/ThreadCreateAuditLogData.cs

@@ -0,0 +1,115 @@
+using System.Linq;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    /// <summary>
+    ///     Contains a piece of audit log data related to a thread creation.
+    /// </summary>
+    public class ThreadCreateAuditLogData : IAuditLogData
+    {
+        private ThreadCreateAuditLogData(IThreadChannel thread, ulong id, string name, ThreadType type, bool archived,
+            ThreadArchiveDuration autoArchiveDuration, bool locked, int? rateLimit)
+        {
+            Thread = thread;
+            ThreadId = id;
+            ThreadName = name;
+            ThreadType = type;
+            IsArchived = archived;
+            AutoArchiveDuration = autoArchiveDuration;
+            IsLocked = locked;
+            SlowModeInterval = rateLimit;
+        }
+
+        internal static ThreadCreateAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var changes = entry.Changes;
+
+            var id = entry.TargetId.Value;
+
+            var nameModel = entry.Changes.FirstOrDefault(x => x.ChangedProperty == "name");
+            var typeModel = entry.Changes.FirstOrDefault(x => x.ChangedProperty == "type");
+
+            var archivedModel = entry.Changes.FirstOrDefault(x => x.ChangedProperty == "archived");
+            var autoArchiveDurationModel = entry.Changes.FirstOrDefault(x => x.ChangedProperty == "auto_archive_duration");
+            var lockedModel = entry.Changes.FirstOrDefault(x => x.ChangedProperty == "locked");
+            var rateLimitPerUserModel = changes.FirstOrDefault(x => x.ChangedProperty == "rate_limit_per_user");
+
+            var name = nameModel.NewValue.ToObject<string>(discord.ApiClient.Serializer);
+            var type = typeModel.NewValue.ToObject<ThreadType>(discord.ApiClient.Serializer);
+
+            var archived = archivedModel.NewValue.ToObject<bool>(discord.ApiClient.Serializer);
+            var autoArchiveDuration = autoArchiveDurationModel.NewValue.ToObject<ThreadArchiveDuration>(discord.ApiClient.Serializer);
+            var locked = lockedModel.NewValue.ToObject<bool>(discord.ApiClient.Serializer);
+            var rateLimit = rateLimitPerUserModel?.NewValue?.ToObject<int>(discord.ApiClient.Serializer);
+
+            var threadInfo = log.Threads.FirstOrDefault(x => x.Id == id);
+            var threadChannel = threadInfo == null ? null : RestThreadChannel.Create(discord, (IGuild)null, threadInfo);
+
+            return new ThreadCreateAuditLogData(threadChannel, id, name, type, archived, autoArchiveDuration, locked, rateLimit);
+        }
+
+        // Doc Note: Corresponds to the *current* data
+
+        /// <summary>
+        ///     Gets the thread that was created if it still exists.
+        /// </summary>
+        /// <returns>
+        ///     A thread object representing the thread that was created if it still exists, otherwise returns <c>null</c>.
+        /// </returns>
+        public IThreadChannel Thread { get; }
+        /// <summary>
+        ///     Gets the snowflake ID of the thread.
+        /// </summary>
+        /// <returns>
+        ///     A <see cref="ulong"/> representing the snowflake identifier for the thread.
+        /// </returns>
+        public ulong ThreadId { get; }
+        /// <summary>
+        ///     Gets the name of the thread.
+        /// </summary>
+        /// <returns>
+        ///     A string containing the name of the thread.
+        /// </returns>
+        public string ThreadName { get; }
+        /// <summary>
+        ///     Gets the type of the thread.
+        /// </summary>
+        /// <returns>
+        ///     The type of thread.
+        /// </returns>
+        public ThreadType ThreadType { get; }
+        /// <summary>
+        ///     Gets the value that indicates whether the thread is archived.
+        /// </summary>
+        /// <returns>
+        ///     <c>true</c> if this thread has the Archived flag enabled; otherwise <c>false</c>.
+        /// </returns>
+        public bool IsArchived { get; }
+        /// <summary>
+        ///     Gets the auto archive duration of the thread.
+        /// </summary>
+        /// <returns>
+        ///     The thread auto archive duration of the thread.
+        /// </returns>
+        public ThreadArchiveDuration AutoArchiveDuration { get; }
+        /// <summary>
+        ///     Gets the value that indicates whether the thread is locked.
+        /// </summary>
+        /// <returns>
+        ///     <c>true</c> if this thread has the Locked flag enabled; otherwise <c>false</c>.
+        /// </returns>
+        public bool IsLocked { get; }
+        /// <summary>
+        ///     Gets the slow-mode delay of the thread.
+        /// </summary>
+        /// <returns>
+        ///     An <see cref="int"/> representing the time in seconds required before the user can send another
+        ///     message; <c>0</c> if disabled.
+        ///     <c>null</c> if this is not mentioned in this entry.
+        /// </returns>
+        public int? SlowModeInterval { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/ThreadDeleteAuditLogData.cs

@@ -0,0 +1,103 @@
+using System.Linq;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    /// <summary>
+    ///     Contains a piece of audit log data related to a thread deletion.
+    /// </summary>
+    public class ThreadDeleteAuditLogData : IAuditLogData
+    {
+        private ThreadDeleteAuditLogData(ulong id, string name, ThreadType type, bool archived,
+            ThreadArchiveDuration autoArchiveDuration, bool locked, int? rateLimit)
+        {
+            ThreadId = id;
+            ThreadName = name;
+            ThreadType = type;
+            IsArchived = archived;
+            AutoArchiveDuration = autoArchiveDuration;
+            IsLocked = locked;
+            SlowModeInterval = rateLimit;
+        }
+
+        internal static ThreadDeleteAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var changes = entry.Changes;
+
+            var id = entry.TargetId.Value;
+            var thread = log.Threads.FirstOrDefault(x => x.Id == id);
+
+            var nameModel = entry.Changes.FirstOrDefault(x => x.ChangedProperty == "name");
+            var typeModel = entry.Changes.FirstOrDefault(x => x.ChangedProperty == "type");
+
+            var archivedModel = entry.Changes.FirstOrDefault(x => x.ChangedProperty == "archived");
+            var autoArchiveDurationModel = entry.Changes.FirstOrDefault(x => x.ChangedProperty == "auto_archive_duration");
+            var lockedModel = entry.Changes.FirstOrDefault(x => x.ChangedProperty == "locked");
+            var rateLimitPerUserModel = changes.FirstOrDefault(x => x.ChangedProperty == "rate_limit_per_user");
+
+            var name = nameModel.OldValue.ToObject<string>(discord.ApiClient.Serializer);
+            var type = typeModel.OldValue.ToObject<ThreadType>(discord.ApiClient.Serializer);
+
+            var archived = archivedModel.OldValue.ToObject<bool>(discord.ApiClient.Serializer);
+            var autoArchiveDuration = autoArchiveDurationModel.OldValue.ToObject<ThreadArchiveDuration>(discord.ApiClient.Serializer);
+            var locked = lockedModel.OldValue.ToObject<bool>(discord.ApiClient.Serializer);
+            var rateLimit = rateLimitPerUserModel?.NewValue?.ToObject<int>(discord.ApiClient.Serializer);
+
+            return new ThreadDeleteAuditLogData(id, name, type, archived, autoArchiveDuration, locked, rateLimit);
+        }
+
+        /// <summary>
+        ///     Gets the snowflake ID of the deleted thread.
+        /// </summary>
+        /// <returns>
+        ///     A <see cref="ulong"/> representing the snowflake identifier for the deleted thread.
+        /// </returns>
+        public ulong ThreadId { get; }
+        /// <summary>
+        ///     Gets the name of the deleted thread.
+        /// </summary>
+        /// <returns>
+        ///     A string containing the name of the deleted thread.
+        /// </returns>
+        public string ThreadName { get; }
+        /// <summary>
+        ///     Gets the type of the deleted thread.
+        /// </summary>
+        /// <returns>
+        ///     The type of thread that was deleted.
+        /// </returns>
+        public ThreadType ThreadType { get; }
+        /// <summary>
+        ///     Gets the value that indicates whether the deleted thread was archived.
+        /// </summary>
+        /// <returns>
+        ///     <c>true</c> if this thread had the Archived flag enabled; otherwise <c>false</c>.
+        /// </returns>
+        public bool IsArchived { get; }
+        /// <summary>
+        ///     Gets the thread auto archive duration of the deleted thread.
+        /// </summary>
+        /// <returns>
+        ///     The thread auto archive duration of the thread that was deleted.
+        /// </returns>
+        public ThreadArchiveDuration AutoArchiveDuration { get; }
+        /// <summary>
+        ///     Gets the value that indicates whether the deleted thread was locked.
+        /// </summary>
+        /// <returns>
+        ///     <c>true</c> if this thread had the Locked flag enabled; otherwise <c>false</c>.
+        /// </returns>
+        public bool IsLocked { get; }
+        /// <summary>
+        ///     Gets the slow-mode delay of the deleted thread.
+        /// </summary>
+        /// <returns>
+        ///     An <see cref="int"/> representing the time in seconds required before the user can send another
+        ///     message; <c>0</c> if disabled.
+        ///     <c>null</c> if this is not mentioned in this entry.
+        /// </returns>
+        public int? SlowModeInterval { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/ThreadInfo.cs

@@ -0,0 +1,39 @@
+namespace Discord.Rest
+{
+    /// <summary>
+    ///     Represents information for a thread.
+    /// </summary>
+    public class ThreadInfo
+    {
+        /// <summary>
+        ///     Gets the name of the thread.
+        /// </summary>
+        public string Name { get; }
+        /// <summary>
+        ///     Gets the value that indicates whether the thread is archived.
+        /// </summary>
+        public bool IsArchived { get; }
+        /// <summary>
+        ///     Gets the auto archive duration of thread.
+        /// </summary>
+        public ThreadArchiveDuration AutoArchiveDuration { get; }
+        /// <summary>
+        ///     Gets the value that indicates whether the thread is locked.
+        /// </summary>
+        public bool IsLocked { get; }
+
+        /// <summary>
+        ///     Gets the slow-mode delay of the ´thread.
+        /// </summary>
+        public int? SlowModeInterval { get; }
+
+        internal ThreadInfo(string name, bool archived, ThreadArchiveDuration autoArchiveDuration, bool locked, int? rateLimit)
+        {
+            Name = name;
+            IsArchived = archived;
+            AutoArchiveDuration = autoArchiveDuration;
+            IsLocked = locked;
+            SlowModeInterval = rateLimit;
+        }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/ThreadUpdateAuditLogData.cs

@@ -0,0 +1,88 @@
+using System.Linq;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    /// <summary>
+    ///     Contains a piece of audit log data related to a thread update.
+    /// </summary>
+    public class ThreadUpdateAuditLogData : IAuditLogData
+    {
+        private ThreadUpdateAuditLogData(IThreadChannel thread, ThreadType type, ThreadInfo before, ThreadInfo after)
+        {
+            Thread = thread;
+            ThreadType = type;
+            Before = before;
+            After = After;
+        }
+
+        internal static ThreadUpdateAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var changes = entry.Changes;
+
+            var id = entry.TargetId.Value;
+
+            var nameModel = entry.Changes.FirstOrDefault(x => x.ChangedProperty == "name");
+            var typeModel = entry.Changes.FirstOrDefault(x => x.ChangedProperty == "type");
+
+            var archivedModel = entry.Changes.FirstOrDefault(x => x.ChangedProperty == "archived");
+            var autoArchiveDurationModel = entry.Changes.FirstOrDefault(x => x.ChangedProperty == "auto_archive_duration");
+            var lockedModel = entry.Changes.FirstOrDefault(x => x.ChangedProperty == "locked");
+            var rateLimitPerUserModel = changes.FirstOrDefault(x => x.ChangedProperty == "rate_limit_per_user");
+
+            var type = typeModel.OldValue.ToObject<ThreadType>(discord.ApiClient.Serializer);
+
+            var oldName = nameModel.OldValue.ToObject<string>(discord.ApiClient.Serializer);
+            var oldArchived = archivedModel.OldValue.ToObject<bool>(discord.ApiClient.Serializer);
+            var oldAutoArchiveDuration = autoArchiveDurationModel.OldValue.ToObject<ThreadArchiveDuration>(discord.ApiClient.Serializer);
+            var oldLocked = lockedModel.OldValue.ToObject<bool>(discord.ApiClient.Serializer);
+            var oldRateLimit = rateLimitPerUserModel?.OldValue?.ToObject<int>(discord.ApiClient.Serializer);
+            var before = new ThreadInfo(oldName, oldArchived, oldAutoArchiveDuration, oldLocked, oldRateLimit);
+
+            var newName = nameModel.NewValue.ToObject<string>(discord.ApiClient.Serializer);
+            var newArchived = archivedModel.NewValue.ToObject<bool>(discord.ApiClient.Serializer);
+            var newAutoArchiveDuration = autoArchiveDurationModel.NewValue.ToObject<ThreadArchiveDuration>(discord.ApiClient.Serializer);
+            var newLocked = lockedModel.NewValue.ToObject<bool>(discord.ApiClient.Serializer);
+            var newRateLimit = rateLimitPerUserModel?.NewValue?.ToObject<int>(discord.ApiClient.Serializer);
+            var after = new ThreadInfo(newName, newArchived, newAutoArchiveDuration, newLocked, newRateLimit);
+
+            var threadInfo = log.Threads.FirstOrDefault(x => x.Id == id);
+            var threadChannel = threadInfo == null ? null : RestThreadChannel.Create(discord, (IGuild)null, threadInfo);
+
+            return new ThreadUpdateAuditLogData(threadChannel,type, before, after);
+        }
+
+        // Doc Note: Corresponds to the *current* data
+
+        /// <summary>
+        ///     Gets the thread that was created if it still exists.
+        /// </summary>
+        /// <returns>
+        ///     A thread object representing the thread that was created if it still exists, otherwise returns <c>null</c>.
+        /// </returns>
+        public IThreadChannel Thread { get; }
+        /// <summary>
+        ///     Gets the type of the thread.
+        /// </summary>
+        /// <returns>
+        ///     The type of thread.
+        /// </returns>
+        public ThreadType ThreadType { get; }
+        /// <summary>
+        ///     Gets the thread information before the changes.
+        /// </summary>
+        /// <returns>
+        ///     A thread information object representing the thread before the changes were made.
+        /// </returns>
+        public ThreadInfo Before { get; }
+        /// <summary>
+        ///     Gets the thread information after the changes.
+        /// </summary>
+        /// <returns>
+        ///     A thread information object representing the thread after the changes were made.
+        /// </returns>
+        public ThreadInfo After { get; }
+    }
+}