public async Task HandleAsync(MemberLeftEventArgs args)
{
using var ctx = new AdminDatabaseContext(_provider);
var guild = await ctx.GetOrCreateGuildAsync(args.Guild.Id);
if (string.IsNullOrWhiteSpace(guild.Goodbye))
{
return;
}
var goodbye = await guild.Goodbye.FormatPlaceHoldersAsync(
AdminCommandContext.MockContext(guild.Language, _provider, args.User, args.Guild));
if (!(await ctx.GetLoggingChannelAsync(args.Guild.Id, LogType.Goodbye) is { } channel))
{
return;
}
if (JsonEmbed.TryParse(goodbye, out var embed))
{
await channel.SendMessageAsync(embed.Text ?? string.Empty, embed : embed.ToLocalEmbed());
return;
}
await channel.SendMessageAsync(goodbye);
}
public async Task HandleAsync(ReactionsClearedEventArgs args)
{
if (!(args.Channel is CachedTextChannel channel))
{
return;
}
using var ctx = new AdminDatabaseContext(_provider);
var star = await ctx.GetSpecialEmojiAsync(channel.Guild.Id, EmojiType.Star);
if (!args.Reactions.HasValue || !args.Reactions.Value.ContainsKey(star)) // TODO: ContainsKey works for Equals?
{
return;
}
if (!(await ctx.Starboard.FindAsync(args.Message.Id) is { } entry))
{
return;
}
ctx.Starboard.Remove(entry);
await ctx.SaveChangesAsync();
await args.Client.DeleteMessageAsync(entry.EntryChannelId, entry.EntryMessageId);
}
public async Task HandleAsync(MessageReceivedEventArgs args)
{
if (!(args.Message is CachedUserMessage message))
{
return;
}
using var ctx = new AdminDatabaseContext(_provider);
if (string.IsNullOrWhiteSpace(message.Content) || message.Author.IsBot ||
!(message.Channel is CachedTextChannel channel))
{
return;
}
var completedHighlights = new List <ulong>();
foreach (var highlight in ctx.Highlights.Where(x => x.UserId != message.Author.Id &&
Regex.IsMatch(message.Content, $@"\b{x.Text}\b", RegexOptions.IgnoreCase)))
{
if (completedHighlights.Contains(highlight.UserId) ||
highlight.GuildId.HasValue && highlight.GuildId != channel.Guild.Id)
{
continue;
}
if (channel.Guild.GetMember(highlight.UserId) is { } member&&
member.GetPermissionsFor(channel).ViewChannel&&
channel.GetMessages().OrderByDescending(x => x.Id)
.Where(x => DateTimeOffset.UtcNow - x.Id.CreatedAt < TimeSpan.FromMinutes(15))
.Take(50).All(x => x.Author.Id != highlight.UserId))
{
var user = await ctx.GetOrCreateGlobalUserAsync(highlight.UserId);
if (user.HighlightBlacklist.Contains(message.Author.Id) ||
user.HighlightBlacklist.Contains(message.Channel.Id))
{
continue;
}
var target = await _client.GetUserAsync(highlight.UserId);
var builder = new LocalEmbedBuilder()
.WithSuccessColor()
.WithAuthor(_localization.Localize(user.Language, "highlight_trigger_author",
message.Author.Tag, message.Channel), message.Author.GetAvatarUrl())
.WithDescription(new StringBuilder()
.AppendNewline(message.Content.TrimTo(LocalEmbedBuilder.MAX_DESCRIPTION_LENGTH - 50))
.AppendNewline()
.AppendNewline($"[{_localization.Localize(user.Language, "info_jumpmessage")}]({message.JumpUrl})")
.ToString())
.WithTimestamp(message.Id.CreatedAt);
_ = target.SendMessageAsync(_localization.Localize(user.Language, "highlight_trigger_text",
channel.Guild.Name.Sanitize()), embed: builder.Build());
completedHighlights.Add(highlight.UserId);
}
}
}
public async Task HandleAsync(MessageReceivedEventArgs args)
{
if (!(args.Message is CachedUserMessage message) ||
message.Author.IsBot || string.IsNullOrWhiteSpace(message.Content))
{
return;
}
var prefixes = new List <string> {
_config.DefaultPrefix
};
LocalizedLanguage language;
using var ctx = new AdminDatabaseContext(_provider);
if (message.Channel is IGuildChannel guildChannel)
{
Guild guild = null;
if (!_languages.TryGetValue(guildChannel.GuildId, out language))
{
guild = await ctx.GetOrCreateGuildAsync(guildChannel.GuildId);
_languages[guild.Id] = language = guild.Language;
}
if (!_guildPrefixes.TryGetValue(guildChannel.GuildId, out var customPrefixes))
{
guild ??= await ctx.GetOrCreateGuildAsync(guildChannel.GuildId);
_guildPrefixes[guild.Id] = customPrefixes = guild.CustomPrefixes;
}
prefixes.AddRange(customPrefixes);
}
else if (!_languages.TryGetValue(message.Author.Id, out language))
{
var user = await ctx.GetOrCreateGlobalUserAsync(message.Author.Id);
_languages[user.Id] = language = user.Language;
}
if (!CommandUtilities.HasAnyPrefix(message.Content, prefixes, StringComparison.OrdinalIgnoreCase,
out var prefix, out var input))
{
return;
}
var context = new AdminCommandContext(message, prefix, language, _provider);
IResult result;
if (!context.IsPrivate && await ctx.CommandAliases
.FirstOrDefaultAsync(x => x.GuildId == context.Guild.Id &&
input.StartsWith(x.Alias,
StringComparison.InvariantCultureIgnoreCase)) is { } alias)
{
result = await _commands.ExecuteAsync(alias, input, context);
}
private async Task CycleStatusAsync()
{
using var ctx = new AdminDatabaseContext(_provider);
var statuses = await ctx.Statuses.ToListAsync();
if (statuses.Count == 0)
{
return;
}
var status = statuses.GetRandomElement(_random);
await _client.SetPresenceAsync(new LocalActivity(status.Text, status.Type));
}
private async Task SendRemindersAsync()
{
using var ctx = new AdminDatabaseContext(_provider);
var now = DateTimeOffset.UtcNow;
foreach (var reminder in ctx.Reminders.Where(x => now >= x.Ending))
{
var user = await _client.GetOrDownloadUserAsync(reminder.AuthorId);
var language = reminder.GuildId.HasValue
? (await ctx.GetOrCreateGuildAsync(reminder.GuildId.Value)).Language
: (await ctx.GetOrCreateGlobalUserAsync(reminder.AuthorId)).Language;
var builder = new LocalEmbedBuilder()
.WithSuccessColor()
.WithDescription(string.Join('\n',
(reminder.Text ?? string.Empty).TrimTo(LocalEmbedBuilder.MAX_DESCRIPTION_LENGTH - 50),
Markdown.Link(_localization.Localize(language, "info_jumpmessage"),
$"https://discordapp.com/channels/{reminder.GuildId?.ToString() ?? "@me"}/{reminder.ChannelId}/{reminder.MessageId}")));
try
{
if (!reminder.GuildId.HasValue)
{
await user.SendMessageAsync(
_localization.Localize(language, "reminder_trigger",
(reminder.Ending - reminder.CreatedAt).HumanizeFormatted(_localization, language,
TimeUnit.Second, true)), embed : builder.Build());
continue;
}
await _client.GetGuild(reminder.GuildId.Value).GetTextChannel(reminder.ChannelId).SendMessageAsync(
_localization.Localize(language, "reminder_trigger",
(reminder.Ending - reminder.CreatedAt).HumanizeFormatted(_localization, language,
TimeUnit.Second, true)), embed: builder.Build());
}
catch { /* ignored */ }
finally
{
ctx.Reminders.Remove(reminder);
}
}
await ctx.SaveChangesAsync();
}
public async Task HandleAsync(MemberJoinedEventArgs args)
{
using var ctx = new AdminDatabaseContext(_provider);
var guild = await ctx.GetOrCreateGuildAsync(args.Member.Guild.Id);
if (string.IsNullOrWhiteSpace(guild.Greeting))
{
return;
}
var greeting = await guild.Greeting.FormatPlaceHoldersAsync(
AdminCommandContext.MockContext(guild.Language, _provider, args.Member, args.Member.Guild));
var hasEmbed = JsonEmbed.TryParse(greeting, out var embed);
if (guild.DmGreeting)
{
if (hasEmbed)
{
_ = args.Member.SendMessageAsync(embed.Text ?? string.Empty, embed: embed.ToLocalEmbed());
}
else
{
_ = args.Member.SendMessageAsync(greeting);
}
return;
}
if (!(await ctx.GetLoggingChannelAsync(args.Member.Guild.Id, LogType.Greeting) is { } channel))
{
return;
}
if (hasEmbed)
{
await channel.SendMessageAsync(embed.Text ?? string.Empty, embed : embed.ToLocalEmbed());
return;
}
await channel.SendMessageAsync(greeting);
}
public async Task HandleAsync(MessagesBulkDeletedEventArgs args)
{
using var ctx = new AdminDatabaseContext(_provider);
foreach (var id in args.Messages.Select(x => x.Id))
{
if (!(await ctx.Starboard.FirstOrDefaultAsync(x => x.MessageId == id ||
x.EntryMessageId == id) is { } entry))
{
continue;
}
ctx.Starboard.Remove(entry);
await ctx.SaveChangesAsync();
if (id != entry.EntryMessageId)
{
await args.Client.DeleteMessageAsync(entry.EntryChannelId, entry.EntryMessageId);
}
}
}
public async Task HandleAsync(MessageDeletedEventArgs args)
{
if (!(args.Channel is CachedTextChannel channel))
{
return;
}
using var ctx = new AdminDatabaseContext(_provider);
if (!(await ctx.Starboard.FirstOrDefaultAsync(x => x.MessageId == args.Message.Id ||
x.EntryMessageId == args.Message.Id) is { } entry))
{
return;
}
ctx.Starboard.Remove(entry);
await ctx.SaveChangesAsync();
if (args.Message.Id != entry.EntryMessageId)
{
await args.Client.DeleteMessageAsync(entry.EntryChannelId, entry.EntryMessageId);
}
}
