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],
            errors: {
                required: "Please specify the text to translate!",
                "type:invalid": "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.";

    protected readonly displayNames = new Intl.DisplayNames(["en"], {
        type: "language"
    });

    protected readonly supportedLocales = Intl.DisplayNames.supportedLocalesOf();

    @GatewayEventListener("interactionCreate")
    onInteractionCreate(interaction: Interaction<CacheType>) {
        if (!interaction.isAutocomplete() || interaction.commandName !== this.name) {
            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
                });
            }
        }

        if (matches.length < 25) {
            for (const locale of this.supportedLocales) {
                if (matches.length >= 25) {
                    break;
                }

                if (this.languages[locale]) {
                    continue;
                }

                const displayName = this.displayNames.of(locale);

                if (!displayName) {
                    continue;
                }

                if (locale === focused || displayName.includes(focused)) {
                    matches.push({
                        name: displayName,
                        value: locale
                    });
                }
            }
        }

        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";

        const toString = this.displayNames.of(to);

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

        if (to !== "auto" && !this.languages[to] && !this.displayNames.of(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;
        }

        const fromString = this.displayNames.of(response!.data.src);

        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 ${fromString ?? this.languages[response!.data.src] ?? response!.data.src} to ${
                            toString ?? this.languages[to] ?? 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	errors: {
45	required: "Please specify the text to translate!",
46	"type:invalid": "Invalid input given"
47	},
48	name: "text"
49	}
50	];
51	public readonly permissions = [];
52	public readonly aliases = ["Translate to English"];
53	public readonly languages: Record<string, string> = JSON5.parse(
54	readFileSync(path.resolve(__dirname, "../../../resources/languages.json"), { encoding: "utf-8" })
55	);
56
57	public readonly slashCommandBuilder = new SlashCommandBuilder()
58	.addStringOption(option => option.setName("text").setDescription("The text to translate").setRequired(true))
59	.addStringOption(option => option.setName("from").setDescription("The language of the input text").setAutocomplete(true))
60	.addStringOption(option => option.setName("to").setDescription("The language of the output text").setAutocomplete(true));
61
62	public readonly otherApplicationCommandBuilders = [
63	new ContextMenuCommandBuilder()
64	.setName("Translate to English")
65	.setType(ApplicationCommandType.Message)
66	.setDMPermission(false)
67	];
68
69	public readonly description = "Translates the given text.";
70
71	protected readonly displayNames = new Intl.DisplayNames(["en"], {
72	type: "language"
73	});
74
75	protected readonly supportedLocales = Intl.DisplayNames.supportedLocalesOf();
76
77	@GatewayEventListener("interactionCreate")
78	onInteractionCreate(interaction: Interaction<CacheType>) {
79	if (!interaction.isAutocomplete() \|\| interaction.commandName !== this.name) {
80	return;
81	}
82
83	const focused = interaction.options.getFocused();
84	const matches: ApplicationCommandOptionChoiceData[] = [];
85
86	for (const code in this.languages) {
87	if (matches.length >= 25) {
88	break;
89	}
90
91	if (code === focused \|\| this.languages[code].includes(focused)) {
92	matches.push({
93	name: this.languages[code],
94	value: code
95	});
96	}
97	}
98
99	if (matches.length < 25) {
100	for (const locale of this.supportedLocales) {
101	if (matches.length >= 25) {
102	break;
103	}
104
105	if (this.languages[locale]) {
106	continue;
107	}
108
109	const displayName = this.displayNames.of(locale);
110
111	if (!displayName) {
112	continue;
113	}
114
115	if (locale === focused \|\| displayName.includes(focused)) {
116	matches.push({
117	name: displayName,
118	value: locale
119	});
120	}
121	}
122	}
123
124	console.log(matches);
125	interaction.respond(matches).catch(console.error);
126	}
127
128	async execute(message: CommandMessage, context: AnyCommandContext): Promise<CommandReturn> {
129	await this.deferIfInteraction(message);
130
131	const text = context.isLegacy
132	? context.parsedNamedArgs.text
133	: message instanceof MessageContextMenuCommandInteraction && context.isContextMenu
134	? message.targetMessage.content
135	: (context as ChatInputCommandContext).options.getString("text", true);
136
137	if (!text) {
138	await this.error(message, "Invalid text content provided.");
139	return;
140	}
141
142	const from = context.isLegacy ? "auto" : (context.isContextMenu ? "auto" : context.options.getString("from")) ?? "auto";
143	const to = context.isLegacy ? "en" : (context.isContextMenu ? "en" : context.options.getString("to")) ?? "en";
144
145	const toString = this.displayNames.of(to);
146
147	if (from !== "auto" && !this.languages[from] && !this.displayNames.of(from)) {
148	await this.error(message, "Invalid language specified in the `from` option");
149	return;
150	}
151
152	if (to !== "auto" && !this.languages[to] && !this.displayNames.of(to)) {
153	await this.error(message, "Invalid language specified in the `to` option");
154	return;
155	}
156
157	const { error, translation, response } = await this.client.translator.translate(text, from, to);
158
159	if (error) {
160	await this.deferredReply(message, {
161	embeds: [
162	new EmbedBuilder({
163	color: 0xf14a60,
164	author: {
165	name: "Translation Failed"
166	},
167	description: `${this.emoji("error")} Couldn't translate that due to an internal error.`,
168	footer: {
169	text: "Powered by Google Translate"
170	}
171	}).setTimestamp()
172	]
173	});
174
175	return;
176	}
177
178	const fromString = this.displayNames.of(response!.data.src);
179
180	await this.deferredReply(message, {
181	embeds: [
182	new EmbedBuilder({
183	color: 0x007bff,
184	author: {
185	name:
186	message instanceof MessageContextMenuCommandInteraction
187	? (message.targetMessage.author as User).username
188	: "Translation",
189	iconURL:
190	message instanceof MessageContextMenuCommandInteraction
191	? (message.targetMessage.author as User).displayAvatarURL()
192	: undefined
193	},
194	description: translation,
195	footer: {
196	text: `Translated from ${fromString ?? this.languages[response!.data.src] ?? response!.data.src} to ${
197	toString ?? this.languages[to] ?? to
198	} • Powered by Google Translate`
199	}
200	})
201	]
202	});
203	}
204	}