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