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	/**
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	}