Migrate Slowmode to new Plugin structure

backend/src/plugins/Slowmode/util/actualDisableSlowmodeCmd.ts

@@ -0,0 +1,39 @@
+import { Message } from "eris";
+import { sendErrorMessage, sendSuccessMessage } from "src/pluginUtils";
+import { disableBotSlowmodeForChannel } from "./disableBotSlowmodeForChannel";
+import { noop } from "src/utils";
+
+export async function actualDisableSlowmodeCmd(msg: Message, args, pluginData) {
+  const botSlowmode = await pluginData.state.slowmodes.getChannelSlowmode(args.channel.id);
+  const hasNativeSlowmode = args.channel.rateLimitPerUser;
+
+  if (!botSlowmode && hasNativeSlowmode === 0) {
+    sendErrorMessage(pluginData, msg.channel, "Channel is not on slowmode!");
+    return;
+  }
+
+  const initMsg = await msg.channel.createMessage("Disabling slowmode...");
+
+  // Disable bot-maintained slowmode
+  let failedUsers = [];
+  if (botSlowmode) {
+    const result = await disableBotSlowmodeForChannel(pluginData, args.channel);
+    failedUsers = result.failedUsers;
+  }
+
+  // Disable native slowmode
+  if (hasNativeSlowmode) {
+    await args.channel.edit({ rateLimitPerUser: 0 });
+  }
+
+  if (failedUsers.length) {
+    sendSuccessMessage(
+      pluginData,
+      msg.channel,
+      `Slowmode disabled! Failed to clear slowmode from the following users:\n\n<@!${failedUsers.join(">\n<@!")}>`,
+    );
+  } else {
+    sendSuccessMessage(pluginData, msg.channel, "Slowmode disabled!");
+    initMsg.delete().catch(noop);
+  }
+}

backend/src/plugins/Slowmode/util/applyBotSlowmodeToUserId.ts

@@ -0,0 +1,43 @@
+import { SlowmodePluginType } from "../types";
+import { PluginData } from "knub";
+import { GuildChannel, TextChannel, Constants } from "eris";
+import { UnknownUser, isDiscordRESTError, stripObjectToScalars } from "src/utils";
+import { LogType } from "src/data/LogType";
+import { logger } from "src/logger";
+
+export async function applyBotSlowmodeToUserId(
+  pluginData: PluginData<SlowmodePluginType>,
+  channel: GuildChannel & TextChannel,
+  userId: string,
+) {
+  // Deny sendMessage permission from the user. If there are existing permission overwrites, take those into account.
+  const existingOverride = channel.permissionOverwrites.get(userId);
+  const newDeniedPermissions = (existingOverride ? existingOverride.deny : 0) | Constants.Permissions.sendMessages;
+  const newAllowedPermissions = (existingOverride ? existingOverride.allow : 0) & ~Constants.Permissions.sendMessages;
+
+  try {
+    await channel.editPermission(userId, newAllowedPermissions, newDeniedPermissions, "member");
+  } catch (e) {
+    const user = pluginData.client.users.get(userId) || new UnknownUser({ id: userId });
+
+    if (isDiscordRESTError(e) && e.code === 50013) {
+      logger.warn(
+        `Missing permissions to apply bot slowmode to user ${userId} on channel ${channel.name} (${channel.id}) on server ${pluginData.guild.name} (${pluginData.guild.id})`,
+      );
+      pluginData.state.logs.log(LogType.BOT_ALERT, {
+        body: `Missing permissions to apply bot slowmode to {userMention(user)} in {channelMention(channel)}`,
+        user: stripObjectToScalars(user),
+        channel: stripObjectToScalars(channel),
+      });
+    } else {
+      pluginData.state.logs.log(LogType.BOT_ALERT, {
+        body: `Failed to apply bot slowmode to {userMention(user)} in {channelMention(channel)}`,
+        user: stripObjectToScalars(user),
+        channel: stripObjectToScalars(channel),
+      });
+      throw e;
+    }
+  }
+
+  await pluginData.state.slowmodes.addSlowmodeUser(channel.id, userId);
+}

backend/src/plugins/Slowmode/util/clearBotSlowmodeFromUserId.ts

@@ -0,0 +1,24 @@
+import { PluginData } from "knub";
+import { SlowmodePluginType } from "../types";
+import { GuildChannel, TextChannel } from "eris";
+
+export async function clearBotSlowmodeFromUserId(
+  pluginData: PluginData<SlowmodePluginType>,
+  channel: GuildChannel & TextChannel,
+  userId: string,
+  force = false,
+) {
+  try {
+    // Remove permission overrides from the channel for this user
+    // Previously we diffed the overrides so we could clear the "send messages" override without touching other
+    // overrides. Unfortunately, it seems that was a bit buggy - we didn't always receive the event for the changed
+    // overrides and then we also couldn't diff against them. For consistency's sake, we just delete the override now.
+    await channel.deletePermission(userId);
+  } catch (e) {
+    if (!force) {
+      throw e;
+    }
+  }
+
+  await pluginData.state.slowmodes.clearSlowmodeUser(channel.id, userId);
+}

backend/src/plugins/Slowmode/util/clearExpiredSlowmodes.ts

@@ -0,0 +1,31 @@
+import { PluginData } from "knub";
+import { SlowmodePluginType } from "../types";
+import { LogType } from "src/data/LogType";
+import { logger } from "src/logger";
+import { GuildChannel, TextChannel } from "eris";
+import { UnknownUser, stripObjectToScalars } from "src/utils";
+import { clearBotSlowmodeFromUserId } from "./clearBotSlowmodeFromUserId";
+
+export async function clearExpiredSlowmodes(pluginData: PluginData<SlowmodePluginType>) {
+  const expiredSlowmodeUsers = await pluginData.state.slowmodes.getExpiredSlowmodeUsers();
+  for (const user of expiredSlowmodeUsers) {
+    const channel = pluginData.guild.channels.get(user.channel_id);
+    if (!channel) {
+      await pluginData.state.slowmodes.clearSlowmodeUser(user.channel_id, user.user_id);
+      continue;
+    }
+
+    try {
+      await clearBotSlowmodeFromUserId(pluginData, channel as GuildChannel & TextChannel, user.user_id);
+    } catch (e) {
+      logger.error(e);
+
+      const realUser = pluginData.client.users.get(user.user_id) || new UnknownUser({ id: user.user_id });
+      pluginData.state.logs.log(LogType.BOT_ALERT, {
+        body: `Failed to clear slowmode permissions from {userMention(user)} in {channelMention(channel)}`,
+        user: stripObjectToScalars(realUser),
+        channel: stripObjectToScalars(channel),
+      });
+    }
+  }
+}

backend/src/plugins/Slowmode/util/disableBotSlowmodeForChannel.ts

@@ -0,0 +1,28 @@
+import { GuildChannel, TextChannel } from "eris";
+import { PluginData } from "knub";
+import { SlowmodePluginType } from "../types";
+import { clearBotSlowmodeFromUserId } from "./clearBotSlowmodeFromUserId";
+
+export async function disableBotSlowmodeForChannel(
+  pluginData: PluginData<SlowmodePluginType>,
+  channel: GuildChannel & TextChannel,
+) {
+  // Disable channel slowmode
+  await pluginData.state.slowmodes.deleteChannelSlowmode(channel.id);
+
+  // Remove currently applied slowmodes
+  const users = await pluginData.state.slowmodes.getChannelSlowmodeUsers(channel.id);
+  const failedUsers = [];
+
+  for (const slowmodeUser of users) {
+    try {
+      await clearBotSlowmodeFromUserId(pluginData, channel, slowmodeUser.user_id);
+    } catch (e) {
+      // Removing the slowmode failed. Record this so the permissions can be changed manually, and remove the database entry.
+      failedUsers.push(slowmodeUser.user_id);
+      await pluginData.state.slowmodes.clearSlowmodeUser(channel.id, slowmodeUser.user_id);
+    }
+  }
+
+  return { failedUsers };
+}

backend/src/plugins/Slowmode/util/onMessageCreate.ts

@@ -0,0 +1,42 @@
+import { SavedMessage } from "src/data/entities/SavedMessage";
+import { GuildChannel, TextChannel } from "eris";
+import { PluginData } from "knub";
+import { SlowmodePluginType } from "../types";
+import { resolveMember } from "src/utils";
+import { applyBotSlowmodeToUserId } from "./applyBotSlowmodeToUserId";
+import { hasPermission } from "src/pluginUtils";
+
+export async function onMessageCreate(pluginData: PluginData<SlowmodePluginType>, msg: SavedMessage) {
+  if (msg.is_bot) return;
+
+  const channel = pluginData.guild.channels.get(msg.channel_id) as GuildChannel & TextChannel;
+  if (!channel) return;
+
+  // Don't apply slowmode if the lock was interrupted earlier (e.g. the message was caught by word filters)
+  const thisMsgLock = await pluginData.locks.acquire(`message-${msg.id}`);
+  if (thisMsgLock.interrupted) return;
+
+  // Check if this channel even *has* a bot-maintained slowmode
+  const channelSlowmode = await pluginData.state.slowmodes.getChannelSlowmode(channel.id);
+  if (!channelSlowmode) return thisMsgLock.unlock();
+
+  // Make sure this user is affected by the slowmode
+  const member = await resolveMember(pluginData.client, pluginData.guild, msg.user_id);
+  const isAffected = hasPermission(pluginData, "is_affected", { channelId: channel.id, userId: msg.user_id, member });
+  if (!isAffected) return thisMsgLock.unlock();
+
+  // Delete any extra messages sent after a slowmode was already applied
+  const userHasSlowmode = await pluginData.state.slowmodes.userHasSlowmode(channel.id, msg.user_id);
+  if (userHasSlowmode) {
+    const message = await channel.getMessage(msg.id);
+    if (message) {
+      message.delete();
+      return thisMsgLock.interrupt();
+    }
+
+    return thisMsgLock.unlock();
+  }
+
+  await applyBotSlowmodeToUserId(pluginData, channel, msg.user_id);
+  thisMsgLock.unlock();
+}