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 { formatDistanceToNowStrict } from "date-fns";
import {
    ActionRowBuilder,
    ButtonBuilder,
    ButtonStyle,
    ColorResolvable,
    EmbedBuilder,
    GuildMember,
    Interaction,
    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 } from "../utils/logger";
import { sudoPrefix } from "../utils/utils";
import { GuildConfig } from "./ConfigManager";

export const name = "welcomer";

export default class WelcomerService extends Service {
    welcomeMessages: string[] = [];
    workingState = false;

    @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
                      })
                  ]
                : 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;

        if (this.workingState) {
            await interaction[interaction.replied ? "followUp" : "reply"]({
                content: `Whoa there! Please calm down! I had to ratelimit this request to prevent spam.`,
                ephemeral: true
            });

            return;
        }

        this.workingState = true;

        const [, memberId, messageId] = interaction.customId.split("__");
        const saysHiToYou = ` says hi to you!`;

        try {
            if (!messageId) {
                const reply = await interaction.reply({
                    content: `${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!
                });

                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 {
                    await interaction.deferUpdate();
                    const message =
                        interaction.channel?.messages.cache.get(messageId) ??
                        (await interaction.channel?.messages.fetch(messageId));

                    if (!message) {
                        this.workingState = false;
                        return;
                    }

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

                        this.workingState = false;
                        return;
                    }

                    await message.edit({
                        content: `${message.content.replace(saysHiToYou, "").replace(" said hi to yourself!", "")}, ${
                            interaction.user.id === memberId ? "__You__" : interaction.user.toString()
                        }${saysHiToYou}`
                    });
                } catch (e) {
                    logError(e);
                    this.workingState = false;
                }
            }

            this.workingState = false;
        } catch (e) {
            logError(e);
            this.workingState = false;
        }
    }

    generateActionRow(memberId: string, { say_hi_emoji }: Pick<NotUndefined<GuildConfig["welcomer"]>, "say_hi_emoji">) {
        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!")
            .setStyle(ButtonStyle.Secondary);

        if (emoji) button.setEmoji(emoji.toString());

        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	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 { formatDistanceToNowStrict } from "date-fns";
21			import {
22			ActionRowBuilder,
23			ButtonBuilder,
24			ButtonStyle,
25			ColorResolvable,
26			EmbedBuilder,
27			GuildMember,
28			Interaction,
29			time
30			} from "discord.js";
31			import { readFile } from "fs/promises";
32			import JSON5 from "json5";
33			import Service from "../core/Service";
34			import { GatewayEventListener } from "../decorators/GatewayEventListener";
35			import { NotUndefined } from "../types/NotUndefined";
36			import { log, logError } from "../utils/logger";
37			import { sudoPrefix } from "../utils/utils";
38			import { GuildConfig } from "./ConfigManager";
39
40			export const name = "welcomer";
41
42			export default class WelcomerService extends Service {
43			welcomeMessages: string[] = [];
44			workingState = false;
45
46			@GatewayEventListener("ready")
47			async onReady() {
48			log("Loading welcome messages...");
49			this.welcomeMessages = JSON5.parse(await readFile(sudoPrefix(`resources/welcome_messages.json`), { encoding: "utf-8" }));
50			}
51
52			@GatewayEventListener("guildMemberAdd")
53			async onGuildMemberAdd(member: GuildMember) {
54			if (member.user.bot) return;
55
56			const config = this.client.configManager.config[member.guild.id];
57
58			if (!config) return;
59
60			const { welcomer } = config;
61
62			if (!welcomer?.enabled) return;
63
64			const {
65			channel: channelId,
66			embed,
67			say_hi_button,
68			custom_message,
69			randomize,
70			mention,
71			say_hi_expire_after,
72			delete_messages
73			} = welcomer;
74
75			if (!custom_message && !randomize) return;
76
77			try {
78			const channel = member.guild.channels.cache.get(channelId) ?? (await member.guild.channels.fetch(channelId));
79
80			if (!channel) return;
81
82			if (!channel.isTextBased()) return;
83
84			const actionRow = say_hi_button
85			? [
86			this.generateActionRow(member.user.id, {
87			say_hi_emoji: welcomer.say_hi_emoji
88			})
89			]
90			: undefined;
91
92			const reply = await channel.send({
93			content: `${mention ? member.user.toString() + "\n" : ""}${!embed ? this.generateContent(member, welcomer) : ""}`,
94			embeds: embed ? [this.generatedEmbed(member, welcomer)] : undefined,
95			components: actionRow
96			});
97
98			if (delete_messages) {
99			setTimeout(() => {
100			reply.delete().catch(logError);
101			}, delete_messages);
102			}
103
104			if (actionRow && say_hi_button && say_hi_expire_after) {
105			setTimeout(() => {
106			const row = actionRow;
107
108			row[0].components[0].setDisabled(true);
109
110			reply
111			.edit({
112			components: row
113			})
114			.catch(logError);
115			}, say_hi_expire_after);
116			}
117			} catch (e) {
118			logError(e);
119			return;
120			}
121			}
122
123			@GatewayEventListener("interactionCreate")
124			async onInteractionCreate(interaction: Interaction) {
125			if (!interaction.isButton()) return;
126
127			const config = this.client.configManager.config[interaction.guild!.id];
128
129			if (!config) return;
130
131			if (!interaction.guild?.id \|\| !config.welcomer?.say_hi_button \|\| !interaction.customId.startsWith(`welcomer_say_hi__`))
132			return;
133
134			if (this.workingState) {
135			await interaction[interaction.replied ? "followUp" : "reply"]({
136			content: `Whoa there! Please calm down! I had to ratelimit this request to prevent spam.`,
137			ephemeral: true
138			});
139
140			return;
141			}
142
143			this.workingState = true;
144
145			const [, memberId, messageId] = interaction.customId.split("__");
146			const saysHiToYou = ` says hi to you!`;
147
148			try {
149			if (!messageId) {
150			const reply = await interaction.reply({
151			content: `${interaction.user.id === memberId ? "__You__" : interaction.user.toString()}${
152			interaction.user.id === memberId ? " said hi to yourself!" : saysHiToYou
153			}`,
154			fetchReply: true
155			});
156
157			const newCustomId = `welcomer_say_hi__${memberId}__${reply.id}`;
158
159			const actionRow = this.generateActionRow(memberId, {
160			say_hi_emoji: config.welcomer?.say_hi_emoji!
161			});
162
163			actionRow.components[0].setCustomId(newCustomId);
164
165			await interaction.message.edit({
166			components: [actionRow]
167			});
168
169			if (config.welcomer.delete_messages) {
170			const time = interaction.message.createdAt.getTime() + config.welcomer.delete_messages - Date.now();
171
172			if (time > 1000) {
173			setTimeout(() => {
174			reply.delete().catch(logError);
175			}, time);
176			}
177			}
178			} else {
179			try {
180			await interaction.deferUpdate();
181			const message =
182			interaction.channel?.messages.cache.get(messageId) ??
183			(await interaction.channel?.messages.fetch(messageId));
184
185			if (!message) {
186			this.workingState = false;
187			return;
188			}
189
190			if (
191			(interaction.user.id === memberId && message.content.includes("__You__")) \|\|
192			(interaction.user.id !== memberId && message.content.includes(`${interaction.user.toString()}`))
193			) {
194			await interaction.followUp({
195			content: `You've already said hi to ${interaction.user.id === memberId ? "yourself!" : "the user!"}`,
196			ephemeral: true
197			});
198
199			this.workingState = false;
200			return;
201			}
202
203			await message.edit({
204			content: `${message.content.replace(saysHiToYou, "").replace(" said hi to yourself!", "")}, ${
205			interaction.user.id === memberId ? "__You__" : interaction.user.toString()
206			}${saysHiToYou}`
207			});
208			} catch (e) {
209			logError(e);
210			this.workingState = false;
211			}
212			}
213
214			this.workingState = false;
215			} catch (e) {
216			logError(e);
217			this.workingState = false;
218			}
219			}
220
221			generateActionRow(memberId: string, { say_hi_emoji }: Pick<NotUndefined<GuildConfig["welcomer"]>, "say_hi_emoji">) {
222			const emoji =
223			!say_hi_emoji \|\| say_hi_emoji === "default"
224			? "👋"
225			: this.client.emojis.cache.find(e => e.name === say_hi_emoji \|\| e.identifier === say_hi_emoji);
226			const button = new ButtonBuilder()
227			.setCustomId(`welcomer_say_hi__${memberId}`)
228			.setLabel("Say Hi!")
229			.setStyle(ButtonStyle.Secondary);
230
231			if (emoji) button.setEmoji(emoji.toString());
232
233			return new ActionRowBuilder<ButtonBuilder>().addComponents(button);
234			}
235
236			pickRandomWelcomeMessage() {
237			return this.welcomeMessages[Math.floor(Math.random() * this.welcomeMessages.length)];
238			}
239
240			replacePlaceholders(member: GuildMember, message: string) {
241			return message
242			.replace(/:tag:/gi, member.user.tag)
243			.replace(/:discriminator:/gi, member.user.discriminator)
244			.replace(/:createdAt:/gi, `${time(member.user.createdTimestamp)}`)
245			.replace(/:age:/gi, formatDistanceToNowStrict(member.user.createdTimestamp))
246			.replace(/:mention:/gi, member.user.toString())
247			.replace(/:guild:/gi, member.guild.name);
248			}
249
250			generateContent(member: GuildMember, { custom_message, randomize, mention }: NotUndefined<GuildConfig["welcomer"]>) {
251			const message = `${randomize ? `${this.pickRandomWelcomeMessage()}\n` : ""}${custom_message ? custom_message : ""}`;
252			return this.replacePlaceholders(member, message);
253			}
254
255			generatedEmbed(member: GuildMember, welcomer: NotUndefined<GuildConfig["welcomer"]>) {
256			return new EmbedBuilder({
257			author: {
258			name: member.user.username,
259			icon_url: member.displayAvatarURL()
260			},
261			description: this.generateContent(member, welcomer),
262			footer: {
263			text: "Welcome"
264			}
265			})
266			.setColor(welcomer.color as ColorResolvable)
267			.setTimestamp();
268			}
269			}