sam/Catalogger.NET
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

chore: format with csharpier

Browse source
This commit is contained in:
sam 2024-10-09 17:35:11 +02:00
parent 2f516dcb73
commit 4f54077c68
59 changed files with 2000 additions and 942 deletions
Download patch file Download diff file Expand all files Collapse all files

512
Catalogger.Backend/Bot/Commands/ChannelCommands.cs
View file

@ -30,7 +30,8 @@ public class ChannelCommands(
ChannelCache channelCache,
IFeedbackService feedbackService,
ContextInjectionService contextInjection,
InMemoryDataService<Snowflake, ChannelCommandData> dataService) : CommandGroup
InMemoryDataService<Snowflake, ChannelCommandData> dataService
) : CommandGroup
{
private readonly ILogger _logger = logger.ForContext<ChannelCommands>();
@ -40,22 +41,30 @@ public class ChannelCommands(
public async Task<IResult> ConfigureChannelsAsync()
{
var (userId, guildId) = contextInjection.GetUserAndGuild();
if (!guildCache.TryGet(guildId, out var guild)) throw new CataloggerError("Guild not in cache");
if (!guildCache.TryGet(guildId, out var guild))
throw new CataloggerError("Guild not in cache");
var guildChannels = channelCache.GuildChannels(guildId).ToList();
var guildConfig = await db.GetGuildAsync(guildId);
var (embeds, components) = BuildRootMenu(guildChannels, guild, guildConfig);
var msg = await feedbackService.SendContextualAsync(embeds: embeds,
options: new FeedbackMessageOptions(MessageComponents: components)).GetOrThrow();
var msg = await feedbackService
.SendContextualAsync(
embeds: embeds,
options: new FeedbackMessageOptions(MessageComponents: components)
)
.GetOrThrow();
dataService.TryAddData(msg.ID, new ChannelCommandData(userId, CurrentPage: null));
return Result.Success;
}
public static (List<IEmbed>, List<IMessageComponent>) BuildRootMenu(List<IChannel> guildChannels, IGuild guild,
DbGuild guildConfig)
public static (List<IEmbed>, List<IMessageComponent>) BuildRootMenu(
List<IChannel> guildChannels,
IGuild guild,
DbGuild guildConfig
)
{
List<IEmbed> embeds =
[
@ -65,158 +74,369 @@ public class ChannelCommands(
Colour: DiscordUtils.Purple,
Fields: new[]
{
new EmbedField("Server changes", PrettyChannelString(guildConfig.Channels.GuildUpdate), true),
new EmbedField("Emoji changes", PrettyChannelString(guildConfig.Channels.GuildEmojisUpdate), true),
new EmbedField("New roles", PrettyChannelString(guildConfig.Channels.GuildRoleCreate), true),
new EmbedField("Edited roles", PrettyChannelString(guildConfig.Channels.GuildRoleUpdate), true),
new EmbedField("Deleted roles", PrettyChannelString(guildConfig.Channels.GuildRoleDelete), true),
new EmbedField("New channels", PrettyChannelString(guildConfig.Channels.ChannelCreate), true),
new EmbedField("Edited channels", PrettyChannelString(guildConfig.Channels.ChannelUpdate), true),
new EmbedField("Deleted channels", PrettyChannelString(guildConfig.Channels.ChannelDelete), true),
new EmbedField("Members joining", PrettyChannelString(guildConfig.Channels.GuildMemberAdd), true),
new EmbedField("Members leaving", PrettyChannelString(guildConfig.Channels.GuildMemberRemove),
true),
new EmbedField("Member role changes", PrettyChannelString(guildConfig.Channels.GuildMemberUpdate),
true),
new EmbedField("Key role changes", PrettyChannelString(guildConfig.Channels.GuildKeyRoleUpdate),
true),
new EmbedField("Member name changes",
new EmbedField(
"Server changes",
PrettyChannelString(guildConfig.Channels.GuildUpdate),
true
),
new EmbedField(
"Emoji changes",
PrettyChannelString(guildConfig.Channels.GuildEmojisUpdate),
true
),
new EmbedField(
"New roles",
PrettyChannelString(guildConfig.Channels.GuildRoleCreate),
true
),
new EmbedField(
"Edited roles",
PrettyChannelString(guildConfig.Channels.GuildRoleUpdate),
true
),
new EmbedField(
"Deleted roles",
PrettyChannelString(guildConfig.Channels.GuildRoleDelete),
true
),
new EmbedField(
"New channels",
PrettyChannelString(guildConfig.Channels.ChannelCreate),
true
),
new EmbedField(
"Edited channels",
PrettyChannelString(guildConfig.Channels.ChannelUpdate),
true
),
new EmbedField(
"Deleted channels",
PrettyChannelString(guildConfig.Channels.ChannelDelete),
true
),
new EmbedField(
"Members joining",
PrettyChannelString(guildConfig.Channels.GuildMemberAdd),
true
),
new EmbedField(
"Members leaving",
PrettyChannelString(guildConfig.Channels.GuildMemberRemove),
true
),
new EmbedField(
"Member role changes",
PrettyChannelString(guildConfig.Channels.GuildMemberUpdate),
true
),
new EmbedField(
"Key role changes",
PrettyChannelString(guildConfig.Channels.GuildKeyRoleUpdate),
true
),
new EmbedField(
"Member name changes",
PrettyChannelString(guildConfig.Channels.GuildMemberNickUpdate),
true),
new EmbedField("Member avatar changes",
PrettyChannelString(guildConfig.Channels.GuildMemberAvatarUpdate), true),
new EmbedField("Kicks", PrettyChannelString(guildConfig.Channels.GuildMemberKick), true),
new EmbedField("Bans", PrettyChannelString(guildConfig.Channels.GuildBanAdd), true),
new EmbedField("Unbans", PrettyChannelString(guildConfig.Channels.GuildBanRemove), true),
new EmbedField("New invites", PrettyChannelString(guildConfig.Channels.InviteCreate), true),
new EmbedField("Deleted invites", PrettyChannelString(guildConfig.Channels.InviteDelete), true),
new EmbedField("Edited messages", PrettyChannelString(guildConfig.Channels.MessageUpdate), true),
new EmbedField("Deleted messages", PrettyChannelString(guildConfig.Channels.MessageDelete), true),
new EmbedField("Bulk deleted messages", PrettyChannelString(guildConfig.Channels.MessageDeleteBulk),
true),
})
true
),
new EmbedField(
"Member avatar changes",
PrettyChannelString(guildConfig.Channels.GuildMemberAvatarUpdate),
true
),
new EmbedField(
"Kicks",
PrettyChannelString(guildConfig.Channels.GuildMemberKick),
true
),
new EmbedField(
"Bans",
PrettyChannelString(guildConfig.Channels.GuildBanAdd),
true
),
new EmbedField(
"Unbans",
PrettyChannelString(guildConfig.Channels.GuildBanRemove),
true
),
new EmbedField(
"New invites",
PrettyChannelString(guildConfig.Channels.InviteCreate),
true
),
new EmbedField(
"Deleted invites",
PrettyChannelString(guildConfig.Channels.InviteDelete),
true
),
new EmbedField(
"Edited messages",
PrettyChannelString(guildConfig.Channels.MessageUpdate),
true
),
new EmbedField(
"Deleted messages",
PrettyChannelString(guildConfig.Channels.MessageDelete),
true
),
new EmbedField(
"Bulk deleted messages",
PrettyChannelString(guildConfig.Channels.MessageDeleteBulk),
true
),
}
),
];
List<IMessageComponent> components =
[
new ActionRowComponent([
new ButtonComponent(ButtonComponentStyle.Primary, Label: "Server changes",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels",
nameof(LogChannelType.GuildUpdate))),
new ButtonComponent(ButtonComponentStyle.Primary, Label: "Emoji changes",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels",
nameof(LogChannelType.GuildEmojisUpdate))),
new ButtonComponent(ButtonComponentStyle.Primary, Label: "New roles",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels",
nameof(LogChannelType.GuildRoleCreate))),
new ButtonComponent(ButtonComponentStyle.Primary, Label: "Edited roles",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels",
nameof(LogChannelType.GuildRoleUpdate))),
new ButtonComponent(ButtonComponentStyle.Primary, Label: "Deleted roles",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels",
nameof(LogChannelType.GuildRoleDelete))),
]),
new ActionRowComponent([
new ButtonComponent(ButtonComponentStyle.Primary, Label: "New channels",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels",
nameof(LogChannelType.ChannelCreate))),
new ButtonComponent(ButtonComponentStyle.Primary, Label: "Edited channels",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels",
nameof(LogChannelType.ChannelUpdate))),
new ButtonComponent(ButtonComponentStyle.Primary, Label: "Deleted channels",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels",
nameof(LogChannelType.ChannelDelete))),
new ButtonComponent(ButtonComponentStyle.Primary, Label: "Members joining",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels",
nameof(LogChannelType.GuildMemberAdd))),
new ButtonComponent(ButtonComponentStyle.Primary, Label: "Members leaving",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels",
nameof(LogChannelType.GuildMemberRemove))),
]),
new ActionRowComponent([
new ButtonComponent(ButtonComponentStyle.Primary, Label: "Member role changes",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels",
nameof(LogChannelType.GuildMemberUpdate))),
new ButtonComponent(ButtonComponentStyle.Primary, Label: "Key role changes",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels",
nameof(LogChannelType.GuildKeyRoleUpdate))),
new ButtonComponent(ButtonComponentStyle.Primary, Label: "Member name changes",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels",
nameof(LogChannelType.GuildMemberNickUpdate))),
new ButtonComponent(ButtonComponentStyle.Primary, Label: "Members avatar changes",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels",
nameof(LogChannelType.GuildMemberAvatarUpdate))),
new ButtonComponent(ButtonComponentStyle.Primary, Label: "Kicks",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels",
nameof(LogChannelType.GuildMemberKick))),
]),
new ActionRowComponent([
new ButtonComponent(ButtonComponentStyle.Primary, Label: "Bans",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels",
nameof(LogChannelType.GuildBanAdd))),
new ButtonComponent(ButtonComponentStyle.Primary, Label: "Unbans",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels",
nameof(LogChannelType.GuildBanRemove))),
new ButtonComponent(ButtonComponentStyle.Primary, Label: "New invites",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels",
nameof(LogChannelType.InviteCreate))),
new ButtonComponent(ButtonComponentStyle.Primary, Label: "Deleted invites",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels",
nameof(LogChannelType.InviteDelete))),
new ButtonComponent(ButtonComponentStyle.Primary, Label: "Edited messages",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels",
nameof(LogChannelType.MessageUpdate))),
]),
new ActionRowComponent([
new ButtonComponent(ButtonComponentStyle.Primary, Label: "Deleted messages",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels",
nameof(LogChannelType.MessageDelete))),
new ButtonComponent(ButtonComponentStyle.Primary, Label: "Bulk deleted messages",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels",
nameof(LogChannelType.MessageDeleteBulk))),
new ButtonComponent(ButtonComponentStyle.Secondary, Label: "Close",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels", "close")),
]),
new ActionRowComponent(
[
new ButtonComponent(
ButtonComponentStyle.Primary,
Label: "Server changes",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
nameof(LogChannelType.GuildUpdate)
)
),
new ButtonComponent(
ButtonComponentStyle.Primary,
Label: "Emoji changes",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
nameof(LogChannelType.GuildEmojisUpdate)
)
),
new ButtonComponent(
ButtonComponentStyle.Primary,
Label: "New roles",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
nameof(LogChannelType.GuildRoleCreate)
)
),
new ButtonComponent(
ButtonComponentStyle.Primary,
Label: "Edited roles",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
nameof(LogChannelType.GuildRoleUpdate)
)
),
new ButtonComponent(
ButtonComponentStyle.Primary,
Label: "Deleted roles",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
nameof(LogChannelType.GuildRoleDelete)
)
),
]
),
new ActionRowComponent(
[
new ButtonComponent(
ButtonComponentStyle.Primary,
Label: "New channels",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
nameof(LogChannelType.ChannelCreate)
)
),
new ButtonComponent(
ButtonComponentStyle.Primary,
Label: "Edited channels",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
nameof(LogChannelType.ChannelUpdate)
)
),
new ButtonComponent(
ButtonComponentStyle.Primary,
Label: "Deleted channels",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
nameof(LogChannelType.ChannelDelete)
)
),
new ButtonComponent(
ButtonComponentStyle.Primary,
Label: "Members joining",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
nameof(LogChannelType.GuildMemberAdd)
)
),
new ButtonComponent(
ButtonComponentStyle.Primary,
Label: "Members leaving",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
nameof(LogChannelType.GuildMemberRemove)
)
),
]
),
new ActionRowComponent(
[
new ButtonComponent(
ButtonComponentStyle.Primary,
Label: "Member role changes",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
nameof(LogChannelType.GuildMemberUpdate)
)
),
new ButtonComponent(
ButtonComponentStyle.Primary,
Label: "Key role changes",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
nameof(LogChannelType.GuildKeyRoleUpdate)
)
),
new ButtonComponent(
ButtonComponentStyle.Primary,
Label: "Member name changes",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
nameof(LogChannelType.GuildMemberNickUpdate)
)
),
new ButtonComponent(
ButtonComponentStyle.Primary,
Label: "Members avatar changes",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
nameof(LogChannelType.GuildMemberAvatarUpdate)
)
),
new ButtonComponent(
ButtonComponentStyle.Primary,
Label: "Kicks",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
nameof(LogChannelType.GuildMemberKick)
)
),
]
),
new ActionRowComponent(
[
new ButtonComponent(
ButtonComponentStyle.Primary,
Label: "Bans",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
nameof(LogChannelType.GuildBanAdd)
)
),
new ButtonComponent(
ButtonComponentStyle.Primary,
Label: "Unbans",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
nameof(LogChannelType.GuildBanRemove)
)
),
new ButtonComponent(
ButtonComponentStyle.Primary,
Label: "New invites",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
nameof(LogChannelType.InviteCreate)
)
),
new ButtonComponent(
ButtonComponentStyle.Primary,
Label: "Deleted invites",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
nameof(LogChannelType.InviteDelete)
)
),
new ButtonComponent(
ButtonComponentStyle.Primary,
Label: "Edited messages",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
nameof(LogChannelType.MessageUpdate)
)
),
]
),
new ActionRowComponent(
[
new ButtonComponent(
ButtonComponentStyle.Primary,
Label: "Deleted messages",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
nameof(LogChannelType.MessageDelete)
)
),
new ButtonComponent(
ButtonComponentStyle.Primary,
Label: "Bulk deleted messages",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
nameof(LogChannelType.MessageDeleteBulk)
)
),
new ButtonComponent(
ButtonComponentStyle.Secondary,
Label: "Close",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
"close"
)
),
]
),
];
return (embeds, components);
string PrettyChannelString(ulong id)
{
if (id == 0) return "Not set";
if (guildChannels.All(c => c.ID != id)) return $"unknown channel {id}";
if (id == 0)
return "Not set";
if (guildChannels.All(c => c.ID != id))
return $"unknown channel {id}";
return $"<#{id}>";
}
}
public static string PrettyLogTypeName(LogChannelType type) => type switch
{
LogChannelType.GuildUpdate => "Server changes",
LogChannelType.GuildEmojisUpdate => "Emoji changes",
LogChannelType.GuildRoleCreate => "New roles",
LogChannelType.GuildRoleUpdate => "Edited roles",
LogChannelType.GuildRoleDelete => "Deleted roles",
LogChannelType.ChannelCreate => "New channels",
LogChannelType.ChannelUpdate => "Edited channels",
LogChannelType.ChannelDelete => "Deleted channels",
LogChannelType.GuildMemberAdd => "Members joining",
LogChannelType.GuildMemberUpdate => "Members leaving",
LogChannelType.GuildKeyRoleUpdate => "Key role changes",
LogChannelType.GuildMemberNickUpdate => "Member name changes",
LogChannelType.GuildMemberAvatarUpdate => "Member avatar changes",
LogChannelType.GuildMemberRemove => "Members leaving",
LogChannelType.GuildMemberKick => "Kicks",
LogChannelType.GuildBanAdd => "Bans",
LogChannelType.GuildBanRemove => "Unbans",
LogChannelType.InviteCreate => "New invites",
LogChannelType.InviteDelete => "Deleted invites",
LogChannelType.MessageUpdate => "Edited messages",
LogChannelType.MessageDelete => "Deleted messages",
LogChannelType.MessageDeleteBulk => "Bulk deleted messages",
_ => throw new ArgumentOutOfRangeException(nameof(type), type, "Invalid LogChannelType value")
};
}
public static string PrettyLogTypeName(LogChannelType type) =>
type switch
{
LogChannelType.GuildUpdate => "Server changes",
LogChannelType.GuildEmojisUpdate => "Emoji changes",
LogChannelType.GuildRoleCreate => "New roles",
LogChannelType.GuildRoleUpdate => "Edited roles",
LogChannelType.GuildRoleDelete => "Deleted roles",
LogChannelType.ChannelCreate => "New channels",
LogChannelType.ChannelUpdate => "Edited channels",
LogChannelType.ChannelDelete => "Deleted channels",
LogChannelType.GuildMemberAdd => "Members joining",
LogChannelType.GuildMemberUpdate => "Members leaving",
LogChannelType.GuildKeyRoleUpdate => "Key role changes",
LogChannelType.GuildMemberNickUpdate => "Member name changes",
LogChannelType.GuildMemberAvatarUpdate => "Member avatar changes",
LogChannelType.GuildMemberRemove => "Members leaving",
LogChannelType.GuildMemberKick => "Kicks",
LogChannelType.GuildBanAdd => "Bans",
LogChannelType.GuildBanRemove => "Unbans",
LogChannelType.InviteCreate => "New invites",
LogChannelType.InviteDelete => "Deleted invites",
LogChannelType.MessageUpdate => "Edited messages",
LogChannelType.MessageDelete => "Deleted messages",
LogChannelType.MessageDeleteBulk => "Bulk deleted messages",
_ => throw new ArgumentOutOfRangeException(
nameof(type),
type,
"Invalid LogChannelType value"
),
};
}

194
Catalogger.Backend/Bot/Commands/ChannelCommandsComponents.cs
View file

@ -27,7 +27,8 @@ public class ChannelCommandsComponents(
ContextInjectionService contextInjection,
IFeedbackService feedbackService,
IDiscordRestInteractionAPI interactionApi,
InMemoryDataService<Snowflake, ChannelCommandData> dataService) : InteractionGroup
InMemoryDataService<Snowflake, ChannelCommandData> dataService
) : InteractionGroup
{
private readonly ILogger _logger = logger.ForContext<ChannelCommandsComponents>();
@ -35,11 +36,16 @@ public class ChannelCommandsComponents(
[SuppressInteractionResponse(true)]
public async Task<Result> OnButtonPressedAsync(string state)
{
if (contextInjection.Context is not IInteractionCommandContext ctx) throw new CataloggerError("No context");
if (!ctx.TryGetUserID(out var userId)) throw new CataloggerError("No user ID in context");
if (!ctx.Interaction.Message.TryGet(out var msg)) throw new CataloggerError("No message ID in context");
if (!ctx.TryGetGuildID(out var guildId)) throw new CataloggerError("No guild ID in context");
if (!guildCache.TryGet(guildId, out var guild)) throw new CataloggerError("Guild not in cache");
if (contextInjection.Context is not IInteractionCommandContext ctx)
throw new CataloggerError("No context");
if (!ctx.TryGetUserID(out var userId))
throw new CataloggerError("No user ID in context");
if (!ctx.Interaction.Message.TryGet(out var msg))
throw new CataloggerError("No message ID in context");
if (!ctx.TryGetGuildID(out var guildId))
throw new CataloggerError("No guild ID in context");
if (!guildCache.TryGet(guildId, out var guild))
throw new CataloggerError("Guild not in cache");
var guildChannels = channelCache.GuildChannels(guildId).ToList();
var guildConfig = await db.GetGuildAsync(guildId);
@ -47,20 +53,27 @@ public class ChannelCommandsComponents(
await using var lease = result.GetOrThrow();
if (lease.Data.UserId != userId)
{
return (Result)await feedbackService.SendContextualAsync("This is not your configuration menu.",
options: new FeedbackMessageOptions(MessageFlags: MessageFlags.Ephemeral));
return (Result)
await feedbackService.SendContextualAsync(
"This is not your configuration menu.",
options: new FeedbackMessageOptions(MessageFlags: MessageFlags.Ephemeral)
);
}
switch (state)
{
case "close":
return await interactionApi.UpdateMessageAsync(ctx.Interaction,
new InteractionMessageCallbackData(Components: Array.Empty<IMessageComponent>()));
return await interactionApi.UpdateMessageAsync(
ctx.Interaction,
new InteractionMessageCallbackData(Components: Array.Empty<IMessageComponent>())
);
case "reset":
if (lease.Data.CurrentPage == null)
throw new CataloggerError("CurrentPage was null in reset button callback");
if (!Enum.TryParse<LogChannelType>(lease.Data.CurrentPage, out var channelType))
throw new CataloggerError($"Invalid config-channels CurrentPage: '{lease.Data.CurrentPage}'");
throw new CataloggerError(
$"Invalid config-channels CurrentPage: '{lease.Data.CurrentPage}'"
);
// TODO: figure out some way to make this less verbose?
switch (channelType)
@ -140,8 +153,10 @@ public class ChannelCommandsComponents(
goto case "return";
case "return":
var (e, c) = ChannelCommands.BuildRootMenu(guildChannels, guild, guildConfig);
await interactionApi.UpdateMessageAsync(ctx.Interaction,
new InteractionMessageCallbackData(Embeds: e, Components: c));
await interactionApi.UpdateMessageAsync(
ctx.Interaction,
new InteractionMessageCallbackData(Embeds: e, Components: c)
);
lease.Data = new ChannelCommandData(userId, CurrentPage: null);
return Result.Success;
}
@ -151,9 +166,12 @@ public class ChannelCommandsComponents(
var channelId = WebhookExecutorService.GetDefaultLogChannel(guildConfig, logChannelType);
string? channelMention;
if (channelId is 0) channelMention = null;
else if (guildChannels.All(c => c.ID != channelId)) channelMention = $"unknown channel {channelId}";
else channelMention = $"<#{channelId}>";
if (channelId is 0)
channelMention = null;
else if (guildChannels.All(c => c.ID != channelId))
channelMention = $"unknown channel {channelId}";
else
channelMention = $"<#{channelId}>";
List<IEmbed> embeds =
[
@ -161,43 +179,69 @@ public class ChannelCommandsComponents(
Title: ChannelCommands.PrettyLogTypeName(logChannelType),
Description: channelMention == null
? "This event is not currently logged.\nTo start logging it somewhere, select a channel below."
: $"This event is currently set to log to {channelMention}." +
"\nTo change where it is logged, select a channel below." +
"\nTo disable logging this event entirely, select \"Stop logging\" below.",
Colour: DiscordUtils.Purple)
: $"This event is currently set to log to {channelMention}."
+ "\nTo change where it is logged, select a channel below."
+ "\nTo disable logging this event entirely, select \"Stop logging\" below.",
Colour: DiscordUtils.Purple
),
];
List<IMessageComponent> components =
[
new ActionRowComponent(new[]
{
new ChannelSelectComponent(CustomID: CustomIDHelpers.CreateSelectMenuID("config-channels"),
ChannelTypes: new[] { ChannelType.GuildText })
}),
new ActionRowComponent(new[]
{
new ButtonComponent(ButtonComponentStyle.Danger, Label: "Stop logging",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels", "reset"),
IsDisabled: channelMention == null),
new ButtonComponent(ButtonComponentStyle.Secondary, Label: "Return to menu",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels", "return"))
})
new ActionRowComponent(
new[]
{
new ChannelSelectComponent(
CustomID: CustomIDHelpers.CreateSelectMenuID("config-channels"),
ChannelTypes: new[] { ChannelType.GuildText }
),
}
),
new ActionRowComponent(
new[]
{
new ButtonComponent(
ButtonComponentStyle.Danger,
Label: "Stop logging",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
"reset"
),
IsDisabled: channelMention == null
),
new ButtonComponent(
ButtonComponentStyle.Secondary,
Label: "Return to menu",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
"return"
)
),
}
),
];
lease.Data = new ChannelCommandData(userId, CurrentPage: state);
return await interactionApi.UpdateMessageAsync(ctx.Interaction,
new InteractionMessageCallbackData(Embeds: embeds, Components: components));
return await interactionApi.UpdateMessageAsync(
ctx.Interaction,
new InteractionMessageCallbackData(Embeds: embeds, Components: components)
);
}
[SelectMenu("config-channels")]
[SuppressInteractionResponse(true)]
public async Task<Result> OnMenuSelectionAsync(IReadOnlyList<IPartialChannel> channels)
{
if (contextInjection.Context is not IInteractionCommandContext ctx) throw new CataloggerError("No context");
if (!ctx.TryGetUserID(out var userId)) throw new CataloggerError("No user ID in context");
if (!ctx.Interaction.Message.TryGet(out var msg)) throw new CataloggerError("No message ID in context");
if (!ctx.TryGetGuildID(out var guildId)) throw new CataloggerError("No guild ID in context");
if (!guildCache.TryGet(guildId, out var guild)) throw new CataloggerError("Guild not in cache");
if (contextInjection.Context is not IInteractionCommandContext ctx)
throw new CataloggerError("No context");
if (!ctx.TryGetUserID(out var userId))
throw new CataloggerError("No user ID in context");
if (!ctx.Interaction.Message.TryGet(out var msg))
throw new CataloggerError("No message ID in context");
if (!ctx.TryGetGuildID(out var guildId))
throw new CataloggerError("No guild ID in context");
if (!guildCache.TryGet(guildId, out var guild))
throw new CataloggerError("Guild not in cache");
var guildConfig = await db.GetGuildAsync(guildId);
var channelId = channels[0].ID.ToUlong();
@ -205,12 +249,17 @@ public class ChannelCommandsComponents(
await using var lease = result.GetOrThrow();
if (lease.Data.UserId != userId)
{
return (Result)await feedbackService.SendContextualAsync("This is not your configuration menu.",
options: new FeedbackMessageOptions(MessageFlags: MessageFlags.Ephemeral));
return (Result)
await feedbackService.SendContextualAsync(
"This is not your configuration menu.",
options: new FeedbackMessageOptions(MessageFlags: MessageFlags.Ephemeral)
);
}
if (!Enum.TryParse<LogChannelType>(lease.Data.CurrentPage, out var channelType))
throw new CataloggerError($"Invalid config-channels CurrentPage '{lease.Data.CurrentPage}'");
throw new CataloggerError(
$"Invalid config-channels CurrentPage '{lease.Data.CurrentPage}'"
);
switch (channelType)
{
@ -291,32 +340,53 @@ public class ChannelCommandsComponents(
[
new Embed(
Title: ChannelCommands.PrettyLogTypeName(channelType),
Description: $"This event is currently set to log to <#{channelId}>." +
"\nTo change where it is logged, select a channel below." +
"\nTo disable logging this event entirely, select \"Stop logging\" below.",
Colour: DiscordUtils.Purple)
Description: $"This event is currently set to log to <#{channelId}>."
+ "\nTo change where it is logged, select a channel below."
+ "\nTo disable logging this event entirely, select \"Stop logging\" below.",
Colour: DiscordUtils.Purple
),
];
List<IMessageComponent> components =
[
new ActionRowComponent(new[]
{
new ChannelSelectComponent(CustomID: CustomIDHelpers.CreateSelectMenuID("config-channels"),
ChannelTypes: new[] { ChannelType.GuildText })
}),
new ActionRowComponent(new[]
{
new ButtonComponent(ButtonComponentStyle.Danger, Label: "Stop logging",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels", "reset")),
new ButtonComponent(ButtonComponentStyle.Secondary, Label: "Return to menu",
CustomID: CustomIDHelpers.CreateButtonIDWithState("config-channels", "return"))
})
new ActionRowComponent(
new[]
{
new ChannelSelectComponent(
CustomID: CustomIDHelpers.CreateSelectMenuID("config-channels"),
ChannelTypes: new[] { ChannelType.GuildText }
),
}
),
new ActionRowComponent(
new[]
{
new ButtonComponent(
ButtonComponentStyle.Danger,
Label: "Stop logging",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
"reset"
)
),
new ButtonComponent(
ButtonComponentStyle.Secondary,
Label: "Return to menu",
CustomID: CustomIDHelpers.CreateButtonIDWithState(
"config-channels",
"return"
)
),
}
),
];
lease.Data = lease.Data with { UserId = userId };
return await interactionApi.UpdateMessageAsync(ctx.Interaction,
new InteractionMessageCallbackData(Embeds: embeds, Components: components));
return await interactionApi.UpdateMessageAsync(
ctx.Interaction,
new InteractionMessageCallbackData(Embeds: embeds, Components: components)
);
}
}
public record ChannelCommandData(Snowflake UserId, string? CurrentPage);
public record ChannelCommandData(Snowflake UserId, string? CurrentPage);

60
Catalogger.Backend/Bot/Commands/KeyRoleCommands.cs
View file

@ -22,41 +22,52 @@ public class KeyRoleCommands(
ContextInjectionService contextInjection,
IFeedbackService feedbackService,
GuildCache guildCache,
RoleCache roleCache) : CommandGroup
RoleCache roleCache
) : CommandGroup
{
[Command("list")]
[Description("List this server's key roles.")]
public async Task<IResult> ListKeyRolesAsync()
{
var (_, guildId) = contextInjection.GetUserAndGuild();
if (!guildCache.TryGet(guildId, out var guild)) throw new CataloggerError("Guild not in cache");
if (!guildCache.TryGet(guildId, out var guild))
throw new CataloggerError("Guild not in cache");
var guildRoles = roleCache.GuildRoles(guildId).ToList();
var guildConfig = await db.GetGuildAsync(guildId);
if (guildConfig.KeyRoles.Count == 0)
return await feedbackService.SendContextualAsync(
"There are no key roles to list. Add some with `/key-roles add`.");
"There are no key roles to list. Add some with `/key-roles add`."
);
var description = string.Join("\n", guildConfig.KeyRoles.Select(id =>
{
var role = guildRoles.FirstOrDefault(r => r.ID.Value == id);
return role != null ? $"- {role.Name} <@&{role.ID}>" : $"- unknown role {id}";
}));
var description = string.Join(
"\n",
guildConfig.KeyRoles.Select(id =>
{
var role = guildRoles.FirstOrDefault(r => r.ID.Value == id);
return role != null ? $"- {role.Name} <@&{role.ID}>" : $"- unknown role {id}";
})
);
return await feedbackService.SendContextualEmbedAsync(new Embed(
Title: $"Key roles for {guild.Name}",
Description: description,
Colour: DiscordUtils.Purple));
return await feedbackService.SendContextualEmbedAsync(
new Embed(
Title: $"Key roles for {guild.Name}",
Description: description,
Colour: DiscordUtils.Purple
)
);
}
[Command("add")]
[Description("Add a new key role.")]
public async Task<IResult> AddKeyRoleAsync(
[Description("The role to add.")] [DiscordTypeHint(TypeHint.Role)] Snowflake roleId)
[Description("The role to add.")] [DiscordTypeHint(TypeHint.Role)] Snowflake roleId
)
{
var (_, guildId) = contextInjection.GetUserAndGuild();
var role = roleCache.GuildRoles(guildId).FirstOrDefault(r => r.ID == roleId);
if (role == null) throw new CataloggerError("Role is not cached");
if (role == null)
throw new CataloggerError("Role is not cached");
var guildConfig = await db.GetGuildAsync(guildId);
if (guildConfig.KeyRoles.Any(id => role.ID == id))
@ -66,27 +77,34 @@ public class KeyRoleCommands(
db.Update(guildConfig);
await db.SaveChangesAsync();
return await feedbackService.SendContextualAsync($"Added {role.Name} to this server's key roles!");
return await feedbackService.SendContextualAsync(
$"Added {role.Name} to this server's key roles!"
);
}
[Command("remove")]
[Description("Remove a key role.")]
public async Task<IResult> RemoveKeyRoleAsync(
[Description("The role to remove.")] [DiscordTypeHint(TypeHint.Role)]
Snowflake roleId)
[Description("The role to remove.")] [DiscordTypeHint(TypeHint.Role)] Snowflake roleId
)
{
var (_, guildId) = contextInjection.GetUserAndGuild();
var role = roleCache.GuildRoles(guildId).FirstOrDefault(r => r.ID == roleId);
if (role == null) throw new CataloggerError("Role is not cached");
if (role == null)
throw new CataloggerError("Role is not cached");
var guildConfig = await db.GetGuildAsync(guildId);
if (guildConfig.KeyRoles.All(id => role.ID != id))
return await feedbackService.SendContextualAsync($"{role.Name} is already not a key role.");
return await feedbackService.SendContextualAsync(
$"{role.Name} is already not a key role."
);
guildConfig.KeyRoles.Remove(role.ID.Value);
db.Update(guildConfig);
await db.SaveChangesAsync();
return await feedbackService.SendContextualAsync($"Removed {role.Name} from this server's key roles!");
return await feedbackService.SendContextualAsync(
$"Removed {role.Name} from this server's key roles!"
);
}
}
}

63
Catalogger.Backend/Bot/Commands/MetaCommands.cs
View file

@ -32,7 +32,8 @@ public class MetaCommands(
ContextInjectionService contextInjection,
GuildCache guildCache,
ChannelCache channelCache,
IDiscordRestChannelAPI channelApi) : CommandGroup
IDiscordRestChannelAPI channelApi
) : CommandGroup
{
private readonly ILogger _logger = logger.ForContext<MetaCommands>();
private readonly HttpClient _client = new();
@ -41,12 +42,14 @@ public class MetaCommands(
[Description("Ping pong! See the bot's latency")]
public async Task<IResult> PingAsync()
{
var shardId = contextInjection.Context?.TryGetGuildID(out var guildId) == true
? client.ShardIdFor(guildId.Value)
: 0;
var shardId =
contextInjection.Context?.TryGetGuildID(out var guildId) == true
? client.ShardIdFor(guildId.Value)
: 0;
var averageLatency = client.Shards.Values.Select(x => x.Latency.TotalMilliseconds).Sum() /
client.Shards.Count;
var averageLatency =
client.Shards.Values.Select(x => x.Latency.TotalMilliseconds).Sum()
/ client.Shards.Count;
var t1 = clock.GetCurrentInstant();
var msg = await feedbackService.SendContextualAsync("...").GetOrThrow();
@ -57,42 +60,54 @@ public class MetaCommands(
var embed = new EmbedBuilder()
.WithColour(DiscordUtils.Purple)
.WithFooter($"{RuntimeInformation.FrameworkDescription} on {RuntimeInformation.RuntimeIdentifier}")
.WithFooter(
$"{RuntimeInformation.FrameworkDescription} on {RuntimeInformation.RuntimeIdentifier}"
)
.WithCurrentTimestamp();
embed.AddField("Ping",
$"Gateway: {client.Shards[shardId].Latency.TotalMilliseconds:N0}ms (average: {averageLatency:N0}ms)\n" +
$"API: {elapsed.TotalMilliseconds:N0}ms",
inline: true);
embed.AddField(
"Ping",
$"Gateway: {client.Shards[shardId].Latency.TotalMilliseconds:N0}ms (average: {averageLatency:N0}ms)\n"
+ $"API: {elapsed.TotalMilliseconds:N0}ms",
inline: true
);
embed.AddField("Memory usage", memoryUsage.Bytes().Humanize(), inline: true);
var messageRate = await MessagesRate();
embed.AddField("Messages received",
embed.AddField(
"Messages received",
messageRate != null
? $"{messageRate / 5:F1}/m\n({CataloggerMetrics.MessagesReceived.Value:N0} since last restart)"
: $"{CataloggerMetrics.MessagesReceived.Value:N0} since last restart",
true);
true
);
embed.AddField("Shard", $"{shardId + 1} of {client.Shards.Count}", true);
embed.AddField("Uptime",
$"{(CataloggerMetrics.Startup - clock.GetCurrentInstant()).Prettify(TimeUnit.Second)}\n" +
$"since <t:{CataloggerMetrics.Startup.ToUnixTimeSeconds()}:F>",
true);
embed.AddField(
"Uptime",
$"{(CataloggerMetrics.Startup - clock.GetCurrentInstant()).Prettify(TimeUnit.Second)}\n"
+ $"since <t:{CataloggerMetrics.Startup.ToUnixTimeSeconds()}:F>",
true
);
embed.AddField("Numbers",
$"{CataloggerMetrics.MessagesStored.Value:N0} messages " +
$"from {guildCache.Size:N0} servers\nCached {channelCache.Size:N0} channels",
false);
embed.AddField(
"Numbers",
$"{CataloggerMetrics.MessagesStored.Value:N0} messages "
+ $"from {guildCache.Size:N0} servers\nCached {channelCache.Size:N0} channels",
false
);
IEmbed[] embeds = [embed.Build().GetOrThrow()];
return (Result)await channelApi.EditMessageAsync(msg.ChannelID, msg.ID, content: "", embeds: embeds);
return (Result)
await channelApi.EditMessageAsync(msg.ChannelID, msg.ID, content: "", embeds: embeds);
}
// TODO: add more checks around response format, configurable prometheus endpoint
private async Task<double?> MessagesRate()
{
if (!config.Logging.EnableMetrics) return null;
if (!config.Logging.EnableMetrics)
return null;
try
{
@ -118,4 +133,4 @@ public class MetaCommands(
private record PrometheusResult(object[] value);
// ReSharper restore InconsistentNaming, ClassNeverInstantiated.Local
}
}

2
Catalogger.Backend/Bot/DiscordUtils.cs
View file

@ -14,4 +14,4 @@ public static class DiscordUtils
public static readonly Color Green = Color.FromArgb(46, 204, 113);
public static readonly Color Blue = Color.FromArgb(52, 152, 219);
public static readonly Color Orange = Color.FromArgb(230, 126, 34);
}
}

51
Catalogger.Backend/Bot/Responders/Channels/ChannelCreateResponder.cs
View file

@ -16,37 +16,47 @@ public class ChannelCreateResponder(
RoleCache roleCache,
ChannelCache channelCache,
UserCache userCache,
WebhookExecutorService webhookExecutor) : IResponder<IChannelCreate>
WebhookExecutorService webhookExecutor
) : IResponder<IChannelCreate>
{
public async Task<Result> RespondAsync(IChannelCreate ch, CancellationToken ct = default)
{
if (!ch.GuildID.IsDefined()) return Result.Success;
if (!ch.GuildID.IsDefined())
return Result.Success;
channelCache.Set(ch);
var builder = new EmbedBuilder()
.WithTitle(ch.Type switch
{
ChannelType.GuildVoice => "Voice channel created",
ChannelType.GuildCategory => "Category channel created",
ChannelType.GuildAnnouncement or ChannelType.GuildText => "Text channel created",
_ => "Channel created"
})
.WithTitle(
ch.Type switch
{
ChannelType.GuildVoice => "Voice channel created",
ChannelType.GuildCategory => "Category channel created",
ChannelType.GuildAnnouncement or ChannelType.GuildText =>
"Text channel created",
_ => "Channel created",
}
)
.WithColour(DiscordUtils.Green)
.WithFooter($"ID: {ch.ID}");
if (ch.ParentID.IsDefined(out var parentId))
{
builder.WithDescription(channelCache.TryGet(parentId.Value, out var parentChannel)
? $"**Name:** {ch.Name}\n**Category:** {parentChannel.Name}"
: $"**Name:** {ch.Name}");
builder.WithDescription(
channelCache.TryGet(parentId.Value, out var parentChannel)
? $"**Name:** {ch.Name}\n**Category:** {parentChannel.Name}"
: $"**Name:** {ch.Name}"
);
}
else builder.WithDescription($"**Name:** {ch.Name}");
else
builder.WithDescription($"**Name:** {ch.Name}");
foreach (var overwrite in ch.PermissionOverwrites.OrDefault() ?? [])
{
if (overwrite.Type == PermissionOverwriteType.Role)
{
var roleName = roleCache.TryGet(overwrite.ID, out var role) ? role.Name : $"role {overwrite.ID}";
var roleName = roleCache.TryGet(overwrite.ID, out var role)
? role.Name
: $"role {overwrite.ID}";
var embedFieldValue = "";
if (overwrite.Allow.GetPermissions().Count != 0)
embedFieldValue += $"\u2705 {overwrite.Allow.ToPrettyString()}";
@ -64,12 +74,19 @@ public class ChannelCreateResponder(
if (overwrite.Deny.GetPermissions().Count != 0)
embedFieldValue += $"\n\n\u274c {overwrite.Deny.ToPrettyString()}";
builder.AddField($"Override for {user?.Tag() ?? $"user {overwrite.ID}"}", embedFieldValue.Trim());
builder.AddField(
$"Override for {user?.Tag() ?? $"user {overwrite.ID}"}",
embedFieldValue.Trim()
);
}
}
var guildConfig = await db.GetGuildAsync(ch.GuildID.Value, ct);
webhookExecutor.QueueLog(guildConfig, LogChannelType.ChannelCreate, builder.Build().GetOrThrow());
webhookExecutor.QueueLog(
guildConfig,
LogChannelType.ChannelCreate,
builder.Build().GetOrThrow()
);
return Result.Success;
}
}
}

16
Catalogger.Backend/Bot/Responders/Channels/ChannelDeleteResponder.cs
View file

@ -14,7 +14,8 @@ public class ChannelDeleteResponder(
ILogger logger,
DatabaseContext db,
ChannelCache channelCache,
WebhookExecutorService webhookExecutor) : IResponder<IChannelDelete>
WebhookExecutorService webhookExecutor
) : IResponder<IChannelDelete>
{
private readonly ILogger _logger = logger.ForContext<ChannelDeleteResponder>();
@ -41,7 +42,10 @@ public class ChannelDeleteResponder(
.WithCurrentTimestamp()
.WithDescription($"**Name:** {channel.Name.Value}");
if (channel.ParentID.IsDefined(out var parentId) && channelCache.TryGet(parentId.Value, out var category))
if (
channel.ParentID.IsDefined(out var parentId)
&& channelCache.TryGet(parentId.Value, out var category)
)
embed.Description += $"\n**Category:** {category.Name}";
else
embed.Description += "\n**Category:** (none)";
@ -49,7 +53,11 @@ public class ChannelDeleteResponder(
if (channel.Topic.IsDefined(out var topic))
embed.AddField("Description", topic);
webhookExecutor.QueueLog(guildConfig, LogChannelType.ChannelDelete, embed.Build().GetOrThrow());
webhookExecutor.QueueLog(
guildConfig,
LogChannelType.ChannelDelete,
embed.Build().GetOrThrow()
);
return Result.Success;
}
}
}

130
Catalogger.Backend/Bot/Responders/Channels/ChannelUpdateResponder.cs
View file

@ -19,8 +19,8 @@ public class ChannelUpdateResponder(
ChannelCache channelCache,
RoleCache roleCache,
UserCache userCache,
WebhookExecutorService webhookExecutor)
: IResponder<IChannelUpdate>
WebhookExecutorService webhookExecutor
) : IResponder<IChannelUpdate>
{
private readonly ILogger _logger = logger.ForContext<ChannelUpdateResponder>();
@ -37,20 +37,26 @@ public class ChannelUpdateResponder(
var guildConfig = await db.GetGuildAsync(evt.GuildID.Value, ct);
var builder = new EmbedBuilder()
.WithTitle(evt.Type switch
{
ChannelType.GuildVoice => "Voice channel edited",
ChannelType.GuildCategory => "Category channel edited",
ChannelType.GuildAnnouncement or ChannelType.GuildText => "Text channel edited",
_ => "Channel edited"
})
.WithTitle(
evt.Type switch
{
ChannelType.GuildVoice => "Voice channel edited",
ChannelType.GuildCategory => "Category channel edited",
ChannelType.GuildAnnouncement or ChannelType.GuildText =>
"Text channel edited",
_ => "Channel edited",
}
)
.WithColour(DiscordUtils.Blue)
.WithFooter($"ID: {evt.ID} | Name: {evt.Name}")
.WithCurrentTimestamp();
if (oldChannel.ParentID != evt.ParentID)
{
var categoryUpdate = CategoryUpdate(oldChannel.ParentID.OrDefault(), evt.ParentID.OrDefault());
var categoryUpdate = CategoryUpdate(
oldChannel.ParentID.OrDefault(),
evt.ParentID.OrDefault()
);
if (!string.IsNullOrWhiteSpace(categoryUpdate))
builder.AddField("Category", categoryUpdate);
}
@ -64,7 +70,8 @@ public class ChannelUpdateResponder(
var newTopic = evt.Topic.OrDefault() ?? "(none)";
var topicField = $"**Before:** {oldTopic}\n\n**After:** {newTopic}";
if (topicField.Length > 1000) topicField = topicField[..1000] + "…";
if (topicField.Length > 1000)
topicField = topicField[..1000] + "…";
builder.AddField("Description", topicField);
}
@ -72,11 +79,19 @@ public class ChannelUpdateResponder(
var oldOverrides = oldChannel.PermissionOverwrites.OrDefault() ?? [];
var newOverrides = evt.PermissionOverwrites.OrDefault() ?? [];
var addedOverrides = newOverrides.Where(o => oldOverrides.All(o2 => o.ID != o2.ID)).ToList();
var removedOverrides = oldOverrides.Where(o => newOverrides.All(o2 => o.ID != o2.ID)).ToList();
var addedOverrides = newOverrides
.Where(o => oldOverrides.All(o2 => o.ID != o2.ID))
.ToList();
var removedOverrides = oldOverrides
.Where(o => newOverrides.All(o2 => o.ID != o2.ID))
.ToList();
// Overrides filtered to ones that exist in both lists, but have different allow or deny values
var editedOverrides = newOverrides.Where(o => oldOverrides.Any(o2 =>
o.ID == o2.ID && (o.Allow.Value != o2.Allow.Value || o.Deny.Value != o2.Deny.Value)));
var editedOverrides = newOverrides.Where(o =>
oldOverrides.Any(o2 =>
o.ID == o2.ID
&& (o.Allow.Value != o2.Allow.Value || o.Deny.Value != o2.Deny.Value)
)
);
if (addedOverrides.Count != 0)
{
@ -90,7 +105,9 @@ public class ChannelUpdateResponder(
}
else
{
addedOverrideNames.Add(roleCache.TryGet(o.ID, out var role) ? role.Name : $"role {o.ID}");
addedOverrideNames.Add(
roleCache.TryGet(o.ID, out var role) ? role.Name : $"role {o.ID}"
);
break;
}
@ -110,7 +127,9 @@ public class ChannelUpdateResponder(
}
else
{
removedOverrideNames.Add(roleCache.TryGet(o.ID, out var role) ? role.Name : $"role {o.ID}");
removedOverrideNames.Add(
roleCache.TryGet(o.ID, out var role) ? role.Name : $"role {o.ID}"
);
break;
}
}
@ -120,9 +139,12 @@ public class ChannelUpdateResponder(
foreach (var overwrite in editedOverrides)
{
var perms = string.Join("\n",
PermissionUpdate(oldOverrides.First(o => o.ID == overwrite.ID), overwrite));
if (string.IsNullOrWhiteSpace(perms)) continue;
var perms = string.Join(
"\n",
PermissionUpdate(oldOverrides.First(o => o.ID == overwrite.ID), overwrite)
);
if (string.IsNullOrWhiteSpace(perms))
continue;
builder.AddField(await OverwriteName(overwrite), perms.Trim());
}
@ -134,19 +156,24 @@ public class ChannelUpdateResponder(
embedFieldValue += $"\u2705 {overwrite.Allow.ToPrettyString()}";
if (overwrite.Deny.GetPermissions().Count != 0)
embedFieldValue += $"\n\n\u274c {overwrite.Deny.ToPrettyString()}";
if (string.IsNullOrWhiteSpace(embedFieldValue)) continue;
if (string.IsNullOrWhiteSpace(embedFieldValue))
continue;
builder.AddField(await OverwriteName(overwrite), embedFieldValue.Trim());
}
// Sometimes we get channel update events for channels that didn't actually have anything loggable change.
// If that happens, there will be no embed fields, so just check for that
if (builder.Fields.Count == 0) return Result.Success;
webhookExecutor.QueueLog(guildConfig, LogChannelType.ChannelUpdate, builder.Build().GetOrThrow());
if (builder.Fields.Count == 0)
return Result.Success;
webhookExecutor.QueueLog(
guildConfig,
LogChannelType.ChannelUpdate,
builder.Build().GetOrThrow()
);
return Result.Success;
}
finally
{
channelCache.Set(evt);
}
@ -172,46 +199,69 @@ public class ChannelUpdateResponder(
: $"Override for role {overwrite.ID}";
case PermissionOverwriteType.Member:
var user = await userCache.GetUserAsync(overwrite.ID);
return user != null ? $"Override for {user.Tag()}" : $"Override for user {overwrite.ID}";
return user != null
? $"Override for {user.Tag()}"
: $"Override for user {overwrite.ID}";
default:
throw new ArgumentOutOfRangeException(nameof(overwrite), overwrite.Type,
"Invalid PermissionOverwriteType");
throw new ArgumentOutOfRangeException(
nameof(overwrite),
overwrite.Type,
"Invalid PermissionOverwriteType"
);
}
}
private static IEnumerable<string> PermissionUpdate(IPermissionOverwrite oldOverwrite,
IPermissionOverwrite newOverwrite)
private static IEnumerable<string> PermissionUpdate(
IPermissionOverwrite oldOverwrite,
IPermissionOverwrite newOverwrite
)
{
foreach (var perm in Enum.GetValues<DiscordPermission>())
{
if (newOverwrite.Allow.HasPermission(perm) && !oldOverwrite.Allow.HasPermission(perm) &&
!oldOverwrite.Deny.HasPermission(perm))
if (
newOverwrite.Allow.HasPermission(perm)
&& !oldOverwrite.Allow.HasPermission(perm)
&& !oldOverwrite.Deny.HasPermission(perm)
)
{
yield return $"\u2b1c \u279c \u2705 {perm.Humanize(LetterCasing.Title)}";
}
else if (newOverwrite.Deny.HasPermission(perm) && !oldOverwrite.Allow.HasPermission(perm) &&
!oldOverwrite.Deny.HasPermission(perm))
else if (
newOverwrite.Deny.HasPermission(perm)
&& !oldOverwrite.Allow.HasPermission(perm)
&& !oldOverwrite.Deny.HasPermission(perm)
)
{
yield return $"\u2b1c \u279c \u274c {perm.Humanize(LetterCasing.Title)}";
}
else if (newOverwrite.Allow.HasPermission(perm) && oldOverwrite.Deny.HasPermission(perm))
else if (
newOverwrite.Allow.HasPermission(perm) && oldOverwrite.Deny.HasPermission(perm)
)
{
yield return $"\u274c \u279c \u2705 {perm.Humanize(LetterCasing.Title)}";
}
else if (newOverwrite.Deny.HasPermission(perm) && oldOverwrite.Allow.HasPermission(perm))
else if (
newOverwrite.Deny.HasPermission(perm) && oldOverwrite.Allow.HasPermission(perm)
)
{
yield return $"\u2705 \u279c \u274c {perm.Humanize(LetterCasing.Title)}";
}
else if (!newOverwrite.Allow.HasPermission(perm) && !newOverwrite.Deny.HasPermission(perm) &&
oldOverwrite.Allow.HasPermission(perm))
else if (
!newOverwrite.Allow.HasPermission(perm)
&& !newOverwrite.Deny.HasPermission(perm)
&& oldOverwrite.Allow.HasPermission(perm)
)
{
yield return $"\u2705 \u279c \u2b1c {perm.Humanize(LetterCasing.Title)}";
}
else if (!newOverwrite.Allow.HasPermission(perm) && !newOverwrite.Deny.HasPermission(perm) &&
oldOverwrite.Allow.HasPermission(perm))
else if (
!newOverwrite.Allow.HasPermission(perm)
&& !newOverwrite.Deny.HasPermission(perm)
&& oldOverwrite.Allow.HasPermission(perm)
)
{
yield return $"\u274c \u279c \u2b1c {perm.Humanize(LetterCasing.Title)}";
}
}
}
}
}

9
Catalogger.Backend/Bot/Responders/Guilds/AuditLogResponder.cs
View file

@ -6,15 +6,16 @@ using Remora.Results;
namespace Catalogger.Backend.Bot.Responders.Guilds;
public class AuditLogResponder(AuditLogCache auditLogCache, ILogger logger) : IResponder<IGuildAuditLogEntryCreate>
public class AuditLogResponder(AuditLogCache auditLogCache, ILogger logger)
: IResponder<IGuildAuditLogEntryCreate>
{
private readonly ILogger _logger = logger.ForContext<AuditLogResponder>();
public Task<Result> RespondAsync(IGuildAuditLogEntryCreate evt, CancellationToken ct = default)
{
_logger.Debug("type: {ActionType}", evt.ActionType);
_logger.Debug("{Id}, {Reason}", evt.ID, evt.Reason);
throw new NotImplementedException();
}
}
}

69
Catalogger.Backend/Bot/Responders/Guilds/GuildCreateResponder.cs
View file

@ -20,8 +20,8 @@ public class GuildCreateResponder(
ChannelCache channelCache,
WebhookExecutorService webhookExecutor,
IMemberCache memberCache,
GuildFetchService guildFetchService)
: IResponder<IGuildCreate>, IResponder<IGuildDelete>
GuildFetchService guildFetchService
) : IResponder<IGuildCreate>, IResponder<IGuildDelete>
{
private readonly ILogger _logger = logger.ForContext<GuildCreateResponder>();
@ -31,46 +31,56 @@ public class GuildCreateResponder(
string? guildName = null;
if (evt.Guild.TryPickT0(out var guild, out var unavailableGuild))
{
_logger.Verbose("Received guild create for available guild {GuildName} / {GuildId})", guild.Name, guild.ID);
_logger.Verbose(
"Received guild create for available guild {GuildName} / {GuildId})",
guild.Name,
guild.ID
);
guildId = guild.ID.ToUlong();
guildName = guild.Name;
guildCache.Set(guild);
foreach (var c in guild.Channels) channelCache.Set(c, guild.ID);
foreach (var r in guild.Roles) roleCache.Set(r, guild.ID);
foreach (var c in guild.Channels)
channelCache.Set(c, guild.ID);
foreach (var r in guild.Roles)
roleCache.Set(r, guild.ID);
if (!await memberCache.IsGuildCachedAsync(guild.ID))
guildFetchService.EnqueueGuild(guild.ID);
}
else
{
_logger.Verbose("Received guild create for unavailable guild {GuildId}", unavailableGuild.ID);
_logger.Verbose(
"Received guild create for unavailable guild {GuildId}",
unavailableGuild.ID
);
guildId = unavailableGuild.ID.ToUlong();
}
var tx = await db.Database.BeginTransactionAsync(ct);
if (await db.Guilds.FindAsync([guildId], ct) != null) return Result.Success;
if (await db.Guilds.FindAsync([guildId], ct) != null)
return Result.Success;
db.Add(new Guild
{
Id = guildId
});
db.Add(new Guild { Id = guildId });
await db.SaveChangesAsync(ct);
await tx.CommitAsync(ct);
_logger.Information("Joined new guild {GuildName} / {GuildId}", guildName, guildId);
if (config.Discord.GuildLogId != null && evt.Guild.IsT0)
webhookExecutor.QueueLog(config.Discord.GuildLogId.Value, new EmbedBuilder()
.WithTitle("Joined new guild")
.WithDescription($"Joined new guild **{guild.Name}**")
.WithFooter($"ID: {guild.ID}")
.WithCurrentTimestamp()
webhookExecutor.QueueLog(
config.Discord.GuildLogId.Value,
new EmbedBuilder()
.WithTitle("Joined new guild")
.WithDescription($"Joined new guild **{guild.Name}**")
.WithFooter($"ID: {guild.ID}")
.WithCurrentTimestamp()
#pragma warning disable CS8604 // Possible null reference argument.
.WithThumbnailUrl(guild.IconUrl())
.WithThumbnailUrl(guild.IconUrl())
#pragma warning restore CS8604 // Possible null reference argument.
.Build()
.GetOrThrow());
.Build()
.GetOrThrow()
);
return Result.Success;
}
@ -92,17 +102,20 @@ public class GuildCreateResponder(
_logger.Information("Left guild {GuildName} / {GuildId}", guild.Name, guild.ID);
if (config.Discord.GuildLogId != null)
webhookExecutor.QueueLog(config.Discord.GuildLogId.Value, new EmbedBuilder()
.WithTitle("Left guild")
.WithDescription($"Left guild **{guild.Name}**")
.WithFooter($"ID: {guild.ID}")
.WithCurrentTimestamp()
webhookExecutor.QueueLog(
config.Discord.GuildLogId.Value,
new EmbedBuilder()
.WithTitle("Left guild")
.WithDescription($"Left guild **{guild.Name}**")
.WithFooter($"ID: {guild.ID}")
.WithCurrentTimestamp()
#pragma warning disable CS8604 // Possible null reference argument.
.WithThumbnailUrl(guild.IconUrl())
.WithThumbnailUrl(guild.IconUrl())
#pragma warning restore CS8604 // Possible null reference argument.
.Build()
.GetOrThrow());
.Build()
.GetOrThrow()
);
return Task.FromResult(Result.Success);
}
}
}

110
Catalogger.Backend/Bot/Responders/Guilds/GuildMemberAddResponder.cs
View file

@ -23,7 +23,8 @@ public class GuildMemberAddResponder(
UserCache userCache,
WebhookExecutorService webhookExecutor,
IDiscordRestGuildAPI guildApi,
PluralkitApiService pluralkitApi) : IResponder<IGuildMemberAdd>
PluralkitApiService pluralkitApi
) : IResponder<IGuildMemberAdd>
{
private readonly ILogger _logger = logger.ForContext<GuildMemberAddResponder>();
private static readonly TimeSpan NewAccountThreshold = 7.Days();
@ -45,7 +46,8 @@ public class GuildMemberAddResponder(
var guildConfig = await db.GetGuildAsync(member.GuildID, ct);
var guildRes = await guildApi.GetGuildAsync(member.GuildID, withCounts: true, ct);
if (guildRes.IsSuccess)
builder.Description += $"\n{guildRes.Entity.ApproximateMemberCount.Value.Ordinalize()} to join";
builder.Description +=
$"\n{guildRes.Entity.ApproximateMemberCount.Value.Ordinalize()} to join";
builder.Description +=
$"\ncreated {user.ID.Timestamp.Prettify()} ago\n<t:{user.ID.Timestamp.ToUnixTimeSeconds()}:F>";
@ -53,15 +55,19 @@ public class GuildMemberAddResponder(
var pkSystem = await pluralkitApi.GetPluralKitSystemAsync(user.ID.Value, ct);
if (pkSystem != null)
{
var createdAt = pkSystem.Created != null
? $"{pkSystem.Created.Value.Prettify()} ago (<t:{pkSystem.Created.Value.ToUnixTimeSeconds()}:F>)"
: "*(unknown)*";
builder.AddField("PluralKit system", $"""
**ID:** {pkSystem.Id} (`{pkSystem.Uuid}`)
**Name:** {pkSystem.Name ?? "*(none)*"}
**Tag:** {pkSystem.Tag ?? "*(none)*"}
**Created:** {createdAt}
""");
var createdAt =
pkSystem.Created != null
? $"{pkSystem.Created.Value.Prettify()} ago (<t:{pkSystem.Created.Value.ToUnixTimeSeconds()}:F>)"
: "*(unknown)*";
builder.AddField(
"PluralKit system",
$"""
**ID:** {pkSystem.Id} (`{pkSystem.Uuid}`)
**Name:** {pkSystem.Name ?? "*(none)*"}
**Tag:** {pkSystem.Tag ?? "*(none)*"}
**Created:** {createdAt}
"""
);
}
// TODO: find used invite
@ -70,51 +76,73 @@ public class GuildMemberAddResponder(
if (user.ID.Timestamp > DateTimeOffset.Now - NewAccountThreshold)
{
embeds.Add(new EmbedBuilder()
.WithTitle("New account")
.WithColour(DiscordUtils.Orange)
.WithDescription($"\u26a0\ufe0f Created {user.ID.Timestamp.Prettify()} ago")
.Build()
.GetOrThrow());
embeds.Add(
new EmbedBuilder()
.WithTitle("New account")
.WithColour(DiscordUtils.Orange)
.WithDescription($"\u26a0\ufe0f Created {user.ID.Timestamp.Prettify()} ago")
.Build()
.GetOrThrow()
);
}
var watchlist = await db.GetWatchlistEntryAsync(member.GuildID, user.ID, ct);
if (watchlist != null)
{
var moderator = await userCache.GetUserAsync(DiscordSnowflake.New(watchlist.ModeratorId));
var mod = moderator != null ? $"{moderator.Tag()} (<@{moderator.ID}>)" : $"<@{watchlist.ModeratorId}>";
var moderator = await userCache.GetUserAsync(
DiscordSnowflake.New(watchlist.ModeratorId)
);
var mod =
moderator != null
? $"{moderator.Tag()} (<@{moderator.ID}>)"
: $"<@{watchlist.ModeratorId}>";
embeds.Add(new EmbedBuilder()
.WithTitle("⚠️ User on watchlist")
.WithColour(DiscordUtils.Red)
.WithDescription($"**{user.Tag()}** is on this server's watch list.\n\n{watchlist.Reason}")
.WithFooter($"ID: {user.ID} | Added")
.WithTimestamp(watchlist.AddedAt.ToDateTimeOffset())
.AddField("Moderator", mod).GetOrThrow()
.Build()
.GetOrThrow());
embeds.Add(
new EmbedBuilder()
.WithTitle("⚠️ User on watchlist")
.WithColour(DiscordUtils.Red)
.WithDescription(
$"**{user.Tag()}** is on this server's watch list.\n\n{watchlist.Reason}"
)
.WithFooter($"ID: {user.ID} | Added")
.WithTimestamp(watchlist.AddedAt.ToDateTimeOffset())
.AddField("Moderator", mod)
.GetOrThrow()
.Build()
.GetOrThrow()
);
}
if (pkSystem != null)
{
if (guildConfig.BannedSystems.Contains(pkSystem.Id) ||
guildConfig.BannedSystems.Contains(pkSystem.Uuid.ToString()))
if (
guildConfig.BannedSystems.Contains(pkSystem.Id)
|| guildConfig.BannedSystems.Contains(pkSystem.Uuid.ToString())
)
{
embeds.Add(new EmbedBuilder().WithTitle("Banned system")
.WithDescription(
"\u26a0\ufe0f The system associated with this account has been banned from the server.")
.WithColour(DiscordUtils.Red)
.WithFooter($"ID: {pkSystem.Id}")
.Build()
.GetOrThrow());
embeds.Add(
new EmbedBuilder()
.WithTitle("Banned system")
.WithDescription(
"\u26a0\ufe0f The system associated with this account has been banned from the server."
)
.WithColour(DiscordUtils.Red)
.WithFooter($"ID: {pkSystem.Id}")
.Build()
.GetOrThrow()
);
}
}
if (embeds.Count > 1)
await webhookExecutor.SendLogAsync(guildConfig.Channels.GuildMemberAdd,
embeds.Cast<IEmbed>().ToList(), []);
else webhookExecutor.QueueLog(guildConfig.Channels.GuildMemberAdd, embeds[0]);
await webhookExecutor.SendLogAsync(
guildConfig.Channels.GuildMemberAdd,
embeds.Cast<IEmbed>().ToList(),
[]
);
else
webhookExecutor.QueueLog(guildConfig.Channels.GuildMemberAdd, embeds[0]);
return Result.Success;
}
}
}

24
Catalogger.Backend/Bot/Responders/Guilds/GuildMemberRemoveResponder.cs
View file

@ -17,7 +17,8 @@ public class GuildMemberRemoveResponder(
IMemberCache memberCache,
RoleCache roleCache,
WebhookExecutorService webhookExecutor,
AuditLogEnrichedResponderService auditLogEnrichedResponderService) : IResponder<IGuildMemberRemove>
AuditLogEnrichedResponderService auditLogEnrichedResponderService
) : IResponder<IGuildMemberRemove>
{
private readonly ILogger _logger = logger.ForContext<GuildMemberAddResponder>();
@ -43,8 +44,14 @@ public class GuildMemberRemoveResponder(
{
_logger.Information(
"Guild member {UserId} in {GuildId} left but wasn't in the cache, sending limited embed",
evt.User.ID, evt.GuildID);
webhookExecutor.QueueLog(guildConfig, LogChannelType.GuildMemberRemove, embed.Build().GetOrThrow());
evt.User.ID,
evt.GuildID
);
webhookExecutor.QueueLog(
guildConfig,
LogChannelType.GuildMemberRemove,
embed.Build().GetOrThrow()
);
return Result.Success;
}
@ -65,12 +72,17 @@ public class GuildMemberRemoveResponder(
}
roleMentions += $"<@&{role.ID}>";
if (idx != roles.Count - 1) roleMentions += ", ";
if (idx != roles.Count - 1)
roleMentions += ", ";
}
embed.AddField("Roles", roleMentions, inline: false);
webhookExecutor.QueueLog(guildConfig, LogChannelType.GuildMemberRemove, embed.Build().GetOrThrow());
webhookExecutor.QueueLog(
guildConfig,
LogChannelType.GuildMemberRemove,
embed.Build().GetOrThrow()
);
return Result.Success;
}
finally
@ -78,4 +90,4 @@ public class GuildMemberRemoveResponder(
await memberCache.RemoveAsync(evt.GuildID, evt.User.ID);
}
}
}
}

18
Catalogger.Backend/Bot/Responders/Guilds/GuildMembersChunkResponder.cs
View file

@ -5,23 +5,31 @@ using Remora.Results;
namespace Catalogger.Backend.Bot.Responders.Guilds;
public class GuildMembersChunkResponder(ILogger logger, IMemberCache memberCache) : IResponder<IGuildMembersChunk>
public class GuildMembersChunkResponder(ILogger logger, IMemberCache memberCache)
: IResponder<IGuildMembersChunk>
{
private readonly ILogger _logger = logger.ForContext<GuildMembersChunkResponder>();
public async Task<Result> RespondAsync(IGuildMembersChunk evt, CancellationToken ct = default)
{
_logger.Debug("Received chunk {ChunkIndex} / {ChunkCount} for guild {GuildId}", evt.ChunkIndex + 1,
evt.ChunkCount, evt.GuildID);
_logger.Debug(
"Received chunk {ChunkIndex} / {ChunkCount} for guild {GuildId}",
evt.ChunkIndex + 1,
evt.ChunkCount,
evt.GuildID
);
await memberCache.SetManyAsync(evt.GuildID, evt.Members);
if (evt.ChunkIndex == evt.ChunkCount - 1)
{
_logger.Debug("Final chunk for guild {GuildId} received, marking as cached", evt.GuildID);
_logger.Debug(
"Final chunk for guild {GuildId} received, marking as cached",
evt.GuildID
);
await memberCache.MarkAsCachedAsync(evt.GuildID);
}
return Result.Success;
}
}
}

66
Catalogger.Backend/Bot/Responders/Messages/MessageCreateResponder.cs
View file

@ -18,8 +18,8 @@ public class MessageCreateResponder(
DatabaseContext db,
MessageRepository messageRepository,
UserCache userCache,
PkMessageHandler pkMessageHandler)
: IResponder<IMessageCreate>
PkMessageHandler pkMessageHandler
) : IResponder<IMessageCreate>
{
private readonly ILogger _logger = logger.ForContext<MessageCreateResponder>();
@ -30,8 +30,10 @@ public class MessageCreateResponder(
if (!msg.GuildID.IsDefined())
{
_logger.Debug("Received message create event for message {MessageId} despite it not being in a guild",
msg.ID);
_logger.Debug(
"Received message create event for message {MessageId} despite it not being in a guild",
msg.ID
);
return Result.Success;
}
@ -66,7 +68,8 @@ public partial class PkMessageHandler(ILogger logger, IServiceProvider services)
private readonly ILogger _logger = logger.ForContext<PkMessageHandler>();
[GeneratedRegex(
@"^System ID: (\w{5,6}) \| Member ID: (\w{5,6}) \| Sender: .+ \((\d+)\) \| Message ID: (\d+) \| Original Message ID: (\d+)$")]
@"^System ID: (\w{5,6}) \| Member ID: (\w{5,6}) \| Sender: .+ \((\d+)\) \| Message ID: (\d+) \| Original Message ID: (\d+)$"
)]
private static partial Regex FooterRegex();
[GeneratedRegex(@"^https:\/\/discord.com\/channels\/\d+\/(\d+)\/\d+$")]
@ -89,11 +92,15 @@ public partial class PkMessageHandler(ILogger logger, IServiceProvider services)
// The first (only, I think always?) embed's footer must match the expected format
var firstEmbed = msg.Embeds.FirstOrDefault();
if (firstEmbed == null || !firstEmbed.Footer.TryGet(out var footer) ||
!FooterRegex().IsMatch(footer.Text))
if (
firstEmbed == null
|| !firstEmbed.Footer.TryGet(out var footer)
|| !FooterRegex().IsMatch(footer.Text)
)
{
_logger.Debug(
"PK message is not a log message because there is no first embed or its footer doesn't match the regex");
"PK message is not a log message because there is no first embed or its footer doesn't match the regex"
);
return;
}
@ -101,19 +108,28 @@ public partial class PkMessageHandler(ILogger logger, IServiceProvider services)
if (!ulong.TryParse(match.Groups[3].Value, out var authorId))
{
_logger.Debug("Author ID in PluralKit log {LogMessageId} was not a valid snowflake", msg.ID);
_logger.Debug(
"Author ID in PluralKit log {LogMessageId} was not a valid snowflake",
msg.ID
);
return;
}
if (!ulong.TryParse(match.Groups[4].Value, out var msgId))
{
_logger.Debug("Message ID in PluralKit log {LogMessageId} was not a valid snowflake", msg.ID);
_logger.Debug(
"Message ID in PluralKit log {LogMessageId} was not a valid snowflake",
msg.ID
);
return;
}
if (!ulong.TryParse(match.Groups[5].Value, out var originalId))
{
_logger.Debug("Original ID in PluralKit log {LogMessageId} was not a valid snowflake", msg.ID);
_logger.Debug(
"Original ID in PluralKit log {LogMessageId} was not a valid snowflake",
msg.ID
);
return;
}
@ -121,8 +137,13 @@ public partial class PkMessageHandler(ILogger logger, IServiceProvider services)
await using var db = scope.ServiceProvider.GetRequiredService<DatabaseContext>();
var messageRepository = scope.ServiceProvider.GetRequiredService<MessageRepository>();
await messageRepository.SetProxiedMessageDataAsync(msgId, originalId, authorId,
systemId: match.Groups[1].Value, memberId: match.Groups[2].Value);
await messageRepository.SetProxiedMessageDataAsync(
msgId,
originalId,
authorId,
systemId: match.Groups[1].Value,
memberId: match.Groups[2].Value
);
db.IgnoredMessages.Add(new IgnoredMessage(originalId));
await db.SaveChangesAsync();
@ -144,19 +165,28 @@ public partial class PkMessageHandler(ILogger logger, IServiceProvider services)
return;
}
if (hasProxyInfo) return;
if (hasProxyInfo)
return;
var pkMessage = await pluralkitApi.GetPluralKitMessageAsync(msgId);
if (pkMessage == null)
{
_logger.Debug("Message with ID {MessageId} was proxied by PluralKit, but API returned 404", msgId);
_logger.Debug(
"Message with ID {MessageId} was proxied by PluralKit, but API returned 404",
msgId
);
return;
}
await messageRepository.SetProxiedMessageDataAsync(msgId, pkMessage.Original, pkMessage.Sender,
pkMessage.System?.Id, pkMessage.Member?.Id);
await messageRepository.SetProxiedMessageDataAsync(
msgId,
pkMessage.Original,
pkMessage.Sender,
pkMessage.System?.Id,
pkMessage.Member?.Id
);
db.IgnoredMessages.Add(new IgnoredMessage(pkMessage.Original));
await db.SaveChangesAsync();
}
}
}

96
Catalogger.Backend/Bot/Responders/Messages/MessageDeleteResponder.cs
View file

@ -24,41 +24,55 @@ public class MessageDeleteResponder(
ChannelCache channelCache,
UserCache userCache,
IClock clock,
PluralkitApiService pluralkitApi) : IResponder<IMessageDelete>
PluralkitApiService pluralkitApi
) : IResponder<IMessageDelete>
{
private readonly ILogger _logger = logger.ForContext<MessageDeleteResponder>();
private static bool MaybePkProxyTrigger(Snowflake id) => id.Timestamp > DateTimeOffset.Now - 1.Minutes();
private static bool MaybePkProxyTrigger(Snowflake id) =>
id.Timestamp > DateTimeOffset.Now - 1.Minutes();
public async Task<Result> RespondAsync(IMessageDelete ev, CancellationToken ct = default)
{
if (!ev.GuildID.IsDefined()) return Result.Success;
if (!ev.GuildID.IsDefined())
return Result.Success;
if (MaybePkProxyTrigger(ev.ID))
{
_logger.Debug(
"Deleted message {MessageId} is less than 1 minute old, delaying 5 seconds to give PK time to catch up",
ev.ID);
ev.ID
);
await Task.Delay(5.Seconds(), ct);
}
if (await messageRepository.IsMessageIgnoredAsync(ev.ID.Value, ct)) return Result.Success;
if (await messageRepository.IsMessageIgnoredAsync(ev.ID.Value, ct))
return Result.Success;
var guild = await db.GetGuildAsync(ev.GuildID, ct);
if (guild.IsMessageIgnored(ev.ChannelID, ev.ID)) return Result.Success;
if (guild.IsMessageIgnored(ev.ChannelID, ev.ID))
return Result.Success;
var logChannel = webhookExecutor.GetLogChannel(guild, LogChannelType.MessageDelete, ev.ChannelID);
var logChannel = webhookExecutor.GetLogChannel(
guild,
LogChannelType.MessageDelete,
ev.ChannelID
);
var msg = await messageRepository.GetMessageAsync(ev.ID.Value, ct);
// Sometimes a message that *should* be logged isn't stored in the database, notify the user of that
if (msg == null)
{
if (logChannel == null) return Result.Success;
webhookExecutor.QueueLog(logChannel.Value, new Embed(
Title: "Message deleted",
Description: $"A message not found in the database was deleted in <#{ev.ChannelID}> ({ev.ChannelID}).",
Footer: new EmbedFooter(Text: $"ID: {ev.ID}"),
Timestamp: clock.GetCurrentInstant().ToDateTimeOffset()
));
if (logChannel == null)
return Result.Success;
webhookExecutor.QueueLog(
logChannel.Value,
new Embed(
Title: "Message deleted",
Description: $"A message not found in the database was deleted in <#{ev.ChannelID}> ({ev.ChannelID}).",
Footer: new EmbedFooter(Text: $"ID: {ev.ID}"),
Timestamp: clock.GetCurrentInstant().ToDateTimeOffset()
)
);
return Result.Success;
}
@ -71,13 +85,22 @@ public class MessageDeleteResponder(
var pkMsg = await pluralkitApi.GetPluralKitMessageAsync(ev.ID.Value, ct);
if (pkMsg != null && pkMsg.Id != ev.ID.Value && pkMsg.Original != ev.ID.Value)
{
_logger.Debug("Deleted message {MessageId} is a `pk;edit` message, ignoring", ev.ID);
_logger.Debug(
"Deleted message {MessageId} is a `pk;edit` message, ignoring",
ev.ID
);
return Result.Success;
}
}
logChannel = webhookExecutor.GetLogChannel(guild, LogChannelType.MessageDelete, ev.ChannelID, msg.UserId);
if (logChannel == null) return Result.Success;
logChannel = webhookExecutor.GetLogChannel(
guild,
LogChannelType.MessageDelete,
ev.ChannelID,
msg.UserId
);
if (logChannel == null)
return Result.Success;
var user = await userCache.GetUserAsync(DiscordSnowflake.New(msg.UserId));
var builder = new EmbedBuilder()
@ -89,23 +112,34 @@ public class MessageDeleteResponder(
if (user != null)
builder.WithAuthor(user.Tag(), url: null, iconUrl: user.AvatarUrl());
if (msg.Member != null) builder.WithTitle($"Message by {msg.Username} deleted");
if (msg.Member != null)
builder.WithTitle($"Message by {msg.Username} deleted");
string channelMention;
if (!channelCache.TryGet(ev.ChannelID, out var channel))
channelMention = $"<#{msg.ChannelId}>";
else if (channel.Type is ChannelType.AnnouncementThread or ChannelType.PrivateThread
or ChannelType.PublicThread)
else if (
channel.Type
is ChannelType.AnnouncementThread
or ChannelType.PrivateThread
or ChannelType.PublicThread
)
channelMention =
$"<#{channel.ParentID.Value}>\nID: {channel.ParentID.Value}\n\nThread: {channel.Name} (<#{channel.ID}>)";
else channelMention = $"<#{channel.ID}>\nID: {channel.ID}";
else
channelMention = $"<#{channel.ID}>\nID: {channel.ID}";
var userMention = user != null
? $"<@{user.ID}>\n{user.Tag()}\nID: {user.ID}"
: $"<@{msg.UserId}>\nID: {msg.UserId}";
var userMention =
user != null
? $"<@{user.ID}>\n{user.Tag()}\nID: {user.ID}"
: $"<@{msg.UserId}>\nID: {msg.UserId}";
builder.AddField("Channel", channelMention, true);
builder.AddField(msg.System != null ? "Linked Discord account" : "Sender", userMention, true);
builder.AddField(
msg.System != null ? "Linked Discord account" : "Sender",
userMention,
true
);
if (msg is { System: not null, Member: not null })
{
builder.AddField("\u200b", "**PluralKit information**", false);
@ -115,13 +149,17 @@ public class MessageDeleteResponder(
if (msg.Metadata != null)
{
var attachmentInfo = string.Join("\n",
var attachmentInfo = string.Join(
"\n",
msg.Metadata.Attachments.Select(a =>
$"{a.Filename} ({a.ContentType}, {a.Size.Bytes().Humanize()})"));
if (!string.IsNullOrWhiteSpace(attachmentInfo)) builder.AddField("Attachments", attachmentInfo, false);
$"{a.Filename} ({a.ContentType}, {a.Size.Bytes().Humanize()})"
)
);
if (!string.IsNullOrWhiteSpace(attachmentInfo))
builder.AddField("Attachments", attachmentInfo, false);
}
webhookExecutor.QueueLog(logChannel.Value, builder.Build().GetOrThrow());
return Result.Success;
}
}
}

150
Catalogger.Backend/Bot/Responders/Messages/MessageUpdateResponder.cs
View file

@ -21,7 +21,8 @@ public class MessageUpdateResponder(
UserCache userCache,
MessageRepository messageRepository,
WebhookExecutorService webhookExecutor,
PluralkitApiService pluralkitApi) : IResponder<IMessageUpdate>
PluralkitApiService pluralkitApi
) : IResponder<IMessageUpdate>
{
private readonly ILogger _logger = logger.ForContext<MessageUpdateResponder>();
@ -33,8 +34,10 @@ public class MessageUpdateResponder(
if (!msg.GuildID.IsDefined())
{
_logger.Debug("Received message create event for message {MessageId} despite it not being in a guild",
msg.ID);
_logger.Debug(
"Received message create event for message {MessageId} despite it not being in a guild",
msg.ID
);
return Result.Success;
}
@ -48,25 +51,39 @@ public class MessageUpdateResponder(
try
{
var logChannel = webhookExecutor.GetLogChannel(guildConfig, LogChannelType.MessageUpdate, msg.ChannelID,
msg.Author.ID.Value);
if (logChannel == null) return Result.Success;
var logChannel = webhookExecutor.GetLogChannel(
guildConfig,
LogChannelType.MessageUpdate,
msg.ChannelID,
msg.Author.ID.Value
);
if (logChannel == null)
return Result.Success;
var oldMessage = await messageRepository.GetMessageAsync(msg.ID.Value, ct);
if (oldMessage == null)
{
logger.Debug("Message {Id} was edited and should be logged but is not in the database", msg.ID);
logger.Debug(
"Message {Id} was edited and should be logged but is not in the database",
msg.ID
);
return Result.Success;
}
if (oldMessage.Content == msg.Content ||
(oldMessage.Content == "None" && string.IsNullOrEmpty(msg.Content))) return Result.Success;
if (
oldMessage.Content == msg.Content
|| (oldMessage.Content == "None" && string.IsNullOrEmpty(msg.Content))
)
return Result.Success;
var user = msg.Author;
if (msg.Author.ID != oldMessage.UserId)
{
var systemAccount = await userCache.GetUserAsync(DiscordSnowflake.New(oldMessage.UserId));
if (systemAccount != null) user = systemAccount;
var systemAccount = await userCache.GetUserAsync(
DiscordSnowflake.New(oldMessage.UserId)
);
if (systemAccount != null)
user = systemAccount;
}
var embedBuilder = new EmbedBuilder()
@ -78,19 +95,25 @@ public class MessageUpdateResponder(
.WithTimestamp(msg.ID.Timestamp);
var fields = ChunksUpTo(msg.Content, 1000)
.Select<string, IEmbedField>((s, i) =>
new EmbedField($"New content{(i != 0 ? " (cont.)" : "")}", s, false))
.Select<string, IEmbedField>(
(s, i) => new EmbedField($"New content{(i != 0 ? " (cont.)" : "")}", s, false)
)
.ToList();
embedBuilder.SetFields(fields);
string channelMention;
if (!channelCache.TryGet(msg.ChannelID, out var channel))
channelMention = $"<#{msg.ChannelID}>";
else if (channel.Type is ChannelType.AnnouncementThread or ChannelType.PrivateThread
or ChannelType.PublicThread)
else if (
channel.Type
is ChannelType.AnnouncementThread
or ChannelType.PrivateThread
or ChannelType.PublicThread
)
channelMention =
$"<#{channel.ParentID.Value}>\nID: {channel.ParentID.Value}\n\nThread: {channel.Name} (<#{channel.ID}>)";
else channelMention = $"<#{channel.ID}>\nID: {channel.ID}";
else
channelMention = $"<#{channel.ID}>\nID: {channel.ID}";
embedBuilder.AddField("Channel", channelMention, true);
embedBuilder.AddField("Sender", $"<@{user.ID}>\n{user.Tag()}\nID: {user.ID}", true);
@ -103,7 +126,10 @@ public class MessageUpdateResponder(
embedBuilder.AddField("Member ID", oldMessage.Member, true);
}
embedBuilder.AddField("Link", $"https://discord.com/channels/{msg.GuildID}/{msg.ChannelID}/{msg.ID}");
embedBuilder.AddField(
"Link",
$"https://discord.com/channels/{msg.GuildID}/{msg.ChannelID}/{msg.ID}"
);
webhookExecutor.QueueLog(logChannel.Value, embedBuilder.Build().GetOrThrow());
return Result.Success;
@ -113,39 +139,91 @@ public class MessageUpdateResponder(
// Messages should be *saved* if any of the message events are enabled for this channel, but should only
// be *logged* if the MessageUpdate event is enabled, so we check if we should save here.
// You also can't return early in `finally` blocks, so this has to be nested :(
if (webhookExecutor.GetLogChannel(guildConfig, LogChannelType.MessageUpdate, msg.ChannelID,
msg.Author.ID.Value) != null || webhookExecutor.GetLogChannel(guildConfig,
LogChannelType.MessageDelete, msg.ChannelID,
msg.Author.ID.Value) != null || webhookExecutor.GetLogChannel(guildConfig,
LogChannelType.MessageDeleteBulk, msg.ChannelID,
msg.Author.ID.Value) != null)
if (
webhookExecutor.GetLogChannel(
guildConfig,
LogChannelType.MessageUpdate,
msg.ChannelID,
msg.Author.ID.Value
) != null
|| webhookExecutor.GetLogChannel(
guildConfig,
LogChannelType.MessageDelete,
msg.ChannelID,
msg.Author.ID.Value
) != null
|| webhookExecutor.GetLogChannel(
guildConfig,
LogChannelType.MessageDeleteBulk,
msg.ChannelID,
msg.Author.ID.Value
) != null
)
{
if (!await messageRepository.UpdateMessageAsync(msg, ct) && msg.ApplicationID.Is(DiscordUtils.PkUserId))
if (
!await messageRepository.UpdateMessageAsync(msg, ct)
&& msg.ApplicationID.Is(DiscordUtils.PkUserId)
)
{
_logger.Debug(
"Message {MessageId} wasn't stored yet and was proxied by PluralKit, fetching proxy information from its API",
msg.ID);
msg.ID
);
var pkMsg = await pluralkitApi.GetPluralKitMessageAsync(msg.ID.Value, ct);
if (pkMsg != null)
await messageRepository.SetProxiedMessageDataAsync(msg.ID.Value, pkMsg.Original, pkMsg.Sender,
pkMsg.System?.Id, pkMsg.Member?.Id);
await messageRepository.SetProxiedMessageDataAsync(
msg.ID.Value,
pkMsg.Original,
pkMsg.Sender,
pkMsg.System?.Id,
pkMsg.Member?.Id
);
}
}
}
}
private static MessageCreate ConvertToMessageCreate(IMessageUpdate evt) => new(evt.GuildID, evt.Member,
evt.Mentions.GetOrThrow(), evt.ID.GetOrThrow(), evt.ChannelID.GetOrThrow(), evt.Author.GetOrThrow(),
evt.Content.GetOrThrow(), evt.Timestamp.GetOrThrow(), evt.EditedTimestamp.GetOrThrow(), IsTTS: false,
evt.MentionsEveryone.GetOrThrow(), evt.MentionedRoles.GetOrThrow(), evt.MentionedChannels,
evt.Attachments.GetOrThrow(), evt.Embeds.GetOrThrow(), evt.Reactions, evt.Nonce, evt.IsPinned.GetOrThrow(),
evt.WebhookID, evt.Type.GetOrThrow(), evt.Activity, evt.Application, evt.ApplicationID, evt.MessageReference,
evt.Flags, evt.ReferencedMessage, evt.Interaction, evt.Thread, evt.Components, evt.StickerItems, evt.Position,
evt.Resolved, evt.InteractionMetadata, evt.Poll);
private static MessageCreate ConvertToMessageCreate(IMessageUpdate evt) =>
new(
evt.GuildID,
evt.Member,
evt.Mentions.GetOrThrow(),
evt.ID.GetOrThrow(),
evt.ChannelID.GetOrThrow(),
evt.Author.GetOrThrow(),
evt.Content.GetOrThrow(),
evt.Timestamp.GetOrThrow(),
evt.EditedTimestamp.GetOrThrow(),
IsTTS: false,
evt.MentionsEveryone.GetOrThrow(),
evt.MentionedRoles.GetOrThrow(),
evt.MentionedChannels,
evt.Attachments.GetOrThrow(),
evt.Embeds.GetOrThrow(),
evt.Reactions,
evt.Nonce,
evt.IsPinned.GetOrThrow(),
evt.WebhookID,
evt.Type.GetOrThrow(),
evt.Activity,
evt.Application,
evt.ApplicationID,
evt.MessageReference,
evt.Flags,
evt.ReferencedMessage,
evt.Interaction,
evt.Thread,
evt.Components,
evt.StickerItems,
evt.Position,
evt.Resolved,
evt.InteractionMetadata,
evt.Poll
);
private static IEnumerable<string> ChunksUpTo(string str, int maxChunkSize)
{
for (var i = 0; i < str.Length; i += maxChunkSize)
yield return str.Substring(i, Math.Min(maxChunkSize, str.Length - i));
}
}
}

17
Catalogger.Backend/Bot/Responders/ReadyResponder.cs
View file

@ -13,11 +13,18 @@ public class ReadyResponder(ILogger logger, WebhookExecutorService webhookExecut
public Task<Result> RespondAsync(IReady gatewayEvent, CancellationToken ct = default)
{
var shardId = gatewayEvent.Shard.TryGet(out var shard) ? (shard.ShardID, shard.ShardCount) : (0, 1);
_logger.Information("Ready as {User} on shard {ShardId} / {ShardCount}", gatewayEvent.User.Tag(), shardId.Item1,
shardId.Item2);
if (shardId.Item1 == 0) webhookExecutorService.SetSelfUser(gatewayEvent.User);
var shardId = gatewayEvent.Shard.TryGet(out var shard)
? (shard.ShardID, shard.ShardCount)
: (0, 1);
_logger.Information(
"Ready as {User} on shard {ShardId} / {ShardCount}",
gatewayEvent.User.Tag(),
shardId.Item1,
shardId.Item2
);
if (shardId.Item1 == 0)
webhookExecutorService.SetSelfUser(gatewayEvent.User);
return Task.FromResult(Result.Success);
}
}
}

17
Catalogger.Backend/Bot/Responders/Roles/RoleCreateResponder.cs
View file

@ -14,7 +14,8 @@ public class RoleCreateResponder(
ILogger logger,
DatabaseContext db,
RoleCache roleCache,
WebhookExecutorService webhookExecutor) : IResponder<IGuildRoleCreate>
WebhookExecutorService webhookExecutor
) : IResponder<IGuildRoleCreate>
{
private readonly ILogger _logger = logger.ForContext<RoleCreateResponder>();
@ -28,16 +29,22 @@ public class RoleCreateResponder(
var embed = new EmbedBuilder()
.WithTitle("Role created")
.WithColour(DiscordUtils.Green)
.WithDescription($"**Name:** {evt.Role.Name}\n**Colour:** {evt.Role.Colour.ToPrettyString()}" +
$"\n**Mentionable:** {evt.Role.IsMentionable}\n**Shown separately:** {evt.Role.IsHoisted}");
.WithDescription(
$"**Name:** {evt.Role.Name}\n**Colour:** {evt.Role.Colour.ToPrettyString()}"
+ $"\n**Mentionable:** {evt.Role.IsMentionable}\n**Shown separately:** {evt.Role.IsHoisted}"
);
if (!evt.Role.Permissions.Value.IsZero)
{
embed.AddField("Permissions", evt.Role.Permissions.ToPrettyString(), inline: false);
}
webhookExecutor.QueueLog(guildConfig, LogChannelType.GuildRoleCreate, embed.Build().GetOrThrow());
webhookExecutor.QueueLog(
guildConfig,
LogChannelType.GuildRoleCreate,
embed.Build().GetOrThrow()
);
return Result.Success;
}
}
}

52
Catalogger.Backend/Bot/Responders/Roles/RoleUpdateResponder.cs
View file

@ -12,22 +12,27 @@ using Remora.Results;
namespace Catalogger.Backend.Bot.Responders.Roles;
public class RoleUpdateResponder(ILogger logger,
public class RoleUpdateResponder(
ILogger logger,
DatabaseContext db,
RoleCache roleCache,
WebhookExecutorService webhookExecutor) : IResponder<IGuildRoleUpdate>
WebhookExecutorService webhookExecutor
) : IResponder<IGuildRoleUpdate>
{
private readonly ILogger _logger = logger.ForContext<RoleUpdateResponder>();
public async Task<Result> RespondAsync(IGuildRoleUpdate evt, CancellationToken ct = default)
{
try
{
var newRole = evt.Role;
if (!roleCache.TryGet(evt.Role.ID, out var oldRole))
{
_logger.Information("Received role update event for {RoleId} but it wasn't cached, ignoring", evt.Role.ID);
_logger.Information(
"Received role update event for {RoleId} but it wasn't cached, ignoring",
evt.Role.ID
);
return Result.Success;
}
@ -42,21 +47,31 @@ public class RoleUpdateResponder(ILogger logger,
embed.AddField("Name", $"**Before:** {oldRole.Name}\n**After:** {newRole.Name}");
}
if (newRole.IsHoisted != oldRole.IsHoisted || newRole.IsMentionable != oldRole.IsMentionable)
if (
newRole.IsHoisted != oldRole.IsHoisted
|| newRole.IsMentionable != oldRole.IsMentionable
)
{
embed.AddField(
"\u200b", $"**Mentionable:** {newRole.IsMentionable}\n**Shown separately:** {newRole.IsHoisted}");
"\u200b",
$"**Mentionable:** {newRole.IsMentionable}\n**Shown separately:** {newRole.IsHoisted}"
);
}
if (newRole.Colour != oldRole.Colour)
{
embed.AddField("Colour",
$"**Before:** {oldRole.Colour.ToPrettyString()}\n**After:** {newRole.Colour.ToPrettyString()}");
embed.AddField(
"Colour",
$"**Before:** {oldRole.Colour.ToPrettyString()}\n**After:** {newRole.Colour.ToPrettyString()}"
);
}
if (newRole.Permissions.Value != oldRole.Permissions.Value)
{
var diff = string.Join("\n", PermissionUpdate(oldRole.Permissions, newRole.Permissions));
var diff = string.Join(
"\n",
PermissionUpdate(oldRole.Permissions, newRole.Permissions)
);
embed.AddField("Permissions", $"```diff\n{diff}\n```");
}
@ -67,9 +82,13 @@ public class RoleUpdateResponder(ILogger logger,
_logger.Debug("We don't care about update of role {RoleId}, ignoring", evt.Role.ID);
return Result.Success;
}
var guildConfig = await db.GetGuildAsync(evt.GuildID, ct);
webhookExecutor.QueueLog(guildConfig, LogChannelType.GuildRoleUpdate, embed.Build().GetOrThrow());
webhookExecutor.QueueLog(
guildConfig,
LogChannelType.GuildRoleUpdate,
embed.Build().GetOrThrow()
);
}
finally
{
@ -78,8 +97,11 @@ public class RoleUpdateResponder(ILogger logger,
return Result.Success;
}
private static IEnumerable<string> PermissionUpdate(IDiscordPermissionSet oldValue, IDiscordPermissionSet newValue)
private static IEnumerable<string> PermissionUpdate(
IDiscordPermissionSet oldValue,
IDiscordPermissionSet newValue
)
{
foreach (var perm in Enum.GetValues<DiscordPermission>())
{
@ -93,4 +115,4 @@ public class RoleUpdateResponder(ILogger logger,
}
}
}
}
}

5
Catalogger.Backend/Bot/ShardedDiscordService.cs
View file

@ -2,7 +2,8 @@ using Remora.Discord.Gateway.Results;
namespace Catalogger.Backend.Bot;
public class ShardedDiscordService(ShardedGatewayClient client, IHostApplicationLifetime lifetime) : BackgroundService
public class ShardedDiscordService(ShardedGatewayClient client, IHostApplicationLifetime lifetime)
: BackgroundService
{
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
@ -10,4 +11,4 @@ public class ShardedDiscordService(ShardedGatewayClient client, IHostApplication
if (result.Error is GatewayError { IsCritical: true })
lifetime.StopApplication();
}
}
}

61
Catalogger.Backend/Bot/ShardedGatewayClient.cs
View file

@ -16,18 +16,22 @@ public class ShardedGatewayClient(
IDiscordRestGatewayAPI gatewayApi,
IServiceProvider services,
IOptions<DiscordGatewayClientOptions> gatewayClientOptions,
Config config)
: IDisposable
Config config
) : IDisposable
{
private int _shardCount = config.Discord.ShardCount ?? 0;
private readonly ILogger _logger = logger.ForContext<ShardedGatewayClient>();
private readonly ConcurrentDictionary<int, DiscordGatewayClient> _gatewayClients = new();
private static readonly FieldInfo Field =
typeof(DiscordGatewayClient).GetField("_connectionStatus", BindingFlags.Instance | BindingFlags.NonPublic)!;
private static readonly FieldInfo Field = typeof(DiscordGatewayClient).GetField(
"_connectionStatus",
BindingFlags.Instance | BindingFlags.NonPublic
)!;
private static readonly Func<DiscordGatewayClient, GatewayConnectionStatus> GetConnectionStatus =
client => (GatewayConnectionStatus)Field.GetValue(client)!;
private static readonly Func<
DiscordGatewayClient,
GatewayConnectionStatus
> GetConnectionStatus = client => (GatewayConnectionStatus)Field.GetValue(client)!;
public IReadOnlyDictionary<int, DiscordGatewayClient> Shards => _gatewayClients;
@ -45,19 +49,26 @@ public class ShardedGatewayClient(
if (_shardCount < discordShardCount && _shardCount != 0)
_logger.Warning(
"Discord recommends {DiscordShardCount} for this bot, but only {ConfigShardCount} shards are requested. This may cause issues later",
discordShardCount, _shardCount);
discordShardCount,
_shardCount
);
if (_shardCount == 0) _shardCount = discordShardCount;
if (_shardCount == 0)
_shardCount = discordShardCount;
}
var clients = Enumerable.Range(0, _shardCount).Select(s =>
{
var client =
ActivatorUtilities.CreateInstance<DiscordGatewayClient>(services,
CloneOptions(gatewayClientOptions.Value, s));
_gatewayClients[s] = client;
return client;
}).ToArray();
var clients = Enumerable
.Range(0, _shardCount)
.Select(s =>
{
var client = ActivatorUtilities.CreateInstance<DiscordGatewayClient>(
services,
CloneOptions(gatewayClientOptions.Value, s)
);
_gatewayClients[s] = client;
return client;
})
.ToArray();
var tasks = new List<Task<Result>>();
@ -69,7 +80,10 @@ public class ShardedGatewayClient(
var res = client.RunAsync(ct);
tasks.Add(res);
while (GetConnectionStatus(client) is not GatewayConnectionStatus.Connected && !res.IsCompleted)
while (
GetConnectionStatus(client) is not GatewayConnectionStatus.Connected
&& !res.IsCompleted
)
{
await Task.Delay(100, ct);
}
@ -92,7 +106,9 @@ public class ShardedGatewayClient(
public DiscordGatewayClient ClientFor(ulong guildId) =>
_gatewayClients.TryGetValue(ShardIdFor(guildId), out var client)
? client
: throw new CataloggerError("Shard was null, has ShardedGatewayClient.RunAsync been called?");
: throw new CataloggerError(
"Shard was null, has ShardedGatewayClient.RunAsync been called?"
);
public void Dispose()
{
@ -100,7 +116,10 @@ public class ShardedGatewayClient(
client.Dispose();
}
private IOptions<DiscordGatewayClientOptions> CloneOptions(DiscordGatewayClientOptions options, int shardId)
private IOptions<DiscordGatewayClientOptions> CloneOptions(
DiscordGatewayClientOptions options,
int shardId
)
{
var ret = new DiscordGatewayClientOptions
{
@ -112,9 +131,9 @@ public class ShardedGatewayClient(
LargeThreshold = options.LargeThreshold,
CommandBurstRate = options.CommandBurstRate,
HeartbeatSafetyMargin = options.HeartbeatSafetyMargin,
MinimumSafetyMargin = options.MinimumSafetyMargin
MinimumSafetyMargin = options.MinimumSafetyMargin,
};
return Options.Create(ret);
}
}
}