commands/information/ProfileCommand.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 { formatDistanceToNowStrict } from "date-fns";
import {
    APIEmbedField,
    ActivityType,
    EmbedBuilder,
    Emoji,
    Guild,
    GuildMember,
    PermissionFlagsBits,
    SlashCommandBuilder,
    roleMention
} from "discord.js";
import Client from "../../core/Client";
import Command, { AnyCommandContext, ArgumentType, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
import { log, logError } from "../../utils/logger";
import { getUserBadges } from "../../utils/user";
import { getEmoji } from "../../utils/utils";

const status = (s: "idle" | "online" | "dnd" | "invisible" | null | undefined): string => {
    if (s === "idle") return "Idle";
    else if (s === "dnd") return "Do not disturb";
    else if (s === "online") return "Online";
    else if (s === undefined || s === null || s === "invisible") return "Offline/Invisible";

    return s;
};

const statusEmoji = (client: Client, s: "idle" | "online" | "dnd" | "invisible" | null | undefined): string => {
    if (s === "idle") return getEmoji(client, "idle");
    else if (s === "dnd") return getEmoji(client, "dnd");
    else if (s === "online") return getEmoji(client, "online");
    else if (s === undefined || s === null || s === "invisible") return getEmoji(client, "invisible");

    return s;
};

const getStatusText = (client: Client, member: GuildMember) =>
    "" +
    ((member?.presence?.clientStatus?.desktop
        ? statusEmoji(client, member?.presence?.clientStatus?.desktop) +
          " Desktop (" +
          status(member?.presence?.clientStatus?.desktop) +
          ")\n"
        : "") +
        (member?.presence?.clientStatus?.web
            ? statusEmoji(client, member?.presence?.clientStatus?.web) +
              " Web (" +
              status(member?.presence?.clientStatus?.web) +
              ")\n"
            : "") +
        (member?.presence?.clientStatus?.mobile
            ? statusEmoji(client, member?.presence?.clientStatus?.mobile) +
              " Mobile (" +
              status(member?.presence?.clientStatus?.mobile) +
              ")"
            : ""));

export function getPermissionLevel(
    { permissions, guild, id }: { id: string; permissions: GuildMember["permissions"]; guild: Guild },
    string: boolean = false
) {
    if (guild.ownerId === id) {
        return string ? "100" : 100;
    }

    const allBits = Object.keys(PermissionFlagsBits).length;
    const array = permissions.toArray();

    if (array.includes("Administrator")) {
        return string ? "100" : 100;
    }

    const percentage = Math.round((array.length / allBits) * 100);
    return string ? percentage.toString() : percentage;
}

export default class ProfileCommand extends Command {
    public readonly name = "profile";
    public readonly validationRules: ValidationRule[] = [
        {
            types: [ArgumentType.GuildMember],
            name: "member",
            optional: true,
            typeErrorMessage: "Invalid member given",
            entityNotNull: true,
            entityNotNullErrorMessage: "That member could not be found!"
        }
    ];
    public readonly aliases = ["userprofile"];
    public readonly permissions = [];

    public readonly description = "Shows your or someone else's profile.";
    public readonly slashCommandBuilder = new SlashCommandBuilder().addUserOption(option =>
        option.setName("member").setDescription("The target member")
    );

    private isAvailableEmoji({ id, identifier }: Emoji) {
        for (const [, guild] of this.client.guilds.cache) {
            const emoji = guild.emojis.cache.find(e => e.id === id || e.identifier === identifier);

            if (emoji) {
                return true;
            }
        }

        return false;
    }

    async execute(message: CommandMessage, context: AnyCommandContext): Promise<CommandReturn> {
        await this.deferIfInteraction(message);

        const member: GuildMember | null =
            (context.isLegacy ? context.parsedNamedArgs.member : context.options.getMember("member")) ?? message.member;

        if (!member) {
            await this.error(message, "Could not resolve that member!");
            return;
        }

        const activities: string[] = [];

        log(member.presence);

        if (member?.presence) {
            for (const a of member?.presence?.activities.values()!) {
                log(a);

                if (a.type === ActivityType.Custom) {
                    activities.push(
                        `${a.emoji && this.isAvailableEmoji(a.emoji) ? `${a.emoji.toString()}` : ":small_blue_diamond:"} ${
                            a.state
                        }`
                    );
                } else if (a.type === ActivityType.Listening) {
                    if (a.name === "Spotify") {
                        const url = a.url ? `${a.url}` : null;
                        activities.push(
                            `${this.emoji("spotify")} Listening to **Spotify**: ${url ? "[" : "__"}${a.state?.split(/\;/)[0]} - ${
                                a.details
                            }${url ? "](" + url + ")" : "__"}`
                        );
                        continue;
                    }

                    activities.push(`:musical_note: Listening to **${a.name}**`);
                } else if (a.type === ActivityType.Competing) {
                    activities.push(`:fire: Competing **${a.name}**`);
                } else if (a.type === ActivityType.Playing) {
                    activities.push(`:video_game: Playing **${a.name}**`);
                } else if (a.type === ActivityType.Streaming) {
                    activities.push(`:video_camera: Streaming **${a.name}**`);
                } else if (a.type === ActivityType.Watching) {
                    activities.push(`:tv: Watching **${a.name}**`);
                }
            }
        }

        const allRoles = [...member!.roles.cache.values()]
            .filter(role => role.id !== message.guildId!)
            .sort((role1, role2) => {
                return role2.position - role1.position;
            });
        const limit = 10;
        const roles = (allRoles.length > limit ? allRoles.slice(0, limit) : allRoles)
            .reduce((acc, value) => `${acc} ${roleMention(value.id)}`, "")!
            .trim()!;
        const statusText = getStatusText(this.client, member!);

        const fields: APIEmbedField[] = [
            {
                name: "Nickname",
                value: `${member!.nickname?.replace(/\*\<\>\@\_\~\|/g, "") ?? "*Nickname not set*"}`
            },
            {
                name: "Account Created",
                value: `${member!.user.createdAt.toLocaleDateString("en-US")} (${formatDistanceToNowStrict(
                    member!.user.createdTimestamp,
                    { addSuffix: true }
                )})`,
                inline: true
            },
            {
                name: "Joined at",
                value: `${member!.joinedAt!.toLocaleDateString("en-US")} (${formatDistanceToNowStrict(member!.joinedTimestamp!, {
                    addSuffix: true
                })})`,
                inline: true
            },
            {
                name: "Active Devices",
                value: `${statusText === "" ? `${this.emoji("invisible")} Offline/Invisible` : statusText}`
            },
            {
                name: "Status",
                value: `${activities.length === 0 ? "*No status set*" : activities.join("\n")}`
            },
            {
                name: "Roles",
                value:
                    roles === ""
                        ? "*No roles assigned*"
                        : `${roles} ${allRoles.length > limit ? `**+ ${allRoles.length - limit} More**` : ""}`
            }
        ];

        const badges = getUserBadges(this.client, member!.user);

        if (badges.length > 0) {
            fields.push({
                name: "Badges",
                value: badges.join("\n")
            });
        }

        let banner: string | undefined;

        try {
            await member?.user.fetch(true);
            banner = member!.user!.bannerURL({ size: 4096, forceStatic: false }) ?? undefined;
        } catch (e) {
            logError(e);
        }

        log("Banner", banner, member!.user!.banner);

        let permissionPercentage = 0;

        if (this.client.configManager.config[message.guildId!]?.permissions.mode === "levels") {
            permissionPercentage = this.client.permissionManager.getMemberPermissionLevel(member);
        } else {
            permissionPercentage = getPermissionLevel(member, false) as number;
        }

        await this.deferredReply(message, {
            embeds: [
                new EmbedBuilder({
                    image: banner
                        ? {
                              url: banner
                          }
                        : undefined
                })
                    .setColor(member!.user!.hexAccentColor ? member!.user!.hexAccentColor! : "#007bff")
                    .setAuthor({
                        name: member?.user.tag!,
                        iconURL: member!.user.displayAvatarURL()
                    })
                    .setThumbnail(
                        member!.displayAvatarURL({
                            size: 4096,
                            forceStatic: false
                        })
                    )
                    .setFields(fields)
                    .setFooter({
                        text: `${member?.user.bot ? "Bot" : "User"} • ${member!.id} • Has ${permissionPercentage}% permissions`
                    })
            ]
        });
    }
}
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 { formatDistanceToNowStrict } from "date-fns";
21	import {
22	APIEmbedField,
23	ActivityType,
24	EmbedBuilder,
25	Emoji,
26	Guild,
27	GuildMember,
28	PermissionFlagsBits,
29	SlashCommandBuilder,
30	roleMention
31	} from "discord.js";
32	import Client from "../../core/Client";
33	import Command, { AnyCommandContext, ArgumentType, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
34	import { log, logError } from "../../utils/logger";
35	import { getUserBadges } from "../../utils/user";
36	import { getEmoji } from "../../utils/utils";
37
38	const status = (s: "idle" \| "online" \| "dnd" \| "invisible" \| null \| undefined): string => {
39	if (s === "idle") return "Idle";
40	else if (s === "dnd") return "Do not disturb";
41	else if (s === "online") return "Online";
42	else if (s === undefined \|\| s === null \|\| s === "invisible") return "Offline/Invisible";
43
44	return s;
45	};
46
47	const statusEmoji = (client: Client, s: "idle" \| "online" \| "dnd" \| "invisible" \| null \| undefined): string => {
48	if (s === "idle") return getEmoji(client, "idle");
49	else if (s === "dnd") return getEmoji(client, "dnd");
50	else if (s === "online") return getEmoji(client, "online");
51	else if (s === undefined \|\| s === null \|\| s === "invisible") return getEmoji(client, "invisible");
52
53	return s;
54	};
55
56	const getStatusText = (client: Client, member: GuildMember) =>
57	"" +
58	((member?.presence?.clientStatus?.desktop
59	? statusEmoji(client, member?.presence?.clientStatus?.desktop) +
60	" Desktop (" +
61	status(member?.presence?.clientStatus?.desktop) +
62	")\n"
63	: "") +
64	(member?.presence?.clientStatus?.web
65	? statusEmoji(client, member?.presence?.clientStatus?.web) +
66	" Web (" +
67	status(member?.presence?.clientStatus?.web) +
68	")\n"
69	: "") +
70	(member?.presence?.clientStatus?.mobile
71	? statusEmoji(client, member?.presence?.clientStatus?.mobile) +
72	" Mobile (" +
73	status(member?.presence?.clientStatus?.mobile) +
74	")"
75	: ""));
76
77	export function getPermissionLevel(
78	{ permissions, guild, id }: { id: string; permissions: GuildMember["permissions"]; guild: Guild },
79	string: boolean = false
80	) {
81	if (guild.ownerId === id) {
82	return string ? "100" : 100;
83	}
84
85	const allBits = Object.keys(PermissionFlagsBits).length;
86	const array = permissions.toArray();
87
88	if (array.includes("Administrator")) {
89	return string ? "100" : 100;
90	}
91
92	const percentage = Math.round((array.length / allBits) * 100);
93	return string ? percentage.toString() : percentage;
94	}
95
96	export default class ProfileCommand extends Command {
97	public readonly name = "profile";
98	public readonly validationRules: ValidationRule[] = [
99	{
100	types: [ArgumentType.GuildMember],
101	name: "member",
102	optional: true,
103	typeErrorMessage: "Invalid member given",
104	entityNotNull: true,
105	entityNotNullErrorMessage: "That member could not be found!"
106	}
107	];
108	public readonly aliases = ["userprofile"];
109	public readonly permissions = [];
110
111	public readonly description = "Shows your or someone else's profile.";
112	public readonly slashCommandBuilder = new SlashCommandBuilder().addUserOption(option =>
113	option.setName("member").setDescription("The target member")
114	);
115
116	private isAvailableEmoji({ id, identifier }: Emoji) {
117	for (const [, guild] of this.client.guilds.cache) {
118	const emoji = guild.emojis.cache.find(e => e.id === id \|\| e.identifier === identifier);
119
120	if (emoji) {
121	return true;
122	}
123	}
124
125	return false;
126	}
127
128	async execute(message: CommandMessage, context: AnyCommandContext): Promise<CommandReturn> {
129	await this.deferIfInteraction(message);
130
131	const member: GuildMember \| null =
132	(context.isLegacy ? context.parsedNamedArgs.member : context.options.getMember("member")) ?? message.member;
133
134	if (!member) {
135	await this.error(message, "Could not resolve that member!");
136	return;
137	}
138
139	const activities: string[] = [];
140
141	log(member.presence);
142
143	if (member?.presence) {
144	for (const a of member?.presence?.activities.values()!) {
145	log(a);
146
147	if (a.type === ActivityType.Custom) {
148	activities.push(
149	`${a.emoji && this.isAvailableEmoji(a.emoji) ? `${a.emoji.toString()}` : ":small_blue_diamond:"} ${
150	a.state
151	}`
152	);
153	} else if (a.type === ActivityType.Listening) {
154	if (a.name === "Spotify") {
155	const url = a.url ? `${a.url}` : null;
156	activities.push(
157	`${this.emoji("spotify")} Listening to Spotify: ${url ? "[" : "__"}${a.state?.split(/\;/)[0]} - ${
158	a.details
159	}${url ? "](" + url + ")" : "__"}`
160	);
161	continue;
162	}
163
164	activities.push(`:musical_note: Listening to ${a.name}`);
165	} else if (a.type === ActivityType.Competing) {
166	activities.push(`:fire: Competing ${a.name}`);
167	} else if (a.type === ActivityType.Playing) {
168	activities.push(`:video_game: Playing ${a.name}`);
169	} else if (a.type === ActivityType.Streaming) {
170	activities.push(`:video_camera: Streaming ${a.name}`);
171	} else if (a.type === ActivityType.Watching) {
172	activities.push(`:tv: Watching ${a.name}`);
173	}
174	}
175	}
176
177	const allRoles = [...member!.roles.cache.values()]
178	.filter(role => role.id !== message.guildId!)
179	.sort((role1, role2) => {
180	return role2.position - role1.position;
181	});
182	const limit = 10;
183	const roles = (allRoles.length > limit ? allRoles.slice(0, limit) : allRoles)
184	.reduce((acc, value) => `${acc} ${roleMention(value.id)}`, "")!
185	.trim()!;
186	const statusText = getStatusText(this.client, member!);
187
188	const fields: APIEmbedField[] = [
189	{
190	name: "Nickname",
191	value: `${member!.nickname?.replace(/\\<\>\@\_\~\\|/g, "") ?? "Nickname not set*"}`
192	},
193	{
194	name: "Account Created",
195	value: `${member!.user.createdAt.toLocaleDateString("en-US")} (${formatDistanceToNowStrict(
196	member!.user.createdTimestamp,
197	{ addSuffix: true }
198	)})`,
199	inline: true
200	},
201	{
202	name: "Joined at",
203	value: `${member!.joinedAt!.toLocaleDateString("en-US")} (${formatDistanceToNowStrict(member!.joinedTimestamp!, {
204	addSuffix: true
205	})})`,
206	inline: true
207	},
208	{
209	name: "Active Devices",
210	value: `${statusText === "" ? `${this.emoji("invisible")} Offline/Invisible` : statusText}`
211	},
212	{
213	name: "Status",
214	value: `${activities.length === 0 ? "No status set" : activities.join("\n")}`
215	},
216	{
217	name: "Roles",
218	value:
219	roles === ""
220	? "No roles assigned"
221	: `${roles} ${allRoles.length > limit ? `+ ${allRoles.length - limit} More` : ""}`
222	}
223	];
224
225	const badges = getUserBadges(this.client, member!.user);
226
227	if (badges.length > 0) {
228	fields.push({
229	name: "Badges",
230	value: badges.join("\n")
231	});
232	}
233
234	let banner: string \| undefined;
235
236	try {
237	await member?.user.fetch(true);
238	banner = member!.user!.bannerURL({ size: 4096, forceStatic: false }) ?? undefined;
239	} catch (e) {
240	logError(e);
241	}
242
243	log("Banner", banner, member!.user!.banner);
244
245	let permissionPercentage = 0;
246
247	if (this.client.configManager.config[message.guildId!]?.permissions.mode === "levels") {
248	permissionPercentage = this.client.permissionManager.getMemberPermissionLevel(member);
249	} else {
250	permissionPercentage = getPermissionLevel(member, false) as number;
251	}
252
253	await this.deferredReply(message, {
254	embeds: [
255	new EmbedBuilder({
256	image: banner
257	? {
258	url: banner
259	}
260	: undefined
261	})
262	.setColor(member!.user!.hexAccentColor ? member!.user!.hexAccentColor! : "#007bff")
263	.setAuthor({
264	name: member?.user.tag!,
265	iconURL: member!.user.displayAvatarURL()
266	})
267	.setThumbnail(
268	member!.displayAvatarURL({
269	size: 4096,
270	forceStatic: false
271	})
272	)
273	.setFields(fields)
274	.setFooter({
275	text: `${member?.user.bot ? "Bot" : "User"} • ${member!.id} • Has ${permissionPercentage}% permissions`
276	})
277	]
278	});
279	}
280	}