public async Task <IActionResult> Status()
{
Identity currentIdentity = await GetIdentity();
if (!currentIdentity.IsSiteAdmin())
{
return(Unauthorized());
}
List <string> currentLogins = new();
foreach (var login in _identityManager.GetCurrentIdentities())
{
if (login is DiscordOAuthIdentity)
{
try
{
var user = login.GetCurrentUser();
if (user == null)
{
currentLogins.Add($"Invalid user.");
}
else
{
currentLogins.Add($"{user.Username}#{user.Discriminator}");
}
}
catch (Exception e)
{
_logger.LogError(e, "Error getting logged in user.");
currentLogins.Add($"Invalid user.");
}
}
}
StatusRepository repo = StatusRepository.CreateDefault(_serviceProvider);
StatusDetail botDetails = repo.GetBotStatus();
StatusDetail dbDetails = await repo.GetDbStatus();
StatusDetail cacheDetails = repo.GetCacheStatus();
return(Ok(new
{
botStatus = botDetails,
dbStatus = dbDetails,
cacheStatus = cacheDetails,
loginsInLast15Minutes = currentLogins,
defaultLanguage = _config.GetDefaultLanguage(),
trackedInvites = await InviteRepository.CreateDefault(_serviceProvider).CountInvites(),
modCases = await ModCaseRepository.CreateDefault(_serviceProvider, currentIdentity).CountAllCases(),
guilds = await GuildConfigRepository.CreateDefault(_serviceProvider).CountGuildConfigs(),
automodEvents = await AutoModerationEventRepository.CreateDefault(_serviceProvider).CountEvents(),
userNotes = await UserNoteRepository.CreateWithBotIdentity(_serviceProvider).CountUserNotes(),
userMappings = await UserMapRepository.CreateWithBotIdentity(_serviceProvider).CountAllUserMaps(),
apiTokens = await TokenRepository.CreateDefault(_serviceProvider).CountTokens(),
nextCache = _scheduler.GetNextCacheSchedule(),
cachedDataFromDiscord = _discordAPI.GetCache().Keys
}));
}
private async Task ExecutePunishment(IMessage message, AutoModerationConfig autoModerationConfig)
{
AutoModerationEvent modEvent = new()
{
GuildId = (message.Channel as ITextChannel).Guild.Id,
AutoModerationType = autoModerationConfig.AutoModerationType,
AutoModerationAction = autoModerationConfig.AutoModerationAction,
UserId = message.Author.Id,
MessageId = message.Id,
MessageContent = message.Content
};
await AutoModerationEventRepository.CreateDefault(_serviceProvider).RegisterEvent(modEvent, message.Channel as ITextChannel, message.Author);
if (modEvent.AutoModerationAction == AutoModerationAction.ContentDeleted || modEvent.AutoModerationAction == AutoModerationAction.ContentDeletedAndCaseCreated)
{
try
{
RequestOptions requestOptions = new();
requestOptions.RetryMode = RetryMode.RetryRatelimit;
await message.DeleteAsync(requestOptions);
}
catch (Exception ex)
{
_logger.LogError(ex, $"Error deleting message {message.Id}.");
}
}
}
}
private async Task <bool> CheckMultipleEvents(IMessage message, AutoModerationConfig config)
{
if (config.Limit == null)
{
return(false);
}
if (config.TimeLimitMinutes == null)
{
return(false);
}
var existing = await AutoModerationEventRepository.CreateDefault(_serviceProvider).GetAllEventsForUserSinceMinutes(message.Author.Id, config.TimeLimitMinutes.Value);
return(existing.Count > config.Limit.Value);
}
public async Task <IActionResult> GetAllItems([FromRoute] ulong guildId, [FromQuery][Range(0, int.MaxValue)] int startPage = 0)
{
Identity currentIdentity = await GetIdentity();
await GetRegisteredGuild(guildId);
ulong userOnly = 0;
if (!await currentIdentity.HasPermissionOnGuild(DiscordPermission.Moderator, guildId))
{
userOnly = currentIdentity.GetCurrentUser().Id;
}
AutoModerationEventRepository repo = AutoModerationEventRepository.CreateDefault(_serviceProvider);
List <AutoModerationEvent> events = null;
int eventsCount = 0;
if (userOnly == 0)
{
events = await repo.GetPagination(guildId, startPage);
eventsCount = await repo.CountEventsByGuild(guildId);
}
else
{
events = await repo.GetPaginationFilteredForUser(guildId, userOnly, startPage);
eventsCount = await repo.CountEventsByGuildAndUser(guildId, userOnly);
}
return(Ok(new
{
events = events.Select(x => new AutoModerationEventView(x)),
count = eventsCount
}));
}
public async Task <IActionResult> GetUserNetwork([FromQuery][Required] ulong userId)
{
Identity currentIdentity = await GetIdentity();
List <string> modGuilds = new();
List <DiscordGuildView> guildViews = new();
List <GuildConfig> guildConfigs = await GuildConfigRepository.CreateDefault(_serviceProvider).GetAllGuildConfigs();
if (guildConfigs.Count == 0)
{
throw new BaseAPIException("No guilds registered");
}
foreach (GuildConfig guildConfig in guildConfigs)
{
if (await currentIdentity.HasPermissionOnGuild(DiscordPermission.Moderator, guildConfig.GuildId))
{
modGuilds.Add(guildConfig.GuildId.ToString());
guildViews.Add(new DiscordGuildView(_discordAPI.FetchGuildInfo(guildConfig.GuildId, CacheBehavior.Default)));
}
}
if (modGuilds.Count == 0)
{
return(Unauthorized());
}
DiscordUserView searchedUser = DiscordUserView.CreateOrDefault(await _discordAPI.FetchUserInfo(userId, CacheBehavior.IgnoreButCacheOnError));
// invites
// ===============================================================================================
InviteRepository inviteRepository = InviteRepository.CreateDefault(_serviceProvider);
List <UserInviteExpandedView> invited = new();
foreach (UserInvite invite in await inviteRepository.GetInvitedForUser(userId))
{
if (!modGuilds.Contains(invite.GuildId.ToString()))
{
continue;
}
invited.Add(new UserInviteExpandedView(
invite,
await _discordAPI.FetchUserInfo(invite.JoinedUserId, CacheBehavior.OnlyCache),
await _discordAPI.FetchUserInfo(invite.InviteIssuerId, CacheBehavior.OnlyCache)
));
}
List <UserInviteExpandedView> invitedBy = new();
foreach (UserInvite invite in await inviteRepository.GetusedInvitesForUser(userId))
{
if (!modGuilds.Contains(invite.GuildId.ToString()))
{
continue;
}
invitedBy.Add(new UserInviteExpandedView(
invite,
await _discordAPI.FetchUserInfo(invite.JoinedUserId, CacheBehavior.OnlyCache),
await _discordAPI.FetchUserInfo(invite.InviteIssuerId, CacheBehavior.OnlyCache)
));
}
// mappings
// ===============================================================================================
UserMapRepository userMapRepository = UserMapRepository.CreateDefault(_serviceProvider, currentIdentity);
List <UserMappingExpandedView> userMappings = new();
foreach (UserMapping userMapping in await userMapRepository.GetUserMapsByUser(userId))
{
if (!modGuilds.Contains(userMapping.GuildId.ToString()))
{
continue;
}
userMappings.Add(new UserMappingExpandedView(
userMapping,
await _discordAPI.FetchUserInfo(userMapping.UserA, CacheBehavior.OnlyCache),
await _discordAPI.FetchUserInfo(userMapping.UserB, CacheBehavior.OnlyCache),
await _discordAPI.FetchUserInfo(userMapping.CreatorUserId, CacheBehavior.OnlyCache)
));
}
ModCaseRepository modCaseRepository = ModCaseRepository.CreateDefault(_serviceProvider, currentIdentity);
AutoModerationEventRepository autoModerationEventRepository = AutoModerationEventRepository.CreateDefault(_serviceProvider);
UserNoteRepository userNoteRepository = UserNoteRepository.CreateDefault(_serviceProvider, currentIdentity);
List <CaseView> modCases = (await modCaseRepository.GetCasesForUser(userId)).Where(x => modGuilds.Contains(x.GuildId.ToString())).Select(x => new CaseView(x)).ToList();
List <AutoModerationEventView> modEvents = (await autoModerationEventRepository.GetAllEventsForUser(userId)).Where(x => modGuilds.Contains(x.GuildId.ToString())).Select(x => new AutoModerationEventView(x)).ToList();
List <UserNoteView> userNotes = (await userNoteRepository.GetUserNotesByUser(userId)).Where(x => modGuilds.Contains(x.GuildId.ToString())).Select(x => new UserNoteView(x)).ToList();
return(Ok(new
{
guilds = guildViews,
user = searchedUser,
invited,
invitedBy,
modCases,
modEvents,
userMappings,
userNotes
}));
}