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