commands/fun/PixabayCommand.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 axios from "axios";
import { EmbedBuilder, SlashCommandBuilder } from "discord.js";
import Command, {
    ArgumentType,
    BasicCommandContext,
    CommandMessage,
    CommandReturn,
    ValidationRule
} from "../../core/Command";

function url() {
    return `https://pixabay.com/api/?key=${process.env.PIXABAY_TOKEN}&safesearch=true&per_page=3`;
}

export async function image(
    cmd: Command & { hitError: PixabayCommand["hitError"] },
    message: CommandMessage,
    options: BasicCommandContext,
    type: "photo" | "all" | "illustration" | "vector"
) {
    let genurl = `${url()}&image_type=${type}`;
    const query = !options.isLegacy
        ? options.options.getString("query")
        : options.parsedNamedArgs.query;

    if (query && query.trim() !== "") {
        const q = new URLSearchParams({ q: query }).toString();
        genurl += `&${q}`;
    }

    axios
        .get(genurl)
        .then(async res => {
            if (res && res.status === 200) {
                if (!res.data.hits || res.data.hits?.length < 1) {
                    await cmd.hitError(message, "No search result found from the API.");

                    return;
                }

                await cmd.deferredReply(message, {
                    content:
                        res.data.hits[Math.floor(Math.random() * res.data.hits.length)]
                            .largeImageURL
                });
            }
        })
        .catch(async () => {
            await cmd.deferredReply(message, {
                embeds: [
                    new EmbedBuilder()
                        .setColor("#f14a60")
                        .setDescription(
                            "Too many requests at the same time, please try again after some time."
                        )
                ]
            });
        });
}

export async function photo(
    cmd: Command & { hitError: PixabayCommand["hitError"] },
    message: CommandMessage,
    options: BasicCommandContext
) {
    await image(cmd, message, options, "photo");
}

export async function vector(
    cmd: Command & { hitError: PixabayCommand["hitError"] },
    message: CommandMessage,
    options: BasicCommandContext
) {
    await image(cmd, message, options, "vector");
}

export async function illustration(
    cmd: Command & { hitError: PixabayCommand["hitError"] },
    message: CommandMessage,
    options: BasicCommandContext
) {
    await image(cmd, message, options, "illustration");
}

export default class PixabayCommand extends Command {
    public readonly name = "pixabay";
    public readonly subcommandsCustom = ["image", "photo", "illustration", "vector"];
    public readonly validationRules: ValidationRule[] = [
        {
            types: [ArgumentType.String],
            name: "subcommand",
            errors: {
                required: `Please provide a valid subcommand! The available subcommands are: \`${this.subcommandsCustom.join(
                    "`, `"
                )}\`.`
            }
        },
        {
            types: [ArgumentType.StringRest],
            name: "query",
            optional: true,
            errors: {
                "type:invalid": "Invalid query given"
            }
        }
    ];
    public readonly permissions = [];
    public readonly description = "Fetch images from Pixabay";

    public readonly slashCommandBuilder = new SlashCommandBuilder()
        .addSubcommand(subcommand =>
            subcommand
                .setName("image")
                .setDescription("Fetch any type of image")
                .addStringOption(option =>
                    option.setName("query").setDescription("The search query")
                )
        )
        .addSubcommand(subcommand =>
            subcommand
                .setName("photo")
                .setDescription("Fetch captured photos only")
                .addStringOption(option =>
                    option.setName("query").setDescription("The search query")
                )
        )
        .addSubcommand(subcommand =>
            subcommand
                .setName("vector")
                .setDescription("Fetch vector graphics only")
                .addStringOption(option =>
                    option.setName("query").setDescription("The search query")
                )
        )
        .addSubcommand(subcommand =>
            subcommand
                .setName("illustration")
                .setDescription("Fetch illustrations")
                .addStringOption(option =>
                    option.setName("query").setDescription("The search query")
                )
        );

    public hitError(message: CommandMessage, errorMessage: string) {
        return this.error(message, errorMessage);
    }

    async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
        const subcmd = context.isLegacy
            ? context.parsedNamedArgs.subcommand
            : context.options.getSubcommand(true);

        if (subcmd === "photo") {
            await photo(this, message, context);
        } else if (subcmd === "vector") {
            await vector(this, message, context);
        } else if (subcmd === "illustration") {
            await illustration(this, message, context);
        } else if (subcmd === "image") {
            await image(this, message, context, "all");
        }
    }
}
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 axios from "axios";
21			import { EmbedBuilder, SlashCommandBuilder } from "discord.js";
22			import Command, {
23			ArgumentType,
24			BasicCommandContext,
25			CommandMessage,
26			CommandReturn,
27			ValidationRule
28			} from "../../core/Command";
29
30			function url() {
31			return `https://pixabay.com/api/?key=${process.env.PIXABAY_TOKEN}&safesearch=true&per_page=3`;
32			}
33
34			export async function image(
35			cmd: Command & { hitError: PixabayCommand["hitError"] },
36			message: CommandMessage,
37			options: BasicCommandContext,
38			type: "photo" \| "all" \| "illustration" \| "vector"
39			) {
40			let genurl = `${url()}&image_type=${type}`;
41			const query = !options.isLegacy
42			? options.options.getString("query")
43			: options.parsedNamedArgs.query;
44
45			if (query && query.trim() !== "") {
46			const q = new URLSearchParams({ q: query }).toString();
47			genurl += `&${q}`;
48			}
49
50			axios
51			.get(genurl)
52			.then(async res => {
53			if (res && res.status === 200) {
54			if (!res.data.hits \|\| res.data.hits?.length < 1) {
55			await cmd.hitError(message, "No search result found from the API.");
56
57			return;
58			}
59
60			await cmd.deferredReply(message, {
61			content:
62			res.data.hits[Math.floor(Math.random() * res.data.hits.length)]
63			.largeImageURL
64			});
65			}
66			})
67			.catch(async () => {
68			await cmd.deferredReply(message, {
69			embeds: [
70			new EmbedBuilder()
71			.setColor("#f14a60")
72			.setDescription(
73			"Too many requests at the same time, please try again after some time."
74			)
75			]
76			});
77			});
78			}
79
80			export async function photo(
81			cmd: Command & { hitError: PixabayCommand["hitError"] },
82			message: CommandMessage,
83			options: BasicCommandContext
84			) {
85			await image(cmd, message, options, "photo");
86			}
87
88			export async function vector(
89			cmd: Command & { hitError: PixabayCommand["hitError"] },
90			message: CommandMessage,
91			options: BasicCommandContext
92			) {
93			await image(cmd, message, options, "vector");
94			}
95
96			export async function illustration(
97			cmd: Command & { hitError: PixabayCommand["hitError"] },
98			message: CommandMessage,
99			options: BasicCommandContext
100			) {
101			await image(cmd, message, options, "illustration");
102			}
103
104			export default class PixabayCommand extends Command {
105			public readonly name = "pixabay";
106			public readonly subcommandsCustom = ["image", "photo", "illustration", "vector"];
107			public readonly validationRules: ValidationRule[] = [
108			{
109			types: [ArgumentType.String],
110			name: "subcommand",
111			errors: {
112			required: `Please provide a valid subcommand! The available subcommands are: \`${this.subcommandsCustom.join(
113			"`, `"
114			)}\`.`
115			}
116			},
117			{
118			types: [ArgumentType.StringRest],
119			name: "query",
120			optional: true,
121			errors: {
122			"type:invalid": "Invalid query given"
123			}
124			}
125			];
126			public readonly permissions = [];
127			public readonly description = "Fetch images from Pixabay";
128
129			public readonly slashCommandBuilder = new SlashCommandBuilder()
130			.addSubcommand(subcommand =>
131			subcommand
132			.setName("image")
133			.setDescription("Fetch any type of image")
134			.addStringOption(option =>
135			option.setName("query").setDescription("The search query")
136			)
137			)
138			.addSubcommand(subcommand =>
139			subcommand
140			.setName("photo")
141			.setDescription("Fetch captured photos only")
142			.addStringOption(option =>
143			option.setName("query").setDescription("The search query")
144			)
145			)
146			.addSubcommand(subcommand =>
147			subcommand
148			.setName("vector")
149			.setDescription("Fetch vector graphics only")
150			.addStringOption(option =>
151			option.setName("query").setDescription("The search query")
152			)
153			)
154			.addSubcommand(subcommand =>
155			subcommand
156			.setName("illustration")
157			.setDescription("Fetch illustrations")
158			.addStringOption(option =>
159			option.setName("query").setDescription("The search query")
160			)
161			);
162
163			public hitError(message: CommandMessage, errorMessage: string) {
164			return this.error(message, errorMessage);
165			}
166
167			async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
168			const subcmd = context.isLegacy
169			? context.parsedNamedArgs.subcommand
170			: context.options.getSubcommand(true);
171
172			if (subcmd === "photo") {
173			await photo(this, message, context);
174			} else if (subcmd === "vector") {
175			await vector(this, message, context);
176			} else if (subcmd === "illustration") {
177			await illustration(this, message, context);
178			} else if (subcmd === "image") {
179			await image(this, message, context, "all");
180			}
181			}
182			}