diff --git a/backend/src/data/DefaultLogMessages.json b/backend/src/data/DefaultLogMessages.json index 5a38dd5f..dd992775 100644 --- a/backend/src/data/DefaultLogMessages.json +++ b/backend/src/data/DefaultLogMessages.json @@ -19,6 +19,8 @@ "MEMBER_NICK_CHANGE": "✏ {userMention(member)}: nickname changed from **{oldNick}** to **{newNick}**", "MEMBER_USERNAME_CHANGE": "✏ {userMention(user)}: username changed from **{oldName}** to **{newName}**", "MEMBER_RESTORE": "💿 Restored {restoredData} for {userMention(member)} on rejoin", + "MEMBER_TIMED_BAN": "🔨 {userMention(user)} was tempbanned by {userMention(mod)} for {banTime}", + "MEMBER_TIMED_UNBAN": "🔓 User (`{userId}`) was automatically unbanned by {userMention(mod)} after a tempban for {banTime}", "CHANNEL_CREATE": "🖊 Channel {channelMention(channel)} was created", "CHANNEL_DELETE": "🗑 Channel {channelMention(channel)} was deleted", diff --git a/backend/src/data/GuildTempbans.ts b/backend/src/data/GuildTempbans.ts new file mode 100644 index 00000000..76e126c5 --- /dev/null +++ b/backend/src/data/GuildTempbans.ts @@ -0,0 +1,75 @@ +import moment from "moment-timezone"; +import { Mute } from "./entities/Mute"; +import { BaseGuildRepository } from "./BaseGuildRepository"; +import { Brackets, getRepository, Repository } from "typeorm"; +import { Tempban } from "./entities/Tempban"; + +export class GuildTempbans extends BaseGuildRepository { + private tempbans: Repository; + + constructor(guildId) { + super(guildId); + this.tempbans = getRepository(Tempban); + } + + async getExpiredTempbans(): Promise { + return this.tempbans + .createQueryBuilder("mutes") + .where("guild_id = :guild_id", { guild_id: this.guildId }) + .andWhere("expires_at IS NOT NULL") + .andWhere("expires_at <= NOW()") + .getMany(); + } + + async findExistingTempbanForUserId(userId: string): Promise { + return this.tempbans.findOne({ + where: { + guild_id: this.guildId, + user_id: userId, + }, + }); + } + + async addTempban(userId, expiryTime, modId): Promise { + const expiresAt = moment + .utc() + .add(expiryTime, "ms") + .format("YYYY-MM-DD HH:mm:ss"); + + const result = await this.tempbans.insert({ + guild_id: this.guildId, + user_id: userId, + mod_id: modId, + expires_at: expiresAt, + created_at: moment.utc().format("YYYY-MM-DD HH:mm:ss"), + }); + + return (await this.tempbans.findOne({ where: result.identifiers[0] }))!; + } + + async updateExpiryTime(userId, newExpiryTime, modId) { + const expiresAt = moment + .utc() + .add(newExpiryTime, "ms") + .format("YYYY-MM-DD HH:mm:ss"); + + return this.tempbans.update( + { + guild_id: this.guildId, + user_id: userId, + }, + { + created_at: moment.utc().format("YYYY-MM-DD HH:mm:ss"), + expires_at: expiresAt, + mod_id: modId, + }, + ); + } + + async clear(userId) { + await this.tempbans.delete({ + guild_id: this.guildId, + user_id: userId, + }); + } +} diff --git a/backend/src/data/LogType.ts b/backend/src/data/LogType.ts index 8f27bf4f..14dadb69 100644 --- a/backend/src/data/LogType.ts +++ b/backend/src/data/LogType.ts @@ -44,6 +44,8 @@ export enum LogType { MEMBER_TIMED_MUTE, MEMBER_TIMED_UNMUTE, + MEMBER_TIMED_BAN, + MEMBER_TIMED_UNBAN, MEMBER_JOIN_WITH_PRIOR_RECORDS, OTHER_SPAM_DETECTED, diff --git a/backend/src/data/entities/Tempban.ts b/backend/src/data/entities/Tempban.ts new file mode 100644 index 00000000..399e94ff --- /dev/null +++ b/backend/src/data/entities/Tempban.ts @@ -0,0 +1,18 @@ +import { Column, Entity, PrimaryColumn } from "typeorm"; + +@Entity("tempbans") +export class Tempban { + @Column() + @PrimaryColumn() + guild_id: string; + + @Column() + @PrimaryColumn() + user_id: string; + + @Column() mod_id: string; + + @Column() created_at: string; + + @Column() expires_at: string; +} diff --git a/backend/src/migrations/1608753440716-CreateTempBansTable.ts b/backend/src/migrations/1608753440716-CreateTempBansTable.ts new file mode 100644 index 00000000..7345d34c --- /dev/null +++ b/backend/src/migrations/1608753440716-CreateTempBansTable.ts @@ -0,0 +1,45 @@ +import { MigrationInterface, QueryRunner, Table, TableIndex } from "typeorm"; + +export class CreateTempBansTable1608753440716 implements MigrationInterface { + public async up(queryRunner: QueryRunner): Promise { + const table = await queryRunner.createTable( + new Table({ + name: "tempbans", + columns: [ + { + name: "guild_id", + type: "bigint", + isPrimary: true, + }, + { + name: "user_id", + type: "bigint", + isPrimary: true, + }, + { + name: "mod_id", + type: "bigint", + }, + { + name: "created_at", + type: "datetime", + }, + { + name: "expires_at", + type: "datetime", + }, + ], + }), + ); + queryRunner.createIndex( + "tempbans", + new TableIndex({ + columnNames: ["expires_at"], + }), + ); + } + + public async down(queryRunner: QueryRunner): Promise { + await queryRunner.dropTable("tempbans"); + } +} diff --git a/backend/src/plugins/ModActions/ModActionsPlugin.ts b/backend/src/plugins/ModActions/ModActionsPlugin.ts index e091b038..876ab044 100644 --- a/backend/src/plugins/ModActions/ModActionsPlugin.ts +++ b/backend/src/plugins/ModActions/ModActionsPlugin.ts @@ -36,6 +36,8 @@ import { MassmuteCmd } from "./commands/MassmuteCmd"; import { trimPluginDescription } from "../../utils"; import { DeleteCaseCmd } from "./commands/DeleteCaseCmd"; import { TimeAndDatePlugin } from "../TimeAndDate/TimeAndDatePlugin"; +import { GuildTempbans } from "../../data/GuildTempbans"; +import { outdatedTempbansLoop } from "./functions/outdatedTempbansLoop"; const defaultOptions = { config: { @@ -49,6 +51,7 @@ const defaultOptions = { warn_message: "You have received a warning on the {guildName} server: {reason}", kick_message: "You have been kicked from the {guildName} server. Reason given: {reason}", ban_message: "You have been banned from the {guildName} server. Reason given: {reason}", + tempban_message: "You have been banned from the {guildName} server for {banTime}. Reason given: {reason}", alert_on_rejoin: false, alert_channel: null, warn_notify_enabled: false, @@ -165,8 +168,17 @@ export const ModActionsPlugin = zeppelinGuildPlugin()("mod state.mutes = GuildMutes.getGuildInstance(guild.id); state.cases = GuildCases.getGuildInstance(guild.id); + state.tempbans = GuildTempbans.getGuildInstance(guild.id); state.serverLogs = new GuildLogs(guild.id); + state.unloaded = false; + state.outdatedTempbansTimeout = null; state.ignoredEvents = []; + + outdatedTempbansLoop(pluginData); + }, + + onUnload(pluginData) { + pluginData.state.unloaded = true; }, }); diff --git a/backend/src/plugins/ModActions/commands/BanCmd.ts b/backend/src/plugins/ModActions/commands/BanCmd.ts index 197a4672..4fe9561e 100644 --- a/backend/src/plugins/ModActions/commands/BanCmd.ts +++ b/backend/src/plugins/ModActions/commands/BanCmd.ts @@ -1,14 +1,16 @@ import { modActionsCmd, IgnoredEventType } from "../types"; import { commandTypeHelpers as ct } from "../../../commandTypes"; import { canActOn, sendErrorMessage, hasPermission, sendSuccessMessage } from "../../../pluginUtils"; -import { resolveUser, resolveMember } from "../../../utils"; +import { resolveUser, resolveMember, stripObjectToScalars, noop } from "../../../utils"; import { isBanned } from "../functions/isBanned"; import { readContactMethodsFromArgs } from "../functions/readContactMethodsFromArgs"; import { formatReasonWithAttachments } from "../functions/formatReasonWithAttachments"; import { banUserId } from "../functions/banUserId"; -import { ignoreEvent } from "../functions/ignoreEvent"; -import { LogType } from "../../../data/LogType"; import { getMemberLevel, waitForReaction } from "knub/dist/helpers"; +import humanizeDuration from "humanize-duration"; +import { CasesPlugin } from "src/plugins/Cases/CasesPlugin"; +import { CaseTypes } from "src/data/CaseTypes"; +import { LogType } from "src/data/LogType"; const opts = { mod: ct.member({ option: true }), @@ -20,9 +22,16 @@ const opts = { export const BanCmd = modActionsCmd({ trigger: "ban", permission: "can_ban", - description: "Ban the specified member", + description: "Ban or Tempban the specified member", signature: [ + { + user: ct.string(), + time: ct.delay(), + reason: ct.string({ required: false, catchAll: true }), + + ...opts, + }, { user: ct.string(), reason: ct.string({ required: false, catchAll: true }), @@ -37,24 +46,90 @@ export const BanCmd = modActionsCmd({ sendErrorMessage(pluginData, msg.channel, `User not found`); return; } + const time = args["time"] ? args["time"] : null; + const reason = formatReasonWithAttachments(args.reason, msg.attachments); const memberToBan = await resolveMember(pluginData.client, pluginData.guild, user.id); - - let forceban = false; - if (!memberToBan) { - const banned = await isBanned(pluginData, user.id); - - if (banned) { - sendErrorMessage(pluginData, msg.channel, `User is already banned`); + // The moderator who did the action is the message author or, if used, the specified -mod + let mod = msg.member; + if (args.mod) { + if (!hasPermission(pluginData, "can_act_as_other", { message: msg, channelId: msg.channel.id })) { + sendErrorMessage(pluginData, msg.channel, "No permission for -mod"); return; + } + + mod = args.mod; + } + + // acquire a lock because of the needed user-inputs below (if banned/not on server) + const lock = await pluginData.locks.acquire(`ban-${user.id}`); + let forceban = false; + const existingTempban = await pluginData.state.tempbans.findExistingTempbanForUserId(user.id); + const banned = await isBanned(pluginData, user.id); + if (!memberToBan) { + if (banned) { + // Abort if trying to ban user indefinitely if they are already banned indefinitely + if (!existingTempban && !time) { + sendErrorMessage(pluginData, msg.channel, `User is already banned indefinitely.`); + return; + } + + // Ask the mod if we should update the existing ban + const alreadyBannedMsg = await msg.channel.createMessage("User is already banned, update ban?"); + const reply = await waitForReaction(pluginData.client, alreadyBannedMsg, ["✅", "❌"], msg.author.id); + + alreadyBannedMsg.delete().catch(noop); + if (!reply || reply.name === "❌") { + sendErrorMessage(pluginData, msg.channel, "User already banned, update cancelled by moderator"); + lock.unlock(); + return; + } else { + // Update or add new tempban / remove old tempban + if (time && time > 0) { + if (existingTempban) { + pluginData.state.tempbans.updateExpiryTime(user.id, time, mod.id); + } else { + pluginData.state.tempbans.addTempban(user.id, time, mod.id); + } + } else if (existingTempban) { + pluginData.state.tempbans.clear(user.id); + } + + // Create a new case for the updated ban since we never stored the old case id and log the action + const casesPlugin = pluginData.getPlugin(CasesPlugin); + const createdCase = await casesPlugin.createCase({ + modId: mod.id, + type: CaseTypes.Ban, + userId: user.id, + reason, + noteDetails: [`Ban updated to ${time ? humanizeDuration(time) : "indefinite"}`], + }); + const logtype = time ? LogType.MEMBER_TIMED_BAN : LogType.MEMBER_BAN; + pluginData.state.serverLogs.log(logtype, { + mod: stripObjectToScalars(mod.user), + user: stripObjectToScalars(user), + caseNumber: createdCase.case_number, + reason, + banTime: time ? humanizeDuration(time) : null, + }); + + sendSuccessMessage( + pluginData, + msg.channel, + `Ban updated to ${time ? "expire in " + humanizeDuration(time) + " from now" : "indefinite"}`, + ); + lock.unlock(); + return; + } } else { // Ask the mod if we should upgrade to a forceban as the user is not on the server const notOnServerMsg = await msg.channel.createMessage("User not found on the server, forceban instead?"); const reply = await waitForReaction(pluginData.client, notOnServerMsg, ["✅", "❌"], msg.author.id); - notOnServerMsg.delete(); + notOnServerMsg.delete().catch(noop); if (!reply || reply.name === "❌") { sendErrorMessage(pluginData, msg.channel, "User not on server, ban cancelled by moderator"); + lock.unlock(); return; } else { forceban = true; @@ -71,53 +146,62 @@ export const BanCmd = modActionsCmd({ msg.channel, `Cannot ban: target permission level is equal or higher to yours, ${targetLevel} >= ${ourLevel}`, ); + lock.unlock(); return; } - // The moderator who did the action is the message author or, if used, the specified -mod - let mod = msg.member; - if (args.mod) { - if (!hasPermission(pluginData, "can_act_as_other", { message: msg, channelId: msg.channel.id })) { - sendErrorMessage(pluginData, msg.channel, "No permission for -mod"); - return; - } - - mod = args.mod; - } - let contactMethods; try { contactMethods = readContactMethodsFromArgs(args); } catch (e) { sendErrorMessage(pluginData, msg.channel, e.message); + lock.unlock(); return; } const deleteMessageDays = args["delete-days"] ?? pluginData.config.getForMessage(msg).ban_delete_message_days; - const reason = formatReasonWithAttachments(args.reason, msg.attachments); - const banResult = await banUserId(pluginData, user.id, reason, { - contactMethods, - caseArgs: { - modId: mod.id, - ppId: mod.id !== msg.author.id ? msg.author.id : undefined, + const banResult = await banUserId( + pluginData, + user.id, + reason, + { + contactMethods, + caseArgs: { + modId: mod.id, + ppId: mod.id !== msg.author.id ? msg.author.id : undefined, + }, + deleteMessageDays, }, - deleteMessageDays, - }); + time, + ); if (banResult.status === "failed") { sendErrorMessage(pluginData, msg.channel, `Failed to ban member: ${banResult.error}`); + lock.unlock(); return; } + let forTime = ""; + if (time && time > 0) { + if (existingTempban) { + pluginData.state.tempbans.updateExpiryTime(user.id, time, mod.id); + } else { + pluginData.state.tempbans.addTempban(user.id, time, mod.id); + } + + forTime = `for ${humanizeDuration(time)} `; + } + // Confirm the action to the moderator let response = ""; if (!forceban) { - response = `Banned **${user.username}#${user.discriminator}** (Case #${banResult.case.case_number})`; + response = `Banned **${user.username}#${user.discriminator}** ${forTime}(Case #${banResult.case.case_number})`; if (banResult.notifyResult.text) response += ` (${banResult.notifyResult.text})`; } else { - response = `Member forcebanned (Case #${banResult.case.case_number})`; + response = `Member forcebanned ${forTime}(Case #${banResult.case.case_number})`; } + lock.unlock(); sendSuccessMessage(pluginData, msg.channel, response); }, }); diff --git a/backend/src/plugins/ModActions/commands/UnbanCmd.ts b/backend/src/plugins/ModActions/commands/UnbanCmd.ts index 07a3edf8..80cac4f2 100644 --- a/backend/src/plugins/ModActions/commands/UnbanCmd.ts +++ b/backend/src/plugins/ModActions/commands/UnbanCmd.ts @@ -64,6 +64,8 @@ export const UnbanCmd = modActionsCmd({ reason, ppId: mod.id !== msg.author.id ? msg.author.id : undefined, }); + // Delete the tempban, if one exists + pluginData.state.tempbans.clear(user.id); // Confirm the action sendSuccessMessage(pluginData, msg.channel, `Member unbanned (Case #${createdCase.case_number})`); diff --git a/backend/src/plugins/ModActions/functions/banUserId.ts b/backend/src/plugins/ModActions/functions/banUserId.ts index 74c0357b..ad7025e7 100644 --- a/backend/src/plugins/ModActions/functions/banUserId.ts +++ b/backend/src/plugins/ModActions/functions/banUserId.ts @@ -16,6 +16,7 @@ import { ignoreEvent } from "./ignoreEvent"; import { CasesPlugin } from "../../Cases/CasesPlugin"; import { CaseTypes } from "../../../data/CaseTypes"; import { logger } from "../../../logger"; +import humanizeDuration from "humanize-duration"; /** * Ban the specified user id, whether or not they're actually on the server at the time. Generates a case. @@ -25,6 +26,7 @@ export async function banUserId( userId: string, reason?: string, banOptions: BanOptions = {}, + banTime?: number, ): Promise { const config = pluginData.config.get(); const user = await resolveUser(pluginData.client, userId); @@ -43,7 +45,7 @@ export async function banUserId( : getDefaultContactMethods(pluginData, "ban"); if (contactMethods.length) { - if (config.ban_message) { + if (!banTime && config.ban_message) { const banMessage = await renderTemplate(config.ban_message, { guildName: pluginData.guild.name, reason, @@ -52,9 +54,20 @@ export async function banUserId( : {}, }); + notifyResult = await notifyUser(user, banMessage, contactMethods); + } else if (banTime && config.tempban_message) { + const banMessage = await renderTemplate(config.tempban_message, { + guildName: pluginData.guild.name, + reason, + moderator: banOptions.caseArgs?.modId + ? stripObjectToScalars(await resolveUser(pluginData.client, banOptions.caseArgs.modId)) + : {}, + banTime: humanizeDuration(banTime), + }); + notifyResult = await notifyUser(user, banMessage, contactMethods); } else { - notifyResult = createUserNotificationError("No ban message specified in config"); + notifyResult = createUserNotificationError("No ban/tempban message specified in config"); } } } @@ -87,22 +100,31 @@ export async function banUserId( // Create a case for this action const modId = banOptions.caseArgs?.modId || pluginData.client.user.id; const casesPlugin = pluginData.getPlugin(CasesPlugin); + + const noteDetails: string[] = []; + const timeUntilUnban = banTime ? humanizeDuration(banTime) : "indefinite"; + const timeDetails = `Banned ${banTime ? `for ${timeUntilUnban}` : "indefinitely"}`; + if (notifyResult.text) noteDetails.push(ucfirst(notifyResult.text)); + noteDetails.push(timeDetails); + const createdCase = await casesPlugin.createCase({ ...(banOptions.caseArgs || {}), userId, modId, type: CaseTypes.Ban, reason, - noteDetails: notifyResult.text ? [ucfirst(notifyResult.text)] : [], + noteDetails, }); // Log the action const mod = await resolveUser(pluginData.client, modId); - pluginData.state.serverLogs.log(LogType.MEMBER_BAN, { + const logtype = banTime ? LogType.MEMBER_TIMED_BAN : LogType.MEMBER_BAN; + pluginData.state.serverLogs.log(logtype, { mod: stripObjectToScalars(mod), user: stripObjectToScalars(user), caseNumber: createdCase.case_number, reason, + banTime: banTime ? humanizeDuration(banTime) : null, }); return { diff --git a/backend/src/plugins/ModActions/functions/outdatedTempbansLoop.ts b/backend/src/plugins/ModActions/functions/outdatedTempbansLoop.ts new file mode 100644 index 00000000..0fc3749c --- /dev/null +++ b/backend/src/plugins/ModActions/functions/outdatedTempbansLoop.ts @@ -0,0 +1,67 @@ +import { resolveUser, SECONDS, stripObjectToScalars } from "../../../utils"; +import { GuildPluginData } from "knub"; +import { IgnoredEventType, ModActionsPluginType } from "../types"; +import { LogType } from "src/data/LogType"; +import { formatReasonWithAttachments } from "./formatReasonWithAttachments"; +import { ignoreEvent } from "./ignoreEvent"; +import { isBanned } from "./isBanned"; +import { logger } from "src/logger"; +import { CasesPlugin } from "../../Cases/CasesPlugin"; +import { CaseTypes } from "../../../data/CaseTypes"; +import moment from "moment-timezone"; +import humanizeDuration from "humanize-duration"; + +const TEMPBAN_LOOP_TIME = 60 * SECONDS; + +export async function outdatedTempbansLoop(pluginData: GuildPluginData) { + const outdatedTempbans = await pluginData.state.tempbans.getExpiredTempbans(); + + for (const tempban of outdatedTempbans) { + if (!(await isBanned(pluginData, tempban.user_id))) { + pluginData.state.tempbans.clear(tempban.user_id); + continue; + } + + pluginData.state.serverLogs.ignoreLog(LogType.MEMBER_UNBAN, tempban.user_id); + const reason = formatReasonWithAttachments( + `Tempban timed out. + Tempbanned at: \`${tempban.created_at} UTC\``, + [], + ); + try { + ignoreEvent(pluginData, IgnoredEventType.Unban, tempban.user_id); + await pluginData.guild.unbanMember(tempban.user_id, reason != null ? encodeURIComponent(reason) : undefined); + } catch (e) { + pluginData.state.serverLogs.log(LogType.BOT_ALERT, { + body: `Encountered an error trying to automatically unban ${tempban.user_id} after tempban timeout`, + }); + logger.warn(`Error automatically unbanning ${tempban.user_id} (tempban timeout): ${e}`); + return; + } + + // Create case and delete tempban + const casesPlugin = pluginData.getPlugin(CasesPlugin); + const createdCase = await casesPlugin.createCase({ + userId: tempban.user_id, + modId: tempban.mod_id, + type: CaseTypes.Unban, + reason, + ppId: undefined, + }); + pluginData.state.tempbans.clear(tempban.user_id); + + // Log the unban + const banTime = moment(tempban.created_at).diff(moment(tempban.expires_at)); + pluginData.state.serverLogs.log(LogType.MEMBER_TIMED_UNBAN, { + mod: stripObjectToScalars(await resolveUser(pluginData.client, tempban.mod_id)), + userId: tempban.user_id, + caseNumber: createdCase.case_number, + reason, + banTime: humanizeDuration(banTime), + }); + } + + if (!pluginData.state.unloaded) { + pluginData.state.outdatedTempbansTimeout = setTimeout(() => outdatedTempbansLoop(pluginData), TEMPBAN_LOOP_TIME); + } +} diff --git a/backend/src/plugins/ModActions/types.ts b/backend/src/plugins/ModActions/types.ts index a6cd96c4..4fb6ba5e 100644 --- a/backend/src/plugins/ModActions/types.ts +++ b/backend/src/plugins/ModActions/types.ts @@ -7,6 +7,8 @@ import { GuildLogs } from "../../data/GuildLogs"; import { Case } from "../../data/entities/Case"; import { CaseArgs } from "../Cases/types"; import { TextChannel } from "eris"; +import { GuildTempbans } from "../../data/GuildTempbans"; +import Timeout = NodeJS.Timeout; export const ConfigSchema = t.type({ dm_on_warn: t.boolean, @@ -19,6 +21,7 @@ export const ConfigSchema = t.type({ warn_message: tNullable(t.string), kick_message: tNullable(t.string), ban_message: tNullable(t.string), + tempban_message: tNullable(t.string), alert_on_rejoin: t.boolean, alert_channel: tNullable(t.string), warn_notify_enabled: t.boolean, @@ -46,8 +49,11 @@ export interface ModActionsPluginType extends BasePluginType { state: { mutes: GuildMutes; cases: GuildCases; + tempbans: GuildTempbans; serverLogs: GuildLogs; + unloaded: boolean; + outdatedTempbansTimeout: Timeout | null; ignoredEvents: IIgnoredEvent[]; }; }