src/services/ChannelLockManager.ts

import { GuildChannel, PermissionString, Role, RoleResolvable, User } from "discord.js";
import MessageEmbed from "../client/MessageEmbed";
import ChannelLock from "../models/ChannelLock";
import Service from "../utils/structures/Service";

export interface ChannelLockOptions {
    reason?: string;
    sendConfirmation?: boolean;
    force?: boolean;
    role?: RoleResolvable;
}

export default class ChannelLockManager extends Service {
    async lock(channel: GuildChannel, user: User, { reason, sendConfirmation, role }: ChannelLockOptions = {}) {
        const lockRole = role ? (role instanceof Role ? role : (await channel.guild.roles.fetch(role))!) : channel.guild.roles.everyone;

        const channelLock = await ChannelLock.findOne({
            where: {
                channel_id: channel.id,
                guild_id: channel.guild.id,
                role_id: lockRole.id
            }
        });

        if (channelLock) {
            console.log('exists');
            return false;
        }

        console.log(lockRole?.name);

        let permissions = channel.permissionOverwrites.cache.get(lockRole.id);

        const permJson = {
            allow: permissions?.allow?.toArray() ?? null,
            deny: permissions?.deny?.toArray() ?? null,
        };

        console.log(permJson);

        await ChannelLock.create({
            user_id: user.id,
            guild_id: channel.guild.id,
            channel_id: channel.id,
            reason,
            previous_perms: permJson,
            role_id: lockRole.id,
            createdAt: new Date()
        });

        await channel.permissionOverwrites.edit(lockRole, {
            SEND_MESSAGES: false,
            SEND_MESSAGES_IN_THREADS: false,
            REQUEST_TO_SPEAK: false,
            SPEAK: false,
        }, { reason });

        console.log('success');

        if (sendConfirmation && channel.isText()) {
            await channel.send({
                embeds: [
                    new MessageEmbed({
                        color: 0x007bff,
                        description: `:lock: This channel has been locked.`,
                        fields: reason ? [
                            {
                                name: 'Reason',
                                value: reason + ''
                            }
                        ] : [],
                        footer: { text: 'Locked' }
                    })
                    .setTimestamp()
                ]
            });
        }

        return true;
    }

    async unlock(channel: GuildChannel, { reason, sendConfirmation, force, role }: ChannelLockOptions = {}) {
        const lockRole = role ? (role instanceof Role ? role : (await channel.guild.roles.fetch(role))!) : channel.guild.roles.everyone;

        const channelLock = await ChannelLock.findOne({
            channel_id: channel.id,
            guild_id: channel.guild.id,
            role_id: lockRole.id
        });

        if (!channelLock) {
            console.log('Channel not locked');            
            return false;
        }

        const permissions = channelLock?.previous_perms; //  as { allow: PermissionString[] | null, deny: PermissionString[] | null }

        if (!permissions && !force) {
            console.log('Permission error');
            return false;
        }

        const transform = (key: PermissionString) => {
            if (!permissions?.allow || !permissions?.deny) {
                return undefined;
            }

            if (!permissions) {
                return force ? true : undefined;
            }

            if (permissions.allow.includes(key) && !permissions.deny.includes(key)) {
                return true;
            }
            else if (!permissions.allow.includes(key) && permissions.deny.includes(key)) {
                return false;
            }
            else {
                return null;
            }
        };

        if (!permissions?.allow && !permissions?.deny) {
            await channel.permissionOverwrites.delete(lockRole);
        }
        else {
            await channel.permissionOverwrites.edit(lockRole, {
                SEND_MESSAGES: transform('SEND_MESSAGES'),
                SEND_MESSAGES_IN_THREADS: transform('SEND_MESSAGES_IN_THREADS'),
                REQUEST_TO_SPEAK: transform('REQUEST_TO_SPEAK'),
                SPEAK: transform('SPEAK'),
            }, { reason });
        }        

        await channelLock?.delete();

        if (sendConfirmation && channel.isText()) {
            await channel.send({
                embeds: [
                    new MessageEmbed({
                        color: 0x007bff,
                        description: `:closed_lock_with_key: This channel has been unlocked.`,
                        fields: reason ? [
                            {
                                name: 'Reason',
                                value: reason + ''
                            }
                        ] : [],
                        footer: { text: 'Unlocked' }
                    })
                    .setTimestamp()
                ]
            });
        }

        return true;
    }

    async lockAll(channels: GuildChannel[], user: User, options: ChannelLockOptions = {}) {
        let success = 0, failure = 0;

        for await (const channel of channels) {
            console.log('Locking', channel.name);
            
            if (await this.lock(channel, user, options)) {
                success++;
            }
            else {
                failure++;
            }
        }

        return [success, failure];
    }

    async unlockAll(channels: GuildChannel[], options: ChannelLockOptions = {}) {
        let success = 0, failure = 0;

        for await (const channel of channels) {
            console.log('Unlocking', channel.name);

            if (await this.unlock(channel, options)) {
                success++;
            }
            else {
                failure++;
            }
        }

        return [success, failure];
    }
}
1	import { GuildChannel, PermissionString, Role, RoleResolvable, User } from "discord.js";
2	import MessageEmbed from "../client/MessageEmbed";
3	import ChannelLock from "../models/ChannelLock";
4	import Service from "../utils/structures/Service";
5
6	export interface ChannelLockOptions {
7	reason?: string;
8	sendConfirmation?: boolean;
9	force?: boolean;
10	role?: RoleResolvable;
11	}
12
13	export default class ChannelLockManager extends Service {
14	async lock(channel: GuildChannel, user: User, { reason, sendConfirmation, role }: ChannelLockOptions = {}) {
15	const lockRole = role ? (role instanceof Role ? role : (await channel.guild.roles.fetch(role))!) : channel.guild.roles.everyone;
16
17	const channelLock = await ChannelLock.findOne({
18	where: {
19	channel_id: channel.id,
20	guild_id: channel.guild.id,
21	role_id: lockRole.id
22	}
23	});
24
25	if (channelLock) {
26	console.log('exists');
27	return false;
28	}
29
30	console.log(lockRole?.name);
31
32	let permissions = channel.permissionOverwrites.cache.get(lockRole.id);
33
34	const permJson = {
35	allow: permissions?.allow?.toArray() ?? null,
36	deny: permissions?.deny?.toArray() ?? null,
37	};
38
39	console.log(permJson);
40
41	await ChannelLock.create({
42	user_id: user.id,
43	guild_id: channel.guild.id,
44	channel_id: channel.id,
45	reason,
46	previous_perms: permJson,
47	role_id: lockRole.id,
48	createdAt: new Date()
49	});
50
51	await channel.permissionOverwrites.edit(lockRole, {
52	SEND_MESSAGES: false,
53	SEND_MESSAGES_IN_THREADS: false,
54	REQUEST_TO_SPEAK: false,
55	SPEAK: false,
56	}, { reason });
57
58	console.log('success');
59
60	if (sendConfirmation && channel.isText()) {
61	await channel.send({
62	embeds: [
63	new MessageEmbed({
64	color: 0x007bff,
65	description: `:lock: This channel has been locked.`,
66	fields: reason ? [
67	{
68	name: 'Reason',
69	value: reason + ''
70	}
71	] : [],
72	footer: { text: 'Locked' }
73	})
74	.setTimestamp()
75	]
76	});
77	}
78
79	return true;
80	}
81
82	async unlock(channel: GuildChannel, { reason, sendConfirmation, force, role }: ChannelLockOptions = {}) {
83	const lockRole = role ? (role instanceof Role ? role : (await channel.guild.roles.fetch(role))!) : channel.guild.roles.everyone;
84
85	const channelLock = await ChannelLock.findOne({
86	channel_id: channel.id,
87	guild_id: channel.guild.id,
88	role_id: lockRole.id
89	});
90
91	if (!channelLock) {
92	console.log('Channel not locked');
93	return false;
94	}
95
96	const permissions = channelLock?.previous_perms; // as { allow: PermissionString[] \| null, deny: PermissionString[] \| null }
97
98	if (!permissions && !force) {
99	console.log('Permission error');
100	return false;
101	}
102
103	const transform = (key: PermissionString) => {
104	if (!permissions?.allow \|\| !permissions?.deny) {
105	return undefined;
106	}
107
108	if (!permissions) {
109	return force ? true : undefined;
110	}
111
112	if (permissions.allow.includes(key) && !permissions.deny.includes(key)) {
113	return true;
114	}
115	else if (!permissions.allow.includes(key) && permissions.deny.includes(key)) {
116	return false;
117	}
118	else {
119	return null;
120	}
121	};
122
123	if (!permissions?.allow && !permissions?.deny) {
124	await channel.permissionOverwrites.delete(lockRole);
125	}
126	else {
127	await channel.permissionOverwrites.edit(lockRole, {
128	SEND_MESSAGES: transform('SEND_MESSAGES'),
129	SEND_MESSAGES_IN_THREADS: transform('SEND_MESSAGES_IN_THREADS'),
130	REQUEST_TO_SPEAK: transform('REQUEST_TO_SPEAK'),
131	SPEAK: transform('SPEAK'),
132	}, { reason });
133	}
134
135	await channelLock?.delete();
136
137	if (sendConfirmation && channel.isText()) {
138	await channel.send({
139	embeds: [
140	new MessageEmbed({
141	color: 0x007bff,
142	description: `:closed_lock_with_key: This channel has been unlocked.`,
143	fields: reason ? [
144	{
145	name: 'Reason',
146	value: reason + ''
147	}
148	] : [],
149	footer: { text: 'Unlocked' }
150	})
151	.setTimestamp()
152	]
153	});
154	}
155
156	return true;
157	}
158
159	async lockAll(channels: GuildChannel[], user: User, options: ChannelLockOptions = {}) {
160	let success = 0, failure = 0;
161
162	for await (const channel of channels) {
163	console.log('Locking', channel.name);
164
165	if (await this.lock(channel, user, options)) {
166	success++;
167	}
168	else {
169	failure++;
170	}
171	}
172
173	return [success, failure];
174	}
175
176	async unlockAll(channels: GuildChannel[], options: ChannelLockOptions = {}) {
177	let success = 0, failure = 0;
178
179	for await (const channel of channels) {
180	console.log('Unlocking', channel.name);
181
182	if (await this.unlock(channel, options)) {
183	success++;
184	}
185	else {
186	failure++;
187	}
188	}
189
190	return [success, failure];
191	}
192	}