commands/tools/CreateBoostRoleCommand.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 { ChatInputCommandInteraction, ColorResolvable, GuildMember, SlashCommandBuilder, resolveColor } from "discord.js";
import Command, { CommandReturn, ValidationRule } from "../../core/Command";
import { ChatInputCommandContext } from "../../services/CommandManager";
import { safeRoleFetch } from "../../utils/fetch";
import { logError } from "../../utils/logger";

export default class CreateBoostRoleCommand extends Command {
    public readonly name = "createboostrole";
    public readonly validationRules: ValidationRule[] = [];
    public readonly permissions = [];
    public readonly aliases = ["cbr", "boostrole", "boosterrole", "makeboostrole"];
    public readonly supportsInteractions = true;
    public readonly supportsLegacy = false;

    public readonly description = "Creates a custom role and assigns it to you (only for boosters).";
    public readonly slashCommandBuilder = new SlashCommandBuilder()
        .addStringOption(option => option.setName("name").setDescription("The role name, defaults to your name"))
        .addStringOption(option => option.setName("color").setDescription("The role color, defaults to transparent"));

    async execute(message: ChatInputCommandInteraction, context: ChatInputCommandContext): Promise<CommandReturn> {
        await this.deferIfInteraction(message);
        const createAfterRoleId = context.config.create_boost_role?.create_roles_after;

        if (!createAfterRoleId) {
            await this.error(message, "This server does not have *automatic custom roles for boosters* enabled.");
            return;
        }

        const member = message.member! as GuildMember;

        if (!member.premiumSince && !member?.permissions.has("Administrator")) {
            await this.error(message, "You are not a booster!");
            return;
        }

        let colorCode: any = context.options.getString("color");
        const name: string = context.options.getString("name") ?? member!.displayName ?? message.user.username;

        if (colorCode && colorCode.startsWith("0x")) {
            colorCode = colorCode.replace(/^0x/i, "#");
        } else if (colorCode && !colorCode.startsWith("#")) {
            colorCode = `#${colorCode}`;
        }

        if (typeof colorCode === "string") {
            try {
                colorCode = resolveColor(colorCode as ColorResolvable);
            } catch (e) {
                logError(e);
                await this.error(message, "Invalid color code specified");
                return;
            }
        }

        const createAfterRole = (await safeRoleFetch(message.guild!, createAfterRoleId)) ?? message.guild!.roles.everyone;

        const boostRoleEntry = await this.client.prisma.boostRoleEntries.findFirst({
            where: {
                guild_id: message.guildId!,
                user_id: message.member!.user.id
            }
        });

        if (boostRoleEntry && member?.roles?.cache.has(boostRoleEntry.role_id)) {
            await this.error(message, "You already have a custom role!");
            return;
        } else if (boostRoleEntry) {
            await this.client.prisma.boostRoleEntries.delete({
                where: {
                    id: boostRoleEntry.id
                }
            });
        }

        try {
            const role = await message.guild!.roles.create({
                color: colorCode ?? undefined,
                hoist: false,
                mentionable: false,
                permissions: [],
                position: createAfterRole.position + 1,
                name,
                reason: "Creating custom role for admin/booster"
            });

            await member.roles?.add(role, "Adding the new role to the member");

            await this.client.prisma.boostRoleEntries
                .create({
                    data: {
                        guild_id: message.guildId!,
                        user_id: message.member!.user.id,
                        role_id: role.id
                    }
                })
                .catch(logError);

            await this.deferredReply(message, {
                content: `${this.emoji("check")} Assigned the role ${role.toString()} to you.`,
                allowedMentions: {
                    roles: []
                }
            });
        } catch (e) {
            logError(e);
            await this.error(message, "An error has occurred while creating the role. Make sure that I have enough permissions.");
            return;
        }
    }
}
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 { ChatInputCommandInteraction, ColorResolvable, GuildMember, SlashCommandBuilder, resolveColor } from "discord.js";
21	import Command, { CommandReturn, ValidationRule } from "../../core/Command";
22	import { ChatInputCommandContext } from "../../services/CommandManager";
23	import { safeRoleFetch } from "../../utils/fetch";
24	import { logError } from "../../utils/logger";
25
26	export default class CreateBoostRoleCommand extends Command {
27	public readonly name = "createboostrole";
28	public readonly validationRules: ValidationRule[] = [];
29	public readonly permissions = [];
30	public readonly aliases = ["cbr", "boostrole", "boosterrole", "makeboostrole"];
31	public readonly supportsInteractions = true;
32	public readonly supportsLegacy = false;
33
34	public readonly description = "Creates a custom role and assigns it to you (only for boosters).";
35	public readonly slashCommandBuilder = new SlashCommandBuilder()
36	.addStringOption(option => option.setName("name").setDescription("The role name, defaults to your name"))
37	.addStringOption(option => option.setName("color").setDescription("The role color, defaults to transparent"));
38
39	async execute(message: ChatInputCommandInteraction, context: ChatInputCommandContext): Promise<CommandReturn> {
40	await this.deferIfInteraction(message);
41	const createAfterRoleId = context.config.create_boost_role?.create_roles_after;
42
43	if (!createAfterRoleId) {
44	await this.error(message, "This server does not have automatic custom roles for boosters enabled.");
45	return;
46	}
47
48	const member = message.member! as GuildMember;
49
50	if (!member.premiumSince && !member?.permissions.has("Administrator")) {
51	await this.error(message, "You are not a booster!");
52	return;
53	}
54
55	let colorCode: any = context.options.getString("color");
56	const name: string = context.options.getString("name") ?? member!.displayName ?? message.user.username;
57
58	if (colorCode && colorCode.startsWith("0x")) {
59	colorCode = colorCode.replace(/^0x/i, "#");
60	} else if (colorCode && !colorCode.startsWith("#")) {
61	colorCode = `#${colorCode}`;
62	}
63
64	if (typeof colorCode === "string") {
65	try {
66	colorCode = resolveColor(colorCode as ColorResolvable);
67	} catch (e) {
68	logError(e);
69	await this.error(message, "Invalid color code specified");
70	return;
71	}
72	}
73
74	const createAfterRole = (await safeRoleFetch(message.guild!, createAfterRoleId)) ?? message.guild!.roles.everyone;
75
76	const boostRoleEntry = await this.client.prisma.boostRoleEntries.findFirst({
77	where: {
78	guild_id: message.guildId!,
79	user_id: message.member!.user.id
80	}
81	});
82
83	if (boostRoleEntry && member?.roles?.cache.has(boostRoleEntry.role_id)) {
84	await this.error(message, "You already have a custom role!");
85	return;
86	} else if (boostRoleEntry) {
87	await this.client.prisma.boostRoleEntries.delete({
88	where: {
89	id: boostRoleEntry.id
90	}
91	});
92	}
93
94	try {
95	const role = await message.guild!.roles.create({
96	color: colorCode ?? undefined,
97	hoist: false,
98	mentionable: false,
99	permissions: [],
100	position: createAfterRole.position + 1,
101	name,
102	reason: "Creating custom role for admin/booster"
103	});
104
105	await member.roles?.add(role, "Adding the new role to the member");
106
107	await this.client.prisma.boostRoleEntries
108	.create({
109	data: {
110	guild_id: message.guildId!,
111	user_id: message.member!.user.id,
112	role_id: role.id
113	}
114	})
115	.catch(logError);
116
117	await this.deferredReply(message, {
118	content: `${this.emoji("check")} Assigned the role ${role.toString()} to you.`,
119	allowedMentions: {
120	roles: []
121	}
122	});
123	} catch (e) {
124	logError(e);
125	await this.error(message, "An error has occurred while creating the role. Make sure that I have enough permissions.");
126	return;
127	}
128	}
129	}