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