commands/tools/ExtractEmojiCommand.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 { EmbedBuilder, SlashCommandBuilder, parseEmoji } from "discord.js";
import Command, { ArgumentType, BasicCommandContext, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
import { safeChannelFetch, safeMessageFetch } from "../../utils/fetch";

export default class ExtractEmojiCommand extends Command {
    public readonly name = "extractemoji";
    public readonly validationRules: ValidationRule[] = [
        {
            types: [ArgumentType.Link],
            name: "message_link",
            errors: {
                required: "Please provide a message link to extract emoji from!",
                "type:invalid": "Invalid message link given!"
            }
        }
    ];
    public readonly permissions = [];
    public readonly aliases = ["getemojis", "extractemojis", "getemojis"];
    public readonly description = "Extracts server emoji links from the given message.";
    public readonly argumentSyntaxes = ["<message_link>"];
    public readonly slashCommandBuilder = new SlashCommandBuilder().addStringOption(option =>
        option.setName("message_link").setDescription("Link to the target message").setRequired(true)
    );

    extract(content: string) {
        const emojis = [];
        const regexMatches = [...content.matchAll(/(<a?:[\w_]+:\d+>)/gim)].map(match => match[0]);

        for (const match of regexMatches) {
            const parsed = parseEmoji(match);

            if (!parsed?.id) {
                continue;
            }

            emojis.push({
                ...parsed,
                url: `https://cdn.discordapp.com/emojis/${encodeURIComponent(parsed.id)}.${parsed.animated ? "gif" : "png"}`
            });
        }

        return emojis;
    }

    async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
        await this.deferIfInteraction(message);

        const link = context.isLegacy ? context.parsedNamedArgs.message_link : context.options.getString("message_link", true);

        if (!/^https?:\/\/(canary\.|ptb\.|beta\.|www\.|)discord\.com\/channels\/\d+\/\d+\/\d+$/i.test(link.trim())) {
            await this.error(message, this.validationRules[0].errors!["type:invalid"]!);
            return;
        }

        const [messageId, channelId, guildId] = link
            .substring(0, link[link.length - 1] === "/" ? link.length - 1 : link.length)
            .split("/")
            .reverse();

        if (guildId !== message.guildId!) {
            await this.error(message, "That's a message link from another server!");
            return;
        }

        const channel = await safeChannelFetch(message.guild!, channelId);

        if (!channel) {
            await this.error(message, "The link is invalid, couldn't find the specified channel!");
            return;
        }

        if (!channel.isTextBased()) {
            await this.error(message, "The link points to a non-text based channel!");
            return;
        }

        const targetMessage = await safeMessageFetch(channel, messageId);

        if (!targetMessage) {
            await this.error(
                message,
                "The link is invalid, couldn't find the specified message! Make sure that it wasn't deleted."
            );
            return;
        }

        const parsedEmojis = this.extract(targetMessage.content);

        for (const embed of targetMessage.embeds) {
            if (embed.description) {
                parsedEmojis.push(...this.extract(embed.description));
            }

            for (const field of embed.fields) {
                if (field.value) {
                    parsedEmojis.push(...this.extract(field.value));
                }
            }
        }

        const emojis: typeof parsedEmojis = [];

        for (const emoji of parsedEmojis) {
            if (!!emojis.find(e => e.id === emoji.id)) {
                continue;
            }

            emojis.push(emoji);
        }

        if (emojis.length === 0) {
            await this.error(message, "Could not find any server-based emoji in the given message.");
            return;
        }

        let description = "";

        for (const { name, url, animated } of emojis) {
            description += `* [${name}](${url})${animated ? " (Animated)" : ""}\n`;
        }

        await this.deferredReply(message, {
            embeds: [
                new EmbedBuilder({
                    title: "Extracted Emojis",
                    color: 0x007bff,
                    description,
                    footer: {
                        text: `Extracted ${emojis.length} emojis total`
                    }
                }).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 { EmbedBuilder, SlashCommandBuilder, parseEmoji } from "discord.js";
21			import Command, { ArgumentType, BasicCommandContext, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
22			import { safeChannelFetch, safeMessageFetch } from "../../utils/fetch";
23
24			export default class ExtractEmojiCommand extends Command {
25			public readonly name = "extractemoji";
26			public readonly validationRules: ValidationRule[] = [
27			{
28			types: [ArgumentType.Link],
29			name: "message_link",
30			errors: {
31			required: "Please provide a message link to extract emoji from!",
32			"type:invalid": "Invalid message link given!"
33			}
34			}
35			];
36			public readonly permissions = [];
37			public readonly aliases = ["getemojis", "extractemojis", "getemojis"];
38			public readonly description = "Extracts server emoji links from the given message.";
39			public readonly argumentSyntaxes = ["<message_link>"];
40			public readonly slashCommandBuilder = new SlashCommandBuilder().addStringOption(option =>
41			option.setName("message_link").setDescription("Link to the target message").setRequired(true)
42			);
43
44			extract(content: string) {
45			const emojis = [];
46			const regexMatches = [...content.matchAll(/(<a?:[\w_]+:\d+>)/gim)].map(match => match[0]);
47
48			for (const match of regexMatches) {
49			const parsed = parseEmoji(match);
50
51			if (!parsed?.id) {
52			continue;
53			}
54
55			emojis.push({
56			...parsed,
57			url: `https://cdn.discordapp.com/emojis/${encodeURIComponent(parsed.id)}.${parsed.animated ? "gif" : "png"}`
58			});
59			}
60
61			return emojis;
62			}
63
64			async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
65			await this.deferIfInteraction(message);
66
67			const link = context.isLegacy ? context.parsedNamedArgs.message_link : context.options.getString("message_link", true);
68
69			if (!/^https?:\/\/(canary\.\|ptb\.\|beta\.\|www\.\|)discord\.com\/channels\/\d+\/\d+\/\d+$/i.test(link.trim())) {
70			await this.error(message, this.validationRules[0].errors!["type:invalid"]!);
71			return;
72			}
73
74			const [messageId, channelId, guildId] = link
75			.substring(0, link[link.length - 1] === "/" ? link.length - 1 : link.length)
76			.split("/")
77			.reverse();
78
79			if (guildId !== message.guildId!) {
80			await this.error(message, "That's a message link from another server!");
81			return;
82			}
83
84			const channel = await safeChannelFetch(message.guild!, channelId);
85
86			if (!channel) {
87			await this.error(message, "The link is invalid, couldn't find the specified channel!");
88			return;
89			}
90
91			if (!channel.isTextBased()) {
92			await this.error(message, "The link points to a non-text based channel!");
93			return;
94			}
95
96			const targetMessage = await safeMessageFetch(channel, messageId);
97
98			if (!targetMessage) {
99			await this.error(
100			message,
101			"The link is invalid, couldn't find the specified message! Make sure that it wasn't deleted."
102			);
103			return;
104			}
105
106			const parsedEmojis = this.extract(targetMessage.content);
107
108			for (const embed of targetMessage.embeds) {
109			if (embed.description) {
110			parsedEmojis.push(...this.extract(embed.description));
111			}
112
113			for (const field of embed.fields) {
114			if (field.value) {
115			parsedEmojis.push(...this.extract(field.value));
116			}
117			}
118			}
119
120			const emojis: typeof parsedEmojis = [];
121
122			for (const emoji of parsedEmojis) {
123			if (!!emojis.find(e => e.id === emoji.id)) {
124			continue;
125			}
126
127			emojis.push(emoji);
128			}
129
130			if (emojis.length === 0) {
131			await this.error(message, "Could not find any server-based emoji in the given message.");
132			return;
133			}
134
135			let description = "";
136
137			for (const { name, url, animated } of emojis) {
138			description += `* [${name}](${url})${animated ? " (Animated)" : ""}\n`;
139			}
140
141			await this.deferredReply(message, {
142			embeds: [
143			new EmbedBuilder({
144			title: "Extracted Emojis",
145			color: 0x007bff,
146			description,
147			footer: {
148			text: `Extracted ${emojis.length} emojis total`
149			}
150			}).setTimestamp()
151			]
152			});
153			}
154			}