Implement profanity.dev as the swear filter with filter notifications.

api/common.js

@@ -4,8 +4,8 @@ import config from "../config.json" assert { type: "json" };
 import fetch from "node-fetch";
 import { readdirSync } from "fs";
 import crypto from "crypto";
-import db from "../controllers/databaseController";
-import { getWebAnnouncement } from "../controllers/announcementController";
+import db from "../controllers/databaseController.js";
+import { getWebAnnouncement } from "../controllers/announcementController.js";
 
 /*
     Check if a specific feature is enabled.

api/internal_redirect/announcement.js

@@ -1,4 +1,4 @@
-import { hasPermission, postAPIRequest } from "../common";
+import { hasPermission, postAPIRequest } from "../common.js";
 
 export default function announcementRedirectRoute(app, config, lang) {
   const baseEndpoint = "/redirect/announcement";

api/internal_redirect/application.js

@@ -1,4 +1,4 @@
-import { hasPermission, postAPIRequest } from "../common";
+import { hasPermission, postAPIRequest } from "../common.js";
 
 export default function applicationRedirectRoute(app, config, lang) {
   const baseEndpoint = "/redirect/application";

api/internal_redirect/bridge.js

@@ -1,4 +1,4 @@
-import { hasPermission, postAPIRequest } from "../common";
+import { hasPermission, postAPIRequest } from "../common.js";
 
 export default function bridgeRedirectRoute(app, config, lang) {
   const baseEndpoint = "/redirect/bridge";

api/internal_redirect/index.js

@@ -1,10 +1,10 @@
-import applicationRedirectRoute from "./application";
-import serverRedirectRoute from "./server";
-import webRedirectRoute from "./web";
-import announcementsRedirectRoute from "./announcement";
-import reportRedirectRoute from "./report";
-import vaultRedirectRoute from "./vault";
-import bridgeRedirectRoute from "./bridge";
+import applicationRedirectRoute from "./application.js";
+import serverRedirectRoute from "./server.js";
+import webRedirectRoute from "./web.js";
+import announcementsRedirectRoute from "./announcement.js";
+import reportRedirectRoute from "./report.js";
+import vaultRedirectRoute from "./vault.js";
+import bridgeRedirectRoute from "./bridge.js";
 
 export default (app, config, lang) => {
   applicationRedirectRoute(app, config, lang);

api/internal_redirect/report.js

@@ -1,4 +1,4 @@
-import { hasPermission, postAPIRequest } from "../common";
+import { hasPermission, postAPIRequest } from "../common.js";
 
 export default function reportRedirectRoute(app, config, lang) {
   const baseEndpoint = "/redirect/report";

api/internal_redirect/server.js

@@ -1,4 +1,4 @@
-import { hasPermission, postAPIRequest } from "../common";
+import { hasPermission, postAPIRequest } from "../common.js";
 
 export default function serverRedirectRoute(app, config, lang) {
   const baseEndpoint = "/redirect/server";

api/internal_redirect/vault.js

@@ -1,4 +1,4 @@
-import { hasPermission, postAPIRequest } from "../common";
+import { hasPermission, postAPIRequest } from "../common.js";
 
 export default function vaultRedirectRoute(app, config, lang) {
   const baseEndpoint = "/redirect/vault";

api/internal_redirect/web.js

@@ -1,4 +1,4 @@
-import { postAPIRequest } from "../common";
+import { postAPIRequest } from "../common.js";
 
 export default function webRedirectRoute(app, config, lang) {
   const baseEndpoint = "/redirect/web";

api/routes/announcement.js

@@ -1,4 +1,9 @@
-import { isFeatureEnabled, required, optional, generateLog } from "../common";
+import {
+  isFeatureEnabled,
+  required,
+  optional,
+  generateLog,
+} from "../common.js";
 
 export default function announcementApiRoute(app, config, db, features, lang) {
   const baseEndpoint = "/api/announcement";

api/routes/application.js

@@ -1,4 +1,9 @@
-import { isFeatureEnabled, required, optional, generateLog } from "../common";
+import {
+  isFeatureEnabled,
+  required,
+  optional,
+  generateLog,
+} from "../common.js";
 
 export default function applicationApiRoute(app, config, db, features, lang) {
   const baseEndpoint = "/api/application";

api/routes/bridge.js

@@ -1,4 +1,9 @@
-import { isFeatureEnabled, required, optional, generateLog } from "../common";
+import {
+  isFeatureEnabled,
+  required,
+  optional,
+  generateLog,
+} from "../common.js";
 
 export default function bridgeApiRoute(app, config, db, features, lang) {
   const baseEndpoint = "/api/bridge";
@@ -91,6 +96,100 @@
     return res;
   });
 
+  app.post(baseEndpoint + "/clear", async function (req, res) {
+    isFeatureEnabled(features.bridge, res, lang);
+
+    try {
+      db.query(
+        `TRUNCATE bridge;`,
+        function (error, results, fields) {
+          if (error) {
+            return res.send({
+              success: false,
+              message: `${error}`,
+            });
+          }
+
+          return res.send({
+            success: true,
+            message: `Bridge has now been cleared.`,
+          });
+        }
+      );
+    } catch (error) {
+      res.send({
+        success: false,
+        message: `${error}`,
+      });
+    }
+
+    return res;
+  });
+
+  app.get(baseEndpoint + "/server/get", async function (req, res) {
+    isFeatureEnabled(features.bridge, res, lang);
+
+    try {
+      db.query(
+        `SELECT * FROM serverStatus;`,
+        function (error, results) {
+          if (error) {
+            return res.send({
+              success: false,
+              message: `Failed: ${error}`,
+            });
+          }
+
+          return res.send({
+            success: true,
+            data: results,
+          });
+        }
+      );
+    } catch (error) {
+      return res.send({
+        success: false,
+        message: `Unexpected error: ${error}`,
+      });
+    }
+
+    return res;
+  });
+
+  app.post(baseEndpoint + "/server/update", async function (req, res) {
+    isFeatureEnabled(features.bridge, res, lang);
+
+    const serverInfo = required(req.body, "serverInfo", res);
+    let lastUpdated = required(req.body, "lastUpdated", res);
+
+    try {
+      const serverInfoString = JSON.stringify(serverInfo);
+
+      db.query(
+        `UPDATE serverStatus SET statusInfo = ?, lastUpdated = ? WHERE serverStatusId = 1;`,
+        [serverInfoString, lastUpdated],
+        function (error, updateResults) {
+          if (error) {
+            return res.send({
+              success: false,
+              message: `Update failed: ${error}`,
+            });
+          }
+
+          return res.send({
+            success: true,
+            message: `Server status updated successfully.`,
+          });
+        }
+      );
+    } catch (error) {
+      return res.send({
+        success: false,
+        message: `Unexpected error: ${error}`,
+      });
+    }
+  });
+
   app.post(baseEndpoint + "/command/process", async function (req, res) {
     isFeatureEnabled(features.bridge, res, lang);
 
@@ -104,7 +203,7 @@
       const bridgeApiData = await response.json();
 
       db.query(
-        `UPDATE bridge SET processed=? WHERE bridgeId=?;`,
+        `DELETE FROM bridge WHERE bridgeId=?;`,
         [1, bridgeId],
         function (error, results, fields) {
           if (error) {

api/routes/discord.js

@@ -1,6 +1,9 @@
-import { updateAudit_lastMinecraftLogin, updateAudit_lastMinecraftMessage } from "../../controllers/auditController";
+import {
+  updateAudit_lastMinecraftLogin,
+  updateAudit_lastMinecraftMessage,
+} from "../../controllers/auditController.js";
 import { Webhook } from "discord-webhook-node";
-import { isFeatureEnabled, required } from "../common";
+import { isFeatureEnabled, required } from "../common.js";
 
 export default function discordApiRoute(
   app,

api/routes/filter.js

@@ -1,70 +1,117 @@
-import { expandString, isFeatureEnabled, required } from "../common";
+import { isFeatureEnabled, optional, required } from "../common.js";
 import filter from "../../filter.json" assert { type: "json" };
+import { UserGetter } from "../../controllers/userController.js";
+import { MessageBuilder, Webhook } from "discord-webhook-node";
+import { Colors } from "discord.js";
 
 export default function filterApiRoute(app, config, db, features, lang) {
   const baseEndpoint = "/api/filter";
 
   app.post(baseEndpoint, async function (req, res) {
-    function expandString(string, filter) {
-      var regexString = "";
-      for (var i = 0; i < string.length; i++) {
-        if (string[i] in filter.alias)
-          regexString += "[" + filter.alias[string[i]] + "]";
-        else regexString += string[i];
-      }
-      regexString = regexString.replace(".", "\\.");
-      return regexString;
-    }
-
     if (!features.filter.phrase && !features.filter.link)
       return isFeatureEnabled(false, res, lang);
 
     const content = required(req.body, "content", res);
+    const username = optional(req.body, "username", res);
+    const discordId = optional(req.body, "discordId", res);
 
-    var bannedWords = [];
-    if (features.filter.phrase)
-      bannedWords = bannedWords.concat(filter.phrases);
-    if (features.filter.link) bannedWords = bannedWords.concat(filter.links);
+    try {
+      let userData = null;
 
-    var bannedRegex = [];
-    bannedWords.forEach((bannedWord) => {
-      bannedRegex.push(new RegExp(expandString(bannedWord, filter)));
-    });
+      // Fetch user data based on username or discordId
+      if (username) {
+        const usernameData = new UserGetter();
+        const usernameGetData = await usernameData.byUsername(username);
+        userData = usernameGetData;
+      }
 
-    let responseSent = false;
+      if (discordId) {
+        const discordUserData = new UserGetter();
+        const discordUserGetData = await discordUserData.byDiscordId(discordId);
+        userData = discordUserGetData;
+      }
 
-    try {
-      const wordList = content.split(" ");
-      for (let i = 0; i < bannedRegex.length; i++) {
-        const re = bannedRegex[i];
-        for (let j = 0; j < wordList.length; j++) {
-          const word = wordList[j];
-          if (re.test(word)) {
-            res.send({
-              success: false,
-              message: lang.filter.phraseCaught,
-            });
-            responseSent = true;
-            break;
-          }
-        }
-        if (responseSent) {
-          break;
+      // Log the received content to ensure it's correct
+      console.log("Received content:", content);
+
+      let urlDetected = false;
+      let flaggedFor = [];
+
+      // Scan for URLs using filter.links
+      filter.links.forEach((link) => {
+        const regex = new RegExp(link, "i");
+        if (regex.test(content)) {
+          console.log(`URL detected: ${link}`);
+          urlDetected = true;
+          flaggedFor.push("URL/Advertising");
         }
-      }
+      });
 
-      if (!responseSent) {
-        res.send({
-          success: true,
-          message: `Content Clean`,
+      // Profanity check via external API
+      const fetchURL = `https://vector.profanity.dev`;
+      let profanityData = {};
+      try {
+        const response = await fetch(fetchURL, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ message: content }),
         });
+
+        profanityData = await response.json();
+        console.log("Profanity Data:", profanityData);
+      } catch (error) {
+        console.log("Error calling profanity API:", error);
       }
-    } catch (error) {
-      console.log(error);
+
+      if (profanityData.isProfanity) {
+        console.log("Profanity detected with score:", profanityData.score);
+        flaggedFor.push(`Profanity (Score: ${profanityData.score})`);
+      }
+
+      // If any flags are detected, send the alert
+      if (urlDetected || flaggedFor.length > 0) {
+        try {
+          const staffChannelHook = new Webhook(
+            config.discord.webhooks.staffChannel
+          );
+          const embed = new MessageBuilder()
+            .setTitle(`🟥 Filter Flagged`)
+            .addField(
+              "Detected User",
+              `${userData?.username || "Unknown"}`,
+              true
+            )
+            .addField("Flagged Issues", flaggedFor.join(", "), true)
+            .addField("Content", `${content}`, false)
+            .setColor(Colors.Red)
+            .setTimestamp();
+
+          console.log("Sending flagged content to staff channel...");
+          await staffChannelHook.send(embed);
 
-      res.send({
+          return res.send({
+            success: false,
+            message: lang.filter.phraseCaught || "Content flagged.",
+          });
+        } catch (error) {
+          console.log("Error sending to webhook:", error);
+          return res.send({
+            success: false,
+            message: `${error}`,
+          });
+        }
+      }
+
+      // If no flags, content is clean
+      return res.send({
+        success: true,
+        message: "Content is clean. No flags detected.",
+      });
+    } catch (error) {
+      console.log("Error processing request:", error);
+      return res.send({
         success: false,
-        message: lang.web.registrationError,
+        message: error,
       });
     }
   });