feat(hub join): check servername for swear words

dev-737 · dev-737 · commit 5dccb74c608c · 2025-02-11T18:51:07.000+05:30
diff --git a/src/services/HubJoinService.ts b/src/services/HubJoinService.ts
@@ -19,38 +19,37 @@ import BlacklistManager from '#src/managers/BlacklistManager.js';
 import HubManager from '#src/managers/HubManager.js';
 import { HubService } from '#src/services/HubService.js';
 import { type EmojiKeys, getEmoji } from '#src/utils/EmojiUtils.js';
-
-import { stripIndents } from 'common-tags';
-import type {
-  ChatInputCommandInteraction,
-  GuildTextBasedChannel,
-  MessageComponentInteraction,
-} from 'discord.js';
+import Context from '#src/core/CommandContext/Context.js';
 import type { TranslationKeys } from '#types/TranslationKeys.d.ts';
 import { createConnection } from '#utils/ConnectedListUtils.js';
 import db from '#utils/Db.js';
 import { type supportedLocaleCodes, t } from '#utils/Locale.js';
-import { check } from '#utils/ProfanityUtils.js';
 import { getOrCreateWebhook, getReplyMethod } from '#utils/Utils.js';
 import { logJoinToHub } from '#utils/hub/logger/JoinLeave.js';
 import { sendToHub } from '#utils/hub/utils.js';
-import Context from '#src/core/CommandContext/Context.js';
+import { stripIndents } from 'common-tags';
+import type {
+  ChatInputCommandInteraction,
+  GuildTextBasedChannel,
+  MessageComponentInteraction,
+} from 'discord.js';
 // eslint-disable-next-line no-duplicate-imports
 import type { CachedContextType } from '#src/core/CommandContext/Context.js';
+import { checkRule } from '#src/utils/network/antiSwearChecks.js';
 
 export class HubJoinService {
   private readonly interaction:
-		| ChatInputCommandInteraction<'cached'>
-		| MessageComponentInteraction<'cached'>
-		| Context<CachedContextType>;
+    | ChatInputCommandInteraction<'cached'>
+    | MessageComponentInteraction<'cached'>
+    | Context<CachedContextType>;
   private readonly locale: supportedLocaleCodes;
   private readonly hubService: HubService;
 
   constructor(
     interaction:
-			| ChatInputCommandInteraction<'cached'>
-			| MessageComponentInteraction<'cached'>
-			| Context<CachedContextType>,
+      | ChatInputCommandInteraction<'cached'>
+      | MessageComponentInteraction<'cached'>
+      | Context<CachedContextType>,
     locale: supportedLocaleCodes,
     hubService: HubService = new HubService(),
   ) {
@@ -74,19 +73,13 @@ export class HubJoinService {
     return await this.joinHub(channel, randomHub.name);
   }
 
-  async joinHub(
-    channel: GuildTextBasedChannel,
-    hubInviteOrName: string | undefined,
-  ) {
+  async joinHub(channel: GuildTextBasedChannel, hubInviteOrName: string | undefined) {
     if (!this.interaction.deferred) {
       // eslint-disable-next-line @typescript-eslint/ban-ts-comment
       // @ts-expect-error
       await this.interaction.deferReply({ flags: ['Ephemeral'] });
     }
 
-    const checksPassed = await this.runChecks(channel);
-    if (!checksPassed) return false;
-
     const hub = await this.fetchHub(hubInviteOrName);
     if (!hub) {
       await this.interaction.editReply({
@@ -97,10 +90,10 @@ export class HubJoinService {
       return false;
     }
 
-    if (
-      (await this.isAlreadyInHub(channel, hub.id)) ||
-			(await this.isBlacklisted(hub))
-    ) {
+    const checksPassed = await this.runChecks(channel, hub);
+    if (!checksPassed) return false;
+
+    if ((await this.isAlreadyInHub(channel, hub.id)) || (await this.isBlacklisted(hub))) {
       return false;
     }
 
@@ -116,32 +109,27 @@ export class HubJoinService {
       hub: { connect: { id: hub.id } },
       connected: true,
       compact: true,
-      profFilter: true,
     });
 
     await this.sendSuccessMessages(hub, channel);
     return true;
   }
 
-  private async runChecks(channel: GuildTextBasedChannel) {
-    if (
-      !channel
-        .permissionsFor(this.interaction.member)
-        .has('ManageMessages', true)
-    ) {
+  private async runChecks(channel: GuildTextBasedChannel, hub: HubManager) {
+    if (!channel.permissionsFor(this.interaction.member).has('ManageMessages', true)) {
       await this.replyError('errors.missingPermissions', {
         permissions: 'Manage Messages',
         emoji: this.getEmoji('x_icon'),
       });
       return false;
     }
 
-    const { hasSlurs, hasProfanity } = check(this.interaction.guild.name);
-    if (hasSlurs || hasProfanity) {
-      await this.replyError('errors.serverNameInappropriate', {
-        emoji: this.getEmoji('x_icon'),
-      });
-      return false;
+    for (const rule of await hub.fetchAntiSwearRules()) {
+      const match = checkRule(channel.guild.name, rule);
+      if (match) {
+        await this.replyError('errors.serverNameInappropriate', { emoji: this.getEmoji('x_icon') });
+        return false;
+      }
     }
 
     return true;
@@ -184,14 +172,8 @@ export class HubJoinService {
   }
 
   private async isBlacklisted(hub: HubManager) {
-    const userBlManager = new BlacklistManager(
-      'user',
-      this.interaction.user.id,
-    );
-    const serverBlManager = new BlacklistManager(
-      'server',
-      this.interaction.guildId,
-    );
+    const userBlManager = new BlacklistManager('user', this.interaction.user.id);
+    const serverBlManager = new BlacklistManager('server', this.interaction.guildId);
 
     const userBlacklist = await userBlManager.fetchBlacklist(hub.id);
     const serverBlacklist = await serverBlManager.fetchBlacklist(hub.id);
@@ -219,10 +201,7 @@ export class HubJoinService {
     return webhook;
   }
 
-  private async sendSuccessMessages(
-    hub: HubManager,
-    channel: GuildTextBasedChannel,
-  ) {
+  private async sendSuccessMessages(hub: HubManager, channel: GuildTextBasedChannel) {
     const replyData = {
       content: t('hub.join.success', this.locale, {
         channel: `${channel}`,
@@ -240,15 +219,15 @@ export class HubJoinService {
     await this.interaction[replyMethod](replyData);
 
     const totalConnections =
-			(await hub.connections.fetch())?.reduce(
-			  (total, c) => total + (c.data.connected ? 1 : 0),
-			  0,
-			) ?? 0;
+      (await hub.connections.fetch())?.reduce(
+        (total, c) => total + (c.data.connected ? 1 : 0),
+        0,
+      ) ?? 0;
 
     const serverCountMessage =
-			totalConnections === 0
-			  ? 'There are no other servers connected to this hub yet. *cricket noises* 🦗'
-			  : `We now have ${totalConnections} servers in this hub! 🎉`;
+      totalConnections === 0
+        ? 'There are no other servers connected to this hub yet. *cricket noises* 🦗'
+        : `We now have ${totalConnections} servers in this hub! 🎉`;
 
     // Announce to hub
     await sendToHub(hub.id, {
diff --git a/src/utils/network/antiSwearChecks.ts b/src/utils/network/antiSwearChecks.ts
@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 2025 InterChat
+ *
+ * InterChat is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * InterChat is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with InterChat.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import BlacklistManager from '#src/managers/BlacklistManager.js';
+
+import { type BlockWord, BlockWordAction } from '@prisma/client';
+import type { ActionRowBuilder, Awaitable, ButtonBuilder, Message } from 'discord.js';
+import Logger from '#src/utils/Logger.js';
+import { logBlockwordAlert } from '#src/utils/hub/logger/BlockWordAlert.js';
+import { sendBlacklistNotif } from '#src/utils/moderation/blacklistUtils.js';
+import { createRegexFromWords } from '#utils/moderation/antiSwear.js';
+import type { CheckResult } from '#src/utils/network/runChecks.js';
+
+// Interface for action handler results
+interface ActionResult {
+  success: boolean;
+  shouldBlock: boolean;
+  components?: ActionRowBuilder<ButtonBuilder>[];
+  message?: string;
+}
+
+// Action handler type
+type ActionHandler = (
+  message: Message<true>,
+  rule: BlockWord,
+  matches: string[],
+) => Awaitable<ActionResult>;
+
+// Map of action handlers
+const actionHandlers: Record<BlockWordAction, ActionHandler> = {
+  [BlockWordAction.BLOCK_MESSAGE]: () => ({
+    success: true,
+    shouldBlock: true,
+    message: 'Message blocked due to containing prohibited words.',
+  }),
+
+  [BlockWordAction.SEND_ALERT]: async (message, rule, matches) => {
+    // Send alert to moderators
+    await logBlockwordAlert(message, rule, matches);
+    return { success: true, shouldBlock: false };
+  },
+
+  [BlockWordAction.BLACKLIST]: async (message, rule) => {
+    const expiresAt = new Date(Date.now() + 10 * 60 * 1000); // 10 minutes
+    const reason = `Auto-blacklisted for using blocked words (Rule: ${rule.name})`;
+    const target = message.author;
+    const mod = message.client.user;
+
+    const blacklistManager = new BlacklistManager('user', target.id);
+    await blacklistManager.addBlacklist({
+      hubId: rule.hubId,
+      reason,
+      expiresAt,
+      moderatorId: mod.id,
+    });
+
+    await blacklistManager.log(rule.hubId, message.client, {
+      mod,
+      reason,
+      expiresAt,
+    });
+    await sendBlacklistNotif('user', message.client, {
+      target,
+      hubId: rule.hubId,
+      expiresAt,
+      reason,
+    }).catch(() => null);
+
+    return {
+      success: true,
+      shouldBlock: true,
+      message: 'You have been blacklisted for using prohibited words.',
+    };
+  },
+};
+
+interface ActionResult {
+  success: boolean;
+  shouldBlock: boolean;
+  message?: string;
+}
+
+interface BlockResult {
+  shouldBlock: boolean;
+  reason?: string;
+}
+
+export async function checkBlockedWords(
+  message: Message<true>,
+  msgBlockList: BlockWord[],
+): Promise<CheckResult> {
+  if (msgBlockList.length === 0) return { passed: true };
+
+  for (const rule of msgBlockList) {
+    const { shouldBlock, reason } = await checkRuleAndExecuteAction(message, rule);
+    if (shouldBlock) return { passed: false, reason };
+  }
+
+  return { passed: true };
+}
+
+async function executeAction(
+  action: keyof typeof actionHandlers,
+  message: Message<true>,
+  rule: BlockWord,
+  matches: RegExpMatchArray,
+): Promise<ActionResult> {
+  const handler = actionHandlers[action];
+  if (!handler) return { success: false, shouldBlock: false };
+
+  try {
+    return await handler(message, rule, matches);
+  }
+  catch (error) {
+    Logger.error(`Failed to execute action ${action}:`, error);
+    return { success: false, shouldBlock: false };
+  }
+}
+
+async function processActions(
+  message: Message<true>,
+  triggeredRule: BlockWord,
+  matches: RegExpMatchArray,
+): Promise<BlockResult> {
+  if (!triggeredRule.actions.length) return { shouldBlock: false };
+
+  for (const actionToTake of triggeredRule.actions) {
+    const result = await executeAction(actionToTake, message, triggeredRule, matches);
+    if (result.success && result.shouldBlock) {
+      return {
+        shouldBlock: true,
+        reason: result.message,
+      };
+    }
+  }
+
+  return { shouldBlock: false };
+}
+
+async function checkRuleAndExecuteAction(
+  message: Message<true>,
+  rule: BlockWord,
+): Promise<BlockResult> {
+  const matches = checkRule(message.content, rule);
+  if (!matches) return { shouldBlock: false };
+
+  return await processActions(message, rule, matches);
+}
+
+export function checkRule(content: string, rule: BlockWord) {
+  const regex = createRegexFromWords(rule.words);
+  const matches = content.match(regex);
+  return matches;
+}
