Implemented Threads

DSharpPlus.Test/TestBot.cs

@@ -99,6 +99,13 @@ public TestBot(TestBotConfig cfg, int shardid)
             //    throw new Exception("Flippin' tables");
             //};
 
+            this.Discord.ThreadCreated += this.Discord_ThreadCreated;
+            this.Discord.ThreadUpdated += this.Discord_ThreadUpdated;
+            this.Discord.ThreadDeleted += this.Discord_ThreadDeleted;
+            this.Discord.ThreadListSynced += this.Discord_ThreadListSynced;
+            this.Discord.ThreadMemberUpdated += this.Discord_ThreadMemberUpdated;
+            this.Discord.ThreadMembersUpdated += this.Discord_ThreadMembersUpdated;
+
             // voice config and the voice service itself
             var vcfg = new VoiceNextConfiguration
             {
@@ -303,5 +310,42 @@ private async Task Discord_ChannelDeleted(DiscordClient client, ChannelDeleteEve
                 Console.WriteLine("TargetId: " + entry.Target.Id);
             }
         }
+
+        private Task Discord_ThreadCreated(DiscordClient client, ThreadCreateEventArgs e)
+        {
+            client.Logger.LogDebug(eventId: TestBotEventId, $"Thread created in {e.Guild.Name}. Thread Name: {e.Thread.Name}");
+            return Task.CompletedTask;
+        }
+
+        private Task Discord_ThreadUpdated(DiscordClient client, ThreadUpdateEventArgs e)
+        {
+            client.Logger.LogDebug(eventId: TestBotEventId, $"Thread updated in {e.Guild.Name}. New Thread Name: {e.ThreadAfter.Name}");
+            return Task.CompletedTask;
+        }
+
+        private Task Discord_ThreadDeleted(DiscordClient client, ThreadDeleteEventArgs e)
+        {
+            client.Logger.LogDebug(eventId: TestBotEventId, $"Thread deleted in {e.Guild.Name}. Thread Name: {e.Thread.Name ?? "Unknown"}");
+            return Task.CompletedTask;
+        }
+
+        private Task Discord_ThreadListSynced(DiscordClient client, ThreadListSyncEventArgs e)
+        {
+            client.Logger.LogDebug(eventId: TestBotEventId, $"Threads synced in {e.Guild.Name}.");
+            return Task.CompletedTask;
+        }
+
+        private Task Discord_ThreadMemberUpdated(DiscordClient client, ThreadMemberUpdateEventArgs e)
+        {
+            client.Logger.LogDebug(eventId: TestBotEventId, $"Thread member updated.");
+            Console.WriteLine($"Discord_ThreadMemberUpdated fired for thread {e.ThreadMember.ThreadId}. User ID {e.ThreadMember.Id}.");
+            return Task.CompletedTask;
+        }
+
+        private Task Discord_ThreadMembersUpdated(DiscordClient client, ThreadMembersUpdateEventArgs e)
+        {
+            client.Logger.LogDebug(eventId: TestBotEventId, $"Thread members updated in {e.Guild.Name}.");
+            return Task.CompletedTask;
+        }
     }
 }

DSharpPlus.Test/TestBotCommands.cs

@@ -534,5 +534,11 @@ public async Task PurgeChatAsync(CommandContext ctx)
                 .WithFooter($"foo");
             await x.SendMessageAsync(embed: embed2);
         }
+        [Command("ping"), Aliases("p")]
+        public async Task PingAsync(CommandContext ctx)
+        {
+            await ctx.TriggerTypingAsync();
+            await ctx.RespondAsync($"Pong: {ctx.Client.Ping}ms");
+        }
     }
 }

DSharpPlus/Clients/DiscordClient.Dispatch.cs

@@ -59,6 +59,7 @@ internal async Task HandleDispatchAsync(GatewayPayload payload)
             }
 
             DiscordChannel chn;
+            DiscordThreadChannel thread;
             ulong gid;
             ulong cid;
             TransportUser usr = default;
@@ -346,6 +347,39 @@ internal async Task HandleDispatchAsync(GatewayPayload payload)
 
                 #endregion
 
+                #region Thread
+
+                case "thread_create":
+                    thread = dat.ToDiscordObject<DiscordThreadChannel>();
+                    await this.OnThreadCreateEventAsync(thread).ConfigureAwait(false);
+                    break;
+
+                case "thread_update":
+                    thread = dat.ToDiscordObject<DiscordThreadChannel>();
+                    await this.OnThreadUpdateEventAsync(thread).ConfigureAwait(false);
+                    break;
+
+                case "thread_delete":
+                    thread = dat.ToDiscordObject<DiscordThreadChannel>();
+                    await this.OnThreadDeleteEventAsync(thread).ConfigureAwait(false);
+                    break;
+
+                case "thread_list_sync":
+                    gid = (ulong)dat["guild_id"]; //get guild
+                    await this.OnThreadListSyncEventAsync(this._guilds[gid], dat["channel_ids"].ToDiscordObject<IReadOnlyList<ulong>>(), dat["threads"].ToObject<IReadOnlyList<DiscordThreadChannel>>(), dat["members"].ToObject<IReadOnlyList<DiscordThreadChannelMember>>()).ConfigureAwait(false);
+                    break;
+
+                case "thread_member_update":
+                    await this.OnThreadMemberUpdateEventAsync(dat.ToDiscordObject<DiscordThreadChannelMember>()).ConfigureAwait(false);
+                    break;
+
+                case "thread_members_update":
+                    gid = (ulong)dat["guild_id"];
+                    await this.OnThreadMembersUpdateEventAsync(this._guilds[gid], (ulong)dat["id"], dat["added_members"]?.ToObject<IReadOnlyList<DiscordThreadChannelMember>>(), dat["removed_member_ids"]?.ToObject<IReadOnlyList<ulong?>>(), (int)dat["member_count"]).ConfigureAwait(false);
+                    break;
+
+                #endregion
+
                 #region Interaction/Integration/Application
 
                 case "interaction_create":
@@ -499,6 +533,8 @@ internal async Task OnReadyEventAsync(ReadyPayload ready, JArray rawGuilds, JArr
 
                 if (guild._channels == null)
                     guild._channels = new ConcurrentDictionary<ulong, DiscordChannel>();
+                if (guild._threads == null)
+                    guild._threads = new ConcurrentDictionary<ulong, DiscordThreadChannel>();
 
                 foreach (var xc in guild.Channels.Values)
                 {
@@ -510,6 +546,11 @@ internal async Task OnReadyEventAsync(ReadyPayload ready, JArray rawGuilds, JArr
                         xo._channel_id = xc.Id;
                     }
                 }
+                foreach (var xt in guild.Threads.Values)
+                {
+                    xt.GuildId = guild.Id;
+                    xt.Discord = this;
+                }
 
                 if (guild._roles == null)
                     guild._roles = new ConcurrentDictionary<ulong, DiscordRole>();
@@ -723,6 +764,8 @@ internal async Task OnGuildCreateEventAsync(DiscordGuild guild, JArray rawMember
 
             if (guild._channels == null)
                 guild._channels = new ConcurrentDictionary<ulong, DiscordChannel>();
+            if (guild._threads == null)
+                guild._threads = new ConcurrentDictionary<ulong, DiscordThreadChannel>();
             if (guild._roles == null)
                 guild._roles = new ConcurrentDictionary<ulong, DiscordRole>();
             if (guild._emojis == null)
@@ -761,6 +804,11 @@ internal async Task OnGuildCreateEventAsync(DiscordGuild guild, JArray rawMember
                     xo._channel_id = xc.Id;
                 }
             }
+            foreach (var xt in guild._threads.Values)
+            {
+                xt.GuildId = guild.Id;
+                xt.Discord = this;
+            }
             foreach (var xe in guild._emojis.Values)
                 xe.Discord = this;
             foreach (var xs in guild._stickers.Values)
@@ -837,13 +885,15 @@ internal async Task OnGuildUpdateEventAsync(DiscordGuild guild, JArray rawMember
                     VoiceRegionId = gld.VoiceRegionId,
                     IsNSFW = gld.IsNSFW,
                     _channels = new ConcurrentDictionary<ulong, DiscordChannel>(),
+                    _threads = new ConcurrentDictionary<ulong, DiscordThreadChannel>(),
                     _emojis = new ConcurrentDictionary<ulong, DiscordEmoji>(),
                     _members = new ConcurrentDictionary<ulong, DiscordMember>(),
                     _roles = new ConcurrentDictionary<ulong, DiscordRole>(),
                     _voiceStates = new ConcurrentDictionary<ulong, DiscordVoiceState>()
                 };
 
                 foreach (var kvp in gld._channels) oldGuild._channels[kvp.Key] = kvp.Value;
+                foreach (var kvp in gld._threads) oldGuild._threads[kvp.Key] = kvp.Value;
                 foreach (var kvp in gld._emojis) oldGuild._emojis[kvp.Key] = kvp.Value;
                 foreach (var kvp in gld._roles) oldGuild._roles[kvp.Key] = kvp.Value;
                 foreach (var kvp in gld._voiceStates) oldGuild._voiceStates[kvp.Key] = kvp.Value;
@@ -857,6 +907,8 @@ internal async Task OnGuildUpdateEventAsync(DiscordGuild guild, JArray rawMember
 
             if (guild._channels == null)
                 guild._channels = new ConcurrentDictionary<ulong, DiscordChannel>();
+            if (guild._threads == null)
+                guild._threads = new ConcurrentDictionary<ulong, DiscordThreadChannel>();
             if (guild._roles == null)
                 guild._roles = new ConcurrentDictionary<ulong, DiscordRole>();
             if (guild._emojis == null)
@@ -878,6 +930,11 @@ internal async Task OnGuildUpdateEventAsync(DiscordGuild guild, JArray rawMember
                     xo._channel_id = xc.Id;
                 }
             }
+            foreach (var xc in guild._threads.Values)
+            {
+                xc.GuildId = guild.Id;
+                xc.Discord = this;
+            }
             foreach (var xe in guild._emojis.Values)
                 xe.Discord = this;
             foreach (var xvs in guild._voiceStates.Values)
@@ -1764,6 +1821,174 @@ internal async Task OnVoiceServerUpdateEventAsync(string endpoint, string token,
 
         #endregion
 
+        #region Thread
+
+        internal async Task OnThreadCreateEventAsync(DiscordThreadChannel thread)
+        {
+            thread.Discord = this;
+            this.InternalGetCachedGuild(thread.GuildId)._threads.AddOrUpdate(thread.Id, thread, (oldThread, newThread) => newThread);
+
+            await this._threadCreated.InvokeAsync(this, new ThreadCreateEventArgs { Thread = thread, Guild = thread.Guild, Parent = thread.Parent }).ConfigureAwait(false);
+        }
+
+        internal async Task OnThreadUpdateEventAsync(DiscordThreadChannel thread)
+        {
+            if (thread == null)
+                return;
+
+            DiscordThreadChannel threadOld;
+            ThreadUpdateEventArgs updateEvent;
+
+            thread.Discord = this;
+
+            var guild = thread.Guild;
+            guild.Discord = this;
+
+            var cthread = this.InternalGetCachedThread(thread.Id);
+
+            if (cthread != null) //thread is cached
+            {
+                threadOld = new DiscordThreadChannel
+                {
+                    Discord = this,
+                    GuildId = cthread.GuildId,
+                    CreatorId = cthread.CreatorId,
+                    ParentId = cthread.ParentId,
+                    Id = cthread.Id,
+                    Name = cthread.Name,
+                    Type = cthread.Type,
+                    LastMessageId = cthread.LastMessageId,
+                    MessageCount = cthread.MessageCount,
+                    MemberCount = cthread.MemberCount,
+                    ThreadMetadata = cthread.ThreadMetadata,
+                    CurrentMember = cthread.CurrentMember,
+                };
+
+                updateEvent = new ThreadUpdateEventArgs
+                {
+                    ThreadAfter = thread,
+                    ThreadBefore = threadOld,
+                    Guild = thread.Guild,
+                    Parent = thread.Parent
+                };
+            }
+            else
+            {
+                updateEvent = new ThreadUpdateEventArgs
+                {
+                    ThreadAfter = thread,
+                    Guild = thread.Guild,
+                    Parent = thread.Parent
+                };
+                guild._threads[thread.Id] = thread;
+            }
+
+            await this._threadUpdated.InvokeAsync(this, updateEvent).ConfigureAwait(false);
+        }
+
+        internal async Task OnThreadDeleteEventAsync(DiscordThreadChannel thread)
+        {
+            if (thread == null)
+                return;
+
+            thread.Discord = this;
+
+            var gld = thread.Guild;
+            if (gld._threads.TryRemove(thread.Id, out var cachedThread))
+                thread = cachedThread;
+
+            await this._threadDeleted.InvokeAsync(this, new ThreadDeleteEventArgs { Thread = thread, Guild = thread.Guild, Parent = thread.Parent}).ConfigureAwait(false);
+        }
+
+        internal async Task OnThreadListSyncEventAsync(DiscordGuild guild, IReadOnlyList<ulong>? channel_ids, IReadOnlyList<DiscordThreadChannel> threads, IReadOnlyList<DiscordThreadChannelMember> members)
+        {
+            guild.Discord = this;
+            var channels = channel_ids.Select(x => guild.GetChannel(x) ?? new DiscordChannel{ Id = x, GuildId = guild.Id}); //getting channel objects
+
+            foreach (var channel in channels)
+            {
+                channel.Discord = this;
+            }
+
+            foreach(var thread in threads)
+            {
+                thread.Discord = this;
+                guild._threads[thread.Id] = thread;
+            }
+
+            foreach(var member in members)
+            {
+                member.Discord = this;
+                member._guild_id = guild.Id;
+
+                var thread = threads.SingleOrDefault(x => x.Id == member.ThreadId);
+                if (thread != null)
+                    thread.CurrentMember = member;
+            }
+
+            await this._threadListSynced.InvokeAsync(this, new ThreadListSyncEventArgs { Guild = guild, Channels = channels.ToList().AsReadOnly(), Threads = threads, CurrentMembers = members.ToList().AsReadOnly() }).ConfigureAwait(false);
+        }
+
+        internal async Task OnThreadMemberUpdateEventAsync(DiscordThreadChannelMember member)
+        {
+            member.Discord = this;
+
+            var thread = this.InternalGetCachedThread(member.ThreadId);
+            member._guild_id = thread.Guild.Id;
+            thread.CurrentMember = member;
+            thread.Guild._threads.AddOrUpdate(member.ThreadId, thread, (oldThread, newThread) => newThread);
+
+            await this._threadMemberUpdated.InvokeAsync(this, new ThreadMemberUpdateEventArgs { ThreadMember = member, Thread = thread }).ConfigureAwait(false);
+        }
+
+        internal async Task OnThreadMembersUpdateEventAsync(DiscordGuild guild, ulong thread_id, IReadOnlyList<DiscordThreadChannelMember> addedMembers, IReadOnlyList<ulong?> removed_member_ids, int member_count)
+        {
+            var thread = this.InternalGetCachedThread(thread_id);
+            thread.Discord = this;
+            guild.Discord = this;
+
+            var removedMembers = new List<DiscordMember>();
+            if (removed_member_ids != null)
+            {
+                foreach (var removedId in removed_member_ids)
+                {
+                    removedMembers.Add(guild._members.TryGetValue(removedId.Value, out var member) ? member: new DiscordMember { Id = removedId.Value, _guild_id = guild.Id, Discord = this });
+                }
+            }
+            else
+                removed_member_ids = Array.Empty<ulong?>();
+            if (addedMembers != null)
+            {
+                foreach (var threadMember in addedMembers)
+                {
+                    threadMember.Discord = this;
+                    threadMember._guild_id = guild.Id;
+
+                    if(threadMember.Id == this.CurrentUser.Id)
+                        thread.CurrentMember = threadMember;
+                }
+            }
+            else
+                addedMembers = Array.Empty<DiscordThreadChannelMember>();
+
+            if (removed_member_ids.Contains(this.CurrentUser.Id)) //indicates the bot was removed from the thread
+                thread.CurrentMember = null;
+            thread.MemberCount = member_count;
+
+            var threadMembersUpdateArg = new ThreadMembersUpdateEventArgs
+            {
+                Guild = guild,
+                Thread = thread,
+                AddedMembers = addedMembers,
+                RemovedMembers = removedMembers,
+                MemberCount = member_count
+            };
+
+            await this._threadMembersUpdated.InvokeAsync(this, threadMembersUpdateArg).ConfigureAwait(false);
+        }
+
+        #endregion
+
         #region Commands
 
         internal async Task OnApplicationCommandCreateAsync(DiscordApplicationCommand cmd, ulong? guild_id)