public void GetModerationType_Follower_WhiteListing_Test() { #region Stubs var settings = new ModerationSettings { FollowersWhiteListing = "@[email protected]" }; #endregion var repo = new ModerationRepository(settings); #region Validations Assert.AreEqual(ModerationTypeEnum.WhiteListing, repo.GetModerationType(ModerationEntityTypeEnum.Follower)); Assert.AreEqual(ModerationTypeEnum.None, repo.GetModerationType(ModerationEntityTypeEnum.TwitterAccount)); #endregion }
public void CheckStatus_Follower_BothListing_Test() { #region Stubs var settings = new ModerationSettings { FollowersWhiteListing = "@[email protected]", FollowersBlackListing = "@[email protected]" }; #endregion var repo = new ModerationRepository(settings); #region Validations Assert.AreEqual(ModeratedTypeEnum.WhiteListed, repo.CheckStatus(ModerationEntityTypeEnum.Follower, "@[email protected]")); Assert.AreEqual(ModeratedTypeEnum.None, repo.CheckStatus(ModerationEntityTypeEnum.Follower, "@[email protected]")); #endregion }
public async Task AddWarnRole(SocketRole role) { ModerationSettings settings = Context.Guild.LoadFromFile <ModerationSettings>(true); if (!settings.ableToWarn.Contains(role.Id)) { settings.ableToWarn.Add(role.Id); } else { _ = ReplyAsync("People with the role \"" + role.Name + "\" can already warn people"); } settings.SaveToFile(Context.Guild); await ReplyAsync("People with the role \"" + role.Name + "\" can now warn people"); }
public override void Recreate() { PacketModified.Append(Unknown0); RoomData.WriteTo(PacketModified); PacketModified.Append(Unknown1); PacketModified.Append(Unknown2); PacketModified.Append(Unknown3); PacketModified.Append(Unknown4); ModerationSettings.WriteTo(PacketModified); PacketModified.Append(Unknown5); ChatSettings.WriteTo(PacketModified); }
private NewChannelsState GetNewChannelState(ModerationSettings currentSettings, FilterType type, List <ulong> channelIds) { var currentWhitelistedChannels = currentSettings?.WhitelistedChannels.Where(c => c.WhitelistType == type); var channelsToAdd = new List <WhitelistedChannel>(); var channelsToRemove = new List <WhitelistedChannel>(); if (channelIds is null) { channelIds = new List <ulong>(); } if (currentWhitelistedChannels is null) { currentWhitelistedChannels = new List <WhitelistedChannel>(); } foreach (var channelId in channelIds) { if (!currentWhitelistedChannels.Any(c => c.ChannelId == channelId)) { channelsToAdd.Add(new WhitelistedChannel { ChannelId = channelId, GuildId = currentSettings.GuildId, WhitelistType = type }); } } foreach (var channel in currentWhitelistedChannels) { if (!channelIds.Any(c => c == channel.ChannelId)) { channelsToRemove.Add(channel); } } return(new NewChannelsState { ChannelsToAdd = channelsToAdd, ChannelsToRemove = channelsToRemove }); }
public async Task ToggleAutoMod() { ModerationSettings settings = Context.Guild.LoadFromFile <ModerationSettings>(true); if (settings.channelsWithoutAutoMod.Contains(Context.Channel.Id)) { settings.channelsWithoutAutoMod.Remove(Context.Channel.Id); await ReplyAsync("Enabled automod in this channel"); } else { settings.channelsWithoutAutoMod.Add(Context.Channel.Id); await ReplyAsync("Disabled automod in this channel"); } settings.SaveToFile(Context.Guild); }
public void CheckStatus_TwitterAccount_BothListing_Test() { #region Stubs var settings = new ModerationSettings { TwitterAccountsWhiteListing = "handle", TwitterAccountsBlackListing = "handle" }; #endregion var repo = new ModerationRepository(settings); #region Validations Assert.AreEqual(ModeratedTypeEnum.WhiteListed, repo.CheckStatus(ModerationEntityTypeEnum.TwitterAccount, "handle")); Assert.AreEqual(ModeratedTypeEnum.None, repo.CheckStatus(ModerationEntityTypeEnum.TwitterAccount, "handle2")); #endregion }
private NewRolesState GetNewRolesState(ModerationSettings currentSettings, FilterType type, List <ulong> roleIds) { var currentWhitelistedRoles = currentSettings?.WhitelistedRoles.Where(r => r.WhitelistType == type); var rolesToRemove = new List <WhitelistedRole>(); var rolesToAdd = new List <WhitelistedRole>(); if (roleIds is null) { roleIds = new List <ulong>(); } if (currentWhitelistedRoles is null) { currentWhitelistedRoles = new List <WhitelistedRole>(); } foreach (var roleId in roleIds) { if (!currentWhitelistedRoles.Any(c => c.RoleId == roleId)) { rolesToAdd.Add(new WhitelistedRole { GuildId = currentSettings.GuildId, RoleId = roleId, WhitelistType = type }); } } foreach (var role in currentWhitelistedRoles) { if (!roleIds.Any(r => r == role.RoleId)) { rolesToRemove.Add(role); } } return(new NewRolesState { RolesToAdd = rolesToAdd, RolesToRemove = rolesToRemove }); }
public async Task AddWarnIgnoredRole(SocketRole role) { ModerationSettings settings = Context.Guild.LoadFromFile <ModerationSettings>(true); if (settings.cantBeWarned == null) { settings.cantBeWarned = new List <ulong>(); } else if (settings.cantBeWarned.Contains(role.Id)) { await ReplyAsync($"Role '{role.Name}' is already not able to be warned"); return; } settings.cantBeWarned.Add(role.Id); settings.SaveToFile(Context.Guild); await ReplyAsync($"Role '{role.Name}' will not be able to be warned now"); }
public async Task RemoveAllowedLink(string link) { ModerationSettings settings = Context.Guild.LoadFromFile <ModerationSettings>(true); if (settings.allowedLinks == null || !settings.allowedLinks.Contains(link)) { await ReplyAsync("Link is already not allowed"); return; } settings.allowedLinks.Remove(link); if (settings.allowedLinks.Count == 0) { settings.allowedLinks = null; } settings.SaveToFile(Context.Guild); await ReplyAsync("People will no longer be allowed to use " + link); }
public async Task ToggleInviteWarn() { IUserMessage message = await ReplyAsync("Trying to toggle"); ModerationSettings settings = Context.Guild.LoadFromFile <ModerationSettings>(true); if (settings == null) { settings = new ModerationSettings(); Console.WriteLine(DateTime.Now.ToShortTimeString() + " Creating new mod settings"); } settings.invitesAllowed = !settings.invitesAllowed; Console.WriteLine(DateTime.Now.ToShortTimeString() + " setting invites to " + settings.invitesAllowed); settings.SaveToFile(Context.Guild); await message.ModifyAsync(msg => msg.Content = "set invites allowed to " + settings.invitesAllowed.ToString().ToLower()); }
public async Task AddAllowedLinkRole(SocketRole role) { ModerationSettings settings = Context.Guild.LoadFromFile <ModerationSettings>(true); if (settings.allowedToLink == null) { settings.allowedToLink = new List <ulong>(); } if (settings.allowedToLink.Contains(role.Id)) { await ReplyAsync($"Role '{role.Name}' was already exempt from link filtering"); return; } settings.allowedToLink.Add(role.Id); settings.SaveToFile(Context.Guild); await ReplyAsync($"Role '{role.Name}' is now exempt from link filtering"); }
public async Task DynamicSlowmode(double factor) { if (factor < 0) { await ReplyAsync("Why would you need a factor that low?"); return; } SocketTextChannel channel = Context.Channel as SocketTextChannel; ModerationSettings settings = Context.Guild.LoadFromFile <ModerationSettings>(true); string channelId = Convert.ToString(channel.Id); if (factor == 0) { settings.dynamicSlowmode.Remove(channelId); await ReplyAsync(channel.Mention + " no longer has dynamic slowmode."); } else { if (!settings.dynamicSlowmode.ContainsKey(channelId)) { settings.dynamicSlowmode.Add(channelId, factor); } else { if (settings.dynamicSlowmode[channelId] == factor) { await ReplyAsync(channel.Mention + " already has a dynamic slowmode with a factor of " + factor + "."); return; } settings.dynamicSlowmode[channelId] = factor; } await ReplyAsync(channel.Mention + " now has a dynamic slowmode with a factor of " + factor + "."); } settings.SaveToFile(); }
public async Task SetMaxEmojis(string amount) { ModerationSettings settings = null; switch (amount.ToLower()) { case "null": case "none": case "disable": settings = Context.Guild.LoadFromFile <ModerationSettings>(false); if (settings?.maxEmojis == null) { await ReplyAsync("Emoji moderation is already disabled"); } else { settings.maxEmojis = null; settings.SaveToFile(Context.Guild); await ReplyAsync("Emoji moderation is now disabled"); } break; case "all": settings = Context.Guild.LoadFromFile <ModerationSettings>(true); settings.maxEmojis = 0; settings.SaveToFile(Context.Guild); string extraInfo = ""; if (settings.allowedToLink.NotEmpty()) { extraInfo = " except by role allowed to link"; } await ReplyAsync("Emojis are now no longer allowed" + extraInfo); break; default: await ReplyAsync("Input not understood"); break; } }
public async Task RemoveAllowedLinkRole(SocketRole role) { ModerationSettings settings = Context.Guild.LoadFromFile <ModerationSettings>(); if (settings == null || settings.allowedToLink == null) { await ReplyAsync($"No role is currently excused from posting links"); return; } if (settings.allowedToLink.Contains(role.Id)) { settings.allowedToLink.Remove(role.Id); settings.SaveToFile(Context.Guild); await ReplyAsync($"Role '{role.Name}' is no longer exempt from link filtering"); return; } await ReplyAsync($"Role '{role.Name}' wasn't exempt from link filtering"); }
public async Task SetMaxPunishment(string length) { ModerationSettings settings = Context.Guild.LoadFromFile <ModerationSettings>(true); if (length == "none") { //Maybe add more options that mean none if (settings.maxTempAction == null) { await ReplyAsync("The maximum temp punishment is already none"); return; } else { settings.maxTempAction = null; settings.SaveToFile(); await ReplyAsync("The maximum temp punishment is now none"); } return; } TimeSpan?span = length.ToTime(); if (span != null) { if (span == settings.maxTempAction) { await ReplyAsync("The maximum temp punishment is already " + ((TimeSpan)span).LimitedHumanize(4)); } else { settings.maxTempAction = span; settings.SaveToFile(); await ReplyAsync("The maximum temp punishment is now " + ((TimeSpan)span).LimitedHumanize(4)); } } else { await ReplyAsync("Your time is incorrectly setup"); } }
public async Task TempMuteWarnUser([RequireHierarchy] UserRef userRef, TimeSpan time, float size, [Remainder] string reason) { if (time.TotalMinutes < 1) { await ReplyAsync("Can't temp-mute for less than a minute"); return; } ModerationSettings settings = Context.Guild.LoadFromFile <ModerationSettings>(); if (!(Context.Message.Author as IGuildUser).HasAdmin()) { if (settings?.maxTempAction != null && time > settings.maxTempAction) { await ReplyAsync("You are not allowed to punish for that long"); return; } } if (settings == null || settings.mutedRole == 0 || Context.Guild.GetRole(settings.mutedRole) == null) { await ReplyAsync("Muted role is null or invalid"); return; } await userRef.Warn(size, reason, Context.Channel as ITextChannel, "Discord"); TempActionList actions = Context.Guild.LoadFromFile <TempActionList>(true); if (actions.tempMutes.Any(tempMute => tempMute.User == userRef.ID)) { await ReplyAsync($"{userRef.Name()} is already temp-muted, (the warn did go through)"); return; } await userRef.TempMute(time, reason, Context, settings, actions); Context.Message.DeleteOrRespond($"Temporarily muted {userRef.Mention()} for {time.LimitedHumanize(3)} because of {reason}", Context.Guild); }
public async Task Check() { try { foreach (SocketGuild guild in _client.Guilds) { ModerationSettings settings = guild.LoadFromFile <ModerationSettings>(); if (settings?.dynamicSlowmode == null) { continue; } foreach (KeyValuePair <string, double> channelSetting in settings.dynamicSlowmode) { // Key: channel id // Value: factor SocketTextChannel channel = guild.GetTextChannel(Convert.ToUInt64(channelSetting.Key)); var messages = await channel.GetMessagesAsync(200).FlattenAsync(); messages = messages.Where(msg => msg.GetTimeAgo() < TimeSpan.FromMinutes(1)); var count = messages.Count() * channelSetting.Value; //API limit if (count >= 21599) { count = 21599; } if (count < 2) { count = 1; } await channel.ModifyAsync(c => c.SlowModeInterval = Convert.ToInt32(count)); } } } catch (Exception e) { await new LogMessage(LogSeverity.Error, "Slow", "Something went wrong in slowmode", e).Log(); } }
private NewWhitelistedLinksState GetNewLinksState(ModerationSettings currentSettings, HashSet <string> links) { var linksToAdd = new List <WhitelistedLink>(); var linksToRemove = new List <WhitelistedLink>(); var whitelistedLinks = currentSettings?.LinkFilter?.WhitelistedLinks ?? new List <WhitelistedLink>(); if (links is null) { links = new HashSet <string>(); } foreach (var link in links) { if (!whitelistedLinks.Any(l => l.Link == link)) { linksToAdd.Add(new WhitelistedLink { GuildId = currentSettings.GuildId, Link = link.ToLower() }); } } foreach (var link in whitelistedLinks) { if (!links.Contains(link.Link)) { linksToRemove.Add(link); } } return(new NewWhitelistedLinksState { LinksToAdd = linksToAdd, LinksToRemove = linksToRemove }); }
private NewBannedWordsState GetNewBannedWordsState(ModerationSettings currentSettings, HashSet <string> words) { var wordsToAdd = new List <BannedWord>(); var wordsToRemove = new List <BannedWord>(); var bannedWords = currentSettings?.ProfanityFilter?.BannedWords ?? new List <BannedWord>(); if (words is null) { words = new HashSet <string>(); } foreach (var word in words) { if (!bannedWords.Any(l => l.Word == word)) { wordsToAdd.Add(new BannedWord { Word = word.ToLower(), GuildId = currentSettings.GuildId }); } } foreach (var word in bannedWords) { if (!words.Contains(word.Word)) { wordsToRemove.Add(word); } } return(new NewBannedWordsState { WordsToAdd = wordsToAdd, WordsToRemove = wordsToRemove }); }
public async Task SetMutedRole(SocketRole role) { ModerationSettings settings = Context.Guild.LoadFromFile <ModerationSettings>(true); if (settings == null) { settings = new ModerationSettings(); } if (settings.mutedRole != role.Id) { settings.mutedRole = role.Id; } else { _ = ReplyAsync("The role \"" + role.Name + "\" is already the muted role"); return; } settings.SaveToFile(Context.Guild); await ReplyAsync("The role \"" + role.Name + "\" is now the muted role"); }
public static bool CantBeWarned(this SocketGuildUser user) { if (HasAdmin(user)) { return(true); } ModerationSettings settings = user.Guild.LoadFromFile <ModerationSettings>(); if (settings != null) { List <SocketRole> rolesUnableToBeWarned = new List <SocketRole>(); foreach (ulong roleID in settings.cantBeWarned) { rolesUnableToBeWarned.Add(user.Guild.GetRole(roleID)); } if (user.Roles.Intersect(rolesUnableToBeWarned).Any()) { return(true); } } return(false); }
public RoomData() { ModerationSettings = new ModerationSettings(this); }
public async Task ModerationInfo() { ModerationSettings settings = SettingFunctions.LoadModSettings(Context.Guild, false); if (settings == null) { _ = ReplyAsync("Moderation settings are null"); return; } var embed = new EmbedBuilder(); string rolesAbleToWarn = ""; foreach (SocketRole role in Context.Guild.Roles) { if (role.Permissions.KickMembers && !role.IsManaged) { if (rolesAbleToWarn != "") { rolesAbleToWarn += "\n"; } if (role.IsMentionable) { rolesAbleToWarn += role.Mention; } else { rolesAbleToWarn += role.Name; } } } if (settings.ableToWarn != null && settings.ableToWarn.Count > 0) { foreach (ulong roleID in settings.ableToWarn) { SocketRole role = Context.Guild.GetRole(roleID); if (role != null) { if (rolesAbleToWarn != "") { rolesAbleToWarn += "\n"; } if (role.IsMentionable) { rolesAbleToWarn += role.Mention; } else { rolesAbleToWarn += role.Name; } } else { settings.ableToWarn.Remove(roleID); } } } embed.AddField("Roles that can warn", rolesAbleToWarn, true); embed.AddField("Will invites lead to warn", !settings.invitesAllowed, true); await ReplyAsync(embed : embed.Build()); }
public async Task CheckMessage(SocketMessage message) { try { if (message.Author.IsBot || !(message.Channel is SocketGuildChannel) || !(message is SocketUserMessage)) { return; //Makes sure it's not logging a message from a bot and that it's in a discord server } SocketCommandContext context = new SocketCommandContext(client, message as SocketUserMessage); SocketGuildChannel chnl = message.Channel as SocketGuildChannel; if (chnl?.Guild == null) { return; } var Guild = chnl.Guild; ModerationSettings modSettings = Guild.LoadFromFile <ModerationSettings>(); SocketGuildUser gUser = message.Author as SocketGuildUser; List <BadWord> badWords = Guild.LoadFromFile <BadWordList>()?.badWords; if (modSettings != null) { if (modSettings.channelsWithoutAutoMod != null && modSettings.channelsWithoutAutoMod.Contains(chnl.Id) || (message.Author as SocketGuildUser).CantBeWarned()) { return; //Returns if channel is set as not using automod } //Checks if a message contains an invite if (!modSettings.invitesAllowed && message.Content.ToLower().Contains("discord.gg/") || message.Content.ToLower().Contains("discordapp.com/invite/")) { await context.Punish("Posted Invite"); return; } //Checks for links if ((modSettings.allowedLinks != null && modSettings.allowedLinks.Count > 0) && (modSettings.allowedToLink == null || !gUser.RoleIDs().Intersect(modSettings.allowedToLink).Any())) { const string linkRegex = @"^((?:https?|steam):\/\/[^\s<]+[^<.,:;" + "\"\'\\]\\s])"; MatchCollection matches = Regex.Matches(message.Content, linkRegex, RegexOptions.IgnoreCase); //if (matches != null && matches.Count > 0) await new LogMessage(LogSeverity.Info, "Filter", "Link detected").Log(); foreach (Match match in matches) { if (!modSettings.allowedLinks.Any(s => match.ToString().ToLower().Contains(s.ToLower()))) { await context.Punish("Using unauthorized links", 1); return; } } } //Check for emojis if (modSettings.badUEmojis.NotEmpty() && modSettings.badUEmojis.Any(s => message.Content.Contains(s))) { await context.Punish("Bad emoji used", 0.8f); return; } if (modSettings.allowedCaps > 0 && message.Content.Length > 5) { uint amountCaps = 0; foreach (char c in message.Content) { if (char.IsUpper(c)) { amountCaps++; } } if (((amountCaps / (float)message.Content.Length) * 100) >= modSettings.allowedCaps) { await context.Punish("Excessive caps", 0.3f); return; } } } //End of stuff from mod settings //Checks for bad words if (badWords != null) { StringBuilder sb = new StringBuilder(); foreach (char c in message.Content) { if (sb.ToString().Length + 1 == message.Content.Length) { sb.Append(c); break; } switch (c) { case '1': case '!': sb.Append('i'); break; case '0': sb.Append('o'); break; case '8': sb.Append('b'); break; case '3': sb.Append('e'); break; case '$': sb.Append('s'); break; case '@': case '4': sb.Append('a'); break; default: if (!char.IsPunctuation(c) && !char.IsSymbol(c)) { sb.Append(c); } break; } } string strippedMessage = sb.ToString().ToLower(); foreach (BadWord badWord in badWords) { if (badWord.partOfWord) { if (strippedMessage.Contains(badWord.word.ToLower())) { if (badWord.euphemism != null && badWord.euphemism != "") { await context.Punish("Bad word used (" + badWord.euphemism + ")"); } else { await context.Punish("Bad word used"); } return; } } else { string[] messageParts = strippedMessage.Split(' '); foreach (string word in messageParts) { if (word == badWord.word.ToLower()) { if (badWord.euphemism != null && badWord.euphemism != "") { await context.Punish("Bad word used (" + badWord.euphemism + ")", badWord.size); } else { await context.Punish("Bad word used", badWord.size); } return; } } } } } } catch (Exception e) { await new LogMessage(LogSeverity.Error, "Filter", "Something went wrong with the message filter", e).Log(); } }
public static async Task CheckTempActs(DiscordSocketClient client, bool debug = false, CancellationToken?ct = null) { RequestOptions requestOptions = RequestOptions.Default; requestOptions.RetryMode = RetryMode.AlwaysRetry; try { currentInfo.checkedGuilds = 0; foreach (SocketGuild sockGuild in client.Guilds) { ct?.ThrowIfCancellationRequested(); currentInfo.checkedMutes = 0; if (currentInfo.checkedGuilds > client.Guilds.Count) { await new LogMessage(LogSeverity.Error, "TempAct", $"Check went past all guilds (at #{currentInfo.checkedGuilds}) but has been stopped. This doesn't seem physically possible.").Log(); return; } RestGuild restGuild = await client.Rest.SuperGetRestGuild(sockGuild.Id); if (debug) { Console.ForegroundColor = ConsoleColor.Cyan; Console.Write($"\nChecking {sockGuild.Name} discord "); } TempActionList actions = sockGuild.LoadFromFile <TempActionList>(false); bool needSave = false; currentInfo.checkedGuilds++; if (actions != null) { if (actions.tempBans?.Count is not null or 0) { currentInfo.editedBans = new List <TempAct>(actions.tempBans); foreach (TempAct tempBan in actions.tempBans) { try { RestBan ban = await sockGuild.GetBanAsync(tempBan.User, requestOptions); if (ban == null) { //If manual unban var user = await client.Rest.GetUserAsync(tempBan.User); currentInfo.editedBans.Remove(tempBan); user?.TryNotify($"As you might know, you have been manually unbanned in {sockGuild.Name} discord"); //_ = new LogMessage(LogSeverity.Warning, "TempAction", "Tempbanned person isn't banned").Log(); if (user == null) { DiscordLogging.LogManualEndTempAct(sockGuild, tempBan.User, "bann", tempBan.DateBanned); } else { DiscordLogging.LogManualEndTempAct(sockGuild, user, "bann", tempBan.DateBanned); } } else if (DateTime.UtcNow >= tempBan.DateBanned.Add(tempBan.Length)) { RestUser rUser = ban.User; await sockGuild.RemoveBanAsync(tempBan.User, requestOptions); currentInfo.editedBans.Remove(tempBan); DiscordLogging.LogEndTempAct(sockGuild, rUser, "bann", tempBan.Reason, tempBan.Length); } } catch (Exception e) { await new LogMessage(LogSeverity.Error, "TempAct", "Something went wrong unbanning someone, continuing", e).Log(); } } //if all tempbans DON'T equal all edited tempbans (basically if there was a change if (currentInfo.editedBans.Count != actions.tempBans.Count) { if (debug) { Console.Write($"{actions.tempBans.Count - currentInfo.editedBans.Count} tempbans are over, "); } needSave = true; actions.tempBans = currentInfo.editedBans; } else if (debug) { Console.Write($"tempbans checked, none over, "); } } else if (debug) { Console.Write($"no tempbans, "); } ModerationSettings settings = sockGuild.LoadFromFile <ModerationSettings>(); if (settings is not null && sockGuild.GetRole(settings.mutedRole) != null && actions.tempMutes?.Count is not null or 0) { var mutedRole = sockGuild.GetRole(settings.mutedRole); List <TempAct> editedMutes = new List <TempAct>(actions.tempMutes); foreach (TempAct tempMute in actions.tempMutes) { currentInfo.checkedMutes++; try { IGuildUser gUser = sockGuild.GetUser(tempMute.User) ?? await restGuild.SuperGetUser(tempMute.User); if (gUser != null && !gUser.RoleIds.Contains(settings.mutedRole)) { //User missing muted role, must have been manually unmuted _ = gUser.TryNotify($"As you might know, you have been manually unmuted in {sockGuild.Name} discord"); editedMutes.Remove(tempMute); DiscordLogging.LogManualEndTempAct(sockGuild, gUser, "mut", tempMute.DateBanned); _ = (!editedMutes.Contains(tempMute)).AssertAsync("Tempmute not removed?!"); } else if (DateTime.UtcNow >= tempMute.DateBanned.Add(tempMute.Length)) { //Normal mute end if (gUser != null) { await gUser.RemoveRoleAsync(mutedRole, requestOptions); } // if user not in guild || if user doesn't contain muted role (successfully removed? if (gUser == null || !gUser.RoleIds.Contains(settings.mutedRole)) { //Doesn't remove tempmute if unmuting fails IUser user = gUser; //Gets user to try to message user ??= await client.SuperGetUser(tempMute.User); if (user != null) { // if possible to message, message and log DiscordLogging.LogEndTempAct(sockGuild, user, "mut", tempMute.Reason, tempMute.Length); _ = user.Notify("auto untempmuted", tempMute.Reason, sockGuild, client.CurrentUser); } editedMutes.Remove(tempMute); } else if (gUser != null) { await new LogMessage(LogSeverity.Warning, "TempAct", "User should've had role removed").Log(); } } } catch (Exception e) { await new LogMessage(LogSeverity.Error, "TempAct", "Something went wrong unmuting someone, continuing", e).Log(); } } //NOTE: Assertions fail if NOT true _ = (currentInfo.checkedMutes == actions.tempMutes.Count).AssertAsync($"Checked incorrect number tempmutes ({currentInfo.checkedMutes}/{actions.tempMutes.Count}) in guild {sockGuild} owned by {sockGuild.Owner}"); if (editedMutes.Count != actions.tempMutes.Count) { if (debug) { Console.Write($"{actions.tempMutes.Count - editedMutes.Count}/{actions.tempMutes.Count} tempmutes are over"); } actions.tempMutes = editedMutes; needSave = true; } else if (debug) { Console.Write($"none of {actions.tempMutes.Count} tempmutes over"); } } else if (debug) { Console.Write("no tempmutes to check or no settings"); } if (needSave) { actions.SaveToFile(); } }
public static void Append(this ServerMessage message, ModerationSettings modSettings) { message.AppendInteger(modSettings.WhoCanMute.Value); message.AppendInteger(modSettings.WhoCanKick.Value); message.AppendInteger(modSettings.WhoCanBan.Value); }
public async Task ListAutoMod(string extension = "", [Remainder] string whoCaresWhatGoesHere = null) { try { ModerationSettings settings = Context.Guild.LoadFromFile <ModerationSettings>(); BadWords badWords = new BadWords(Context.Guild); var embed = new EmbedBuilder(); embed.Author = new EmbedAuthorBuilder().WithName("Automod information for " + Context.Guild.Name + " discord"); string message = ""; bool useExplicit = false; if (extension != null && extension.ToLower() == "explicit" || extension.ToLower() == "e") { if ((Context.Message.Author as SocketGuildUser).CanWarn()) { useExplicit = true; } else { await ReplyAsync("You lack the permissions for viewing explicit bad words"); return; } } if (settings == null) { embed.AddField("Moderation settings", "Are null", true); } else { embed.AddField("Warn for posting invite", !settings.invitesAllowed, true); if (settings.allowedLinks == null || settings.allowedLinks.Count == 0) { embed.AddField("Allowed links", "Links aren't moderated ", true); } else { message = settings.allowedLinks.ListItems("\n"); if (message.NotEmpty()) { embed.AddField("Allowed links", message, true); } if (settings.allowedToLink != null && settings.allowedToLink.Count > 0) { message = Context.Guild.Roles.Where( role => (role.Permissions.Administrator && !role.IsManaged) || settings.allowedToLink.Contains(role.Id)).Select(role => role.Name).ToArray().ListItems("\n"); if (message.NotEmpty()) { embed.AddField("Roles that can post links", message, true); } } } if (settings.allowedCaps > 0) { embed.AddField("Allowed caps", $"{settings.allowedCaps}% in msgs more than 5 long"); } else { embed.AddField("Allowed caps", "Capitalization is not filtered"); } string badUniEmojis = settings.badUEmojis?.ListItems(""); if (!badUniEmojis.IsNullOrEmpty()) { embed.AddField("Banned Emojis", badUniEmojis, true); } } if (badWords != null && badWords.all != null && badWords.all.Count > 0) { List <string> words = new List <string>(); foreach (List <BadWord> group in badWords.grouped) { BadWord first = group.FirstOrDefault(); if (first != null) { string word = ""; if (useExplicit) { if (group.Count == 1 || group.All(badWord => badWord.size == first.size)) { word = $"[{first.size}x] "; } else { var sizes = group.Select(badword => badword.size); word = $"[{sizes.Min()}-{sizes.Max()}x] "; } if (first.euphemism.NotEmpty()) { word += $"{first.euphemism} "; } word += $"({group.Select(badWord => badWord.word).ToArray().ListItems(", ")})"; } else if (!first.euphemism.IsNullOrEmpty()) { word = first.euphemism; } if (first.partOfWord && (!first.euphemism.IsNullOrEmpty() || useExplicit)) { word += "⌝"; } words.Add(word); } else { _ = new LogMessage(LogSeverity.Error, "Filter", "Empty badword list in badwords").Log(); } } /*foreach (BadWord badWord in badWords.all) { Old code * string word = ""; * if (useExplicit) { * word = $"[{badWord.size}x] " ; * if (badWord.euphemism.NotEmpty()) word += $"{badWord.euphemism} "; * word += $"({badWord.word})"; * } * else if (!badWord.euphemism.IsNullOrEmpty()) word = badWord.euphemism; * if (badWord.partOfWord && (useExplicit || !badWord.euphemism.IsNullOrEmpty())) { * word += "⌝"; * } * words.Add(word); * }*/ message = words.ListItems("\n"); embed.AddField("Badword euphemisms (not an exhaustive list)", message, false); } IDMChannel channel = Context.Message.Author.GetOrCreateDMChannelAsync().Result; if (channel != null) { _ = channel.SendMessageAsync("The symbol '⌝' next to a word means that you can be warned for a word that contains the bad word", embed: embed.Build()); } else { _ = ReplyAsync(Context.Message.Author.Mention + " we can't send a message to your DMs"); } } catch (Exception e) { _ = new LogMessage(LogSeverity.Error, "Settings", "Error", e).Log(); } }
public static async Task TempActChecker(DiscordSocketClient client, bool debug = false) { try { int checkedGuilds = 0; foreach (SocketGuild guild in client.Guilds) { if (debug) { Console.ForegroundColor = ConsoleColor.Cyan; Console.Write($"\nChecking {guild.Name} discord "); } TempActionList actions = guild.LoadFromFile <TempActionList>(false); bool needSave = false; checkedGuilds++; if (actions != null) { if (!actions.tempBans.IsNullOrEmpty()) { List <TempAct> editedBans = new List <TempAct>(actions.tempBans); foreach (TempAct tempBan in actions.tempBans) { try { if (!guild.GetBansAsync().Result.Any(ban => ban.User.Id == tempBan.user)) //Need to add an embed for when this happens that's distinct { _ = client.GetUser(tempBan.user)?.TryNotify($"As you might know, you have been manually unbanned in {guild.Name} discord"); //_ = new LogMessage(LogSeverity.Warning, "TempAction", "Tempbanned person isn't banned").Log(); editedBans.Remove(tempBan); } else if (DateTime.Now >= tempBan.dateBanned.Add(tempBan.length)) { RestUser rUser = guild.GetBansAsync().Result.First(ban => ban.User.Id == tempBan.user).User; await guild.RemoveBanAsync(tempBan.user); editedBans.Remove(tempBan); Logging.LogEndTempAct(guild, rUser, "bann", tempBan.reason, tempBan.length); } } catch (Exception e) { _ = new LogMessage(LogSeverity.Error, "TempAct", "Something went wrong unbanning someone, continuing", e).Log(); } } if (editedBans != actions.tempBans) { if (debug) { Console.Write($"{actions.tempBans.Count - editedBans.Count} tempbans are over, "); } needSave = true; actions.tempBans = editedBans; } else if (debug) { Console.Write($"tempbans checked, none over, "); } } else if (debug) { Console.Write($"no tempbans, "); } ModerationSettings settings = guild.LoadFromFile <ModerationSettings>(); if (settings != null && guild.GetRole(settings.mutedRole) != null && !actions.tempMutes.IsNullOrEmpty()) { List <TempAct> editedMutes = new List <TempAct>(actions.tempMutes); uint checkedMutes = 0; foreach (TempAct tempMute in actions.tempMutes) { checkedMutes++; try { SocketUser user = guild.GetUser(tempMute.user); if (user != null && !(user as IGuildUser).RoleIds.Contains(settings.mutedRole)) { _ = user.TryNotify($"As you might know, you have been manually unmuted in {guild.Name} discord"); editedMutes.Remove(tempMute); } else if (DateTime.Now >= tempMute.dateBanned.Add(tempMute.length)) { if (user != null) { await guild.GetUser(tempMute.user).RemoveRoleAsync(guild.GetRole(settings.mutedRole)); } if (!(user as IGuildUser)?.RoleIds?.NotEmpty() ?? true || !(user as IGuildUser).RoleIds.Contains(settings.mutedRole)) //Doesn't remove tempmute if unmuting fails { user ??= client.GetUser(tempMute.user); if (user != null) { Logging.LogEndTempAct(guild, user, "mut", tempMute.reason, tempMute.length); _ = user.Notify($"untemp-muted", tempMute.reason, guild); } editedMutes.Remove(tempMute); } } } catch (Exception e) { _ = new LogMessage(LogSeverity.Error, "TempAct", "Something went wrong unmuting someone, continuing", e).Log(); } } _ = (checkedMutes == actions.tempMutes.Count || checkedMutes == uint.MaxValue).AssertAsync("Didn't check all tempmutes"); if (editedMutes != actions.tempMutes) { if (debug) { Console.Write($"{actions.tempMutes.Count - editedMutes.Count}/{actions.tempMutes.Count} tempmutes are over"); } actions.tempMutes = editedMutes; needSave = true; } else if (debug) { Console.Write($"no tempmute changes"); } } else if (debug) { Console.Write("no tempmutes to check or no settings"); } if (needSave) { actions.SaveToFile(guild); } } } if (debug) { Console.Write("\n"); } _ = (checkedGuilds > 0).AssertWarnAsync("Checked 0 guilds for tempbans?"); } catch (Exception e) { _ = new LogMessage(LogSeverity.Error, "TempAct", "Something went wrong unbanning someone", e).Log(); } }