public static async Task <IUserMessage> CreateInteractionFollowupAsync(this IRestClient client, Snowflake applicationId, string interactionToken, LocalInteractionFollowup followup, IRestRequestOptions options = null, CancellationToken cancellationToken = default) { Guard.IsNotNull(followup); followup.Validate(); var messageContent = new CreateFollowupMessageJsonRestRequestContent { Content = Optional.FromNullable(followup.Content), Tts = Optional.Conditional(followup.IsTextToSpeech, true), Embeds = Optional.Conditional(followup.Embeds.Count != 0, x => x.Select(x => x.ToModel()).ToArray(), followup.Embeds), AllowedMentions = Optional.FromNullable(followup.AllowedMentions.ToModel()), Components = Optional.Conditional(followup.Components.Count != 0, x => x.Select(x => x.ToModel()).ToArray(), followup.Components), Flags = followup.Flags }; Task <MessageJsonModel> task; if (followup.Attachments.Count != 0) { // If there are attachments, we must send them via multipart HTTP content. // Our `messageContent` will be serialized into a "payload_json" form data field. var content = new MultipartJsonPayloadRestRequestContent <CreateFollowupMessageJsonRestRequestContent>(messageContent, followup.Attachments); task = client.ApiClient.CreateFollowupInteractionResponseAsync(applicationId, interactionToken, content, options, cancellationToken); } else { task = client.ApiClient.CreateFollowupInteractionResponseAsync(applicationId, interactionToken, messageContent, options, cancellationToken); } var model = await task.ConfigureAwait(false); return(new TransientUserMessage(client, model)); }
private static async Task <IUserMessage> InternalModifyInteractionResponseAsync(this IRestClient client, Snowflake applicationId, string interactionToken, Snowflake?messageId, Action <ModifyWebhookMessageActionProperties> action, IRestRequestOptions options, CancellationToken cancellationToken) { var properties = new ModifyWebhookMessageActionProperties(); action.Invoke(properties); var messageContent = new ModifyWebhookMessageJsonRestRequestContent { Content = properties.Content, Embeds = Optional.Convert(properties.Embeds, x => x.Select(x => { x.Validate(); return(x.ToModel()); }).ToArray()), AllowedMentions = Optional.Convert(properties.AllowedMentions, x => x.ToModel()), Attachments = Optional.Convert(properties.AttachmentIds, x => x.Select(x => new AttachmentJsonModel { Id = x }).ToArray()), Components = Optional.Convert(properties.Components, x => x.Select(x => { x.Validate(); return(x.ToModel()); }).ToArray()) }; Task <MessageJsonModel> task; if (properties.Attachments.HasValue) { // If there is an attachment, we must send it via multipart HTTP content. // Our `messageContent` will be serialized into a "payload_json" form data field. var content = new MultipartJsonPayloadRestRequestContent <ModifyWebhookMessageJsonRestRequestContent>(messageContent, properties.Attachments.Value); task = messageId == null ? client.ApiClient.ModifyInitialInteractionResponseAsync(applicationId, interactionToken, content, options, cancellationToken) : client.ApiClient.ModifyFollowupInteractionResponseAsync(applicationId, interactionToken, messageId.Value, content, options, cancellationToken); } else { task = messageId == null ? client.ApiClient.ModifyInitialInteractionResponseAsync(applicationId, interactionToken, messageContent, options, cancellationToken) : client.ApiClient.ModifyFollowupInteractionResponseAsync(applicationId, interactionToken, messageId.Value, messageContent, options, cancellationToken); } var model = await task.ConfigureAwait(false); return(new TransientUserMessage(client, model)); }
public static Task CreateInteractionResponseAsync(this IRestClient client, Snowflake interactionId, string interactionToken, ILocalInteractionResponse response, IRestRequestOptions options = null, CancellationToken cancellationToken = default) { var content = response.ToContent(client.ApiClient.Serializer, out var attachments); Task task; if (attachments.Count != 0) { var multipartContent = new MultipartJsonPayloadRestRequestContent <CreateInitialInteractionResponseJsonRestRequestContent>(content, attachments); task = client.ApiClient.CreateInitialInteractionResponseAsync(interactionId, interactionToken, multipartContent, options, cancellationToken); } else { task = client.ApiClient.CreateInitialInteractionResponseAsync(interactionId, interactionToken, content, options, cancellationToken); } return(task); }
public static async Task <IUserMessage> ModifyMessageAsync(this IRestClient client, Snowflake channelId, Snowflake messageId, Action <ModifyMessageActionProperties> action, IRestRequestOptions options = null, CancellationToken cancellationToken = default) { Guard.IsNotNull(action); var properties = new ModifyMessageActionProperties(); action(properties); var messageContent = new ModifyMessageJsonRestRequestContent { Content = properties.Content, Embeds = Optional.Convert(properties.Embeds, models => models.Select(x => { x.Validate(); return(x.ToModel()); }).ToArray()), Flags = properties.Flags, AllowedMentions = Optional.Convert(properties.AllowedMentions, x => x.ToModel()), Attachments = Optional.Convert(properties.AttachmentIds, x => x.Select(x => new AttachmentJsonModel { Id = x }).ToArray()), Components = Optional.Convert(properties.Components, models => models.Select(x => { x.Validate(); return(x.ToModel()); }).ToArray()), StickerIds = Optional.Convert(properties.StickerIds, x => x.ToArray()) }; Task <MessageJsonModel> task; LocalAttachment[] attachments; if (properties.Attachments.TryGetValue(out var attachmentsEnumerable) && (attachments = attachmentsEnumerable.GetArray()).Length != 0) { // If there are attachments, we must send them via multipart HTTP content. // Our `messageContent` will be serialized into a "payload_json" form data field. var content = new MultipartJsonPayloadRestRequestContent <ModifyMessageJsonRestRequestContent>(messageContent, attachments); task = client.ApiClient.ModifyMessageAsync(channelId, messageId, content, options, cancellationToken); }
public static async Task <IUserMessage> SendMessageAsync(this IRestClient client, Snowflake channelId, LocalMessage message, IRestRequestOptions options = null, CancellationToken cancellationToken = default) { Guard.IsNotNull(message); message.Validate(); var messageContent = new CreateMessageJsonRestRequestContent { Content = Optional.FromNullable(message.Content), Tts = Optional.Conditional(message.IsTextToSpeech, true), Embeds = Optional.Conditional(message.Embeds.Count != 0, x => x.Select(x => x.ToModel()).ToArray(), message.Embeds), Flags = Optional.Conditional(message.Flags != 0, message.Flags), AllowedMentions = Optional.FromNullable(message.AllowedMentions.ToModel()), MessageReference = Optional.FromNullable(message.Reference.ToModel()), Nonce = Optional.FromNullable(message.Nonce), Components = Optional.Conditional(message.Components.Count != 0, x => x.Select(x => x.ToModel()).ToArray(), message.Components), StickerIds = Optional.Conditional(message.StickerIds.Count != 0, x => x.ToArray(), message.StickerIds) }; Task <MessageJsonModel> task; if (message.Attachments.Count != 0) { // If there are attachments, we must send them via multipart HTTP content. // Our `messageContent` will be serialized into a "payload_json" form data field. var content = new MultipartJsonPayloadRestRequestContent <CreateMessageJsonRestRequestContent>(messageContent, message.Attachments); task = client.ApiClient.CreateMessageAsync(channelId, content, options, cancellationToken); } else { task = client.ApiClient.CreateMessageAsync(channelId, messageContent, options, cancellationToken); } var model = await task.ConfigureAwait(false); return(new TransientUserMessage(client, model)); }