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