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: Function }, message: CommandMessage, options: BasicCommandContext, type: "photo" | "all" | "illustration" | "vector") {
    let genurl = `${url()}&image_type=${type}`;
    let query = !options.isLegacy ? options.options.getString("query") : options.parsedNamedArgs.query;

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

    axios
        .get(genurl)
        .then(async res => {
            if (res && res.status === 200) {
                //console.log(res.data.hits);
                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 err => {
            console.log(err.message);
            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: Function }, message: CommandMessage, options: BasicCommandContext) {
    await image(cmd, message, options, "photo");
}

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

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