commands/information/UserLookupCommand.ts

/**
* This file is part of SudoBot.
* 
* Copyright (C) 2021-2022 OSN Inc.
*
* 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 { formatDistanceStrict, formatDistanceToNowStrict } from "date-fns";
import { APIEmbedField } from "discord-api-types/v9";
import { Util, Message, CacheType, CommandInteraction } from "discord.js";
import Client from "../../client/Client";
import MessageEmbed from "../../client/MessageEmbed";
import CommandOptions from "../../types/CommandOptions";
import InteractionOptions from "../../types/InteractionOptions";
import { emoji } from "../../utils/Emoji";
import getUser from "../../utils/getUser";
import BaseCommand from "../../utils/structures/BaseCommand";
import { getUserBadges } from "./ProfileCommand";

export default class UserLookupCommand extends BaseCommand {
    supportsInteractions: boolean = true;

    constructor() {
        super("userlookup", "information", ['user', 'ulookup']);
    }

    async run(client: Client, message: CommandInteraction<CacheType> | Message<boolean>, options: CommandOptions | InteractionOptions): Promise<void> {
        if (!options.isInteraction && options.args[0] === undefined) {
            await message.reply({ ephemeral: true, content: `${emoji("error")} You must specify a user to lookup!` });
            return;
        }

        const user = !options.isInteraction ? await getUser(client, message as Message, options, 0) : options.options.getUser("user");

        if (!user) {
            await message.reply({ content: `${emoji("error")} That user does not exist.` });
            return;
        }

        let member = undefined;

        try {
            member = await message.guild!.members.fetch(user.id);

            if (!member)
                throw new Error("Member not found");
        }
        catch (e) {
            console.log(e);       
            member = undefined;     
        }
        
        const embed = new MessageEmbed({
            author: {
                name: user.tag,
                iconURL: user.displayAvatarURL()
            },
            footer: {
                text: `${user.id}`,
            }
        });


        if (user.hexAccentColor) {            
            embed.setColor(user.hexAccentColor);
        }

        const fieldsCommon: APIEmbedField[] = [  
            
        ];

        let fields: APIEmbedField[] = [
            {
                name: "Server Member?",
                value: member ? "Yes" : "No",
                inline: true
            },
            {
                name: "Bot?",
                value: user.bot ? "Yes" : "No",
                inline: true
            },
            {
                name: "Account created",
                value: user.createdAt.toLocaleString() + " (" + formatDistanceToNowStrict(user.createdAt, { addSuffix: true }) + ")",
                inline: true
            }
        ];

        embed.setThumbnail(user.displayAvatarURL());

        if (member) {
            fields.push({
                name: "Joined Server",
                value: member.joinedAt ? member.joinedAt.toLocaleString() + " (" + formatDistanceToNowStrict(member.joinedAt, { addSuffix: true }) + ")" : "Information not available",
                inline: true
            });

            if (member.premiumSince) {
                fields.push({
                    name: "Boosted Server",
                    value: member.premiumSince.toLocaleString() + " (" + formatDistanceToNowStrict(member.premiumSince, { addSuffix: true }) + ")",
                    inline: true
                });
            }

            if (member.communicationDisabledUntil) {
                fields.push({
                    name: "Timed-out Until",
                    value: member.communicationDisabledUntil.toLocaleString() + " (" + formatDistanceStrict(member.communicationDisabledUntil, new Date()) + ")",
                    inline: true
                });
            }

            if (member.displayAvatarURL()) {
                embed.setThumbnail(member.displayAvatarURL());
            }

            if (member.nickname) {
                fields.push({
                    name: "Nickname",
                    value: Util.escapeMarkdown(member.nickname)
                });
            }

            if (member.displayHexColor) {
                fields.push({
                    name: "Guild Profile Theme Color",
                    value: member.displayHexColor
                });
            }
            
            if (member.displayHexColor && !user.hexAccentColor) {
                embed.setColor(member.displayHexColor);
            }

            if (member.voice && member.voice.channel) {
                fields.push({
                    name: "Current Voice Channel",
                    value: member.voice.channel.toString()
                });
            }

            fields.push({
                name: "Completed Membership Screening",
                value: member.pending ? "No" : "Yes"
            });

            fields.push({
                name: "Mention",
                value: member.toString()
            });

            if (member.roles.highest.id !== member.guild.id) {
                fields.push({
                    name: "Highest Role",
                    value: member.roles.highest.toString()
                });
            }
        }

        const badges = getUserBadges(user).join('\n');

        fields.push({
            name: "Badges",
            value: badges.trim() === '' ? '*No badges found*' : badges
        });

        fields = [...fields, ...fieldsCommon];
        embed.setFields(fields);
        embed.setTimestamp();
        
        await message.reply({
            embeds: [
                embed
            ]
        });
    } 
}
1	rakinar2	577	/**
2			* This file is part of SudoBot.
3			*
4			* Copyright (C) 2021-2022 OSN Inc.
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 { formatDistanceStrict, formatDistanceToNowStrict } from "date-fns";
21			import { APIEmbedField } from "discord-api-types/v9";
22			import { Util, Message, CacheType, CommandInteraction } from "discord.js";
23			import Client from "../../client/Client";
24			import MessageEmbed from "../../client/MessageEmbed";
25			import CommandOptions from "../../types/CommandOptions";
26			import InteractionOptions from "../../types/InteractionOptions";
27			import { emoji } from "../../utils/Emoji";
28			import getUser from "../../utils/getUser";
29			import BaseCommand from "../../utils/structures/BaseCommand";
30			import { getUserBadges } from "./ProfileCommand";
31
32			export default class UserLookupCommand extends BaseCommand {
33			supportsInteractions: boolean = true;
34
35			constructor() {
36			super("userlookup", "information", ['user', 'ulookup']);
37			}
38
39			async run(client: Client, message: CommandInteraction<CacheType> \| Message<boolean>, options: CommandOptions \| InteractionOptions): Promise<void> {
40			if (!options.isInteraction && options.args[0] === undefined) {
41			await message.reply({ ephemeral: true, content: `${emoji("error")} You must specify a user to lookup!` });
42			return;
43			}
44
45			const user = !options.isInteraction ? await getUser(client, message as Message, options, 0) : options.options.getUser("user");
46
47			if (!user) {
48			await message.reply({ content: `${emoji("error")} That user does not exist.` });
49			return;
50			}
51
52			let member = undefined;
53
54			try {
55			member = await message.guild!.members.fetch(user.id);
56
57			if (!member)
58			throw new Error("Member not found");
59			}
60			catch (e) {
61			console.log(e);
62			member = undefined;
63			}
64
65			const embed = new MessageEmbed({
66			author: {
67			name: user.tag,
68			iconURL: user.displayAvatarURL()
69			},
70			footer: {
71			text: `${user.id}`,
72			}
73			});
74
75
76			if (user.hexAccentColor) {
77			embed.setColor(user.hexAccentColor);
78			}
79
80			const fieldsCommon: APIEmbedField[] = [
81
82			];
83
84			let fields: APIEmbedField[] = [
85			{
86			name: "Server Member?",
87			value: member ? "Yes" : "No",
88			inline: true
89			},
90			{
91			name: "Bot?",
92			value: user.bot ? "Yes" : "No",
93			inline: true
94			},
95			{
96			name: "Account created",
97			value: user.createdAt.toLocaleString() + " (" + formatDistanceToNowStrict(user.createdAt, { addSuffix: true }) + ")",
98			inline: true
99			}
100			];
101
102			embed.setThumbnail(user.displayAvatarURL());
103
104			if (member) {
105			fields.push({
106			name: "Joined Server",
107			value: member.joinedAt ? member.joinedAt.toLocaleString() + " (" + formatDistanceToNowStrict(member.joinedAt, { addSuffix: true }) + ")" : "Information not available",
108			inline: true
109			});
110
111			if (member.premiumSince) {
112			fields.push({
113			name: "Boosted Server",
114			value: member.premiumSince.toLocaleString() + " (" + formatDistanceToNowStrict(member.premiumSince, { addSuffix: true }) + ")",
115			inline: true
116			});
117			}
118
119			if (member.communicationDisabledUntil) {
120			fields.push({
121			name: "Timed-out Until",
122			value: member.communicationDisabledUntil.toLocaleString() + " (" + formatDistanceStrict(member.communicationDisabledUntil, new Date()) + ")",
123			inline: true
124			});
125			}
126
127			if (member.displayAvatarURL()) {
128			embed.setThumbnail(member.displayAvatarURL());
129			}
130
131			if (member.nickname) {
132			fields.push({
133			name: "Nickname",
134			value: Util.escapeMarkdown(member.nickname)
135			});
136			}
137
138			if (member.displayHexColor) {
139			fields.push({
140			name: "Guild Profile Theme Color",
141			value: member.displayHexColor
142			});
143			}
144
145			if (member.displayHexColor && !user.hexAccentColor) {
146			embed.setColor(member.displayHexColor);
147			}
148
149			if (member.voice && member.voice.channel) {
150			fields.push({
151			name: "Current Voice Channel",
152			value: member.voice.channel.toString()
153			});
154			}
155
156			fields.push({
157			name: "Completed Membership Screening",
158			value: member.pending ? "No" : "Yes"
159			});
160
161			fields.push({
162			name: "Mention",
163			value: member.toString()
164			});
165
166			if (member.roles.highest.id !== member.guild.id) {
167			fields.push({
168			name: "Highest Role",
169			value: member.roles.highest.toString()
170			});
171			}
172			}
173
174			const badges = getUserBadges(user).join('\n');
175
176			fields.push({
177			name: "Badges",
178			value: badges.trim() === '' ? 'No badges found' : badges
179			});
180
181			fields = [...fields, ...fieldsCommon];
182			embed.setFields(fields);
183			embed.setTimestamp();
184
185			await message.reply({
186			embeds: [
187			embed
188			]
189			});
190			}
191			}