src/services/WelcomerService.ts

/**
 * This file is part of SudoBot.
 *
 * Copyright (C) 2021-2023 OSN Developers.
 *
 * SudoBot is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * SudoBot is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
 */

import { Mutex } from "async-mutex";
import { formatDistanceToNowStrict } from "date-fns";
import {
    ActionRowBuilder,
    ButtonBuilder,
    ButtonStyle,
    ColorResolvable,
    ComponentEmojiResolvable,
    EmbedBuilder,
    GuildMember,
    Interaction,
    Snowflake,
    time
} from "discord.js";
import { readFile } from "fs/promises";
import JSON5 from "json5";
import Service from "../core/Service";
import { GatewayEventListener } from "../decorators/GatewayEventListener";
import { NotUndefined } from "../types/NotUndefined";
import { log, logError, logWarn } from "../utils/Logger";
import { pick, sudoPrefix } from "../utils/utils";
import { GuildConfig } from "./ConfigManager";

export const name = "welcomer";

export default class WelcomerService extends Service {
    welcomeMessages: string[] = [];
    mutexes: Record<Snowflake, Mutex | undefined> = {};

    @GatewayEventListener("ready")
    async onReady() {
        log("Loading welcome messages...");
        this.welcomeMessages = JSON5.parse(
            await readFile(sudoPrefix("resources/welcome_messages.json"), { encoding: "utf-8" })
        );
    }

    @GatewayEventListener("guildMemberAdd")
    async onGuildMemberAdd(member: GuildMember) {
        if (member.user.bot) return;

        const config = this.client.configManager.config[member.guild.id];

        if (!config) return;

        const { welcomer } = config;

        if (!welcomer?.enabled) return;

        const {
            channel: channelId,
            embed,
            say_hi_button,
            custom_message,
            randomize,
            mention,
            say_hi_expire_after,
            delete_messages
        } = welcomer;

        if (!custom_message && !randomize) return;

        try {
            const channel =
                member.guild.channels.cache.get(channelId) ??
                (await member.guild.channels.fetch(channelId));

            if (!channel) return;

            if (!channel.isTextBased()) return;

            const actionRow = say_hi_button
                ? [
                      this.generateActionRow(member.user.id, {
                          say_hi_emoji: welcomer.say_hi_emoji,
                          say_hi_label: welcomer.say_hi_label
                      })
                  ]
                : undefined;

            const reply = await channel.send({
                content: `${mention ? member.user.toString() + "\n" : ""}${
                    !embed ? this.generateContent(member, welcomer) : ""
                }`,
                embeds: embed ? [this.generatedEmbed(member, welcomer)] : undefined,
                components: actionRow
            });

            if (delete_messages) {
                setTimeout(() => {
                    reply.delete().catch(logError);
                }, delete_messages);
            }

            if (actionRow && say_hi_button && say_hi_expire_after) {
                setTimeout(() => {
                    const row = actionRow;

                    row[0].components[0].setDisabled(true);

                    reply
                        .edit({
                            components: row
                        })
                        .catch(logError);
                }, say_hi_expire_after);
            }
        } catch (e) {
            logError(e);
            return;
        }
    }

    @GatewayEventListener("interactionCreate")
    async onInteractionCreate(interaction: Interaction) {
        if (!interaction.isButton()) return;

        const config = this.client.configManager.config[interaction.guild!.id];

        if (!config) return;

        if (
            !interaction.guild?.id ||
            !config.welcomer?.say_hi_button ||
            !interaction.customId.startsWith("welcomer_say_hi__")
        )
            return;

        this.mutexes[interaction.guildId!] ??= new Mutex();
        const wasLocked = this.mutexes[interaction.guildId!]!.isLocked();

        if (!interaction.deferred && !interaction.replied) {
            await interaction.deferUpdate();
        }

        const release = await this.mutexes[interaction.guildId!]!.acquire();
        const saysHiToYou = " says hi to you!";

        if (wasLocked) {
            try {
                interaction.customId = (
                    await interaction.message.fetch(true)
                ).components[0].components[0].customId!;
                log("Refetched custom ID: ", interaction.customId);
            } catch (e) {
                release();
                return;
            }
        }

        const [, memberId, messageId] = interaction.customId.split("__");
        let sayHiReply =
            this.client.configManager.config[interaction.guildId!]?.welcomer?.say_hi_reply;

        if (typeof sayHiReply === "string" && !sayHiReply?.includes(":mentions:")) {
            logWarn(
                "config.welcomer.say_hi_reply does not include :mentions: placeholder, defaulting to the built in message"
            );

            sayHiReply = undefined;
        }

        try {
            if (!messageId) {
                const reply = await interaction[
                    interaction.replied || interaction.deferred ? "followUp" : "reply"
                ]({
                    content:
                        sayHiReply?.replace(/:mentions:/gi, `<@${interaction.user.id}>`) ??
                        `${
                            interaction.user.id === memberId
                                ? "__You__"
                                : interaction.user.toString()
                        }${
                            interaction.user.id === memberId ? " said hi to yourself!" : saysHiToYou
                        }`,
                    fetchReply: true
                });

                const newCustomId = `welcomer_say_hi__${memberId}__${reply.id}`;

                const actionRow = this.generateActionRow(memberId, {
                    say_hi_emoji: config.welcomer?.say_hi_emoji,
                    say_hi_label: config.welcomer?.say_hi_label
                });

                actionRow.components[0].setCustomId(newCustomId);

                await interaction.message.edit({
                    components: [actionRow]
                });

                if (config.welcomer.delete_messages) {
                    const time =
                        interaction.message.createdAt.getTime() +
                        config.welcomer.delete_messages -
                        Date.now();

                    if (time > 1000) {
                        setTimeout(() => {
                            reply.delete().catch(logError);
                        }, time);
                    }
                }
            } else {
                try {
                    if (!interaction.replied && !interaction.deferred) {
                        await interaction.deferUpdate();
                    }

                    const message =
                        interaction.channel?.messages.cache.get(messageId) ??
                        (await interaction.channel?.messages.fetch(messageId));

                    if (!message) {
                        release();
                        return;
                    }

                    const parts = sayHiReply?.split(/:mentions:/i);
                    let contentOrUsers: string | string[] = message.content;
                    let usersArray: string[] | undefined;

                    if (parts !== undefined) {
                        let content = message.content;

                        for (const part of parts) {
                            content = content.replace(part.trim(), "");
                        }

                        content = content.trim();

                        const users = content
                            .split(/\s*,\s*/)
                            .filter((part, index, array) => array.lastIndexOf(part) === index);

                        contentOrUsers = [...users];

                        if (!users.includes(`<@${interaction.user.id}>`)) {
                            users.push(`<@${interaction.user.id}>`);
                        }

                        usersArray = users;
                    }

                    if (
                        contentOrUsers.includes(`${interaction.user.toString()}`) ||
                        (interaction.user.id === memberId && contentOrUsers.includes("__You__"))
                    ) {
                        await interaction.followUp({
                            content: `You've already said hi to ${
                                interaction.user.id === memberId ? "yourself!" : "the user!"
                            }`,
                            ephemeral: true
                        });

                        release();
                        return;
                    }

                    await message.edit({
                        content:
                            sayHiReply === undefined
                                ? `${message.content
                                      .replace(saysHiToYou, "")
                                      .replace(" said hi to yourself!", "")
                                      .trim()}, ${
                                      interaction.user.id === memberId
                                          ? "__You__"
                                          : interaction.user.toString()
                                  }${saysHiToYou}`
                                : sayHiReply.replace(/:mentions:/gi, usersArray!.join(", "))
                    });
                } catch (e) {
                    logError(e);
                }
            }
        } catch (e) {
            logError(e);
        }

        release();
    }

    generateActionRow(
        memberId: string,
        {
            say_hi_emoji,
            say_hi_label
        }: Pick<NotUndefined<GuildConfig["welcomer"]>, "say_hi_emoji" | "say_hi_label">
    ) {
        const emoji =
            !say_hi_emoji || say_hi_emoji === "default"
                ? "👋"
                : this.client.emojis.cache.find(
                      e => e.name === say_hi_emoji || e.identifier === say_hi_emoji
                  );
        const button = new ButtonBuilder()
            .setCustomId(`welcomer_say_hi__${memberId}`)
            .setLabel(say_hi_label ?? "Say Hi!")
            .setStyle(ButtonStyle.Secondary);

        if (emoji)
            button.setEmoji(
                typeof emoji === "string"
                    ? emoji
                    : pick(emoji as Exclude<ComponentEmojiResolvable, string>, [
                          "id",
                          "name",
                          "animated"
                      ])
            );

        return new ActionRowBuilder<ButtonBuilder>().addComponents(button);
    }

    pickRandomWelcomeMessage() {
        return this.welcomeMessages[Math.floor(Math.random() * this.welcomeMessages.length)];
    }

    replacePlaceholders(member: GuildMember, message: string) {
        return message
            .replace(/:tag:/gi, member.user.tag)
            .replace(/:discriminator:/gi, member.user.discriminator)
            .replace(/:createdAt:/gi, `${time(member.user.createdTimestamp)}`)
            .replace(/:age:/gi, formatDistanceToNowStrict(member.user.createdTimestamp))
            .replace(/:mention:/gi, member.user.toString())
            .replace(/:guild:/gi, member.guild.name);
    }

    generateContent(
        member: GuildMember,
        { custom_message, randomize }: NotUndefined<GuildConfig["welcomer"]>
    ) {
        const message = `${randomize ? `${this.pickRandomWelcomeMessage()}\n` : ""}${
            custom_message ? custom_message : ""
        }`;
        return this.replacePlaceholders(member, message);
    }

    generatedEmbed(member: GuildMember, welcomer: NotUndefined<GuildConfig["welcomer"]>) {
        return new EmbedBuilder({
            author: {
                name: member.user.username,
                icon_url: member.displayAvatarURL()
            },
            description: this.generateContent(member, welcomer),
            footer: {
                text: "Welcome"
            }
        })
            .setColor(welcomer.color as ColorResolvable)
            .setTimestamp();
    }
}
1	rakinar2	577	/**
2			* This file is part of SudoBot.
3			*
4			* Copyright (C) 2021-2023 OSN Developers.
5			*
6			* SudoBot is free software; you can redistribute it and/or modify it
7			* under the terms of the GNU Affero General Public License as published by
8			* the Free Software Foundation, either version 3 of the License, or
9			* (at your option) any later version.
10			*
11			* SudoBot is distributed in the hope that it will be useful, but
12			* WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU Affero General Public License for more details.
15			*
16			* You should have received a copy of the GNU Affero General Public License
17			* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
18			*/
19
20			import { Mutex } from "async-mutex";
21			import { formatDistanceToNowStrict } from "date-fns";
22			import {
23			ActionRowBuilder,
24			ButtonBuilder,
25			ButtonStyle,
26			ColorResolvable,
27			ComponentEmojiResolvable,
28			EmbedBuilder,
29			GuildMember,
30			Interaction,
31			Snowflake,
32			time
33			} from "discord.js";
34			import { readFile } from "fs/promises";
35			import JSON5 from "json5";
36			import Service from "../core/Service";
37			import { GatewayEventListener } from "../decorators/GatewayEventListener";
38			import { NotUndefined } from "../types/NotUndefined";
39			import { log, logError, logWarn } from "../utils/Logger";
40			import { pick, sudoPrefix } from "../utils/utils";
41			import { GuildConfig } from "./ConfigManager";
42
43			export const name = "welcomer";
44
45			export default class WelcomerService extends Service {
46			welcomeMessages: string[] = [];
47			mutexes: Record<Snowflake, Mutex \| undefined> = {};
48
49			@GatewayEventListener("ready")
50			async onReady() {
51			log("Loading welcome messages...");
52			this.welcomeMessages = JSON5.parse(
53			await readFile(sudoPrefix("resources/welcome_messages.json"), { encoding: "utf-8" })
54			);
55			}
56
57			@GatewayEventListener("guildMemberAdd")
58			async onGuildMemberAdd(member: GuildMember) {
59			if (member.user.bot) return;
60
61			const config = this.client.configManager.config[member.guild.id];
62
63			if (!config) return;
64
65			const { welcomer } = config;
66
67			if (!welcomer?.enabled) return;
68
69			const {
70			channel: channelId,
71			embed,
72			say_hi_button,
73			custom_message,
74			randomize,
75			mention,
76			say_hi_expire_after,
77			delete_messages
78			} = welcomer;
79
80			if (!custom_message && !randomize) return;
81
82			try {
83			const channel =
84			member.guild.channels.cache.get(channelId) ??
85			(await member.guild.channels.fetch(channelId));
86
87			if (!channel) return;
88
89			if (!channel.isTextBased()) return;
90
91			const actionRow = say_hi_button
92			? [
93			this.generateActionRow(member.user.id, {
94			say_hi_emoji: welcomer.say_hi_emoji,
95			say_hi_label: welcomer.say_hi_label
96			})
97			]
98			: undefined;
99
100			const reply = await channel.send({
101			content: `${mention ? member.user.toString() + "\n" : ""}${
102			!embed ? this.generateContent(member, welcomer) : ""
103			}`,
104			embeds: embed ? [this.generatedEmbed(member, welcomer)] : undefined,
105			components: actionRow
106			});
107
108			if (delete_messages) {
109			setTimeout(() => {
110			reply.delete().catch(logError);
111			}, delete_messages);
112			}
113
114			if (actionRow && say_hi_button && say_hi_expire_after) {
115			setTimeout(() => {
116			const row = actionRow;
117
118			row[0].components[0].setDisabled(true);
119
120			reply
121			.edit({
122			components: row
123			})
124			.catch(logError);
125			}, say_hi_expire_after);
126			}
127			} catch (e) {
128			logError(e);
129			return;
130			}
131			}
132
133			@GatewayEventListener("interactionCreate")
134			async onInteractionCreate(interaction: Interaction) {
135			if (!interaction.isButton()) return;
136
137			const config = this.client.configManager.config[interaction.guild!.id];
138
139			if (!config) return;
140
141			if (
142			!interaction.guild?.id \|\|
143			!config.welcomer?.say_hi_button \|\|
144			!interaction.customId.startsWith("welcomer_say_hi__")
145			)
146			return;
147
148			this.mutexes[interaction.guildId!] ??= new Mutex();
149			const wasLocked = this.mutexes[interaction.guildId!]!.isLocked();
150
151			if (!interaction.deferred && !interaction.replied) {
152			await interaction.deferUpdate();
153			}
154
155			const release = await this.mutexes[interaction.guildId!]!.acquire();
156			const saysHiToYou = " says hi to you!";
157
158			if (wasLocked) {
159			try {
160			interaction.customId = (
161			await interaction.message.fetch(true)
162			).components[0].components[0].customId!;
163			log("Refetched custom ID: ", interaction.customId);
164			} catch (e) {
165			release();
166			return;
167			}
168			}
169
170			const [, memberId, messageId] = interaction.customId.split("__");
171			let sayHiReply =
172			this.client.configManager.config[interaction.guildId!]?.welcomer?.say_hi_reply;
173
174			if (typeof sayHiReply === "string" && !sayHiReply?.includes(":mentions:")) {
175			logWarn(
176			"config.welcomer.say_hi_reply does not include :mentions: placeholder, defaulting to the built in message"
177			);
178
179			sayHiReply = undefined;
180			}
181
182			try {
183			if (!messageId) {
184			const reply = await interaction[
185			interaction.replied \|\| interaction.deferred ? "followUp" : "reply"
186			]({
187			content:
188			sayHiReply?.replace(/:mentions:/gi, `<@${interaction.user.id}>`) ??
189			`${
190			interaction.user.id === memberId
191			? "__You__"
192			: interaction.user.toString()
193			}${
194			interaction.user.id === memberId ? " said hi to yourself!" : saysHiToYou
195			}`,
196			fetchReply: true
197			});
198
199			const newCustomId = `welcomer_say_hi__${memberId}__${reply.id}`;
200
201			const actionRow = this.generateActionRow(memberId, {
202			say_hi_emoji: config.welcomer?.say_hi_emoji,
203			say_hi_label: config.welcomer?.say_hi_label
204			});
205
206			actionRow.components[0].setCustomId(newCustomId);
207
208			await interaction.message.edit({
209			components: [actionRow]
210			});
211
212			if (config.welcomer.delete_messages) {
213			const time =
214			interaction.message.createdAt.getTime() +
215			config.welcomer.delete_messages -
216			Date.now();
217
218			if (time > 1000) {
219			setTimeout(() => {
220			reply.delete().catch(logError);
221			}, time);
222			}
223			}
224			} else {
225			try {
226			if (!interaction.replied && !interaction.deferred) {
227			await interaction.deferUpdate();
228			}
229
230			const message =
231			interaction.channel?.messages.cache.get(messageId) ??
232			(await interaction.channel?.messages.fetch(messageId));
233
234			if (!message) {
235			release();
236			return;
237			}
238
239			const parts = sayHiReply?.split(/:mentions:/i);
240			let contentOrUsers: string \| string[] = message.content;
241			let usersArray: string[] \| undefined;
242
243			if (parts !== undefined) {
244			let content = message.content;
245
246			for (const part of parts) {
247			content = content.replace(part.trim(), "");
248			}
249
250			content = content.trim();
251
252			const users = content
253			.split(/\s,\s/)
254			.filter((part, index, array) => array.lastIndexOf(part) === index);
255
256			contentOrUsers = [...users];
257
258			if (!users.includes(`<@${interaction.user.id}>`)) {
259			users.push(`<@${interaction.user.id}>`);
260			}
261
262			usersArray = users;
263			}
264
265			if (
266			contentOrUsers.includes(`${interaction.user.toString()}`) \|\|
267			(interaction.user.id === memberId && contentOrUsers.includes("__You__"))
268			) {
269			await interaction.followUp({
270			content: `You've already said hi to ${
271			interaction.user.id === memberId ? "yourself!" : "the user!"
272			}`,
273			ephemeral: true
274			});
275
276			release();
277			return;
278			}
279
280			await message.edit({
281			content:
282			sayHiReply === undefined
283			? `${message.content
284			.replace(saysHiToYou, "")
285			.replace(" said hi to yourself!", "")
286			.trim()}, ${
287			interaction.user.id === memberId
288			? "__You__"
289			: interaction.user.toString()
290			}${saysHiToYou}`
291			: sayHiReply.replace(/:mentions:/gi, usersArray!.join(", "))
292			});
293			} catch (e) {
294			logError(e);
295			}
296			}
297			} catch (e) {
298			logError(e);
299			}
300
301			release();
302			}
303
304			generateActionRow(
305			memberId: string,
306			{
307			say_hi_emoji,
308			say_hi_label
309			}: Pick<NotUndefined<GuildConfig["welcomer"]>, "say_hi_emoji" \| "say_hi_label">
310			) {
311			const emoji =
312			!say_hi_emoji \|\| say_hi_emoji === "default"
313			? "👋"
314			: this.client.emojis.cache.find(
315			e => e.name === say_hi_emoji \|\| e.identifier === say_hi_emoji
316			);
317			const button = new ButtonBuilder()
318			.setCustomId(`welcomer_say_hi__${memberId}`)
319			.setLabel(say_hi_label ?? "Say Hi!")
320			.setStyle(ButtonStyle.Secondary);
321
322			if (emoji)
323			button.setEmoji(
324			typeof emoji === "string"
325			? emoji
326			: pick(emoji as Exclude<ComponentEmojiResolvable, string>, [
327			"id",
328			"name",
329			"animated"
330			])
331			);
332
333			return new ActionRowBuilder<ButtonBuilder>().addComponents(button);
334			}
335
336			pickRandomWelcomeMessage() {
337			return this.welcomeMessages[Math.floor(Math.random() * this.welcomeMessages.length)];
338			}
339
340			replacePlaceholders(member: GuildMember, message: string) {
341			return message
342			.replace(/:tag:/gi, member.user.tag)
343			.replace(/:discriminator:/gi, member.user.discriminator)
344			.replace(/:createdAt:/gi, `${time(member.user.createdTimestamp)}`)
345			.replace(/:age:/gi, formatDistanceToNowStrict(member.user.createdTimestamp))
346			.replace(/:mention:/gi, member.user.toString())
347			.replace(/:guild:/gi, member.guild.name);
348			}
349
350			generateContent(
351			member: GuildMember,
352			{ custom_message, randomize }: NotUndefined<GuildConfig["welcomer"]>
353			) {
354			const message = `${randomize ? `${this.pickRandomWelcomeMessage()}\n` : ""}${
355			custom_message ? custom_message : ""
356			}`;
357			return this.replacePlaceholders(member, message);
358			}
359
360			generatedEmbed(member: GuildMember, welcomer: NotUndefined<GuildConfig["welcomer"]>) {
361			return new EmbedBuilder({
362			author: {
363			name: member.user.username,
364			icon_url: member.displayAvatarURL()
365			},
366			description: this.generateContent(member, welcomer),
367			footer: {
368			text: "Welcome"
369			}
370			})
371			.setColor(welcomer.color as ColorResolvable)
372			.setTimestamp();
373			}
374			}