Implement a command bridge between servers and the API

api/common.js

@@ -220,20 +220,24 @@ export async function setBannerCookie(alertType, alertContent, res) {
     res.setCookie("alertType", alertType, {
       path: "/",
       expires: expiryTime,
+      httpOnly: true,
     });
 
     // Set Content Type
     res.setCookie("alertContent", alertContent, {
       path: "/",
       expires: expiryTime,
+      httpOnly: true,
     });
 
-    return true;
+    // Make sure to send the res
+    return res;
   } catch (error) {
     console.log(error);
   }
 }
 
+
 /*
     Sets two cookies (alertType and alertContent) with specified values and an expiration time of one second. 
     These cookies are set on the root path and are returned by the function.

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

@@ -2,10 +2,16 @@ 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";
 
 export default (app, config, lang) => {
   applicationRedirectRoute(app, config, lang);
   serverRedirectRoute(app, config, lang);
+  reportRedirectRoute(app, config, lang);
   webRedirectRoute(app, config, lang);
   announcementsRedirectRoute(app, config, lang);
+  vaultRedirectRoute(app, config, lang);
+  bridgeRedirectRoute(app, config, lang);
 };

api/internal_redirect/report.js

@@ -0,0 +1,20 @@
+import { hasPermission, postAPIRequest } from "../common";
+
+export default function reportRedirectRoute(app, config, lang) {
+  const baseEndpoint = "/redirect/report";
+
+  app.post(baseEndpoint + "/create", async function (req, res) {
+    req.body.reporterUser = req.session.user.username;
+
+    postAPIRequest(
+      `${process.env.siteAddress}/api/report/create`,
+      req.body,
+      `${process.env.siteAddress}/report`,
+      res
+    );
+
+    res.redirect(`${process.env.siteAddress}/`);
+
+    return res;
+  });
+}

api/internal_redirect/vault.js

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

api/routes/announcement.js

@@ -5,13 +5,13 @@
 
   app.get(baseEndpoint + "/get", async function (req, res) {
     isFeatureEnabled(features.announcements, res, lang);
-    const announcementId = optional(req.query, "id");
+    const announcementId = optional(req.query, "announcementId");
     const announcementType = optional(req.query, "announcementType");
     const enabled = optional(req.query, "enabled");
 
     try {
       function getAnnouncements(dbQuery) {
         db.query(dbQuery, function (error, results, fields) {
           if (error) {
             return res.send({
               success: false,
@@ -157,14 +157,14 @@
     try {
       db.query(
         `
-                UPDATE announcements 
-                    SET 
-                        enabled=?,
-                        announcementType=?,
-                        body=?,
-                        colourMessageFormat=?,
-                        link=?
-                    WHERE announcementId=?;`,
+          UPDATE announcements 
+              SET 
+                  enabled=?,
+                  announcementType=?,
+                  body=?,
+                  colourMessageFormat=?,
+                  link=?
+              WHERE announcementId=?;`,
         [
           enabled,
           announcementType,

api/routes/application.js

@@ -5,11 +5,11 @@
 
   app.get(baseEndpoint + "/get", async function (req, res) {
     isFeatureEnabled(features.applications, res, lang);
-    const applicationId = optional(req.query, "applicationId");
+    const applicationId = optional(req.query, "id");
 
     try {
       function getApplications(dbQuery) {
         db.query(dbQuery, function (error, results, fields) {
           console.log(results);
 
           if (error) {

api/routes/bridge.js

@@ -0,0 +1,196 @@
+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 + "/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);
+
+    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;
+  });
+}