Implement Voting via 3rd party websites and have bridge distribute commands.

api/internal_redirect/bridge.js

@@ -0,0 +1,23 @@
+import { hasPermission, postAPIRequest } from "../common";
+
+export default function bridgeRedirectRoute(app, config, lang) {
+  const baseEndpoint = "/redirect/bridge";
+
+  app.post(baseEndpoint + "/command/add", async function (req, res) {
+    if (!hasPermission("zander.web.bridge", req, res)) return;
+
+    // Add userId to req.body
+    req.body.actioningUser = req.session.user.userId;
+
+    postAPIRequest(
+      `${process.env.siteAddress}/api/bridge/command/add`,
+      req.body,
+      `${process.env.siteAddress}/dashboard/bridge`,
+      res
+    );
+
+    res.redirect(`${process.env.siteAddress}/dashboard/bridge`);
+
+    return res;
+  });
+}

api/internal_redirect/index.js

@@ -4,6 +4,8 @@ import webRedirectRoute from "./web";
 import announcementsRedirectRoute from "./announcement";
 import reportRedirectRoute from "./report";
 import vaultRedirectRoute from "./vault";
+import bridgeRedirectRoute from "./bridge";
+import voteRedirectRoute from "./vote";
 
 export default (app, config, lang) => {
   applicationRedirectRoute(app, config, lang);
@@ -12,4 +14,6 @@ export default (app, config, lang) => {
   webRedirectRoute(app, config, lang);
   announcementsRedirectRoute(app, config, lang);
   vaultRedirectRoute(app, config, lang);
+  bridgeRedirectRoute(app, config, lang);
+  voteRedirectRoute(app, config, lang);
 };

api/internal_redirect/vote.js

@@ -0,0 +1,77 @@
+import { hasPermission, postAPIRequest } from "../common";
+
+export default function voteRedirectRoute(app, config, lang) {
+  const baseEndpoint = "/redirect/vote";
+
+  app.post(baseEndpoint + "/cast", async function (req, res) {
+    if (!hasPermission("zander.web.vote", req, res)) return;
+
+    // Add userId to req.body
+    req.body.actioningUser = req.session.user.userId;
+
+    postAPIRequest(
+      `${process.env.siteAddress}/api/vote/cast`,
+      req.body,
+      `${process.env.siteAddress}/dashboard/vote`,
+      res
+    );
+
+    res.redirect(`${process.env.siteAddress}/dashboard/vote`);
+
+    return res;
+  });
+
+  app.post(baseEndpoint + "/site/create", async function (req, res) {
+    if (!hasPermission("zander.web.vote", req, res)) return;
+
+    // Add userId to req.body
+    req.body.actioningUser = req.session.user.userId;
+
+    postAPIRequest(
+      `${process.env.siteAddress}/api/vote/site/create`,
+      req.body,
+      `${process.env.siteAddress}/dashboard/vote`,
+      res
+    );
+
+    res.redirect(`${process.env.siteAddress}/dashboard/vote`);
+
+    return res;
+  });
+
+  app.post(baseEndpoint + "/site/edit", async function (req, res) {
+    if (!hasPermission("zander.web.vote", req, res)) return;
+
+    // Add userId to req.body
+    req.body.actioningUser = req.session.user.userId;
+
+    postAPIRequest(
+      `${process.env.siteAddress}/api/vote/site/edit`,
+      req.body,
+      `${process.env.siteAddress}/dashboard/vote`,
+      res
+    );
+
+    res.redirect(`${process.env.siteAddress}/dashboard/vote`);
+
+    return res;
+  });
+
+  app.post(baseEndpoint + "/site/delete", async function (req, res) {
+    if (!hasPermission("zander.web.vote", req, res)) return;
+
+    // Add userId to req.body
+    req.body.actioningUser = req.session.user.userId;
+
+    postAPIRequest(
+      `${process.env.siteAddress}/api/vote/site/delete`,
+      req.body,
+      `${process.env.siteAddress}/dashboard/vote`,
+      res
+    );
+
+    res.redirect(`${process.env.siteAddress}/dashboard/vote`);
+
+    return res;
+  });
+}

api/routes/application.js

@@ -9,9 +9,7 @@ export default function applicationApiRoute(app, config, db, features, lang) {
 
     try {
       function getApplications(dbQuery) {
-        db.query(dbQuery, function (error, results, fields) {
-          console.log(results);
-
+        db.query(dbQuery, function (error, results, fields) {          
           if (error) {
             res.send({
               success: false,

api/routes/bridge.js

@@ -0,0 +1,162 @@
+import { isFeatureEnabled, required, optional, generateLog } from "../common";
+
+export default function bridgeApiRoute(app, config, db, features, lang) {
+  const baseEndpoint = "/api/bridge";
+
+  app.get(baseEndpoint + "/get", async function (req, res) {
+    isFeatureEnabled(features.bridge, res, lang);
+    const bridgeId = optional(req.query, "id");
+    const targetServer = optional(req.query, "targetServer");
+
+    try {
+      function getBridge(dbQuery) {
+        db.query(dbQuery, function (error, results, fields) {
+          if (error) {
+            res.send({
+              success: false,
+              message: `${error}`,
+            });
+          }          
+
+          if (!results) {
+            return res.send({
+              success: false,
+              message: `No Bridge requests can be found`,
+            });
+          }
+
+          return res.send({
+            success: true,
+            data: results,
+          });
+        });
+      }
+
+      // Get Bridge by ID
+      if (bridgeId) {
+        let dbQuery = `SELECT * FROM bridge WHERE bridgeId=${bridgeId};`;
+        getBridge(dbQuery);
+      }
+
+      // Get Bridge by Targeted Server
+      if (targetServer) {
+        let dbQuery = `SELECT * FROM bridge WHERE targetServer='${targetServer}' AND processed=0;`;
+        getBridge(dbQuery);
+      }
+
+      // Return all Bridge requests by default
+      let dbQuery = `SELECT * FROM bridge;`;
+      getBridge(dbQuery);
+    } catch (error) {
+      res.send({
+        success: false,
+        message: `${error}`,
+      });
+    }
+
+    return res;
+  });
+
+  app.post(baseEndpoint + "/command/add", async function (req, res) {
+    isFeatureEnabled(features.bridge, res, lang);
+
+    const command = required(req.body, "command", res);
+    const targetServer = required(req.body, "targetServer", res);
+
+    try {
+      db.query(
+        `INSERT INTO bridge (command, targetServer) VALUES (?, ?)`,
+        [command, targetServer],
+        function (error, results, fields) {
+          if (error) {
+            return res.send({
+              success: false,
+              message: `${error}`,
+            });
+          }
+
+          return res.send({
+            success: true,
+            message: `New Bridge command added for ${targetServer}: ${command}`,
+          });
+        }
+      );
+    } catch (error) {
+      res.send({
+        success: false,
+        message: `${error}`,
+      });
+    }
+
+    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.post(baseEndpoint + "/command/process", async function (req, res) {
+    isFeatureEnabled(features.bridge, res, lang);
+
+    const bridgeId = required(req.body, "bridgeId", res);
+
+    try {
+      const fetchURL = `${process.env.siteAddress}/api/bridge/get?id=${bridgeId}`;
+      const response = await fetch(fetchURL, {
+        headers: { "x-access-token": process.env.apiKey },
+      });
+      const bridgeApiData = await response.json();
+
+      db.query(
+        `UPDATE bridge SET processed=? WHERE bridgeId=?;`,
+        [1, bridgeId],
+        function (error, results, fields) {
+          if (error) {
+            return res.send({
+              success: false,
+              message: `${error}`,
+            });
+          }
+
+          return res.send({
+            success: true,
+            message: `Bridge ID ${bridgeId} has been executed.`,
+          });
+        }
+      );
+    } catch (error) {
+      res.send({
+        success: false,
+        message: `${error}`,
+      });
+    }
+
+    return res;
+  });
+}

api/routes/index.js

@@ -9,6 +9,8 @@ import filterApiRoute from "./filter";
 import rankApiRoute from "./ranks";
 import reportApiRoute from "./report";
 import vaultApiRoute from "./vault";
+import bridgeApiRoute from "./bridge";
+import voteApiRoute from "./vote";
 
 export default (app, client, moment, config, db, features, lang) => {
   announcementApiRoute(app, config, db, features, lang);
@@ -22,6 +24,8 @@ export default (app, client, moment, config, db, features, lang) => {
   rankApiRoute(app, config, db, features, lang);
   filterApiRoute(app, config, db, features, lang);
   vaultApiRoute(app, config, db, features, lang);
+  bridgeApiRoute(app, config, db, features, lang);
+  voteApiRoute(app, config, db, features, lang);
 
   app.get("/api/heartbeat", async function (req, res) {
     return res.send({

api/routes/user.js

@@ -80,6 +80,8 @@ export default function userApiRoute(app, config, db, features, lang) {
   // TODO: Update docs
   app.get(baseEndpoint + "/get", async function (req, res) {
     const username = optional(req.query, "username");
+    const discordId = optional(req.query, "discordId");
+    const userId = optional(req.query, "userId");
 
     try {
       if (username) {
@@ -101,6 +103,56 @@ export default function userApiRoute(app, config, db, features, lang) {
               });
             }
 
+            return res.send({
+              success: true,
+              data: results,
+            });
+          }
+        );
+      } else if (discordId) {
+        db.query(
+          `SELECT * FROM users WHERE discordId=?;`,
+          [discordId],
+          function (error, results, fields) {
+            if (error) {
+              return res.send({
+                success: false,
+                message: error,
+              });
+            }
+
+            if (!results || !results.length) {
+              return res.send({
+                success: false,
+                message: lang.api.userDoesNotExist,
+              });
+            }
+
+            return res.send({
+              success: true,
+              data: results,
+            });
+          }
+        );
+      } else if (userId) {
+        db.query(
+          `SELECT * FROM users WHERE userId=?;`,
+          [userId],
+          function (error, results, fields) {
+            if (error) {
+              return res.send({
+                success: false,
+                message: error,
+              });
+            }
+
+            if (!results || !results.length) {
+              return res.send({
+                success: false,
+                message: lang.api.userDoesNotExist,
+              });
+            }
+
             return res.send({
               success: true,
               data: results,