src/utils/utils.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 {
    APIEmbedField,
    Channel,
    ChannelType,
    ColorResolvable,
    ComponentEmojiResolvable,
    EmbedBuilder,
    GuildEmoji,
    GuildMember,
    NewsChannel,
    PermissionOverwrites,
    PermissionResolvable,
    PermissionsBitField,
    TextBasedChannel,
    TextChannel,
    ThreadChannel,
    User,
    escapeMarkdown
} from "discord.js";
import { mkdirSync } from "fs";
import path from "path";
import Client from "../core/Client";
import { ActionDoneName } from "../services/InfractionManager";
import { userInfo } from "./embed";

export function isSnowflake(input: string) {
    return /^\d{16,22}$/.test(input);
}

export function pick<T, K extends Array<keyof T>>(object: T, keys: K): Pick<T, K extends Array<infer E> ? E : never> {
    if (typeof object === "object" && object !== null) {
        const picked: Partial<T> = {};

        for (const key of keys) {
            picked[key] = object[key];
        }

        return picked as Pick<T, K extends Array<infer E> ? E : never>;
    }

    return {} as Pick<T, K extends Array<infer E> ? E : never>;
}

export interface CreateModerationEmbedOptions {
    user: User;
    moderator: User;
    actionDoneName?: ActionDoneName;
    reason?: string;
    description?: string;
    fields?:
        | APIEmbedField[]
        | ((fields: APIEmbedField[], id: string, reason?: string) => Promise<APIEmbedField[]> | APIEmbedField[]);
    id: string | number;
    color?: ColorResolvable;
}

export async function createModerationEmbed({
    user,
    actionDoneName,
    reason,
    description,
    fields,
    id,
    color = 0xf14a60,
    moderator
}: CreateModerationEmbedOptions) {
    return new EmbedBuilder({
        author: {
            name: user.tag,
            icon_url: user.displayAvatarURL()
        },
        description: description ?? `**${escapeMarkdown(user.tag)}** has been ${actionDoneName}.`,
        fields:
            typeof fields === "function"
                ? await fields(
                      [
                          {
                              name: "Reason",
                              value: reason ?? "*No reason provided*"
                          },
                          {
                              name: "User",
                              value: userInfo(user)
                          },
                          {
                              name: "Moderator",
                              value: userInfo(moderator)
                          },
                          {
                              name: "Infraction ID",
                              value: `${id}`
                          }
                      ],
                      `${id}`,
                      reason
                  )
                : [
                      {
                          name: "Reason",
                          value: reason ?? "*No reason provided*"
                      },
                      {
                          name: "User",
                          value: userInfo(user)
                      },
                      {
                          name: "Moderator",
                          value: userInfo(moderator)
                      },
                      ...(fields ?? []),
                      {
                          name: "Infraction ID",
                          value: `${id}`
                      }
                  ],
        footer: actionDoneName
            ? {
                  text: actionDoneName[0].toUpperCase() + actionDoneName.substring(1)
              }
            : undefined
    })
        .setTimestamp()
        .setColor(color);
}

export function getEmoji<B extends boolean = false>(
    client: Client,
    name: string,
    returnNull: B = false as B
): B extends false ? string : string | null {
    return (
        client.guilds.cache
            .get(process.env.HOME_GUILD_ID!)
            ?.emojis.cache.find(e => e.name === name)
            ?.toString() ??
        client.configManager.systemConfig.emojis?.[name] ??
        client.emojiMap.get(name)?.toString() ??
        (returnNull ? null : "")
    );
}

export function getEmojiObject(client: Client, name: string): GuildEmoji | null {
    return (
        client.guilds.cache.get(process.env.HOME_GUILD_ID!)?.emojis.cache.find(e => e.name === name) ??
        client.emojiMap.get(name) ??
        null
    );
}

export function getComponentEmojiResolvable(client: Client, name: string): ComponentEmojiResolvable | null {
    const emoji = getEmojiObject(client, name);

    return emoji
        ? {
              id: emoji?.id,
              name: emoji?.name ?? emoji?.identifier,
              animated: emoji?.animated ?? false
          }
        : null;
}

export function isTextableChannel(
    channel: Channel | ThreadChannel,
    DMs = false
): channel is TextChannel | NewsChannel | ThreadChannel {
    return [
        ...(DMs ? [ChannelType.DM, ChannelType.GroupDM] : []),
        ChannelType.GuildAnnouncement,
        ChannelType.GuildText,
        ChannelType.PrivateThread,
        ChannelType.PublicThread,
        ChannelType.GuildVoice
    ].includes(channel.type);
}

export function developmentMode() {
    return (
        ["dev", "development"].includes(process.env.NODE_ENV?.toLowerCase()!) ||
        ["dev", "development"].includes(process.env.SUDO_ENV?.toLowerCase()!)
    );
}

export function isImmuneToAutoMod(
    client: Client,
    member: GuildMember,
    permission?: PermissionResolvable[] | PermissionResolvable
) {
    return client.permissionManager.isImmuneToAutoMod(member, permission);
}

export function wait(time: number) {
    return new Promise(resolve => setTimeout(resolve, time));
}

export function sudoPrefix(pathLike: string, createDirIfNotExists = false) {
    const directoryOrFile = path.resolve(process.env.SUDO_PREFIX ?? __dirname, process.env.SUDO_PREFIX ? "" : "../..", pathLike);

    if (createDirIfNotExists) mkdirSync(directoryOrFile, { recursive: true });

    return directoryOrFile;
}

export function getPermissionNames(permissionsBit: bigint) {
    const result = [];
    const permissions = new PermissionsBitField(permissionsBit);

    for (const permission of Object.keys(PermissionsBitField.Flags) as (keyof typeof PermissionsBitField.Flags)[]) {
        if (permissions.has(PermissionsBitField.Flags[permission])) {
            result.push(permission);
        }
    }

    return result;
}

export function forceGetPermissionNames(permissions: PermissionResolvable[]) {
    const strings: string[] = [];

    for (const permission of permissions) {
        if (typeof permission === "bigint") {
            strings.push(...getPermissionNames(permission));
        } else if (typeof permission === "string") {
            strings.push(permission);
        } else throw new Error("Unknown permission type");
    }

    return strings;
}

export function getChannelPermissionOverride(permission: PermissionResolvable, permissionOverwrites: PermissionOverwrites) {
    return permissionOverwrites.allow.has(permission, true)
        ? true
        : permissionOverwrites.deny.has(permission, true)
        ? true
        : null;
}

export function chunkedString(str: string, chunkSize = 4000) {
    let output = [];
    let chunk = "";

    for (let i = 0; i < str.length; i++) {
        if (i !== 0 && i % chunkSize === 0) {
            output.push(chunk);
            chunk = str[i];
            continue;
        }

        chunk += str[i];
    }

    if (chunk.length !== 0) {
        output.push(chunk);
    }

    return output;
}

export function escapeRegex(string: string) {
    return string.replace(/[/\-\\^$*+?.()|[\]{}]/g, "\\$&");
}

export function safeMessageContent(content: string, member: GuildMember, channel?: TextBasedChannel) {
    return member.permissions.has("MentionEveryone") &&
        (!channel || member.permissionsIn(channel as TextChannel).has("MentionEveryone"))
        ? content
        : content
              .replaceAll(/@everyone/gi, "`@everyone`")
              .replaceAll(/@here/gi, "`@here`")
              .replaceAll(`<@&${member.guild.id}>`, "`@everyone`")
              .replace(/<@&(\d+)>/gim, (_, id) => `@${member.guild.roles.cache.get(id)?.name ?? id}`);
}

export function isSystemAdmin(client: Client, userId: string) {
    return client.configManager.systemConfig.system_admins.includes(userId);
}
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 {
21			APIEmbedField,
22			Channel,
23			ChannelType,
24			ColorResolvable,
25			ComponentEmojiResolvable,
26			EmbedBuilder,
27			GuildEmoji,
28			GuildMember,
29			NewsChannel,
30			PermissionOverwrites,
31			PermissionResolvable,
32			PermissionsBitField,
33			TextBasedChannel,
34			TextChannel,
35			ThreadChannel,
36			User,
37			escapeMarkdown
38			} from "discord.js";
39			import { mkdirSync } from "fs";
40			import path from "path";
41			import Client from "../core/Client";
42			import { ActionDoneName } from "../services/InfractionManager";
43			import { userInfo } from "./embed";
44
45			export function isSnowflake(input: string) {
46			return /^\d{16,22}$/.test(input);
47			}
48
49			export function pick<T, K extends Array<keyof T>>(object: T, keys: K): Pick<T, K extends Array<infer E> ? E : never> {
50			if (typeof object === "object" && object !== null) {
51			const picked: Partial<T> = {};
52
53			for (const key of keys) {
54			picked[key] = object[key];
55			}
56
57			return picked as Pick<T, K extends Array<infer E> ? E : never>;
58			}
59
60			return {} as Pick<T, K extends Array<infer E> ? E : never>;
61			}
62
63			export interface CreateModerationEmbedOptions {
64			user: User;
65			moderator: User;
66			actionDoneName?: ActionDoneName;
67			reason?: string;
68			description?: string;
69			fields?:
70			\| APIEmbedField[]
71			\| ((fields: APIEmbedField[], id: string, reason?: string) => Promise<APIEmbedField[]> \| APIEmbedField[]);
72			id: string \| number;
73			color?: ColorResolvable;
74			}
75
76			export async function createModerationEmbed({
77			user,
78			actionDoneName,
79			reason,
80			description,
81			fields,
82			id,
83			color = 0xf14a60,
84			moderator
85			}: CreateModerationEmbedOptions) {
86			return new EmbedBuilder({
87			author: {
88			name: user.tag,
89			icon_url: user.displayAvatarURL()
90			},
91			description: description ?? `${escapeMarkdown(user.tag)} has been ${actionDoneName}.`,
92			fields:
93			typeof fields === "function"
94			? await fields(
95			[
96			{
97			name: "Reason",
98			value: reason ?? "No reason provided"
99			},
100			{
101			name: "User",
102			value: userInfo(user)
103			},
104			{
105			name: "Moderator",
106			value: userInfo(moderator)
107			},
108			{
109			name: "Infraction ID",
110			value: `${id}`
111			}
112			],
113			`${id}`,
114			reason
115			)
116			: [
117			{
118			name: "Reason",
119			value: reason ?? "No reason provided"
120			},
121			{
122			name: "User",
123			value: userInfo(user)
124			},
125			{
126			name: "Moderator",
127			value: userInfo(moderator)
128			},
129			...(fields ?? []),
130			{
131			name: "Infraction ID",
132			value: `${id}`
133			}
134			],
135			footer: actionDoneName
136			? {
137			text: actionDoneName[0].toUpperCase() + actionDoneName.substring(1)
138			}
139			: undefined
140			})
141			.setTimestamp()
142			.setColor(color);
143			}
144
145			export function getEmoji<B extends boolean = false>(
146			client: Client,
147			name: string,
148			returnNull: B = false as B
149			): B extends false ? string : string \| null {
150			return (
151			client.guilds.cache
152			.get(process.env.HOME_GUILD_ID!)
153			?.emojis.cache.find(e => e.name === name)
154			?.toString() ??
155			client.configManager.systemConfig.emojis?.[name] ??
156			client.emojiMap.get(name)?.toString() ??
157			(returnNull ? null : "")
158			);
159			}
160
161			export function getEmojiObject(client: Client, name: string): GuildEmoji \| null {
162			return (
163			client.guilds.cache.get(process.env.HOME_GUILD_ID!)?.emojis.cache.find(e => e.name === name) ??
164			client.emojiMap.get(name) ??
165			null
166			);
167			}
168
169			export function getComponentEmojiResolvable(client: Client, name: string): ComponentEmojiResolvable \| null {
170			const emoji = getEmojiObject(client, name);
171
172			return emoji
173			? {
174			id: emoji?.id,
175			name: emoji?.name ?? emoji?.identifier,
176			animated: emoji?.animated ?? false
177			}
178			: null;
179			}
180
181			export function isTextableChannel(
182			channel: Channel \| ThreadChannel,
183			DMs = false
184			): channel is TextChannel \| NewsChannel \| ThreadChannel {
185			return [
186			...(DMs ? [ChannelType.DM, ChannelType.GroupDM] : []),
187			ChannelType.GuildAnnouncement,
188			ChannelType.GuildText,
189			ChannelType.PrivateThread,
190			ChannelType.PublicThread,
191			ChannelType.GuildVoice
192			].includes(channel.type);
193			}
194
195			export function developmentMode() {
196			return (
197			["dev", "development"].includes(process.env.NODE_ENV?.toLowerCase()!) \|\|
198			["dev", "development"].includes(process.env.SUDO_ENV?.toLowerCase()!)
199			);
200			}
201
202			export function isImmuneToAutoMod(
203			client: Client,
204			member: GuildMember,
205			permission?: PermissionResolvable[] \| PermissionResolvable
206			) {
207			return client.permissionManager.isImmuneToAutoMod(member, permission);
208			}
209
210			export function wait(time: number) {
211			return new Promise(resolve => setTimeout(resolve, time));
212			}
213
214			export function sudoPrefix(pathLike: string, createDirIfNotExists = false) {
215			const directoryOrFile = path.resolve(process.env.SUDO_PREFIX ?? __dirname, process.env.SUDO_PREFIX ? "" : "../..", pathLike);
216
217			if (createDirIfNotExists) mkdirSync(directoryOrFile, { recursive: true });
218
219			return directoryOrFile;
220			}
221
222			export function getPermissionNames(permissionsBit: bigint) {
223			const result = [];
224			const permissions = new PermissionsBitField(permissionsBit);
225
226			for (const permission of Object.keys(PermissionsBitField.Flags) as (keyof typeof PermissionsBitField.Flags)[]) {
227			if (permissions.has(PermissionsBitField.Flags[permission])) {
228			result.push(permission);
229			}
230			}
231
232			return result;
233			}
234
235			export function forceGetPermissionNames(permissions: PermissionResolvable[]) {
236			const strings: string[] = [];
237
238			for (const permission of permissions) {
239			if (typeof permission === "bigint") {
240			strings.push(...getPermissionNames(permission));
241			} else if (typeof permission === "string") {
242			strings.push(permission);
243			} else throw new Error("Unknown permission type");
244			}
245
246			return strings;
247			}
248
249			export function getChannelPermissionOverride(permission: PermissionResolvable, permissionOverwrites: PermissionOverwrites) {
250			return permissionOverwrites.allow.has(permission, true)
251			? true
252			: permissionOverwrites.deny.has(permission, true)
253			? true
254			: null;
255			}
256
257			export function chunkedString(str: string, chunkSize = 4000) {
258			let output = [];
259			let chunk = "";
260
261			for (let i = 0; i < str.length; i++) {
262			if (i !== 0 && i % chunkSize === 0) {
263			output.push(chunk);
264			chunk = str[i];
265			continue;
266			}
267
268			chunk += str[i];
269			}
270
271			if (chunk.length !== 0) {
272			output.push(chunk);
273			}
274
275			return output;
276			}
277
278			export function escapeRegex(string: string) {
279			return string.replace(/[/\-\\^$*+?.()\|[\]{}]/g, "\\$&");
280			}
281
282			export function safeMessageContent(content: string, member: GuildMember, channel?: TextBasedChannel) {
283			return member.permissions.has("MentionEveryone") &&
284			(!channel \|\| member.permissionsIn(channel as TextChannel).has("MentionEveryone"))
285			? content
286			: content
287			.replaceAll(/@everyone/gi, "`@everyone`")
288			.replaceAll(/@here/gi, "`@here`")
289			.replaceAll(`<@&${member.guild.id}>`, "`@everyone`")
290			.replace(/<@&(\d+)>/gim, (_, id) => `@${member.guild.roles.cache.get(id)?.name ?? id}`);
291			}
292
293			export function isSystemAdmin(client: Client, userId: string) {
294			return client.configManager.systemConfig.system_admins.includes(userId);
295			}