/// <inheritdoc />
public virtual async Task <ICreateRestEntityResult <IGuild> > CreateGuildFromTemplateAsync
(
string templateCode,
string name,
Optional <Stream> icon = default,
CancellationToken ct = default
)
{
var packIcon = await ImagePacker.PackImageAsync(new Optional <Stream?>(icon.Value), ct);
if (!packIcon.IsSuccess)
{
return(CreateRestEntityResult <IGuild> .FromError(packIcon));
}
var iconData = packIcon.Entity;
return(await _discordHttpClient.PostAsync <IGuild>
(
$"guilds/templates/{templateCode}",
b => b.WithJson
(
j =>
{
j.WriteString("name", name);
j.Write("icon", iconData);
}
),
ct : ct
));
}
/// <inheritdoc />
public virtual async Task <ICreateRestEntityResult <IGuild> > CreateGuildAsync
(
string name,
Optional <string> region = default,
Optional <Stream> icon = default,
Optional <VerificationLevel> verificationLevel = default,
Optional <MessageNotificationLevel> defaultMessageNotifications = default,
Optional <ExplicitContentFilterLevel> explicitContentFilter = default,
Optional <IReadOnlyList <IRole> > roles = default,
Optional <IReadOnlyList <IPartialChannel> > channels = default,
Optional <Snowflake> afkChannelID = default,
Optional <TimeSpan> afkTimeout = default,
Optional <Snowflake> systemChannelID = default,
CancellationToken ct = default
)
{
if (name.Length < 2 || name.Length > 100)
{
return(CreateRestEntityResult <IGuild> .FromError("The name must be between 2 and 100 characters."));
}
await using var memoryStream = new MemoryStream();
var packIcon = await ImagePacker.PackImageAsync(new Optional <Stream?>(icon.Value), ct);
if (!packIcon.IsSuccess)
{
return(CreateRestEntityResult <IGuild> .FromError(packIcon));
}
var iconData = packIcon.Entity;
return(await _discordHttpClient.PostAsync <IGuild>
(
"guilds",
b => b.WithJson
(
json =>
{
json.WriteString("name", name);
json.Write("region", region, _jsonOptions);
json.Write("icon", iconData, _jsonOptions);
json.Write("verification_level", verificationLevel, _jsonOptions);
json.Write("default_message_notifications", defaultMessageNotifications, _jsonOptions);
json.Write("explicit_content_filter", explicitContentFilter, _jsonOptions);
json.Write("roles", roles, _jsonOptions);
json.Write("channels", channels, _jsonOptions);
json.Write("afk_channel_id", afkChannelID, _jsonOptions);
if (afkTimeout.HasValue)
{
json.WriteNumber("afk_timeout", (ulong)afkTimeout.Value.TotalSeconds);
}
json.Write("system_channel_id", systemChannelID, _jsonOptions);
}
),
ct : ct
));
}
/// <inheritdoc />
public virtual async Task <ICreateRestEntityResult <IWebhook> > CreateWebhookAsync
(
Snowflake channelID,
string name,
Stream?avatar,
CancellationToken ct = default
)
{
if (name.Length < 1 || name.Length > 80)
{
return(CreateRestEntityResult <IWebhook> .FromError("Names must be between 1 and 80 characters"));
}
if (name.Equals("clyde", StringComparison.InvariantCultureIgnoreCase))
{
return(CreateRestEntityResult <IWebhook> .FromError("Names cannot be \"clyde\"."));
}
var packAvatar = await ImagePacker.PackImageAsync(new Optional <Stream?>(avatar), ct);
if (!packAvatar.IsSuccess)
{
return(CreateRestEntityResult <IWebhook> .FromError(packAvatar));
}
var avatarData = packAvatar.Entity;
return(await _discordHttpClient.PostAsync <IWebhook>
(
$"channels/{channelID}/webhooks",
b => b.WithJson
(
json =>
{
json.WriteString("name", name);
json.WriteString("avatar", avatarData.Value);
}
),
ct : ct
));
}
/// <inheritdoc />
public async Task <ICreateRestEntityResult <IApplicationCommand> > CreateGuildApplicationCommandAsync
(
Snowflake applicationID,
Snowflake guildID,
string name,
string description,
Optional <IReadOnlyList <IApplicationCommandOption> > options,
CancellationToken ct
)
{
if (name.Length is < 3 or > 32)
{
return(CreateRestEntityResult <IApplicationCommand> .FromError
(
"The name must be between 3 and 32 characters."
));
}
if (description.Length is < 1 or > 100)
{
return(CreateRestEntityResult <IApplicationCommand> .FromError
(
"The description must be between 1 and 100 characters."
));
}
return(await _discordHttpClient.PostAsync <IApplicationCommand>
(
$"applications/{applicationID}/guilds/{guildID}/commands",
b => b.WithJson
(
json =>
{
json.WriteString("name", name);
json.WriteString("description", description);
json.Write("options", options, _jsonOptions);
}
),
ct : ct
));
}
/// <inheritdoc />
public virtual async Task <ICreateRestEntityResult <IEmoji> > CreateGuildEmojiAsync
(
Snowflake guildID,
string name,
Stream image,
IReadOnlyList <Snowflake> roles,
CancellationToken ct = default
)
{
if (image.Length > 256000)
{
return(CreateRestEntityResult <IEmoji> .FromError("Image too large."));
}
var packImage = await ImagePacker.PackImageAsync(image, ct);
if (!packImage.IsSuccess)
{
return(CreateRestEntityResult <IEmoji> .FromError(packImage));
}
var emojiData = packImage.Entity;
return(await _discordHttpClient.PostAsync <IEmoji>
(
$"guilds/{guildID}/emojis",
b => b.WithJson
(
json =>
{
json.WriteString("name", name);
json.WriteString("image", emojiData);
json.WritePropertyName("roles");
JsonSerializer.Serialize(json, roles, _jsonOptions);
}
),
ct : ct
));
}
/// <summary>
/// Performs a PUT request to the Discord REST API at the given endpoint.
/// </summary>
/// <param name="endpoint">The endpoint.</param>
/// <param name="configureRequestBuilder">The request builder for the request.</param>
/// <param name="allowNullReturn">Whether to allow null return values inside the creation result.</param>
/// <param name="ct">The cancellation token for this operation.</param>
/// <typeparam name="TEntity">The type of entity to create.</typeparam>
/// <returns>A result which may or may not have succeeded.</returns>
public async Task <ICreateRestEntityResult <TEntity> > PutAsync <TEntity>
(
string endpoint,
Action <RestRequestBuilder>?configureRequestBuilder = null,
bool allowNullReturn = false,
CancellationToken ct = default
)
{
configureRequestBuilder ??= _ => { };
var requestBuilder = new RestRequestBuilder(endpoint);
configureRequestBuilder(requestBuilder);
requestBuilder.WithMethod(HttpMethod.Put);
try
{
using var request = requestBuilder.Build();
using var response = await _httpClient.SendAsync
(
request,
HttpCompletionOption.ResponseHeadersRead,
ct
);
var entityResult = await UnpackResponseAsync <TEntity>(response, allowNullReturn, ct);
return(!entityResult.IsSuccess
? CreateRestEntityResult <TEntity> .FromError(entityResult)
: CreateRestEntityResult <TEntity> .FromSuccess(entityResult.Entity));
}
catch (Exception e)
{
return(CreateRestEntityResult <TEntity> .FromError(e));
}
}
