src/services/Welcomer.ts

/**
* This file is part of SudoBot.
* 
* Copyright (C) 2021-2022 OSN Inc.
*
* 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 { ButtonInteraction, GuildMember, MessageActionRow, MessageButton, MessageEmbed, TextChannel, Util, Message } from "discord.js";
import fs from 'fs';
import path from "path";
import Service from "../utils/structures/Service";
import { hasConfig } from "../utils/util";
import { emoji } from "../utils/Emoji";

export default class Welcomer extends Service {
    messages: string[] = JSON.parse(fs.readFileSync(path.resolve(process.env.SUDO_PREFIX ?? path.join(__dirname, '..', '..'), 'resources', 'welcome_messages.json')).toString());
    updatingMessage: boolean = false;
    lastUpdate = Date.now();

    generateMessageOptions(member: GuildMember, index?: number) {
        const { message, randomize, embed, color } = this.client.config.props[member.guild.id].welcomer;
        let content: string = message ?? '';

        if (randomize) {
            content = this.generateMessage(index) + (message ? "\n" + content : '');
        }

        if (content.trim() === '') {
            return false;
        }

        content = content
            .replace(/:name:/g, member.displayName)
            .replace(/:tag:/g, member.user.tag)
            .replace(/:username:/g, member.user.username)
            .replace(/:discrim:/g, member.user.discriminator)
            .replace(/:avatar:/g, member.displayAvatarURL())
            .replace(/:date:/g, `<t:${member.joinedAt?.getTime()}>`)
            .replace(/:guild:/g, member.guild.name)
            .replace(/:mention:/g, member.toString());

        return {
            content: member.toString() + (
                !embed ? "\n" + content : ""
            ),
            embeds: embed ? [
                new MessageEmbed({
                    author: {
                        iconURL: member.displayAvatarURL(),
                        name: member.user.tag
                    },
                    description: content,
                    footer: {
                        text: 'Welcome'
                    }
                })
                    .setColor(color ?? '#007bff')
                    .setTimestamp()
            ] : [],
            components: [
                this.createComponent(member.user.id)
            ]
        };
    }

    createComponent(memberId: string) {
        return new MessageActionRow<MessageButton>()
                .addComponents(
                    new MessageButton()
                        .setCustomId(`say_hi__${memberId}`)
                        .setLabel('Say Hi')
                        .setEmoji(emoji('wave')! as any)
                        .setStyle("SECONDARY")
                );
    }

    async onButtonInteraction(interaction: ButtonInteraction) {
        console.log(interaction.customId);

        if (!interaction.customId.startsWith("say_hi__"))
            return;

        if (this.updatingMessage || Date.now() - this.lastUpdate <= 800) {
            await interaction.reply({
                content: "Whoa there! That was too quick! Please try again in a second. I had to ratelimit this in order to prevent spam!",
                ephemeral: true
            }).catch(console.error);
            
            return;
        } 

        let [, memberId, messageId] = interaction.customId.split('__');

        if (messageId)
            await interaction.deferUpdate();

        try {
            if (!messageId) {
                this.updatingMessage = true;

                const reply = await interaction.reply({
                    content: `${interaction.user.id === memberId ? `<@${interaction.user.id}> (You)` : `<@${interaction.user.id}>`} says hi!`,
                    fetchReply: true
                });

                const component = this.createComponent(memberId);

                component.components[0].setCustomId(`say_hi__${memberId}__${reply.id}`);
                
                await (interaction.message as Message).edit({
                    components: [
                        component
                    ],
                });

                messageId = reply.id;
                this.updatingMessage = false;

                setTimeout(async () => {
                    try {
                        component.components[0].setDisabled(true);

                        await (interaction.message as Message).delete().catch(console.error);
                        await (reply as Message).delete().catch(console.error);
                    }
                    catch (e) {
                        console.log(e);
                    }
                }, 240_000);
            }
            else {
                const message = await interaction.channel!.messages.fetch(messageId);
                
                if (!message)
                    throw new Error();

                if (
                    (interaction.user.id === memberId && message.content.includes("You")) ||
                    (interaction.user.id !== memberId && message.content.includes(`<@${interaction.user.id}>`))
                ) {
                    await interaction.followUp({
                        content: "You've already greeted the user!",
                        ephemeral: true
                    });

                    return;
                }

                await message.edit({
                    content: message.content.replace(/ says hi\!$/gi, "") + ", " + (interaction.user.id === memberId ? `<@${interaction.user.id}> (You)` : `<@${interaction.user.id}>`) + " says hi!",
                });

                await interaction.update({
                    content: interaction.message.content
                });
            }
        }
        catch (e) {
            this.updatingMessage = false;
            console.log(e);
            return;
        }

        this.lastUpdate = Date.now();
    }

    async start(member: GuildMember, index?: number) {
        if (!hasConfig(this.client, member.guild.id, "welcomer"))
            return;

        if (this.client.config.props[member.guild.id].welcomer.enabled) {
            const { channel: channelID } = this.client.config.props[member.guild.id].welcomer;

            try {
                const channel = (await member.guild.channels.fetch(channelID)) as TextChannel;
                const options = this.generateMessageOptions(member, index);

                if (!options) {
                    return;
                }

                if (channel) {
                    await channel.send(options);
                }
            }
            catch (e) {
                console.log(e);
            }
        }
    }

    generateMessage(index?: number) {
        return this.messages[index ?? Math.floor(this.messages.length * Math.random())];
    }
}
1	/**
2	* This file is part of SudoBot.
3	*
4	* Copyright (C) 2021-2022 OSN Inc.
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 { ButtonInteraction, GuildMember, MessageActionRow, MessageButton, MessageEmbed, TextChannel, Util, Message } from "discord.js";
21	import fs from 'fs';
22	import path from "path";
23	import Service from "../utils/structures/Service";
24	import { hasConfig } from "../utils/util";
25	import { emoji } from "../utils/Emoji";
26
27	export default class Welcomer extends Service {
28	messages: string[] = JSON.parse(fs.readFileSync(path.resolve(process.env.SUDO_PREFIX ?? path.join(__dirname, '..', '..'), 'resources', 'welcome_messages.json')).toString());
29	updatingMessage: boolean = false;
30	lastUpdate = Date.now();
31
32	generateMessageOptions(member: GuildMember, index?: number) {
33	const { message, randomize, embed, color } = this.client.config.props[member.guild.id].welcomer;
34	let content: string = message ?? '';
35
36	if (randomize) {
37	content = this.generateMessage(index) + (message ? "\n" + content : '');
38	}
39
40	if (content.trim() === '') {
41	return false;
42	}
43
44	content = content
45	.replace(/:name:/g, member.displayName)
46	.replace(/:tag:/g, member.user.tag)
47	.replace(/:username:/g, member.user.username)
48	.replace(/:discrim:/g, member.user.discriminator)
49	.replace(/:avatar:/g, member.displayAvatarURL())
50	.replace(/:date:/g, `<t:${member.joinedAt?.getTime()}>`)
51	.replace(/:guild:/g, member.guild.name)
52	.replace(/:mention:/g, member.toString());
53
54	return {
55	content: member.toString() + (
56	!embed ? "\n" + content : ""
57	),
58	embeds: embed ? [
59	new MessageEmbed({
60	author: {
61	iconURL: member.displayAvatarURL(),
62	name: member.user.tag
63	},
64	description: content,
65	footer: {
66	text: 'Welcome'
67	}
68	})
69	.setColor(color ?? '#007bff')
70	.setTimestamp()
71	] : [],
72	components: [
73	this.createComponent(member.user.id)
74	]
75	};
76	}
77
78	createComponent(memberId: string) {
79	return new MessageActionRow<MessageButton>()
80	.addComponents(
81	new MessageButton()
82	.setCustomId(`say_hi__${memberId}`)
83	.setLabel('Say Hi')
84	.setEmoji(emoji('wave')! as any)
85	.setStyle("SECONDARY")
86	);
87	}
88
89	async onButtonInteraction(interaction: ButtonInteraction) {
90	console.log(interaction.customId);
91
92	if (!interaction.customId.startsWith("say_hi__"))
93	return;
94
95	if (this.updatingMessage \|\| Date.now() - this.lastUpdate <= 800) {
96	await interaction.reply({
97	content: "Whoa there! That was too quick! Please try again in a second. I had to ratelimit this in order to prevent spam!",
98	ephemeral: true
99	}).catch(console.error);
100
101	return;
102	}
103
104	let [, memberId, messageId] = interaction.customId.split('__');
105
106	if (messageId)
107	await interaction.deferUpdate();
108
109	try {
110	if (!messageId) {
111	this.updatingMessage = true;
112
113	const reply = await interaction.reply({
114	content: `${interaction.user.id === memberId ? `<@${interaction.user.id}> (You)` : `<@${interaction.user.id}>`} says hi!`,
115	fetchReply: true
116	});
117
118	const component = this.createComponent(memberId);
119
120	component.components[0].setCustomId(`say_hi__${memberId}__${reply.id}`);
121
122	await (interaction.message as Message).edit({
123	components: [
124	component
125	],
126	});
127
128	messageId = reply.id;
129	this.updatingMessage = false;
130
131	setTimeout(async () => {
132	try {
133	component.components[0].setDisabled(true);
134
135	await (interaction.message as Message).delete().catch(console.error);
136	await (reply as Message).delete().catch(console.error);
137	}
138	catch (e) {
139	console.log(e);
140	}
141	}, 240_000);
142	}
143	else {
144	const message = await interaction.channel!.messages.fetch(messageId);
145
146	if (!message)
147	throw new Error();
148
149	if (
150	(interaction.user.id === memberId && message.content.includes("You")) \|\|
151	(interaction.user.id !== memberId && message.content.includes(`<@${interaction.user.id}>`))
152	) {
153	await interaction.followUp({
154	content: "You've already greeted the user!",
155	ephemeral: true
156	});
157
158	return;
159	}
160
161	await message.edit({
162	content: message.content.replace(/ says hi\!$/gi, "") + ", " + (interaction.user.id === memberId ? `<@${interaction.user.id}> (You)` : `<@${interaction.user.id}>`) + " says hi!",
163	});
164
165	await interaction.update({
166	content: interaction.message.content
167	});
168	}
169	}
170	catch (e) {
171	this.updatingMessage = false;
172	console.log(e);
173	return;
174	}
175
176	this.lastUpdate = Date.now();
177	}
178
179	async start(member: GuildMember, index?: number) {
180	if (!hasConfig(this.client, member.guild.id, "welcomer"))
181	return;
182
183	if (this.client.config.props[member.guild.id].welcomer.enabled) {
184	const { channel: channelID } = this.client.config.props[member.guild.id].welcomer;
185
186	try {
187	const channel = (await member.guild.channels.fetch(channelID)) as TextChannel;
188	const options = this.generateMessageOptions(member, index);
189
190	if (!options) {
191	return;
192	}
193
194	if (channel) {
195	await channel.send(options);
196	}
197	}
198	catch (e) {
199	console.log(e);
200	}
201	}
202	}
203
204	generateMessage(index?: number) {
205	return this.messages[index ?? Math.floor(this.messages.length * Math.random())];
206	}
207	}