commands/tools/TranslateCommand.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 {
    ApplicationCommandOptionChoiceData,
    ApplicationCommandType,
    CacheType,
    ContextMenuCommandBuilder,
    EmbedBuilder,
    Interaction,
    MessageContextMenuCommandInteraction,
    SlashCommandBuilder,
    User
} from "discord.js";
import { readFileSync } from "fs";
import JSON5 from "json5";
import path from "path";
import Command, { AnyCommandContext, ArgumentType, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
import { GatewayEventListener } from "../../decorators/GatewayEventListener";
import { ChatInputCommandContext } from "../../services/CommandManager";
import { HasEventListeners } from "../../types/HasEventListeners";

export default class TranslateCommand extends Command implements HasEventListeners {
    public readonly name = "translate";
    public readonly validationRules: ValidationRule[] = [
        {
            types: [ArgumentType.StringRest],
            requiredErrorMessage: "Please specify the text to translate!",
            typeErrorMessage: "Invalid input given",
            name: "text"
        }
    ];
    public readonly permissions = [];
    public readonly aliases = ["Translate to English"];
    public readonly languages: Record<string, string> = JSON5.parse(
        readFileSync(path.resolve(__dirname, "../../../resources/languages.json"), { encoding: "utf-8" })
    );

    public readonly slashCommandBuilder = new SlashCommandBuilder()
        .addStringOption(option => option.setName("text").setDescription("The text to translate").setRequired(true))
        .addStringOption(option => option.setName("from").setDescription("The language of the input text").setAutocomplete(true))
        .addStringOption(option => option.setName("to").setDescription("The language of the output text").setAutocomplete(true));

    public readonly otherApplicationCommandBuilders = [
        new ContextMenuCommandBuilder()
            .setName("Translate to English")
            .setType(ApplicationCommandType.Message)
            .setDMPermission(false)
    ];

    public readonly description = "Translates the given text.";

    @GatewayEventListener("interactionCreate")
    onInteractionCreate(interaction: Interaction<CacheType>) {
        if (!interaction.isAutocomplete()) {
            return;
        }

        const focused = interaction.options.getFocused();
        const matches: ApplicationCommandOptionChoiceData[] = [];

        for (const code in this.languages) {
            if (matches.length >= 25) {
                break;
            }

            if (code === focused || this.languages[code].includes(focused)) {
                matches.push({
                    name: this.languages[code],
                    value: code
                });
            }
        }

        console.log(matches);
        interaction.respond(matches).catch(console.error);
    }

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

        const text = context.isLegacy
            ? context.parsedNamedArgs.text
            : message instanceof MessageContextMenuCommandInteraction && context.isContextMenu
            ? message.targetMessage.content
            : (context as ChatInputCommandContext).options.getString("text", true);

        if (!text) {
            await this.error(message, "Invalid text content provided.");
            return;
        }

        const from = context.isLegacy ? "auto" : (context.isContextMenu ? "auto" : context.options.getString("from")) ?? "auto";
        const to = context.isLegacy ? "en" : (context.isContextMenu ? "en" : context.options.getString("to")) ?? "en";

        if (from !== "auto" && !this.languages[from]) {
            await this.error(message, "Invalid language specified in the `from` option");
            return;
        }

        if (to !== "auto" && !this.languages[to]) {
            await this.error(message, "Invalid language specified in the `to` option");
            return;
        }

        const { error, translation, response } = await this.client.translator.translate(text, from, to);

        if (error) {
            await this.deferredReply(message, {
                embeds: [
                    new EmbedBuilder({
                        color: 0xf14a60,
                        author: {
                            name: "Translation Failed"
                        },
                        description: `${this.emoji("error")} Couldn't translate that due to an internal error.`,
                        footer: {
                            text: "Powered by Google Translate"
                        }
                    }).setTimestamp()
                ]
            });

            return;
        }

        await this.deferredReply(message, {
            embeds: [
                new EmbedBuilder({
                    color: 0x007bff,
                    author: {
                        name:
                            message instanceof MessageContextMenuCommandInteraction
                                ? (message.targetMessage.author as User).username
                                : "Translation",
                        iconURL:
                            message instanceof MessageContextMenuCommandInteraction
                                ? (message.targetMessage.author as User).displayAvatarURL()
                                : undefined
                    },
                    description: translation,
                    footer: {
                        text: `Translated from ${this.languages[response!.data.src]} to ${
                            this.languages[to]
                        } • Powered by Google Translate`
                    }
                })
            ]
        });
    }
}
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 {
21			ApplicationCommandOptionChoiceData,
22			ApplicationCommandType,
23			CacheType,
24			ContextMenuCommandBuilder,
25			EmbedBuilder,
26			Interaction,
27			MessageContextMenuCommandInteraction,
28			SlashCommandBuilder,
29			User
30			} from "discord.js";
31			import { readFileSync } from "fs";
32			import JSON5 from "json5";
33			import path from "path";
34			import Command, { AnyCommandContext, ArgumentType, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
35			import { GatewayEventListener } from "../../decorators/GatewayEventListener";
36			import { ChatInputCommandContext } from "../../services/CommandManager";
37			import { HasEventListeners } from "../../types/HasEventListeners";
38
39			export default class TranslateCommand extends Command implements HasEventListeners {
40			public readonly name = "translate";
41			public readonly validationRules: ValidationRule[] = [
42			{
43			types: [ArgumentType.StringRest],
44			requiredErrorMessage: "Please specify the text to translate!",
45			typeErrorMessage: "Invalid input given",
46			name: "text"
47			}
48			];
49			public readonly permissions = [];
50			public readonly aliases = ["Translate to English"];
51			public readonly languages: Record<string, string> = JSON5.parse(
52			readFileSync(path.resolve(__dirname, "../../../resources/languages.json"), { encoding: "utf-8" })
53			);
54
55			public readonly slashCommandBuilder = new SlashCommandBuilder()
56			.addStringOption(option => option.setName("text").setDescription("The text to translate").setRequired(true))
57			.addStringOption(option => option.setName("from").setDescription("The language of the input text").setAutocomplete(true))
58			.addStringOption(option => option.setName("to").setDescription("The language of the output text").setAutocomplete(true));
59
60			public readonly otherApplicationCommandBuilders = [
61			new ContextMenuCommandBuilder()
62			.setName("Translate to English")
63			.setType(ApplicationCommandType.Message)
64			.setDMPermission(false)
65			];
66
67			public readonly description = "Translates the given text.";
68
69			@GatewayEventListener("interactionCreate")
70			onInteractionCreate(interaction: Interaction<CacheType>) {
71			if (!interaction.isAutocomplete()) {
72			return;
73			}
74
75			const focused = interaction.options.getFocused();
76			const matches: ApplicationCommandOptionChoiceData[] = [];
77
78			for (const code in this.languages) {
79			if (matches.length >= 25) {
80			break;
81			}
82
83			if (code === focused \|\| this.languages[code].includes(focused)) {
84			matches.push({
85			name: this.languages[code],
86			value: code
87			});
88			}
89			}
90
91			console.log(matches);
92			interaction.respond(matches).catch(console.error);
93			}
94
95			async execute(message: CommandMessage, context: AnyCommandContext): Promise<CommandReturn> {
96			await this.deferIfInteraction(message);
97
98			const text = context.isLegacy
99			? context.parsedNamedArgs.text
100			: message instanceof MessageContextMenuCommandInteraction && context.isContextMenu
101			? message.targetMessage.content
102			: (context as ChatInputCommandContext).options.getString("text", true);
103
104			if (!text) {
105			await this.error(message, "Invalid text content provided.");
106			return;
107			}
108
109			const from = context.isLegacy ? "auto" : (context.isContextMenu ? "auto" : context.options.getString("from")) ?? "auto";
110			const to = context.isLegacy ? "en" : (context.isContextMenu ? "en" : context.options.getString("to")) ?? "en";
111
112			if (from !== "auto" && !this.languages[from]) {
113			await this.error(message, "Invalid language specified in the `from` option");
114			return;
115			}
116
117			if (to !== "auto" && !this.languages[to]) {
118			await this.error(message, "Invalid language specified in the `to` option");
119			return;
120			}
121
122			const { error, translation, response } = await this.client.translator.translate(text, from, to);
123
124			if (error) {
125			await this.deferredReply(message, {
126			embeds: [
127			new EmbedBuilder({
128			color: 0xf14a60,
129			author: {
130			name: "Translation Failed"
131			},
132			description: `${this.emoji("error")} Couldn't translate that due to an internal error.`,
133			footer: {
134			text: "Powered by Google Translate"
135			}
136			}).setTimestamp()
137			]
138			});
139
140			return;
141			}
142
143			await this.deferredReply(message, {
144			embeds: [
145			new EmbedBuilder({
146			color: 0x007bff,
147			author: {
148			name:
149			message instanceof MessageContextMenuCommandInteraction
150			? (message.targetMessage.author as User).username
151			: "Translation",
152			iconURL:
153			message instanceof MessageContextMenuCommandInteraction
154			? (message.targetMessage.author as User).displayAvatarURL()
155			: undefined
156			},
157			description: translation,
158			footer: {
159			text: `Translated from ${this.languages[response!.data.src]} to ${
160			this.languages[to]
161			} • Powered by Google Translate`
162			}
163			})
164			]
165			});
166			}
167			}