Make interactivity responses conditionally follow up (#2282)

VelvetToroyashi · web-flow · commit 55c50afa8f58 · 2025-03-29T13:40:31.000+01:00
This commit fixes a few issues, including bot not limited to:

- Requiring a static response message instead of the factory
 - Subsequently using the static response over the factory
- Unconditionally sending a followup instead of checking the response status
diff --git a/DSharpPlus.Interactivity/EventHandling/ComponentBased/ComponentEventWaiter.cs b/DSharpPlus.Interactivity/EventHandling/ComponentBased/ComponentEventWaiter.cs
@@ -19,15 +19,12 @@ internal class ComponentEventWaiter : IDisposable
     private readonly ConcurrentHashSet<ComponentMatchRequest> matchRequests = [];
     private readonly ConcurrentHashSet<ComponentCollectRequest> collectRequests = [];
 
-    private readonly DiscordFollowupMessageBuilder message;
     private readonly InteractivityConfiguration config;
 
     public ComponentEventWaiter(DiscordClient client, InteractivityConfiguration config)
     {
         this.client = client;
         this.config = config;
-
-        this.message = new() { Content = config.ResponseMessage ?? "This message was not meant for you.", IsEphemeral = true };
     }
 
     /// <summary>
@@ -90,17 +87,27 @@ internal async Task HandleAsync(DiscordClient _, ComponentInteractionCreatedEven
             {
                 try
                 {
-                    string responseMessage = this.config.ResponseMessage ?? 
-                                             this.config.ResponseMessageFactory(args, client.ServiceProvider);
-                    
-                    await args.Interaction.CreateFollowupMessageAsync
-                    (
-                        new DiscordFollowupMessageBuilder { Content = responseMessage, IsEphemeral = true }
-                    );
+                    string responseMessage = this.config.ResponseMessage ?? this.config.ResponseMessageFactory(args, this.client.ServiceProvider);
+
+                    if (args.Interaction.ResponseState is DiscordInteractionResponseState.Unacknowledged)
+                    {
+                        await args.Interaction.CreateResponseAsync
+                        (
+                            DiscordInteractionResponseType.ChannelMessageWithSource,
+                            new() { Content = responseMessage, IsEphemeral = true }
+                        );
+                    }
+                    else
+                    {
+                        await args.Interaction.CreateFollowupMessageAsync
+                        (
+                            new() { Content = responseMessage, IsEphemeral = true }
+                        );
+                    }
                 }
                 catch (Exception e) 
                 {
-                    client.Logger.LogWarning(e, "An exception was thrown during an interactivity response.");
+                    this.client.Logger.LogWarning(e, "An exception was thrown during an interactivity response.");
                 }
             }
         }
@@ -119,17 +126,27 @@ await args.Interaction.CreateFollowupMessageAsync
                 {
                     try
                     {
-                        string responseMessage = this.config.ResponseMessage ?? 
-                                                 this.config.ResponseMessageFactory(args, client.ServiceProvider);
-                    
-                        await args.Interaction.CreateFollowupMessageAsync
-                        (
-                            new DiscordFollowupMessageBuilder { Content = responseMessage, IsEphemeral = true }
-                        );
+                        string responseMessage = this.config.ResponseMessage ?? this.config.ResponseMessageFactory(args, this.client.ServiceProvider);
+
+                        if (args.Interaction.ResponseState is DiscordInteractionResponseState.Unacknowledged)
+                        {
+                            await args.Interaction.CreateResponseAsync
+                            (
+                                DiscordInteractionResponseType.ChannelMessageWithSource,
+                                new() { Content = responseMessage, IsEphemeral = true }
+                            );
+                        }
+                        else
+                        {
+                            await args.Interaction.CreateFollowupMessageAsync
+                            (
+                                new() { Content = responseMessage, IsEphemeral = true }
+                            );
+                        }
                     }
                     catch (Exception e) 
                     {
-                        client.Logger.LogWarning(e, "An exception was thrown during an interactivity response.");
+                        this.client.Logger.LogWarning(e, "An exception was thrown during an interactivity response.");
                     }
                 }
             }
diff --git a/DSharpPlus.Interactivity/InteractivityConfiguration.cs b/DSharpPlus.Interactivity/InteractivityConfiguration.cs
@@ -91,10 +91,5 @@ public InteractivityConfiguration(InteractivityConfiguration other)
         this.ResponseMessage = other.ResponseMessage;
         this.PollBehaviour = other.PollBehaviour;
         this.Timeout = other.Timeout;
-
-        if (this.ResponseBehavior is InteractionResponseBehavior.Respond && string.IsNullOrWhiteSpace(this.ResponseMessage))
-        {
-            throw new ArgumentException($"{nameof(this.ResponseMessage)} cannot be null, empty, or whitespace when {nameof(this.ResponseBehavior)} is set to respond.");
-        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -19,15 +19,12 @@ internal class ComponentEventWaiter : IDisposable`
`19`	`19`	`private readonly ConcurrentHashSet<ComponentMatchRequest> matchRequests = [];`
`20`	`20`	`private readonly ConcurrentHashSet<ComponentCollectRequest> collectRequests = [];`
`21`	`21`
`22`		`- private readonly DiscordFollowupMessageBuilder message;`
`23`	`22`	`private readonly InteractivityConfiguration config;`
`24`	`23`
`25`	`24`	`public ComponentEventWaiter(DiscordClient client, InteractivityConfiguration config)`
`26`	`25`	`{`
`27`	`26`	`this.client = client;`
`28`	`27`	`this.config = config;`
`29`		`-`
`30`		`- this.message = new() { Content = config.ResponseMessage ?? "This message was not meant for you.", IsEphemeral = true };`
`31`	`28`	`}`
`32`	`29`
`33`	`30`	`/// <summary>`
`@@ -90,17 +87,27 @@ internal async Task HandleAsync(DiscordClient _, ComponentInteractionCreatedEven`
`90`	`87`	`{`
`91`	`88`	`try`
`92`	`89`	`{`
`93`		`- string responseMessage = this.config.ResponseMessage ??`
`94`		`- this.config.ResponseMessageFactory(args, client.ServiceProvider);`
`95`		`-`
`96`		`- await args.Interaction.CreateFollowupMessageAsync`
`97`		`- (`
`98`		`- new DiscordFollowupMessageBuilder { Content = responseMessage, IsEphemeral = true }`
`99`		`- );`
	`90`	`+ string responseMessage = this.config.ResponseMessage ?? this.config.ResponseMessageFactory(args, this.client.ServiceProvider);`
	`91`	`+`
	`92`	`+ if (args.Interaction.ResponseState is DiscordInteractionResponseState.Unacknowledged)`
	`93`	`+ {`
	`94`	`+ await args.Interaction.CreateResponseAsync`
	`95`	`+ (`
	`96`	`+ DiscordInteractionResponseType.ChannelMessageWithSource,`
	`97`	`+ new() { Content = responseMessage, IsEphemeral = true }`
	`98`	`+ );`
	`99`	`+ }`
	`100`	`+ else`
	`101`	`+ {`
	`102`	`+ await args.Interaction.CreateFollowupMessageAsync`
	`103`	`+ (`
	`104`	`+ new() { Content = responseMessage, IsEphemeral = true }`
	`105`	`+ );`
	`106`	`+ }`
`100`	`107`	`}`
`101`	`108`	`catch (Exception e)`
`102`	`109`	`{`
`103`		`- client.Logger.LogWarning(e, "An exception was thrown during an interactivity response.");`
	`110`	`+ this.client.Logger.LogWarning(e, "An exception was thrown during an interactivity response.");`
`104`	`111`	`}`
`105`	`112`	`}`
`106`	`113`	`}`
`@@ -119,17 +126,27 @@ await args.Interaction.CreateFollowupMessageAsync`
`119`	`126`	`{`
`120`	`127`	`try`
`121`	`128`	`{`
`122`		`- string responseMessage = this.config.ResponseMessage ??`
`123`		`- this.config.ResponseMessageFactory(args, client.ServiceProvider);`
`124`		`-`
`125`		`- await args.Interaction.CreateFollowupMessageAsync`
`126`		`- (`
`127`		`- new DiscordFollowupMessageBuilder { Content = responseMessage, IsEphemeral = true }`
`128`		`- );`
	`129`	`+ string responseMessage = this.config.ResponseMessage ?? this.config.ResponseMessageFactory(args, this.client.ServiceProvider);`
	`130`	`+`
	`131`	`+ if (args.Interaction.ResponseState is DiscordInteractionResponseState.Unacknowledged)`
	`132`	`+ {`
	`133`	`+ await args.Interaction.CreateResponseAsync`
	`134`	`+ (`
	`135`	`+ DiscordInteractionResponseType.ChannelMessageWithSource,`
	`136`	`+ new() { Content = responseMessage, IsEphemeral = true }`
	`137`	`+ );`
	`138`	`+ }`
	`139`	`+ else`
	`140`	`+ {`
	`141`	`+ await args.Interaction.CreateFollowupMessageAsync`
	`142`	`+ (`
	`143`	`+ new() { Content = responseMessage, IsEphemeral = true }`
	`144`	`+ );`
	`145`	`+ }`
`129`	`146`	`}`
`130`	`147`	`catch (Exception e)`
`131`	`148`	`{`
`132`		`- client.Logger.LogWarning(e, "An exception was thrown during an interactivity response.");`
	`149`	`+ this.client.Logger.LogWarning(e, "An exception was thrown during an interactivity response.");`
`133`	`150`	`}`
`134`	`151`	`}`
`135`	`152`	`}`
Original file line number	Diff line number	Diff line change
`@@ -91,10 +91,5 @@ public InteractivityConfiguration(InteractivityConfiguration other)`
`91`	`91`	`this.ResponseMessage = other.ResponseMessage;`
`92`	`92`	`this.PollBehaviour = other.PollBehaviour;`
`93`	`93`	`this.Timeout = other.Timeout;`
`94`		`-`
`95`		`- if (this.ResponseBehavior is InteractionResponseBehavior.Respond && string.IsNullOrWhiteSpace(this.ResponseMessage))`
`96`		`- {`
`97`		`- throw new ArgumentException($"{nameof(this.ResponseMessage)} cannot be null, empty, or whitespace when {nameof(this.ResponseBehavior)} is set to respond.");`
`98`		`- }`
`99`	`94`	`}`
`100`	`95`	`}`