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