src/services/SnippetManager.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 { PermissionRole, Snippet } from "@prisma/client";
import { AxiosError } from "axios";
import { Attachment, Collection, GuildMember, Message, MessageCreateOptions, PermissionFlagsBits, Snowflake } from "discord.js";
import { existsSync } from "fs";
import fs from "fs/promises";
import { basename } from "path";
import Command, { CommandMessage } from "../core/Command";
import Service from "../core/Service";
import EmbedSchemaParser from "../utils/EmbedSchemaParser";
import { downloadFile } from "../utils/download";
import { LogLevel, log, logError, logInfo, logWithLevel } from "../utils/logger";
import { getEmoji, sudoPrefix } from "../utils/utils";

export const name = "snippetManager";

type SnippetWithPermissions = Snippet & { permission_roles: PermissionRole[] };

export default class SnippetManager extends Service {
    public readonly snippets = new Collection<`${Snowflake}_${string}`, SnippetWithPermissions>();

    async boot() {
        const snippets = await this.client.prisma.snippet.findMany({
            include: {
                permission_roles: true
            }
        });

        for (const snippet of snippets) {
            this.snippets.set(`${snippet.guild_id}_${snippet.name}`, snippet);
        }
    }

    async removeFiles(fileNames: string[], guildId: string) {
        for (const name of fileNames) {
            const filePath = `${sudoPrefix(`storage/snippet_attachments/${guildId}`, true)}/${name}`;
            logInfo("Attempting to remove file: " + filePath);
            await fs.rm(filePath).catch(logError);
        }
    }

    async createSnippet({
        name,
        content,
        attachments,
        guildId,
        userId,
        roles,
        channels,
        users,
        randomize
    }: CreateSnippetOptions) {
        if (!content && (!attachments || attachments.length === 0)) {
            return { error: "Content or attachment is required to create a snippet" };
        }

        if (this.snippets.has(`${guildId}_${name}`)) {
            return { error: "A snippet with the same name already exists" };
        }

        if (this.client.commands.has(name)) {
            return { error: "Sorry, there's a built-in internal command already with that name" };
        }

        const filesDownloaded: string[] = [];

        log(attachments);
        log(this.client.configManager.systemConfig.snippets?.save_attachments);

        if (attachments && this.client.configManager.systemConfig.snippets?.save_attachments) {
            for (const attachment of attachments) {
                const { error, name } = await this.downloadAttachment({
                    guildId,
                    proxyURL: attachment.proxyURL
                });

                if (error) {
                    await this.removeFiles(filesDownloaded, guildId);

                    if (error instanceof Error && error.message.startsWith("HTTP error")) {
                        return { error: error.message };
                    }

                    return { error: "Could not save attachments: An internal error has occurred" };
                }

                filesDownloaded.push(name);
            }
        }

        const snippet = await this.client.prisma.snippet.create({
            data: {
                content: content ? [content] : undefined,
                guild_id: guildId,
                user_id: userId,
                attachments: filesDownloaded,
                channels,
                roles,
                users,
                name,
                randomize
            },
            include: {
                permission_roles: true
            }
        });

        this.snippets.set(`${guildId}_${snippet.name}`, snippet);

        return { snippet };
    }

    async downloadAttachment({ guildId, proxyURL }: { proxyURL: string; guildId: string }) {
        try {
            const splittedName = basename(proxyURL).split(".");
            const extension = splittedName.pop()!;
            splittedName.push(`_${Date.now()}_${Math.random() * 10000000}`);
            splittedName.push(extension);
            const fileName = splittedName.join(".").replace(/\//g, "_");
            const path = sudoPrefix(`storage/snippet_attachments/${guildId}`, true);

            await downloadFile({
                url: proxyURL,
                path,
                name: fileName
            });

            return { path, name: fileName };
        } catch (e) {
            logError(e);
            return { error: e as Error | AxiosError };
        }
    }

    async deleteSnippet({ name, guildId }: CommonSnippetActionOptions) {
        if (!this.snippets.has(`${guildId}_${name}`)) {
            return { error: "No snippet found with that name" };
        }

        await this.client.prisma.snippet.deleteMany({
            where: {
                guild_id: guildId,
                name
            }
        });

        await this.removeFiles(this.snippets.get(`${guildId}_${name}`)!.attachments, guildId);
        this.snippets.delete(`${guildId}_${name}`);

        return { success: true };
    }

    async renameSnippet({ name, guildId, newName }: CommonSnippetActionOptions & { newName: string }) {
        if (!this.snippets.has(`${guildId}_${name}`)) {
            return { error: "No snippet found with that name" };
        }

        if (this.client.commands.has(newName)) {
            return { error: "Sorry, there's a built-in internal command already with that name" };
        }

        await this.client.prisma.snippet.updateMany({
            where: {
                name,
                guild_id: guildId
            },
            data: {
                name: newName
            }
        });

        const snippet = this.snippets.get(`${guildId}_${name}`)!;
        snippet.name = newName;
        this.snippets.set(`${guildId}_${newName}`, snippet);
        this.snippets.delete(`${guildId}_${name}`);

        return { success: true, snippet };
    }

    async checkPermissions(snippet: SnippetWithPermissions, member: GuildMember, guildId: string, channelId?: string) {
        if (member.permissions.has(PermissionFlagsBits.Administrator, true)) return true;

        if (
            (snippet.channels.length > 0 && channelId && !snippet.channels.includes(channelId)) ||
            (snippet.users.length > 0 && !snippet.users.includes(member.user.id)) ||
            (snippet.roles.length > 0 && !member.roles.cache.hasAll(...snippet.roles))
        ) {
            log("Channel/user doesn't have permission to run this snippet.");
            return false;
        }

        const { permissions: memberPermissions } = await this.client.permissionManager.getMemberPermissions(member, true);

        if (this.client.permissionManager.usesLevelBasedMode(guildId) && typeof snippet.level === "number") {
            const level = (await this.client.permissionManager.getManager(member.guild.id)).getPermissionLevel(member);

            if (level < snippet.level) {
                log("User doesn't have enough permission to run this snippet. (level based permission system)");
                return false;
            }
        }

        const { permissions: snippetPermissions } = await this.client.permissionManager.getMemberPermissions(member);

        for (const permission of snippetPermissions) {
            if (!memberPermissions.has(permission)) {
                log("User doesn't have enough permission to run this snippet. (hybrid permission system)");
                return false;
            }
        }

        return true;
    }

    async createMessageOptionsFromSnippet({
        name,
        guildId,
        channelId,
        member
    }: CommonSnippetActionOptions & {
        channelId: string;
        member: GuildMember;
    }) {
        if (!this.snippets?.has(`${guildId}_${name}`)) {
            return { error: "No snippet found with that name", found: false };
        }

        const snippet = this.snippets.get(`${guildId}_${name}`)!;

        if (!snippet.content && snippet.attachments.length === 0)
            throw new Error("Corrupted database: snippet attachment and content both are unusable");

        if (!(await this.checkPermissions(snippet, member, guildId, channelId))) {
            return {
                options: undefined
            };
        }

        const files = [];

        if (snippet.randomize && snippet.attachments.length > 0) {
            const randomAttachment = snippet.attachments[Math.floor(Math.random() * snippet.attachments.length)];

            const file = sudoPrefix(`storage/snippet_attachments/${guildId}/${randomAttachment}`, false);

            if (!existsSync(file)) {
                logWithLevel(LogLevel.CRITICAL, `Could find attachment: ${file}`);
            } else {
                files.push(file);
            }
        } else {
            for (const attachment of snippet.attachments) {
                const file = sudoPrefix(`storage/snippet_attachments/${guildId}/${attachment}`, false);

                if (!existsSync(file)) {
                    logWithLevel(LogLevel.CRITICAL, `Could find attachment: ${file}`);
                    continue;
                }

                files.push(file);
            }
        }

        const content = snippet.content[snippet.randomize ? Math.floor(Math.random() * snippet.content.length) : 0];

        return {
            options: EmbedSchemaParser.getMessageOptions(
                {
                    content: content ?? undefined,
                    files
                } as MessageCreateOptions,
                true
            ),
            found: true
        };
    }

    async onMessageCreate(message: Message, commandName: string) {
        const { options, found } = await this.createMessageOptionsFromSnippet({
            name: commandName,
            guildId: message.guildId!,
            channelId: message.channelId!,
            member: message.member! as GuildMember
        });

        if (!found || !options) {
            log("Snippet not found or permission error");
            return false;
        }

        await message.channel.send(options).catch(logError);
        return true;
    }

    async toggleRandomization({ guildId, name }: CommonSnippetActionOptions) {
        if (!this.snippets.has(`${guildId}_${name}`)) return { error: "Snippet does not exist" };

        const snippet = this.snippets.get(`${guildId}_${name}`);

        if (!snippet) {
            return { error: "Snippet does not exist" };
        }

        await this.client.prisma.snippet.update({
            where: {
                id: snippet.id
            },
            data: {
                randomize: !snippet.randomize
            }
        });

        const localSnippet = this.snippets.get(`${guildId}_${name}`)!;
        localSnippet.randomize = !snippet.randomize;
        this.snippets.set(`${guildId}_${name}`, localSnippet);

        return { randomization: !snippet.randomize };
    }

    async pushFile({ files, guildId, name }: CommonSnippetActionOptions & { files: string[] }) {
        if (!this.snippets.has(`${guildId}_${name}`)) return { error: "Snippet does not exist" };

        const filesDownloaded = [];

        for (const file of files) {
            const { error, name } = await this.downloadAttachment({
                guildId,
                proxyURL: file
            });

            if (error) {
                await this.removeFiles(filesDownloaded, guildId);

                if (error instanceof Error && error.message.startsWith("HTTP error")) {
                    return { error: error.message };
                }

                return { error: "Could not save attachments: An internal error has occurred" };
            }

            filesDownloaded.push(name);
        }

        const { count } = await this.client.prisma.snippet.updateMany({
            where: {
                name,
                guild_id: guildId
            },
            data: {
                attachments: {
                    push: filesDownloaded
                }
            }
        });

        if (count === 0) return { error: "Snippet does not exist" };

        const snippet = this.snippets.get(`${guildId}_${name}`)!;
        snippet.attachments.push(...filesDownloaded);
        this.snippets.set(`${guildId}_${name}`, snippet);

        return { count };
    }

    async checkPermissionInSnippetCommands(name: string, message: CommandMessage, command: Command) {
        const snippet = this.snippets.get(`${message.guildId!}_${name}`);

        if (!snippet) {
            await command.deferredReply(message, `${getEmoji(this.client, "error")} No snippet found with that name!')}`);
            return false;
        }

        if (!(await this.client.snippetManager.checkPermissions(snippet, message.member! as GuildMember, message.guildId!))) {
            await command.deferredReply(
                message,
                `${getEmoji(this.client, "error")} You don't have permission to modify this snippet!`
            );
            return false;
        }

        return true;
    }

    async updateSnippet({
        channels,
        content,
        guildId,
        name,
        randomize,
        roles,
        users,
        permissionRoleName,
        level
    }: Partial<Omit<CreateSnippetOptions, "attachments" | "userId">> &
        CommonSnippetActionOptions & { permissionRoleName?: string; level?: number }) {
        if (!this.snippets.has(`${guildId}_${name}`)) {
            return { error: "No snippet found with that name" };
        }

        const snippet = this.snippets.get(`${guildId}_${name}`)!;

        let permissionRole: PermissionRole | null = null;

        if (permissionRoleName) {
            permissionRole = await this.client.prisma.permissionRole.findFirst({
                where: {
                    guild_id: guildId,
                    name: permissionRoleName
                }
            });

            if (!permissionRole) {
                return { error: "No named permission role found with the given name!" };
            }
        }

        const updatedSnippet = await this.client.prisma.snippet.update({
            where: {
                id: snippet.id
            },
            data: {
                content: content ? [content] : undefined,
                channels,
                roles,
                randomize,
                users,
                permission_roles: permissionRole
                    ? {
                          connect: {
                              id: permissionRole.id
                          }
                      }
                    : undefined,
                level
            },
            include: {
                permission_roles: true
            }
        });

        this.snippets.set(`${guildId}_${name}`, updatedSnippet);

        return {
            updatedSnippet
        };
    }
}

interface CommonSnippetActionOptions {
    name: string;
    guildId: string;
}

interface CreateSnippetOptions extends CommonSnippetActionOptions {
    content?: string;
    attachments?: Attachment[];
    userId: string;
    roles: string[];
    users: string[];
    channels: string[];
    randomize?: boolean;
}
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 { PermissionRole, Snippet } from "@prisma/client";
21			import { AxiosError } from "axios";
22			import { Attachment, Collection, GuildMember, Message, MessageCreateOptions, PermissionFlagsBits, Snowflake } from "discord.js";
23			import { existsSync } from "fs";
24			import fs from "fs/promises";
25			import { basename } from "path";
26			import Command, { CommandMessage } from "../core/Command";
27			import Service from "../core/Service";
28			import EmbedSchemaParser from "../utils/EmbedSchemaParser";
29			import { downloadFile } from "../utils/download";
30			import { LogLevel, log, logError, logInfo, logWithLevel } from "../utils/logger";
31			import { getEmoji, sudoPrefix } from "../utils/utils";
32
33			export const name = "snippetManager";
34
35			type SnippetWithPermissions = Snippet & { permission_roles: PermissionRole[] };
36
37			export default class SnippetManager extends Service {
38			public readonly snippets = new Collection<`${Snowflake}_${string}`, SnippetWithPermissions>();
39
40			async boot() {
41			const snippets = await this.client.prisma.snippet.findMany({
42			include: {
43			permission_roles: true
44			}
45			});
46
47			for (const snippet of snippets) {
48			this.snippets.set(`${snippet.guild_id}_${snippet.name}`, snippet);
49			}
50			}
51
52			async removeFiles(fileNames: string[], guildId: string) {
53			for (const name of fileNames) {
54			const filePath = `${sudoPrefix(`storage/snippet_attachments/${guildId}`, true)}/${name}`;
55			logInfo("Attempting to remove file: " + filePath);
56			await fs.rm(filePath).catch(logError);
57			}
58			}
59
60			async createSnippet({
61			name,
62			content,
63			attachments,
64			guildId,
65			userId,
66			roles,
67			channels,
68			users,
69			randomize
70			}: CreateSnippetOptions) {
71			if (!content && (!attachments \|\| attachments.length === 0)) {
72			return { error: "Content or attachment is required to create a snippet" };
73			}
74
75			if (this.snippets.has(`${guildId}_${name}`)) {
76			return { error: "A snippet with the same name already exists" };
77			}
78
79			if (this.client.commands.has(name)) {
80			return { error: "Sorry, there's a built-in internal command already with that name" };
81			}
82
83			const filesDownloaded: string[] = [];
84
85			log(attachments);
86			log(this.client.configManager.systemConfig.snippets?.save_attachments);
87
88			if (attachments && this.client.configManager.systemConfig.snippets?.save_attachments) {
89			for (const attachment of attachments) {
90			const { error, name } = await this.downloadAttachment({
91			guildId,
92			proxyURL: attachment.proxyURL
93			});
94
95			if (error) {
96			await this.removeFiles(filesDownloaded, guildId);
97
98			if (error instanceof Error && error.message.startsWith("HTTP error")) {
99			return { error: error.message };
100			}
101
102			return { error: "Could not save attachments: An internal error has occurred" };
103			}
104
105			filesDownloaded.push(name);
106			}
107			}
108
109			const snippet = await this.client.prisma.snippet.create({
110			data: {
111			content: content ? [content] : undefined,
112			guild_id: guildId,
113			user_id: userId,
114			attachments: filesDownloaded,
115			channels,
116			roles,
117			users,
118			name,
119			randomize
120			},
121			include: {
122			permission_roles: true
123			}
124			});
125
126			this.snippets.set(`${guildId}_${snippet.name}`, snippet);
127
128			return { snippet };
129			}
130
131			async downloadAttachment({ guildId, proxyURL }: { proxyURL: string; guildId: string }) {
132			try {
133			const splittedName = basename(proxyURL).split(".");
134			const extension = splittedName.pop()!;
135			splittedName.push(`_${Date.now()}_${Math.random() * 10000000}`);
136			splittedName.push(extension);
137			const fileName = splittedName.join(".").replace(/\//g, "_");
138			const path = sudoPrefix(`storage/snippet_attachments/${guildId}`, true);
139
140			await downloadFile({
141			url: proxyURL,
142			path,
143			name: fileName
144			});
145
146			return { path, name: fileName };
147			} catch (e) {
148			logError(e);
149			return { error: e as Error \| AxiosError };
150			}
151			}
152
153			async deleteSnippet({ name, guildId }: CommonSnippetActionOptions) {
154			if (!this.snippets.has(`${guildId}_${name}`)) {
155			return { error: "No snippet found with that name" };
156			}
157
158			await this.client.prisma.snippet.deleteMany({
159			where: {
160			guild_id: guildId,
161			name
162			}
163			});
164
165			await this.removeFiles(this.snippets.get(`${guildId}_${name}`)!.attachments, guildId);
166			this.snippets.delete(`${guildId}_${name}`);
167
168			return { success: true };
169			}
170
171			async renameSnippet({ name, guildId, newName }: CommonSnippetActionOptions & { newName: string }) {
172			if (!this.snippets.has(`${guildId}_${name}`)) {
173			return { error: "No snippet found with that name" };
174			}
175
176			if (this.client.commands.has(newName)) {
177			return { error: "Sorry, there's a built-in internal command already with that name" };
178			}
179
180			await this.client.prisma.snippet.updateMany({
181			where: {
182			name,
183			guild_id: guildId
184			},
185			data: {
186			name: newName
187			}
188			});
189
190			const snippet = this.snippets.get(`${guildId}_${name}`)!;
191			snippet.name = newName;
192			this.snippets.set(`${guildId}_${newName}`, snippet);
193			this.snippets.delete(`${guildId}_${name}`);
194
195			return { success: true, snippet };
196			}
197
198			async checkPermissions(snippet: SnippetWithPermissions, member: GuildMember, guildId: string, channelId?: string) {
199			if (member.permissions.has(PermissionFlagsBits.Administrator, true)) return true;
200
201			if (
202			(snippet.channels.length > 0 && channelId && !snippet.channels.includes(channelId)) \|\|
203			(snippet.users.length > 0 && !snippet.users.includes(member.user.id)) \|\|
204			(snippet.roles.length > 0 && !member.roles.cache.hasAll(...snippet.roles))
205			) {
206			log("Channel/user doesn't have permission to run this snippet.");
207			return false;
208			}
209
210			const { permissions: memberPermissions } = await this.client.permissionManager.getMemberPermissions(member, true);
211
212			if (this.client.permissionManager.usesLevelBasedMode(guildId) && typeof snippet.level === "number") {
213			const level = (await this.client.permissionManager.getManager(member.guild.id)).getPermissionLevel(member);
214
215			if (level < snippet.level) {
216			log("User doesn't have enough permission to run this snippet. (level based permission system)");
217			return false;
218			}
219			}
220
221			const { permissions: snippetPermissions } = await this.client.permissionManager.getMemberPermissions(member);
222
223			for (const permission of snippetPermissions) {
224			if (!memberPermissions.has(permission)) {
225			log("User doesn't have enough permission to run this snippet. (hybrid permission system)");
226			return false;
227			}
228			}
229
230			return true;
231			}
232
233			async createMessageOptionsFromSnippet({
234			name,
235			guildId,
236			channelId,
237			member
238			}: CommonSnippetActionOptions & {
239			channelId: string;
240			member: GuildMember;
241			}) {
242			if (!this.snippets?.has(`${guildId}_${name}`)) {
243			return { error: "No snippet found with that name", found: false };
244			}
245
246			const snippet = this.snippets.get(`${guildId}_${name}`)!;
247
248			if (!snippet.content && snippet.attachments.length === 0)
249			throw new Error("Corrupted database: snippet attachment and content both are unusable");
250
251			if (!(await this.checkPermissions(snippet, member, guildId, channelId))) {
252			return {
253			options: undefined
254			};
255			}
256
257			const files = [];
258
259			if (snippet.randomize && snippet.attachments.length > 0) {
260			const randomAttachment = snippet.attachments[Math.floor(Math.random() * snippet.attachments.length)];
261
262			const file = sudoPrefix(`storage/snippet_attachments/${guildId}/${randomAttachment}`, false);
263
264			if (!existsSync(file)) {
265			logWithLevel(LogLevel.CRITICAL, `Could find attachment: ${file}`);
266			} else {
267			files.push(file);
268			}
269			} else {
270			for (const attachment of snippet.attachments) {
271			const file = sudoPrefix(`storage/snippet_attachments/${guildId}/${attachment}`, false);
272
273			if (!existsSync(file)) {
274			logWithLevel(LogLevel.CRITICAL, `Could find attachment: ${file}`);
275			continue;
276			}
277
278			files.push(file);
279			}
280			}
281
282			const content = snippet.content[snippet.randomize ? Math.floor(Math.random() * snippet.content.length) : 0];
283
284			return {
285			options: EmbedSchemaParser.getMessageOptions(
286			{
287			content: content ?? undefined,
288			files
289			} as MessageCreateOptions,
290			true
291			),
292			found: true
293			};
294			}
295
296			async onMessageCreate(message: Message, commandName: string) {
297			const { options, found } = await this.createMessageOptionsFromSnippet({
298			name: commandName,
299			guildId: message.guildId!,
300			channelId: message.channelId!,
301			member: message.member! as GuildMember
302			});
303
304			if (!found \|\| !options) {
305			log("Snippet not found or permission error");
306			return false;
307			}
308
309			await message.channel.send(options).catch(logError);
310			return true;
311			}
312
313			async toggleRandomization({ guildId, name }: CommonSnippetActionOptions) {
314			if (!this.snippets.has(`${guildId}_${name}`)) return { error: "Snippet does not exist" };
315
316			const snippet = this.snippets.get(`${guildId}_${name}`);
317
318			if (!snippet) {
319			return { error: "Snippet does not exist" };
320			}
321
322			await this.client.prisma.snippet.update({
323			where: {
324			id: snippet.id
325			},
326			data: {
327			randomize: !snippet.randomize
328			}
329			});
330
331			const localSnippet = this.snippets.get(`${guildId}_${name}`)!;
332			localSnippet.randomize = !snippet.randomize;
333			this.snippets.set(`${guildId}_${name}`, localSnippet);
334
335			return { randomization: !snippet.randomize };
336			}
337
338			async pushFile({ files, guildId, name }: CommonSnippetActionOptions & { files: string[] }) {
339			if (!this.snippets.has(`${guildId}_${name}`)) return { error: "Snippet does not exist" };
340
341			const filesDownloaded = [];
342
343			for (const file of files) {
344			const { error, name } = await this.downloadAttachment({
345			guildId,
346			proxyURL: file
347			});
348
349			if (error) {
350			await this.removeFiles(filesDownloaded, guildId);
351
352			if (error instanceof Error && error.message.startsWith("HTTP error")) {
353			return { error: error.message };
354			}
355
356			return { error: "Could not save attachments: An internal error has occurred" };
357			}
358
359			filesDownloaded.push(name);
360			}
361
362			const { count } = await this.client.prisma.snippet.updateMany({
363			where: {
364			name,
365			guild_id: guildId
366			},
367			data: {
368			attachments: {
369			push: filesDownloaded
370			}
371			}
372			});
373
374			if (count === 0) return { error: "Snippet does not exist" };
375
376			const snippet = this.snippets.get(`${guildId}_${name}`)!;
377			snippet.attachments.push(...filesDownloaded);
378			this.snippets.set(`${guildId}_${name}`, snippet);
379
380			return { count };
381			}
382
383			async checkPermissionInSnippetCommands(name: string, message: CommandMessage, command: Command) {
384			const snippet = this.snippets.get(`${message.guildId!}_${name}`);
385
386			if (!snippet) {
387			await command.deferredReply(message, `${getEmoji(this.client, "error")} No snippet found with that name!')}`);
388			return false;
389			}
390
391			if (!(await this.client.snippetManager.checkPermissions(snippet, message.member! as GuildMember, message.guildId!))) {
392			await command.deferredReply(
393			message,
394			`${getEmoji(this.client, "error")} You don't have permission to modify this snippet!`
395			);
396			return false;
397			}
398
399			return true;
400			}
401
402			async updateSnippet({
403			channels,
404			content,
405			guildId,
406			name,
407			randomize,
408			roles,
409			users,
410			permissionRoleName,
411			level
412			}: Partial<Omit<CreateSnippetOptions, "attachments" \| "userId">> &
413			CommonSnippetActionOptions & { permissionRoleName?: string; level?: number }) {
414			if (!this.snippets.has(`${guildId}_${name}`)) {
415			return { error: "No snippet found with that name" };
416			}
417
418			const snippet = this.snippets.get(`${guildId}_${name}`)!;
419
420			let permissionRole: PermissionRole \| null = null;
421
422			if (permissionRoleName) {
423			permissionRole = await this.client.prisma.permissionRole.findFirst({
424			where: {
425			guild_id: guildId,
426			name: permissionRoleName
427			}
428			});
429
430			if (!permissionRole) {
431			return { error: "No named permission role found with the given name!" };
432			}
433			}
434
435			const updatedSnippet = await this.client.prisma.snippet.update({
436			where: {
437			id: snippet.id
438			},
439			data: {
440			content: content ? [content] : undefined,
441			channels,
442			roles,
443			randomize,
444			users,
445			permission_roles: permissionRole
446			? {
447			connect: {
448			id: permissionRole.id
449			}
450			}
451			: undefined,
452			level
453			},
454			include: {
455			permission_roles: true
456			}
457			});
458
459			this.snippets.set(`${guildId}_${name}`, updatedSnippet);
460
461			return {
462			updatedSnippet
463			};
464			}
465			}
466
467			interface CommonSnippetActionOptions {
468			name: string;
469			guildId: string;
470			}
471
472			interface CreateSnippetOptions extends CommonSnippetActionOptions {
473			content?: string;
474			attachments?: Attachment[];
475			userId: string;
476			roles: string[];
477			users: string[];
478			channels: string[];
479			randomize?: boolean;
480			}