Add tempbans (#139)

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<ModActionsPluginType>()("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;
   },
 });

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);
   },
 });

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})`);

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<BanResult> {
   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 {

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<ModActionsPluginType>) {
+  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);
+  }
+}

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[];
   };
 }