Arthonor-Neo/events/InteractionCreate.js

const { Events, MessageFlags, Message } = require('discord.js')
const { mClient } = require('../index')
require('dotenv').config()

module.exports = {
    name: Events.InteractionCreate,
    once: false,
    async execute(interaction) {
        if (interaction.isChatInputCommand()) { commandHandler(interaction) }
        if (interaction.isButton()) { buttonHandler(interaction) }
        if (interaction.isMentionableSelectMenu()) { selectMenuHandler(interaction) }
        if (interaction.isUserSelectMenu()) { selectMenuHandler(interaction) }
        if (interaction.isModalSubmit()) { modalSubmitHandler(interaction) }
    }
}
async function commandHandler(interaction) {
    const command = interaction.client.commands.get(interaction.commandName);

    if (!command) {
        console.error(`No command matching ${interaction.commandName} was found.`);
        return;
    }
    try {
        await command.execute(interaction);
    } catch (error) {
        console.error(error);
        if (interaction.replied || interaction.deferred) {
            await interaction.followUp({ content: 'There was an error while executing this command!', flags: MessageFlags.Ephemeral });
        } else {
            await interaction.reply({ content: 'There was an error while executing this command!', flags: MessageFlags.Ephemeral });
        }
    }
}
async function buttonHandler(interaction) {
    const button = interaction.client.buttons.get(interaction.customId)
    if (!button) { return }// console.error(`No button registered matching ${interaction.customId}.`) }
    try {
        await button.execute(interaction);
    } catch (error) {
        console.error(error);
        if (interaction.replied || interaction.deferred) {
            await interaction.followUp({ content: 'There was an error while executing this command!', flags: MessageFlags.Ephemeral });
        } else {
            await interaction.reply({ content: 'There was an error while executing this command!', flags: MessageFlags.Ephemeral });
        }
    }
}
async function selectMenuHandler(interaction) {
    const selectMenu = interaction.client.selectMenus.get(interaction.customId)
    if (!selectMenu) { return console.error(`No Select Menu registered matching ${interaction.customId}.`) }
    try {
        await selectMenu.execute(interaction);
    } catch (error) {
        console.error(error);
        if (interaction.replied || interaction.deferred) {
            await interaction.followUp({ content: 'There was an error while executing this command!', flags: MessageFlags.Ephemeral });
        } else {
            await interaction.reply({ content: 'There was an error while executing this command!', flags: MessageFlags.Ephemeral });
        }
    }
}

async function modalSubmitHandler(interaction) {
    if (interaction.customId !== 'wgeBaseModal') return;

    const db = mClient.db('neo-db');
    const wgeColl = db.collection('timer_wge');
    const participateColl = db.collection('items_wge');
    const historyWgeColl = db.collection('history_wge');

    const assigningUser = interaction.user;
    const selectedUserId = interaction.components[0].component.values[0];
    const topic = interaction.fields.getTextInputValue('wgeTopicInput');
    const defaultAssignedTime = 7 * 24 * 60 * 60 * 1000; // 7 days

    // Get current running WGE so we can exclude the current expert
    const prevWge = await wgeColl.findOne({
        debug: false,
        state: 'running'
    });

    let assignedUser;

    // Random assignment
    if (selectedUserId === process.env.D_ID) {
        const randomParticipant = await participateColl.aggregate([
            {
                $match: {
                    status: true,
                    ...(prevWge && {
                        userID: { $ne: prevWge.assignedUser }
                    })
                }
            },
            { $sample: { size: 1 } }
        ]).toArray();

        if (randomParticipant.length === 0) {
            return interaction.reply({
                content: 'There are no eligible participants available.',
                flags: MessageFlags.Ephemeral
            });
        }

        const member = await interaction.guild.members.fetch(randomParticipant[0].userID);
        assignedUser = member.user;
    }
    // Manual assignment
    else {
        const participant = await participateColl.findOne({
            userID: selectedUserId,
            status: true
        });

        if (!participant) {
            return interaction.reply({
                content: `<@${selectedUserId}> is not participating!`,
                flags: MessageFlags.Ephemeral
            });
        }

        if (prevWge && selectedUserId === prevWge.assignedUser) {
            return interaction.reply({
                content: `<@${selectedUserId}> was the previous expert and cannot be selected again this round.`,
                flags: MessageFlags.Ephemeral
            });
        }

        assignedUser = { id: selectedUserId };
    }

    // Archive previous WGE
    if (prevWge) {
        await historyWgeColl.insertOne({
            assignedUser: prevWge.assignedUser,
            assigningUser: prevWge.assigningUser,
            timeRemaining: prevWge.timeRemaining,
            topic: prevWge.topic,
            debug: prevWge.debug,
            createdAt: prevWge.createdAt
        });

        console.log({
            message: 'Saved previous WGE to history_wge',
            data: prevWge
        });

        await wgeColl.deleteOne({
            _id: prevWge._id
        });
    }

    // Create new WGE
    await wgeColl.insertOne({
        assignedUser: assignedUser.id,
        assigningUser: assigningUser.id,

        startedAt: Date.now(),
        timeRemaining: defaultAssignedTime,

        state: 'running',

        notifications: {
            half: false,
            day24: false,
            complete: false
        },

        topic,
        debug: false,

        createdAt: new Date()
    });

    return interaction.reply({
        content: `<@${assignedUser.id}> is the next expert! Their topic is **${topic}**`
    });
}