Fixes for timer bot - not announcing, skip not working (#270)

Author: ebm5025

src/features/spawn-timers/commands/helpers/channel-update.ts

@@ -10,13 +10,14 @@ import {
   inWindow,
   displayWindow,
 } from "./timer";
-import { formatTimeDistance } from "./duration";
+import { formatTimeDistance, formatMinutesSecondsAgo } from "./duration";
 import { getSettingByKey, saveSettingByKey } from "./settings";
 import { TIMER_CHANNEL_ID, SHOW_FUTURE_WINDOW } from "../../../../config";
 import { timerPrismaClient } from "../../../../db/timer-client";
 
 const MAX_DESCRIPTION_LENGTH = 4096;
 const MAX_EMBEDS_PER_MESSAGE = 10;
+const ENDED_RECENTLY_WINDOW_MS = 60 * 60 * 1000;
 
 interface TableRow {
   name: string;
@@ -25,6 +26,12 @@ interface TableRow {
   remainingMs: number;
 }
 
+interface EndedRow {
+  name: string;
+  time: string;
+  endedMsAgo: number;
+}
+
 function pad(str: string, len: number): string {
   if (str.length > len) return str.slice(0, len);
   return str.padEnd(len, " ");
@@ -65,33 +72,53 @@ function renderTable(
   return "```\n" + lines.join("\n") + "\n```";
 }
 
-function chunkTable(
-  rows: TableRow[],
-  maxLen: number,
-  widths: { nameWidth: number; timeWidth: number; windowWidth: number },
-  thirdColumnLabel?: string
-): string[] {
+function chunkRows<T>(rows: T[], maxLen: number, render: (rows: T[]) => string): string[] {
   const chunks: string[] = [];
-  let currentRows: TableRow[] = [];
+  let currentRows: T[] = [];
 
   for (const row of rows) {
     const testRows = [...currentRows, row];
-    const rendered = renderTable(testRows, widths, thirdColumnLabel);
+    const rendered = render(testRows);
     if (rendered.length > maxLen && currentRows.length > 0) {
-      chunks.push(renderTable(currentRows, widths, thirdColumnLabel));
+      chunks.push(render(currentRows));
       currentRows = [row];
     } else {
       currentRows = testRows;
     }
   }
 
   if (currentRows.length > 0) {
-    chunks.push(renderTable(currentRows, widths, thirdColumnLabel));
+    chunks.push(render(currentRows));
   }
 
   return chunks;
 }
 
+function getEndedColumnWidths(rows: EndedRow[]): { nameWidth: number; timeWidth: number } {
+  return {
+    nameWidth: Math.max(5, ...rows.map((r) => r.name.length)),
+    timeWidth: Math.max(5, ...rows.map((r) => r.time.length)),
+  };
+}
+
+function renderEndedTable(
+  rows: EndedRow[],
+  widths: { nameWidth: number; timeWidth: number }
+): string {
+  const { nameWidth, timeWidth } = widths;
+  const sep = " | ";
+  const header = `${pad("Timer", nameWidth)}${sep}${pad("Ended", timeWidth)}`;
+  const divider = "-".repeat(header.length);
+
+  const lines = [
+    header,
+    divider,
+    ...rows.map((r) => `${pad(r.name, nameWidth)}${sep}${pad(r.time, timeWidth)}`),
+  ];
+
+  return "```\n" + lines.join("\n") + "\n```";
+}
+
 /**
  * Update the timer channel with current timer status using standard message embeds.
  */
@@ -116,6 +143,7 @@ export async function updateTimersChannel(client: Client): Promise<void> {
   const futureRows: TableRow[] = [];
   const upcomingRows: TableRow[] = [];
   const inWindowRows: TableRow[] = [];
+  const endedRows: EndedRow[] = [];
 
   for (const timer of sortedTimers) {
     if (!timer.lastTod) continue;
@@ -142,6 +170,16 @@ export async function updateTimersChannel(client: Client): Promise<void> {
           remainingMs,
         });
       }
+    } else if (
+      endsAt.getTime() < now.getTime() &&
+      now.getTime() - endsAt.getTime() <= ENDED_RECENTLY_WINDOW_MS
+    ) {
+      const endedMsAgo = now.getTime() - endsAt.getTime();
+      endedRows.push({
+        name: getDisplayName(timer.name, timer.skipCount),
+        time: formatMinutesSecondsAgo(endsAt, now),
+        endedMsAgo,
+      });
     } else if (startsAt.getTime() <= now.getTime() + 24 * 60 * 60 * 1000) {
       const remainingMs = startsAt.getTime() - now.getTime();
       upcomingRows.push({
@@ -165,6 +203,8 @@ export async function updateTimersChannel(client: Client): Promise<void> {
   futureRows.sort((a, b) => b.remainingMs - a.remainingMs);
   upcomingRows.sort((a, b) => b.remainingMs - a.remainingMs);
   inWindowRows.sort((a, b) => b.remainingMs - a.remainingMs);
+  // Most recently ended at the bottom, oldest at the top
+  endedRows.sort((a, b) => b.endedMsAgo - a.endedMsAgo);
 
   const embeds: EmbedBuilder[] = [];
 
@@ -177,7 +217,7 @@ export async function updateTimersChannel(client: Client): Promise<void> {
   // Future window embed(s)
   if (SHOW_FUTURE_WINDOW?.toLowerCase() === "true" && futureRows.length > 0) {
     const widths = getColumnWidths(futureRows);
-    const descChunks = chunkTable(futureRows, MAX_DESCRIPTION_LENGTH, widths);
+    const descChunks = chunkRows(futureRows, MAX_DESCRIPTION_LENGTH, (rs) => renderTable(rs, widths));
     for (let i = 0; i < descChunks.length; i++) {
       const embed = new EmbedBuilder().setDescription(descChunks[i]);
       if (i === 0) embed.setTitle("Future Windows");
@@ -188,7 +228,7 @@ export async function updateTimersChannel(client: Client): Promise<void> {
   // Upcoming embed(s)
   if (upcomingRows.length > 0) {
     const widths = getColumnWidths(upcomingRows);
-    const descChunks = chunkTable(upcomingRows, MAX_DESCRIPTION_LENGTH, widths);
+    const descChunks = chunkRows(upcomingRows, MAX_DESCRIPTION_LENGTH, (rs) => renderTable(rs, widths));
     for (let i = 0; i < descChunks.length; i++) {
       const embed = new EmbedBuilder().setDescription(descChunks[i]);
       if (i === 0) embed.setTitle("Mobs Entering Window In The Next 24 Hours");
@@ -199,7 +239,7 @@ export async function updateTimersChannel(client: Client): Promise<void> {
   // In-window embed(s)
   if (anyInWindow) {
     const widths = getColumnWidths(inWindowRows);
-    const descChunks = chunkTable(inWindowRows, MAX_DESCRIPTION_LENGTH, widths, "%");
+    const descChunks = chunkRows(inWindowRows, MAX_DESCRIPTION_LENGTH, (rs) => renderTable(rs, widths, "%"));
     for (let i = 0; i < descChunks.length; i++) {
       const embed = new EmbedBuilder().setColor(0xe67e22).setDescription(descChunks[i]);
       if (i === 0) embed.setTitle("Mobs In Window");
@@ -215,6 +255,17 @@ export async function updateTimersChannel(client: Client): Promise<void> {
     );
   }
 
+  // Ended recently embed(s)
+  if (endedRows.length > 0) {
+    const widths = getEndedColumnWidths(endedRows);
+    const descChunks = chunkRows(endedRows, MAX_DESCRIPTION_LENGTH, (rs) => renderEndedTable(rs, widths));
+    for (let i = 0; i < descChunks.length; i++) {
+      const embed = new EmbedBuilder().setColor(0x95a5a6).setDescription(descChunks[i]);
+      if (i === 0) embed.setTitle("Ended Recently");
+      embeds.push(embed);
+    }
+  }
+
   // Discord allows at most 10 embeds per message
   embeds.splice(MAX_EMBEDS_PER_MESSAGE);
 

src/features/spawn-timers/commands/helpers/duration.test.ts

@@ -1,4 +1,9 @@
-import { parseDuration, formatDuration, formatTimeDistance } from "./duration";
+import {
+  parseDuration,
+  formatDuration,
+  formatTimeDistance,
+  formatMinutesSecondsAgo,
+} from "./duration";
 
 describe("parseDuration", () => {
   it("should parse various duration formats", () => {
@@ -68,3 +73,17 @@ describe("formatTimeDistance", () => {
     expect(formatTimeDistance(past, now)).toBe("2h");
   });
 });
+
+describe("formatMinutesSecondsAgo", () => {
+  it("should always include both minutes and seconds", () => {
+    const now = new Date("2021-05-27T05:57:45Z");
+    expect(formatMinutesSecondsAgo(new Date("2021-05-27T05:57:00Z"), now)).toBe("0m 45s ago");
+    expect(formatMinutesSecondsAgo(new Date("2021-05-27T05:52:45Z"), now)).toBe("5m 0s ago");
+    expect(formatMinutesSecondsAgo(new Date("2021-05-27T05:53:12Z"), now)).toBe("4m 33s ago");
+  });
+
+  it("should clamp to zero for times not in the past", () => {
+    const now = new Date("2021-05-27T05:57:00Z");
+    expect(formatMinutesSecondsAgo(new Date("2021-05-27T05:58:00Z"), now)).toBe("0m 0s ago");
+  });
+});

src/features/spawn-timers/commands/helpers/duration.ts

@@ -129,6 +129,16 @@ export function formatTimeAgo(time: Date, now: Date = new Date()): string {
   return formatTimeDistance(time, now) + " ago";
 }
 
+/**
+ * Format how long ago a time was as "Xm Ys ago", always including both units.
+ */
+export function formatMinutesSecondsAgo(time: Date, now: Date = new Date()): string {
+  const diffSeconds = Math.floor(Math.max(0, now.getTime() - time.getTime()) / 1000);
+  const minutes = Math.floor(diffSeconds / 60);
+  const seconds = diffSeconds % 60;
+  return `${minutes}m ${seconds}s ago`;
+}
+
 /**
  * Format a Date as a Discord Hammertime timestamp.
  * Default style is relative (R), which renders dynamically in Discord

src/features/spawn-timers/commands/prefix-adapter.test.ts

@@ -0,0 +1,42 @@
+import { buildTodAdapter } from "./prefix-adapter";
+
+function fakeMessage(content: string): any {
+  return { content, author: { id: "1", username: "tester" } };
+}
+
+describe("buildTodAdapter", () => {
+  it("should extract a trailing #<n> as skip_count", () => {
+    const adapter = buildTodAdapter(fakeMessage("!tod lodi 7/26 04:04:10#1"));
+    expect(adapter.options.getString("mob")).toBe("lodi");
+    expect(adapter.options.getString("time")).toBe("7/26 04:04:10");
+    expect(adapter.options.getInteger("skip_count")).toBe(1);
+  });
+
+  it("should extract #<n> when separated by a space", () => {
+    const adapter = buildTodAdapter(fakeMessage("!tod lodi 7/26 04:04:10 #2"));
+    expect(adapter.options.getString("mob")).toBe("lodi");
+    expect(adapter.options.getString("time")).toBe("7/26 04:04:10");
+    expect(adapter.options.getInteger("skip_count")).toBe(2);
+  });
+
+  it("should extract #<n> from the negative-minutes shorthand", () => {
+    const adapter = buildTodAdapter(fakeMessage("!tod lodi -20#1"));
+    expect(adapter.options.getString("mob")).toBe("lodi");
+    expect(adapter.options.getString("time")).toBe("-20");
+    expect(adapter.options.getInteger("skip_count")).toBe(1);
+  });
+
+  it("should extract #<n> when no time is given", () => {
+    const adapter = buildTodAdapter(fakeMessage("!tod lodi #1"));
+    expect(adapter.options.getString("mob")).toBe("lodi");
+    expect(adapter.options.getString("time")).toBe(null);
+    expect(adapter.options.getInteger("skip_count")).toBe(1);
+  });
+
+  it("should default skip_count to null when no #<n> is present", () => {
+    const adapter = buildTodAdapter(fakeMessage("!tod lodi 7/26 04:04:10"));
+    expect(adapter.options.getString("mob")).toBe("lodi");
+    expect(adapter.options.getString("time")).toBe("7/26 04:04:10");
+    expect(adapter.options.getInteger("skip_count")).toBe(null);
+  });
+});

src/features/spawn-timers/commands/prefix-adapter.ts

@@ -48,12 +48,21 @@ export class PrefixInteractionAdapter {
 }
 
 export function buildTodAdapter(message: Message): PrefixInteractionAdapter {
-  const raw = message.content.slice(4).trim(); // strip "!tod"
+  let raw = message.content.slice(4).trim(); // strip "!tod"
+
+  // A trailing "#<n>" indicates a skip count, e.g. "lodi 7/26 04:04:10#1"
+  let skipCount: number | null = null;
+  const skipMatch = raw.match(/#(\d+)\s*$/);
+  if (skipMatch) {
+    skipCount = parseInt(skipMatch[1], 10);
+    raw = raw.slice(0, skipMatch.index).trim();
+  }
+
   const [mob, time] = parseArguments(raw);
   const args = new Map<string, string | number | null>([
     ["mob", mob],
     ["time", time],
-    ["skip_count", null],
+    ["skip_count", skipCount],
   ]);
   return new PrefixInteractionAdapter(message, args);
 }

src/features/spawn-timers/commands/register.ts

@@ -75,6 +75,8 @@ class RegisterCommand extends SimpleCommand {
           windowEnd,
           variance,
           skipCount: 0,
+          alerted: null,
+          alertingSoon: false,
         },
       });
     } else {