Merge branch 'master' of github.com:ZeppelinBot/Zeppelin

Author: Dragory

backend/src/plugins/Logs/types.ts

@@ -23,6 +23,7 @@ import {
 } from "../../utils/templateSafeObjects.js";
 import { TemplateSafeValueContainer } from "../../templateFormatter.js";
 import DefaultLogMessages from "../../data/DefaultLogMessages.json" with { type: "json" };
+import { TemplateSafeValueContainer } from "templateFormatter.js";
 
 const DEFAULT_BATCH_TIME = 1000;
 const MIN_BATCH_TIME = 250;

backend/src/plugins/WelcomeMessage/events/SendWelcomeMessageEvt.ts

@@ -1,6 +1,13 @@
-import { Snowflake, TextChannel } from "discord.js";
+import { PermissionsBitField, Snowflake, TextChannel } from "discord.js";
 import { TemplateParseError, TemplateSafeValueContainer, renderTemplate } from "../../../templateFormatter.js";
-import { createChunkedMessage, verboseChannelMention, verboseUserMention } from "../../../utils.js";
+import {
+  createChunkedMessage,
+  renderRecursively,
+  verboseChannelMention,
+  verboseUserMention
+} from "../../../utils.js";
+import { MessageContent } from "../../../utils.js";
+import { hasDiscordPermissions } from "../../../utils/hasDiscordPermissions.js";
 import { sendDM } from "../../../utils/sendDM.js";
 import {
   guildToTemplateSafeGuild,
@@ -28,25 +35,27 @@ export const SendWelcomeMessageEvt = welcomeMessageEvt({
 
     pluginData.state.sentWelcomeMessages.add(member.id);
 
-    let formatted;
+    const templateValues = new TemplateSafeValueContainer({
+      member: memberToTemplateSafeMember(member),
+      user: userToTemplateSafeUser(member.user),
+      guild: guildToTemplateSafeGuild(member.guild),
+    });
+
+    const renderMessageText = (str: string) => renderTemplate(str, templateValues);
+
+    let formatted: MessageContent;
 
     try {
-      formatted = await renderTemplate(
-        config.message,
-        new TemplateSafeValueContainer({
-          member: memberToTemplateSafeMember(member),
-          user: userToTemplateSafeUser(member.user),
-          guild: guildToTemplateSafeGuild(member.guild),
-        }),
-      );
+      formatted = typeof config.message === "string"
+        ? await renderMessageText(config.message)
+        : ((await renderRecursively(config.message, renderMessageText)) as MessageContent);
     } catch (e) {
       if (e instanceof TemplateParseError) {
         pluginData.getPlugin(LogsPlugin).logBotAlert({
           body: `Error formatting welcome message: ${e.message}`,
         });
         return;
       }
-
       throw e;
     }
 
@@ -65,17 +74,49 @@ export const SendWelcomeMessageEvt = welcomeMessageEvt({
       const channel = meta.args.member.guild.channels.cache.get(config.send_to_channel as Snowflake);
       if (!channel || !(channel instanceof TextChannel)) return;
 
-      try {
-        await createChunkedMessage(channel, formatted, {
-          parse: ["users"],
+      if (
+        !hasDiscordPermissions(
+          channel.permissionsFor(pluginData.client.user!.id),
+          PermissionsBitField.Flags.SendMessages | PermissionsBitField.Flags.ViewChannel,
+        )
+      ) {
+        pluginData.getPlugin(LogsPlugin).logBotAlert({
+          body: `Missing permissions to send welcome message in ${verboseChannelMention(channel)}`,
         });
+        return;
+      }
+
+      if (
+        typeof formatted === "object" && formatted.embeds && formatted.embeds.length > 0 &&
+        !hasDiscordPermissions(
+          channel.permissionsFor(pluginData.client.user!.id),
+          PermissionsBitField.Flags.EmbedLinks,
+        )
+      ) {
+        pluginData.getPlugin(LogsPlugin).logBotAlert({
+          body: `Missing permissions to send welcome message **with embeds** in ${verboseChannelMention(channel)}`,
+        });
+        return;
+      }
+
+      try {
+        if (typeof formatted === "string") {
+          await createChunkedMessage(channel, formatted, {
+            parse: ["users"],
+          });
+        } else {
+          await channel.send({
+            ...formatted,
+            allowedMentions: {
+              parse: ["users"],
+            },
+          });
+        }
       } catch {
         pluginData.getPlugin(LogsPlugin).logBotAlert({
-          body: `Failed send a welcome message for ${verboseUserMention(member.user)} to ${verboseChannelMention(
-            channel,
-          )}`,
+          body: `Failed to send welcome message for ${verboseUserMention(member.user)} to ${verboseChannelMention(channel)}`,
         });
       }
     }
   },
-});
+});

backend/src/plugins/WelcomeMessage/types.ts

@@ -1,11 +1,12 @@
 import { BasePluginType, guildPluginEventListener } from "vety";
 import { z } from "zod";
 import { GuildLogs } from "../../data/GuildLogs.js";
+import { zMessageContent } from "../../utils.js";
 
 export const zWelcomeMessageConfig = z.strictObject({
   send_dm: z.boolean().default(false),
   send_to_channel: z.string().nullable().default(null),
-  message: z.string().nullable().default(null),
+  message: zMessageContent.nullable().default(null),
 });
 
 export interface WelcomeMessagePluginType extends BasePluginType {

backend/src/utils.ts

@@ -1,5 +1,7 @@
 import {
+  ActionRowBuilder,
   APIEmbed,
+  ButtonBuilder,
   ChannelType,
   Client,
   DiscordAPIError,
@@ -18,6 +20,7 @@ import {
   InviteType,
   LimitedCollection,
   Message,
+  MessageActionRowComponentBuilder,
   MessageCreateOptions,
   MessageMentionOptions,
   PartialGroupDMChannel,
@@ -1306,6 +1309,20 @@ export async function confirm(
   return waitForButtonConfirm(context, content, { restrictToId: userId });
 }
 
+export function createDisabledButtonRow(
+  row: ActionRowBuilder<MessageActionRowComponentBuilder>
+): ActionRowBuilder<MessageActionRowComponentBuilder> {
+  const newRow = new ActionRowBuilder<MessageActionRowComponentBuilder>();
+  for (const component of row.components) {
+    if (component instanceof ButtonBuilder) {
+      newRow.addComponents(
+        ButtonBuilder.from(component).setDisabled(true)
+      );
+    }
+  }
+  return newRow;
+}
+
 export function messageSummary(msg: SavedMessage) {
   // Regular text content
   let result = "```\n" + (msg.data.content ? escapeCodeBlock(msg.data.content) : "<no text content>") + "```";

backend/src/utils/sendDM.ts

@@ -1,6 +1,7 @@
-import { MessagePayload, User } from "discord.js";
+import { User } from "discord.js";
 import { logger } from "../logger.js";
 import { HOURS, createChunkedMessage, isDiscordAPIError } from "../utils.js";
+import { MessageContent } from "../utils.js";
 import Timeout = NodeJS.Timeout;
 
 let dmsDisabled = false;
@@ -16,7 +17,11 @@ export class DMError extends Error {}
 
 const error20026 = "The bot cannot currently send DMs";
 
-export async function sendDM(user: User, content: string | MessagePayload, source: string) {
+export async function sendDM(
+  user: User,
+  content: MessageContent,
+  source: string,
+) {
   if (dmsDisabled) {
     throw new DMError(error20026);
   }
@@ -36,7 +41,6 @@ export async function sendDM(user: User, content: string | MessagePayload, sourc
       disableDMs(1 * HOURS);
       throw new DMError(error20026);
     }
-
     throw e;
   }
-}
+}

backend/src/utils/waitForInteraction.ts

@@ -9,7 +9,7 @@ import {
 import moment from "moment-timezone";
 import { v4 as uuidv4 } from "uuid";
 import { GenericCommandSource, isContextInteraction, sendContextResponse } from "../pluginUtils.js";
-import { noop } from "../utils.js";
+import { noop, createDisabledButtonRow } from "../utils.js";
 
 export async function waitForButtonConfirm(
   context: GenericCommandSource,
@@ -24,34 +24,42 @@ export async function waitForButtonConfirm(
         .setStyle(ButtonStyle.Success)
         .setLabel(options?.confirmText || "Confirm")
         .setCustomId(`confirmButton:${idMod}:${uuidv4()}`),
-
       new ButtonBuilder()
         .setStyle(ButtonStyle.Danger)
         .setLabel(options?.cancelText || "Cancel")
         .setCustomId(`cancelButton:${idMod}:${uuidv4()}`),
     ]);
     const message = await sendContextResponse(context, { ...toPost, components: [row] }, true);
-
     const collector = message.createMessageComponentCollector({ time: 10000 });
 
     collector.on("collect", (interaction: MessageComponentInteraction) => {
       if (options?.restrictToId && options.restrictToId !== interaction.user.id) {
         interaction
           .reply({ content: `You are not permitted to use these buttons.`, ephemeral: true })
-          // tslint:disable-next-line no-console
-          .catch((err) => console.trace(err.message));
-      } else {
-        if (interaction.customId.startsWith(`confirmButton:${idMod}:`)) {
-          if (!contextIsInteraction) message.delete();
-          resolve(true);
-        } else if (interaction.customId.startsWith(`cancelButton:${idMod}:`)) {
-          if (!contextIsInteraction) message.delete();
-          resolve(false);
+          .catch(noop);
+      } else if (interaction.customId.startsWith(`confirmButton:${idMod}:`)) {
+        if (!contextIsInteraction) {
+          message.delete().catch(noop);
+        } else {
+          interaction.update({ components: [createDisabledButtonRow(row)] }).catch(noop);
+        }
+        resolve(true);
+      } else if (interaction.customId.startsWith(`cancelButton:${idMod}:`)) {
+        if (!contextIsInteraction) {
+          message.delete().catch(noop);
+        } else {
+          interaction.update({ components: [createDisabledButtonRow(row)] }).catch(noop);
         }
+        resolve(false);
       }
     });
+
     collector.on("end", () => {
-      if (!contextIsInteraction && message.deletable) message.delete().catch(noop);
+      if (!contextIsInteraction) {
+        if (message.deletable) message.delete().catch(noop);
+      } else {
+        message.edit({ components: [createDisabledButtonRow(row)] }).catch(noop);
+      }
       resolve(false);
     });
   });