commands/moderation/SetChPermsCommand.ts

import { CategoryChannel, CommandInteraction, Message, TextChannel, Permissions, PermissionFlags, PermissionString, GuildChannel, Role } from 'discord.js';
import BaseCommand from '../../utils/structures/BaseCommand';
import DiscordClient from '../../client/Client';
import CommandOptions from '../../types/CommandOptions';
import InteractionOptions from '../../types/InteractionOptions';
import MessageEmbed from '../../client/MessageEmbed';
import getUser from '../../utils/getUser';
import History from '../../automod/History';
import { fetchEmoji } from '../../utils/Emoji';
import getRole, { getRoleRaw } from '../../utils/getRole';
import { channelMention } from '@discordjs/builders';

export default class BanCommand extends BaseCommand {
    supportsInteractions: boolean = true;

    constructor() {
        super('setchperms', 'moderation', []);
    }

    async run(client: DiscordClient, msg: Message | CommandInteraction, options: CommandOptions | InteractionOptions) {
        if (!options.isInteraction && typeof options.args[3] === 'undefined') {
            await msg.reply({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setDescription(`This command requires at least four arguments.`)
                ]
            });

            return;
        }

        if (msg instanceof CommandInteraction)
            await msg.deferReply();
        else {
            msg = await msg.reply({
                embeds: [
                    new MessageEmbed()
                    .setColor('GOLD')
                    .setDescription((await fetchEmoji('loading'))?.toString() + ' Working...')
                ]
            });
        }

        const { FLAGS } = Permissions;
        
        let channels: (TextChannel | CategoryChannel)[] = [];
        let permKey: PermissionString;
        let permValue: null | boolean = null;
        let role: Role;

        if (options.isInteraction) {
            channels.push(<TextChannel | CategoryChannel> options.options.getChannel('channel'));

            if (channels[0].type !== 'GUILD_CATEGORY' && channels[0].type !== 'GUILD_TEXT') {
                await this.deferReply(msg, {
                    content: (await fetchEmoji('error'))?.toString() + ' The channel with ID ' + (channels[0] as GuildChannel).id + ' is not a text channel or category.',
                    embeds: []
                }, true);

                return;
            }

            permKey = <PermissionString> options.options.getString('permission');
            
            if (FLAGS[permKey] === undefined) {
                await this.deferReply(msg, {
                    content: (await fetchEmoji('error'))?.toString() + ' Invalid permission key given.',
                    embeds: []
                }, true);

                return;
            }

            const permValueInput = <string> options.options.getString('value');

            if (permValueInput === 'true')
                permValue = true;
            else if (permValueInput === 'false')
                permValue = false;
            else
                permValue = null;

            role = <Role> options.options.getRole('role');
        }
        else {
            const permValueInput = options.args.pop();

            if (permValueInput === 'true')
                permValue = true;
            else if (permValueInput === 'false')
                permValue = false;
            else if (permValueInput === 'null')
                permValue = null;
            else {
                await this.deferReply(msg, {
                    content: (await fetchEmoji('error'))?.toString() + ' Invalid permission value given, permission values must be one of these: `null`, `true`, `false`.',
                    embeds: []
                }, true);

                return;
            }

            permKey = <PermissionString> options.args.pop();

            if (FLAGS[permKey] === undefined) {
                await this.deferReply(msg, {
                    content: (await fetchEmoji('error'))?.toString() + ' Invalid permission key given.',
                    embeds: []
                }, true);

                return;
            }

            if (options.args[options.args.length - 1] === 'everyone') {
                role = msg.guild!.roles.everyone;
            }
            else {
                try {
                    role = <Role> await getRoleRaw(options.args[options.args.length - 1], msg.guild!);
    
                    if (!role)
                        throw new Error();
                }
                catch (e) {
                    console.log(e);
                    
                    await this.deferReply(msg, {
                        content: (await fetchEmoji('error'))?.toString() + ' Invalid role given.',
                        embeds: []
                    }, true);
    
                    return;
                }
            }

            options.args.pop();

            for await (let chID of options.args) {
                if (/^\d+$/g.test(chID)) {
                    let channel: CategoryChannel | TextChannel;

                    try {
                        channel = <typeof channel> (await msg.guild!.channels.fetch(chID))!;

                        if (channel.type !== 'GUILD_CATEGORY' && channel.type !== 'GUILD_TEXT') {
                            await this.deferReply(msg, {
                                content: (await fetchEmoji('error'))?.toString() + ' The channel with ID ' + chID + ' is not a text channel or category.',
                                embeds: []
                            }, true);
    
                            return;
                        }

                        if (channel.type === 'GUILD_CATEGORY') {
                            channels = [...channel.children.filter(c => c.type === 'GUILD_TEXT').toJSON() as TextChannel[], ...channels];
                            continue;
                        }
                    }
                    catch (e) {
                        console.log(e);
                        
                        await this.deferReply(msg, {
                            content: (await fetchEmoji('error'))?.toString() + ' The channel with ID ' + chID + ' could not be fetched.',
                            embeds: []
                        }, true);

                        return;
                    }
                    
                    channels.push(channel);
                }
            }
        }

        if (FLAGS[permKey] === undefined) {
            await this.deferReply(msg, {
                content: (await fetchEmoji('error'))?.toString() + ' Invalid permission key given.',
                embeds: []
            }, true);

            return;
        }

        let affected = '';

        for await (const channel of channels) {
            try {
                await channel.permissionOverwrites.edit(role, {
                    [permKey]: permValue
                });

                affected += `${channelMention(channel.id)} (${channel.id})\n`;
            }
            catch (e) {
                console.log(e);
                
                await this.deferReply(msg, {
                    content: (await fetchEmoji('error'))?.toString() + ' Failed to set permissions for channel ' + channel.id,
                    embeds: []
                }, true);
    
                return;
            }
        }

        await this.deferReply(msg, {
            embeds: [
                new MessageEmbed()
                .setColor('GREEN')
                .setDescription(`${(await fetchEmoji('check'))?.toString()} Permissions updated!\nThese channels were affected:\n\n${affected}`)
            ]
        }, true);
    }
}
1	import { CategoryChannel, CommandInteraction, Message, TextChannel, Permissions, PermissionFlags, PermissionString, GuildChannel, Role } from 'discord.js';
2	import BaseCommand from '../../utils/structures/BaseCommand';
3	import DiscordClient from '../../client/Client';
4	import CommandOptions from '../../types/CommandOptions';
5	import InteractionOptions from '../../types/InteractionOptions';
6	import MessageEmbed from '../../client/MessageEmbed';
7	import getUser from '../../utils/getUser';
8	import History from '../../automod/History';
9	import { fetchEmoji } from '../../utils/Emoji';
10	import getRole, { getRoleRaw } from '../../utils/getRole';
11	import { channelMention } from '@discordjs/builders';
12
13	export default class BanCommand extends BaseCommand {
14	supportsInteractions: boolean = true;
15
16	constructor() {
17	super('setchperms', 'moderation', []);
18	}
19
20	async run(client: DiscordClient, msg: Message \| CommandInteraction, options: CommandOptions \| InteractionOptions) {
21	if (!options.isInteraction && typeof options.args[3] === 'undefined') {
22	await msg.reply({
23	embeds: [
24	new MessageEmbed()
25	.setColor('#f14a60')
26	.setDescription(`This command requires at least four arguments.`)
27	]
28	});
29
30	return;
31	}
32
33	if (msg instanceof CommandInteraction)
34	await msg.deferReply();
35	else {
36	msg = await msg.reply({
37	embeds: [
38	new MessageEmbed()
39	.setColor('GOLD')
40	.setDescription((await fetchEmoji('loading'))?.toString() + ' Working...')
41	]
42	});
43	}
44
45	const { FLAGS } = Permissions;
46
47	let channels: (TextChannel \| CategoryChannel)[] = [];
48	let permKey: PermissionString;
49	let permValue: null \| boolean = null;
50	let role: Role;
51
52	if (options.isInteraction) {
53	channels.push(<TextChannel \| CategoryChannel> options.options.getChannel('channel'));
54
55	if (channels[0].type !== 'GUILD_CATEGORY' && channels[0].type !== 'GUILD_TEXT') {
56	await this.deferReply(msg, {
57	content: (await fetchEmoji('error'))?.toString() + ' The channel with ID ' + (channels[0] as GuildChannel).id + ' is not a text channel or category.',
58	embeds: []
59	}, true);
60
61	return;
62	}
63
64	permKey = <PermissionString> options.options.getString('permission');
65
66	if (FLAGS[permKey] === undefined) {
67	await this.deferReply(msg, {
68	content: (await fetchEmoji('error'))?.toString() + ' Invalid permission key given.',
69	embeds: []
70	}, true);
71
72	return;
73	}
74
75	const permValueInput = <string> options.options.getString('value');
76
77	if (permValueInput === 'true')
78	permValue = true;
79	else if (permValueInput === 'false')
80	permValue = false;
81	else
82	permValue = null;
83
84	role = <Role> options.options.getRole('role');
85	}
86	else {
87	const permValueInput = options.args.pop();
88
89	if (permValueInput === 'true')
90	permValue = true;
91	else if (permValueInput === 'false')
92	permValue = false;
93	else if (permValueInput === 'null')
94	permValue = null;
95	else {
96	await this.deferReply(msg, {
97	content: (await fetchEmoji('error'))?.toString() + ' Invalid permission value given, permission values must be one of these: `null`, `true`, `false`.',
98	embeds: []
99	}, true);
100
101	return;
102	}
103
104	permKey = <PermissionString> options.args.pop();
105
106	if (FLAGS[permKey] === undefined) {
107	await this.deferReply(msg, {
108	content: (await fetchEmoji('error'))?.toString() + ' Invalid permission key given.',
109	embeds: []
110	}, true);
111
112	return;
113	}
114
115	if (options.args[options.args.length - 1] === 'everyone') {
116	role = msg.guild!.roles.everyone;
117	}
118	else {
119	try {
120	role = <Role> await getRoleRaw(options.args[options.args.length - 1], msg.guild!);
121
122	if (!role)
123	throw new Error();
124	}
125	catch (e) {
126	console.log(e);
127
128	await this.deferReply(msg, {
129	content: (await fetchEmoji('error'))?.toString() + ' Invalid role given.',
130	embeds: []
131	}, true);
132
133	return;
134	}
135	}
136
137	options.args.pop();
138
139	for await (let chID of options.args) {
140	if (/^\d+$/g.test(chID)) {
141	let channel: CategoryChannel \| TextChannel;
142
143	try {
144	channel = <typeof channel> (await msg.guild!.channels.fetch(chID))!;
145
146	if (channel.type !== 'GUILD_CATEGORY' && channel.type !== 'GUILD_TEXT') {
147	await this.deferReply(msg, {
148	content: (await fetchEmoji('error'))?.toString() + ' The channel with ID ' + chID + ' is not a text channel or category.',
149	embeds: []
150	}, true);
151
152	return;
153	}
154
155	if (channel.type === 'GUILD_CATEGORY') {
156	channels = [...channel.children.filter(c => c.type === 'GUILD_TEXT').toJSON() as TextChannel[], ...channels];
157	continue;
158	}
159	}
160	catch (e) {
161	console.log(e);
162
163	await this.deferReply(msg, {
164	content: (await fetchEmoji('error'))?.toString() + ' The channel with ID ' + chID + ' could not be fetched.',
165	embeds: []
166	}, true);
167
168	return;
169	}
170
171	channels.push(channel);
172	}
173	}
174	}
175
176	if (FLAGS[permKey] === undefined) {
177	await this.deferReply(msg, {
178	content: (await fetchEmoji('error'))?.toString() + ' Invalid permission key given.',
179	embeds: []
180	}, true);
181
182	return;
183	}
184
185	let affected = '';
186
187	for await (const channel of channels) {
188	try {
189	await channel.permissionOverwrites.edit(role, {
190	[permKey]: permValue
191	});
192
193	affected += `${channelMention(channel.id)} (${channel.id})\n`;
194	}
195	catch (e) {
196	console.log(e);
197
198	await this.deferReply(msg, {
199	content: (await fetchEmoji('error'))?.toString() + ' Failed to set permissions for channel ' + channel.id,
200	embeds: []
201	}, true);
202
203	return;
204	}
205	}
206
207	await this.deferReply(msg, {
208	embeds: [
209	new MessageEmbed()
210	.setColor('GREEN')
211	.setDescription(`${(await fetchEmoji('check'))?.toString()} Permissions updated!\nThese channels were affected:\n\n${affected}`)
212	]
213	}, true);
214	}
215	}