commands/moderation/SetChPermsCommand.ts

/**
* This file is part of SudoBot.
* 
* Copyright (C) 2021-2022 OSN Inc.
*
* 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 { CategoryChannel, CommandInteraction, Message, TextChannel, Permissions, PermissionString, GuildChannel, Role, AutocompleteInteraction, Collection } 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 { fetchEmoji } from '../../utils/Emoji';
import { getRoleRaw } from '../../utils/getRole';
import { channelMention } from '@discordjs/builders';
import AutoCompleteOptions from '../../types/AutoCompleteOptions';

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

    permissions = [Permissions.FLAGS.MANAGE_CHANNELS];

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

    async autoComplete(client: DiscordClient, interaction: AutocompleteInteraction, options: AutoCompleteOptions) {
        if (interaction.commandName === this.getName()) {
            const focused = interaction.options.getFocused(true);

            console.log(focused);            

            if (focused.name === 'permission') {
                const { FLAGS } = Permissions;
                const responseArray = [];
                const perms: (keyof typeof FLAGS)[] = [
                    'SEND_MESSAGES',
                    'ATTACH_FILES',
                    'EMBED_LINKS',
                    'MANAGE_MESSAGES',
                    'MENTION_EVERYONE',
                    'USE_APPLICATION_COMMANDS',
                    'USE_EXTERNAL_EMOJIS',
                    'USE_EXTERNAL_STICKERS',
                    'ADD_REACTIONS',
                    'VIEW_CHANNEL'
                ];

                for await (const key of perms) {
                    if (key.includes(focused.value.toString())) {
                        responseArray.push({
                            name: key,
                            value: key
                        });
                    }
                }

                console.log(responseArray);                

                await interaction.respond(responseArray);
            }
        }
    }

    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;
            }
            else if (channels[0].type === 'GUILD_CATEGORY') {
                const ch = channels[0];
                channels = [];

                const matching = <Collection<string, TextChannel>> await msg.guild!.channels.cache.filter(c => c.parent?.id === ch.id && c.type === 'GUILD_TEXT');
                channels = matching.toJSON();
            }

            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	/**
2	* This file is part of SudoBot.
3	*
4	* Copyright (C) 2021-2022 OSN Inc.
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 { CategoryChannel, CommandInteraction, Message, TextChannel, Permissions, PermissionString, GuildChannel, Role, AutocompleteInteraction, Collection } from 'discord.js';
21	import BaseCommand from '../../utils/structures/BaseCommand';
22	import DiscordClient from '../../client/Client';
23	import CommandOptions from '../../types/CommandOptions';
24	import InteractionOptions from '../../types/InteractionOptions';
25	import MessageEmbed from '../../client/MessageEmbed';
26	import { fetchEmoji } from '../../utils/Emoji';
27	import { getRoleRaw } from '../../utils/getRole';
28	import { channelMention } from '@discordjs/builders';
29	import AutoCompleteOptions from '../../types/AutoCompleteOptions';
30
31	export default class SetChPermsCommand extends BaseCommand {
32	supportsInteractions: boolean = true;
33
34	permissions = [Permissions.FLAGS.MANAGE_CHANNELS];
35
36	constructor() {
37	super('setchperms', 'moderation', []);
38	}
39
40	async autoComplete(client: DiscordClient, interaction: AutocompleteInteraction, options: AutoCompleteOptions) {
41	if (interaction.commandName === this.getName()) {
42	const focused = interaction.options.getFocused(true);
43
44	console.log(focused);
45
46	if (focused.name === 'permission') {
47	const { FLAGS } = Permissions;
48	const responseArray = [];
49	const perms: (keyof typeof FLAGS)[] = [
50	'SEND_MESSAGES',
51	'ATTACH_FILES',
52	'EMBED_LINKS',
53	'MANAGE_MESSAGES',
54	'MENTION_EVERYONE',
55	'USE_APPLICATION_COMMANDS',
56	'USE_EXTERNAL_EMOJIS',
57	'USE_EXTERNAL_STICKERS',
58	'ADD_REACTIONS',
59	'VIEW_CHANNEL'
60	];
61
62	for await (const key of perms) {
63	if (key.includes(focused.value.toString())) {
64	responseArray.push({
65	name: key,
66	value: key
67	});
68	}
69	}
70
71	console.log(responseArray);
72
73	await interaction.respond(responseArray);
74	}
75	}
76	}
77
78	async run(client: DiscordClient, msg: Message \| CommandInteraction, options: CommandOptions \| InteractionOptions) {
79	if (!options.isInteraction && typeof options.args[3] === 'undefined') {
80	await msg.reply({
81	embeds: [
82	new MessageEmbed()
83	.setColor('#f14a60')
84	.setDescription(`This command requires at least four arguments.`)
85	]
86	});
87
88	return;
89	}
90
91	if (msg instanceof CommandInteraction)
92	await msg.deferReply();
93	else {
94	msg = await msg.reply({
95	embeds: [
96	new MessageEmbed()
97	.setColor('GOLD')
98	.setDescription((await fetchEmoji('loading'))?.toString() + ' Working...')
99	]
100	});
101	}
102
103	const { FLAGS } = Permissions;
104
105	let channels: (TextChannel \| CategoryChannel)[] = [];
106	let permKey: PermissionString;
107	let permValue: null \| boolean = null;
108	let role: Role;
109
110	if (options.isInteraction) {
111	channels.push(<TextChannel \| CategoryChannel> options.options.getChannel('channel'));
112
113	if (channels[0].type !== 'GUILD_CATEGORY' && channels[0].type !== 'GUILD_TEXT') {
114	await this.deferReply(msg, {
115	content: (await fetchEmoji('error'))?.toString() + ' The channel with ID ' + (channels[0] as GuildChannel).id + ' is not a text channel or category.',
116	embeds: []
117	}, true);
118
119	return;
120	}
121	else if (channels[0].type === 'GUILD_CATEGORY') {
122	const ch = channels[0];
123	channels = [];
124
125	const matching = <Collection<string, TextChannel>> await msg.guild!.channels.cache.filter(c => c.parent?.id === ch.id && c.type === 'GUILD_TEXT');
126	channels = matching.toJSON();
127	}
128
129	permKey = <PermissionString> options.options.getString('permission');
130
131	if (FLAGS[permKey] === undefined) {
132	await this.deferReply(msg, {
133	content: (await fetchEmoji('error'))?.toString() + ' Invalid permission key given.',
134	embeds: []
135	}, true);
136
137	return;
138	}
139
140	const permValueInput = <string> options.options.getString('value');
141
142	if (permValueInput === 'true')
143	permValue = true;
144	else if (permValueInput === 'false')
145	permValue = false;
146	else
147	permValue = null;
148
149	role = <Role> options.options.getRole('role');
150	}
151	else {
152	const permValueInput = options.args.pop();
153
154	if (permValueInput === 'true')
155	permValue = true;
156	else if (permValueInput === 'false')
157	permValue = false;
158	else if (permValueInput === 'null')
159	permValue = null;
160	else {
161	await this.deferReply(msg, {
162	content: (await fetchEmoji('error'))?.toString() + ' Invalid permission value given, permission values must be one of these: `null`, `true`, `false`.',
163	embeds: []
164	}, true);
165
166	return;
167	}
168
169	permKey = <PermissionString> options.args.pop();
170
171	if (FLAGS[permKey] === undefined) {
172	await this.deferReply(msg, {
173	content: (await fetchEmoji('error'))?.toString() + ' Invalid permission key given.',
174	embeds: []
175	}, true);
176
177	return;
178	}
179
180	if (options.args[options.args.length - 1] === 'everyone') {
181	role = msg.guild!.roles.everyone;
182	}
183	else {
184	try {
185	role = <Role> await getRoleRaw(options.args[options.args.length - 1], msg.guild!);
186
187	if (!role)
188	throw new Error();
189	}
190	catch (e) {
191	console.log(e);
192
193	await this.deferReply(msg, {
194	content: (await fetchEmoji('error'))?.toString() + ' Invalid role given.',
195	embeds: []
196	}, true);
197
198	return;
199	}
200	}
201
202	options.args.pop();
203
204	for await (let chID of options.args) {
205	if (/^\d+$/g.test(chID)) {
206	let channel: CategoryChannel \| TextChannel;
207
208	try {
209	channel = <typeof channel> (await msg.guild!.channels.fetch(chID))!;
210
211	if (channel.type !== 'GUILD_CATEGORY' && channel.type !== 'GUILD_TEXT') {
212	await this.deferReply(msg, {
213	content: (await fetchEmoji('error'))?.toString() + ' The channel with ID ' + chID + ' is not a text channel or category.',
214	embeds: []
215	}, true);
216
217	return;
218	}
219
220	if (channel.type === 'GUILD_CATEGORY') {
221	channels = [...channel.children.filter(c => c.type === 'GUILD_TEXT').toJSON() as TextChannel[], ...channels];
222	continue;
223	}
224	}
225	catch (e) {
226	console.log(e);
227
228	await this.deferReply(msg, {
229	content: (await fetchEmoji('error'))?.toString() + ' The channel with ID ' + chID + ' could not be fetched.',
230	embeds: []
231	}, true);
232
233	return;
234	}
235
236	channels.push(channel);
237	}
238	}
239	}
240
241	if (FLAGS[permKey] === undefined) {
242	await this.deferReply(msg, {
243	content: (await fetchEmoji('error'))?.toString() + ' Invalid permission key given.',
244	embeds: []
245	}, true);
246
247	return;
248	}
249
250	let affected = '';
251
252	for await (const channel of channels) {
253	try {
254	await channel.permissionOverwrites.edit(role, {
255	[permKey]: permValue
256	});
257
258	affected += `${channelMention(channel.id)} (${channel.id})\n`;
259	}
260	catch (e) {
261	console.log(e);
262
263	await this.deferReply(msg, {
264	content: (await fetchEmoji('error'))?.toString() + ' Failed to set permissions for channel ' + channel.id,
265	embeds: []
266	}, true);
267
268	return;
269	}
270	}
271
272	await this.deferReply(msg, {
273	embeds: [
274	new MessageEmbed()
275	.setColor('GREEN')
276	.setDescription(`${(await fetchEmoji('check'))?.toString()} Permissions updated!\nThese channels were affected:\n\n${affected}`)
277	]
278	}, true);
279	}
280	}