(tickets): Implement on close-mod-ticket button.

This applies to both tickets closed manually & tickets closed after 5 days of inactivity.

.gitignore

@@ -1,9 +1,5 @@
-# Directories
-certs/
-data/
-dist/
-node_modules/
-
-# Files
-.DS_Store
+node_modules
+dist
+data/*
 .env
+certs/*

sql/migrations/0006-remove-devwatch-role.sql

@@ -1,9 +0,0 @@
---------------------------------------------------------------------------------
--- Up
---------------------------------------------------------------------------------
-ALTER TABLE settings DROP COLUMN devwatch_role_id;
-
---------------------------------------------------------------------------------
--- Down
---------------------------------------------------------------------------------
-ALTER TABLE settings ADD devwatch_role_id TEXT;

src/buttons/claim-ticket.ts

@@ -0,0 +1,40 @@
+import { ActionRowBuilder, ButtonBuilder, ButtonInteraction, ButtonStyle, ChannelType, Client, MessageFlags, PermissionFlagsBits } from 'discord.js';
+import { Database } from '../shared/Database';
+
+export default {
+  name: 'claim-ticket',
+  handler: async function (client: Client, interaction: ButtonInteraction) {
+    const channel = await interaction.channel?.fetch();
+
+    if (!channel || !channel.isThread() || !channel.isSendable() || channel.type != ChannelType.PrivateThread)
+      return interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'Oops. Something went wrong.' });
+
+    if (!interaction.memberPermissions) return interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'An error has occurred.' });
+
+    if (!interaction.memberPermissions.has(PermissionFlagsBits.ManageMessages)) return interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'You do not have permission to claim tickets.' });
+
+    const guild = await client.guilds.fetch(interaction.guildId!);
+
+    const settings = await Database.getOrCreateSettings(guild.id);
+    if (!settings.private_help_role_id) return interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'Failed to claim ticket.' });
+
+    const closeButton = new ButtonBuilder()
+      .setCustomId('close-ticket')
+      .setLabel('Click here if you no longer need help')
+      .setStyle(ButtonStyle.Danger);
+
+    const unclaimButton = new ButtonBuilder()
+      .setCustomId('unclaim-ticket')
+      .setLabel('Unclaim ticket')
+      .setStyle(ButtonStyle.Primary);
+
+    const row = new ActionRowBuilder<ButtonBuilder>().addComponents(closeButton, unclaimButton);
+
+    await interaction.message.edit({
+      content: `${interaction.message.content}\n\nClaimed by: ${interaction.user}`,
+      components: [row]
+    });
+
+    await interaction.reply({ content: `Ticket claimed by ${interaction.user}.` });
+  }
+};

src/buttons/claimTicket.ts

@@ -1,52 +0,0 @@
-import { ActionRowBuilder, ButtonBuilder, ButtonInteraction, ButtonStyle, ChannelType, Client, MessageFlags, PermissionFlagsBits } from 'discord.js';
-import { Button } from '../types';
-import { SetSeverity } from '../utils';
-
-class ClaimTicketButton implements Button<Client> {
-  id = 'claim-ticket';
-
-  async execute(context: Client<boolean>, interaction: ButtonInteraction): Promise<void> {
-    if (!interaction.inGuild()) return;
-    await interaction.deferReply({ flags: [MessageFlags.Ephemeral] });
-
-    try {
-      const channel = await context.channels.fetch(interaction.channelId);
-
-      if (!channel) throw new Error("The interaction channel couldn't be fetched.");
-      if (!channel.isThread() || channel.type != ChannelType.PrivateThread) throw new Error('This interaction was not run in a ticket thread.');
-      if (!channel.isSendable()) throw new Error("I don't have permission to send messages in this channel.");
-
-      if (!interaction.memberPermissions.has(PermissionFlagsBits.ManageMessages)) throw new Error("You don't have permission to claim tickets.");
-
-      const closeButton = new ButtonBuilder()
-        .setCustomId('close-ticket')
-        .setLabel('Click here if you no longer need help')
-        .setStyle(ButtonStyle.Danger);
-
-      const unclaimButton = new ButtonBuilder()
-        .setCustomId('unclaim-ticket')
-        .setLabel('Unclaim ticket')
-        .setStyle(ButtonStyle.Primary);
-
-      const row = new ActionRowBuilder<ButtonBuilder>().addComponents(closeButton, unclaimButton);
-
-      await interaction.message.edit({
-        content: `${interaction.message.content}\n\nClaimed by: ${interaction.user}`,
-        components: [row]
-      });
-
-      await channel.send({
-        embeds: [{
-          ...SetSeverity('success'),
-          description: `This ticket has been claimed by ${interaction.user}.`
-        }],
-      });
-
-      await interaction.editReply({ content: "You've claimed this ticket." });
-    } catch (error: Error | any) {
-      await interaction.editReply({ content: error.message }).catch(() => {});
-    }
-  }
-}
-
-export default new ClaimTicketButton();

src/buttons/close-mod-ticket.ts

@@ -0,0 +1,28 @@
+import { ButtonInteraction, Client, MessageFlags, ChannelType, PermissionFlagsBits } from 'discord.js';
+import { closeTicket } from '../utils';
+
+export default {
+  name: 'close-mod-ticket',
+  handler: async function (client: Client, interaction: ButtonInteraction) {
+    await interaction.deferReply({ flags: [MessageFlags.Ephemeral] });
+    const channel = await interaction.channel?.fetch();
+    const guild = await interaction.guild?.fetch();
+    const member = await guild?.members.fetch(interaction.user.id);
+
+    if (!channel || !channel.isThread() || !channel.isSendable() || channel.type != ChannelType.PrivateThread || !member)
+      return interaction.editReply({ content: 'Oops. Something went wrong. Please report this to a staff member.' });
+
+    if (!member.permissions.has(PermissionFlagsBits.KickMembers))
+      return interaction.editReply({ content: 'Only staff members may close mod tickets.' });
+
+    await interaction.message.edit({
+      content: interaction.message.content,
+      components: []
+    });
+
+    if (!await closeTicket(client, channel, `This ticket has been closed by staff.`))
+      return await interaction.editReply({ content: 'An error occurred while trying to close this ticket.' });
+
+    await interaction.editReply({ content: 'Ticket closed.' });
+  }
+};

src/buttons/close-ticket.ts

@@ -0,0 +1,26 @@
+import { ButtonInteraction, Client, MessageFlags, ChannelType } from 'discord.js';
+import { closeTicket } from '../utils';
+
+export default {
+  name: 'close-ticket',
+  handler: async function (client: Client, interaction: ButtonInteraction) {
+    const channel = await interaction.channel?.fetch();
+    if (!channel || !channel.isThread() || !channel.isSendable() || channel.type != ChannelType.PrivateThread)
+      return await interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'Oops. Something went wrong. Please report this to a staff member.' });
+
+    await interaction.reply({
+      content: 'Closing, please wait...',
+      flags: MessageFlags.Ephemeral
+    });
+
+    await interaction.message.edit({
+      content: interaction.message.content,
+      components: []
+    });
+
+    if (!await closeTicket(client, channel, `This ticket has been closed by ${interaction.user}`))
+      return await interaction.editReply({ content: 'An error occurred while trying to close this ticket.' });
+
+    await interaction.editReply({ content: 'Ticket closed.' });
+  }
+};

src/buttons/closeModTicket.ts

@@ -1,38 +0,0 @@
-import { ButtonInteraction, Client, MessageFlags, ChannelType } from 'discord.js';
-import { Button } from '../types';
-import { closeTicket } from '../utils';
-
-class CloseModTicketButton implements Button<Client> {
-  id = 'close-mod-ticket';
-
-  async execute(context: Client<boolean>, interaction: ButtonInteraction): Promise<void> {
-    if (!interaction.inGuild()) return;
-    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
-
-    try {
-      const channel = await context.channels.fetch(interaction.channelId);
-
-      if (!channel) throw new Error("The interaction channel couldn't be fetched.");
-      if (!channel.isThread() || channel.type != ChannelType.PrivateThread) throw new Error('This interaction was not run in a ticket thread.');
-      if (!channel.isSendable()) throw new Error("I don't have permission to send messages in this channel.");
-
-      if (!interaction.memberPermissions.has('KickMembers')) throw new Error("You don't have permission to close this ticket.");
-
-      await interaction.message.edit({
-        content: interaction.message.content,
-        components: []
-      });
-
-      if (!await closeTicket(context, channel, 'This ticket has been closed by staff.')) {
-        await interaction.editReply({ content: 'An error occurred while trying to close this ticket.' });
-        return;
-      }
-
-      await interaction.editReply({ content: 'Ticket closed.' });
-    } catch (error: Error | any) {
-      await interaction.editReply({ content: error.message }).catch(() => {});
-    }
-  }
-}
-
-export default new CloseModTicketButton();

src/buttons/closeTicket.ts

@@ -1,38 +0,0 @@
-import { ButtonInteraction, Client, MessageFlags, ChannelType } from 'discord.js';
-import { Button } from '../types';
-import { closeTicket } from '../utils';
-
-class CloseTicketButton implements Button<Client> {
-  id = 'close-ticket';
-
-  async execute(context: Client<boolean>, interaction: ButtonInteraction): Promise<void> {
-    if (!interaction.inGuild()) return;
-    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
-
-    try {
-      const channel = await context.channels.fetch(interaction.channelId);
-
-      if (!channel) throw new Error("The interaction channel couldn't be fetched.");
-      if (!channel.isThread() || channel.type != ChannelType.PrivateThread) throw new Error('This interaction was not run in a ticket thread.');
-      if (!channel.isSendable()) throw new Error("I don't have permission to send messages in this channel.");
-
-      await interaction.editReply({ content: 'Closing, please wait...' });
-
-      await interaction.message.edit({
-        content: interaction.message.content,
-        components: []
-      });
-
-      if (!await closeTicket(context, channel, `This ticket has been closed by ${interaction.user}`)) {
-        await interaction.editReply({ content: 'An error occurred while trying to close this ticket.' });
-        return;
-      }
-
-      await interaction.editReply({ content: 'Ticket closed.' });
-    } catch (error: Error | any) {
-      await interaction.editReply({ content: error.message }).catch(() => {});
-    }
-  }
-}
-
-export default new CloseTicketButton();

src/buttons/dev-watch.ts

@@ -0,0 +1,32 @@
+import { ButtonInteraction, Client, MessageFlags } from 'discord.js';
+import { Database } from '../shared/Database';
+
+export default {
+  name: 'dev-watch',
+  handler: async function (client: Client, interaction: ButtonInteraction) {
+    try {
+      if (!interaction.guild) throw new Error('This action must be run in a guild.');
+
+      const settings = await Database.getOrCreateSettings(interaction.guild.id);
+      if (!settings.devwatch_role_id) throw new Error('`devwatch_role_id` was not configured. Please configure a role then try again.');
+
+      const member = await interaction.guild.members.fetch(interaction.user.id);
+      if (!member) throw new Error('Unable to retreive the member executing this command.');
+
+      const bot = await interaction.guild.members.fetchMe();
+      const role = await interaction.guild?.roles.fetch(settings.devwatch_role_id);
+      if (!role) throw new Error('The configured `devwatch_role_id` does not exist.');
+      if (role.position > bot.roles.highest.position) throw new Error('The configured `devwatch_role_id` is higher than my highest role.');
+
+      if (member.roles.cache.has(settings.devwatch_role_id)) {
+        await member.roles.remove(settings.devwatch_role_id);
+        await interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'Removed role.' });
+      } else {
+        await member.roles.add(settings.devwatch_role_id);
+        await interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'Added role.' });
+      }
+    } catch (error: Error | any) {
+      await interaction.reply({ flags: [MessageFlags.Ephemeral], content: error.message });
+    }
+  }
+};

src/buttons/devWatch.ts

@@ -1,21 +0,0 @@
-import { ButtonInteraction, Client, MessageFlags } from 'discord.js';
-import { Button } from '../types';
-import { SetSeverity } from '../utils';
-
-class DevWatchButton implements Button<Client> {
-  id = 'dev-watch';
-
-  async execute(context: Client<boolean>, interaction: ButtonInteraction): Promise<void> {
-    if (!interaction.inGuild()) return;
-    await interaction.reply({
-      embeds: [{
-        ...SetSeverity('warning'),
-        description: 'DevWatch roles have been deprecated in favour of the `/role-buttons create` command. Please notify an administrator to setup a new role-button.'
-      }],
-
-      flags: MessageFlags.Ephemeral,
-    });
-  }
-}
-
-export default new DevWatchButton();

src/buttons/index.ts

@@ -1,27 +0,0 @@
-import claimTicket from './claimTicket';
-import closeModTicket from './closeModTicket';
-import closeTicket from './closeTicket';
-import devWatch from './devWatch';
-import noteNext from './noteNext';
-import notePrevious from './notePrevious';
-import openTicketForReportedMessage from './openTicketForReportedMessage';
-import privateHelp from './privateHelp';
-import recordsNext from './recordsNext';
-import recordsPrevious from './recordsPrevious';
-import roleButton from './roleButton';
-import unclaimTicket from './unclaimTicket';
-
-export default [
-  claimTicket,
-  closeModTicket,
-  closeTicket,
-  devWatch,
-  noteNext,
-  notePrevious,
-  openTicketForReportedMessage,
-  privateHelp,
-  recordsNext,
-  recordsPrevious,
-  roleButton,
-  unclaimTicket
-];

src/buttons/note-next.ts

@@ -0,0 +1,15 @@
+import { ButtonInteraction, Client } from 'discord.js';
+import { getNoteMessage } from '../utils';
+
+export default {
+  name: 'note-next',
+  handler: async function (client: Client, interaction: ButtonInteraction, userId: string, page: string) {
+    await interaction.deferUpdate();
+
+    const message = await getNoteMessage(userId, parseInt(page) + 1);
+
+    if (!message) return;
+
+    interaction.editReply(message);
+  }
+};

src/buttons/note-previous.ts

@@ -0,0 +1,15 @@
+import { ButtonInteraction, Client} from 'discord.js';
+import { getNoteMessage } from '../utils';
+
+export default {
+  name: 'note-previous',
+  handler: async function (client: Client, interaction: ButtonInteraction, userId: string, page: string) {
+    await interaction.deferUpdate();
+
+    const message = await getNoteMessage(userId, parseInt(page) - 1);
+
+    if (!message) return;
+
+    interaction.editReply(message);
+  }
+};

src/buttons/noteNext.ts

@@ -1,18 +0,0 @@
-import { ButtonInteraction, Client } from 'discord.js';
-import { Button } from '../types';
-import { getNoteMessage } from '../utils';
-
-class NoteNextButton implements Button<Client> {
-  id = 'note-next';
-
-  async execute(context: Client<boolean>, interaction: ButtonInteraction, userId: string, page: string): Promise<void> {
-    await interaction.deferUpdate();
-
-    const message = await getNoteMessage(userId, parseInt(page) + 1);
-    if (!message) return;
-
-    await interaction.editReply(message);
-  }
-}
-
-export default new NoteNextButton();

src/buttons/notePrevious.ts

@@ -1,18 +0,0 @@
-import { ButtonInteraction, Client } from 'discord.js';
-import { Button } from '../types';
-import { getNoteMessage } from '../utils';
-
-class NotePreviousButton implements Button<Client> {
-  id = 'note-previous';
-
-  async execute(context: Client<boolean>, interaction: ButtonInteraction, userId: string, page: string): Promise<void> {
-    await interaction.deferUpdate();
-
-    const message = await getNoteMessage(userId, parseInt(page) - 1);
-    if (!message) return;
-
-    await interaction.editReply(message);
-  }
-}
-
-export default new NotePreviousButton();

src/buttons/open-ticket-for-reported-message.ts

@@ -0,0 +1,40 @@
+import { ButtonInteraction, Client, MessageFlags, MessageMentions } from 'discord.js';
+import { createPrivateHelpTicketThread } from '../utils';
+
+export default {
+  name: 'open-ticket-for-reported-message',
+  handler: async function (client: Client, interaction: ButtonInteraction) {
+    const message = await interaction.message.fetch();
+    const guild = await interaction.guild!.fetch();
+
+    const reportEmbed = message.embeds[0]!;
+
+    const regex = new RegExp(MessageMentions.UsersPattern);
+
+    const reportedMessageUrl = reportEmbed.fields[0].value;
+    const reporterId = regex.exec(reportEmbed.fields[2].value)!.groups!.id;
+    const additionalInfo = reportEmbed.fields[3]?.name == 'Additional Information' ? reportEmbed.fields[3].value : '';
+
+    const reporter = await guild.members.fetch(reporterId) ?? await client.users.fetch(reporterId);
+
+    const thread = await createPrivateHelpTicketThread(client, guild, null, `Ticket creted by staff in response to message report: ${message.url}. Reported message: ${reportedMessageUrl}. ${additionalInfo ? `\n\nAdditional information provided in report:\n${additionalInfo.split('\n').map(c => `> ${c}`).join('\n')}` : ''}`, `Ticket: Message Report From ${reporter.displayName}`, [reporterId, interaction.user.id]);
+
+    if (thread) {
+      await interaction.reply({
+        flags: [MessageFlags.Ephemeral],
+        content: `Ticket created: ${thread}`
+      });
+
+      const requestIndex = reportEmbed.fields.findIndex(f => f.name == 'User Requested Private Ticket');
+      if (requestIndex != -1) reportEmbed.fields.splice(requestIndex, 1);
+
+      reportEmbed.fields.push({
+        name: 'Private Help Ticket',
+        value: thread.url,
+        inline: false
+      });
+
+      await message.edit({ embeds: [reportEmbed], components: [] });
+    }
+  }
+};

src/buttons/openTicketForReportedMessage.ts

@@ -1,45 +0,0 @@
-import { ButtonInteraction, Client, MessageFlags, MessageMentions } from 'discord.js';
-import { Button } from '../types';
-import { createPrivateHelpTicketThread } from '../utils';
-
-class OpenTicketForReportedMessageButton implements Button<Client> {
-  id = 'open-ticket-for-reported-message';
-
-  async execute(context: Client<boolean>, interaction: ButtonInteraction): Promise<void> {
-    if (!interaction.inGuild()) return;
-    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
-
-    try {
-      const guild = await context.guilds.fetch(interaction.guildId);
-      const message = await interaction.message.fetch();
-
-      const reportEmbed = message.embeds[0]!;
-      const regex = new RegExp(MessageMentions.UsersPattern);
-
-      const reportedMessageUrl = reportEmbed.fields[0].value;
-      const reporterId = regex.exec(reportEmbed.fields[2].value)!.groups!.id;
-      const additionalInfo = reportEmbed.fields[3]?.name == 'Additional Information' ? reportEmbed.fields[3].value : '';
-      const reporter = await guild.members.fetch(reporterId) ?? await context.users.fetch(reporterId);
-
-      const thread = await createPrivateHelpTicketThread(context, guild, null, `Ticket creted by staff in response to message report: ${message.url}. Reported message: ${reportedMessageUrl}. ${additionalInfo ? `\n\nAdditional information provided in report:\n${additionalInfo.split('\n').map(c => `> ${c}`).join('\n')}` : ''}`, `Ticket: Message Report From ${reporter.displayName}`, [reporterId, interaction.user.id]);
-      if (!thread) throw new Error('An error occured and a thread was not created.');
-
-      await interaction.editReply({ content: `Ticket Created: ${thread}` });
-
-      const requestIndex = reportEmbed.fields.findIndex(f => f.name == 'User Requested Private Ticket');
-      if (requestIndex != -1) reportEmbed.fields.splice(requestIndex, 1);
-
-      reportEmbed.fields.push({
-        name: 'Private Help Ticket',
-        value: thread.url,
-        inline: false
-      });
-
-      await message.edit({ embeds: [reportEmbed], components: [] });
-    } catch (error: Error | any) {
-      await interaction.editReply({ content: error.message }).catch(() => {});
-    }
-  }
-}
-
-export default new OpenTicketForReportedMessageButton();

src/buttons/private-help.ts

@@ -0,0 +1,20 @@
+import { ButtonInteraction, Client, ModalBuilder, TextInputStyle, MessageFlags } from 'discord.js';
+import { canOpenPrivateHelpTicket, createTextInput } from '../utils';
+
+export default {
+  name: 'private-help',
+  handler: async function (client: Client, interaction: ButtonInteraction) {
+    if (!(await canOpenPrivateHelpTicket(interaction.user.id)))
+      return interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'You can only have one open ticket at a time that is less than a day old.' });
+
+    const modal = new ModalBuilder()
+      .setCustomId('open-ticket-modal')
+      .setTitle('Get in contact');
+
+    const label = createTextInput('ticket-message', 'What is the reason for your ticket?', null, true, TextInputStyle.Paragraph, 1500, 10);
+
+    modal.addLabelComponents(label);
+
+    await interaction.showModal(modal);
+  }
+};

src/buttons/privateHelp.ts

@@ -1,30 +0,0 @@
-import { ButtonInteraction, Client, ModalBuilder, TextInputStyle, MessageFlags } from 'discord.js';
-import { Button } from '../types';
-import { canOpenPrivateHelpTicket, createTextInput } from '../utils';
-
-class PrivateHelpButton implements Button<Client> {
-  id = 'private-help';
-
-  async execute(context: Client<boolean>, interaction: ButtonInteraction): Promise<void> {
-    try {
-      if (!await canOpenPrivateHelpTicket(interaction.user.id))
-        throw new Error('You can only have one open ticket at a time that is less than a day old.');
-
-      const modal = new ModalBuilder()
-        .setCustomId('open-ticket-modal')
-        .setTitle('Get in contact');
-
-      const label = createTextInput('ticket-message', 'What is the reason for your ticket?', null, true, TextInputStyle.Paragraph, 1500, 10);
-      modal.addLabelComponents(label);
-
-      await interaction.showModal(modal);
-    } catch (error: Error | any) {
-      await interaction.reply({
-        content: error.message,
-        flags: MessageFlags.Ephemeral,
-      }).catch(() => {});
-    }
-  }
-}
-
-export default new PrivateHelpButton();

src/buttons/records-next.ts

@@ -0,0 +1,15 @@
+import { ButtonInteraction, Client } from 'discord.js';
+import { getRecordMessageFromDiscordId } from '../utils';
+
+export default {
+  name: 'records-next',
+  handler: async function (client: Client, interaction: ButtonInteraction, userId: string, page: string) {
+    await interaction.deferUpdate();
+
+    const message = await getRecordMessageFromDiscordId(userId, parseInt(page) + 1, interaction.guild!);
+
+    if (!message) return;
+
+    interaction.editReply(message);
+  }
+};

src/buttons/records-previous.ts

@@ -0,0 +1,15 @@
+import { ButtonInteraction, Client} from 'discord.js';
+import { getRecordMessageFromDiscordId } from '../utils';
+
+export default {
+  name: 'records-previous',
+  handler: async function (client: Client, interaction: ButtonInteraction, userId: string, page: string) {
+    await interaction.deferUpdate();
+
+    const message = await getRecordMessageFromDiscordId(userId, parseInt(page) - 1, interaction.guild!);
+
+    if (!message) return;
+
+    interaction.editReply(message);
+  }
+};

src/buttons/recordsNext.ts

@@ -1,18 +0,0 @@
-import { ButtonInteraction, Client } from 'discord.js';
-import { Button } from '../types';
-import { getRecordMessageFromDiscordId } from '../utils';
-
-class RecordsNextButton implements Button<Client> {
-  id = 'records-next';
-
-  async execute(context: Client<boolean>, interaction: ButtonInteraction, userId: string, page: string): Promise<void> {
-    await interaction.deferUpdate();
-
-    const message = await getRecordMessageFromDiscordId(userId, parseInt(page) + 1, interaction.guild!);
-    if (!message) return;
-
-    await interaction.editReply(message);
-  }
-}
-
-export default new RecordsNextButton();

src/buttons/recordsPrevious.ts

@@ -1,18 +0,0 @@
-import { ButtonInteraction, Client } from 'discord.js';
-import { Button } from '../types';
-import { getRecordMessageFromDiscordId } from '../utils';
-
-class RecordsPreviousButton implements Button<Client> {
-  id = 'records-previous';
-
-  async execute(context: Client<boolean>, interaction: ButtonInteraction, userId: string, page: string): Promise<void> {
-    await interaction.deferUpdate();
-
-    const message = await getRecordMessageFromDiscordId(userId, parseInt(page) - 1, interaction.guild!);
-    if (!message) return;
-
-    await interaction.editReply(message);
-  }
-}
-
-export default new RecordsPreviousButton();

src/buttons/role-button.ts

@@ -0,0 +1,32 @@
+import { ButtonInteraction, Client, MessageFlags } from 'discord.js';
+import { Database } from '../shared/Database';
+
+export default {
+  name: 'role-button',
+  handler: async function (client: Client, interaction: ButtonInteraction) {
+    await interaction.deferReply({ flags: [MessageFlags.Ephemeral] });
+
+    const roleId = await Database.getRoleFromButton(interaction.message.id);
+
+    if (!roleId) await interaction.editReply({ content: 'Could not find role button.' });
+
+    const guild = await interaction.guild?.fetch();
+    const member = await guild?.members.fetch(interaction.user.id);
+
+    if (!member) return interaction.editReply({ content: 'Member not found.' });
+
+    try {
+      if (member.roles.cache.has(roleId!)) {
+        await member.roles.remove(roleId!);
+        interaction.editReply({ content: 'Role removed.' });
+      } else {
+        await member.roles.add(roleId!);
+        interaction.editReply({ content: 'Role added.' });
+      }
+
+    } catch (e) {
+      console.error(e);
+      interaction.editReply({ content: 'Could not add role. Is it higher than mine?' });
+    }
+  }
+};

src/buttons/roleButton.ts

@@ -1,38 +0,0 @@
-import { ButtonInteraction, Client, MessageFlags } from 'discord.js';
-import { Database } from '../shared/Database';
-import { Button } from '../types';
-
-class RoleButtonButton implements Button<Client> {
-  id = 'role-button';
-
-  async execute(context: Client<boolean>, interaction: ButtonInteraction): Promise<void> {
-    if (!interaction.inGuild()) return;
-    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
-
-    try {
-      const roleId = await Database.getRoleFromButton(interaction.message.id);
-      if (!roleId) throw new Error("I couldn't find an associated role ID with this button.");
-
-      const guild = await context.guilds.fetch(interaction.guildId);
-      const member = await guild.members.fetch(interaction.user.id);
-      if (!member) throw new Error('I was unable to fetch you as a member.');
-
-      const bot = await guild.members.fetchMe();
-      const role = await guild.roles.fetch(roleId);
-      if (!role) throw new Error("The configured role for this button doesn't exist.");
-      if (role.position > bot.roles.highest.position) throw new Error(`The configured role (\`${role.name}\`) is higher than my highest role.`);
-
-      if (member.roles.cache.has(roleId)) {
-        await member.roles.remove(roleId);
-        await interaction.editReply({ content: 'Role removed.' });
-      } else {
-        await member.roles.add(roleId);
-        await interaction.editReply({ content: 'Role Added' });
-      }
-    } catch (error: Error | any) {
-      await interaction.editReply({ content: error.message }).catch(() => {});
-    }
-  }
-}
-
-export default new RoleButtonButton();

src/buttons/unclaim-ticket.ts

@@ -0,0 +1,42 @@
+import { ActionRowBuilder, ButtonBuilder, ButtonInteraction, ButtonStyle, ChannelType, Client, MessageFlags, PermissionFlagsBits } from 'discord.js';
+import { Database } from '../shared/Database';
+
+export default {
+  name: 'unclaim-ticket',
+  handler: async function (client: Client, interaction: ButtonInteraction) {
+    const channel = await interaction.channel?.fetch();
+
+    if (!channel || !channel.isThread() || !channel.isSendable() || channel.type != ChannelType.PrivateThread)
+      return interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'Oops. Something went wrong.' });
+
+    if (!interaction.memberPermissions) return interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'An error has occurred.' });
+
+    if (!interaction.memberPermissions.has(PermissionFlagsBits.ManageMessages)) return interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'You do not have permission to unclaim this ticket.' });
+
+    if (!interaction.message.content.split('\n').at(-1)!.includes(`<@${interaction.user.id}>`)) return interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'You did not claim this ticket.' });
+
+    const guild = await client.guilds.fetch(interaction.guildId!);
+
+    const settings = await Database.getOrCreateSettings(guild.id);
+    if (!settings.private_help_role_id) return interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'Failed to unclaim ticket.' });
+
+    const closeButton = new ButtonBuilder()
+      .setCustomId('close-ticket')
+      .setLabel('Click here if you no longer need help')
+      .setStyle(ButtonStyle.Danger);
+
+    const claimButton = new ButtonBuilder()
+      .setCustomId('claim-ticket')
+      .setLabel('Claim ticket')
+      .setStyle(ButtonStyle.Primary);
+
+    const row = new ActionRowBuilder<ButtonBuilder>().addComponents(closeButton, claimButton);
+
+    await interaction.message.edit({
+      content: interaction.message.content.split('\n').slice(0, -1).join('\n').trim(),
+      components: [row]
+    });
+
+    await interaction.reply({ content: 'Ticket unclaimed.', flags: [MessageFlags.Ephemeral] });
+  }
+};

src/buttons/unclaimTicket.ts

@@ -1,54 +0,0 @@
-import { ActionRowBuilder, ButtonBuilder, ButtonInteraction, ButtonStyle, ChannelType, Client, MessageFlags, PermissionFlagsBits } from 'discord.js';
-import { Button } from '../types';
-import { SetSeverity } from '../utils';
-
-class UnclaimTicketButton implements Button<Client> {
-  id = 'unclaim-ticket';
-
-  async execute(context: Client<boolean>, interaction: ButtonInteraction): Promise<void> {
-    if (!interaction.inGuild()) return;
-    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
-
-    try {
-      const channel = await context.channels.fetch(interaction.channelId);
-
-      if (!channel) throw new Error("The interaction channel couldn't be fetched.");
-      if (!channel.isThread() || channel.type != ChannelType.PrivateThread) throw new Error('This interaction was not run in a ticket thread.');
-      if (!channel.isSendable()) throw new Error("I don't have permission to send messages in this channel.");
-
-      if (!interaction.memberPermissions.has(PermissionFlagsBits.ManageMessages)) throw new Error("You don't have permission to unclaim tickets.");
-
-      if (!interaction.message.content.split('\n').at(-1)!.includes(`<@${interaction.user.id}>`)) throw new Error("You haven't claimed this ticket.");
-
-      const closeButton = new ButtonBuilder()
-        .setCustomId('close-ticket')
-        .setLabel('Click here if you no longer need help')
-        .setStyle(ButtonStyle.Danger);
-
-      const claimButton = new ButtonBuilder()
-        .setCustomId('claim-ticket')
-        .setLabel('Claim ticket')
-        .setStyle(ButtonStyle.Primary);
-
-      const row = new ActionRowBuilder<ButtonBuilder>().addComponents(closeButton, claimButton);
-
-      await interaction.message.edit({
-        content: interaction.message.content.split('\n').slice(0, -1).join('\n').trim(),
-        components: [row]
-      });
-
-      await channel.send({
-        embeds: [{
-          ...SetSeverity('warning'),
-          description: 'This ticket has been unclaimed.'
-        }],
-      });
-
-      await interaction.editReply({ content: 'Ticket unclaimed.' });
-    } catch (error: Error | any) {
-      await interaction.editReply({ content: error.message }).catch(() => {});
-    }
-  }
-}
-
-export default new UnclaimTicketButton();

src/commands/devwatch.ts

@@ -0,0 +1,42 @@
+import { ActionRowBuilder, ApplicationIntegrationType, ButtonBuilder, ButtonStyle, ChatInputCommandInteraction, Client, InteractionContextType, MessageFlags, PermissionFlagsBits, SlashCommandBuilder } from 'discord.js';
+
+export default {
+  name: 'devwatch',
+  data: new SlashCommandBuilder()
+    .setName('devwatch')
+    .setDescription('Sends a dev watch role toggle button.')
+    .setIntegrationTypes(ApplicationIntegrationType.GuildInstall)
+    .setContexts(InteractionContextType.Guild)
+    .setDefaultMemberPermissions(PermissionFlagsBits.ManageGuild)
+    .addStringOption(option =>
+      option
+        .setName('content')
+        .setDescription('The content of the message.')
+        .setRequired(false)
+    )
+    .addStringOption(option =>
+      option
+        .setName('button-label')
+        .setDescription('The button label.')
+        .setRequired(false)
+    ),
+  handler: async function (client: Client, interaction: ChatInputCommandInteraction) {
+    if (!interaction.channel || !interaction.channel.isSendable())
+      return interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'Missing permissions to send to channel.' });
+
+    const content = interaction.options.getString('content') ?? '';
+    const label = interaction.options.getString('button-label') ?? 'Toggle DevWatch Role';
+
+    const button = new ButtonBuilder()
+      .setCustomId('dev-watch')
+      .setStyle(ButtonStyle.Primary)
+      .setLabel(label);
+
+    const row = new ActionRowBuilder<ButtonBuilder>()
+      .addComponents(button);
+
+    await interaction.channel.send({ components: [row], content });
+
+    interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'Sent.' });
+  }
+};

src/commands/github-mapping.ts

@@ -1,61 +1,6 @@
 import { ApplicationIntegrationType, ChatInputCommandInteraction, Client, InteractionContextType, MessageFlags, PermissionFlagsBits, SlashCommandBuilder } from 'discord.js';
 import { Database } from '../shared/Database';
-import { getIdFromInput, SetSeverity } from '../utils';
-
-const userRegex = new RegExp(/^\d{16,20}$/);
-
-async function addUserMapping(interaction: ChatInputCommandInteraction) {
-  const githubUsername = interaction.options.getString('github-name', true);
-  const discordId = getIdFromInput(interaction.options.getString('discord-user', true));
-  if (!userRegex.test(discordId)) throw new Error('The provided Discord user ID is invalid.');
-
-  const existingMappingId = await Database.getGithubFromDiscordId(discordId);
-  const existingMappingName = await Database.getDiscordIdFromGithub(githubUsername);
-
-  if (existingMappingId) throw new Error(`<@${discordId}> (${discordId}) is already mapped to \`${existingMappingId}\``);
-  if (existingMappingName) throw new Error(`\`${githubUsername}\` is already mapped to <@${existingMappingName}> (${existingMappingName})`);
-
-  await Database.putGithubUserMapping(discordId, githubUsername);
-
-  await interaction.editReply({
-    embeds: [{
-      ...SetSeverity('success'),
-
-      title: 'GitHub/Discord Mapping | Add',
-      description: `\`${githubUsername}\` has been linked to <@${discordId}>`,
-    }],
-  });
-}
-
-async function removeUserMapping(interaction: ChatInputCommandInteraction) {
-  const discordId = getIdFromInput(interaction.options.getString('discord-user', true));
-  if (!userRegex.test(discordId)) throw new Error('The provided Discord user ID is invalid.');
-
-  if (!await Database.removeGithubUserMapping(discordId)) throw new Error('No existing GitHub mapping was found.');
-
-  await interaction.editReply({
-    embeds: [{
-      ...SetSeverity('success'),
-
-      title: 'GitHub/Discord Mapping | Remove',
-      description: `<@${discordId}> is no longer linked.`,
-    }],
-  });
-}
-
-async function listUserMapping(interaction: ChatInputCommandInteraction) {
-  const allMappings = await Database.getAllGithubUserMappings();
-  if (allMappings.length < 1) throw new Error('No GitHub mappings have been configured.');
-
-  await interaction.editReply({
-    embeds: [{
-      ...SetSeverity('success'),
-
-      title: 'GitHub/Discord Mapping | List',
-      description: allMappings.map(m => `- <@${m.discord_id}> (${m.discord_id}) - ${m.github_username}`).join('\n'),
-    }]
-  });
-}
+import { getIdFromInput } from '../utils';
 
 export default {
   name: 'github-mapping',
@@ -99,17 +44,37 @@ export default {
         .setDescription('List all github-discord mappings.')
     ),
   handler: async function (client: Client, interaction: ChatInputCommandInteraction) {
-    if (!interaction.inGuild()) return;
-    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
+    await interaction.deferReply({ flags: [MessageFlags.Ephemeral] });
 
-    try {
-      switch (interaction.options.getSubcommand(true)) {
-        case 'add': return await addUserMapping(interaction);
-        case 'remove': return await removeUserMapping(interaction);
-        case 'list': return await listUserMapping(interaction);
-      }
-    } catch (error: Error | any) {
-      await interaction.editReply({ content: error.message }).catch(() => {});
+    const subcommand = await interaction.options.getSubcommand(true);
+
+    if (subcommand == 'add') {
+      const discordUserInput = interaction.options.getString('discord-user', true);
+
+      const idToUse = getIdFromInput(discordUserInput);
+
+      const githubName = interaction.options.getString('github-name', true);
+
+      const existingMappingId = await Database.getGithubFromDiscordId(idToUse);
+      const existingMappingName = await Database.getDiscordIdFromGithub(githubName);
+
+      if (existingMappingId) return interaction.editReply(`Discord user id is already mapped to ${existingMappingId}`);
+      if (existingMappingName) return interaction.editReply(`Github username is already mapped to <@${existingMappingName}> (${existingMappingName})`);
+
+      Database.putGithubUserMapping(idToUse, githubName);
+
+      return interaction.editReply('Mapping added.');
+    } else if (subcommand == 'remove') {
+      const discordUserInput = interaction.options.getString('discord-user', true);
+
+      const idToUse = getIdFromInput(discordUserInput);
+
+      Database.removeGithubUserMapping(idToUse);
+      return interaction.editReply('Mapping removed.');
+    } else if (subcommand == 'list') {
+      const allMappings = await Database.getAllGithubUserMappings();
+
+      return interaction.editReply(allMappings.map(m => `- <@${m.discord_id}> (${m.discord_id}) - ${m.github_username}`).join('\n'));
     }
   }
 };

src/commands/settings.ts

@@ -75,7 +75,12 @@ export default {
         .setDescription('Set the private helper role.')
         .setRequired(false)
     )
-
+    .addRoleOption(option =>
+      option
+        .setName('devwatch-role')
+        .setDescription('Set the DevWatch role.')
+        .setRequired(false)
+    )
     .addChannelOption(option =>
       option
         .setName('add-staff-category')
@@ -184,7 +189,7 @@ export default {
     const moderatorChannel = interaction.options.getChannel('moderator-channel');
     if (moderatorChannel) {
       await Database.updateSettings(interaction.guildId, 'moderator_channel_id', moderatorChannel.id);
-      response.push(`**moderator_channel_id** has been set to: ${moderatorChannel}.`);
+      response.push(`**moderator_channel_id** has been set to": ${moderatorChannel}.`);
     }
 
     const adminRole = interaction.options.getRole('admin-role');
@@ -199,6 +204,12 @@ export default {
       response.push(`**private_help_role_id** has been set to: ${privateHelperRole}.`);
     }
 
+    const devWatchRole = interaction.options.getRole('devwatch-role');
+    if (devWatchRole) {
+      await Database.updateSettings(interaction.guildId, 'devwatch_role_id', devWatchRole.id);
+      response.push(`**devwatch_role_id** has been set to ${devWatchRole}.`);
+    }
+
     const addCategory = interaction.options.getChannel('add-staff-category');
     if (addCategory) {
       if (addCategory.type == ChannelType.GuildCategory) {

src/context-menus/report.ts

@@ -1,4 +1,5 @@
-import { ApplicationCommandType, ApplicationIntegrationType, CheckboxBuilder, Client, ContextMenuCommandBuilder, InteractionContextType, LabelBuilder, MessageContextMenuCommandInteraction, MessageFlags, ModalBuilder, TextInputBuilder, TextInputStyle } from 'discord.js';
+import { ApplicationCommandType, ApplicationIntegrationType, Client, ContextMenuCommandBuilder, InteractionContextType, LabelBuilder, MessageContextMenuCommandInteraction, MessageFlags, ModalBuilder, StringSelectMenuBuilder, StringSelectMenuOptionBuilder, TextInputBuilder, TextInputStyle } from 'discord.js';
+
 import { Database } from '../shared/Database';
 
 export default {
@@ -27,13 +28,24 @@ export default {
         .setDescription('Any additional information? This will help staff understand your report. 1000 characters maximum.')
         .setTextInputComponent(additionalInfoInput);
 
-      const createTicketCheckbox = new CheckboxBuilder()
-        .setCustomId('create-private-help-ticket');
+      const yesNoMenu = new StringSelectMenuBuilder()
+        .setCustomId('create-private-help-ticket')
+        .setRequired(false)
+        .addOptions(
+          new StringSelectMenuOptionBuilder()
+            .setLabel('No')
+            .setDefault(true)
+            .setValue('no'),
+          new StringSelectMenuOptionBuilder()
+            .setLabel('Yes')
+            .setDefault(false)
+            .setValue('yes')
+        );
 
       const createPrivateTicket = new LabelBuilder()
         .setLabel('Create Private Help Ticket')
         .setDescription('Should a private help ticket be opened with this report? (Does not bypass ticket restrictions)')
-        .setCheckboxComponent(createTicketCheckbox);
+        .setStringSelectMenuComponent(yesNoMenu);
 
       modal.addLabelComponents(additionalInfoLabel, createPrivateTicket);
 

src/events/guild/guildCreate.ts

@@ -1,5 +1,4 @@
 import { Client, Guild } from 'discord.js';
-import { config } from '../../config';
 import { Database } from '../../shared/Database';
 import { Event } from '../../types';
 
@@ -7,11 +6,6 @@ class GuildCreateEvent implements Event<Client, 'guildCreate'> {
   event = 'guildCreate' as const;
 
   async execute(context: Client<boolean>, guild: Guild): Promise<void> {
-    if (guild.id != config.DISCORD_GUILD_ID) {
-      await guild.leave();
-      return;
-    }
-
     await Database.getOrCreateSettings(guild.id);
   }
 }

src/index.ts

@@ -1,8 +1,6 @@
-import { ButtonInteraction, Client, GatewayIntentBits, MessageFlags, ModalSubmitInteraction, Partials } from 'discord.js';
-import buttons from './buttons';
+import { Client, GatewayIntentBits, MessageFlags, Partials } from 'discord.js';
 import { config } from './config';
 import events from './events';
-import modals from './modals';
 import { Database } from './shared/Database';
 import { openRedisClient } from './shared/RedisClient';
 import { Handler } from './types';
@@ -39,6 +37,8 @@ const client = new Client({
 
 const commands: Handler[] = [];
 const contextMenus: Handler[] = [];
+const buttons: Handler[] = [];
+const modals: Handler[] = [];
 const menus: Handler[] = [];
 
 // Due to their reliance on each other, these two events (interactionCreate, and ready) have to stay here.
@@ -93,23 +93,21 @@ client.on('interactionCreate', async (interaction) => {
     const id = interaction.customId.split('_')[0];
 
     for (const button of buttons) {
-      if (button.id != id) continue;
-
-      Promise.resolve((button.execute as (context: Client, interaction: ButtonInteraction, ...args: unknown[]) => Promise<void>)(client, interaction, ...interaction.customId.split('_').slice(1))
-        .catch(e => console.error('An error occurred while handling a button interaction: ', e)));
+      if (id == button.name) {
+        button.handler(client, interaction, ...interaction.customId.split('_').slice(1));
         return;
       }
+    }
   } else if (interaction.isModalSubmit()) {
     // Handle modal submissions.
     const id = interaction.customId.split('_')[0];
 
     for (const modal of modals) {
-      if (id != modal.id) continue;
-
-      Promise.resolve((modal.execute as (context: Client, interaction: ModalSubmitInteraction, ...args: unknown[]) => Promise<void>)(client, interaction, ...interaction.customId.split('_').slice(1))
-        .catch(e => console.error('An error occurred while handling a modal interaction: ', e)));
+      if (id == modal.name) {
+        modal.handler(client, interaction, ...interaction.customId.split('_').slice(1));
         return;
       }
+    }
   } else if (interaction.isAnySelectMenu()) {
     // Handle menu selections.
     const id = interaction.customId.split('_')[0];
@@ -126,17 +124,17 @@ client.on('interactionCreate', async (interaction) => {
 client.on('clientReady', async () => {
   console.log(`Logged in as ${client.user!.tag}!`);
 
-  for (const guild of client.guilds.cache.values()) {
-    if (guild.id != config.DISCORD_GUILD_ID) await guild.leave();
-  }
-
   await loadHandlersFrom('commands', commands);
   await loadHandlersFrom('context-menus', contextMenus);
+  await loadHandlersFrom('buttons', buttons);
+  await loadHandlersFrom('modals', modals);
   await loadHandlersFrom('menus', menus);
 
   await refreshCommands(client);
 
   await initIfNecessary(client, commands);
+  await initIfNecessary(client, buttons);
+  await initIfNecessary(client, modals);
   await initIfNecessary(client, menus);
 
   Encrypter.initialize(config.DATABASE_SECRET!);

src/modals/add-knowledgebase-item-modal.ts

@@ -0,0 +1,49 @@
+import { Client, MessageFlags, ModalSubmitInteraction } from 'discord.js';
+import { Database } from '../shared/Database';
+import { deferInteraction, logCustomEvent } from '../utils';
+
+export default {
+  name: 'add-knowledgebase-item-modal',
+  handler: async function (client: Client, interaction: ModalSubmitInteraction) {
+    if (!interaction.guild) return interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'Must be ran in guild.' });
+
+    await deferInteraction(interaction);
+
+    const name = interaction.fields.getTextInputValue('name');
+    const content = interaction.fields.getTextInputValue('content');
+
+    if (content.length > 2000) return interaction.editReply('Content cannot be over 2000 characters long.');
+
+    const existingItem = await Database.getFromKnowledgebaseByName(interaction.guild.id, name);
+
+    if (existingItem) return interaction.editReply(`Knowledgebase item ${name} already exists!`);
+
+    logCustomEvent(interaction.guild!, {
+      title: 'Knowledgebase Item Added',
+      description: null,
+      color: 0x00FF00,
+      timestamp: new Date(),
+      fields: [
+        {
+          name: 'User',
+          value: `<@${interaction.user.id}>\n${interaction.user.username}`,
+          inline: true
+        },
+        {
+          name: 'Name',
+          value: name,
+          inline: true
+        },
+        {
+          name: 'Content',
+          value: content,
+          inline: true
+        }
+      ]
+    });
+
+    await Database.addToKnowledgebase(interaction.guild.id, name, content);
+
+    return interaction.editReply(`Entry \`${name}\` added to knowledgebase.`);
+  }
+};

src/modals/add-note-modal.ts

@@ -0,0 +1,40 @@
+import { Client, MessageFlags, ModalSubmitInteraction } from 'discord.js';
+import { Database } from '../shared/Database';
+import { logCustomEvent } from '../utils';
+
+export default {
+  name: 'add-note-modal',
+  handler: async function (client: Client, interaction: ModalSubmitInteraction, id: string) {
+    const message = interaction.fields.getTextInputValue('note-message');
+
+    const user = await client.users.fetch(id);
+
+    logCustomEvent(interaction.guild!, {
+      title: 'Note Added',
+      description: null,
+      color: 0x00FF00,
+      timestamp: new Date(),
+      fields: [
+        {
+          name: 'Moderator',
+          value: `<@${interaction.user.id}>\n${interaction.user.username}`,
+          inline: true
+        },
+        {
+          name: 'User',
+          value: `<@${id}>\n${user.username}`,
+          inline: true
+        },
+        {
+          name: 'Note',
+          value: message,
+          inline: true
+        }
+      ]
+    });
+
+    await Database.putNote(id, message, interaction.user.id);
+
+    interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'Note added' });
+  }
+};

src/modals/addKnowledgebaseItemModal.ts

@@ -1,41 +0,0 @@
-import { Client, ModalSubmitInteraction } from 'discord.js';
-import { Database } from '../shared/Database';
-import { Modal } from '../types';
-import { deferInteraction, logCustomEvent } from '../utils';
-
-class AddKnowledgebaseItemModal implements Modal<Client> {
-  id = 'add-knowledgebase-item-modal';
-
-  async execute(context: Client<boolean>, interaction: ModalSubmitInteraction): Promise<void> {
-    if (!interaction.inGuild()) return;
-    await deferInteraction(interaction);
-
-    try {
-      const name = interaction.fields.getTextInputValue('name');
-      const content = interaction.fields.getTextInputValue('content');
-      if (content.length > 2000) throw new Error('Content cannot be longer than 2000 characters.');
-
-      const existing = await Database.getFromKnowledgebaseByName(interaction.guildId, name);
-      if (existing) throw new Error(`A knowledgebase item under \`${name}\` already exists.`);
-
-      await logCustomEvent(interaction.guild!, {
-        title: 'Knowledgebase Item Added',
-        description: null,
-        color: 0x00FF00,
-        timestamp: new Date(),
-        fields: [
-          { name: 'User', value: `${interaction.user} (${interaction.user.id})`, inline: false },
-          { name: 'Name', value: name, inline: false },
-          { name: 'Content', value: content, inline: false },
-        ],
-      });
-
-      await Database.addToKnowledgebase(interaction.guildId, name, content);
-      await interaction.editReply({ content: `\`${name}\` has been added to the knowledgebase.` });
-    } catch (error: Error | any) {
-      await interaction.editReply({ content: error.message }).catch(() => {});
-    }
-  }
-}
-
-export default new AddKnowledgebaseItemModal();

src/modals/addNoteModal.ts

@@ -1,38 +0,0 @@
-import { Client, ModalSubmitInteraction } from 'discord.js';
-import { Database } from '../shared/Database';
-import { deferInteraction, logCustomEvent } from '../utils';
-import { Modal } from '../types';
-
-class AddNoteModal implements Modal<Client> {
-  id = 'add-note-modal';
-
-  async execute(context: Client<boolean>, interaction: ModalSubmitInteraction, id: string): Promise<void> {
-    if (!interaction.inGuild()) return;
-    await deferInteraction(interaction);
-
-    try {
-      const message = interaction.fields.getTextInputValue('note-message');
-      const guild = await context.guilds.fetch(interaction.guildId);
-      const user = await context.users.fetch(id);
-
-      await logCustomEvent(guild, {
-        title: 'Note Added',
-        description: null,
-        color: 0x00FF00,
-        timestamp: new Date(),
-        fields: [
-          { name: 'Moderator', value: `${interaction.user} (${interaction.user.id})`, inline: false },
-          { name: 'User', value: `${user.username} (${user.id})`, inline: false },
-          { name: 'Note', value: message, inline: false },
-        ],
-      });
-
-      await Database.putNote(id, message, interaction.user.id);
-      await interaction.editReply({ content: 'Note added.' });
-    } catch (error: Error | any) {
-      await interaction.editReply({ content: error.message }).catch(() => {});
-    }
-  }
-}
-
-export default new AddNoteModal();

src/modals/edit-knowledgebase-item-modal.ts

@@ -0,0 +1,54 @@
+import { Client, MessageFlags, ModalSubmitInteraction } from 'discord.js';
+import { Database } from '../shared/Database';
+import { deferInteraction, logCustomEvent } from '../utils';
+
+export default {
+  name: 'edit-knowledgebase-item-modal',
+  handler: async function (client: Client, interaction: ModalSubmitInteraction, idString: string) {
+    if (!interaction.guild) return interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'Must be ran in guild.' });
+
+    await deferInteraction(interaction);
+
+    const id = parseInt(idString);
+    const content = interaction.fields.getTextInputValue('content');
+
+    const existingItem = await Database.getFromKnowledgebase(id);
+
+    if (!existingItem) return interaction.editReply('Knowledgebase item not found.');
+
+    if (content.length > 2000) return interaction.editReply('Content cannot be over 2000 characters long.');
+
+    logCustomEvent(interaction.guild!, {
+      title: 'Knowledgebase Item Edited',
+      description: null,
+      color: 0xFFFF00,
+      timestamp: new Date(),
+      fields: [
+        {
+          name: 'User',
+          value: `<@${interaction.user.id}>\n${interaction.user.username}`,
+          inline: true
+        },
+        {
+          name: 'Name',
+          value: existingItem.name,
+          inline: true
+        },
+        {
+          name: 'Old Content',
+          value: existingItem.content,
+          inline: true
+        },
+        {
+          name: 'New Content',
+          value: content,
+          inline: true
+        }
+      ]
+    });
+
+    await Database.editKnowledgebaseItem(id, content);
+
+    return interaction.editReply(`Edited knowledgebase entry \`${existingItem.name}\`.`);
+  }
+};

src/modals/editKnowledgebaseItemModal.ts

@@ -1,43 +0,0 @@
-import { Client, ModalSubmitInteraction } from 'discord.js';
-import { Database } from '../shared/Database';
-import { deferInteraction, logCustomEvent } from '../utils';
-import { Modal } from '../types';
-
-class EditKnowledgebaseItemModal implements Modal<Client> {
-  id = 'edit-knowledgebase-item-modal';
-
-  async execute(context: Client<boolean>, interaction: ModalSubmitInteraction, idString: string): Promise<void> {
-    if (!interaction.inGuild()) return;
-    await deferInteraction(interaction);
-
-    try {
-      const id = parseInt(idString);
-      const existing = await Database.getFromKnowledgebase(id);
-      if (!existing) throw new Error("A knowledgebase item with that ID doesn't exist.");
-
-      const content = interaction.fields.getTextInputValue('content');
-      if (content.length > 2000) throw new Error('Content cannot be longer than 2000 characters.');
-
-      const guild = await context.guilds.fetch(interaction.guildId);
-      await logCustomEvent(guild, {
-        title: 'Knowledgebase Item Edited',
-        description: null,
-        color: 0xFFFF00,
-        timestamp: new Date(),
-        fields: [
-          { name: 'User', value: `${interaction.user} (${interaction.user.id})`, inline: false },
-          { name: 'Name', value: existing.name, inline: false },
-          { name: 'Old Content', value: existing.content, inline: false },
-          { name: 'New Content', value: content, inline: false },
-        ],
-      });
-
-      await Database.editKnowledgebaseItem(id, content);
-      await interaction.editReply({ content: `\`${existing.name}\` has been edited.` });
-    } catch (error: Error | any) {
-      await interaction.editReply({ content: error.message }).catch(() => {});
-    }
-  }
-}
-
-export default new EditKnowledgebaseItemModal();

src/modals/index.ts

@@ -1,17 +0,0 @@
-import addKnowledgebaseItemModal from './addKnowledgebaseItemModal';
-import addNoteModal from './addNoteModal';
-import editKnowledgebaseItemModal from './editKnowledgebaseItemModal';
-import openModTicket from './openModTicket';
-import openTicketModal from './openTicketModal';
-import reportMessage from './reportMessage';
-import syncNameModal from './syncNameModal';
-
-export default [
-  addKnowledgebaseItemModal,
-  addNoteModal,
-  editKnowledgebaseItemModal,
-  openModTicket,
-  openTicketModal,
-  reportMessage,
-  syncNameModal
-];

src/modals/open-mod-ticket.ts

@@ -0,0 +1,31 @@
+import { Client, MessageFlags, ModalSubmitInteraction } from 'discord.js';
+import { Database } from '../shared/Database';
+import { createPrivateHelpTicketThread } from '../utils';
+
+const warning = '\n\n\nLeaving this thread without acknowledgement may result in punishment. Staff will close the thread when they deem your response acceptable.';
+
+export default {
+  name: 'open-mod-ticket',
+  handler: async function (client: Client, interaction: ModalSubmitInteraction, userId: string) {
+    const guild = await client.guilds.fetch(interaction.guildId!);
+    const member = await guild.members.fetch(userId);
+
+    const guildSettings = await Database.getOrCreateSettings(guild.id);
+
+    if (!guildSettings || !guildSettings.private_help_channel_id)
+      return interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'Failed to create ticket. Please report this to a developer.' });
+
+    const title = interaction.fields.getTextInputValue('title') ? interaction.fields.getTextInputValue('title') : `Mod Ticket For ${member.displayName}`;
+    const reason = interaction.fields.getTextInputValue('initial-message') + warning;
+    const autoJoin = interaction.fields.getStringSelectValues('auto-join-thread')[0] == 'yes';
+
+    const membersToAdd = [userId];
+
+    if (autoJoin) membersToAdd.push(interaction.user.id);
+
+    const thread = await createPrivateHelpTicketThread(client, guild, null, reason, title, membersToAdd);
+
+    if (thread) interaction.reply({ flags: [MessageFlags.Ephemeral], content: `Mod ticket created: ${thread}.${!autoJoin ? "You've selected not to auto join the thread. You will not be notified of messages sent there. You will have to check the thread periodically for user response." : ''}` });
+    else interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'Failed to create ticket. Please report this to a developer.' });
+  }
+};

src/modals/open-ticket-modal.ts

@@ -0,0 +1,23 @@
+import { Client, MessageFlags, ModalSubmitInteraction } from 'discord.js';
+import { Database } from '../shared/Database';
+import { createPrivateHelpTicketThread } from '../utils';
+
+export default {
+  name: 'open-ticket-modal',
+  handler: async function (client: Client, interaction: ModalSubmitInteraction) {
+    const guild = await client.guilds.fetch(interaction.guildId!);
+    const member = await guild.members.fetch(interaction.user.id);
+
+    const guildSettings = await Database.getOrCreateSettings(guild.id);
+
+    if (!guildSettings || !guildSettings.private_help_role_id)
+      return interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'Failed to create ticket. Please report this to a staff member.' });
+
+    const reason = interaction.fields.getTextInputValue('ticket-message');
+
+    const thread = await createPrivateHelpTicketThread(client, guild, member, reason);
+
+    if (thread) interaction.reply({ flags: [MessageFlags.Ephemeral], content: `Your ticket has been created: ${thread}` });
+    else interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'Failed to create ticket. Please report this to a staff member.' });
+  }
+};

src/modals/openModTicket.ts

@@ -1,39 +0,0 @@
-import { Client, MessageFlags, ModalSubmitInteraction } from 'discord.js';
-import { Database } from '../shared/Database';
-import { Modal } from '../types';
-import { createPrivateHelpTicketThread } from '../utils';
-
-const warning = '\n\n\nLeaving this thread without acknowledgement may result in punishment. Staff will close the thread when they deem your response acceptable.';
-
-class OpenModTicketModal implements Modal<Client> {
-  id = 'open-mod-ticket';
-
-  async execute(context: Client<boolean>, interaction: ModalSubmitInteraction, userId: string): Promise<void> {
-    if (!interaction.inGuild()) return;
-    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
-
-    try {
-      const settings = await Database.getOrCreateSettings(interaction.guildId);
-      if (!settings.private_help_channel_id) throw new Error("`private_help_channel_id` hasn't been configured. Please report this error to staff.");
-
-      const guild = await context.guilds.fetch(interaction.guildId);
-      const member = await guild.members.fetch(userId);
-
-      const title = interaction.fields.getTextInputValue('title') ? interaction.fields.getTextInputValue('title') : `Mod Ticket For ${member.displayName}`;
-      const reason = interaction.fields.getTextInputValue('initial-message') + warning;
-      const autoJoin = interaction.fields.getCheckbox('auto-join-thread');
-
-      const membersToAdd = [userId];
-      if (autoJoin) membersToAdd.push(interaction.user.id);
-
-      const thread = await createPrivateHelpTicketThread(context, guild, null, reason, title, membersToAdd);
-      if (!thread) throw new Error('Failed to create a ticket thread. Please report this to a developer.');
-
-      await interaction.editReply({ content: `Mod ticket created: ${thread}. ${!autoJoin ? "You've selected not to auto join the thread. You will not be notified of messages sent there. You will have to check the thread periodically for user response." : ''}` });
-    } catch (error: Error | any) {
-      await interaction.editReply({ content: error.message }).catch(() => {});
-    }
-  }
-}
-
-export default new OpenModTicketModal();

src/modals/openTicketModal.ts

@@ -1,31 +0,0 @@
-import { Client, MessageFlags, ModalSubmitInteraction } from 'discord.js';
-import { Database } from '../shared/Database';
-import { Modal } from '../types';
-import { createPrivateHelpTicketThread } from '../utils';
-
-class OpenTicketModal implements Modal<Client> {
-  id = 'open-ticket-modal';
-
-  async execute(context: Client<boolean>, interaction: ModalSubmitInteraction): Promise<void> {
-    if (!interaction.inGuild()) return;
-    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
-
-    try {
-      const guild = await context.guilds.fetch(interaction.guildId);
-      const member = await guild.members.fetch(interaction.user.id);
-
-      const settings = await Database.getOrCreateSettings(interaction.guildId);
-      if (!settings.private_help_role_id) throw new Error("`private_help_role_id` hasn't been configured. Please report this error to staff.");
-
-      const reason = interaction.fields.getTextInputValue('ticket-message');
-      const thread = await createPrivateHelpTicketThread(context, guild, member, reason);
-      if (!thread) throw new Error('Failed to create ticket. Please report this to a staff member.');
-
-      await interaction.editReply({ content: `Your ticket has been created: ${thread}` });
-    } catch (error: Error | any) {
-      await interaction.editReply({ content: error.message }).catch(() => {});
-    }
-  }
-}
-
-export default new OpenTicketModal();

src/modals/report-message.ts

@@ -0,0 +1,118 @@
+import { ActionRowBuilder, AttachmentBuilder, ButtonBuilder, ButtonStyle, Client, EmbedBuilder, GuildTextBasedChannel, MessageFlags, ModalSubmitInteraction } from 'discord.js';
+import { Database } from '../shared/Database';
+import { canOpenPrivateHelpTicket, createPrivateHelpTicketThread } from '../utils';
+
+export default {
+  name: 'report-message',
+  handler: async function (client: Client, interaction: ModalSubmitInteraction, channelId: string, messageId: string) {
+    await interaction.deferReply({ flags: [MessageFlags.Ephemeral] });
+
+    const guild = await client.guilds.fetch(interaction.guildId!);
+    const member = await guild.members.fetch(interaction.user.id);
+    const reportedMessageChannel = await guild.channels.fetch(channelId) as GuildTextBasedChannel;
+    const reportedMessage = await reportedMessageChannel?.messages.fetch(messageId);
+
+    const additionalInfo = interaction.fields.getTextInputValue('additional-info');
+    const createPrivateHelpTicket = interaction.fields.getStringSelectValues('create-private-help-ticket')[0] == 'yes';
+
+    if (!reportedMessageChannel || !reportedMessage)
+      return interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'Failed to submit report. Please report this to a staff member.' });
+
+    const guildSettings = await Database.getOrCreateSettings(interaction.guildId!);
+
+    if (!guildSettings || !guildSettings.moderator_channel_id)
+      return interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'Report channel missing. Unable to submit report.' });
+
+    const reportsChannel = await interaction.guild!.channels.fetch(guildSettings.moderator_channel_id);
+
+    if (!reportsChannel || !reportsChannel.isSendable())
+      return interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'Report channel missing. Unable to submit report.' });
+
+    const embed = new EmbedBuilder()
+      .setTitle('New Message Report!')
+      .setColor(0xFF0000)
+      .addFields(
+        {
+          name: 'Message',
+          value: reportedMessage.url,
+          inline: false
+        },
+        {
+          name: 'Message Author',
+          value: reportedMessage.author.toString(),
+          inline: false
+        },
+        {
+          name: 'Reporter',
+          value: member.toString(),
+          inline: false
+        });
+
+    if (additionalInfo) {
+      embed.addFields(
+        {
+          name: 'Additional Information',
+          value: additionalInfo,
+          inline: false
+        }
+      );
+    }
+
+    let replyContent = "Thanks for making a report! I've notified the moderators who can take further action.";
+
+    const wantsTicketButCantOpen = createPrivateHelpTicket && !await canOpenPrivateHelpTicket(member.id);
+
+    if (wantsTicketButCantOpen) {
+      embed.addFields(
+        {
+          name: 'User Requested Private Ticket',
+          value: 'The user requested a private ticket be opened, but already has an open ticket. If additional information is needed, press the button below to open a ticket with the user.',
+          inline: false
+        }
+      );
+
+      replyContent += " Could not open private help ticket since you already have one open. Staff have been notified that you'd like to have a ticket opened, and can make one for you if they deem it necessary.";
+    }
+
+    const openTicketButton = new ButtonBuilder()
+      .setCustomId('open-ticket-for-reported-message')
+      .setLabel('Open Private Ticket')
+      .setStyle(ButtonStyle.Primary);
+
+    const row = new ActionRowBuilder<ButtonBuilder>().addComponents(openTicketButton);
+
+    const reportMessage = await reportsChannel.send({
+      embeds: [embed],
+      components: createPrivateHelpTicket && !wantsTicketButCantOpen ? [] : [row]
+    });
+
+    await reportsChannel.send({ files: [new AttachmentBuilder(Buffer.from(reportedMessage.content), { name: 'message-content.txt' })] });
+
+    if (createPrivateHelpTicket && !wantsTicketButCantOpen) {
+      if (!guildSettings.private_help_channel_id) {
+        replyContent += ' Could not open private help ticket. Private help channel not set. Please report this to a staff member.';
+      } else {
+        const thread = await createPrivateHelpTicketThread(client, guild, member, `Ticket created with message report (${reportMessage.url}). ${member}, use this channel to talk with staff privately about the reported message (${reportedMessage.url}). ${additionalInfo ? `\n\nAdditional information provided in report:\n${additionalInfo.split('\n').map(c => `> ${c}`).join('\n')}` : ''}`);
+        if (thread) {
+          replyContent += ` Private help ticket created: ${thread}.`;
+          embed.addFields({
+            name: 'Private Help Ticket',
+            value: thread.url,
+            inline: false
+          });
+
+          await reportMessage.edit({ embeds: [embed] });
+
+        } else {
+          replyContent += ' There was an issue opening a private help ticket, please report this to a staff member.';
+          await reportMessage.edit({
+            embeds: [embed],
+            components: [row]
+          });
+        }
+      }
+    }
+
+    await interaction.editReply(replyContent);
+  }
+};

src/modals/reportMessage.ts

@@ -1,96 +0,0 @@
-import { ActionRowBuilder, AttachmentBuilder, ButtonBuilder, ButtonStyle, Client, EmbedBuilder, GuildTextBasedChannel, MessageFlags, ModalSubmitInteraction } from 'discord.js';
-import { Database } from '../shared/Database';
-import { Modal } from '../types';
-import { canOpenPrivateHelpTicket, createPrivateHelpTicketThread } from '../utils';
-
-class ReportMessageModal implements Modal<Client> {
-  id = 'report-message';
-
-  async execute(context: Client<boolean>, interaction: ModalSubmitInteraction, channelId: string, messageId: string): Promise<void> {
-    if (!interaction.inGuild()) return;
-    await interaction.deferReply({ flags: [MessageFlags.Ephemeral] });
-
-    try {
-      const guild = await context.guilds.fetch(interaction.guildId);
-      const member = await guild.members.fetch(interaction.user.id);
-      const reportedMessageChannel = await guild.channels.fetch(channelId) as GuildTextBasedChannel;
-      const reportedMessage = await reportedMessageChannel?.messages.fetch(messageId);
-
-      const additionalInfo = interaction.fields.getTextInputValue('additional-info');
-      const createPrivateHelpTicket = interaction.fields.getCheckbox('create-private-help-ticket');
-
-      if (!reportedMessageChannel || !reportedMessage) throw new Error('Failed to submit report. Please report this to a staff member.');
-
-      const settings = await Database.getOrCreateSettings(interaction.guildId);
-      if (!settings.moderator_channel_id) throw new Error('Report channel missing. Unable to submit report.');
-
-      const reportsChannel = await interaction.guild!.channels.fetch(settings.moderator_channel_id);
-      if (!reportsChannel || !reportsChannel.isSendable()) throw new Error('Report channel missing. Unable to submit report.');
-
-      const embed = new EmbedBuilder()
-        .setTitle('New Message Report!')
-        .setColor(0xFF0000)
-        .addFields(
-          { name: 'Message', value: reportedMessage.url, inline: false },
-          { name: 'Author', value: reportedMessage.author.toString(), inline: false },
-          { name: 'Reporter', value: member.toString(), inline: false }
-        );
-
-      if (additionalInfo) embed.addFields({ name: 'Additional Information', value: additionalInfo, inline: false });
-
-      let replyContent = "Thanks for making a report! I've notified the moderators who can take further action.";
-      const wantsTicketButCantOpen = createPrivateHelpTicket && !await canOpenPrivateHelpTicket(member.id);
-
-      if (wantsTicketButCantOpen) {
-        embed.addFields({
-          name: 'User Requested Private Ticket',
-          value: 'The user requested a private ticket be opened, but already has an open ticket. If additional information is needed, press the button below to open a ticket with the user.',
-          inline: false
-        });
-
-        replyContent += " Could not open private help ticket since you already have one open. Staff have been notified that you'd like to have a ticket opened, and can make one for you if they deem it necessary.";
-      }
-
-      const openTicketButton = new ButtonBuilder()
-        .setCustomId('open-ticket-for-reported-message')
-        .setLabel('Open Private Ticket')
-        .setStyle(ButtonStyle.Primary);
-
-      const row = new ActionRowBuilder<ButtonBuilder>().addComponents(openTicketButton);
-
-      const reportMessage = await reportsChannel.send({
-        embeds: [embed],
-        components: createPrivateHelpTicket && !wantsTicketButCantOpen ? [] : [row]
-      });
-
-      await reportsChannel.send({ files: [new AttachmentBuilder(Buffer.from(reportedMessage.content), { name: 'message-content.txt' })] });
-
-      if (createPrivateHelpTicket && !wantsTicketButCantOpen) {
-        if (!settings.private_help_channel_id) {
-          replyContent += ' Could not open private help ticket. Private help channel not set. Please report this to a staff member.';
-        } else {
-          const thread = await createPrivateHelpTicketThread(context, guild, member, `Ticket created with message report (${reportMessage.url}). ${member}, use this channel to talk with staff privately about the reported message (${reportedMessage.url}). ${additionalInfo ? `\n\nAdditional information provided in report:\n${additionalInfo.split('\n').map(c => `> ${c}`).join('\n')}` : ''}`);
-          if (thread) {
-            replyContent += ` Private help ticket created: ${thread}.`;
-            embed.addFields({ name: 'Private Help Ticket', value: thread.url, inline: false });
-
-            await reportMessage.edit({ embeds: [embed] });
-          } else {
-            replyContent += ' There was an issue opening a private help ticket, please report this to a staff member.';
-
-            await reportMessage.edit({
-              embeds: [embed],
-              components: [row]
-            });
-          }
-        }
-      }
-
-      await interaction.editReply(replyContent);
-    } catch (error: Error | any) {
-      await interaction.editReply({ content: error.message }).catch(() => {});
-    }
-  }
-}
-
-export default new ReportMessageModal();

src/modals/sync-name-modal.ts

@@ -0,0 +1,32 @@
+import { Client, ModalSubmitInteraction } from 'discord.js';
+import { config } from '../config';
+import { deferInteraction, syncName } from '../utils';
+
+export default {
+  name: 'sync-name-modal',
+  handler: async function (client: Client, interaction: ModalSubmitInteraction, id: string) {
+    await deferInteraction(interaction);
+
+    const e621Id = Number(interaction.fields.getTextInputValue('id') ?? 0);
+
+    if (isNaN(e621Id)) return await interaction.editReply('Provided id is not a number');
+
+    const member = await interaction.guild?.members.fetch(id);
+
+    if (!member) {
+      return interaction.editReply('An error has occurred. Please try again later.');
+    }
+
+    const guild = await interaction.client.guilds.fetch(config.DISCORD_GUILD_ID!);
+
+    if (!guild) {
+      return interaction.editReply('An error has occurred. Please try again later.');
+    }
+
+    if (!guild.members.me) {
+      return interaction.editReply('An error has occurred. Please try again later.');
+    }
+
+    await syncName(interaction, member, e621Id);
+  }
+};

src/modals/syncNameModal.ts

@@ -1,27 +0,0 @@
-import { Client, ModalSubmitInteraction } from 'discord.js';
-import { Modal } from '../types';
-import { deferInteraction, syncName } from '../utils';
-
-class SyncNameModal implements Modal<Client> {
-  id = 'sync-name-modal';
-
-  async execute(context: Client<boolean>, interaction: ModalSubmitInteraction, id: string): Promise<void> {
-    if (!interaction.inGuild()) return;
-    await deferInteraction(interaction);
-
-    try {
-      const e621Id = Number(interaction.fields.getTextInputValue('id') ?? 0);
-      if (isNaN(e621Id)) throw new Error('Provided id is not a number.');
-
-      const guild = await context.guilds.fetch(interaction.guildId);
-      const member = await guild.members.fetch(id);
-      if (!member) throw new Error('Unable to fetch the target member.');
-
-      await syncName(interaction, member, e621Id);
-    } catch (error: Error | any) {
-      await interaction.editReply({ content: error.message }).catch(() => {});
-    }
-  }
-}
-
-export default new SyncNameModal();

src/shared/Database.ts

@@ -364,9 +364,8 @@ export class Database {
     });
   }
 
-  static async removeGithubUserMapping(discordId: string): Promise<boolean> {
-    const result = await Database.db.run('DELETE FROM github_user_mapping WHERE discord_id_hash = ?', Encrypter.hash(discordId));
-    return (result.changes ?? 0) > 0;
+  static async removeGithubUserMapping(discordId: string) {
+    await Database.db.run('DELETE from github_user_mapping WHERE discord_id_hash = ?', Encrypter.encrypt(discordId));
   }
 
   //#endregion

src/types/button.d.ts

@@ -1,6 +0,0 @@
-import { ButtonInteraction } from 'discord.js';
-
-export interface Button<Context> {
-  id: string;
-  execute(context: Context, interaction: ButtonInteraction, ...args: any): Promise<void>;
-}

src/types/database-types.d.ts

@@ -22,6 +22,7 @@ export type GuildSettings = {
   voice_logs_channel_id?: string
   admin_role_id?: string
   private_help_role_id?: string
+  devwatch_role_id?: string
   staff_categories?: string
   safe_channels?: string
   link_skip_channels?: string

src/types/index.d.ts

@@ -1,9 +1,7 @@
-export * from './button.d';
 export * from './command.d';
 export * from './database-types.d';
 export * from './event.d';
 export * from './e621-types.d';
 export * from './handler.d';
 export * from './helper-types.d';
-export * from './modal.d';
 export * from './task.d';

src/types/modal.d.ts

@@ -1,6 +0,0 @@
-import { ModalSubmitInteraction } from 'discord.js';
-
-export interface Modal<Context> {
-  id: string;
-  execute(context: Context, interaction: ModalSubmitInteraction, ...args: any): Promise<void>;
-}

src/utils/interaction-utils.ts

@@ -1,5 +1,5 @@
 import { ChatInputCommandInteraction, ContextMenuCommandInteraction, GuildBasedChannel, MessageFlags, ModalSubmitInteraction } from 'discord.js';
-import { channelIsInStaffCategory } from '.';
+import { channelIsInStaffCategory } from './channel-utils';
 
 export async function deferInteraction(interaction: ChatInputCommandInteraction | ContextMenuCommandInteraction | ModalSubmitInteraction) {
   const isStaffChannel = await channelIsInStaffCategory(interaction.channel as GuildBasedChannel);

src/utils/modal-utils.ts

@@ -1,4 +1,4 @@
-import { CheckboxBuilder, LabelBuilder, TextInputBuilder, TextInputStyle } from 'discord.js';
+import { LabelBuilder, StringSelectMenuBuilder, StringSelectMenuOptionBuilder, TextInputBuilder, TextInputStyle } from 'discord.js';
 
 export function createTextInput(customId: string, labelTitle: string, description: string | null, required: boolean, style: TextInputStyle, maxLength: number | null, minLength: number | null): LabelBuilder {
   const input = new TextInputBuilder()
@@ -19,14 +19,23 @@ export function createTextInput(customId: string, labelTitle: string, descriptio
   return label;
 }
 
-export function createCheckbox(customId: string, labelTitle: string, description: string | null, defaultYes: boolean): LabelBuilder {
-  const component = new CheckboxBuilder()
+export function createYesNoMenu(customId: string, labelTitle: string, description: string | null, defaultYes: boolean): LabelBuilder {
+  const yesNoMenu = new StringSelectMenuBuilder()
     .setCustomId(customId)
-    .setDefault(defaultYes);
+    .addOptions(
+      new StringSelectMenuOptionBuilder()
+        .setLabel('Yes')
+        .setDefault(defaultYes)
+        .setValue('yes'),
+      new StringSelectMenuOptionBuilder()
+        .setLabel('No')
+        .setDefault(!defaultYes)
+        .setValue('no')
+    );
 
   const yesNoLabel = new LabelBuilder()
     .setLabel(labelTitle)
-    .setCheckboxComponent(component);
+    .setStringSelectMenuComponent(yesNoMenu);
 
   if (description !== null) yesNoLabel.setDescription(description);
 

src/utils/private-help-utils.ts

@@ -1,6 +1,6 @@
 import { ActionRowBuilder, ButtonBuilder, ButtonStyle, ChannelType, ChatInputCommandInteraction, Client, Guild, GuildMember, ModalBuilder, PrivateThreadChannel, TextChannel, TextInputStyle, ThreadAutoArchiveDuration, ThreadChannel, UserContextMenuCommandInteraction } from 'discord.js';
 import { Database } from '../shared/Database';
-import { CreateDefaultEmbed, createTextInput, createCheckbox, SetSeverity } from '.';
+import { CreateDefaultEmbed, createTextInput, createYesNoMenu, SetSeverity } from '.';
 
 export async function closeOldTickets(client: Client) {
   for (const ticket of await Database.getAllOpenPrivateHelpTickets()) {
@@ -121,8 +121,9 @@ export async function openModTicketModal(interaction: UserContextMenuCommandInte
 
   const titleLabel = createTextInput('title', 'Title', `The name of the thread. Defaults to "Mod Ticket For ${member.displayName}" if left empty`, false, TextInputStyle.Short, 100, null);
   const initialMessageLabel = createTextInput('initial-message', 'Inital Message', 'The inital message sent in the thread', false, TextInputStyle.Paragraph, 1800, null);
-  const autoJoinLabel = createCheckbox('auto-join-thread', 'Auto Join Thread', 'Whether or not to automatically add you to the thread.', true);
+  const autoJoinLabel = createYesNoMenu('auto-join-thread', 'Auto Join Thread', 'Whether or not to join you to the thread. Selecting no will not notify you of messages sent!', true);
 
   modal.addLabelComponents(titleLabel, initialMessageLabel, autoJoinLabel);
+
   interaction.showModal(modal);
 }