1299 lines
49 KiB
C#
1299 lines
49 KiB
C#
using Microsoft.EntityFrameworkCore;
|
||
using Microsoft.Extensions.Caching.Memory;
|
||
using EllieBot.Common.ModuleBehaviors;
|
||
using EllieBot.Modules.Administration.Services;
|
||
using EllieBot.Db.Models;
|
||
|
||
namespace EllieBot.Modules.Administration;
|
||
|
||
public sealed class LogCommandService : ILogCommandService, IReadyExecutor
|
||
#if !GLOBAL_ELLIE
|
||
, IEService // don't load this service on global ellie
|
||
#endif
|
||
{
|
||
public ConcurrentDictionary<ulong, LogSetting> GuildLogSettings { get; }
|
||
|
||
private ConcurrentDictionary<ITextChannel, List<string>> PresenceUpdates { get; } = new();
|
||
private readonly DiscordSocketClient _client;
|
||
|
||
private readonly IBotStrings _strings;
|
||
private readonly DbService _db;
|
||
private readonly MuteService _mute;
|
||
private readonly ProtectionService _prot;
|
||
private readonly GuildTimezoneService _tz;
|
||
private readonly IMemoryCache _memoryCache;
|
||
|
||
private readonly ConcurrentHashSet<ulong> _ignoreMessageIds = [];
|
||
private readonly UserPunishService _punishService;
|
||
private readonly IMessageSenderService _sender;
|
||
|
||
public LogCommandService(
|
||
DiscordSocketClient client,
|
||
IBotStrings strings,
|
||
DbService db,
|
||
MuteService mute,
|
||
ProtectionService prot,
|
||
GuildTimezoneService tz,
|
||
IMemoryCache memoryCache,
|
||
UserPunishService punishService,
|
||
IMessageSenderService sender)
|
||
{
|
||
_client = client;
|
||
_memoryCache = memoryCache;
|
||
_sender = sender;
|
||
_strings = strings;
|
||
_db = db;
|
||
_mute = mute;
|
||
_prot = prot;
|
||
_tz = tz;
|
||
_punishService = punishService;
|
||
|
||
using (var uow = db.GetDbContext())
|
||
{
|
||
var guildIds = client.Guilds.Select(x => x.Id).ToList();
|
||
var configs = uow.Set<LogSetting>().AsQueryable()
|
||
.AsNoTracking()
|
||
.Where(x => guildIds.Contains(x.GuildId))
|
||
.Include(ls => ls.LogIgnores)
|
||
.ToList();
|
||
|
||
GuildLogSettings = configs.ToDictionary(ls => ls.GuildId).ToConcurrent();
|
||
}
|
||
|
||
//_client.MessageReceived += _client_MessageReceived;
|
||
_client.MessageUpdated += _client_MessageUpdated;
|
||
_client.MessageDeleted += _client_MessageDeleted;
|
||
_client.UserBanned += _client_UserBanned;
|
||
_client.UserUnbanned += _client_UserUnbanned;
|
||
_client.UserJoined += _client_UserJoined;
|
||
_client.UserLeft += _client_UserLeft;
|
||
// _client.PresenceUpdated += _client_UserPresenceUpdated;
|
||
_client.UserVoiceStateUpdated += _client_UserVoiceStateUpdated;
|
||
_client.GuildMemberUpdated += _client_GuildUserUpdated;
|
||
_client.PresenceUpdated += _client_PresenceUpdated;
|
||
_client.UserUpdated += _client_UserUpdated;
|
||
_client.ChannelCreated += _client_ChannelCreated;
|
||
_client.ChannelDestroyed += _client_ChannelDestroyed;
|
||
_client.ChannelUpdated += _client_ChannelUpdated;
|
||
_client.RoleDeleted += _client_RoleDeleted;
|
||
|
||
_client.ThreadCreated += _client_ThreadCreated;
|
||
_client.ThreadDeleted += _client_ThreadDeleted;
|
||
|
||
_mute.UserMuted += MuteCommands_UserMuted;
|
||
_mute.UserUnmuted += MuteCommands_UserUnmuted;
|
||
|
||
_prot.OnAntiProtectionTriggered += TriggeredAntiProtection;
|
||
|
||
_punishService.OnUserWarned += PunishServiceOnOnUserWarned;
|
||
}
|
||
|
||
private async Task _client_PresenceUpdated(SocketUser user, SocketPresence? before, SocketPresence? after)
|
||
{
|
||
if (user is not SocketGuildUser gu)
|
||
return;
|
||
|
||
if (!GuildLogSettings.TryGetValue(gu.Guild.Id, out var logSetting)
|
||
|| before is null
|
||
|| after is null
|
||
|| logSetting.LogIgnores.Any(ilc => ilc.LogItemId == gu.Id && ilc.ItemType == IgnoredItemType.User))
|
||
return;
|
||
|
||
ITextChannel? logChannel;
|
||
|
||
if (!user.IsBot
|
||
&& logSetting.LogUserPresenceId is not null
|
||
&& (logChannel =
|
||
await TryGetLogChannel(gu.Guild, logSetting, LogType.UserPresence)) is not null)
|
||
{
|
||
if (before.Status != after.Status)
|
||
{
|
||
var str = "🎭"
|
||
+ Format.Code(PrettyCurrentTime(gu.Guild))
|
||
+ GetText(logChannel.Guild,
|
||
strs.user_status_change("👤" + Format.Bold(gu.Username),
|
||
Format.Bold(after.Status.ToString())));
|
||
PresenceUpdates.AddOrUpdate(logChannel,
|
||
[str],
|
||
(_, list) =>
|
||
{
|
||
list.Add(str);
|
||
return list;
|
||
});
|
||
}
|
||
else if (before.Activities.FirstOrDefault()?.Name != after.Activities.FirstOrDefault()?.Name)
|
||
{
|
||
var str =
|
||
$"👾`{PrettyCurrentTime(gu.Guild)}`👤__**{gu.Username}**__ is now playing **{after.Activities.FirstOrDefault()?.Name ?? "-"}**.";
|
||
PresenceUpdates.AddOrUpdate(logChannel,
|
||
[str],
|
||
(_, list) =>
|
||
{
|
||
list.Add(str);
|
||
return list;
|
||
});
|
||
}
|
||
}
|
||
}
|
||
|
||
private Task _client_ThreadDeleted(Cacheable<SocketThreadChannel, ulong> sch)
|
||
{
|
||
_ = Task.Run(async () =>
|
||
{
|
||
try
|
||
{
|
||
if (!sch.HasValue)
|
||
return;
|
||
|
||
var ch = sch.Value;
|
||
|
||
if (!GuildLogSettings.TryGetValue(ch.Guild.Id, out var logSetting)
|
||
|| logSetting.ThreadDeletedId is null)
|
||
return;
|
||
|
||
ITextChannel? logChannel;
|
||
if ((logChannel = await TryGetLogChannel(ch.Guild, logSetting, LogType.ThreadDeleted)) is null)
|
||
return;
|
||
|
||
var title = GetText(logChannel.Guild, strs.thread_deleted);
|
||
|
||
await _sender.Response(logChannel).Embed(_sender.CreateEmbed()
|
||
.WithOkColor()
|
||
.WithTitle("🗑 " + title)
|
||
.WithDescription($"{ch.Name} | {ch.Id}")
|
||
.WithFooter(CurrentTime(ch.Guild))).SendAsync();
|
||
}
|
||
catch (Exception)
|
||
{
|
||
// ignored
|
||
}
|
||
});
|
||
return Task.CompletedTask;
|
||
}
|
||
|
||
private Task _client_ThreadCreated(SocketThreadChannel ch)
|
||
{
|
||
_ = Task.Run(async () =>
|
||
{
|
||
try
|
||
{
|
||
if (!GuildLogSettings.TryGetValue(ch.Guild.Id, out var logSetting)
|
||
|| logSetting.ThreadCreatedId is null)
|
||
return;
|
||
|
||
ITextChannel? logChannel;
|
||
if ((logChannel = await TryGetLogChannel(ch.Guild, logSetting, LogType.ThreadCreated)) is null)
|
||
return;
|
||
|
||
var title = GetText(logChannel.Guild, strs.thread_created);
|
||
|
||
await _sender.Response(logChannel).Embed(_sender.CreateEmbed()
|
||
.WithOkColor()
|
||
.WithTitle("🆕 " + title)
|
||
.WithDescription($"{ch.Name} | {ch.Id}")
|
||
.WithFooter(CurrentTime(ch.Guild))).SendAsync();
|
||
}
|
||
catch (Exception)
|
||
{
|
||
// ignored
|
||
}
|
||
});
|
||
|
||
return Task.CompletedTask;
|
||
}
|
||
|
||
public async Task OnReadyAsync()
|
||
=> await Task.WhenAll(PresenceUpdateTask(), IgnoreMessageIdsClearTask());
|
||
|
||
private async Task IgnoreMessageIdsClearTask()
|
||
{
|
||
using var timer = new PeriodicTimer(TimeSpan.FromHours(1));
|
||
while (await timer.WaitForNextTickAsync())
|
||
_ignoreMessageIds.Clear();
|
||
}
|
||
|
||
private async Task PresenceUpdateTask()
|
||
{
|
||
using var timer = new PeriodicTimer(TimeSpan.FromSeconds(15));
|
||
while (await timer.WaitForNextTickAsync())
|
||
{
|
||
try
|
||
{
|
||
var keys = PresenceUpdates.Keys.ToList();
|
||
|
||
await keys.Select(channel =>
|
||
{
|
||
if (!((SocketGuild)channel.Guild).CurrentUser.GetPermissions(channel).SendMessages)
|
||
return Task.CompletedTask;
|
||
|
||
if (PresenceUpdates.TryRemove(channel, out var msgs))
|
||
{
|
||
var title = GetText(channel.Guild, strs.presence_updates);
|
||
var desc = string.Join(Environment.NewLine, msgs);
|
||
return _sender.Response(channel).Confirm(title, desc.TrimTo(2048)!).SendAsync();
|
||
}
|
||
|
||
return Task.CompletedTask;
|
||
})
|
||
.WhenAll();
|
||
}
|
||
catch
|
||
{
|
||
}
|
||
}
|
||
}
|
||
|
||
public LogSetting? GetGuildLogSettings(ulong guildId)
|
||
{
|
||
GuildLogSettings.TryGetValue(guildId, out var logSetting);
|
||
return logSetting;
|
||
}
|
||
|
||
public void AddDeleteIgnore(ulong messageId)
|
||
=> _ignoreMessageIds.Add(messageId);
|
||
|
||
public bool LogIgnore(ulong gid, ulong itemId, IgnoredItemType itemType)
|
||
{
|
||
using var uow = _db.GetDbContext();
|
||
var logSetting = uow.LogSettingsFor(gid);
|
||
var removed = logSetting.LogIgnores.RemoveAll(x => x.ItemType == itemType && itemId == x.LogItemId);
|
||
|
||
if (removed == 0)
|
||
{
|
||
var toAdd = new IgnoredLogItem
|
||
{
|
||
LogItemId = itemId,
|
||
ItemType = itemType
|
||
};
|
||
logSetting.LogIgnores.Add(toAdd);
|
||
}
|
||
|
||
uow.SaveChanges();
|
||
GuildLogSettings.AddOrUpdate(gid, logSetting, (_, _) => logSetting);
|
||
return removed > 0;
|
||
}
|
||
|
||
private string GetText(IGuild guild, LocStr str)
|
||
=> _strings.GetText(str, guild.Id);
|
||
|
||
private string PrettyCurrentTime(IGuild? g)
|
||
{
|
||
var time = DateTime.UtcNow;
|
||
if (g is not null)
|
||
time = TimeZoneInfo.ConvertTime(time, _tz.GetTimeZoneOrUtc(g.Id));
|
||
return $"【{time:HH:mm:ss}】";
|
||
}
|
||
|
||
private string CurrentTime(IGuild? g)
|
||
{
|
||
var time = DateTime.UtcNow;
|
||
if (g is not null)
|
||
time = TimeZoneInfo.ConvertTime(time, _tz.GetTimeZoneOrUtc(g.Id));
|
||
|
||
return $"{time:HH:mm:ss}";
|
||
}
|
||
|
||
public async Task LogServer(ulong guildId, ulong channelId, bool value)
|
||
{
|
||
await using var uow = _db.GetDbContext();
|
||
var logSetting = uow.LogSettingsFor(guildId);
|
||
|
||
logSetting.LogOtherId = logSetting.MessageUpdatedId = logSetting.MessageDeletedId = logSetting.UserJoinedId =
|
||
logSetting.UserLeftId = logSetting.UserBannedId = logSetting.UserUnbannedId = logSetting.UserUpdatedId =
|
||
logSetting.ChannelCreatedId = logSetting.ChannelDestroyedId = logSetting.ChannelUpdatedId =
|
||
logSetting.LogUserPresenceId = logSetting.LogVoicePresenceId = logSetting.UserMutedId =
|
||
logSetting.ThreadCreatedId = logSetting.ThreadDeletedId
|
||
= logSetting.LogWarnsId = value ? channelId : null;
|
||
await uow.SaveChangesAsync();
|
||
GuildLogSettings.AddOrUpdate(guildId, _ => logSetting, (_, _) => logSetting);
|
||
}
|
||
|
||
|
||
private async Task PunishServiceOnOnUserWarned(Warning arg)
|
||
{
|
||
if (!GuildLogSettings.TryGetValue(arg.GuildId, out var logSetting) || logSetting.LogWarnsId is null)
|
||
return;
|
||
|
||
var g = _client.GetGuild(arg.GuildId);
|
||
|
||
ITextChannel? logChannel;
|
||
if ((logChannel = await TryGetLogChannel(g, logSetting, LogType.UserWarned)) is null)
|
||
return;
|
||
|
||
var embed = _sender.CreateEmbed()
|
||
.WithOkColor()
|
||
.WithTitle($"⚠️ User Warned")
|
||
.WithDescription($"<@{arg.UserId}> | {arg.UserId}")
|
||
.AddField("Mod", arg.Moderator)
|
||
.AddField("Reason", string.IsNullOrWhiteSpace(arg.Reason) ? "-" : arg.Reason, true)
|
||
.WithFooter(CurrentTime(g));
|
||
|
||
await _sender.Response(logChannel).Embed(embed).SendAsync();
|
||
}
|
||
|
||
private Task _client_UserUpdated(SocketUser before, SocketUser uAfter)
|
||
{
|
||
_ = Task.Run(async () =>
|
||
{
|
||
try
|
||
{
|
||
if (uAfter is not SocketGuildUser after)
|
||
return;
|
||
|
||
var g = after.Guild;
|
||
|
||
if (!GuildLogSettings.TryGetValue(g.Id, out var logSetting) || logSetting.UserUpdatedId is null || logSetting.LogIgnores.Any(ilc => ilc.LogItemId == after.Id && ilc.ItemType == IgnoredItemType.User))
|
||
return;
|
||
|
||
ITextChannel? logChannel;
|
||
if ((logChannel = await TryGetLogChannel(g, logSetting, LogType.UserUpdated)) is null)
|
||
return;
|
||
|
||
var embed = _sender.CreateEmbed();
|
||
|
||
if (before.Username != after.Username)
|
||
{
|
||
embed.WithTitle("👥 " + GetText(g, strs.username_changed))
|
||
.WithDescription($"{before.Username} | {before.Id}")
|
||
.AddField("Old Name", $"{before.Username}", true)
|
||
.AddField("New Name", $"{after.Username}", true)
|
||
.WithFooter(CurrentTime(g))
|
||
.WithOkColor();
|
||
}
|
||
else if (before.AvatarId != after.AvatarId)
|
||
{
|
||
embed.WithTitle("👥" + GetText(g, strs.avatar_changed))
|
||
.WithDescription($"{before.Username}#{before.Discriminator} | {before.Id}")
|
||
.WithFooter(CurrentTime(g))
|
||
.WithOkColor();
|
||
|
||
var bav = before.RealAvatarUrl();
|
||
if (bav.IsAbsoluteUri)
|
||
embed.WithThumbnailUrl(bav.ToString());
|
||
|
||
var aav = after.RealAvatarUrl();
|
||
if (aav.IsAbsoluteUri)
|
||
embed.WithImageUrl(aav.ToString());
|
||
}
|
||
else
|
||
return;
|
||
|
||
await _sender.Response(logChannel).Embed(embed).SendAsync();
|
||
}
|
||
catch
|
||
{
|
||
// ignored
|
||
}
|
||
});
|
||
return Task.CompletedTask;
|
||
}
|
||
|
||
public bool Log(ulong gid, ulong? cid, LogType type /*, string options*/)
|
||
{
|
||
ulong? channelId = null;
|
||
using (var uow = _db.GetDbContext())
|
||
{
|
||
var logSetting = uow.LogSettingsFor(gid);
|
||
GuildLogSettings.AddOrUpdate(gid, _ => logSetting, (_, _) => logSetting);
|
||
switch (type)
|
||
{
|
||
case LogType.Other:
|
||
channelId = logSetting.LogOtherId = logSetting.LogOtherId is null ? cid : default;
|
||
break;
|
||
case LogType.MessageUpdated:
|
||
channelId = logSetting.MessageUpdatedId = logSetting.MessageUpdatedId is null ? cid : default;
|
||
break;
|
||
case LogType.MessageDeleted:
|
||
channelId = logSetting.MessageDeletedId = logSetting.MessageDeletedId is null ? cid : default;
|
||
//logSetting.DontLogBotMessageDeleted = (options == "nobot");
|
||
break;
|
||
case LogType.UserJoined:
|
||
channelId = logSetting.UserJoinedId = logSetting.UserJoinedId is null ? cid : default;
|
||
break;
|
||
case LogType.UserLeft:
|
||
channelId = logSetting.UserLeftId = logSetting.UserLeftId is null ? cid : default;
|
||
break;
|
||
case LogType.UserBanned:
|
||
channelId = logSetting.UserBannedId = logSetting.UserBannedId is null ? cid : default;
|
||
break;
|
||
case LogType.UserUnbanned:
|
||
channelId = logSetting.UserUnbannedId = logSetting.UserUnbannedId is null ? cid : default;
|
||
break;
|
||
case LogType.UserUpdated:
|
||
channelId = logSetting.UserUpdatedId = logSetting.UserUpdatedId is null ? cid : default;
|
||
break;
|
||
case LogType.UserMuted:
|
||
channelId = logSetting.UserMutedId = logSetting.UserMutedId is null ? cid : default;
|
||
break;
|
||
case LogType.ChannelCreated:
|
||
channelId = logSetting.ChannelCreatedId = logSetting.ChannelCreatedId is null ? cid : default;
|
||
break;
|
||
case LogType.ChannelDestroyed:
|
||
channelId = logSetting.ChannelDestroyedId = logSetting.ChannelDestroyedId is null ? cid : default;
|
||
break;
|
||
case LogType.ChannelUpdated:
|
||
channelId = logSetting.ChannelUpdatedId = logSetting.ChannelUpdatedId is null ? cid : default;
|
||
break;
|
||
case LogType.UserPresence:
|
||
channelId = logSetting.LogUserPresenceId = logSetting.LogUserPresenceId is null ? cid : default;
|
||
break;
|
||
case LogType.VoicePresence:
|
||
channelId = logSetting.LogVoicePresenceId = logSetting.LogVoicePresenceId is null ? cid : default;
|
||
break;
|
||
case LogType.UserWarned:
|
||
channelId = logSetting.LogWarnsId = logSetting.LogWarnsId is null ? cid : default;
|
||
break;
|
||
case LogType.ThreadDeleted:
|
||
channelId = logSetting.ThreadDeletedId = logSetting.ThreadDeletedId is null ? cid : default;
|
||
break;
|
||
case LogType.ThreadCreated:
|
||
channelId = logSetting.ThreadCreatedId = logSetting.ThreadCreatedId is null ? cid : default;
|
||
break;
|
||
}
|
||
|
||
uow.SaveChanges();
|
||
}
|
||
|
||
return channelId is not null;
|
||
}
|
||
|
||
private void MuteCommands_UserMuted(
|
||
IGuildUser usr,
|
||
IUser mod,
|
||
MuteType muteType,
|
||
string reason)
|
||
=> _ = Task.Run(async () =>
|
||
{
|
||
try
|
||
{
|
||
if (!GuildLogSettings.TryGetValue(usr.Guild.Id, out var logSetting) || logSetting.UserMutedId is null)
|
||
return;
|
||
|
||
ITextChannel? logChannel;
|
||
if ((logChannel = await TryGetLogChannel(usr.Guild, logSetting, LogType.UserMuted)) is null)
|
||
return;
|
||
var mutes = string.Empty;
|
||
var mutedLocalized = GetText(logChannel.Guild, strs.muted_sn);
|
||
switch (muteType)
|
||
{
|
||
case MuteType.Voice:
|
||
mutes = "🔇 " + GetText(logChannel.Guild, strs.xmuted_voice(mutedLocalized, mod.ToString()));
|
||
break;
|
||
case MuteType.Chat:
|
||
mutes = "🔇 " + GetText(logChannel.Guild, strs.xmuted_text(mutedLocalized, mod.ToString()));
|
||
break;
|
||
case MuteType.All:
|
||
mutes = "🔇 "
|
||
+ GetText(logChannel.Guild, strs.xmuted_text_and_voice(mutedLocalized, mod.ToString()));
|
||
break;
|
||
}
|
||
|
||
var embed = _sender.CreateEmbed()
|
||
.WithAuthor(mutes)
|
||
.WithTitle($"{usr.Username}#{usr.Discriminator} | {usr.Id}")
|
||
.WithFooter(CurrentTime(usr.Guild))
|
||
.WithOkColor();
|
||
|
||
if (!string.IsNullOrWhiteSpace(reason))
|
||
embed.WithDescription(reason);
|
||
|
||
await _sender.Response(logChannel).Embed(embed).SendAsync();
|
||
}
|
||
catch
|
||
{
|
||
// ignored
|
||
}
|
||
});
|
||
|
||
private void MuteCommands_UserUnmuted(
|
||
IGuildUser usr,
|
||
IUser mod,
|
||
MuteType muteType,
|
||
string reason)
|
||
=> _ = Task.Run(async () =>
|
||
{
|
||
try
|
||
{
|
||
if (!GuildLogSettings.TryGetValue(usr.Guild.Id, out var logSetting) || logSetting.UserMutedId is null)
|
||
return;
|
||
|
||
ITextChannel? logChannel;
|
||
if ((logChannel = await TryGetLogChannel(usr.Guild, logSetting, LogType.UserMuted)) is null)
|
||
return;
|
||
|
||
var mutes = string.Empty;
|
||
var unmutedLocalized = GetText(logChannel.Guild, strs.unmuted_sn);
|
||
switch (muteType)
|
||
{
|
||
case MuteType.Voice:
|
||
mutes = "🔊 " + GetText(logChannel.Guild, strs.xmuted_voice(unmutedLocalized, mod.ToString()));
|
||
break;
|
||
case MuteType.Chat:
|
||
mutes = "🔊 " + GetText(logChannel.Guild, strs.xmuted_text(unmutedLocalized, mod.ToString()));
|
||
break;
|
||
case MuteType.All:
|
||
mutes = "🔊 "
|
||
+ GetText(logChannel.Guild,
|
||
strs.xmuted_text_and_voice(unmutedLocalized, mod.ToString()));
|
||
break;
|
||
}
|
||
|
||
var embed = _sender.CreateEmbed()
|
||
.WithAuthor(mutes)
|
||
.WithTitle($"{usr.Username}#{usr.Discriminator} | {usr.Id}")
|
||
.WithFooter($"{CurrentTime(usr.Guild)}")
|
||
.WithOkColor();
|
||
|
||
if (!string.IsNullOrWhiteSpace(reason))
|
||
embed.WithDescription(reason);
|
||
|
||
await _sender.Response(logChannel).Embed(embed).SendAsync();
|
||
}
|
||
catch
|
||
{
|
||
// ignored
|
||
}
|
||
});
|
||
|
||
public Task TriggeredAntiProtection(PunishmentAction action, ProtectionType protection, params IGuildUser[] users)
|
||
{
|
||
_ = Task.Run(async () =>
|
||
{
|
||
try
|
||
{
|
||
if (users.Length == 0)
|
||
return;
|
||
|
||
if (!GuildLogSettings.TryGetValue(users.First().Guild.Id, out var logSetting)
|
||
|| logSetting.LogOtherId is null)
|
||
return;
|
||
|
||
ITextChannel? logChannel;
|
||
if ((logChannel = await TryGetLogChannel(users.First().Guild, logSetting, LogType.Other)) is null)
|
||
return;
|
||
|
||
var punishment = string.Empty;
|
||
switch (action)
|
||
{
|
||
case PunishmentAction.Mute:
|
||
punishment = "🔇 " + GetText(logChannel.Guild, strs.muted_pl).ToUpperInvariant();
|
||
break;
|
||
case PunishmentAction.Kick:
|
||
punishment = "👢 " + GetText(logChannel.Guild, strs.kicked_pl).ToUpperInvariant();
|
||
break;
|
||
case PunishmentAction.Softban:
|
||
punishment = "☣ " + GetText(logChannel.Guild, strs.soft_banned_pl).ToUpperInvariant();
|
||
break;
|
||
case PunishmentAction.Ban:
|
||
punishment = "⛔️ " + GetText(logChannel.Guild, strs.banned_pl).ToUpperInvariant();
|
||
break;
|
||
case PunishmentAction.RemoveRoles:
|
||
punishment = "⛔️ " + GetText(logChannel.Guild, strs.remove_roles_pl).ToUpperInvariant();
|
||
break;
|
||
}
|
||
|
||
var embed = _sender.CreateEmbed()
|
||
.WithAuthor($"🛡 Anti-{protection}")
|
||
.WithTitle(GetText(logChannel.Guild, strs.users) + " " + punishment)
|
||
.WithDescription(string.Join("\n", users.Select(u => u.ToString())))
|
||
.WithFooter(CurrentTime(logChannel.Guild))
|
||
.WithOkColor();
|
||
|
||
await _sender.Response(logChannel).Embed(embed).SendAsync();
|
||
}
|
||
catch
|
||
{
|
||
// ignored
|
||
}
|
||
});
|
||
return Task.CompletedTask;
|
||
}
|
||
|
||
private string GetRoleDeletedKey(ulong roleId)
|
||
=> $"role_deleted_{roleId}";
|
||
|
||
private Task _client_RoleDeleted(SocketRole socketRole)
|
||
{
|
||
Serilog.Log.Information("Role deleted {RoleId}", socketRole.Id);
|
||
_memoryCache.Set(GetRoleDeletedKey(socketRole.Id), true, TimeSpan.FromMinutes(5));
|
||
return Task.CompletedTask;
|
||
}
|
||
|
||
private bool IsRoleDeleted(ulong roleId)
|
||
{
|
||
var isDeleted = _memoryCache.TryGetValue(GetRoleDeletedKey(roleId), out _);
|
||
return isDeleted;
|
||
}
|
||
|
||
private Task _client_GuildUserUpdated(Cacheable<SocketGuildUser, ulong> optBefore, SocketGuildUser after)
|
||
{
|
||
_ = Task.Run(async () =>
|
||
{
|
||
try
|
||
{
|
||
var before = await optBefore.GetOrDownloadAsync();
|
||
|
||
if (before is null)
|
||
return;
|
||
|
||
if (!GuildLogSettings.TryGetValue(before.Guild.Id, out var logSetting)
|
||
|| logSetting.LogIgnores.Any(ilc
|
||
=> ilc.LogItemId == after.Id && ilc.ItemType == IgnoredItemType.User))
|
||
return;
|
||
|
||
ITextChannel? logChannel;
|
||
if (logSetting.UserUpdatedId is not null
|
||
&& (logChannel = await TryGetLogChannel(before.Guild, logSetting, LogType.UserUpdated)) is not null)
|
||
{
|
||
var embed = _sender.CreateEmbed()
|
||
.WithOkColor()
|
||
.WithFooter(CurrentTime(before.Guild))
|
||
.WithTitle($"{before.Username}#{before.Discriminator} | {before.Id}");
|
||
if (before.Nickname != after.Nickname)
|
||
{
|
||
embed.WithAuthor("👥 " + GetText(logChannel.Guild, strs.nick_change))
|
||
.AddField(GetText(logChannel.Guild, strs.old_nick),
|
||
$"{before.Nickname}#{before.Discriminator}")
|
||
.AddField(GetText(logChannel.Guild, strs.new_nick),
|
||
$"{after.Nickname}#{after.Discriminator}");
|
||
|
||
await _sender.Response(logChannel).Embed(embed).SendAsync();
|
||
}
|
||
else if (!before.Roles.SequenceEqual(after.Roles))
|
||
{
|
||
if (before.Roles.Count < after.Roles.Count)
|
||
{
|
||
var diffRoles = after.Roles.Where(r => !before.Roles.Contains(r)).Select(r => r.Name);
|
||
embed.WithAuthor("⚔ " + GetText(logChannel.Guild, strs.user_role_add))
|
||
.WithDescription(string.Join(", ", diffRoles).SanitizeMentions());
|
||
|
||
await _sender.Response(logChannel).Embed(embed).SendAsync();
|
||
}
|
||
else if (before.Roles.Count > after.Roles.Count)
|
||
{
|
||
await Task.Delay(1000);
|
||
var diffRoles = before.Roles.Where(r => !after.Roles.Contains(r) && !IsRoleDeleted(r.Id))
|
||
.Select(r => r.Name)
|
||
.ToList();
|
||
|
||
if (diffRoles.Any())
|
||
{
|
||
embed.WithAuthor("⚔ " + GetText(logChannel.Guild, strs.user_role_rem))
|
||
.WithDescription(string.Join(", ", diffRoles).SanitizeMentions());
|
||
|
||
await _sender.Response(logChannel).Embed(embed).SendAsync();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
// ignored
|
||
}
|
||
});
|
||
return Task.CompletedTask;
|
||
}
|
||
|
||
private Task _client_ChannelUpdated(IChannel cbefore, IChannel cafter)
|
||
{
|
||
_ = Task.Run(async () =>
|
||
{
|
||
try
|
||
{
|
||
if (cbefore is not IGuildChannel before)
|
||
return;
|
||
|
||
var after = (IGuildChannel)cafter;
|
||
|
||
if (!GuildLogSettings.TryGetValue(before.Guild.Id, out var logSetting)
|
||
|| logSetting.ChannelUpdatedId is null
|
||
|| logSetting.LogIgnores.Any(ilc
|
||
=> ilc.LogItemId == after.Id && ilc.ItemType == IgnoredItemType.Channel))
|
||
return;
|
||
|
||
ITextChannel? logChannel;
|
||
if ((logChannel = await TryGetLogChannel(before.Guild, logSetting, LogType.ChannelUpdated)) is null)
|
||
return;
|
||
|
||
var embed = _sender.CreateEmbed().WithOkColor().WithFooter(CurrentTime(before.Guild));
|
||
|
||
var beforeTextChannel = cbefore as ITextChannel;
|
||
var afterTextChannel = cafter as ITextChannel;
|
||
|
||
if (before.Name != after.Name)
|
||
{
|
||
embed.WithTitle("ℹ️ " + GetText(logChannel.Guild, strs.ch_name_change))
|
||
.WithDescription($"{after} | {after.Id}")
|
||
.AddField(GetText(logChannel.Guild, strs.ch_old_name), before.Name);
|
||
}
|
||
else if (beforeTextChannel?.Topic != afterTextChannel?.Topic)
|
||
{
|
||
embed.WithTitle("ℹ️ " + GetText(logChannel.Guild, strs.ch_topic_change))
|
||
.WithDescription($"{after} | {after.Id}")
|
||
.AddField(GetText(logChannel.Guild, strs.old_topic), beforeTextChannel?.Topic ?? "-")
|
||
.AddField(GetText(logChannel.Guild, strs.new_topic), afterTextChannel?.Topic ?? "-");
|
||
}
|
||
else
|
||
return;
|
||
|
||
await _sender.Response(logChannel).Embed(embed).SendAsync();
|
||
}
|
||
catch
|
||
{
|
||
// ignored
|
||
}
|
||
});
|
||
return Task.CompletedTask;
|
||
}
|
||
|
||
private Task _client_ChannelDestroyed(IChannel ich)
|
||
{
|
||
_ = Task.Run(async () =>
|
||
{
|
||
try
|
||
{
|
||
if (ich is not IGuildChannel ch)
|
||
return;
|
||
|
||
if (!GuildLogSettings.TryGetValue(ch.Guild.Id, out var logSetting)
|
||
|| logSetting.ChannelDestroyedId is null
|
||
|| logSetting.LogIgnores.Any(ilc
|
||
=> ilc.LogItemId == ch.Id && ilc.ItemType == IgnoredItemType.Channel))
|
||
return;
|
||
|
||
ITextChannel? logChannel;
|
||
if ((logChannel = await TryGetLogChannel(ch.Guild, logSetting, LogType.ChannelDestroyed)) is null)
|
||
return;
|
||
|
||
string title;
|
||
if (ch is IVoiceChannel)
|
||
title = GetText(logChannel.Guild, strs.voice_chan_destroyed);
|
||
else
|
||
title = GetText(logChannel.Guild, strs.text_chan_destroyed);
|
||
|
||
await _sender.Response(logChannel).Embed(_sender.CreateEmbed()
|
||
.WithOkColor()
|
||
.WithTitle("🆕 " + title)
|
||
.WithDescription($"{ch.Name} | {ch.Id}")
|
||
.WithFooter(CurrentTime(ch.Guild))).SendAsync();
|
||
}
|
||
catch
|
||
{
|
||
// ignored
|
||
}
|
||
});
|
||
return Task.CompletedTask;
|
||
}
|
||
|
||
private Task _client_ChannelCreated(IChannel ich)
|
||
{
|
||
_ = Task.Run(async () =>
|
||
{
|
||
try
|
||
{
|
||
if (ich is not IGuildChannel ch)
|
||
return;
|
||
|
||
if (!GuildLogSettings.TryGetValue(ch.Guild.Id, out var logSetting)
|
||
|| logSetting.ChannelCreatedId is null)
|
||
return;
|
||
|
||
ITextChannel? logChannel;
|
||
if ((logChannel = await TryGetLogChannel(ch.Guild, logSetting, LogType.ChannelCreated)) is null)
|
||
return;
|
||
string title;
|
||
if (ch is IVoiceChannel)
|
||
title = GetText(logChannel.Guild, strs.voice_chan_created);
|
||
else
|
||
title = GetText(logChannel.Guild, strs.text_chan_created);
|
||
|
||
await _sender.Response(logChannel).Embed(_sender.CreateEmbed()
|
||
.WithOkColor()
|
||
.WithTitle("🆕 " + title)
|
||
.WithDescription($"{ch.Name} | {ch.Id}")
|
||
.WithFooter(CurrentTime(ch.Guild))).SendAsync();
|
||
}
|
||
catch (Exception)
|
||
{
|
||
// ignored
|
||
}
|
||
});
|
||
return Task.CompletedTask;
|
||
}
|
||
|
||
private Task _client_UserVoiceStateUpdated(SocketUser iusr, SocketVoiceState before, SocketVoiceState after)
|
||
{
|
||
_ = Task.Run(async () =>
|
||
{
|
||
try
|
||
{
|
||
if (iusr is not IGuildUser usr || usr.IsBot)
|
||
return;
|
||
|
||
var beforeVch = before.VoiceChannel;
|
||
var afterVch = after.VoiceChannel;
|
||
|
||
if (beforeVch == afterVch)
|
||
return;
|
||
|
||
if (!GuildLogSettings.TryGetValue(usr.Guild.Id, out var logSetting)
|
||
|| logSetting.LogVoicePresenceId is null
|
||
|| logSetting.LogIgnores.Any(
|
||
ilc => ilc.LogItemId == iusr.Id && ilc.ItemType == IgnoredItemType.User))
|
||
return;
|
||
|
||
ITextChannel? logChannel;
|
||
if ((logChannel = await TryGetLogChannel(usr.Guild, logSetting, LogType.VoicePresence)) is null)
|
||
return;
|
||
|
||
var str = string.Empty;
|
||
if (beforeVch?.Guild == afterVch?.Guild)
|
||
{
|
||
str = "🎙"
|
||
+ Format.Code(PrettyCurrentTime(usr.Guild))
|
||
+ GetText(logChannel.Guild,
|
||
strs.user_vmoved("👤" + Format.Bold(usr.Username),
|
||
Format.Bold(beforeVch?.Name ?? ""),
|
||
Format.Bold(afterVch?.Name ?? "")));
|
||
}
|
||
else if (beforeVch is null)
|
||
{
|
||
str = "🎙"
|
||
+ Format.Code(PrettyCurrentTime(usr.Guild))
|
||
+ GetText(logChannel.Guild,
|
||
strs.user_vjoined("👤" + Format.Bold(usr.Username),
|
||
Format.Bold(afterVch?.Name ?? "")));
|
||
}
|
||
else if (afterVch is null)
|
||
{
|
||
str = "🎙"
|
||
+ Format.Code(PrettyCurrentTime(usr.Guild))
|
||
+ GetText(logChannel.Guild,
|
||
strs.user_vleft("👤" + Format.Bold(usr.Username),
|
||
Format.Bold(beforeVch.Name ?? "")));
|
||
}
|
||
|
||
if (!string.IsNullOrWhiteSpace(str))
|
||
{
|
||
PresenceUpdates.AddOrUpdate(logChannel,
|
||
[str],
|
||
(_, list) =>
|
||
{
|
||
list.Add(str);
|
||
return list;
|
||
});
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
// ignored
|
||
}
|
||
});
|
||
return Task.CompletedTask;
|
||
}
|
||
|
||
private Task _client_UserLeft(SocketGuild guild, SocketUser usr)
|
||
{
|
||
_ = Task.Run(async () =>
|
||
{
|
||
try
|
||
{
|
||
if (!GuildLogSettings.TryGetValue(guild.Id, out var logSetting)
|
||
|| logSetting.UserLeftId is null
|
||
|| logSetting.LogIgnores.Any(ilc
|
||
=> ilc.LogItemId == usr.Id && ilc.ItemType == IgnoredItemType.User))
|
||
return;
|
||
|
||
ITextChannel? logChannel;
|
||
if ((logChannel = await TryGetLogChannel(guild, logSetting, LogType.UserLeft)) is null)
|
||
return;
|
||
var embed = _sender.CreateEmbed()
|
||
.WithOkColor()
|
||
.WithTitle("❌ " + GetText(logChannel.Guild, strs.user_left))
|
||
.WithDescription(usr.ToString())
|
||
.AddField("Id", usr.Id.ToString())
|
||
.WithFooter(CurrentTime(guild));
|
||
|
||
if (Uri.IsWellFormedUriString(usr.GetAvatarUrl(), UriKind.Absolute))
|
||
embed.WithThumbnailUrl(usr.GetAvatarUrl());
|
||
|
||
await _sender.Response(logChannel).Embed(embed).SendAsync();
|
||
}
|
||
catch
|
||
{
|
||
// ignored
|
||
}
|
||
});
|
||
return Task.CompletedTask;
|
||
}
|
||
|
||
private Task _client_UserJoined(IGuildUser usr)
|
||
{
|
||
_ = Task.Run(async () =>
|
||
{
|
||
try
|
||
{
|
||
if (!GuildLogSettings.TryGetValue(usr.Guild.Id, out var logSetting) || logSetting.UserJoinedId is null)
|
||
return;
|
||
|
||
ITextChannel? logChannel;
|
||
if ((logChannel = await TryGetLogChannel(usr.Guild, logSetting, LogType.UserJoined)) is null)
|
||
return;
|
||
|
||
var embed = _sender.CreateEmbed()
|
||
.WithOkColor()
|
||
.WithTitle("✅ " + GetText(logChannel.Guild, strs.user_joined))
|
||
.WithDescription($"{usr.Mention} `{usr}`")
|
||
.AddField("Id", usr.Id.ToString())
|
||
.AddField(GetText(logChannel.Guild, strs.joined_server),
|
||
$"{usr.JoinedAt?.ToString("dd.MM.yyyy HH:mm") ?? "?"}",
|
||
true)
|
||
.AddField(GetText(logChannel.Guild, strs.joined_discord),
|
||
$"{usr.CreatedAt:dd.MM.yyyy HH:mm}",
|
||
true)
|
||
.WithFooter(CurrentTime(usr.Guild));
|
||
|
||
if (Uri.IsWellFormedUriString(usr.GetAvatarUrl(), UriKind.Absolute))
|
||
embed.WithThumbnailUrl(usr.GetAvatarUrl());
|
||
|
||
await _sender.Response(logChannel).Embed(embed).SendAsync();
|
||
}
|
||
catch (Exception)
|
||
{
|
||
// ignored
|
||
}
|
||
});
|
||
return Task.CompletedTask;
|
||
}
|
||
|
||
private Task _client_UserUnbanned(IUser usr, IGuild guild)
|
||
{
|
||
_ = Task.Run(async () =>
|
||
{
|
||
try
|
||
{
|
||
if (!GuildLogSettings.TryGetValue(guild.Id, out var logSetting)
|
||
|| logSetting.UserUnbannedId is null
|
||
|| logSetting.LogIgnores.Any(ilc
|
||
=> ilc.LogItemId == usr.Id && ilc.ItemType == IgnoredItemType.User))
|
||
return;
|
||
|
||
ITextChannel? logChannel;
|
||
if ((logChannel = await TryGetLogChannel(guild, logSetting, LogType.UserUnbanned)) is null)
|
||
return;
|
||
var embed = _sender.CreateEmbed()
|
||
.WithOkColor()
|
||
.WithTitle("♻️ " + GetText(logChannel.Guild, strs.user_unbanned))
|
||
.WithDescription(usr.ToString()!)
|
||
.AddField("Id", usr.Id.ToString())
|
||
.WithFooter(CurrentTime(guild));
|
||
|
||
if (Uri.IsWellFormedUriString(usr.GetAvatarUrl(), UriKind.Absolute))
|
||
embed.WithThumbnailUrl(usr.GetAvatarUrl());
|
||
|
||
await _sender.Response(logChannel).Embed(embed).SendAsync();
|
||
}
|
||
catch (Exception)
|
||
{
|
||
// ignored
|
||
}
|
||
});
|
||
return Task.CompletedTask;
|
||
}
|
||
|
||
private Task _client_UserBanned(IUser usr, IGuild guild)
|
||
{
|
||
_ = Task.Run(async () =>
|
||
{
|
||
try
|
||
{
|
||
if (!GuildLogSettings.TryGetValue(guild.Id, out var logSetting)
|
||
|| logSetting.UserBannedId is null
|
||
|| logSetting.LogIgnores.Any(ilc
|
||
=> ilc.LogItemId == usr.Id && ilc.ItemType == IgnoredItemType.User))
|
||
return;
|
||
|
||
ITextChannel? logChannel;
|
||
if ((logChannel = await TryGetLogChannel(guild, logSetting, LogType.UserBanned)) == null)
|
||
return;
|
||
|
||
|
||
string? reason = null;
|
||
try
|
||
{
|
||
var ban = await guild.GetBanAsync(usr);
|
||
reason = ban?.Reason;
|
||
}
|
||
catch
|
||
{
|
||
}
|
||
|
||
var embed = _sender.CreateEmbed()
|
||
.WithOkColor()
|
||
.WithTitle("🚫 " + GetText(logChannel.Guild, strs.user_banned))
|
||
.WithDescription(usr.ToString()!)
|
||
.AddField("Id", usr.Id.ToString())
|
||
.AddField("Reason", string.IsNullOrWhiteSpace(reason) ? "-" : reason)
|
||
.WithFooter(CurrentTime(guild));
|
||
|
||
var avatarUrl = usr.GetAvatarUrl();
|
||
|
||
if (Uri.IsWellFormedUriString(avatarUrl, UriKind.Absolute))
|
||
embed.WithThumbnailUrl(usr.GetAvatarUrl());
|
||
|
||
await _sender.Response(logChannel).Embed(embed).SendAsync();
|
||
}
|
||
catch (Exception)
|
||
{
|
||
// ignored
|
||
}
|
||
});
|
||
return Task.CompletedTask;
|
||
}
|
||
|
||
private Task _client_MessageDeleted(Cacheable<IMessage, ulong> optMsg, Cacheable<IMessageChannel, ulong> optCh)
|
||
{
|
||
_ = Task.Run(async () =>
|
||
{
|
||
try
|
||
{
|
||
if (optMsg.Value is not IUserMessage msg || msg.IsAuthor(_client))
|
||
return;
|
||
|
||
if (_ignoreMessageIds.Contains(msg.Id))
|
||
return;
|
||
|
||
var ch = optCh.Value;
|
||
if (ch is not ITextChannel channel)
|
||
return;
|
||
|
||
if (!GuildLogSettings.TryGetValue(channel.Guild.Id, out var logSetting)
|
||
|| logSetting.MessageDeletedId is null
|
||
|| logSetting.LogIgnores.Any(ilc
|
||
=> ilc.LogItemId == channel.Id && ilc.ItemType == IgnoredItemType.Channel))
|
||
return;
|
||
|
||
ITextChannel? logChannel;
|
||
if ((logChannel = await TryGetLogChannel(channel.Guild, logSetting, LogType.MessageDeleted)) is null
|
||
|| logChannel.Id == msg.Id)
|
||
return;
|
||
|
||
var resolvedMessage = msg.Resolve(TagHandling.FullName);
|
||
var embed = _sender.CreateEmbed()
|
||
.WithOkColor()
|
||
.WithTitle("🗑 "
|
||
+ GetText(logChannel.Guild, strs.msg_del(((ITextChannel)msg.Channel).Name)))
|
||
.WithDescription(msg.Author.ToString()!)
|
||
.AddField(GetText(logChannel.Guild, strs.content),
|
||
string.IsNullOrWhiteSpace(resolvedMessage) ? "-" : resolvedMessage)
|
||
.AddField("Id", msg.Id.ToString())
|
||
.WithFooter(CurrentTime(channel.Guild));
|
||
if (msg.Attachments.Any())
|
||
{
|
||
embed.AddField(GetText(logChannel.Guild, strs.attachments),
|
||
string.Join(", ", msg.Attachments.Select(a => a.Url)));
|
||
}
|
||
|
||
await _sender.Response(logChannel).Embed(embed).SendAsync();
|
||
}
|
||
catch (Exception)
|
||
{
|
||
// ignored
|
||
}
|
||
});
|
||
return Task.CompletedTask;
|
||
}
|
||
|
||
private Task _client_MessageUpdated(
|
||
Cacheable<IMessage, ulong> optmsg,
|
||
SocketMessage imsg2,
|
||
ISocketMessageChannel ch)
|
||
{
|
||
_ = Task.Run(async () =>
|
||
{
|
||
try
|
||
{
|
||
if (imsg2 is not IUserMessage after || after.IsAuthor(_client))
|
||
return;
|
||
|
||
if ((optmsg.HasValue ? optmsg.Value : null) is not IUserMessage before)
|
||
return;
|
||
|
||
if (ch is not ITextChannel channel)
|
||
return;
|
||
|
||
if (before.Content == after.Content)
|
||
return;
|
||
|
||
if (before.Author.IsBot)
|
||
return;
|
||
|
||
if (!GuildLogSettings.TryGetValue(channel.Guild.Id, out var logSetting)
|
||
|| logSetting.MessageUpdatedId is null
|
||
|| logSetting.LogIgnores.Any(ilc
|
||
=> ilc.LogItemId == channel.Id && ilc.ItemType == IgnoredItemType.Channel))
|
||
return;
|
||
|
||
ITextChannel? logChannel;
|
||
if ((logChannel = await TryGetLogChannel(channel.Guild, logSetting, LogType.MessageUpdated)) is null
|
||
|| logChannel.Id == after.Channel.Id)
|
||
return;
|
||
|
||
var embed = _sender.CreateEmbed()
|
||
.WithOkColor()
|
||
.WithTitle("📝 "
|
||
+ GetText(logChannel.Guild,
|
||
strs.msg_update(((ITextChannel)after.Channel).Name)))
|
||
.WithDescription(after.Author.ToString()!)
|
||
.AddField(GetText(logChannel.Guild, strs.old_msg),
|
||
string.IsNullOrWhiteSpace(before.Content)
|
||
? "-"
|
||
: before.Resolve(TagHandling.FullName))
|
||
.AddField(GetText(logChannel.Guild, strs.new_msg),
|
||
string.IsNullOrWhiteSpace(after.Content) ? "-" : after.Resolve(TagHandling.FullName))
|
||
.AddField("Id", after.Id.ToString())
|
||
.WithFooter(CurrentTime(channel.Guild));
|
||
|
||
await _sender.Response(logChannel).Embed(embed).SendAsync();
|
||
}
|
||
catch
|
||
{
|
||
// ignored
|
||
}
|
||
});
|
||
return Task.CompletedTask;
|
||
}
|
||
|
||
private async Task<ITextChannel?> TryGetLogChannel(IGuild guild, LogSetting logSetting, LogType logChannelType)
|
||
{
|
||
ulong? id = null;
|
||
switch (logChannelType)
|
||
{
|
||
case LogType.Other:
|
||
id = logSetting.LogOtherId;
|
||
break;
|
||
case LogType.MessageUpdated:
|
||
id = logSetting.MessageUpdatedId;
|
||
break;
|
||
case LogType.MessageDeleted:
|
||
id = logSetting.MessageDeletedId;
|
||
break;
|
||
case LogType.UserJoined:
|
||
id = logSetting.UserJoinedId;
|
||
break;
|
||
case LogType.UserLeft:
|
||
id = logSetting.UserLeftId;
|
||
break;
|
||
case LogType.UserBanned:
|
||
id = logSetting.UserBannedId;
|
||
break;
|
||
case LogType.UserUnbanned:
|
||
id = logSetting.UserUnbannedId;
|
||
break;
|
||
case LogType.UserUpdated:
|
||
id = logSetting.UserUpdatedId;
|
||
break;
|
||
case LogType.ChannelCreated:
|
||
id = logSetting.ChannelCreatedId;
|
||
break;
|
||
case LogType.ChannelDestroyed:
|
||
id = logSetting.ChannelDestroyedId;
|
||
break;
|
||
case LogType.ChannelUpdated:
|
||
id = logSetting.ChannelUpdatedId;
|
||
break;
|
||
case LogType.UserPresence:
|
||
id = logSetting.LogUserPresenceId;
|
||
break;
|
||
case LogType.VoicePresence:
|
||
id = logSetting.LogVoicePresenceId;
|
||
break;
|
||
case LogType.UserMuted:
|
||
id = logSetting.UserMutedId;
|
||
break;
|
||
case LogType.UserWarned:
|
||
id = logSetting.LogWarnsId;
|
||
break;
|
||
case LogType.ThreadCreated:
|
||
id = logSetting.ThreadCreatedId;
|
||
break;
|
||
case LogType.ThreadDeleted:
|
||
id = logSetting.ThreadDeletedId;
|
||
break;
|
||
}
|
||
|
||
if (id is null or 0)
|
||
{
|
||
UnsetLogSetting(guild.Id, logChannelType);
|
||
return null;
|
||
}
|
||
|
||
var channel = await guild.GetTextChannelAsync(id.Value);
|
||
|
||
if (channel is null)
|
||
{
|
||
UnsetLogSetting(guild.Id, logChannelType);
|
||
return null;
|
||
}
|
||
|
||
return channel;
|
||
}
|
||
|
||
private void UnsetLogSetting(ulong guildId, LogType logChannelType)
|
||
{
|
||
using var uow = _db.GetDbContext();
|
||
var newLogSetting = uow.LogSettingsFor(guildId);
|
||
switch (logChannelType)
|
||
{
|
||
case LogType.Other:
|
||
newLogSetting.LogOtherId = null;
|
||
break;
|
||
case LogType.MessageUpdated:
|
||
newLogSetting.MessageUpdatedId = null;
|
||
break;
|
||
case LogType.MessageDeleted:
|
||
newLogSetting.MessageDeletedId = null;
|
||
break;
|
||
case LogType.UserJoined:
|
||
newLogSetting.UserJoinedId = null;
|
||
break;
|
||
case LogType.UserLeft:
|
||
newLogSetting.UserLeftId = null;
|
||
break;
|
||
case LogType.UserBanned:
|
||
newLogSetting.UserBannedId = null;
|
||
break;
|
||
case LogType.UserUnbanned:
|
||
newLogSetting.UserUnbannedId = null;
|
||
break;
|
||
case LogType.UserUpdated:
|
||
newLogSetting.UserUpdatedId = null;
|
||
break;
|
||
case LogType.UserMuted:
|
||
newLogSetting.UserMutedId = null;
|
||
break;
|
||
case LogType.ChannelCreated:
|
||
newLogSetting.ChannelCreatedId = null;
|
||
break;
|
||
case LogType.ChannelDestroyed:
|
||
newLogSetting.ChannelDestroyedId = null;
|
||
break;
|
||
case LogType.ChannelUpdated:
|
||
newLogSetting.ChannelUpdatedId = null;
|
||
break;
|
||
case LogType.UserPresence:
|
||
newLogSetting.LogUserPresenceId = null;
|
||
break;
|
||
case LogType.VoicePresence:
|
||
newLogSetting.LogVoicePresenceId = null;
|
||
break;
|
||
case LogType.UserWarned:
|
||
newLogSetting.LogWarnsId = null;
|
||
break;
|
||
}
|
||
|
||
GuildLogSettings.AddOrUpdate(guildId, newLogSetting, (_, _) => newLogSetting);
|
||
uow.SaveChanges();
|
||
}
|
||
}
|