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, PermissionFlagsBits, 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 options = {
                    Connect: false,
                    SendMessages: false,
                    SendMessagesInThreads: false,
                    AddReactions: false
                };

                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;
                    }
                }

                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, options);

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

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

        log(originalPermissions);

        await this.client.logger.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 any).Connect,
                    SendMessages: force ? true : (originalPermission.permissions! as any).SendMessages,
                    SendMessagesInThreads: force ? true : (originalPermission.permissions! as any).SendMessagesInThreads,
                    AddReactions: force ? true : (originalPermission.permissions! as any).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);
                else await (channel as TextChannel).permissionOverwrites?.create(guild.id, options);

                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.logger.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.logger
                .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 any).Connect,
                SendMessages: force ? true : (channelLock.permissions as any).SendMessages,
                SendMessagesInThreads: force ? true : (channelLock.permissions as any).SendMessagesInThreads,
                AddReactions: force ? true : (channelLock.permissions as any).AddReactions
            };

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

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

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