Modal Components v2 Single-select Typeconverters, Rest, and Patches (#3209)

* implement modal v2 components to rest interaction extensions

* update rest extensions inline docs

* rename respondwithmodal to respondwithmodalasync

* add type converters for single user, role, channel, mentionable selects and file-uploads

* update rest interaction module base with new async methods

* code cleanup and bug fixes in default snowflake modal typeconverter

* add default snowflake typeconverters to interaction service

* fix nre in respondwithmodal extension method

Author: Cenngo

src/Discord.Net.Interactions/Extensions/IDiscordInteractionExtensions.cs

@@ -65,16 +65,16 @@ public static Task RespondWithModalAsync<T>(this IDiscordInteraction interaction
             if (!ModalUtils.TryGet<T>(out var modalInfo))
                 throw new ArgumentException($"{typeof(T).FullName} isn't referenced by any registered Modal Interaction Command and doesn't have a cached {typeof(ModalInfo)}");
 
-            return SendModalResponseAsync<T>(interaction, customId, modalInfo, modal, options, modifyModal);
+            return SendModalResponseAsync(interaction, customId, modalInfo, modal, options, modifyModal);
         }
 
-        private static async Task SendModalResponseAsync<T>(IDiscordInteraction interaction, string customId, ModalInfo modalInfo, T modalInstance = null, RequestOptions options = null, Action<ModalBuilder> modifyModal = null)
+        public static async Task<Modal> ToModalAsync<T>(this IDiscordInteraction interaction, string customId, ModalInfo modalInfo, T modalInstance = null, RequestOptions options = null, Action<ModalBuilder> modifyModal = null)
             where T : class, IModal
         {
             if (!modalInfo.Type.IsAssignableFrom(typeof(T)))
                 throw new ArgumentException($"{modalInfo.Type.FullName} isn't assignable from {typeof(T).FullName}.");
 
-            var builder = new ModalBuilder(modalInstance.Title, customId);
+            var builder = new ModalBuilder(modalInstance?.Title ?? modalInfo.Title, customId);
 
             foreach (var input in modalInfo.Components)
                 switch (input)
@@ -134,7 +134,7 @@ private static async Task SendModalResponseAsync<T>(IDiscordInteraction interact
                         break;
                     case TextDisplayComponentInfo textDisplayComponent:
                         {
-                            var content = textDisplayComponent.Getter(modalInstance).ToString() ?? textDisplayComponent.Content;
+                            var content = modalInstance is not null ? textDisplayComponent.Getter(modalInstance).ToString() : (textDisplayComponent.DefaultValue as string) ?? textDisplayComponent.Content;
                             var componentBuilder = new TextDisplayBuilder(content);
                             builder.AddTextDisplay(componentBuilder);
                         }
@@ -145,7 +145,15 @@ private static async Task SendModalResponseAsync<T>(IDiscordInteraction interact
 
             modifyModal?.Invoke(builder);
 
-            await interaction.RespondWithModalAsync(builder.Build(), options);
+            return builder.Build();
+        }
+
+        private static async Task SendModalResponseAsync<T>(IDiscordInteraction interaction, string customId, ModalInfo modalInfo, T modalInstance = null, RequestOptions options = null, Action<ModalBuilder> modifyModal = null)
+            where T : class, IModal
+        {
+            var modal = await interaction.ToModalAsync(customId, modalInfo, modalInstance, options, modifyModal);
+
+            await interaction.RespondWithModalAsync(modal, options);
         }
     }
 }

src/Discord.Net.Interactions/Extensions/RestExtensions.cs

@@ -1,5 +1,6 @@
 using Discord.Interactions;
 using System;
+using System.Threading.Tasks;
 
 namespace Discord.Rest
 {
@@ -11,14 +12,16 @@ public static class RestExtensions
         /// <typeparam name="T">Type of the <see cref="IModal"/> implementation.</typeparam>
         /// <param name="interaction">The interaction to respond to.</param>
         /// <param name="options">The request options for this <see langword="async"/> request.</param>
-        /// <returns>Serialized payload to be used to create a HTTP response.</returns>
-        public static string RespondWithModal<T>(this RestInteraction interaction, string customId, RequestOptions options = null, Action<ModalBuilder> modifyModal = null)
+        /// <returns>
+        ///     Task representing the asynchronous modal creation operation. The task result contains the serialized payload to be used to create a HTTP response.
+        /// </returns>
+        public static async Task<string> RespondWithModalAsync<T>(this RestInteraction interaction, string customId, RequestOptions options = null, Action<ModalBuilder> modifyModal = null)
             where T : class, IModal
         {
             if (!ModalUtils.TryGet<T>(out var modalInfo))
                 throw new ArgumentException($"{typeof(T).FullName} isn't referenced by any registered Modal Interaction Command and doesn't have a cached {typeof(ModalInfo)}");
 
-            var modal = modalInfo.ToModal(customId, modifyModal);
+            var modal = await interaction.ToModalAsync<T>(customId, modalInfo, null, options, modifyModal);
             return interaction.RespondWithModal(modal, options);
         }
 
@@ -27,35 +30,20 @@ public static string RespondWithModal<T>(this RestInteraction interaction, strin
         /// </summary>
         /// <typeparam name="T">Type of the <see cref="IModal"/> implementation.</typeparam>
         /// <param name="interaction">The interaction to respond to.</param>
-        /// <param name="modal">The <see cref="IModal"/> instance to get field values from.</param>
+        /// <param name="modalInstance">The <see cref="IModal"/> instance to get field values from.</param>
         /// <param name="options">The request options for this <see langword="async"/> request.</param>
         /// <param name="modifyModal">Delegate that can be used to modify the modal.</param>
-        /// <returns>Serialized payload to be used to create a HTTP response.</returns>
-        public static string RespondWithModal<T>(this RestInteraction interaction, string customId, T modal, RequestOptions options = null, Action<ModalBuilder> modifyModal = null)
+        /// <returns>
+        ///     Task representing the asynchronous modal creation operation. The task result contains the serialized payload to be used to create a HTTP response.
+        /// </returns>
+        public static async Task<string> RespondWithModalAsync<T>(this RestInteraction interaction, string customId, T modalInstance, RequestOptions options = null, Action<ModalBuilder> modifyModal = null)
             where T : class, IModal
         {
             if (!ModalUtils.TryGet<T>(out var modalInfo))
                 throw new ArgumentException($"{typeof(T).FullName} isn't referenced by any registered Modal Interaction Command and doesn't have a cached {typeof(ModalInfo)}");
 
-            var builder = new ModalBuilder(modal.Title, customId);
-
-            foreach (var input in modalInfo.Components)
-                switch (input)
-                {
-                    case TextInputComponentInfo textComponent:
-                        {
-                            builder.AddTextInput(textComponent.Label, textComponent.CustomId, textComponent.Style, textComponent.Placeholder, textComponent.IsRequired ? textComponent.MinLength : null,
-                            textComponent.MaxLength, textComponent.IsRequired, textComponent.Getter(modal) as string);
-                        }
-                        break;
-                    default:
-                        throw new InvalidOperationException($"{input.GetType().FullName} isn't a valid component info class");
-                }
-
-            if (modifyModal is not null)
-                modifyModal(builder);
-
-            return interaction.RespondWithModal(builder.Build(), options);
+            var modal = await interaction.ToModalAsync<T>(customId, modalInfo, null, options, modifyModal);
+            return interaction.RespondWithModal(modal, options);
         }
     }
 }

src/Discord.Net.Interactions/InteractionService.cs

@@ -236,7 +236,12 @@ private InteractionService(Func<DiscordRestClient> getRestClient, InteractionSer
                 [typeof(IConvertible)] = typeof(DefaultValueModalComponentConverter<>),
                 [typeof(Enum)] = typeof(EnumModalComponentConverter<>),
                 [typeof(Nullable<>)] = typeof(NullableComponentConverter<>),
-                [typeof(Array)] = typeof(DefaultArrayModalComponentConverter<>)
+                [typeof(Array)] = typeof(DefaultArrayModalComponentConverter<>),
+                [typeof(IChannel)] = typeof(DefaultChannelModalComponentConverter<>),
+                [typeof(IUser)] = typeof(DefaultUserModalComponentConverter<>),
+                [typeof(IRole)] = typeof(DefaultRoleModalComponentConverter<>),
+                [typeof(IMentionable)] = typeof(DefaultMentionableModalComponentConverter<>),
+                [typeof(IAttachment)] = typeof(DefaultAttachmentModalComponentConverter<>)
             });
         }
 

src/Discord.Net.Interactions/RestInteractionModuleBase.cs

@@ -71,7 +71,7 @@ protected override Task RespondWithModalAsync(Modal modal, RequestOptions option
         /// </returns>
         /// <exception cref="InvalidOperationException">Thrown if the interaction isn't a type of <see cref="RestInteraction"/>.</exception>
         protected override async Task RespondWithModalAsync<TModal>(string customId, TModal modal, RequestOptions options = null, Action<ModalBuilder> modifyModal = null)
-            => await HandleInteractionAsync(x => x.RespondWithModal(customId, modal, options, modifyModal));
+            => await HandleInteractionAsync(x => RestExtensions.RespondWithModalAsync(x, customId, modal, options, modifyModal));
 
         /// <summary>
         ///     Responds to the interaction with a modal.
@@ -85,7 +85,7 @@ protected override async Task RespondWithModalAsync<TModal>(string customId, TMo
         /// </returns>
         /// <exception cref="InvalidOperationException">Thrown if the interaction isn't a type of <see cref="RestInteraction"/>.</exception>
         protected override Task RespondWithModalAsync<TModal>(string customId, RequestOptions options = null, Action<ModalBuilder> modifyModal = null) 
-            => HandleInteractionAsync(x => x.RespondWithModal<TModal>(customId, options, modifyModal));
+            => HandleInteractionAsync(x => RestExtensions.RespondWithModalAsync<TModal>(x, customId, options, modifyModal));
 
         private Task HandleInteractionAsync(Func<RestInteraction, string> action)
         {
@@ -99,5 +99,18 @@ private Task HandleInteractionAsync(Func<RestInteraction, string> action)
             else
                 return InteractionService._restResponseCallback(Context, payload);
         }
+
+        private async Task HandleInteractionAsync(Func<RestInteraction, Task<string>> action)
+        {
+            if (Context.Interaction is not RestInteraction restInteraction)
+                throw new InvalidOperationException($"Interaction must be a type of {nameof(RestInteraction)} in order to execute this method.");
+
+            var payload = await action(restInteraction);
+
+            if (Context is IRestInteractionContext restContext && restContext.InteractionResponseCallback != null)
+                await restContext.InteractionResponseCallback.Invoke(payload);
+            else
+                await InteractionService._restResponseCallback(Context, payload);
+        }
     }
 }