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));
}
