Emojis in async results threads; allow setting packet name for bulk playtesting; bulk playtesting reacts per-packet indexing; auto-add users to thread based on category roles; fix various other issues

package.json

@@ -12,9 +12,9 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "better-sqlite3": "^8.4.0",
-    "crypto": "^1.0.1",
-    "discord.js": "14.16.0",
+    "better-sqlite3": "^11.7.0",
+    "discord.js": "^14.16.3",
+    "ts-node": "^10.9.2",
     "dotenv": "^16.3.1",
     "radash": "^11.0.0"
   },

src/bot.ts

@@ -1,52 +1,135 @@
-import { Client, GatewayIntentBits, Partials, ChannelType, Interaction } from 'discord.js';
+import { Client, GatewayIntentBits, Partials, ChannelType, Interaction, TextChannel } from "discord.js";
 import { config } from "./config";
-import handleTossupPlaytest from './handlers/tossupHandler';
-import handleBonusPlaytest from './handlers/bonusHandler';
-import handleNewQuestion from './handlers/newQuestionHandler';
-import handleConfig from './handlers/configHandler';
-import handleButtonClick from './handlers/buttonClickHandler';
-import handleCategoryCommand from './handlers/categoryCommandHandler';
-import { QuestionType, UserBonusProgress, UserProgress, UserTossupProgress } from './utils';
-import handleAuthorCommand from './handlers/authorCommandHandler';
+import handleTossupPlaytest from "./handlers/tossupHandler";
+import handleBonusPlaytest from "./handlers/bonusHandler";
+import handleNewQuestion from "./handlers/newQuestionHandler";
+import handleConfig from "./handlers/configHandler";
+import handleButtonClick from "./handlers/buttonClickHandler";
+import handleCategoryCommand from "./handlers/categoryCommandHandler";
+import handleTally from "./handlers/bulkQuestionHandler";
+import { QuestionType, UserBonusProgress, UserProgress, UserTossupProgress, getBulkQuestions, getBulkQuestionsInPacket, getServerChannels, getServerSettings, updatePacketName } from "./utils";
+import handleAuthorCommand from "./handlers/authorCommandHandler";
 
 const userProgressMap = new Map<string, UserProgress>();
 
+const packetCommands = ["packet", "round", "read", "end"];
+const tallyCommands = ["tally", "count", "end"];
+
 export const client = new Client({
     intents: [
         GatewayIntentBits.Guilds,
         GatewayIntentBits.GuildMessages,
         GatewayIntentBits.MessageContent,
-        GatewayIntentBits.DirectMessages
+        GatewayIntentBits.DirectMessages,
+        GatewayIntentBits.GuildMembers,
+        GatewayIntentBits.GuildMessageReactions
     ],
     partials: [
         Partials.Channel,
-        Partials.Message
+        Partials.Message,
+        Partials.Reaction
     ],
     allowedMentions: {
         parse: []
     }
 });
 
-client.once('ready', () => {
+client.once("ready", () => {
     console.log(`Logged in as ${client.user?.tag}`);
 });
 
-client.on('messageCreate', async (message) => {
+client.on("messageCreate", async (message) => {
     try {
         if (message.author.id === config.DISCORD_APPLICATION_ID)
             return;
-
-        if (message.content === '!config') {
+        if (message.content.startsWith("!config")) {
             await handleConfig(message);
-        } else if (message.content === '!category') {
+        } else if ([...packetCommands, ...tallyCommands].some(v => message.content.startsWith("!" + v))) {
+            let currentServerSetting = getServerSettings(message.guild!.id).find(ss => ss.server_id == message.guild!.id);
+            let currentPacket = currentServerSetting?.packet_name;
+            if (tallyCommands.some(v => message.content.startsWith("!" + v))) {
+                let currentServerSetting = getServerSettings(message.guild!.id).find(ss => ss.server_id == message.guild!.id);
+                let currentPacket = currentServerSetting?.packet_name;
+                let splits = message.content.split(" ");
+                if (splits.length > 1) {
+                    let desiredPacketCommand = splits.slice(-1)[0];
+                    if (desiredPacketCommand) {
+                        if (desiredPacketCommand.includes("all")) {
+                            [...new Set(getBulkQuestions(message.guild!.id).map(u => u.packet_name))].forEach(async packet => {
+                                let desiredPacketBulkQuestions = getBulkQuestionsInPacket(message.guild!.id, packet);
+                                if (desiredPacketBulkQuestions) {
+                                    await handleTally(message.guild!.id, packet, message);
+                                } else {
+                                    message.reply(`No questions in packet ${packet} yet.`);
+                                }
+                            });
+                        } else {
+                            let desiredPacket = desiredPacketCommand.trim().substring(0, 2);
+                            let desiredPacketBulkQuestions = getBulkQuestionsInPacket(message.guild!.id, desiredPacket);
+                            if (desiredPacketBulkQuestions) {
+                                await handleTally(message.guild!.id, desiredPacket, message);
+                            } else {
+                                message.reply(`No questions in packet ${desiredPacket} yet.`);
+                            }
+                        }
+                    } else {
+                        message.reply("Invalid packet name.");
+                    }
+                } else {
+                    if (currentPacket) {
+                        await handleTally(message.guild!.id, currentPacket, message);
+                    } else {
+                        message.reply("Packet not configured yet.");
+                    }
+                }
+            }
+            if (packetCommands.some(v => message.content.startsWith("!" + v))) {
+                let splits = message.content.split(" ");
+                let endPacket = message.content.startsWith("!end");
+                if (splits.length > 1 || endPacket) {
+                    let desiredPacketCommand = splits.slice(-1)[0];
+                    if (desiredPacketCommand || endPacket) {
+                        if (desiredPacketCommand.includes("reset") || desiredPacketCommand.includes("clear") || endPacket) {
+                            updatePacketName(message.guild!.id, "");
+                            message.reply(`Packet ${endPacket ? "finished" : "cleared"}.`);
+                        } else {
+                            let desiredPacket = desiredPacketCommand.trim().substring(0, 2);
+                            let newPacketName = updatePacketName(message.guild!.id, desiredPacket);
+                            message.reply(`Now reading packet ${newPacketName}.`);
+                            const echoChannelId = getServerChannels(message.guild!.id).find(c => (c.channel_type === 3))?.channel_id;
+                            if (echoChannelId) {
+                                const echoChannel = (client.channels.cache.get(echoChannelId) as TextChannel);
+                                echoChannel.send(`# Packet ${newPacketName}`);
+                            }
+                        }
+                    } else {
+                        if (message.content.startsWith("!packet") || message.content.startsWith("!round")) {
+                            if (currentPacket) {
+                                message.reply(`The current packet is ${currentPacket}.`);
+                            } else {
+                                message.reply("Packet not configured yet.");
+                            }
+                        }
+                    }
+                } else {
+                    if (message.content.startsWith("!packet") || message.content.startsWith("!round")) {
+                        if (currentPacket) {
+                            message.reply(`The current packet is ${currentPacket}.`);
+                        } else {
+                            message.reply("Packet not configured yet.");
+                        }
+                    }
+                }
+            }
+        } else if (message.content.startsWith("!category")) {
             await handleCategoryCommand(message);
-        } else if (message.content === '!author') {
+        } else if (message.content.startsWith("!author")) {
             await handleAuthorCommand(message);
         } else {
             let setUserProgress = userProgressMap.set.bind(userProgressMap);
             let deleteUserProgress = userProgressMap.delete.bind(userProgressMap);
 
-            if (message.channel.type !== ChannelType.DM && message.content.includes('ANSWER:')) {
+            if (message.channel.type !== ChannelType.DM && message.content.includes("ANSWER:")) {
                 await handleNewQuestion(message);
             } else if (message.channel.type === ChannelType.DM) {
                 let userProgress = userProgressMap.get(message.author.id)
@@ -63,7 +146,7 @@ client.on('messageCreate', async (message) => {
     }
 });
 
-client.on('interactionCreate', async (interaction: Interaction) => {
+client.on("interactionCreate", async (interaction: Interaction) => {
     try {
         await handleButtonClick(interaction, userProgressMap, userProgressMap.set.bind(userProgressMap));
     } catch (e) {

src/constants/index.ts

@@ -4,4 +4,7 @@ export const BONUS_DIFFICULTY_REGEX = /.*\[10(?:\|\|)?(\w{1})(?:\|\|)?\].*/;
 export const SECRET_ROLE = "secret";
 
 export const CATEGORY = 'category';
-export const AUTHOR = 'author';
+export const AUTHOR = 'author';
+
+export const asyncCharLimit = 60;
+export const bulkCharLimit = 35;

src/handlers/bonusHandler.ts

@@ -1,40 +1,67 @@
 import { Client, Message, TextChannel } from "discord.js";
+import { asyncCharLimit } from "src/constants";
 import KeySingleton from "src/services/keySingleton";
-import { UserBonusProgress, getEmbeddedMessage, getServerChannels, getSilentMessage, getThreadAndUpdateSummary, getToFirstIndicator, removeBonusValue, removeSpoilers, saveBonusDirect, shortenAnswerline } from "src/utils";
+import { UserBonusProgress, getEmbeddedMessage, getServerChannels, getSilentMessage, getResultsThreadAndUpdateSummary, getToFirstIndicator, removeQuestionNumber, removeBonusValue, removeSpoilers, saveBonusDirect, shortenAnswerline, cleanThreadName, stripFormatting } from "src/utils";
+import { getEmojiList } from "src/utils/emojis";
 
 export default async function handleBonusPlaytest(message: Message<boolean>, client: Client<boolean>, userProgress: UserBonusProgress, setUserProgress: (key: any, value: any) => void, deleteUserProgress: (key: any) => void) {
-    let validGradingResponse = userProgress.grade && (message.content.toLowerCase().startsWith('y') || message.content.toLowerCase().startsWith('n'));
+    let validGradingResponse = userProgress.grade && (message.content.toLowerCase().startsWith("y") || message.content.toLowerCase().startsWith("n"));
 
-    if (message.content.toLowerCase().startsWith('x')) {
+    if (message.content.toLowerCase().startsWith("x")) {
         deleteUserProgress(message.author.id);
         await message.author.send(getEmbeddedMessage("Ended bonus reading.", true));
 
         return;
     }
 
-    if (!userProgress.grade && (message.content.toLowerCase().startsWith('d') || message.content.toLowerCase().startsWith('p'))) {
+    if (message.content.toLowerCase().startsWith("u") && userProgress.index < userProgress.parts.length) {
+        let index: number;
+        if (userProgress.grade) {
+            index = userProgress.index;
+        } else {
+            index = userProgress.index - 1;
+        }
+        if (userProgress.grade || userProgress.index > 0) {
+            setUserProgress(message.author.id, {
+                ...userProgress,
+                grade: false,
+                index,
+                results: userProgress.results.filter(n => n.note.index !== index)
+            });
+
+            let partToShow = removeBonusValue(removeSpoilers(userProgress.parts[index] || ""));
+            if (index === 0) {
+                partToShow = removeBonusValue(removeSpoilers(userProgress.leadin || "")) + "\n" + partToShow;
+            }
+            await message.author.send(getSilentMessage(partToShow));
+        } else {
+            await message.author.send(getEmbeddedMessage("You can't go back; this was the first bonus part.", true));
+        }
+    }
+
+    if (!userProgress.grade && (message.content.toLowerCase().startsWith("d") || message.content.toLowerCase().startsWith("p"))) {
         await message.author.send(getSilentMessage(`ANSWER: ${removeSpoilers(userProgress.answers![userProgress.index])}`));
     }
 
-    if (!userProgress.grade && message.content.toLowerCase().startsWith('d')) {
+    if (!userProgress.grade && message.content.toLowerCase().startsWith("d")) {
         setUserProgress(message.author.id, {
             ...userProgress,
             grade: true
         });
 
-        await message.author.send(getEmbeddedMessage("Were you correct? Type `y`/`yes` or `n`/`no`. If you'd like to indicate your answer, you can put it in parenthesis at the end of your message, e.g. `y (foo)`", true));
+        await message.author.send(getEmbeddedMessage("Were you correct? Type `y`/`yes` or `n`/`no`. To indicate your answer, you can put it in parentheses at the end of your message - e.g. `y (foo)`. To undo your direct, type `u`/`undo`.", true));
     }
 
-    if (validGradingResponse || (!userProgress.grade && message.content.toLowerCase().startsWith('p'))) {
+    if (validGradingResponse || (!userProgress.grade && message.content.toLowerCase().startsWith("p"))) {
+        const index = userProgress.index + 1;
         const note = message.content.match(/\((.+)\)/);
         const results = [
             ...userProgress.results, {
-                points: message.content.toLowerCase().startsWith('y') ? 10 : 0,
-                passed: message.content.toLowerCase().startsWith('p'),
-                note: note ? note[1] : null
+                points: message.content.toLowerCase().startsWith("y") ? 10 : 0,
+                passed: message.content.toLowerCase().startsWith("p"),
+                note: note ? {text: note[1], index: userProgress.index} : {text: null, index: userProgress.index}
             }
         ];
-        const index = userProgress.index + 1;
 
         setUserProgress(message.author.id, {
             ...userProgress,
@@ -43,20 +70,20 @@ export default async function handleBonusPlaytest(message: Message<boolean>, cli
             results
         });
 
-        if (userProgress.parts.length > index) {
-            await message.author.send(getSilentMessage(removeBonusValue(removeSpoilers(userProgress.parts[index] || ''))));
+        if (index < userProgress.parts.length) {
+            await message.author.send(getSilentMessage(removeBonusValue(removeSpoilers(userProgress.parts[index] || ""))));
         } else {
             const key = KeySingleton.getInstance().getKey(message);
             const resultChannel = getServerChannels(userProgress.serverId).find(s => (s.channel_id === userProgress.channelId && s.channel_type === 1));
-            let resultMessage = ``;
+            let resultMessage = "";
             let points_emoji_names: string[] = [];
-            let emoji_summary: string[] = [];
             let partMessages: string[] = [];
             let totalPoints = 0;
+            let answer_emoji = (await getEmojiList(["answer"]))[0] || "answer:";
 
-            results.forEach(async function(r: any, i: number) {
+            results.forEach(async function (r: any, i: number) {
                 let answer = shortenAnswerline(userProgress.answers[i]);
-                let partMessage = '';
+                let partMessage = "";
                 var points_emoji_name = "";
 
                 if (r.points > 0) {
@@ -73,40 +100,33 @@ export default async function handleBonusPlaytest(message: Message<boolean>, cli
                 points_emoji_name += userProgress.difficulties[i]?.toUpperCase()
 
                 points_emoji_names.push(points_emoji_name);
-                partMessage += (r.note ? ` (answer: "||${r.note}||")` : '');
+                partMessage += (r.note?.text ? ` (${answer_emoji} "||${r.note.text}||")` : "");
                 partMessages.push(partMessage);
-                saveBonusDirect(userProgress.serverId, userProgress.questionId, userProgress.authorId, message.author.id, i + 1, r.points, r.note, key);
+                saveBonusDirect(userProgress.serverId, userProgress.questionId, userProgress.posterId, message.author.id, i + 1, r.points, r.note?.text || null, key);
             });
 
-            await client.application?.emojis.fetch().then(function(emojis) {
-                try {
-                    points_emoji_names.forEach(function(points_emoji_name) {
-                        // console.log(`Searching for emoji: ${points_emoji_name}`);
-                        var points_emoji = emojis.find(emoji => emoji.name === points_emoji_name);
-                        // console.log(`Found emoji: ${points_emoji}`);
-                        if (points_emoji) {
-                            emoji_summary.push(`${points_emoji}`);
-                        }
-                    });
-                } catch (error) {
-                    console.error("One or more of the bonus points emojis failed to fetch:", error);
-                }
-            });
+            let emoji_summary = await getEmojiList(points_emoji_names);
 
-            resultMessage += emoji_summary.join(' ');
-            resultMessage += ` <@${message.author.id}> scored ${totalPoints} points: `;
-            resultMessage += partMessages.join(', ');
+            resultMessage += emoji_summary.join(" ");
+            resultMessage += ` ${totalPoints} <@${message.author.id}> `;
+            resultMessage += partMessages.join(", ");
 
-            const threadName = `B | ${userProgress.authorName} | "${getToFirstIndicator(userProgress.leadin)}"`;
+            const fallbackName = cleanThreadName(getToFirstIndicator(stripFormatting(removeQuestionNumber(userProgress.leadin)), asyncCharLimit));
+            const threadName = `B | ${userProgress?.authorName || userProgress?.posterName || ""} | ${fallbackName}`;
             const resultsChannel = client.channels.cache.get(resultChannel!.result_channel_id) as TextChannel;
             const playtestingChannel = client.channels.cache.get(userProgress.channelId) as TextChannel;
-            const thread = await getThreadAndUpdateSummary(userProgress, threadName.slice(0, 100), resultsChannel, playtestingChannel);
+            const thread = await getResultsThreadAndUpdateSummary(userProgress, threadName.replaceAll(/\s\s+/g, " ").trim().slice(0, 100), resultsChannel, playtestingChannel);
 
             await thread.send(resultMessage);
 
             deleteUserProgress(message.author.id);
 
-            await message.author.send(getEmbeddedMessage(`Your result has been sent to <#${thread.id}>.`, true));
+            await message.author.send(getEmbeddedMessage(`Your result has been sent to this thread: <#${thread.id}>.`, true));
+
+            const questionMessage = await playtestingChannel.messages.fetch(userProgress.questionId);
+            if (questionMessage.hasThread) {
+                await message.author.send(getEmbeddedMessage(`See the discussion thread: <#${questionMessage?.thread?.id}>.`, true));
+            }
         }
     }
 }