commands/moderation/UnlockallCommand.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 unlockAll(client: DiscordClient, role: Role, msg: Message | CommandInteraction, options: CommandOptions | InteractionOptions, channels: Collection <string, TextChannel>, force: boolean) {
    if (role) {
        const gen = await msg.guild!.roles.fetch(client.config.props[msg.guild!.id].gen_role);

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

                client.db.get('SELECT * FROM locks WHERE channel_id = ?', [channel.id], async (err: any, data: any) => {
                    if (data || force) {
                        let perm1;
                        let perm;
                        const data1 = data?.perms?.split(',');

                        if (data1) {
                            if (data1[0] === 'DENY') {
                                await (perm = false);
                            }
                            else if (data1[0] === 'NULL') {
                                await (perm = null);
                            }
                            else if (data1[0] === 'ALLOW') {
                                await (perm = true);
                            }

                            if (data1[1] === 'DENY') {
                                await (perm1 = false);
                            }
                            else if (data1[1] === 'NULL') {
                                await (perm1 = null);
                            }
                            else if (data1[1] === 'ALLOW') {
                                await (perm1 = true);
                            }
                        }
                        
                        if (force) {
                            await (perm1 = true);
                            await (perm = true);
                        }

                        await console.log(channel.name);

                        try {
                            await channel.permissionOverwrites.edit(role, {
                                SEND_MESSAGES: perm,
                            });

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

                        await console.log(perm, perm1);

                        if (data) {
                            await client.db.get('DELETE FROM locks WHERE id = ?', [data?.id], async (err: any) => {});
                        }
                    }
                });
            }
            catch(e) {
                console.log(e);
            }
        });
    }
}

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

    constructor() {
        super('unlockall', '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 unlockAll(client, role, msg, options, channels as Collection <string, TextChannel>, force);

        if (options.isInteraction) {
            await msg.reply({
                content: "The channels are unlocked.",
                ephemeral: true
            });
        }
        else {
            await (msg as Message).react('🔓');
        }
    }
}
1	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 unlockAll(client: DiscordClient, role: Role, msg: Message \| CommandInteraction, options: CommandOptions \| InteractionOptions, channels: Collection <string, TextChannel>, force: boolean) {
9	if (role) {
10	const gen = await msg.guild!.roles.fetch(client.config.props[msg.guild!.id].gen_role);
11
12	channels.forEach(async channel => {
13	try {
14	await channel.send({
15	embeds: [
16	new MessageEmbed()
17	.setDescription(':closed_lock_with_key: This channel has been unlocked.')
18	]
19	});
20
21	client.db.get('SELECT * FROM locks WHERE channel_id = ?', [channel.id], async (err: any, data: any) => {
22	if (data \|\| force) {
23	let perm1;
24	let perm;
25	const data1 = data?.perms?.split(',');
26
27	if (data1) {
28	if (data1[0] === 'DENY') {
29	await (perm = false);
30	}
31	else if (data1[0] === 'NULL') {
32	await (perm = null);
33	}
34	else if (data1[0] === 'ALLOW') {
35	await (perm = true);
36	}
37
38	if (data1[1] === 'DENY') {
39	await (perm1 = false);
40	}
41	else if (data1[1] === 'NULL') {
42	await (perm1 = null);
43	}
44	else if (data1[1] === 'ALLOW') {
45	await (perm1 = true);
46	}
47	}
48
49	if (force) {
50	await (perm1 = true);
51	await (perm = true);
52	}
53
54	await console.log(channel.name);
55
56	try {
57	await channel.permissionOverwrites.edit(role, {
58	SEND_MESSAGES: perm,
59	});
60
61	await channel.permissionOverwrites.edit(gen!, {
62	SEND_MESSAGES: perm1,
63	});
64	}
65	catch (e) {
66	console.log(e);
67	}
68
69	await console.log(perm, perm1);
70
71	if (data) {
72	await client.db.get('DELETE FROM locks WHERE id = ?', [data?.id], async (err: any) => {});
73	}
74	}
75	});
76	}
77	catch(e) {
78	console.log(e);
79	}
80	});
81	}
82	}
83
84	export default class UnlockallCommand extends BaseCommand {
85	supportsInteractions: boolean = true;
86
87	constructor() {
88	super('unlockall', 'moderation', []);
89	}
90
91	async run(client: DiscordClient, msg: Message \| CommandInteraction, options: CommandOptions \| InteractionOptions) {
92	const raid = options.isInteraction ? options.options.getBoolean('raid') === true : (options.options.indexOf('--raid') !== -1);
93
94	let role: Role = <Role> msg.guild!.roles.everyone;
95	const force = options.isInteraction ? options.options.getBoolean('force') === true : (options.options.indexOf('--force') !== -1);
96
97	if (options.isInteraction) {
98	if (options.options.getChannel('role')) {
99	role = await <Role> options.options.getRole('role');
100	}
101	}
102	else {
103	if ((msg as Message).mentions.roles.first()) {
104	role = await <Role> (msg as Message).mentions.roles.first();
105	}
106	else if (options.normalArgs[0] && options.normalArgs[0] !== 'everyone') {
107	role = <Role> await (msg as Message).guild?.roles.fetch(options.normalArgs[0]);
108	}
109
110	if (!role) {
111	await msg.reply({
112	embeds: [
113	new MessageEmbed()
114	.setColor('#f14a60')
115	.setDescription(`Invalid role given.`)
116	],
117	ephemeral: true
118	});
119
120	return;
121	}
122	}
123
124	const channels: Collection <string, GuildBasedChannel> = await msg.guild!.channels.cache.filter(c => (
125	(!raid && (client.config.props[msg.guild!.id].lockall.indexOf(c.id) !== -1 \|\| client.config.props[msg.guild!.id].lockall.indexOf(c.parent?.id) !== -1)) \|\|
126	(raid && (
127	(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)) \|\|
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	))) && c.type === 'GUILD_TEXT'
130	);
131
132	await unlockAll(client, role, msg, options, channels as Collection <string, TextChannel>, force);
133
134	if (options.isInteraction) {
135	await msg.reply({
136	content: "The channels are unlocked.",
137	ephemeral: true
138	});
139	}
140	else {
141	await (msg as Message).react('🔓');
142	}
143	}
144	}