Initial move

discordBot/commands/join.mjs

@@ -0,0 +1,154 @@
+import { SlashCommandBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle } from 'discord.js';
+import { requestNodeJoinSystem, checkIfNodeIsConnectedToVC, checkIfNodeHasOpenDiscordClient, getNodeCurrentListeningSystem } from '../../modules/socketServerWrappers.mjs';
+import { getSystemsByNuid, getAllSystems, getSystemByName } from '../../modules/mongoSystemsWrappers.mjs';
+import { getAvailableTokensInGuild } from '../modules/wrappers.mjs';
+
+// Exporting data property
+export const data = new SlashCommandBuilder()
+  .setName('join')
+  .setDescription('Listen to the selected radio system in your channel')
+  .addStringOption(system =>
+    system.setName('system')
+      .setDescription('The radio system you would like to listen to')
+      .setRequired(true)
+      .setAutocomplete(true));
+
+// Exporting other properties
+export const example = "/join";
+export const deferInitialReply = true;
+
+/**
+ * Function to give the user auto-reply suggestions
+ * @param {any} nodeIo The nodeIO server for manipulation of sockets
+ * @param {any} interaction The interaction object
+ */
+export async function autocomplete(nodeIo, interaction) {
+  const focusedValue = interaction.options.getFocused();
+  const choices = await getAllSystems();
+  const filtered = choices.filter(choice => choice.name.startsWith(focusedValue));
+
+  console.log(focusedValue, choices, filtered);
+
+  await interaction.respond(
+    filtered.map(choice => ({ name: choice.name, value: choice.name })),
+  );
+}
+
+/**
+ * The function to run when the command is called by a discord user
+ * @param {any} nodeIo The nodeIO server for manipulation of sockets
+ * @param {any} interaction The interaction object
+ */
+export async function execute(nodeIo, interaction) {
+  // Check if the user is in a VC
+  if (!interaction.member.voice.channel) { return await interaction.editReply({ content: `<@${interaction.member.id}>, you need to enter a voice channel before you use this command`, ephemeral: true }) }
+  // Grab the channel if the user is connected to VC
+  const channelToJoin = interaction.member.voice.channel;
+  console.log(`The user '${interaction.member.id}' is in the voice channel '${channelToJoin}'`);
+
+  // Get the selected system option from the command interaction
+  const selectedSystem = interaction.options.getString('system');
+
+  try {
+    // Get the selected system object from the DB
+    const system = await getSystemByName(selectedSystem);
+
+    // Function wrapper to request the selected/only node to join the selected system
+    const joinSelectedNode = async (selectedNodeSocketId) => {
+      const openSocket = await nodeIo.sockets.sockets.get(selectedNodeSocketId);
+      // Get the open ID for this connection\
+      const ss = await getAvailableTokensInGuild(nodeIo, interaction.guild.id);
+      console.log("Available discord tokens: ", discordTokens);
+
+      if (discordTokens.length >= 1) {
+        // TODO - Implement a method to have preferred tokens (bot users) for specific systems
+        console.log("Joining selected open socket:", selectedNodeSocketId, system.name, channelToJoin.id, openSocket.node.name, discordTokens[0].token);
+
+        // Ask the node to join the selected channel and system
+        await requestNodeJoinSystem(openSocket, system.name, channelToJoin.id, discordTokens[0].token);
+      }
+      else {
+        return await interaction.editReply({ content: `<@${interaction.member.id}>, there are no free bots. Free up or create a new bot ID (discord app) to listen to this system.`, ephemeral: true })
+      }
+    }
+
+    // Get all open socket nodes
+    const openSockets = [...await nodeIo.allSockets()]; // TODO - Filter the returned nodes to only nodes that have the radio capability
+    console.log("All open sockets: ", openSockets);
+
+    var availableNodes = [];
+    // Check each open socket to see if the node has the requested system
+    await Promise.all(openSockets.map(async openSocket => {
+      openSocket = await nodeIo.sockets.sockets.get(openSocket);
+      // Check if the node has an existing open client (meaning the radio is already being listened to)
+      const hasOpenClient = await checkIfNodeHasOpenDiscordClient(openSocket);
+      if (hasOpenClient) {
+        let currentSystem = await getNodeCurrentListeningSystem(openSocket);
+        if (currentSystem != system.name) {
+          console.log("Node is listening to a different system than requested", openSocket.node.name);
+          return;
+        }
+      }
+
+      // Check if the bot has an open voice connection in the requested server already
+      const connected = await checkIfNodeIsConnectedToVC(nodeIo, interaction.guild.id, openSocket.node.nuid);
+      console.log("Connected:", connected);
+      if (!connected) {
+        // Check if this node has the requested system, if so add it to the availble array
+        if (system.nodes.includes(openSocket.node.nuid)) {
+          availableNodes.push(openSocket);
+        }
+      }
+
+    }));
+
+    console.log("Availble nodes:", availableNodes.map(socket => socket.node.name));
+
+    // If there are no available nodes, let the user know there are none available
+    if (availableNodes.length == 0) {
+      // There are no nodes availble for the requested system
+      return await interaction.editReply(`<@${interaction.member.id}>, the selected system has no available nodes`);
+    } else if (availableNodes.length == 1) {
+      // There is only one node available for the requested system
+      // Request the node to join
+      await joinSelectedNode(availableNodes[0].id);
+      // Let the user know
+      await interaction.editReply({ content: `Ok <@${interaction.member.id}>, a bot will join your channel listening to *'${system.name}'* shortly`, components: [] });
+    } else if (availableNodes.length > 1) {
+      // There is more than one node availble for the requested system
+      const nodeSelectionButtons = []
+
+      // Create a button for each available node
+      for (const availableNode of availableNodes) {
+        nodeSelectionButtons.push(new ButtonBuilder().setCustomId(availableNode.id).setLabel(availableNode.node.name).setStyle(ButtonStyle.Primary));
+      }
+
+      const actionRow = new ActionRowBuilder().addComponents(nodeSelectionButtons);
+
+      // Reply to the user with the button prompts
+      const response = await interaction.editReply({
+        content: `<@${interaction.member.id}>, Please select the Node you would like to join with this system`,
+        components: [actionRow]
+      });
+
+      // Make sure the responding selection is from the user who initiated the command
+      const collectorFilter = i => i.user.id === interaction.user.id;
+
+      // Wait for the confirmation from the user on which node to join
+      try {
+        const selectedNode = await response.awaitMessageComponent({ filter: collectorFilter, time: 60_000 });
+        // Run the local wrapper to listen to the selected node
+        await joinSelectedNode(selectedNode.customId);
+        // Let the user know
+        await selectedNodeConfirmation.update({ content: `Ok <@${interaction.member.id}>, a bot will join your channel listening to *'${system.name}'*`, components: [] });
+      } catch (e) {
+        console.error(e);
+        // Timeout the prompt if the user doesn't interact with it
+        await interaction.editReply({ content: 'Confirmation not received within 1 minute, cancelling', components: [] });
+      }
+    }
+  } catch (err) {
+    console.error(err);
+    // await interaction.reply(err.toString());
+  }
+}