Send out expired reminders (for when the bot was down), count guild scheduled events, fix obscure bugs

cakedan · cakedan · commit 5f1bb585c726 · 2022-05-26T01:47:32.000-04:00
- Fixed a bug with disabling commands for roles/channels/users
- Fixed a bug where time would default to AM instead of PM in reminders
- Fix emojis not working properly in image commands
diff --git a/package-lock.json b/package-lock.json
diff --git a/src/api/raw.ts b/src/api/raw.ts
@@ -1876,6 +1876,7 @@ export async function putInfoDiscord(
         emojis: x.emojis,
         events: x.events,
         guilds: x.guilds,
+        guild_scheduled_events: x.guildScheduledEvents,
         members: x.members,
         member_count: x.memberCount,
         messages: x.messages,
@@ -1927,6 +1928,7 @@ export async function putUser(
   const body = {
     avatar: options.avatar,
     bot: options.bot,
+    blocked: options.blocked,
     channel_id: options.channelId,
     discriminator: options.discriminator,
     locale: options.locale,
diff --git a/src/api/types.ts b/src/api/types.ts
@@ -309,6 +309,7 @@ export namespace RestOptions {
       emojis?: number,
       events?: number,
       guilds?: number,
+      guildScheduledEvents?: number,
       members?: number,
       memberCount?: number,
       messages?: number,
@@ -332,6 +333,7 @@ export namespace RestOptions {
   export interface PutUser {
     avatar: null | string,
     bot: boolean,
+    blocked?: boolean,
     channelId?: null | string,
     discriminator: string,
     locale?: null | string,
diff --git a/src/commandclient.ts b/src/commandclient.ts
@@ -1,5 +1,7 @@
 import { Command, CommandClient } from 'detritus-client';
 
+import { CommandMetadata } from './commands/prefixed/basecommand';
+
 import { GuildAllowlistTypes, GuildBlocklistTypes, GuildDisableCommandsTypes } from './constants';
 import GuildSettingsStore from './stores/guildsettings';
 import UserStore from './stores/users';
@@ -30,10 +32,15 @@ export class NotSoCommandClient extends CommandClient {
       return true;
     }
 
+    const metadata = command.metadata as CommandMetadata;
+    const commandId = metadata.id || command.name.split(' ').join('.');
+
     const channel = context.channel;
     const parent = (channel) ? channel.parent : null;
     if (settings) {
-      const disabledCommands = settings.disabledCommands.filter((disabled) => disabled.command === command.name);
+      const disabledCommands = settings.disabledCommands.filter((disabled) => {
+        return disabled.command === commandId;
+      });
       if (disabledCommands.length) {
         const shouldIgnore = disabledCommands.some((disabled) => {
           switch (disabled.type) {
diff --git a/src/commands/interactions/basecommand.ts b/src/commands/interactions/basecommand.ts
@@ -256,6 +256,31 @@ export class BaseInteractionCommand<ParsedArgsFinished = Interaction.ParsedArgs>
       }
     }
   }
+
+  onValueError(context: Interaction.InteractionContext, args: ParsedArgsFinished, errors: Interaction.ParsedErrors) {
+    const embed = new Embed();
+    embed.setColor(EmbedColors.ERROR);
+    embed.setTitle(`⚠ ${this.error} Argument Error`);
+
+    const store: {[key: string]: string} = {};
+
+    const description: Array<string> = ['Invalid Arguments' + '\n'];
+    for (let key in errors) {
+      const message = errors[key].message;
+      if (message in store) {
+        description.push(`**${key}**: Same error as **${store[message]}**`);
+      } else {
+        description.push(`**${key}**: ${message}`);
+      }
+      store[message] = key;
+    }
+  
+    embed.setDescription(description.join('\n'));
+    return editOrReply(context, {
+      embed,
+      flags: MessageFlags.EPHEMERAL,
+    });
+  }
 }
 
 
diff --git a/src/commands/prefixed/moderation/commands.disable.ts b/src/commands/prefixed/moderation/commands.disable.ts
@@ -6,7 +6,7 @@ import { createGuildDisabledCommand, editGuildSettings } from '../../../api';
 import { GuildSettings } from '../../../api/structures/guildsettings';
 import { CommandCategories, GuildDisableCommandsTypes } from '../../../constants';
 import GuildSettingsStore from '../../../stores/guildsettings';
-import { Parameters } from '../../../utils';
+import { Parameters, editOrReply } from '../../../utils';
 
 import { BaseCommand } from '../basecommand';
 
@@ -90,15 +90,15 @@ export default class CommandsDisable extends BaseCommand {
       if (args.users && !args.users.length) {
         errors.push('users');
       }
-      return context.editOrReply(`⚠ Unable to find the provided ${errors.join(', ')}.`);
+      return editOrReply(context, `⚠ Unable to find the provided ${errors.join(', ')}.`);
     }
-    return context.editOrReply('⚠ Unknown Command');
+    return editOrReply(context, '⚠ Unknown Command');
   }
 
   async run(context: Command.Context, args: CommandArgs) {
     const { command } = args;
     const commandId = (command.metadata && command.metadata.id) ? command.metadata.id : command.name.split(' ').join('.');
-    const guildId = context.guildId as string;
+    const guildId = context.guildId!;
 
     const isServerWide = !args.channels && !args.roles && !args.users;
 
@@ -135,7 +135,7 @@ export default class CommandsDisable extends BaseCommand {
       for (let payload of payloads) {
         const key = `${commandId}.${payload.item.id}.${payload.type}`;
         if (!settings.disabledCommands.has(key)) {
-          await createGuildDisabledCommand(context, guildId, command.name, payload.item.id, payload.type);
+          await createGuildDisabledCommand(context, guildId, commandId, payload.item.id, payload.type);
         }
       }
       settings = await GuildSettingsStore.fetch(context, guildId) as GuildSettings;
diff --git a/src/commands/prefixed/moderation/commands.enable.ts b/src/commands/prefixed/moderation/commands.enable.ts
@@ -114,7 +114,7 @@ export default class CommandsEnable extends BaseCommand {
   async run(context: Command.Context, args: CommandArgs) {
     const { command } = args;
     const commandId = (command.metadata && command.metadata.id) ? command.metadata.id : command.name.split(' ').join('.');
-    const guildId = context.guildId as string;
+    const guildId = context.guildId!;
 
     const isServerWide = !args.channels && !args.roles && !args.users;
 
diff --git a/src/commands/prefixed/utils/shards.ts b/src/commands/prefixed/utils/shards.ts
@@ -28,6 +28,7 @@ export interface ClusterObjectInformation {
   emojis: number,
   events: number,
   guilds: number,
+  guildScheduledEvents: number,
   members: number,
   memberCount: number,
   messages: number,
@@ -59,6 +60,7 @@ export async function getClusterInformation(context: Command.Context): Promise<A
           emojis: 0,
           events: 0,
           guilds: 0,
+          guildScheduledEvents: 0,
           members: 0,
           memberCount: 0,
           messages: 0,
@@ -89,6 +91,7 @@ export async function getClusterInformation(context: Command.Context): Promise<A
           information.objects.emojis += shard.emojis.length;
           information.objects.events += shard.gateway.sequence;
           information.objects.guilds += shard.guilds.length;
+          information.objects.guildScheduledEvents += shard.guildScheduledEvents.length;
           information.objects.members += shard.members.length;
           information.objects.memberCount += shard.guilds.reduce((x, guild) => x + guild.memberCount, 0);
           information.objects.messages += shard.messages.length;
diff --git a/src/constants.ts b/src/constants.ts
@@ -11,13 +11,14 @@ import {
 } from 'detritus-client/lib/constants';
 
 
-
 export const MAX_MEMBERS_SAFE = 1000;
 
 export const MOMENT_FORMAT = 'y [years], w [weeks], d [days], h [hours], m [minutes], s [seconds]';
 export const SNOWFLAKE_EPOCH = 1564790400000;
 export const ZERO_WIDTH_SPACE = '\u200b';
 
+export const ONE_DAY = 24 * 60 * 60 * 1000;
+
 
 export enum BooleanEmojis {
   NO = '❌',
diff --git a/src/interactioncommandclient.ts b/src/interactioncommandclient.ts
@@ -35,16 +35,14 @@ export class NotSoInteractionClient extends InteractionCommandClient {
       return true;
     }
 
-    const metadata = (command.metadata.id) ? (command.metadata as InteractionCommandMetadata) : null;
+    const metadata = command.metadata as InteractionCommandMetadata;
+    const commandId = metadata.id || command.name.split(' ').join('.');
 
     const channel = context.channel;
     const parent = (channel) ? channel.parent : null;
     if (settings) {
       const disabledCommands = settings.disabledCommands.filter((disabled) => {
-        if (metadata) {
-          return metadata.id === disabled.command;
-        }
-        return command.name === disabled.command;
+        return disabled.command === commandId;
       });
       if (disabledCommands.length) {
         const shouldIgnore = disabledCommands.some((disabled) => {
diff --git a/src/listeners/clusterinfointerval.ts b/src/listeners/clusterinfointerval.ts
@@ -43,6 +43,7 @@ class ClusterInfoInterval extends Listener {
               emojis: shard.emojis.length,
               events: shard.gateway.sequence,
               guilds: shard.guilds.length,
+              guildScheduledEvents: shard.guildScheduledEvents.length,
               members: shard.members.length,
               memberCount: shard.guilds.reduce((x, guild) => x + guild.memberCount, 0),
               messages: shard.messages.length,
diff --git a/src/listeners/reminders.ts b/src/listeners/reminders.ts
@@ -7,24 +7,36 @@ import { Listener } from './listener';
 
 import { deleteReminder, fetchReminders } from '../api';
 import { RestResponsesRaw } from '../api/types';
-import { RedisChannels, SNOWFLAKE_EPOCH } from '../constants';
+import { RedisChannels, ONE_DAY, SNOWFLAKE_EPOCH } from '../constants';
 import { RedisSpewer } from '../redis';
 import { RedisPayloads } from '../types';
 import { createTimestampMomentFromGuild, getReminderMessage } from '../utils';
 
 
-
 export interface ReminderItem {
   reminder: RestResponsesRaw.Reminder,
   timeout: Timers.Timeout,
 }
 
 class ReminderInterval extends Listener {
-  // every 6 hours we will scan for reminders for the next hour
+  // every 12 hours we will scan for reminders for the next 12 hour
   interval = new Timers.Interval();
-  intervalTime = 6 * 60 * 60 * 1000;
+  intervalTime = 12 * 60 * 60 * 1000;
   reminders = new Collections.BaseCollection<string, ReminderItem>();
 
+  createReminderText(reminder: RestResponsesRaw.Reminder, expired: boolean = false): string {
+    const createdAtUnix = Snowflake.timestamp(reminder.id, {epoch: SNOWFLAKE_EPOCH});
+    const text = (reminder.content) ? Markup.codestring(reminder.content) : getReminderMessage(reminder.id);
+
+    const mention = `<@${reminder.user.id}>`;
+    const timestampText = Markup.timestamp(createdAtUnix, MarkupTimestampStyles.RELATIVE);
+    if (expired) {
+      const expiredTimestampText = Markup.timestamp(Date.parse(reminder.timestamp_start));
+      return `${mention}, an expired reminder from ${timestampText} for ${expiredTimestampText}: ${text}`;
+    }
+    return `${mention}, reminder from ${timestampText}: ${text}`;
+  }
+
   insertReminder(cluster: ClusterClient, reminder: RestResponsesRaw.Reminder): void {
     const shard = cluster.shards.first();
     if (!shard) {
@@ -37,24 +49,41 @@ class ReminderInterval extends Listener {
 
     const now = Date.now();
     const timestamp = Date.parse(reminder.timestamp_start);
-    const duration = timestamp - now;
+    const duration = Math.max(timestamp - now, 0);
     if (this.intervalTime < duration) {
       // ignore this guy since he's so far into the future
       return;
     }
 
     const timeout = new Timers.Timeout();
     timeout.start(duration, async () => {
-      const allowedMentions = {
-        repliedUser: true,
-        users: [reminder.user.id],
-      };
-      const createdAtUnix = Snowflake.timestamp(reminder.id, {epoch: SNOWFLAKE_EPOCH});
-      const text = (reminder.content) ? Markup.codestring(reminder.content) : getReminderMessage(reminder.id);
-      const content = `<@${reminder.user.id}>, reminder from ${Markup.timestamp(createdAtUnix, MarkupTimestampStyles.RELATIVE)}: ${text}`;
-
-      let channelId = reminder.channel_id || reminder.channel_id_backup;
-      let dmChannelId = reminder.channel_id_backup;
+      const content = this.createReminderText(reminder);
+      await this.executeReminder(shard, reminder, content);
+    });
+    this.reminders.set(reminder.id, {reminder, timeout});
+  }
+
+  removeReminder(reminderId: string): void {
+    if (this.reminders.has(reminderId)) {
+      const item = this.reminders.get(reminderId)!;
+      item.timeout.stop();
+      this.reminders.delete(reminderId);
+    }
+  }
+
+  async executeReminder(
+    shard: ShardClient,
+    reminder: RestResponsesRaw.Reminder,
+    content: string,
+  ): Promise<void> {
+    const allowedMentions = {
+      repliedUser: true,
+      users: [reminder.user.id],
+    };
+
+    let channelId = reminder.channel_id || reminder.channel_id_backup;
+    let dmChannelId = reminder.channel_id_backup;
+    try {
       try {
         // channelId then channelIdBackup then fetchDm channel
         // maybe check perms using eval
@@ -93,32 +122,24 @@ class ReminderInterval extends Listener {
         }
       } finally {
         this.removeReminder(reminder.id);
-        return deleteReminder({client: shard}, reminder.id);
+        await deleteReminder({client: shard}, reminder.id);
       }
-    });
-    this.reminders.set(reminder.id, {reminder, timeout});
-  }
+    } catch(e) {
 
-  removeReminder(reminderId: string): void {
-    if (this.reminders.has(reminderId)) {
-      const item = this.reminders.get(reminderId)!;
-      item.timeout.stop();
-      this.reminders.delete(reminderId);
     }
   }
 
-  async scanForReminders(cluster: ClusterClient) {
-    const shard = cluster.shards.first();
-    if (!shard) {
-      return;
-    }
+  async fetchReminders(
+    shard: ShardClient,
+    timestampMin: number,
+    timestampMax: number,
+  ): Promise<Collections.BaseCollection<string, RestResponsesRaw.Reminder>> {
+    const reminders = new Collections.BaseCollection<string, RestResponsesRaw.Reminder>();
 
     let count = -1;
 
     let after: string | undefined;
     const limit = 1000;
-    const timestampMax = Date.now() + this.intervalTime;
-    const timestampMin = Date.now();
     while (count === -1 || limit < count) {
       const response = await fetchReminders({client: shard}, {
         after,
@@ -127,10 +148,39 @@ class ReminderInterval extends Listener {
         timestampMin,
       });
       count = response.count;
-      for (let x of response.reminders) {
-        this.insertReminder(cluster, x);
+      for (let reminder of response.reminders) {
+        reminders.set(reminder.id, reminder);
       }
     }
+
+    return reminders;
+  }
+
+  async scanForRemindersExpired(cluster: ClusterClient) {
+    const shard = cluster.shards.first();
+    if (!shard) {
+      return;
+    }
+
+    // Maybe limit to less than a week old?
+    const reminders = await this.fetchReminders(shard, 0, Date.now());
+    for (let [reminderId, reminder] of reminders) {
+      const content = this.createReminderText(reminder, true);
+      await this.executeReminder(shard, reminder, content);
+    }
+  }
+
+  async scanForReminders(cluster: ClusterClient) {
+    const shard = cluster.shards.first();
+    if (!shard) {
+      return;
+    }
+
+    // from (now - 2 seconds) to (now + intervalTime (12 hours?))
+    const reminders = await this.fetchReminders(shard, Date.now() - 2000, Date.now() + this.intervalTime);
+    for (let [reminderId, reminder] of reminders) {
+      this.insertReminder(cluster, reminder);
+    }
   }
 
   create(cluster: ClusterClient, redis: RedisSpewer) {
@@ -144,7 +194,6 @@ class ReminderInterval extends Listener {
 
     {
       const subscription = redis.subscribe(RedisChannels.REMINDER_CREATE, async (payload) => {
-        console.log(payload);
         this.insertReminder(cluster, payload);
       });
       subscriptions.push(subscription);
@@ -157,6 +206,7 @@ class ReminderInterval extends Listener {
       subscriptions.push(subscription);
     }
 
+    this.scanForRemindersExpired(cluster);
     this.scanForReminders(cluster);
     this.interval.start(this.intervalTime, this.scanForReminders.bind(this, cluster));
 
diff --git a/src/utils/formatter/commands/reminder.create.ts b/src/utils/formatter/commands/reminder.create.ts
diff --git a/src/utils/parameters/index.ts b/src/utils/parameters/index.ts
