[Buttons] Remove separate devwatch button. (#29)

Co-authored-by: Cinder <cinder@e621.net>

.gitignore

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

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

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

src/buttons/claim-ticket.ts

@@ -1,40 +0,0 @@
-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

@@ -0,0 +1,52 @@
+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

@@ -1,31 +0,0 @@
-import { ButtonInteraction, Client, MessageFlags, ChannelType, PermissionFlagsBits } from 'discord.js';
-
-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: []
-    });
-
-    await channel.send('This ticket has been closed by staff.');
-
-    await interaction.editReply({ content: 'Ticket closed.' });
-
-    channel.edit({
-      archived: true,
-      locked: true
-    });
-  }
-};

src/buttons/close-ticket.ts

@@ -1,28 +0,0 @@
-import { ButtonInteraction, Client, MessageFlags, ChannelType } from 'discord.js';
-import { Database } from '../shared/Database';
-
-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 interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'Oops. Something went wrong. Please report this to a staff member.' });
-
-    await interaction.message.edit({
-      content: interaction.message.content,
-      components: []
-    });
-
-    await Database.closePrivateHelpTicket(channel.id);
-
-    await channel.send(`This ticket has been closed by ${interaction.user}`);
-
-    await interaction.reply({ flags: [MessageFlags.Ephemeral], content: 'Ticket closed.' });
-
-    channel.edit({
-      archived: true,
-      locked: true
-    });
-  }
-};

src/buttons/closeModTicket.ts

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -1,32 +0,0 @@
-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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,27 @@
+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

@@ -1,15 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -1,40 +0,0 @@
-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

@@ -0,0 +1,45 @@
+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

@@ -1,20 +0,0 @@
-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

@@ -0,0 +1,30 @@
+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

@@ -1,15 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -1,32 +0,0 @@
-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

@@ -0,0 +1,38 @@
+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

@@ -1,42 +0,0 @@
-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

@@ -0,0 +1,54 @@
+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

@@ -1,42 +0,0 @@
-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,6 +1,61 @@
 import { ApplicationIntegrationType, ChatInputCommandInteraction, Client, InteractionContextType, MessageFlags, PermissionFlagsBits, SlashCommandBuilder } from 'discord.js';
 import { Database } from '../shared/Database';
-import { getIdFromInput } from '../utils';
+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'),
+    }]
+  });
+}
 
 export default {
   name: 'github-mapping',
@@ -44,37 +99,17 @@ export default {
         .setDescription('List all github-discord mappings.')
     ),
   handler: async function (client: Client, interaction: ChatInputCommandInteraction) {
-    await interaction.deferReply({ flags: [MessageFlags.Ephemeral] });
+    if (!interaction.inGuild()) return;
+    await interaction.deferReply({ flags: MessageFlags.Ephemeral });
 
-    const subcommand = await interaction.options.getSubcommand(true);
+    try {
-
+      switch (interaction.options.getSubcommand(true)) {
-    if (subcommand == 'add') {
+        case 'add': return await addUserMapping(interaction);
-      const discordUserInput = interaction.options.getString('discord-user', true);
+        case 'remove': return await removeUserMapping(interaction);
-
+        case 'list': return await listUserMapping(interaction);
-      const idToUse = getIdFromInput(discordUserInput);
+      }
-
+    } catch (error: Error | any) {
-      const githubName = interaction.options.getString('github-name', true);
+      await interaction.editReply({ content: error.message }).catch(() => {});
-
-      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,12 +75,7 @@ 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')
@@ -189,7 +184,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');
@@ -204,12 +199,6 @@ 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/events/guild/guildCreate.ts

@@ -1,4 +1,5 @@
 import { Client, Guild } from 'discord.js';
+import { config } from '../../config';
 import { Database } from '../../shared/Database';
 import { Event } from '../../types';
 
@@ -6,6 +7,11 @@ 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,4 +1,5 @@
-import { Client, GatewayIntentBits, MessageFlags, ModalSubmitInteraction, Partials } from 'discord.js';
+import { ButtonInteraction, Client, GatewayIntentBits, MessageFlags, ModalSubmitInteraction, Partials } from 'discord.js';
+import buttons from './buttons';
 import { config } from './config';
 import events from './events';
 import modals from './modals';
@@ -38,7 +39,6 @@ const client = new Client({
 
 const commands: Handler[] = [];
 const contextMenus: Handler[] = [];
-const buttons: Handler[] = [];
 const menus: Handler[] = [];
 
 // Due to their reliance on each other, these two events (interactionCreate, and ready) have to stay here.
@@ -93,10 +93,11 @@ client.on('interactionCreate', async (interaction) => {
     const id = interaction.customId.split('_')[0];
 
     for (const button of buttons) {
-      if (id == button.name) {
+      if (button.id != id) continue;
-        button.handler(client, interaction, ...interaction.customId.split('_').slice(1));
+
-        return;
+      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)));
+      return;
     }
   } else if (interaction.isModalSubmit()) {
     // Handle modal submissions.
@@ -125,15 +126,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('menus', menus);
 
   await refreshCommands(client);
 
   await initIfNecessary(client, commands);
-  await initIfNecessary(client, buttons);
   await initIfNecessary(client, menus);
 
   Encrypter.initialize(config.DATABASE_SECRET!);

src/modals/editKnowledgebaseItemModal.ts

@@ -18,7 +18,8 @@ class EditKnowledgebaseItemModal implements Modal<Client> {
       const content = interaction.fields.getTextInputValue('content');
       if (content.length > 2000) throw new Error('Content cannot be longer than 2000 characters.');
 
-      await logCustomEvent(interaction.guild!, {
+      const guild = await context.guilds.fetch(interaction.guildId);
+      await logCustomEvent(guild, {
         title: 'Knowledgebase Item Edited',
         description: null,
         color: 0xFFFF00,

src/modals/openTicketModal.ts

@@ -11,7 +11,7 @@ class OpenTicketModal implements Modal<Client> {
     await interaction.deferReply({ flags: MessageFlags.Ephemeral });
 
     try {
-      const guild = await context.guilds.fetch(interaction.guildId!);
+      const guild = await context.guilds.fetch(interaction.guildId);
       const member = await guild.members.fetch(interaction.user.id);
 
       const settings = await Database.getOrCreateSettings(interaction.guildId);

src/modals/reportMessage.ts

@@ -11,7 +11,7 @@ class ReportMessageModal implements Modal<Client> {
     await interaction.deferReply({ flags: [MessageFlags.Ephemeral] });
 
     try {
-      const guild = await context.guilds.fetch(interaction.guildId!);
+      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);
@@ -72,12 +72,7 @@ class ReportMessageModal implements Modal<Client> {
           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 });
-            embed.addFields({
-              name: 'Private Help Ticket',
-              value: thread.url,
-              inline: false
-            });
 
             await reportMessage.edit({ embeds: [embed] });
           } else {

src/shared/Database.ts

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

src/types/button.d.ts

@@ -0,0 +1,6 @@
+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,7 +22,6 @@ 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,3 +1,4 @@
+export * from './button.d';
 export * from './command.d';
 export * from './database-types.d';
 export * from './event.d';

src/utils/modal-utils.ts

@@ -21,7 +21,8 @@ export function createTextInput(customId: string, labelTitle: string, descriptio
 
 export function createCheckbox(customId: string, labelTitle: string, description: string | null, defaultYes: boolean): LabelBuilder {
   const component = new CheckboxBuilder()
-    .setCustomId(customId);
+    .setCustomId(customId)
+    .setDefault(defaultYes);
 
   const yesNoLabel = new LabelBuilder()
     .setLabel(labelTitle)

src/utils/private-help-utils.ts

@@ -121,9 +121,8 @@ 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 join you to the thread. Selecting no will not notify you of messages sent!', true);
+  const autoJoinLabel = createCheckbox('auto-join-thread', 'Auto Join Thread', 'Whether or not to automatically add you to the thread.', true);
 
   modal.addLabelComponents(titleLabel, initialMessageLabel, autoJoinLabel);
-
   interaction.showModal(modal);
 }