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);

                        console.log("DEBUG", users);
                        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, mention }: 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	/**
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(await readFile(sudoPrefix(`resources/welcome_messages.json`), { encoding: "utf-8" }));
53	}
54
55	@GatewayEventListener("guildMemberAdd")
56	async onGuildMemberAdd(member: GuildMember) {
57	if (member.user.bot) return;
58
59	const config = this.client.configManager.config[member.guild.id];
60
61	if (!config) return;
62
63	const { welcomer } = config;
64
65	if (!welcomer?.enabled) return;
66
67	const {
68	channel: channelId,
69	embed,
70	say_hi_button,
71	custom_message,
72	randomize,
73	mention,
74	say_hi_expire_after,
75	delete_messages
76	} = welcomer;
77
78	if (!custom_message && !randomize) return;
79
80	try {
81	const channel = member.guild.channels.cache.get(channelId) ?? (await member.guild.channels.fetch(channelId));
82
83	if (!channel) return;
84
85	if (!channel.isTextBased()) return;
86
87	const actionRow = say_hi_button
88	? [
89	this.generateActionRow(member.user.id, {
90	say_hi_emoji: welcomer.say_hi_emoji,
91	say_hi_label: welcomer.say_hi_label
92	})
93	]
94	: undefined;
95
96	const reply = await channel.send({
97	content: `${mention ? member.user.toString() + "\n" : ""}${!embed ? this.generateContent(member, welcomer) : ""}`,
98	embeds: embed ? [this.generatedEmbed(member, welcomer)] : undefined,
99	components: actionRow
100	});
101
102	if (delete_messages) {
103	setTimeout(() => {
104	reply.delete().catch(logError);
105	}, delete_messages);
106	}
107
108	if (actionRow && say_hi_button && say_hi_expire_after) {
109	setTimeout(() => {
110	const row = actionRow;
111
112	row[0].components[0].setDisabled(true);
113
114	reply
115	.edit({
116	components: row
117	})
118	.catch(logError);
119	}, say_hi_expire_after);
120	}
121	} catch (e) {
122	logError(e);
123	return;
124	}
125	}
126
127	@GatewayEventListener("interactionCreate")
128	async onInteractionCreate(interaction: Interaction) {
129	if (!interaction.isButton()) return;
130
131	const config = this.client.configManager.config[interaction.guild!.id];
132
133	if (!config) return;
134
135	if (!interaction.guild?.id \|\| !config.welcomer?.say_hi_button \|\| !interaction.customId.startsWith(`welcomer_say_hi__`))
136	return;
137
138	this.mutexes[interaction.guildId!] ??= new Mutex();
139	const wasLocked = this.mutexes[interaction.guildId!]!.isLocked();
140
141	if (!interaction.deferred && !interaction.replied) {
142	await interaction.deferUpdate();
143	}
144
145	const release = await this.mutexes[interaction.guildId!]!.acquire();
146	const saysHiToYou = ` says hi to you!`;
147
148	if (wasLocked) {
149	try {
150	interaction.customId = (await interaction.message.fetch(true)).components[0].components[0].customId!;
151	log("Refetched custom ID: ", interaction.customId);
152	} catch (e) {
153	release();
154	return;
155	}
156	}
157
158	const [, memberId, messageId] = interaction.customId.split("__");
159	let sayHiReply = this.client.configManager.config[interaction.guildId!]?.welcomer?.say_hi_reply;
160
161	if (typeof sayHiReply === "string" && !sayHiReply?.includes(":mentions:")) {
162	logWarn("config.welcomer.say_hi_reply does not include :mentions: placeholder, defaulting to the built in message");
163
164	sayHiReply = undefined;
165	}
166
167	try {
168	if (!messageId) {
169	const reply = await interaction[interaction.replied \|\| interaction.deferred ? "followUp" : "reply"]({
170	content:
171	sayHiReply?.replace(/:mentions:/gi, `<@${interaction.user.id}>`) ??
172	`${interaction.user.id === memberId ? "__You__" : interaction.user.toString()}${
173	interaction.user.id === memberId ? " said hi to yourself!" : saysHiToYou
174	}`,
175	fetchReply: true
176	});
177
178	const newCustomId = `welcomer_say_hi__${memberId}__${reply.id}`;
179
180	const actionRow = this.generateActionRow(memberId, {
181	say_hi_emoji: config.welcomer?.say_hi_emoji!,
182	say_hi_label: config.welcomer?.say_hi_label!
183	});
184
185	actionRow.components[0].setCustomId(newCustomId);
186
187	await interaction.message.edit({
188	components: [actionRow]
189	});
190
191	if (config.welcomer.delete_messages) {
192	const time = interaction.message.createdAt.getTime() + config.welcomer.delete_messages - Date.now();
193
194	if (time > 1000) {
195	setTimeout(() => {
196	reply.delete().catch(logError);
197	}, time);
198	}
199	}
200	} else {
201	try {
202	if (!interaction.replied && !interaction.deferred) {
203	await interaction.deferUpdate();
204	}
205
206	const message =
207	interaction.channel?.messages.cache.get(messageId) ??
208	(await interaction.channel?.messages.fetch(messageId));
209
210	if (!message) {
211	release();
212	return;
213	}
214
215	const parts = sayHiReply?.split(/:mentions:/i);
216	let contentOrUsers: string \| string[] = message.content;
217	let usersArray: string[] \| undefined;
218
219	if (parts !== undefined) {
220	let content = message.content;
221
222	for (const part of parts) {
223	content = content.replace(part.trim(), "");
224	}
225
226	content = content.trim();
227
228	const users = content.split(/\s,\s/).filter((part, index, array) => array.lastIndexOf(part) === index);
229
230	console.log("DEBUG", users);
231	contentOrUsers = [...users];
232
233	if (!users.includes(`<@${interaction.user.id}>`)) {
234	users.push(`<@${interaction.user.id}>`);
235	}
236
237	usersArray = users;
238	}
239
240	if (
241	contentOrUsers.includes(`${interaction.user.toString()}`) \|\|
242	(interaction.user.id === memberId && contentOrUsers.includes("__You__"))
243	) {
244	await interaction.followUp({
245	content: `You've already said hi to ${interaction.user.id === memberId ? "yourself!" : "the user!"}`,
246	ephemeral: true
247	});
248
249	release();
250	return;
251	}
252
253	await message.edit({
254	content:
255	sayHiReply === undefined
256	? `${message.content.replace(saysHiToYou, "").replace(" said hi to yourself!", "").trim()}, ${
257	interaction.user.id === memberId ? "__You__" : interaction.user.toString()
258	}${saysHiToYou}`
259	: sayHiReply.replace(/:mentions:/gi, usersArray!.join(", "))
260	});
261	} catch (e) {
262	logError(e);
263	}
264	}
265	} catch (e) {
266	logError(e);
267	}
268
269	release();
270	}
271
272	generateActionRow(
273	memberId: string,
274	{ say_hi_emoji, say_hi_label }: Pick<NotUndefined<GuildConfig["welcomer"]>, "say_hi_emoji" \| "say_hi_label">
275	) {
276	const emoji =
277	!say_hi_emoji \|\| say_hi_emoji === "default"
278	? "👋"
279	: this.client.emojis.cache.find(e => e.name === say_hi_emoji \|\| e.identifier === say_hi_emoji);
280	const button = new ButtonBuilder()
281	.setCustomId(`welcomer_say_hi__${memberId}`)
282	.setLabel(say_hi_label ?? "Say Hi!")
283	.setStyle(ButtonStyle.Secondary);
284
285	if (emoji)
286	button.setEmoji(
287	typeof emoji === "string"
288	? emoji
289	: pick(emoji as Exclude<ComponentEmojiResolvable, string>, ["id", "name", "animated"])
290	);
291
292	return new ActionRowBuilder<ButtonBuilder>().addComponents(button);
293	}
294
295	pickRandomWelcomeMessage() {
296	return this.welcomeMessages[Math.floor(Math.random() * this.welcomeMessages.length)];
297	}
298
299	replacePlaceholders(member: GuildMember, message: string) {
300	return message
301	.replace(/:tag:/gi, member.user.tag)
302	.replace(/:discriminator:/gi, member.user.discriminator)
303	.replace(/:createdAt:/gi, `${time(member.user.createdTimestamp)}`)
304	.replace(/:age:/gi, formatDistanceToNowStrict(member.user.createdTimestamp))
305	.replace(/:mention:/gi, member.user.toString())
306	.replace(/:guild:/gi, member.guild.name);
307	}
308
309	generateContent(member: GuildMember, { custom_message, randomize, mention }: NotUndefined<GuildConfig["welcomer"]>) {
310	const message = `${randomize ? `${this.pickRandomWelcomeMessage()}\n` : ""}${custom_message ? custom_message : ""}`;
311	return this.replacePlaceholders(member, message);
312	}
313
314	generatedEmbed(member: GuildMember, welcomer: NotUndefined<GuildConfig["welcomer"]>) {
315	return new EmbedBuilder({
316	author: {
317	name: member.user.username,
318	icon_url: member.displayAvatarURL()
319	},
320	description: this.generateContent(member, welcomer),
321	footer: {
322	text: "Welcome"
323	}
324	})
325	.setColor(welcomer.color as ColorResolvable)
326	.setTimestamp();
327	}
328	}