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	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 { 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			}