commands/moderation/LockallCommand.ts

import { Collection, CommandInteraction, GuildBasedChannel, GuildChannel, Message, Permissions, Role, TextChannel } from 'discord.js';
import BaseCommand from '../../utils/structures/BaseCommand';
import CommandOptions from '../../types/CommandOptions';
import InteractionOptions from '../../types/InteractionOptions';
import DiscordClient from '../../client/Client';
import MessageEmbed from '../../client/MessageEmbed';

export async function lockAll(client: DiscordClient, role: Role, channels: Collection <string, TextChannel>, send: boolean = true) {
    if (role) {
        let role1 = await channels.first()!.guild.roles.fetch(client.config.props[channels.first()!.guild.id].gen_role);
        const gen = await channels.first()!.guild.roles.fetch(client.config.props[channels.first()!.guild.id].gen_role);

        await channels.forEach(async channel => {
            try {
                if (send) {
                    await channel.send({
                        embeds: [
                            new MessageEmbed()
                            .setDescription(':lock: This channel has been locked.')
                        ]
                    });
                }

                let dbPerms;
                let dbPerms1;

                let overWrites = await channel.permissionOverwrites.cache.get(role.id);
                let allowperms = await overWrites?.allow?.has(Permissions.FLAGS.SEND_MESSAGES);
                let denyperms = await overWrites?.deny?.has(Permissions.FLAGS.SEND_MESSAGES);

                let overWrites1 = await channel.permissionOverwrites.cache.get(role1!.id);
                let allowperms1 = await overWrites1?.allow?.has(Permissions.FLAGS.SEND_MESSAGES);
                let denyperms1 = await overWrites1?.deny?.has(Permissions.FLAGS.SEND_MESSAGES);

                if (allowperms && !denyperms) {
                    await (dbPerms = 'ALLOW');
                }
                else if (!allowperms && denyperms) {
                    await (dbPerms = 'DENY');
                }
                else if (!allowperms && !denyperms) {
                    await (dbPerms = 'NULL');
                }

                if (allowperms1 && !denyperms1) {
                    await (dbPerms1 = 'ALLOW');
                }
                else if (!allowperms1 && denyperms1) {
                    await (dbPerms1 = 'DENY');
                }
                else if (!allowperms1 && !denyperms1) {
                    await (dbPerms1 = 'NULL');
                }
                
                await client.db.get('INSERT INTO locks(channel_id, perms, date) VALUES(?, ?, ?)', [channel.id, dbPerms + ',' + dbPerms1, new Date().toISOString()], async (err: any) => {
                    if (err)
                        console.log(err);
                    
                    try {
                        await channel.permissionOverwrites.edit(role, {
                            SEND_MESSAGES: false,
                        });
                    }
                    catch (e) {
                        console.log(e);
                    }

                    try {
                        await channel.permissionOverwrites.edit(gen!, {
                            SEND_MESSAGES: false,
                        });
                    }
                    catch (e) {
                        console.log(e);
                    }
                })
            }
            catch (e) {
                console.log(e);
            }
        });
    }
}

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

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

    async run(client: DiscordClient, msg: Message | CommandInteraction, options: CommandOptions | InteractionOptions) {
        const raid = options.isInteraction ? options.options.getBoolean('raid') === true : (options.options.indexOf('--raid') !== -1);

        let role: Role = <Role> msg.guild!.roles.everyone;
        // const force = options.isInteraction ? options.options.getBoolean('force') === true : (options.options.indexOf('--force') !== -1);

        if (options.isInteraction) {
            if (options.options.getChannel('role')) {
                role = await <Role> options.options.getRole('role');
            }
        }
        else {
            if ((msg as Message).mentions.roles.first()) {
                role = await <Role> (msg as Message).mentions.roles.first();
            }
            else if (options.normalArgs[0] && options.normalArgs[0] !== 'everyone') {
                role = <Role> await (msg as Message).guild?.roles.fetch(options.normalArgs[0]);
            }

            if (!role) {
                await msg.reply({
                    embeds: [
                        new MessageEmbed()
                        .setColor('#f14a60')
                        .setDescription(`Invalid role given.`)
                    ],
                    ephemeral: true
                });
    
                return;
            }
        }

        const channels: Collection <string, GuildBasedChannel> = await msg.guild!.channels.cache.filter(c => (
            (!raid && (client.config.props[msg.guild!.id].lockall.indexOf(c.id) !== -1 || client.config.props[msg.guild!.id].lockall.indexOf(c.parent?.id) !== -1)) ||
            (raid && (
                (client.config.props[msg.guild!.id].raid.exclude && (client.config.props[msg.guild!.id].raid.channels.indexOf(c.id) === -1 && client.config.props[msg.guild!.id].raid.channels.indexOf(c.parent?.id) === -1)) || 
                (!client.config.props[msg.guild!.id].raid.exclude && (client.config.props[msg.guild!.id].raid.channels.indexOf(c.id) !== -1 || client.config.props[msg.guild!.id].raid.channels.indexOf(c.parent?.id) !== -1))
            ))) && c.type === 'GUILD_TEXT'
        );
        await lockAll(client, role, channels as Collection <string, TextChannel>, true);

        if (options.isInteraction) {
            await msg.reply({
                content: "The channels are locked.",
                ephemeral: true
            });
        }
        else {
            await (msg as Message).react('🔒');
        }
    }
}
1	rakin	51	import { Collection, CommandInteraction, GuildBasedChannel, GuildChannel, Message, Permissions, Role, TextChannel } from 'discord.js';
2			import BaseCommand from '../../utils/structures/BaseCommand';
3			import CommandOptions from '../../types/CommandOptions';
4			import InteractionOptions from '../../types/InteractionOptions';
5			import DiscordClient from '../../client/Client';
6			import MessageEmbed from '../../client/MessageEmbed';
7
8			export async function lockAll(client: DiscordClient, role: Role, channels: Collection <string, TextChannel>, send: boolean = true) {
9			if (role) {
10			let role1 = await channels.first()!.guild.roles.fetch(client.config.props[channels.first()!.guild.id].gen_role);
11			const gen = await channels.first()!.guild.roles.fetch(client.config.props[channels.first()!.guild.id].gen_role);
12
13			await channels.forEach(async channel => {
14			try {
15			if (send) {
16			await channel.send({
17			embeds: [
18			new MessageEmbed()
19			.setDescription(':lock: This channel has been locked.')
20			]
21			});
22			}
23
24			let dbPerms;
25			let dbPerms1;
26
27			let overWrites = await channel.permissionOverwrites.cache.get(role.id);
28			let allowperms = await overWrites?.allow?.has(Permissions.FLAGS.SEND_MESSAGES);
29			let denyperms = await overWrites?.deny?.has(Permissions.FLAGS.SEND_MESSAGES);
30
31			let overWrites1 = await channel.permissionOverwrites.cache.get(role1!.id);
32			let allowperms1 = await overWrites1?.allow?.has(Permissions.FLAGS.SEND_MESSAGES);
33			let denyperms1 = await overWrites1?.deny?.has(Permissions.FLAGS.SEND_MESSAGES);
34
35			if (allowperms && !denyperms) {
36			await (dbPerms = 'ALLOW');
37			}
38			else if (!allowperms && denyperms) {
39			await (dbPerms = 'DENY');
40			}
41			else if (!allowperms && !denyperms) {
42			await (dbPerms = 'NULL');
43			}
44
45			if (allowperms1 && !denyperms1) {
46			await (dbPerms1 = 'ALLOW');
47			}
48			else if (!allowperms1 && denyperms1) {
49			await (dbPerms1 = 'DENY');
50			}
51			else if (!allowperms1 && !denyperms1) {
52			await (dbPerms1 = 'NULL');
53			}
54
55			await client.db.get('INSERT INTO locks(channel_id, perms, date) VALUES(?, ?, ?)', [channel.id, dbPerms + ',' + dbPerms1, new Date().toISOString()], async (err: any) => {
56			if (err)
57			console.log(err);
58
59			try {
60			await channel.permissionOverwrites.edit(role, {
61			SEND_MESSAGES: false,
62			});
63			}
64			catch (e) {
65			console.log(e);
66			}
67
68			try {
69			await channel.permissionOverwrites.edit(gen!, {
70			SEND_MESSAGES: false,
71			});
72			}
73			catch (e) {
74			console.log(e);
75			}
76			})
77			}
78			catch (e) {
79			console.log(e);
80			}
81			});
82			}
83			}
84
85			export default class LockallCommand extends BaseCommand {
86			supportsInteractions: boolean = true;
87
88			constructor() {
89			super('lockall', 'moderation', []);
90			}
91
92			async run(client: DiscordClient, msg: Message \| CommandInteraction, options: CommandOptions \| InteractionOptions) {
93			const raid = options.isInteraction ? options.options.getBoolean('raid') === true : (options.options.indexOf('--raid') !== -1);
94
95			let role: Role = <Role> msg.guild!.roles.everyone;
96			// const force = options.isInteraction ? options.options.getBoolean('force') === true : (options.options.indexOf('--force') !== -1);
97
98			if (options.isInteraction) {
99			if (options.options.getChannel('role')) {
100			role = await <Role> options.options.getRole('role');
101			}
102			}
103			else {
104			if ((msg as Message).mentions.roles.first()) {
105			role = await <Role> (msg as Message).mentions.roles.first();
106			}
107			else if (options.normalArgs[0] && options.normalArgs[0] !== 'everyone') {
108			role = <Role> await (msg as Message).guild?.roles.fetch(options.normalArgs[0]);
109			}
110
111			if (!role) {
112			await msg.reply({
113			embeds: [
114			new MessageEmbed()
115			.setColor('#f14a60')
116			.setDescription(`Invalid role given.`)
117			],
118			ephemeral: true
119			});
120
121			return;
122			}
123			}
124
125			const channels: Collection <string, GuildBasedChannel> = await msg.guild!.channels.cache.filter(c => (
126			(!raid && (client.config.props[msg.guild!.id].lockall.indexOf(c.id) !== -1 \|\| client.config.props[msg.guild!.id].lockall.indexOf(c.parent?.id) !== -1)) \|\|
127			(raid && (
128			(client.config.props[msg.guild!.id].raid.exclude && (client.config.props[msg.guild!.id].raid.channels.indexOf(c.id) === -1 && client.config.props[msg.guild!.id].raid.channels.indexOf(c.parent?.id) === -1)) \|\|
129			(!client.config.props[msg.guild!.id].raid.exclude && (client.config.props[msg.guild!.id].raid.channels.indexOf(c.id) !== -1 \|\| client.config.props[msg.guild!.id].raid.channels.indexOf(c.parent?.id) !== -1))
130			))) && c.type === 'GUILD_TEXT'
131			);
132			await lockAll(client, role, channels as Collection <string, TextChannel>, true);
133
134			if (options.isInteraction) {
135			await msg.reply({
136			content: "The channels are locked.",
137			ephemeral: true
138			});
139			}
140			else {
141			await (msg as Message).react('🔒');
142			}
143			}
144			}