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	rakinar2	577	/**
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			}