src/services/ChannelLockManager.ts

/**
 * This file is part of SudoBot.
 *
 * Copyright (C) 2021-2023 OSN Developers.
 *
 * 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 {
    ChannelType,
    Guild,
    GuildBasedChannel,
    PermissionFlags,
    PermissionFlagsBits,
    PermissionOverwriteOptions,
    Snowflake,
    TextChannel,
    User
} from "discord.js";
import Service from "../core/Service";
import { log, logError } from "../utils/Logger";
import { getChannelPermissionOverride } from "../utils/utils";

export const name = "channelLockManager";

type ChannelLockOptions = {
    channels?: Snowflake[];
    channelMode?: "exclude" | "include";
    ignorePrivateChannels?: boolean;
    moderator: User;
    reason?: string;
};

export default class ChannelLockManager extends Service {
    async shouldLock(channels: Snowflake[], channel: GuildBasedChannel, channelMode: "exclude" | "include") {
        return (
            channels.length === 0 ||
            (channelMode === "include" && channels.includes(channel.id)) ||
            (channelMode === "exclude" && !channels.includes(channel.id))
        );
    }

    async lockGuild(
        guild: Guild,
        { reason, moderator, channels = [], channelMode = "include", ignorePrivateChannels = true }: ChannelLockOptions
    ) {
        let countSuccess = 0,
            countFailed = 0,
            countSkipped = 0,
            countInvalidChannel = 0;

        const originalPermissions = [];

        for (const [, channel] of guild.channels.cache) {
            log(channel.name);

            if (
                !this.shouldLock(channels, channel, channelMode) ||
                ![
                    ChannelType.GuildAnnouncement,
                    ChannelType.GuildCategory,
                    ChannelType.GuildText,
                    ChannelType.GuildVoice,
                    ChannelType.GuildStageVoice,
                    ChannelType.GuildForum
                ].includes(channel.type)
            ) {
                countInvalidChannel++;
                continue;
            }

            try {
                const permissionOverwrites = (channel as TextChannel).permissionOverwrites?.cache.get(guild.id);

                if (ignorePrivateChannels) {
                    if (permissionOverwrites?.deny.has(PermissionFlagsBits.ViewChannel, true)) {
                        log("Private channel, skipping lock");
                        countSkipped++;
                        continue;
                    }
                }

                if (permissionOverwrites?.deny.has(PermissionFlagsBits.SendMessages, true)) {
                    log("Already locked channel, skipping lock");
                    countSkipped++;
                    continue;
                }

                const permissionJson = {
                    Connect: permissionOverwrites
                        ? getChannelPermissionOverride(PermissionFlagsBits.Connect, permissionOverwrites)
                        : null,
                    SendMessages: permissionOverwrites
                        ? getChannelPermissionOverride(PermissionFlagsBits.SendMessages, permissionOverwrites)
                        : null,
                    SendMessagesInThreads: permissionOverwrites
                        ? getChannelPermissionOverride(PermissionFlagsBits.SendMessagesInThreads, permissionOverwrites)
                        : null,
                    AddReactions: permissionOverwrites
                        ? getChannelPermissionOverride(PermissionFlagsBits.AddReactions, permissionOverwrites)
                        : null
                };

                originalPermissions.push({
                    channel_id: channel.id,
                    guild_id: guild.id,
                    permissions: permissionJson
                });

                await (channel as TextChannel).permissionOverwrites?.edit(guild.id, {
                    Connect: false,
                    SendMessages: false,
                    SendMessagesInThreads: false,
                    AddReactions: false
                });

                countSuccess++;
            } catch (e) {
                logError(e);
                countFailed++;
            }
        }

        await this.client.prisma.channelLock.createMany({
            data: originalPermissions
        });

        await this.client.loggerService.logServerLockOrUnlock({
            guild,
            action: "Locked",
            moderator,
            countSuccess,
            countFailed,
            countInvalidChannel,
            countSkipped,
            reason
        });

        return {
            countSuccess,
            countFailed,
            countInvalidChannel,
            countSkipped
        };
    }

    async unlockGuild(
        guild: Guild,
        {
            channels = [],
            channelMode = "include",
            ignorePrivateChannels = true,
            force,
            moderator,
            reason
        }: ChannelLockOptions & { force?: boolean }
    ) {
        let countSuccess = 0,
            countFailed = 0,
            countSkipped = 0,
            countInvalidChannel = 0;

        const originalPermissions = force
            ? guild.channels.cache.map(c => ({ channel_id: c.id, permissions: {}, id: 0 }))
            : await this.client.prisma.channelLock.findMany({
                  where: {
                      guild_id: guild.id
                  }
              });

        for (const originalPermission of originalPermissions) {
            const channel = guild.channels.cache.get(originalPermission.channel_id);

            if (!channel) continue;

            if (
                !this.shouldLock(channels, channel, channelMode) ||
                ![
                    ChannelType.GuildAnnouncement,
                    ChannelType.GuildCategory,
                    ChannelType.GuildText,
                    ChannelType.GuildVoice,
                    ChannelType.GuildStageVoice,
                    ChannelType.GuildForum
                ].includes(channel.type)
            ) {
                countInvalidChannel++;
                continue;
            }

            try {
                const options = {
                    Connect: force ? true : (originalPermission.permissions! as PermissionFlags).Connect,
                    SendMessages: force ? true : (originalPermission.permissions! as PermissionFlags).SendMessages,
                    SendMessagesInThreads: force
                        ? true
                        : (originalPermission.permissions! as PermissionFlags).SendMessagesInThreads,
                    AddReactions: force ? true : (originalPermission.permissions! as PermissionFlags).AddReactions
                };

                const permissionOverwrites = (channel as TextChannel).permissionOverwrites?.cache.get(guild.id);

                if (ignorePrivateChannels && !force) {
                    if (permissionOverwrites?.deny.has(PermissionFlagsBits.ViewChannel, true)) {
                        log("Private channel, skipping lock");
                        countSkipped++;
                        continue;
                    }
                }

                if (permissionOverwrites)
                    await (channel as TextChannel).permissionOverwrites?.edit(guild.id, options as PermissionOverwriteOptions);
                else await (channel as TextChannel).permissionOverwrites?.create(guild.id, options as PermissionOverwriteOptions);

                countSuccess++;
            } catch (e) {
                logError(e);
                countFailed++;
            }
        }

        log(originalPermissions);

        if (!force)
            await this.client.prisma.channelLock.deleteMany({
                where: {
                    id: {
                        in: originalPermissions.map(permission => permission.id)
                    }
                }
            });

        await this.client.loggerService.logServerLockOrUnlock({
            guild,
            action: "Unlocked",
            moderator,
            countSuccess,
            countFailed,
            countInvalidChannel,
            countSkipped,
            reason
        });

        return {
            countSuccess,
            countFailed,
            countInvalidChannel,
            countSkipped
        };
    }

    async lock(channel: TextChannel, moderator: User, reason?: string) {
        try {
            const options = {
                Connect: false,
                SendMessages: false,
                SendMessagesInThreads: false,
                AddReactions: false
            };

            const permissionOverwrites = channel.permissionOverwrites?.cache.get(channel.guild.id);

            const permissionJson = {
                Connect: permissionOverwrites
                    ? getChannelPermissionOverride(PermissionFlagsBits.Connect, permissionOverwrites)
                    : null,
                SendMessages: permissionOverwrites
                    ? getChannelPermissionOverride(PermissionFlagsBits.SendMessages, permissionOverwrites)
                    : null,
                SendMessagesInThreads: permissionOverwrites
                    ? getChannelPermissionOverride(PermissionFlagsBits.SendMessagesInThreads, permissionOverwrites)
                    : null,
                AddReactions: permissionOverwrites
                    ? getChannelPermissionOverride(PermissionFlagsBits.AddReactions, permissionOverwrites)
                    : null
            };

            if (permissionOverwrites) await channel.permissionOverwrites?.edit(channel.guild.id, options);
            else await channel.permissionOverwrites?.create(channel.guild.id, options);

            this.client.loggerService
                .logChannelLockOrUnlock({
                    guild: channel.guild,
                    action: "Locked",
                    channel,
                    moderator,
                    reason
                })
                .catch(logError);

            return await this.client.prisma.channelLock.create({
                data: {
                    channel_id: channel.id,
                    guild_id: channel.guild.id,
                    permissions: permissionJson
                }
            });
        } catch (e) {
            logError(e);
            return null;
        }
    }

    async unlock(channel: TextChannel, moderator: User, reason?: string, force?: boolean) {
        try {
            const channelLock = await this.client.prisma.channelLock.findFirst({
                where: {
                    channel_id: channel.id,
                    guild_id: channel.guild.id
                }
            });

            if (!channelLock) return null;

            const options = {
                Connect: force ? true : (channelLock.permissions as unknown as PermissionFlags).Connect,
                SendMessages: force ? true : (channelLock.permissions as unknown as PermissionFlags).SendMessages,
                SendMessagesInThreads: force
                    ? true
                    : (channelLock.permissions as unknown as PermissionFlags).SendMessagesInThreads,
                AddReactions: force ? true : (channelLock.permissions as unknown as PermissionFlags).AddReactions
            };

            const permissionOverwrites = channel.permissionOverwrites?.cache.get(channel.guild.id);

            if (permissionOverwrites)
                await channel.permissionOverwrites?.edit(channel.guild.id, options as PermissionOverwriteOptions);
            else await channel.permissionOverwrites?.create(channel.guild.id, options as PermissionOverwriteOptions);

            this.client.loggerService
                .logChannelLockOrUnlock({
                    guild: channel.guild,
                    action: "Unlocked",
                    channel,
                    moderator,
                    reason
                })
                .catch(logError);

            return true;
        } catch (e) {
            logError(e);
            return false;
        }
    }
}
1	/**
2	* This file is part of SudoBot.
3	*
4	* Copyright (C) 2021-2023 OSN Developers.
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 {
21	ChannelType,
22	Guild,
23	GuildBasedChannel,
24	PermissionFlags,
25	PermissionFlagsBits,
26	PermissionOverwriteOptions,
27	Snowflake,
28	TextChannel,
29	User
30	} from "discord.js";
31	import Service from "../core/Service";
32	import { log, logError } from "../utils/Logger";
33	import { getChannelPermissionOverride } from "../utils/utils";
34
35	export const name = "channelLockManager";
36
37	type ChannelLockOptions = {
38	channels?: Snowflake[];
39	channelMode?: "exclude" \| "include";
40	ignorePrivateChannels?: boolean;
41	moderator: User;
42	reason?: string;
43	};
44
45	export default class ChannelLockManager extends Service {
46	async shouldLock(channels: Snowflake[], channel: GuildBasedChannel, channelMode: "exclude" \| "include") {
47	return (
48	channels.length === 0 \|\|
49	(channelMode === "include" && channels.includes(channel.id)) \|\|
50	(channelMode === "exclude" && !channels.includes(channel.id))
51	);
52	}
53
54	async lockGuild(
55	guild: Guild,
56	{ reason, moderator, channels = [], channelMode = "include", ignorePrivateChannels = true }: ChannelLockOptions
57	) {
58	let countSuccess = 0,
59	countFailed = 0,
60	countSkipped = 0,
61	countInvalidChannel = 0;
62
63	const originalPermissions = [];
64
65	for (const [, channel] of guild.channels.cache) {
66	log(channel.name);
67
68	if (
69	!this.shouldLock(channels, channel, channelMode) \|\|
70	![
71	ChannelType.GuildAnnouncement,
72	ChannelType.GuildCategory,
73	ChannelType.GuildText,
74	ChannelType.GuildVoice,
75	ChannelType.GuildStageVoice,
76	ChannelType.GuildForum
77	].includes(channel.type)
78	) {
79	countInvalidChannel++;
80	continue;
81	}
82
83	try {
84	const permissionOverwrites = (channel as TextChannel).permissionOverwrites?.cache.get(guild.id);
85
86	if (ignorePrivateChannels) {
87	if (permissionOverwrites?.deny.has(PermissionFlagsBits.ViewChannel, true)) {
88	log("Private channel, skipping lock");
89	countSkipped++;
90	continue;
91	}
92	}
93
94	if (permissionOverwrites?.deny.has(PermissionFlagsBits.SendMessages, true)) {
95	log("Already locked channel, skipping lock");
96	countSkipped++;
97	continue;
98	}
99
100	const permissionJson = {
101	Connect: permissionOverwrites
102	? getChannelPermissionOverride(PermissionFlagsBits.Connect, permissionOverwrites)
103	: null,
104	SendMessages: permissionOverwrites
105	? getChannelPermissionOverride(PermissionFlagsBits.SendMessages, permissionOverwrites)
106	: null,
107	SendMessagesInThreads: permissionOverwrites
108	? getChannelPermissionOverride(PermissionFlagsBits.SendMessagesInThreads, permissionOverwrites)
109	: null,
110	AddReactions: permissionOverwrites
111	? getChannelPermissionOverride(PermissionFlagsBits.AddReactions, permissionOverwrites)
112	: null
113	};
114
115	originalPermissions.push({
116	channel_id: channel.id,
117	guild_id: guild.id,
118	permissions: permissionJson
119	});
120
121	await (channel as TextChannel).permissionOverwrites?.edit(guild.id, {
122	Connect: false,
123	SendMessages: false,
124	SendMessagesInThreads: false,
125	AddReactions: false
126	});
127
128	countSuccess++;
129	} catch (e) {
130	logError(e);
131	countFailed++;
132	}
133	}
134
135	await this.client.prisma.channelLock.createMany({
136	data: originalPermissions
137	});
138
139	await this.client.loggerService.logServerLockOrUnlock({
140	guild,
141	action: "Locked",
142	moderator,
143	countSuccess,
144	countFailed,
145	countInvalidChannel,
146	countSkipped,
147	reason
148	});
149
150	return {
151	countSuccess,
152	countFailed,
153	countInvalidChannel,
154	countSkipped
155	};
156	}
157
158	async unlockGuild(
159	guild: Guild,
160	{
161	channels = [],
162	channelMode = "include",
163	ignorePrivateChannels = true,
164	force,
165	moderator,
166	reason
167	}: ChannelLockOptions & { force?: boolean }
168	) {
169	let countSuccess = 0,
170	countFailed = 0,
171	countSkipped = 0,
172	countInvalidChannel = 0;
173
174	const originalPermissions = force
175	? guild.channels.cache.map(c => ({ channel_id: c.id, permissions: {}, id: 0 }))
176	: await this.client.prisma.channelLock.findMany({
177	where: {
178	guild_id: guild.id
179	}
180	});
181
182	for (const originalPermission of originalPermissions) {
183	const channel = guild.channels.cache.get(originalPermission.channel_id);
184
185	if (!channel) continue;
186
187	if (
188	!this.shouldLock(channels, channel, channelMode) \|\|
189	![
190	ChannelType.GuildAnnouncement,
191	ChannelType.GuildCategory,
192	ChannelType.GuildText,
193	ChannelType.GuildVoice,
194	ChannelType.GuildStageVoice,
195	ChannelType.GuildForum
196	].includes(channel.type)
197	) {
198	countInvalidChannel++;
199	continue;
200	}
201
202	try {
203	const options = {
204	Connect: force ? true : (originalPermission.permissions! as PermissionFlags).Connect,
205	SendMessages: force ? true : (originalPermission.permissions! as PermissionFlags).SendMessages,
206	SendMessagesInThreads: force
207	? true
208	: (originalPermission.permissions! as PermissionFlags).SendMessagesInThreads,
209	AddReactions: force ? true : (originalPermission.permissions! as PermissionFlags).AddReactions
210	};
211
212	const permissionOverwrites = (channel as TextChannel).permissionOverwrites?.cache.get(guild.id);
213
214	if (ignorePrivateChannels && !force) {
215	if (permissionOverwrites?.deny.has(PermissionFlagsBits.ViewChannel, true)) {
216	log("Private channel, skipping lock");
217	countSkipped++;
218	continue;
219	}
220	}
221
222	if (permissionOverwrites)
223	await (channel as TextChannel).permissionOverwrites?.edit(guild.id, options as PermissionOverwriteOptions);
224	else await (channel as TextChannel).permissionOverwrites?.create(guild.id, options as PermissionOverwriteOptions);
225
226	countSuccess++;
227	} catch (e) {
228	logError(e);
229	countFailed++;
230	}
231	}
232
233	log(originalPermissions);
234
235	if (!force)
236	await this.client.prisma.channelLock.deleteMany({
237	where: {
238	id: {
239	in: originalPermissions.map(permission => permission.id)
240	}
241	}
242	});
243
244	await this.client.loggerService.logServerLockOrUnlock({
245	guild,
246	action: "Unlocked",
247	moderator,
248	countSuccess,
249	countFailed,
250	countInvalidChannel,
251	countSkipped,
252	reason
253	});
254
255	return {
256	countSuccess,
257	countFailed,
258	countInvalidChannel,
259	countSkipped
260	};
261	}
262
263	async lock(channel: TextChannel, moderator: User, reason?: string) {
264	try {
265	const options = {
266	Connect: false,
267	SendMessages: false,
268	SendMessagesInThreads: false,
269	AddReactions: false
270	};
271
272	const permissionOverwrites = channel.permissionOverwrites?.cache.get(channel.guild.id);
273
274	const permissionJson = {
275	Connect: permissionOverwrites
276	? getChannelPermissionOverride(PermissionFlagsBits.Connect, permissionOverwrites)
277	: null,
278	SendMessages: permissionOverwrites
279	? getChannelPermissionOverride(PermissionFlagsBits.SendMessages, permissionOverwrites)
280	: null,
281	SendMessagesInThreads: permissionOverwrites
282	? getChannelPermissionOverride(PermissionFlagsBits.SendMessagesInThreads, permissionOverwrites)
283	: null,
284	AddReactions: permissionOverwrites
285	? getChannelPermissionOverride(PermissionFlagsBits.AddReactions, permissionOverwrites)
286	: null
287	};
288
289	if (permissionOverwrites) await channel.permissionOverwrites?.edit(channel.guild.id, options);
290	else await channel.permissionOverwrites?.create(channel.guild.id, options);
291
292	this.client.loggerService
293	.logChannelLockOrUnlock({
294	guild: channel.guild,
295	action: "Locked",
296	channel,
297	moderator,
298	reason
299	})
300	.catch(logError);
301
302	return await this.client.prisma.channelLock.create({
303	data: {
304	channel_id: channel.id,
305	guild_id: channel.guild.id,
306	permissions: permissionJson
307	}
308	});
309	} catch (e) {
310	logError(e);
311	return null;
312	}
313	}
314
315	async unlock(channel: TextChannel, moderator: User, reason?: string, force?: boolean) {
316	try {
317	const channelLock = await this.client.prisma.channelLock.findFirst({
318	where: {
319	channel_id: channel.id,
320	guild_id: channel.guild.id
321	}
322	});
323
324	if (!channelLock) return null;
325
326	const options = {
327	Connect: force ? true : (channelLock.permissions as unknown as PermissionFlags).Connect,
328	SendMessages: force ? true : (channelLock.permissions as unknown as PermissionFlags).SendMessages,
329	SendMessagesInThreads: force
330	? true
331	: (channelLock.permissions as unknown as PermissionFlags).SendMessagesInThreads,
332	AddReactions: force ? true : (channelLock.permissions as unknown as PermissionFlags).AddReactions
333	};
334
335	const permissionOverwrites = channel.permissionOverwrites?.cache.get(channel.guild.id);
336
337	if (permissionOverwrites)
338	await channel.permissionOverwrites?.edit(channel.guild.id, options as PermissionOverwriteOptions);
339	else await channel.permissionOverwrites?.create(channel.guild.id, options as PermissionOverwriteOptions);
340
341	this.client.loggerService
342	.logChannelLockOrUnlock({
343	guild: channel.guild,
344	action: "Unlocked",
345	channel,
346	moderator,
347	reason
348	})
349	.catch(logError);
350
351	return true;
352	} catch (e) {
353	logError(e);
354	return false;
355	}
356	}
357	}