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 { logError } from "../../utils/Logger";
import { safeRoleFetch } from "../../utils/fetch";

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 = context.options.getString("color");
        let colorCodeHex: number | null = null;
        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 {
                colorCodeHex = 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: colorCodeHex ?? 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 { logError } from "../../utils/Logger";
24	import { safeRoleFetch } from "../../utils/fetch";
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 = context.options.getString("color");
56	let colorCodeHex: number \| null = null;
57	const name: string = context.options.getString("name") ?? member!.displayName ?? message.user.username;
58
59	if (colorCode && colorCode.startsWith("0x")) {
60	colorCode = colorCode.replace(/^0x/i, "#");
61	} else if (colorCode && !colorCode.startsWith("#")) {
62	colorCode = `#${colorCode}`;
63	}
64
65	if (typeof colorCode === "string") {
66	try {
67	colorCodeHex = resolveColor(colorCode as ColorResolvable);
68	} catch (e) {
69	logError(e);
70	await this.error(message, "Invalid color code specified");
71	return;
72	}
73	}
74
75	const createAfterRole = (await safeRoleFetch(message.guild!, createAfterRoleId)) ?? message.guild!.roles.everyone;
76
77	const boostRoleEntry = await this.client.prisma.boostRoleEntries.findFirst({
78	where: {
79	guild_id: message.guildId!,
80	user_id: message.member!.user.id
81	}
82	});
83
84	if (boostRoleEntry && member?.roles?.cache.has(boostRoleEntry.role_id)) {
85	await this.error(message, "You already have a custom role!");
86	return;
87	} else if (boostRoleEntry) {
88	await this.client.prisma.boostRoleEntries.delete({
89	where: {
90	id: boostRoleEntry.id
91	}
92	});
93	}
94
95	try {
96	const role = await message.guild!.roles.create({
97	color: colorCodeHex ?? undefined,
98	hoist: false,
99	mentionable: false,
100	permissions: [],
101	position: createAfterRole.position + 1,
102	name,
103	reason: "Creating custom role for admin/booster"
104	});
105
106	await member.roles?.add(role, "Adding the new role to the member");
107
108	await this.client.prisma.boostRoleEntries
109	.create({
110	data: {
111	guild_id: message.guildId!,
112	user_id: message.member!.user.id,
113	role_id: role.id
114	}
115	})
116	.catch(logError);
117
118	await this.deferredReply(message, {
119	content: `${this.emoji("check")} Assigned the role ${role.toString()} to you.`,
120	allowedMentions: {
121	roles: []
122	}
123	});
124	} catch (e) {
125	logError(e);
126	await this.error(message, "An error has occurred while creating the role. Make sure that I have enough permissions.");
127	return;
128	}
129	}
130	}