Implement Nag service

commands/calendar/nag/service.ts

@@ -0,0 +1,222 @@
+import { type Client, TextChannel } from "discord.js";
+import {
+  type Sequelize,
+  Model,
+  INTEGER,
+  STRING,
+  BOOLEAN,
+  DATE,
+  literal,
+  Op,
+} from "sequelize";
+
+export interface Settings {
+  client: Client; // Main Discord client object
+  db: Sequelize; // Database access object
+  publicChannel?: string; // Channel to use if a reminder is public
+}
+
+export class Nag extends Model {
+  // Primary key
+  declare id: number;
+  // User who created this nag
+  declare userId: string;
+  // Guild (server) of original nag request
+  declare guildId: string;
+  // Channel of original nag request
+  declare channelId: string;
+  // Message of original nag request
+  declare messageId: string;
+  // Description of what you're supposed to do
+  declare text: string;
+  // Custom failure text
+  declare failText?: string;
+  // Should we @here?
+  declare mentionHere?: boolean;
+}
+
+export class CheckIn extends Model {
+  declare nagId: string;
+  // Date of the last time user ran /checkin
+  declare lastCheckIn: Date;
+}
+
+export async function initAndSyncTables(sequelize: Sequelize) {
+  Nag.init(
+    {
+      id: {
+        primaryKey: true,
+        type: INTEGER,
+        autoIncrement: true,
+      },
+      userId: {
+        type: STRING,
+        allowNull: false,
+      },
+      text: {
+        type: STRING,
+        allowNull: false,
+      },
+      failText: {
+        type: STRING,
+      },
+      mentionHere: {
+        type: BOOLEAN,
+      },
+    },
+    { sequelize },
+  );
+  CheckIn.init(
+    {
+      nagId: {
+        type: INTEGER,
+        allowNull: false,
+      },
+      lastCheckIn: {
+        type: DATE,
+        allowNull: false,
+      },
+    },
+    { sequelize },
+  );
+  CheckIn.hasOne(Nag, { foreignKey: "nagId" });
+  await Nag.sync();
+  await CheckIn.sync();
+}
+
+/**
+ *
+ * @param hour Number between 0-24 representing the hour the check-in is performed.
+ * @param offset Number of days from today; this can be positive for future days or negative for past days.
+ * @returns Date object representing the check-in time
+ */
+export function getCheckIn(hour: number, offset: number = 0) {
+  const nDaysInMS = offset * 24 * 60 * 60 * 1000;
+  const day = new Date(Date.now() + nDaysInMS);
+  const checkInDate = new Date(
+    day.getFullYear(),
+    day.getMonth(),
+    day.getDate(),
+    hour,
+  );
+  return checkInDate;
+}
+
+export async function findGuiltyNags() {
+  const results = await Nag.findAll({ where: {} });
+  const guiltyNags: Nag[] = [];
+  const prevCheckIn = getCheckIn(9, -1);
+  const currentCheckIn = getCheckIn(9, 0);
+
+  for (const nag of results) {
+    console.log("Checking nag: ", nag.id);
+    const checkInResults = await CheckIn.findAll({
+      where: {
+        nagId: nag.id,
+        lastCheckIn: {
+          [Op.between]: [prevCheckIn, currentCheckIn],
+        },
+      },
+    });
+    if (checkInResults.length <= 0) {
+      guiltyNags.push(nag);
+    }
+  }
+  return guiltyNags;
+}
+
+/**
+ *
+ * @returns The Date representing the next check-in, which will be either
+ * today (if we are asking in the morning) or tomorrow (if we are asking
+ * after the check-in time for today.)
+ */
+export function nextCheckInDate() {
+  const todaysCheckInDate = getCheckIn(9, 0);
+  if (Date.now() - todaysCheckInDate.getTime() < 0) {
+    return getCheckIn(9, 0);
+  } else {
+    return getCheckIn(9, 1);
+  }
+}
+
+function nextCheckInMs() {
+  const delayMs = nextCheckInDate().getTime() - Date.now();
+  if (delayMs <= 0) {
+    // The value of nextCheckInDate is guaranteed to be in the future; if not, that's a bug in the program.
+    throw Error("Invalid value for nextCheckInDate");
+  }
+  return delayMs;
+}
+
+/**
+ * Handle state for the various nag-related commands, mainly related to
+ * tracking of timers and triggers.
+ */
+export class Manager {
+  // NOTE(DWM): I really hate the word 'Manager' when applied to code, but I
+  // thought for quite a bit about what to name these classes and I just can't
+  // come up with anything solid. (Pun intended.)
+
+  settings: Settings;
+  interval?: NodeJS.Timeout;
+
+  constructor(settings: Settings) {
+    this.settings = settings;
+  }
+
+  start() {
+    this.interval = setTimeout(this.loop, nextCheckInMs());
+  }
+
+  async triggerNag(nag: Nag) {
+    const client = this.settings.client;
+    // First, try and find the appropriate channel to send on
+    const guild = client.guilds.cache.get(nag.guildId);
+    if (!guild) {
+      console.error(
+        `No longer have access to Guild ${nag.guildId}; consider deleting this nag manually :(`,
+      );
+      return;
+    }
+    const channel = guild.channels.cache.get(nag.channelId);
+    if (!channel) {
+      console.error(
+        `No longer have access to Channel ${nag.channelId}; consider deleting this nag manually :(`,
+      );
+      return;
+    }
+    if (!channel?.isSendable() || !(channel instanceof TextChannel)) {
+      console.error("Somehow, we specified a channel which isn't sendable");
+      return; // TODO
+    }
+    try {
+      const failText =
+        nag.failText ??
+        `<@${nag.userId}> didn't complete "${nag.text}". Shame shame!`;
+      const mentionHere = nag.mentionHere ? "<@here> " : "";
+      const msg = `${mentionHere}${failText}`;
+      await channel.send(msg);
+    } catch (error) {
+      console.log("Error while creating Nag:", error); // TODO
+    }
+  }
+
+  async loop() {
+    // According to MDN we don't need to do this, but it makes me feel happier
+    // knowing that we won't accidentally call clearInterval(...) on a timer
+    // that isn't running anymore.
+    this.interval = undefined;
+
+    console.debug("nag.js main loop");
+    const guiltyNags = await findGuiltyNags();
+    for (const nag of guiltyNags) {
+      await this.triggerNag(nag);
+    }
+    this.interval = setTimeout(this.loop, nextCheckInMs());
+  }
+
+  stop() {
+    clearInterval(this.interval);
+  }
+}