Refactor to more consistent structure (e.g. "plugins")

2025-07-06 15:23:03 -04:00
parent a6255de889
commit 6fb38d36f3
22 changed files with 567 additions and 600 deletions
--- a/plugins/remind/index.ts
+++ b/plugins/remind/index.ts
@@ -0,0 +1,136 @@
+import * as chrono from 'chrono-node';
+import {
+	type ChatInputCommandInteraction,
+	SlashCommandBuilder,
+	TextChannel,
+} from 'discord.js';
+import * as sequelize from 'sequelize';
+
+import {BasePlugin, type Command, type Settings} from '../../plugin';
+
+import {initializeModels, Reminder, syncModels} from './models';
+
+async function triggerReminder(channel: TextChannel, reminder: Reminder) {
+	try {
+		await channel.send({
+			content: `Reminder for <@${reminder.userId}>: ${reminder.text}`,
+		});
+		reminder.isValid = false;
+	} catch (error) {
+		console.log(`Error trigggering Reminder ${reminder.id}: ${error}`);
+	} finally {
+		await reminder.save();
+	}
+}
+
+export class RemindPlugin extends BasePlugin {
+	interval: NodeJS.Timeout;
+
+	constructor(settings: Settings) {
+		super(settings);
+		initializeModels(settings.database);
+		this.commands = [
+			{
+				data: new SlashCommandBuilder()
+					.setName('remind')
+					.setDescription('Remind me to do something')
+					.addStringOption(option =>
+						option
+							.setName('when')
+							.setDescription('Short description of when you want the reminder')
+							.setRequired(true),
+					)
+					.addStringOption(option =>
+						option
+							.setName('what')
+							.setDescription(
+								'Short description of what you want to be reminded of',
+							)
+							.setRequired(true),
+					),
+
+				execute: async (interaction: ChatInputCommandInteraction) => {
+					const whenString = interaction.options.getString('when') ?? 'now';
+					const when = chrono.parseDate(whenString);
+					if (!when) {
+						await interaction.reply(
+							`Sorry, I don't understand '${when}' as a date`,
+						);
+						return;
+					}
+					const reminder = await Reminder.create({
+						userId: interaction.user.id,
+						text: interaction.options.getString('what'),
+						trigger: when, // TODO
+						requestMessage: interaction.id,
+						requestChannel: interaction.channelId,
+						isValid: true,
+					});
+					reminder.save();
+					await interaction.reply(`Ok, I'll remind you at ${when}`);
+					console.info(
+						`Created Reminder ${reminder.id} to be triggered at ${reminder.trigger}`,
+					);
+				},
+			} as Command, // TODO
+		];
+	}
+
+	getChannel(reminder: Reminder) {
+		// TODO I don't really know what else needs to go into this function
+		// I had some permissions stuff but it seemed very out-of-place
+		// I don't know why isSendable() doesn't cover permissions? Or maybe
+		// it does?
+		// Either way this function kind of smells
+		const client = this.settings.client;
+		const channel = client.channels.cache.get(reminder.requestChannel);
+		if (!(channel instanceof TextChannel)) {
+			throw TypeError("Can't send to a non-ext channel");
+		}
+		if (!channel) {
+			throw Error('Cannot find valid channel to send reminder on');
+		}
+		if (!channel.isSendable()) {
+			throw Error("Can't send to that channel");
+		}
+		return channel;
+	}
+
+	async loop() {
+		console.debug('remind.js main loop');
+		const results = await Reminder.findAll({
+			// NOTE: 'trigger' is the time when the reminder should go off. If trigger -
+			// now is positive, trigger is in the future. If trigger - now <=
+			// 1.0, then we have less than one minute before the timer should go
+			// off.
+			where: sequelize.literal(
+				"isValid AND (julianday(trigger) - julianday('now')) <= 1.0",
+			),
+		});
+		for (const reminder of results) {
+			try {
+				const now = new Date(Date.now());
+				const delay = reminder.trigger.getTime() - now.getTime();
+				console.log(
+					`Callback for Reminder ${reminder.get('id')} triggering in ${delay}ms`,
+				);
+				const channel = this.getChannel(reminder);
+				setTimeout(async () => await triggerReminder(channel, reminder), delay);
+			} catch (error) {
+				console.error(
+					`Error while processing Reminder ${reminder.id}: ${error}`,
+				);
+				console.trace();
+			}
+		}
+	}
+
+	async start() {
+		await syncModels();
+		this.interval = setInterval(this.loop.bind(this), 1000 * 60);
+	}
+
+	async stop() {
+		clearInterval(this.interval);
+	}
+}