private bool IsLatchExpired(ulong?messageId)
{
if (messageId == null)
{
return(true);
}
var timestamp = DiscordUtils.SnowflakeToInstant(messageId.Value);
return(_clock.GetCurrentInstant() - timestamp > LatchExpiryTime);
}
public DiscordEmbed CreateLoggedMessageEmbed(PKSystem system, PKMember member, ulong messageId, ulong originalMsgId, DiscordUser sender, string content, DiscordChannel channel)
{
// TODO: pronouns in ?-reacted response using this card
var timestamp = DiscordUtils.SnowflakeToInstant(messageId);
return(new DiscordEmbedBuilder()
.WithAuthor($"#{channel.Name}: {member.Name}", iconUrl: DiscordUtils.WorkaroundForUrlBug(member.AvatarUrl))
.WithThumbnailUrl(member.AvatarUrl)
.WithDescription(content?.NormalizeLineEndSpacing())
.WithFooter($"System ID: {system.Hid} | Member ID: {member.Hid} | Sender: {sender.Username}#{sender.Discriminator} ({sender.Id}) | Message ID: {messageId} | Original Message ID: {originalMsgId}")
.WithTimestamp(timestamp.ToDateTimeOffset())
.Build());
}
public Embed CreateEditedMessageEmbed(PKSystem system, PKMember member, ulong messageId, ulong originalMsgId, User sender, string content, string oldContent, Channel channel)
{
var timestamp = DiscordUtils.SnowflakeToInstant(messageId);
var name = member.NameFor(LookupContext.ByNonOwner);
return(new EmbedBuilder()
.Author(new($"[Edited] #{channel.Name}: {name}", IconUrl: DiscordUtils.WorkaroundForUrlBug(member.AvatarFor(LookupContext.ByNonOwner))))
.Thumbnail(new(member.AvatarFor(LookupContext.ByNonOwner)))
.Field(new("Old message", oldContent?.NormalizeLineEndSpacing().Truncate(1000)))
.Description(content?.NormalizeLineEndSpacing())
.Footer(new($"System ID: {system.Hid} | Member ID: {member.Hid} | Sender: {sender.Username}#{sender.Discriminator} ({sender.Id}) | Message ID: {messageId} | Original Message ID: {originalMsgId}"))
.Timestamp(timestamp.ToDateTimeOffset().ToString("O"))
.Build());
}
public void RenderPage(DiscordEmbedBuilder eb, DateTimeZone zone, IEnumerable <ListedMember> members)
{
string FormatTimestamp(Instant timestamp) => DateTimeFormats.ZonedDateTimeFormat.Format(timestamp.InZone(zone));
foreach (var m in members)
{
var profile = $"**ID**: {m.Hid}";
if (_fields.ShowDisplayName && m.DisplayName != null)
{
profile += $"\n**Display name**: {m.DisplayName}";
}
if (_fields.ShowPronouns && m.Pronouns != null)
{
profile += $"\n**Pronouns**: {m.Pronouns}";
}
if (_fields.ShowBirthday && m.Birthday != null)
{
profile += $"\n**Birthdate**: {m.BirthdayString}";
}
if (_fields.ShowPronouns && m.ProxyTags.Count > 0)
{
profile += $"\n**Proxy tags:** {m.ProxyTagsString()}";
}
if (_fields.ShowMessageCount && m.MessageCount > 0)
{
profile += $"\n**Message count:** {m.MessageCount}";
}
if (_fields.ShowLastMessage && m.LastMessage != null)
{
profile += $"\n**Last message:** {FormatTimestamp(DiscordUtils.SnowflakeToInstant(m.LastMessage.Value))}";
}
if (_fields.ShowLastSwitch && m.LastSwitchTime != null)
{
profile += $"\n**Last switched in:** {FormatTimestamp(m.LastSwitchTime.Value)}";
}
if (_fields.ShowDescription && m.Description != null)
{
profile += $"\n\n{m.Description}";
}
if (_fields.ShowPrivacy && m.MemberPrivacy == PrivacyLevel.Private)
{
profile += "\n*(this member is private)*";
}
eb.AddField(m.Name, profile.Truncate(1024));
}
}
public void RenderPage(DiscordEmbedBuilder eb, DateTimeZone zone, IEnumerable <ListedMember> members, LookupContext ctx)
{
foreach (var m in members)
{
var profile = $"**ID**: {m.Hid}";
if (_fields.ShowDisplayName && m.DisplayName != null && m.NamePrivacy.CanAccess(ctx))
{
profile += $"\n**Display name**: {m.DisplayName}";
}
if (_fields.ShowPronouns && m.PronounsFor(ctx) is {} pronouns)
{
profile += $"\n**Pronouns**: {pronouns}";
}
if (_fields.ShowBirthday && m.BirthdayFor(ctx) != null)
{
profile += $"\n**Birthdate**: {m.BirthdayString}";
}
if (_fields.ShowProxyTags && m.ProxyTags.Count > 0)
{
profile += $"\n**Proxy tags:** {m.ProxyTagsString()}";
}
if (_fields.ShowMessageCount && m.MessageCountFor(ctx) is {} count&& count > 0)
{
profile += $"\n**Message count:** {count}";
}
if (_fields.ShowLastMessage && m.MetadataPrivacy.TryGet(ctx, m.LastMessage, out var lastMsg))
{
profile += $"\n**Last message:** {DiscordUtils.SnowflakeToInstant(lastMsg.Value).FormatZoned(zone)}";
}
if (_fields.ShowLastSwitch && m.MetadataPrivacy.TryGet(ctx, m.LastSwitchTime, out var lastSw))
{
profile += $"\n**Last switched in:** {lastSw.Value.FormatZoned(zone)}";
}
if (_fields.ShowDescription && m.DescriptionFor(ctx) is {} desc)
{
profile += $"\n\n{desc}";
}
if (_fields.ShowPrivacy && m.MemberVisibility == PrivacyLevel.Private)
{
profile += "\n*(this member is hidden)*";
}
eb.AddField(m.NameFor(ctx), profile.Truncate(1024));
}
}
private bool IsLatchExpired(MessageContext ctx)
{
if (ctx.LastMessage == null)
{
return(true);
}
if (ctx.LatchTimeout == 0)
{
return(false);
}
var timeout = ctx.LatchTimeout.HasValue
? Duration.FromSeconds(ctx.LatchTimeout.Value)
: DefaultLatchExpiryTime;
var timestamp = DiscordUtils.SnowflakeToInstant(ctx.LastMessage.Value);
return(_clock.GetCurrentInstant() - timestamp > timeout);
}
private async Task <PKMessage?> FindRecentMessage(Context ctx)
{
await using var conn = await _db.Obtain();
var lastMessage = await _repo.GetLastMessage(conn, ctx.Guild.Id, ctx.Channel.Id, ctx.Author.Id);
if (lastMessage == null)
{
return(null);
}
var timestamp = DiscordUtils.SnowflakeToInstant(lastMessage.Mid);
if (_clock.GetCurrentInstant() - timestamp > EditTimeout)
{
return(null);
}
return(lastMessage);
}
public async Task <DiscordEmbed> CreateMessageInfoEmbed(DiscordClient client, FullMessage msg)
{
var ctx = LookupContext.ByNonOwner;
var channel = await _client.GetChannel(msg.Message.Channel);
var serverMsg = channel != null ? await channel.GetMessage(msg.Message.Mid) : null;
// Need this whole dance to handle cases where:
// - the user is deleted (userInfo == null)
// - the bot's no longer in the server we're querying (channel == null)
// - the member is no longer in the server we're querying (memberInfo == null)
DiscordMember memberInfo = null;
DiscordUser userInfo = null;
if (channel != null)
{
memberInfo = await channel.Guild.GetMember(msg.Message.Sender);
}
if (memberInfo != null)
{
userInfo = memberInfo; // Don't do an extra request if we already have this info from the member lookup
}
else
{
userInfo = await client.GetUser(msg.Message.Sender);
}
// Calculate string displayed under "Sent by"
string userStr;
if (memberInfo != null && memberInfo.Nickname != null)
{
userStr = $"**Username:** {memberInfo.NameAndMention()}\n**Nickname:** {memberInfo.Nickname}";
}
else if (userInfo != null)
{
userStr = userInfo.NameAndMention();
}
else
{
userStr = $"*(deleted user {msg.Message.Sender})*";
}
// Put it all together
var eb = new DiscordEmbedBuilder()
.WithAuthor(msg.Member.NameFor(ctx), iconUrl: DiscordUtils.WorkaroundForUrlBug(msg.Member.AvatarFor(ctx)))
.WithDescription(serverMsg?.Content?.NormalizeLineEndSpacing() ?? "*(message contents deleted or inaccessible)*")
.WithImageUrl(serverMsg?.Attachments?.FirstOrDefault()?.Url)
.AddField("System",
msg.System.Name != null ? $"{msg.System.Name} (`{msg.System.Hid}`)" : $"`{msg.System.Hid}`", true)
.AddField("Member", $"{msg.Member.NameFor(ctx)} (`{msg.Member.Hid}`)", true)
.AddField("Sent by", userStr, inline: true)
.WithTimestamp(DiscordUtils.SnowflakeToInstant(msg.Message.Mid).ToDateTimeOffset());
var roles = memberInfo?.Roles?.ToList();
if (roles != null && roles.Count > 0)
{
eb.AddField($"Account roles ({roles.Count})", string.Join(", ", roles.Select(role => role.Name)));
}
return(eb.Build());
}
public async Task <Embed> CreateMessageInfoEmbed(FullMessage msg)
{
var channel = await _cache.GetOrFetchChannel(_rest, msg.Message.Channel);
var ctx = LookupContext.ByNonOwner;
Message serverMsg = null;
try
{
serverMsg = await _rest.GetMessage(msg.Message.Channel, msg.Message.Mid);
}
catch (ForbiddenException)
{
// no permission, couldn't fetch, oh well
}
// Need this whole dance to handle cases where:
// - the user is deleted (userInfo == null)
// - the bot's no longer in the server we're querying (channel == null)
// - the member is no longer in the server we're querying (memberInfo == null)
// TODO: optimize ordering here a bit with new cache impl; and figure what happens if bot leaves server -> channel still cached -> hits this bit and 401s?
GuildMemberPartial memberInfo = null;
User userInfo = null;
if (channel != null)
{
GuildMember member = null;
try
{
member = await _rest.GetGuildMember(channel.GuildId !.Value, msg.Message.Sender);
}
catch (ForbiddenException)
{
// no permission, couldn't fetch, oh well
}
if (member != null)
{
// Don't do an extra request if we already have this info from the member lookup
userInfo = member.User;
}
memberInfo = member;
}
if (userInfo == null)
{
userInfo = await _cache.GetOrFetchUser(_rest, msg.Message.Sender);
}
// Calculate string displayed under "Sent by"
string userStr;
if (memberInfo != null && memberInfo.Nick != null)
{
userStr = $"**Username:** {userInfo.NameAndMention()}\n**Nickname:** {memberInfo.Nick}";
}
else if (userInfo != null)
{
userStr = userInfo.NameAndMention();
}
else
{
userStr = $"*(deleted user {msg.Message.Sender})*";
}
// Put it all together
var eb = new EmbedBuilder()
.Author(new(msg.Member.NameFor(ctx), IconUrl: DiscordUtils.WorkaroundForUrlBug(msg.Member.AvatarFor(ctx))))
.Description(serverMsg?.Content?.NormalizeLineEndSpacing() ?? "*(message contents deleted or inaccessible)*")
.Image(new(serverMsg?.Attachments?.FirstOrDefault()?.Url))
.Field(new("System",
msg.System.Name != null ? $"{msg.System.Name} (`{msg.System.Hid}`)" : $"`{msg.System.Hid}`", true))
.Field(new("Member", $"{msg.Member.NameFor(ctx)} (`{msg.Member.Hid}`)", true))
.Field(new("Sent by", userStr, true))
.Timestamp(DiscordUtils.SnowflakeToInstant(msg.Message.Mid).ToDateTimeOffset().ToString("O"));
var roles = memberInfo?.Roles?.ToList();
if (roles != null && roles.Count > 0)
{
// TODO: what if role isn't in cache? figure out a fallback
var rolesString = string.Join(", ", roles.Select(id => _cache.GetRole(id))
.OrderByDescending(role => role.Position)
.Select(role => role.Name));
eb.Field(new($"Account roles ({roles.Count})", rolesString.Truncate(1024)));
}
return(eb.Build());
}
public static async Task RenderMemberList(this Context ctx, LookupContext lookupCtx, IDatabase db, SystemId system, string embedTitle, MemberListOptions opts)
{
// We take an IDatabase instead of a IPKConnection so we don't keep the handle open for the entire runtime
// We wanna release it as soon as the member list is actually *fetched*, instead of potentially minutes later (paginate timeout)
var members = (await db.Execute(conn => conn.QueryMemberList(system, opts.ToQueryOptions())))
.SortByMemberListOptions(opts, lookupCtx)
.ToList();
var itemsPerPage = opts.Type == ListType.Short ? 25 : 5;
await ctx.Paginate(members.ToAsyncEnumerable(), members.Count, itemsPerPage, embedTitle, Renderer);
// Base renderer, dispatches based on type
Task Renderer(DiscordEmbedBuilder eb, IEnumerable <ListedMember> page)
{
// Add a global footer with the filter/sort string + result count
eb.WithFooter($"{opts.CreateFilterString()}. {"result".ToQuantity(members.Count)}.");
// Then call the specific renderers
if (opts.Type == ListType.Short)
{
ShortRenderer(eb, page);
}
else
{
LongRenderer(eb, page);
}
return(Task.CompletedTask);
}
void ShortRenderer(DiscordEmbedBuilder eb, IEnumerable <ListedMember> page)
{
// We may end up over the description character limit
// so run it through a helper that "makes it work" :)
eb.WithSimpleLineContent(page.Select(m =>
{
if (m.HasProxyTags)
{
var proxyTagsString = m.ProxyTagsString();
if (proxyTagsString.Length > 100) // arbitrary threshold for now, tweak?
{
proxyTagsString = "tags too long, see member card";
}
return($"[`{m.Hid}`] **{m.NameFor(ctx)}** *(*{proxyTagsString}*)*");
}
return($"[`{m.Hid}`] **{m.NameFor(ctx)}**");
}));
}
void LongRenderer(DiscordEmbedBuilder eb, IEnumerable <ListedMember> page)
{
var zone = ctx.System?.Zone ?? DateTimeZone.Utc;
foreach (var m in page)
{
var profile = new StringBuilder($"**ID**: {m.Hid}");
if (m.DisplayName != null && m.NamePrivacy.CanAccess(lookupCtx))
{
profile.Append($"\n**Display name**: {m.DisplayName}");
}
if (m.PronounsFor(lookupCtx) is {} pronouns)
{
profile.Append($"\n**Pronouns**: {pronouns}");
}
if (m.BirthdayFor(lookupCtx) != null)
{
profile.Append($"\n**Birthdate**: {m.BirthdayString}");
}
if (m.ProxyTags.Count > 0)
{
profile.Append($"\n**Proxy tags**: {m.ProxyTagsString()}");
}
if (opts.IncludeMessageCount && m.MessageCountFor(lookupCtx) is {} count&& count > 0)
{
profile.Append($"\n**Message count:** {count}");
}
if (opts.IncludeLastMessage && m.MetadataPrivacy.TryGet(lookupCtx, m.LastMessage, out var lastMsg))
{
profile.Append($"\n**Last message:** {DiscordUtils.SnowflakeToInstant(lastMsg.Value).FormatZoned(zone)}");
}
if (opts.IncludeLastSwitch && m.MetadataPrivacy.TryGet(lookupCtx, m.LastSwitchTime, out var lastSw))
{
profile.Append($"\n**Last switched in:** {lastSw.Value.FormatZoned(zone)}");
}
if (opts.IncludeCreated && m.MetadataPrivacy.TryGet(lookupCtx, m.Created, out var created))
{
profile.Append($"\n**Created on:** {created.FormatZoned(zone)}");
}
if (m.DescriptionFor(lookupCtx) is {} desc)
{
profile.Append($"\n\n{desc}");
}
if (m.MemberVisibility == PrivacyLevel.Private)
{
profile.Append("\n*(this member is hidden)*");
}
eb.AddField(m.NameFor(ctx), profile.ToString().Truncate(1024));
}
}
}
