src/commands/AnimeCommand.ts

import { Buildable, Command } from "@framework/commands/Command";
import InteractionContext from "@framework/commands/InteractionContext";
import LegacyContext from "@framework/commands/LegacyContext";
import { GatewayEventListener } from "@framework/events/GatewayEventListener";
import { HasEventListeners } from "@framework/types/HasEventListeners";
import { getAxiosClient } from "@sudobot/utils/axios";
import {
    ApplicationCommandOptionChoiceData,
    ChatInputCommandInteraction,
    type Interaction
} from "discord.js";

export default class AnimeCommand extends Command implements HasEventListeners {
    public override readonly name = "anime";
    public override readonly description = "Fetch a random anime waifu image.";
    public override readonly permissions = [];
    public override readonly defer = true;
    private readonly validCategories = [
        "waifu",
        "neko",
        "shinobu",
        "megumin",
        "bully",
        "cuddle",
        "cry",
        "hug",
        "awoo",
        "kiss",
        "lick",
        "pat",
        "smug",
        "bonk",
        "yeet",
        "blush",
        "smile",
        "wave",
        "highfive",
        "handhold",
        "nom",
        "bite",
        "glomp",
        "slap",
        "kill",
        "kick",
        "happy",
        "wink",
        "poke",
        "dance",
        "cringe"
    ];

    public override build(): Buildable[] {
        return [
            this.buildChatInput().addStringOption(option =>
                option
                    .setName("category")
                    .setDescription("The category of the image to fetch.")
                    .setRequired(true)
                    .setAutocomplete(true)
            )
        ];
    }

    @GatewayEventListener("interactionCreate")
    public async onInteractionCreate(interaction: Interaction) {
        if (!interaction.isAutocomplete() || interaction.commandName !== this.name) {
            return;
        }

        const query = interaction.options.getString("category", true);
        const results: ApplicationCommandOptionChoiceData[] = [];

        for (const category of this.validCategories) {
            if (results.length >= 25) {
                break;
            }

            if (category.startsWith(query.toLowerCase())) {
                results.push({
                    name: category[0].toUpperCase() + category.slice(1),
                    value: category
                });
            }
        }

        await interaction.respond(results);
    }

    public override async execute(
        context: LegacyContext | InteractionContext<ChatInputCommandInteraction>
    ) {
        const category = (
            context.isLegacy() ? context.args[0] : context.options.getString("category", true)
        )?.toLowerCase();

        if (!category || !this.validCategories.includes(category)) {
            return void (await context.reply(
                `Please provide a valid category. Valid categories are: ${this.validCategories.join(", ")}`
            ));
        }

        const url = `https://api.waifu.pics/sfw/${category}`;

        try {
            const response = await getAxiosClient().get(url);

            if (response.status < 200 || response.status >= 300) {
                throw new Error("Invalid status code");
            }

            try {
                await context.reply({
                    files: [
                        {
                            attachment: response.data.url
                        }
                    ]
                });
            } catch (error) {
                this.application.logger.error(error);
                await context.error("Failed to send image to this channel.");
            }
        } catch (error) {
            this.application.logger.error(error);
            await context.error("Failed to fetch image.");
        }
    }
}
1	rakinar2	626	import { Buildable, Command } from "@framework/commands/Command";
2			import InteractionContext from "@framework/commands/InteractionContext";
3			import LegacyContext from "@framework/commands/LegacyContext";
4			import { GatewayEventListener } from "@framework/events/GatewayEventListener";
5			import { HasEventListeners } from "@framework/types/HasEventListeners";
6			import { getAxiosClient } from "@sudobot/utils/axios";
7			import {
8			ApplicationCommandOptionChoiceData,
9			ChatInputCommandInteraction,
10			type Interaction
11			} from "discord.js";
12
13			export default class AnimeCommand extends Command implements HasEventListeners {
14			public override readonly name = "anime";
15			public override readonly description = "Fetch a random anime waifu image.";
16			public override readonly permissions = [];
17			public override readonly defer = true;
18			private readonly validCategories = [
19			"waifu",
20			"neko",
21			"shinobu",
22			"megumin",
23			"bully",
24			"cuddle",
25			"cry",
26			"hug",
27			"awoo",
28			"kiss",
29			"lick",
30			"pat",
31			"smug",
32			"bonk",
33			"yeet",
34			"blush",
35			"smile",
36			"wave",
37			"highfive",
38			"handhold",
39			"nom",
40			"bite",
41			"glomp",
42			"slap",
43			"kill",
44			"kick",
45			"happy",
46			"wink",
47			"poke",
48			"dance",
49			"cringe"
50			];
51
52			public override build(): Buildable[] {
53			return [
54			this.buildChatInput().addStringOption(option =>
55			option
56			.setName("category")
57			.setDescription("The category of the image to fetch.")
58			.setRequired(true)
59			.setAutocomplete(true)
60			)
61			];
62			}
63
64			@GatewayEventListener("interactionCreate")
65			public async onInteractionCreate(interaction: Interaction) {
66			if (!interaction.isAutocomplete() \|\| interaction.commandName !== this.name) {
67			return;
68			}
69
70			const query = interaction.options.getString("category", true);
71			const results: ApplicationCommandOptionChoiceData[] = [];
72
73			for (const category of this.validCategories) {
74			if (results.length >= 25) {
75			break;
76			}
77
78			if (category.startsWith(query.toLowerCase())) {
79			results.push({
80			name: category[0].toUpperCase() + category.slice(1),
81			value: category
82			});
83			}
84			}
85
86			await interaction.respond(results);
87			}
88
89			public override async execute(
90			context: LegacyContext \| InteractionContext<ChatInputCommandInteraction>
91			) {
92			const category = (
93			context.isLegacy() ? context.args[0] : context.options.getString("category", true)
94			)?.toLowerCase();
95
96			if (!category \|\| !this.validCategories.includes(category)) {
97			return void (await context.reply(
98			`Please provide a valid category. Valid categories are: ${this.validCategories.join(", ")}`
99			));
100			}
101
102			const url = `https://api.waifu.pics/sfw/${category}`;
103
104			try {
105			const response = await getAxiosClient().get(url);
106
107			if (response.status < 200 \|\| response.status >= 300) {
108			throw new Error("Invalid status code");
109			}
110
111			try {
112			await context.reply({
113			files: [
114			{
115			attachment: response.data.url
116			}
117			]
118			});
119			} catch (error) {
120			this.application.logger.error(error);
121			await context.error("Failed to send image to this channel.");
122			}
123			} catch (error) {
124			this.application.logger.error(error);
125			await context.error("Failed to fetch image.");
126			}
127			}
128			}