/// <inheritdoc/>
public Task <EventResponseResult> RespondAsync(IGuildMembersChunk gatewayEvent, CancellationToken ct = default)
{
foreach (var member in gatewayEvent.Members)
{
if (!member.User.HasValue)
{
continue;
}
var key = KeyHelpers.CreateGuildMemberKey(gatewayEvent.GuildID, member.User.Value !.ID);
_cacheService.Cache(key, member);
}
if (!gatewayEvent.Presences.HasValue)
{
return(Task.FromResult(EventResponseResult.FromSuccess()));
}
foreach (var presence in gatewayEvent.Presences.Value !)
{
if (!presence.User.ID.HasValue)
{
continue;
}
var key = KeyHelpers.CreatePresenceCacheKey(gatewayEvent.GuildID, presence.User.ID.Value);
_cacheService.Cache(key, presence);
}
return(Task.FromResult(EventResponseResult.FromSuccess()));
}
/// <inheritdoc/>
public Task <EventResponseResult> RespondAsync(IChannelUpdate gatewayEvent, CancellationToken ct = default)
{
var key = KeyHelpers.CreateChannelCacheKey(gatewayEvent.ID);
_cacheService.Cache <IChannel>(key, gatewayEvent);
return(Task.FromResult(EventResponseResult.FromSuccess()));
}
/// <inheritdoc/>
public Task <EventResponseResult> RespondAsync(IGuildMemberRemove gatewayEvent, CancellationToken ct = default)
{
var key = KeyHelpers.CreateGuildMemberKey(gatewayEvent.GuildID, gatewayEvent.User.ID);
_cacheService.Evict(key);
return(Task.FromResult(EventResponseResult.FromSuccess()));
}
/// <inheritdoc/>
public Task <EventResponseResult> RespondAsync(IGuildBanAdd gatewayEvent, CancellationToken ct = default)
{
var key = KeyHelpers.CreateGuildBanCacheKey(gatewayEvent.GuildID, gatewayEvent.User.ID);
_cacheService.Cache <IBan>(key, new Ban(null, gatewayEvent.User));
return(Task.FromResult(EventResponseResult.FromSuccess()));
}
/// <inheritdoc/>
public async Task <EventResponseResult> RespondAsync(IMessageCreate gatewayEvent, CancellationToken ct = default)
{
if (!gatewayEvent.Content.StartsWith('!'))
{
return(EventResponseResult.FromSuccess());
}
var statusCode = gatewayEvent.Content[1..];
/// <inheritdoc/>
public async Task <EventResponseResult> RespondAsync
(
IUnknownEvent?gatewayEvent,
CancellationToken ct = default
)
{
if (gatewayEvent is null)
{
return(EventResponseResult.FromSuccess());
}
using var jsonDocument = JsonDocument.Parse(gatewayEvent.Data);
if (!jsonDocument.RootElement.TryGetProperty("t", out var eventTypeElement))
{
_log.LogWarning("Failed to find an event type on the given unknown event");
return(EventResponseResult.FromSuccess());
}
if (!jsonDocument.RootElement.TryGetProperty("s", out var eventSequenceElement))
{
_log.LogWarning("Failed to find an event sequence on the given unknown event");
return(EventResponseResult.FromSuccess());
}
var eventType = eventTypeElement.GetString();
if (eventType is null)
{
return(EventResponseResult.FromError("The event type was null."));
}
var sequenceNumber = eventSequenceElement.GetInt64();
var logTime = $"{DateTime.UtcNow:u}";
_log.LogInformation("Received an event of type \"{EventType}\"", eventType);
var eventDirectory = Path.GetFullPath(eventType.ToUpperInvariant());
if (!Directory.Exists(eventDirectory))
{
Directory.CreateDirectory(eventDirectory);
}
var filename = $"{logTime}.{sequenceNumber}.json";
var filePath = Path.Combine(eventDirectory, filename);
await using var file = File.OpenWrite(filePath);
await using var jsonWriter = new Utf8JsonWriter(file, new JsonWriterOptions
{
Indented = true
});
jsonDocument.WriteTo(jsonWriter);
return(EventResponseResult.FromSuccess());
}
private async Task <EventResponseResult> ReplyWithFailureAsync(Snowflake channel)
{
var failEmbed = new Embed(Description: "Dice rolling failed :(", Colour: Color.OrangeRed);
var replyFail = await _channelAPI.CreateMessageAsync(channel, embed : failEmbed);
return(!replyFail.IsSuccess
? EventResponseResult.FromError(replyFail)
: EventResponseResult.FromSuccess());
}
private async Task <EventResponseResult> ExecuteCommandAsync
(
string content,
ICommandContext commandContext,
CancellationToken ct = default
)
{
// Strip off the prefix
if (_options.Prefix is not null)
{
content = content.Substring
(
content.IndexOf(_options.Prefix, StringComparison.Ordinal) + _options.Prefix.Length
);
}
var additionalParameters = new object[] { commandContext };
// Run any user-provided pre execution events
var preExecution = await _eventCollector.RunPreExecutionEvents(commandContext, ct);
if (!preExecution.IsSuccess)
{
return(EventResponseResult.FromError(preExecution));
}
// Run the actual command
var executeResult = await _commandService.TryExecuteAsync
(
content,
_services,
additionalParameters,
ct : ct
);
if (!executeResult.IsSuccess)
{
return(EventResponseResult.FromError(executeResult));
}
// Run any user-provided post execution events
var postExecution = await _eventCollector.RunPostExecutionEvents
(
commandContext,
executeResult.InnerResult !,
ct
);
if (!postExecution.IsSuccess)
{
return(EventResponseResult.FromError(postExecution));
}
return(EventResponseResult.FromSuccess());
}
/// <inheritdoc/>
public Task <EventResponseResult> RespondAsync(IChannelDelete?gatewayEvent, CancellationToken ct = default)
{
if (gatewayEvent is null)
{
return(Task.FromResult(EventResponseResult.FromSuccess()));
}
var key = KeyHelpers.CreateChannelCacheKey(gatewayEvent.ID);
_cacheService.Evict(key);
return(Task.FromResult(EventResponseResult.FromSuccess()));
}
/// <inheritdoc/>
public Task <EventResponseResult> RespondAsync(IGuildCreate?gatewayEvent, CancellationToken ct = default)
{
if (gatewayEvent is null)
{
return(Task.FromResult(EventResponseResult.FromSuccess()));
}
var key = KeyHelpers.CreateGuildCacheKey(gatewayEvent.ID);
_cacheService.Cache <IGuild>(key, gatewayEvent);
return(Task.FromResult(EventResponseResult.FromSuccess()));
}
/// <inheritdoc/>
public Task <EventResponseResult> RespondAsync(IGuildMemberAdd gatewayEvent, CancellationToken ct = default)
{
if (!gatewayEvent.User.HasValue)
{
return(Task.FromResult(EventResponseResult.FromSuccess()));
}
var key = KeyHelpers.CreateGuildMemberKey(gatewayEvent.GuildID, gatewayEvent.User.Value !.ID);
_cacheService.Cache <IGuildMember>(key, gatewayEvent);
return(Task.FromResult(EventResponseResult.FromSuccess()));
}
/// <inheritdoc/>
public async Task <EventResponseResult> RespondAsync
(
IMessageUpdate?gatewayEvent,
CancellationToken ct = default
)
{
if (gatewayEvent is null)
{
return(EventResponseResult.FromSuccess());
}
if (!gatewayEvent.Content.HasValue)
{
return(EventResponseResult.FromSuccess());
}
if (_options.Prefix is not null)
{
if (!gatewayEvent.Content.Value !.StartsWith(_options.Prefix))
{
return(EventResponseResult.FromSuccess());
}
}
if (!gatewayEvent.Author.HasValue)
{
return(EventResponseResult.FromSuccess());
}
var author = gatewayEvent.Author.Value !;
if (author.IsBot.HasValue && author.IsBot.Value)
{
return(EventResponseResult.FromSuccess());
}
if (author.IsSystem.HasValue && author.IsSystem.Value)
{
return(EventResponseResult.FromSuccess());
}
var context = new MessageContext
(
gatewayEvent.ChannelID.Value,
author,
gatewayEvent.ID.Value,
gatewayEvent
);
return(await ExecuteCommandAsync(gatewayEvent.Content.Value !, context, ct));
}
/// <inheritdoc/>
public Task <EventResponseResult> RespondAsync(IGuildEmojisUpdate gatewayEvent, CancellationToken ct = default)
{
foreach (var emoji in gatewayEvent.Emojis)
{
if (emoji.ID is null)
{
continue;
}
var key = KeyHelpers.CreateEmojiCacheKey(gatewayEvent.GuildID, emoji.ID.Value);
_cacheService.Cache(key, emoji);
}
return(Task.FromResult(EventResponseResult.FromSuccess()));
}
public async Task <IResult> PostHttpCatAsync([Description("The HTTP code.")] int httpCode)
{
var embedImage = new EmbedImage($"https://http.cat/{httpCode}");
var embed = new Embed(Image: embedImage);
var reply = await _channelAPI.CreateMessageAsync
(
_context.ChannelID,
embed : embed,
ct : this.CancellationToken
);
return(!reply.IsSuccess
? EventResponseResult.FromError(reply)
: EventResponseResult.FromSuccess());
}
/// <inheritdoc />
public async Task <EventResponseResult> RespondAsync(IMessageCreate gatewayEvent, CancellationToken ct = default)
{
if ((gatewayEvent.Author.IsBot.HasValue && gatewayEvent.Author.IsBot.Value) ||
(gatewayEvent.Author.IsSystem.HasValue && gatewayEvent.Author.IsSystem.Value))
{
return(EventResponseResult.FromSuccess());
}
var replyResult = await _channelAPI.CreateMessageAsync
(
gatewayEvent.ChannelID,
gatewayEvent.Content,
ct : ct
);
return(replyResult.IsSuccess
? EventResponseResult.FromSuccess()
: EventResponseResult.FromError(replyResult));
}
private async Task <EventResponseResult> ReplyWithRollsAsync(Snowflake channel, RollResponse rollResponse)
{
var rolls = rollResponse.Dice
.GroupBy(d => d.Type)
.ToDictionary
(
g => g.Key,
g => g.Select(d => d.Value).Aggregate((a, b) => a + b)
);
var fields = rolls.Select(kvp => new EmbedField(kvp.Key, kvp.Value.ToString(), true)).ToList();
var embed = new Embed("Rolls", Fields: fields, Colour: Color.LawnGreen);
var replyRolls = await _channelAPI.CreateMessageAsync(channel, embed : embed);
return(!replyRolls.IsSuccess
? EventResponseResult.FromError(replyRolls)
: EventResponseResult.FromSuccess());
}
/// <inheritdoc/>
public Task <EventResponseResult> RespondAsync(IGuildMemberUpdate?gatewayEvent, CancellationToken ct = default)
{
if (gatewayEvent is null)
{
return(Task.FromResult(EventResponseResult.FromSuccess()));
}
var key = KeyHelpers.CreateGuildMemberKey(gatewayEvent.GuildID, gatewayEvent.User.ID);
// Since this event isn't playing nice, we'll have to update by creating an object of our own.
if (!_cacheService.TryGetValue <IGuildMember>(key, out var cachedInstance))
{
cachedInstance = new GuildMember
(
new Optional <IUser>(gatewayEvent.User),
gatewayEvent.Nickname,
gatewayEvent.Roles,
gatewayEvent.JoinedAt,
gatewayEvent.PremiumSince,
false,
false,
public async Task <IResult> RollDiceAsync(string value)
{
var rollRequests = value.Split(' ', StringSplitOptions.RemoveEmptyEntries);
if (rollRequests.Length == 0)
{
return(EventResponseResult.FromSuccess());
}
var getRolls = await GetRollsAsync(rollRequests);
if (!getRolls.IsSuccess)
{
var replyWithFailure = await ReplyWithFailureAsync(_context.ChannelID);
return(replyWithFailure.IsSuccess
? EventResponseResult.FromError(getRolls)
: replyWithFailure);
}
var rollResponse = getRolls.Entity;
return(await ReplyWithRollsAsync(_context.ChannelID, rollResponse));
}
/// <inheritdoc />
public Task <EventResponseResult> RespondAsync(IMessageCreate?gatewayEvent, CancellationToken ct = default)
{
return(Task.FromResult(EventResponseResult.FromSuccess()));
}
/// <inheritdoc/>
public async Task <EventResponseResult> RespondAsync
(
IMessageCreate?gatewayEvent,
CancellationToken ct = default
)
{
if (gatewayEvent is null)
{
return(EventResponseResult.FromSuccess());
}
if (_options.Prefix is not null)
{
if (!gatewayEvent.Content.StartsWith(_options.Prefix))
{
return(EventResponseResult.FromSuccess());
}
}
var author = gatewayEvent.Author;
if (author.IsBot.HasValue && author.IsBot.Value)
{
return(EventResponseResult.FromSuccess());
}
if (author.IsSystem.HasValue && author.IsSystem.Value)
{
return(EventResponseResult.FromSuccess());
}
var context = new MessageContext
(
gatewayEvent.ChannelID,
author,
gatewayEvent.ID,
new PartialMessage
(
gatewayEvent.ID,
gatewayEvent.ChannelID,
gatewayEvent.GuildID,
new Optional <IUser>(gatewayEvent.Author),
gatewayEvent.Member,
gatewayEvent.Content,
gatewayEvent.Timestamp,
gatewayEvent.EditedTimestamp,
gatewayEvent.IsTTS,
gatewayEvent.MentionsEveryone,
new Optional <IReadOnlyList <IUserMention> >(gatewayEvent.Mentions),
new Optional <IReadOnlyList <Snowflake> >(gatewayEvent.MentionedRoles),
gatewayEvent.MentionedChannels,
new Optional <IReadOnlyList <IAttachment> >(gatewayEvent.Attachments),
new Optional <IReadOnlyList <IEmbed> >(gatewayEvent.Embeds),
gatewayEvent.Reactions,
gatewayEvent.Nonce,
gatewayEvent.IsPinned,
gatewayEvent.WebhookID,
gatewayEvent.Type,
gatewayEvent.Activity,
gatewayEvent.Application,
gatewayEvent.MessageReference,
gatewayEvent.Flags
)
);
return(await ExecuteCommandAsync(gatewayEvent.Content, context, ct));
}
/// <inheritdoc />
public async Task <EventResponseResult> RespondAsync
(
IInteractionCreate?gatewayEvent,
CancellationToken ct = default
)
{
if (gatewayEvent is null)
{
return(EventResponseResult.FromSuccess());
}
if (!gatewayEvent.Data.HasValue)
{
return(EventResponseResult.FromSuccess());
}
if (!gatewayEvent.Member.User.HasValue)
{
return(EventResponseResult.FromSuccess());
}
// Signal Discord that we'll be handling this one asynchronously
var response = new InteractionResponse(InteractionResponseType.Acknowledge, default);
var interactionResponse = await _interactionAPI.CreateInteractionResponseAsync
(
gatewayEvent.ID,
gatewayEvent.Token,
response,
ct
);
if (!interactionResponse.IsSuccess)
{
return(EventResponseResult.FromError(interactionResponse));
}
var interactionData = gatewayEvent.Data.Value !;
interactionData.UnpackInteraction(out var command, out var parameters);
var context = new InteractionContext
(
gatewayEvent.ChannelID,
gatewayEvent.Member.User.Value !,
gatewayEvent.Member,
gatewayEvent.Token,
gatewayEvent.ID,
gatewayEvent.GuildID
);
// Run any user-provided pre execution events
var preExecution = await _eventCollector.RunPreExecutionEvents(context, ct);
if (!preExecution.IsSuccess)
{
return(EventResponseResult.FromError(preExecution));
}
// Run the actual command
var searchOptions = new TreeSearchOptions(StringComparison.OrdinalIgnoreCase);
var executeResult = await _commandService.TryExecuteAsync
(
command,
parameters,
_services,
new object[] { context },
searchOptions,
ct
);
if (!executeResult.IsSuccess)
{
return(EventResponseResult.FromError(executeResult));
}
// Run any user-provided post execution events
var postExecution = await _eventCollector.RunPostExecutionEvents
(
context,
executeResult.InnerResult !,
ct
);
if (!postExecution.IsSuccess)
{
return(EventResponseResult.FromError(postExecution));
}
return(EventResponseResult.FromSuccess());
}
