src/services/CommandPermissionOverwriteManager.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 { CommandPermissionOverwrite } from "@prisma/client";
import { Awaitable, GuildMember, PermissionsString, Snowflake } from "discord.js";
import Service from "../core/Service";
import { GatewayEventListener } from "../decorators/GatewayEventListener";
import { HasEventListeners } from "../types/HasEventListeners";
import { log } from "../utils/Logger";
import { GetMemberPermissionInGuildResult } from "./PermissionManager";

export const name = "commandPermissionOverwriteManager";

export default class CommandPermissionOverwriteManager extends Service implements HasEventListeners {
    readonly permissionOverwrites = new Map<`${Snowflake}____${string}`, CommandPermissionOverwrite[]>();
    readonly validators: Array<keyof this> = [
        "validatePermissionOverwriteUsers",
        "validatePermissionOverwriteChannels",
        "validatePermissionOverwriteRoles",
        "validatePermissionOverwriteLevels",
        "validatePermissionOverwritePermissions"
    ];

    @GatewayEventListener("ready")
    async onReady() {
        log("Syncing command permission overwrites...");

        const permissionOverwrites = await this.client.prisma.commandPermissionOverwrite.findMany();
        this.permissionOverwrites.clear();

        for (const permissionOverwrite of permissionOverwrites) {
            for (const command of permissionOverwrite.commands) {
                const key = `${permissionOverwrite.guildId}____${command}` as const;
                let existingOverwriteArray = this.permissionOverwrites.get(key);

                if (!existingOverwriteArray) {
                    existingOverwriteArray = [];
                    this.permissionOverwrites.set(key, existingOverwriteArray);
                }

                existingOverwriteArray.push(permissionOverwrite);
            }
        }

        log("Successfully synced command permission overwrites");
    }

    async validatePermissionOverwritePermissions(
        permissionOverwrite: CommandPermissionOverwrite,
        _: ValidatePermissionOverwritesOptions,
        { permissions }: GetMemberPermissionInGuildResult
    ) {
        return (
            (permissionOverwrite.requiredPermissionMode === "AND" &&
                permissions.has(permissionOverwrite.requiredPermissions as PermissionsString[], true)) ||
            (permissionOverwrite.requiredPermissionMode === "OR" &&
                permissions.any(permissionOverwrite.requiredPermissions as PermissionsString[], true))
        );
    }

    validatePermissionOverwriteChannels(
        permissionOverwrite: CommandPermissionOverwrite,
        { channelId }: ValidatePermissionOverwritesOptions
    ) {
        if (permissionOverwrite.requiredChannels.length === 0) {
            return true;
        }

        return permissionOverwrite.requiredChannels.includes(channelId);
    }

    validatePermissionOverwriteUsers(
        permissionOverwrite: CommandPermissionOverwrite,
        { member }: ValidatePermissionOverwritesOptions
    ) {
        if (permissionOverwrite.requiredUsers.length === 0) {
            return true;
        }

        return permissionOverwrite.requiredUsers.includes(member.user.id);
    }

    validatePermissionOverwriteRoles(
        permissionOverwrite: CommandPermissionOverwrite,
        { member }: ValidatePermissionOverwritesOptions
    ) {
        if (permissionOverwrite.requiredRoles.length === 0) {
            return true;
        }

        for (const roleId of member.roles.cache.keys()) {
            if (permissionOverwrite.requiredRoles.includes(roleId)) {
                return true;
            }
        }

        return false;
    }

    validatePermissionOverwriteLevels(
        permissionOverwrite: CommandPermissionOverwrite,
        _: ValidatePermissionOverwritesOptions,
        permissions: GetMemberPermissionInGuildResult
    ) {
        if (permissions.type !== "levels" || permissionOverwrite.requiredLevel === null) {
            return true;
        }

        return permissions.level >= permissionOverwrite.requiredLevel;
    }

    async validatePermissionOverwrites(options: ValidatePermissionOverwritesOptions) {
        const { guildId, commandName, member } = options;
        const permissionOverwrites = this.client.commandPermissionOverwriteManager.permissionOverwrites.get(
            `${guildId!}____${commandName}`
        );
        const hasOverwrite = !!permissionOverwrites?.length;

        if (!permissionOverwrites?.length) {
            return { hasOverwrite: false, result: true };
        }

        const memberPermissions = await this.client.permissionManager.getMemberPermissions(member, true);
        let result = true;

        outerLoop: for (const permissionOverwrite of permissionOverwrites) {
            for (const validator of this.validators) {
                const method = this[validator] as PermissionValidatorFunction | undefined;
                const validationResult = !!(await method?.call(this, permissionOverwrite, options, memberPermissions));

                if (permissionOverwrite.mode === "AND" && !validationResult) {
                    return { hasOverwrite, result: false };
                }

                if (permissionOverwrite.mode === "OR" && validationResult) {
                    result &&= true;
                    continue outerLoop;
                }
            }

            result &&= permissionOverwrite.mode === "AND";

            if (!result) {
                break;
            }
        }

        return { hasOverwrite, result };
    }
}

type ValidatePermissionOverwritesOptions = {
    guildId: Snowflake;
    commandName: string;
    member: GuildMember;
    channelId: Snowflake;
};

type PermissionValidatorFunction = (
    permissionOverwrite: CommandPermissionOverwrite,
    { member }: ValidatePermissionOverwritesOptions,
    permissions?: GetMemberPermissionInGuildResult
) => Awaitable<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 { CommandPermissionOverwrite } from "@prisma/client";
21			import { Awaitable, GuildMember, PermissionsString, Snowflake } from "discord.js";
22			import Service from "../core/Service";
23			import { GatewayEventListener } from "../decorators/GatewayEventListener";
24			import { HasEventListeners } from "../types/HasEventListeners";
25			import { log } from "../utils/Logger";
26			import { GetMemberPermissionInGuildResult } from "./PermissionManager";
27
28			export const name = "commandPermissionOverwriteManager";
29
30			export default class CommandPermissionOverwriteManager extends Service implements HasEventListeners {
31			readonly permissionOverwrites = new Map<`${Snowflake}____${string}`, CommandPermissionOverwrite[]>();
32			readonly validators: Array<keyof this> = [
33			"validatePermissionOverwriteUsers",
34			"validatePermissionOverwriteChannels",
35			"validatePermissionOverwriteRoles",
36			"validatePermissionOverwriteLevels",
37			"validatePermissionOverwritePermissions"
38			];
39
40			@GatewayEventListener("ready")
41			async onReady() {
42			log("Syncing command permission overwrites...");
43
44			const permissionOverwrites = await this.client.prisma.commandPermissionOverwrite.findMany();
45			this.permissionOverwrites.clear();
46
47			for (const permissionOverwrite of permissionOverwrites) {
48			for (const command of permissionOverwrite.commands) {
49			const key = `${permissionOverwrite.guildId}____${command}` as const;
50			let existingOverwriteArray = this.permissionOverwrites.get(key);
51
52			if (!existingOverwriteArray) {
53			existingOverwriteArray = [];
54			this.permissionOverwrites.set(key, existingOverwriteArray);
55			}
56
57			existingOverwriteArray.push(permissionOverwrite);
58			}
59			}
60
61			log("Successfully synced command permission overwrites");
62			}
63
64			async validatePermissionOverwritePermissions(
65			permissionOverwrite: CommandPermissionOverwrite,
66			_: ValidatePermissionOverwritesOptions,
67			{ permissions }: GetMemberPermissionInGuildResult
68			) {
69			return (
70			(permissionOverwrite.requiredPermissionMode === "AND" &&
71			permissions.has(permissionOverwrite.requiredPermissions as PermissionsString[], true)) \|\|
72			(permissionOverwrite.requiredPermissionMode === "OR" &&
73			permissions.any(permissionOverwrite.requiredPermissions as PermissionsString[], true))
74			);
75			}
76
77			validatePermissionOverwriteChannels(
78			permissionOverwrite: CommandPermissionOverwrite,
79			{ channelId }: ValidatePermissionOverwritesOptions
80			) {
81			if (permissionOverwrite.requiredChannels.length === 0) {
82			return true;
83			}
84
85			return permissionOverwrite.requiredChannels.includes(channelId);
86			}
87
88			validatePermissionOverwriteUsers(
89			permissionOverwrite: CommandPermissionOverwrite,
90			{ member }: ValidatePermissionOverwritesOptions
91			) {
92			if (permissionOverwrite.requiredUsers.length === 0) {
93			return true;
94			}
95
96			return permissionOverwrite.requiredUsers.includes(member.user.id);
97			}
98
99			validatePermissionOverwriteRoles(
100			permissionOverwrite: CommandPermissionOverwrite,
101			{ member }: ValidatePermissionOverwritesOptions
102			) {
103			if (permissionOverwrite.requiredRoles.length === 0) {
104			return true;
105			}
106
107			for (const roleId of member.roles.cache.keys()) {
108			if (permissionOverwrite.requiredRoles.includes(roleId)) {
109			return true;
110			}
111			}
112
113			return false;
114			}
115
116			validatePermissionOverwriteLevels(
117			permissionOverwrite: CommandPermissionOverwrite,
118			_: ValidatePermissionOverwritesOptions,
119			permissions: GetMemberPermissionInGuildResult
120			) {
121			if (permissions.type !== "levels" \|\| permissionOverwrite.requiredLevel === null) {
122			return true;
123			}
124
125			return permissions.level >= permissionOverwrite.requiredLevel;
126			}
127
128			async validatePermissionOverwrites(options: ValidatePermissionOverwritesOptions) {
129			const { guildId, commandName, member } = options;
130			const permissionOverwrites = this.client.commandPermissionOverwriteManager.permissionOverwrites.get(
131			`${guildId!}____${commandName}`
132			);
133			const hasOverwrite = !!permissionOverwrites?.length;
134
135			if (!permissionOverwrites?.length) {
136			return { hasOverwrite: false, result: true };
137			}
138
139			const memberPermissions = await this.client.permissionManager.getMemberPermissions(member, true);
140			let result = true;
141
142			outerLoop: for (const permissionOverwrite of permissionOverwrites) {
143			for (const validator of this.validators) {
144			const method = this[validator] as PermissionValidatorFunction \| undefined;
145			const validationResult = !!(await method?.call(this, permissionOverwrite, options, memberPermissions));
146
147			if (permissionOverwrite.mode === "AND" && !validationResult) {
148			return { hasOverwrite, result: false };
149			}
150
151			if (permissionOverwrite.mode === "OR" && validationResult) {
152			result &&= true;
153			continue outerLoop;
154			}
155			}
156
157			result &&= permissionOverwrite.mode === "AND";
158
159			if (!result) {
160			break;
161			}
162			}
163
164			return { hasOverwrite, result };
165			}
166			}
167
168			type ValidatePermissionOverwritesOptions = {
169			guildId: Snowflake;
170			commandName: string;
171			member: GuildMember;
172			channelId: Snowflake;
173			};
174
175			type PermissionValidatorFunction = (
176			permissionOverwrite: CommandPermissionOverwrite,
177			{ member }: ValidatePermissionOverwritesOptions,
178			permissions?: GetMemberPermissionInGuildResult
179			) => Awaitable<boolean>;