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

init

Browse source
This commit is contained in:
sam 2024-08-13 13:08:50 +02:00
commit ded4f4db26
Signed by: sam
GPG key ID: 5F3C3C1B3166639D
43 changed files with 2052 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

49
Catalogger.Backend/Bot/Responders/GuildCreateResponder.cs Normal file
View file

@ -0,0 +1,49 @@
using System.Diagnostics;
using Catalogger.Backend.Cache;
using Catalogger.Backend.Database;
using Catalogger.Backend.Database.Models;
using Catalogger.Backend.Extensions;
using Remora.Discord.API.Abstractions.Gateway.Events;
using Remora.Discord.Gateway.Responders;
using Remora.Results;
namespace Catalogger.Backend.Bot.Responders;
public class GuildCreateResponder(ILogger logger, DatabaseContext db, ChannelCacheService channelCache)
: IResponder<IGuildCreate>
{
private readonly ILogger _logger = logger.ForContext<GuildCreateResponder>();
public async Task<Result> RespondAsync(IGuildCreate evt, CancellationToken ct = default)
{
ulong guildId;
string? guildName = null;
if (evt.Guild.TryPickT0(out var guild, out _))
{
_logger.Verbose("Received guild create for available guild {GuildId} ({Name})", guild.ID, guild.Name);
guildId = guild.ID.ToUlong();
guildName = guild.Name;
foreach (var c in guild.Channels) channelCache.AddChannel(c, guild.ID);
}
else if (evt.Guild.TryPickT1(out var unavailableGuild, out _))
{
_logger.Verbose("Received guild create for unavailable guild {GuildId}", unavailableGuild.ID);
guildId = unavailableGuild.ID.ToUlong();
}
else throw new UnreachableException();
var tx = await db.Database.BeginTransactionAsync(ct);
if (await db.Guilds.FindAsync([guildId], ct) != null) return Result.Success;
db.Add(new Guild
{
Id = guildId
});
await db.SaveChangesAsync(ct);
await tx.CommitAsync(ct);
_logger.Information("Joined new guild {GuildId} ({Name})", guildId, guildName);
return Result.Success;
}
}

157
Catalogger.Backend/Bot/Responders/MessageCreateResponder.cs Normal file
View file

@ -0,0 +1,157 @@
using System.Text.RegularExpressions;
using Catalogger.Backend.Cache;
using Catalogger.Backend.Database;
using Catalogger.Backend.Database.Models;
using Catalogger.Backend.Database.Queries;
using Catalogger.Backend.Extensions;
using Catalogger.Backend.Services;
using Humanizer;
using Remora.Discord.API;
using Remora.Discord.API.Abstractions.Gateway.Events;
using Remora.Discord.Gateway.Responders;
using Remora.Rest.Core;
using Remora.Results;
namespace Catalogger.Backend.Bot.Responders;
public class MessageCreateResponder(
ILogger logger,
DatabaseContext db,
MessageRepository messageRepository,
UserCacheService userCache,
PkMessageHandler pkMessageHandler)
: IResponder<IMessageCreate>
{
private readonly ILogger _logger = logger.ForContext<MessageCreateResponder>();
private static readonly Snowflake PkUserId = DiscordSnowflake.New(466378653216014359);
public async Task<Result> RespondAsync(IMessageCreate msg, CancellationToken ct = default)
{
userCache.UpdateUser(msg.Author);
if (!msg.GuildID.IsDefined())
{
_logger.Debug("Received message create event for message {MessageId} despite it not being in a guild",
msg.ID);
return Result.Success;
}
var guild = await db.GetGuildAsync(msg.GuildID, ct);
// The guild needs to have enabled at least one of the message logging events,
// and the channel must not be ignored, to store the message.
if (guild.IsMessageIgnored(msg.ChannelID, msg.Author.ID))
{
db.IgnoredMessages.Add(new IgnoredMessage(msg.ID.ToUlong()));
await db.SaveChangesAsync(ct);
return Result.Success;
}
if (msg.Author.ID == PkUserId)
_ = pkMessageHandler.HandlePkMessageAsync(msg);
if (msg.ApplicationID.IsDefined(out var appId) && appId == PkUserId)
_ = pkMessageHandler.HandleProxiedMessageAsync(msg.ID.Value);
await messageRepository.SaveMessageAsync(msg, ct);
return Result.Success;
}
}
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+)$")]
private static partial Regex FooterRegex();
[GeneratedRegex(@"^https:\/\/discord.com\/channels\/\d+\/(\d+)\/\d+$")]
private static partial Regex LinkRegex();
public async Task HandlePkMessageAsync(IMessageCreate msg)
{
_logger.Debug("Received PluralKit message");
await Task.Delay(500.Milliseconds());
_logger.Debug("Starting handling PluralKit message");
// Check if the content matches a Discord link--if not, it's not a log message (we already check if this is a PluralKit message earlier)
if (!LinkRegex().IsMatch(msg.Content))
{
_logger.Debug("PluralKit message is not a log message because content is not a link");
return;
}
// 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))
{
_logger.Debug(
"PK message is not a log message because there is no first embed or its footer doesn't match the regex");
return;
}
var match = FooterRegex().Match(footer.Text);
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);
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);
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);
return;
}
await using var scope = services.CreateAsyncScope();
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);
db.IgnoredMessages.Add(new IgnoredMessage(originalId));
await db.SaveChangesAsync();
}
public async Task HandleProxiedMessageAsync(ulong msgId)
{
await Task.Delay(3.Seconds());
await using var scope = services.CreateAsyncScope();
await using var db = scope.ServiceProvider.GetRequiredService<DatabaseContext>();
var messageRepository = scope.ServiceProvider.GetRequiredService<MessageRepository>();
var pluralkitApi = scope.ServiceProvider.GetRequiredService<PluralkitApiService>();
var (isStored, hasProxyInfo) = await messageRepository.HasProxyInfoAsync(msgId);
if (!isStored)
{
_logger.Debug("Message with ID {MessageId} is not stored in the database", msgId);
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);
return;
}
await messageRepository.SetProxiedMessageDataAsync(msgId, pkMessage.Original, pkMessage.Sender,
pkMessage.System?.Id, pkMessage.Member?.Id);
db.IgnoredMessages.Add(new IgnoredMessage(pkMessage.Original));
await db.SaveChangesAsync();
}
}

102
Catalogger.Backend/Bot/Responders/MessageDeleteResponder.cs Normal file
View file

@ -0,0 +1,102 @@
using Catalogger.Backend.Cache;
using Catalogger.Backend.Database;
using Catalogger.Backend.Database.Queries;
using Catalogger.Backend.Extensions;
using Catalogger.Backend.Services;
using Humanizer;
using NodaTime;
using Remora.Discord.API;
using Remora.Discord.API.Abstractions.Gateway.Events;
using Remora.Discord.API.Abstractions.Objects;
using Remora.Discord.API.Objects;
using Remora.Discord.Extensions.Embeds;
using Remora.Discord.Gateway.Responders;
using Remora.Results;
namespace Catalogger.Backend.Bot.Responders;
public class MessageDeleteResponder(
ILogger logger,
DatabaseContext db,
MessageRepository messageRepository,
WebhookExecutorService webhookExecutor,
ChannelCacheService channelCache,
UserCacheService userCache,
IClock clock) : IResponder<IMessageDelete>
{
private readonly ILogger _logger = logger.ForContext<MessageDeleteResponder>();
public async Task<Result> RespondAsync(IMessageDelete ev, CancellationToken ct = default)
{
if (!ev.GuildID.IsDefined()) return Result.Success;
if (ev.ID.Timestamp < DateTimeOffset.Now - 1.Minutes())
{
_logger.Debug(
"Deleted message {MessageId} is less than 1 minute old, delaying 5 seconds to give PK time to catch up",
ev.ID);
await Task.Delay(5.Seconds(), ct);
}
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;
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;
await webhookExecutor.QueueLogAsync(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;
}
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()
.WithTitle("Message deleted")
.WithDescription(msg.Content)
.WithColour(DiscordUtils.Red)
.WithFooter($"ID: {msg.Id}")
.WithTimestamp(ev.ID);
if (user != null)
builder.WithAuthor(user.Tag(), url: null, iconUrl: user.AvatarUrl());
if (msg.Member != null) builder.WithTitle($"Message by {msg.Username} deleted");
string channelMention;
if (!channelCache.GetChannel(ev.ChannelID, out var channel))
channelMention = $"<#{msg.ChannelId}>";
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}";
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);
if (msg is { System: not null, Member: not null })
{
builder.AddField("\u200b", "**PluralKit information**", false);
builder.AddField("System ID", msg.System, true);
builder.AddField("Member ID", msg.Member, true);
}
await webhookExecutor.QueueLogAsync(logChannel.Value, builder.Build().GetOrThrow());
return Result.Success;
}
}

27
Catalogger.Backend/Bot/Responders/ReadyResponder.cs Normal file
View file

@ -0,0 +1,27 @@
using Catalogger.Backend.Extensions;
using Catalogger.Backend.Services;
using Remora.Discord.API.Abstractions.Gateway.Events;
using Remora.Discord.Gateway.Responders;
using Remora.Results;
namespace Catalogger.Backend.Bot.Responders;
public class ReadyResponder(ILogger logger, WebhookExecutorService webhookExecutorService, Config config)
: IResponder<IReady>
{
private readonly ILogger _logger = logger.ForContext<ReadyResponder>();
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);
// Sanity check
var appId = gatewayEvent.Application.ID.ToUlong();
_logger.Debug("Application ID is {ApplicationId}, is same as config? {SameAsConfig}", appId,
appId == config.Discord.ApplicationId);
return Task.FromResult(Result.Success);
}
}