Initial move

modules/addonManager.mjs

@@ -0,0 +1,31 @@
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+import path from 'path';
+
+// Function to load addons from the addons directory
+export const loadAddons = async (nodeIo) => {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+
+    const addonsDir = path.join(__dirname, '../addons');
+
+    // Read the directory containing addon modules
+    const addonDirectories = await fs.readdirSync(addonsDir, { withFileTypes: true });
+
+    addonDirectories.forEach(addonDir => {
+        if (addonDir.isDirectory()) {
+            const addonConfigPath = path.join(addonsDir, addonDir.name, 'config.json');
+            if (fs.existsSync(addonConfigPath)) {
+                const addonConfig = JSON.parse(fs.readFileSync(addonConfigPath, 'utf-8'));
+                if (addonConfig.enabled) {
+                    const addonIndexPath = path.join(addonsDir, addonDir.name, 'index.js');
+                    import(`file://${addonIndexPath}`).then(addonModule => {
+                        console.log("Loading addon: ", addonModule);
+                        addonModule.initialize(nodeIo, addonConfig);
+                        console.log(`Addon ${addonConfig.name} loaded.`);
+                    });
+                }
+            }
+        }
+    });
+}

modules/mongoDiscordIDWrappers.mjs

@@ -0,0 +1,90 @@
+import { insertDocument, getDocuments, connectToDatabase } from "./mongoHandler.mjs";
+
+const collectionName = 'discord-ids';
+
+// Wrapper for inserting a Discord ID
+export const createDiscordID = async (discordID) => {
+  try {
+    const insertedId = await insertDocument(collectionName, discordID);
+    return insertedId;
+  } catch (error) {
+    console.error('Error creating Discord ID:', error);
+    throw error;
+  }
+};
+
+// Wrapper for retrieving all Discord IDs
+export const getAllDiscordIDs = async () => {
+  try {
+    const discordIDs = await getDocuments(collectionName);
+    return discordIDs;
+  } catch (error) {
+    console.error('Error getting all Discord IDs:', error);
+    throw error;
+  }
+};
+
+// Wrapper for retrieving a Discord ID by name or discord_id
+export const getDiscordID = async (identifier) => {
+  const db = await connectToDatabase();
+  try {    
+    const collection = db.db().collection(collectionName);
+    const discordID = await collection.findOne({
+      $or: [
+        { name: identifier },
+        { discord_id: identifier }
+      ]
+    });
+    return discordID;
+  } catch (error) {
+    console.error('Error getting Discord ID:', error);
+    throw error;
+  } finally {
+    // Close the connection
+    await db.close();
+  }
+};
+
+// Wrapper for updating a Discord ID by name or discord_id
+export const updateDiscordID = async (identifier, updatedFields) => {
+  const db = await connectToDatabase();
+  try {
+    const collection = db.db().collection(collectionName);
+    const result = await collection.updateOne({
+      $or: [
+        { name: identifier },
+        { discord_id: identifier }
+      ]
+    }, { $set: updatedFields });
+    console.log('Discord ID updated:', result.modifiedCount);
+    return result.modifiedCount;
+  } catch (error) {
+    console.error('Error updating Discord ID:', error);
+    throw error;
+  } finally {
+    // Close the connection
+    await db.close();
+  }
+};
+
+// Wrapper for deleting a Discord ID by name or discord_id
+export const deleteDiscordID = async (identifier) => {
+  const db = await connectToDatabase();
+  try {    
+    const collection = db.db().collection(collectionName);
+    const result = await collection.deleteOne({
+      $or: [
+        { name: identifier },
+        { discord_id: identifier }
+      ]
+    });
+    console.log('Discord ID deleted:', result.deletedCount);
+    return result.deletedCount;
+  } catch (error) {
+    console.error('Error deleting Discord ID:', error);
+    throw error;
+  } finally {
+    // Close the connection
+    await db.close();
+  }
+};

modules/mongoHandler.mjs

@@ -0,0 +1,53 @@
+// Import necessary modules
+import { MongoClient } from 'mongodb';
+
+import dotenv from 'dotenv';
+dotenv.config()
+
+// MongoDB connection URI
+const uri = process.env.MONGO_URL;
+
+// Function to connect to the database
+export const connectToDatabase = async () => {
+  try {
+    const client = await MongoClient.connect(uri);
+    return client;
+  } catch (error) {
+    console.error('Error connecting to the database:', error);
+    throw error;
+  }
+};
+
+// Function to insert a document into the collection
+export const insertDocument = async (collectionName, document) => {
+  const db = await connectToDatabase();
+  try {    
+    const collection = db.db().collection(collectionName);
+    const result = await collection.insertOne(document);
+    console.log('Document inserted:', result.insertedId);
+    return result.insertedId;
+  } catch (error) {
+    console.error('Error inserting document:', error);
+    throw error;
+  } finally {
+    // Close the connection
+    await db.close();
+  }
+};
+
+// Function to retrieve documents from the collection
+export const getDocuments = async (collectionName) => {
+  const db = await connectToDatabase();
+  try {    
+    const collection = db.db().collection(collectionName);
+    const documents = await collection.find({}).toArray();
+    console.log('Documents retrieved:', documents);
+    return documents;
+  } catch (error) {
+    console.error('Error retrieving documents:', error);
+    throw error;
+  } finally {
+    // Close the connection
+    await db.close();
+  }
+};

modules/mongoNodesWrappers.mjs

@@ -0,0 +1,75 @@
+import { insertDocument, getDocuments, connectToDatabase } from "./mongoHandler.mjs";
+
+const collectionName = 'nodes';
+
+// Wrapper for inserting a node
+export const createNode = async (node) => {
+  try {
+    const insertedId = await insertDocument(collectionName, node);
+    return insertedId;
+  } catch (error) {
+    console.error('Error creating node:', error);
+    throw error;
+  }
+};
+
+// Wrapper for retrieving all nodes
+export const getAllNodes = async () => {
+  try {
+    const nodes = await getDocuments(collectionName);
+    return nodes;
+  } catch (error) {
+    console.error('Error getting all nodes:', error);
+    throw error;
+  }
+};
+
+// Wrapper for retrieving a node by NUID
+export const getNodeByNuid = async (nuid) => {
+  const db = await connectToDatabase();
+  try {    
+    const collection = db.db().collection(collectionName);
+    const node = await collection.findOne({ nuid });
+    return node;
+  } catch (error) {
+    console.error('Error getting node by NUID:', error);
+    throw error;
+  } finally {
+    // Close the connection
+    await db.close();
+  }
+};
+
+// Wrapper for updating a node by NUID
+export const updateNodeByNuid = async (nuid, updatedFields) => {
+  const db = await connectToDatabase();
+  try {
+    const collection = db.db().collection(collectionName);
+    const result = await collection.updateOne({ nuid }, { $set: updatedFields });
+    console.log('Node updated:', result.modifiedCount);
+    return result.modifiedCount;
+  } catch (error) {
+    console.error('Error updating node by NUID:', error);
+    throw error;
+  } finally {
+    // Close the connection
+    await db.close();
+  }
+};
+
+// Wrapper for deleting a node by NUID
+export const deleteNodeByNuid = async (nuid) => {
+  const db = await connectToDatabase();
+  try {    
+    const collection = db.db().collection(collectionName);
+    const result = await collection.deleteOne({ nuid });
+    console.log('Node deleted:', result.deletedCount);
+    return result.deletedCount;
+  } catch (error) {
+    console.error('Error deleting node by NUID:', error);
+    throw error;
+  } finally {
+    // Close the connection
+    await db.close();
+  }
+};

modules/mongoSystemsWrappers.mjs

@@ -0,0 +1,111 @@
+import { insertDocument, getDocuments, connectToDatabase } from "./mongoHandler.mjs";
+
+const collectionName = 'radio-systems';
+
+// Local wrapper to remove any local files from radio systems
+const removeLocalFilesFromsystem = async (system) => {
+    if (system.trunkFile) delete system.trunkFile;
+    if (system.whitelistFile) delete system.whitelistFile;
+}
+
+
+// Wrapper for inserting a system
+export const createSystem = async (name, system, nuid) => {
+    try {
+        // Remove any local files
+        await removeLocalFilesFromsystem(system);
+        // Add the NUID of the node that created this system
+        system.nodes = [nuid];
+        // Add the name of the system 
+        system.name = name
+        const insertedId = await insertDocument(collectionName, system);
+        return insertedId;
+    } catch (error) {
+        console.error('Error creating system:', error);
+        throw error;
+    }
+};
+
+// Wrapper for retrieving all systems
+export const getAllSystems = async () => {
+    try {
+        const systems = await getDocuments(collectionName);
+        return systems;
+    } catch (error) {
+        console.error('Error getting all systems:', error);
+        throw error;
+    }
+};
+
+// Wrapper for retrieving a system by name
+export const getSystemByName = async (name) => {
+    const db = await connectToDatabase();
+    try {        
+        const collection = db.db().collection(collectionName);
+        const system = await collection.findOne({ name });
+        return system;
+    } catch (error) {
+        console.error('Error getting system by name:', error);
+        throw error;
+    } finally {
+        // Close the connection
+        await db.close();
+    }
+};
+
+// Wrapper to get all systems from a given node
+export const getSystemsByNuid = async (nuid) => {
+    const db = await connectToDatabase();
+    try {        
+        const collection = db.db().collection(collectionName);
+
+        // Query for documents where the 'nodes' array contains the given nodeID
+        const query = { nodes: nuid };
+        const systems = await collection.find(query).toArray();
+
+        return systems;
+    } catch (error) {
+        console.error('Error finding entries:', error);
+        throw error;
+    } finally {
+        // Close the connection
+        await db.close();
+    }
+};
+
+// Wrapper for updating a system by name
+export const updateSystemByName = async (name, updatedSystem) => {
+    // Remove any local files
+    await removeLocalFilesFromsystem(updatedSystem);
+    
+    const db = await connectToDatabase();
+    try {        
+        const collection = db.db().collection(collectionName);
+        const result = await collection.updateOne({ name }, { $set: updatedSystem });
+        console.log('System updated:', result.modifiedCount);
+        return result.modifiedCount;
+    } catch (error) {
+        console.error('Error updating system by name:', error);
+        throw error;
+    } finally {
+        // Close the connection
+        await db.close();
+    }
+};
+
+// Wrapper for deleting a system by name
+export const deleteSystemByName = async (name) => {
+    const db = await connectToDatabase();
+    try {        
+        const collection = db.db().collection(collectionName);
+        const result = await collection.deleteOne({ name });
+        console.log('System deleted:', result.deletedCount);
+        return result.deletedCount;
+    } catch (error) {
+        console.error('Error deleting system by name:', error);
+        throw error;
+    } finally {
+        // Close the connection
+        await db.close();
+    }
+};

modules/socketServer.mjs

@@ -0,0 +1,39 @@
+import express from 'express';
+import { createServer } from 'node:http';
+import { Server } from 'socket.io';
+import morgan from 'morgan';
+import { nodeLoginWrapper, nodeUpdateWrapper, nodeDisconnectWrapper, nearbySystemsUpdateWraper } from "./socketServerWrappers.mjs";
+
+export const app = express();
+export const server = createServer(app);
+export const nodeIo = new Server(server);
+
+app.use(morgan('tiny'));
+
+app.get('/', (req, res) => {
+    res.send('<h1>Hello world</h1>');
+});
+
+nodeIo.on('connection', (socket) => {
+    console.log('a user connected', socket.id);
+
+    socket.on('node-login', async (data) => {
+        await nodeLoginWrapper(data, socket);
+        await socket.emit('node-login-successful');
+    })
+
+    socket.on('node-update', async (data) => {
+        let tempPromises = [];
+        tempPromises.push(nodeUpdateWrapper(data.node));
+        tempPromises.push(nearbySystemsUpdateWraper(data.node.nuid, data.nearbySystems));
+
+        await Promise.all(tempPromises);
+
+        await socket.emit('node-update-successful')
+    })
+
+    socket.on('disconnect', () => {
+        nodeDisconnectWrapper(socket.id);
+    });
+
+});

modules/socketServerWrappers.mjs

@@ -0,0 +1,315 @@
+import { createNode, getNodeByNuid, updateNodeByNuid } from "./mongoNodesWrappers.mjs"
+import { createSystem, getSystemByName, updateSystemByName, getSystemsByNuid, deleteSystemByName } from "./mongoSystemsWrappers.mjs"
+
+/**
+ * Description
+ * @param {any} socket
+ * @param {any} command
+ * @param {any} data
+ * @returns {any}
+ */
+const sendNodeCommand = async (socket, command, data) => {
+    // TODO - Check to see if the command exists
+    // TODO - Check to see if the socket is alive?
+    // TODO - Validate the given data
+    socket.emit(command, data);
+}
+
+/**
+ * Log the node into the network
+ * @param {object} data The data sent from the node
+ * @param {any} socket The socket the node is connected from
+ * @returns {any}
+ */
+export const nodeLoginWrapper = async (data, socket) => {
+    console.log(`Login requested from node: ${data.nuid}`, data);
+    // Check to see if node exists
+    var node = await getNodeByNuid(data.nuid);
+    console.log("After grabbing", node);
+    if (!node) {
+        const insertedId = await createNode(data);
+        console.log("Added new node to the database:", insertedId);
+    } else {
+        // Check for updates
+        const updatedNode = await updateNodeByNuid(data.nuid, data)
+        console.log("Updated node:", updatedNode);
+    }
+
+    node = await getNodeByNuid(data.nuid);
+
+    // Add the socket/node connection
+    socket.node = node;
+
+    return;
+}
+
+/**
+ * Disconnect the client from the server
+ * @param {string} socketId The socket ID that was disconnected
+ * @returns {any}
+ */
+export const nodeDisconnectWrapper = async (socketId) => {
+    // TODO - Let any server know that a bot has disconnected if the bot was joined to vc? might not be worth cpu lol
+    return;
+}
+
+/**
+ * Update node data in the database
+ * @param {object} nodeData The data object sent from the node
+ * @returns {any}
+ */
+export const nodeUpdateWrapper = async (nodeData) => {
+    console.log("Data update sent by node: ", nodeData);
+    const updateResults = await updateNodeByNuid(nodeData.nuid, nodeData);
+    return;
+}
+
+/**
+ * Wrapper to update the systems from the nearbySystems object passed from clients
+ * @param {string} nuid The NUID of the node that sent the update
+ * @param {object} nearbySystems The nearby systems object passed from the node to be updated
+ */
+export const nearbySystemsUpdateWraper = async (nuid, nearbySystems) => {
+    console.log("System updates sent by node: ", nuid, nearbySystems);
+    // Check to see if the node removed any systems
+    const existingSystems = await getSystemsByNuid(nuid);
+    console.log("Existing systems:", existingSystems);
+    if (existingSystems !== nearbySystems) {
+        for (const existingSystem of existingSystems) {
+            if (existingSystem.name in nearbySystems) {
+                // Skip this system if it's in the given systems update
+                continue;
+            }
+
+            console.log("System exists that was not given by node", existingSystem);
+            // Check if this node was the only node on this system
+            if (existingSystem.nodes.filter(node => node !== nuid).length === 0) {
+                // Remove the system if so
+                console.log("Given node was the only node on this system, removing the system...");
+                await deleteSystemByName(existingSystem.name);
+            } else {
+                // Remove the node from the array if there are other nodes with this system
+                console.log("Other nodes found on this system, removing the given NUID");
+                existingSystem.nodes = existingSystem.nodes.filter(node => node !== nuid);
+                console.log(existingSystem);
+                await updateSystemByName(existingSystem.name, existingSystem);
+            }
+        }
+    }
+
+    // Add and update the given systems
+    for (const nearbySystem in nearbySystems) {
+        // Check if the system exists already on another node
+        const existingSystem = await getSystemByName(nearbySystem);
+        if (existingSystem) {
+            // Verify the frequencies match (to make sure the name isn't just the same)
+            if (JSON.stringify(existingSystem.frequencies) === JSON.stringify(nearbySystems[nearbySystem].frequencies)) {
+                // The systems are the same                
+
+                // Check if the current node is listed in the nodes, if not add it
+                if (!existingSystem.nodes.includes(nuid)) {
+                    existingSystem.nodes.push(nuid);
+                    // Update the system with the added node
+                    const updateResults = await updateSystemByName(nearbySystem, existingSystem);
+                    if (updateResults) console.log("System updated", nearbySystem);
+                }
+            } else {
+                // The systems are not the same
+                // TODO - Implement logic to handle if system names match, but they are for different frequencies or have additional freqs
+
+                // Check if the current node is listed in the nodes, if not add it
+                if (!existingSystem.nodes.includes(nuid)) {
+                    existingSystem.nodes.push(nuid);
+                    nearbySystems[nearbySystem].nodes = existingSystem.nodes;
+                }
+
+                // Update the system with the added node
+                const updateResults = await updateSystemByName(nearbySystem, nearbySystems[nearbySystem]);
+                if (updateResults) console.log("System updated", nearbySystem);
+            }
+        }
+        else {
+            // Create a new system
+            const newSystem = await createSystem(nearbySystem, nearbySystems[nearbySystem], nuid);
+            console.log("New system created", nearbySystem, newSystem);
+        }
+    }
+    return;
+}
+
+
+/**
+ * Get the open socket connection ID for a node from the NUID 
+ * @param {string} nuid The NUID to find within the open sockets
+ * @returns {string|null} Will return the open socket ID or NULL
+ */
+export const getSocketIdByNuid = async (nodeIo, nuid) => {
+    const openSockets = await nodeIo.allSockets();
+    for (const openSocketId of openSockets) {
+        console.log(openSockets)
+        const openSocket = await nodeIo.sockets.sockets.get(openSocketId);
+        if (openSocket.node.nuid == nuid)
+            return openSocket;
+    }
+    return null;
+}
+
+/**
+ * Get all nodes that are connected to a voice channel
+ * @param {any} nodeIo The nodeIo object that contains the IO server
+ * @param {string} guildId The guild ID string for the guild we are looking in
+ * @returns {Array} The sockets connected to VC in a given server
+ */
+export const getAllSocketsConnectedToVC = async (nodeIo, guildId) => {
+    // Get all open socket nodes
+    // TODO - require a server guild to filter the results, ie this would be able to check what server the VCs the nodes are connected are in
+    const openSockets = [...await nodeIo.allSockets()]; // TODO - Filter the returned nodes to only nodes that have the radio capability
+    // Check each open socket to see if the node has the requested system
+    const socketsConnectedToVC = []
+    await Promise.all(openSockets.map(async openSocket => {
+        openSocket = await nodeIo.sockets.sockets.get(openSocket);
+        await new Promise((res) => {
+            openSocket.emit('node-check-connected-status', guildId, (status) => {
+                if (status) {
+                    console.log("Socket is connected to VC:", openSocket.node.name, status);
+                    socketsConnectedToVC.push(openSocket);
+                } else {
+                    console.log("Socket is NOT connected to VC:", openSocket.node.name);
+                }
+                res();
+            })
+        });
+    }));
+
+    return socketsConnectedToVC;
+}
+
+
+/**
+ * Check if the given node has an open discord client
+ * @param {any} openSocket The open socket connection with the node to check
+ * @returns {boolean} If the given node has an open discord client or not
+ */
+export const checkIfNodeHasOpenDiscordClient = async (openSocket) => {
+    // Check the open socket to see if the node has an open discord client
+    let hasOpenDiscordClient = false;
+    await new Promise((res) => {
+        openSocket.emit('node-check-discord-open-client', (status) => {
+            if (status) {
+                console.log("Socket has an open discord client:", openSocket.node.name, status);
+                hasOpenDiscordClient = true;
+            } else {
+                console.log("Socket does NOT have an open discord client:", openSocket.node.name);
+            }
+            res();
+        })
+    });
+
+    return hasOpenDiscordClient;
+}
+
+export const getNodeCurrentListeningSystem = async (openSocket) => {
+    const hasOpenClient = checkIfNodeHasOpenDiscordClient(openSocket);
+    if (!hasOpenClient) return undefined;
+
+    // check what system the socket is listening to
+    let currentSystem = undefined;
+    await new Promise((res) => {
+        openSocket.emit('node-check-current-system', (system) => {
+            if (system) {
+                console.log("Socket is listening to system:", openSocket.node.name, system);
+                currentSystem = system;
+            } else {
+                console.log("Socket is not currently listening to a system:", openSocket.node.name);
+            }
+            res();
+        })
+    });
+
+    return currentSystem;
+}
+
+/**
+ * Wrapper to check if the given NUID is connected to a VC
+ * @param {any} nodeIo The nodeIo object that contains the IO server
+ * @param {string} nuid The NUID string that we would like to find in the open socket connections
+ * @returns {boolean} If the node is connected to VC in the given server
+ */
+export const checkIfNodeIsConnectedToVC = async (nodeIo, guildId, nuid) => {
+    const socketsConnectedToVC = await getAllSocketsConnectedToVC(nodeIo, guildId);
+    for (const socket of socketsConnectedToVC) {
+        if (socket.node.nuid === nuid) {
+            return true;
+        }
+    }
+    return false;
+}
+
+/**
+ * Get the discord username from a given socket
+ * @param {any} socket The socket object of the node to check the username of
+ * * @param {string} guildId The guild ID to check the username in
+ * @returns {string} The username of the bot in the requested server
+ */
+export const getNodeDiscordUsername = async (socket, guildId) => {
+    return await new Promise((res) => {
+        socket.emit('node-get-discord-username', guildId, (username) => {
+            res(username);
+        });
+    });
+}
+
+/**
+ * Get the discord ID from a given socket
+ * @param {any} socket The socket object of the node to check the ID of
+ * @returns {string} The ID of the bot
+ */
+export const getNodeDiscordID = async (socket) => {
+    return await new Promise((res) => {
+        socket.emit('node-get-discord-id', (discordID) => {
+            res(discordID);
+        });
+    });
+}
+
+/**
+ * Request a given socket node to join a given voice channel
+ * @param {any} socket The socket object of the node the request should be sent to
+ * @param {any} systemName The system preset name that we would like to listen to
+ * @param {string} discordChanelId The Discord channel ID to join the listening bot to
+ */
+export const requestNodeJoinSystem = async (socket, systemName, discordChanelId, discordToken = "MTE5NjAwNTM2ODYzNjExMjk3Nw.GuCMXg.24iNNofNNumq46FIj68zMe9RmQgugAgfrvelEA") => {
+    // Join the system
+    const joinData = {
+        'clientID': discordToken,
+        'channelID': discordChanelId,
+        'system': systemName
+    }
+    // Send the command to the node
+    await sendNodeCommand(socket, "node-join", joinData);
+}
+
+/**
+ * Request a given socket node to leave VC in a given server
+ * @param {any} socket The socket object of the node the request should be sent to
+ * @param {string} guildId The guild ID to disconnect the socket node from
+ */
+export const requestBotLeaveServer = async (socket, guildId) => {
+    // Send the command to the node
+    await sendNodeCommand(socket, "node-leave", guildId);
+}
+
+
+/**
+ * Requset a given socket node to update themselves
+ * @param {any} socket The socket object of the node to request to update
+ */
+export const requestNodeUpdate = async (socket) => {
+    await sendNodeCommand(socket, 'node-update', (status) => {
+        if (status) {
+            console.log("Node is out of date, updating now", socket.node.name);
+        } else {
+            console.log("Node is up to date", socket.node.name);
+        }
+    });
+}