public UserMappingExpandedView(UserMapping userMapping, IUser userA, IUser userB, IUser moderator)
{
UserMapping = new UserMappingView(userMapping);
UserA = DiscordUserView.CreateOrDefault(userA);
UserB = DiscordUserView.CreateOrDefault(userB);
Moderator = DiscordUserView.CreateOrDefault(moderator);
}
public CaseExpandedView(ModCase modCase, IUser moderator, IUser lastModerator, IUser suspect, List <CommentExpandedView> comments, UserNoteExpandedView userNoteView)
{
ModCase = new CaseView(modCase);
Moderator = DiscordUserView.CreateOrDefault(moderator);
LastModerator = DiscordUserView.CreateOrDefault(lastModerator);
Suspect = DiscordUserView.CreateOrDefault(suspect);
Comments = comments;
UserNote = userNoteView;
if (modCase.PunishedUntil != null)
{
if (modCase.PunishedUntil > modCase.CreatedAt)
{
if (modCase.PunishedUntil < DateTime.UtcNow)
{
PunishmentProgress = 100;
}
else
{
double totalPunished = (modCase.PunishedUntil.Value - modCase.CreatedAt).TotalSeconds;
double alreadyPunished = (DateTime.UtcNow - modCase.CreatedAt).TotalSeconds;
PunishmentProgress = alreadyPunished / totalPunished * 100;
}
}
}
}
private static bool Contains(DiscordUserView obj, string search)
{
if (obj == null)
{
return(false);
}
return(Contains(obj.Username, search) || Contains(obj.Discriminator, search));
}
public void RemoveModeratorInfo(string suspectId)
{
if (Comment.UserId != suspectId)
{
Comment.UserId = null;
Commentor = null;
}
}
protected bool Contains(DiscordUserView obj, string search)
{
if (obj == null)
{
return(false);
}
return(Contains($"{obj.Username}#{obj.Discriminator}", search));
}
public APIUser(List <DiscordGuildView> memberGuilds, List <DiscordGuildView> bannedGuilds, List <DiscordGuildView> modGuilds, List <DiscordGuildView> adminGuilds, IUser user, bool isAdmin = false)
{
MemberGuilds = memberGuilds;
BannedGuilds = bannedGuilds;
ModGuilds = modGuilds;
AdminGuilds = adminGuilds;
DiscordUser = DiscordUserView.CreateOrDefault(user);
IsAdmin = isAdmin;
}
public async Task <IActionResult> GetSpecificUser([FromRoute] ulong userid)
{
var IUser = await _discordAPI.FetchUserInfo(userid, CacheBehavior.OnlyCache);
if (IUser != null)
{
return(Ok(DiscordUserView.CreateOrDefault(IUser)));
}
return(NotFound());
}
public async Task <IActionResult> GetGuildMembers([FromRoute] ulong guildId)
{
await GetRegisteredGuild(guildId); // Endpoint only available for registered guilds.
var members = await _discordAPI.FetchGuildMembers(guildId, CacheBehavior.OnlyCache);
if (members != null)
{
return(Ok(members.Select(x => DiscordUserView.CreateOrDefault(x))));
}
return(NotFound());
}
public ScheduledMessageView(ScheduledMessage message, IUser creator, IUser lastEdited, IGuildChannel channel = null)
{
Id = message.Id;
Name = message.Name;
Content = message.Content;
ScheduledFor = message.ScheduledFor;
Status = message.Status;
GuildId = message.GuildId.ToString();
ChannelId = message.ChannelId.ToString();
CreatorId = message.CreatorId.ToString();
LastEditedById = message.LastEditedById.ToString();
CreatedAt = message.CreatedAt;
LastEditedAt = message.LastEditedAt;
FailureReason = message.FailureReason;
Creator = DiscordUserView.CreateOrDefault(creator);
LastEdited = DiscordUserView.CreateOrDefault(lastEdited);
Channel = DiscordChannelView.CreateOrDefault(channel);
}
public UserNoteExpandedView(UserNote userNote, IUser user, IUser moderator)
{
UserNote = new UserNoteView(userNote);
User = DiscordUserView.CreateOrDefault(user);
Moderator = DiscordUserView.CreateOrDefault(moderator);
}
public IActionResult GetBotUser()
{
return(Ok(DiscordUserView.CreateOrDefault(_discordAPI.GetCurrentBotInfo())));
}
public CommentExpandedView(ModCaseComment comment, IUser commentor)
{
Comment = new CommentsView(comment);
Commentor = DiscordUserView.CreateOrDefault(commentor);
}
public UserInviteExpandedView(UserInvite userInvite, IUser invitedUser, IUser invitedBy)
{
UserInvite = new UserInviteView(userInvite);
InvitedUser = DiscordUserView.CreateOrDefault(invitedUser);
InvitedBy = DiscordUserView.CreateOrDefault(invitedBy);
}
public AutoModerationEventExpandedView(AutoModerationEvent moderationEvent, IUser suspect)
{
AutoModerationEvent = new AutoModerationEventView(moderationEvent);
Suspect = DiscordUserView.CreateOrDefault(suspect);
}
public async Task <IActionResult> GetModCaseView([FromRoute] ulong guildId, [FromRoute] int caseId)
{
await RequirePermission(guildId, caseId, APIActionPermission.View);
GuildConfig guildConfig = await GetRegisteredGuild(guildId);
Identity identity = await GetIdentity();
ModCase modCase = await ModCaseRepository.CreateDefault(_serviceProvider, identity).GetModCase(guildId, caseId);
IUser suspect = await _discordAPI.FetchUserInfo(modCase.UserId, CacheBehavior.OnlyCache);
List <CommentExpandedView> comments = new();
foreach (ModCaseComment comment in modCase.Comments)
{
comments.Add(new CommentExpandedView(
comment,
await _discordAPI.FetchUserInfo(comment.UserId, CacheBehavior.OnlyCache)
));
}
UserNoteExpandedView userNote = null;
if (await identity.HasPermissionOnGuild(DiscordPermission.Moderator, guildId))
{
try
{
var note = await UserNoteRepository.CreateDefault(_serviceProvider, identity).GetUserNote(guildId, modCase.UserId);
userNote = new UserNoteExpandedView(
note,
suspect,
await _discordAPI.FetchUserInfo(note.CreatorId, CacheBehavior.OnlyCache)
);
}
catch (ResourceNotFoundException) { }
}
CaseExpandedView caseView = new(
modCase,
await _discordAPI.FetchUserInfo(modCase.ModId, CacheBehavior.OnlyCache),
await _discordAPI.FetchUserInfo(modCase.LastEditedByModId, CacheBehavior.OnlyCache),
suspect,
comments,
userNote
);
if (modCase.LockedByUserId != 0)
{
caseView.LockedBy = DiscordUserView.CreateOrDefault(await _discordAPI.FetchUserInfo(modCase.LockedByUserId, CacheBehavior.OnlyCache));
}
if (modCase.DeletedByUserId != 0)
{
caseView.DeletedBy = DiscordUserView.CreateOrDefault(await _discordAPI.FetchUserInfo(modCase.DeletedByUserId, CacheBehavior.OnlyCache));
}
if (!(await identity.HasPermissionOnGuild(DiscordPermission.Moderator, guildId) || guildConfig.PublishModeratorInfo))
{
caseView.RemoveModeratorInfo();
}
return(Ok(caseView));
}
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
}));
}
public GuildMotdExpandedView(GuildMotd moderationEvent, IUser creator)
{
Motd = new GuildMotdView(moderationEvent);
Creator = DiscordUserView.CreateOrDefault(creator);
}
public ModCaseTableEntry(ModCase modCase, IUser moderator, IUser suspect)
{
ModCase = new CaseView(modCase);
Moderator = DiscordUserView.CreateOrDefault(moderator);
Suspect = DiscordUserView.CreateOrDefault(suspect);
}
