commands/moderation/WarningCommand.ts

import { BanOptions, CommandInteraction, Guild, GuildMember, Interaction, Message, User } from 'discord.js';
import BaseCommand from '../../utils/structures/BaseCommand';
import DiscordClient from '../../client/Client';
import CommandOptions from '../../types/CommandOptions';
import InteractionOptions from '../../types/InteractionOptions';
import MessageEmbed from '../../client/MessageEmbed';
import getUser from '../../utils/getUser';
import History from '../../automod/History';
import getMember from '../../utils/getMember';
import ms from 'ms';
import Punishment from '../../models/Punishment';
import { fetchEmoji } from '../../utils/Emoji';
import PunishmentType from '../../types/PunishmentType';

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

    constructor() {
        super('warning', 'moderation', []);
    }

    async list(client: DiscordClient, msg: Message | CommandInteraction, options: CommandOptions | InteractionOptions) {
        if (!options.isInteraction && typeof options.args[0] === 'undefined') {
            await msg.reply({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setDescription(`This command requires an argument.`)
                ]
            });

            return;
        }

        let user: User;

        try {
            user = await (options.isInteraction ? options.options.getUser('user') : (await getUser(client, msg as Message, options)))!;

            if (!user)
                throw new Error();
        }
        catch (e) {
            await msg.reply({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setDescription(`Invalid user given.`)
                ]
            });

            return;
        }

        const warnings = await Punishment.findAll({
            where: {
                guild_id: msg.guild!.id,
                user_id: user.id,
                type: PunishmentType.WARNING
            },
        });

        if (warnings.length < 1) {
            await msg.reply({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setDescription(`No warnings found for that user.`)
                ]
            });

            return;
        }

        let str = '';

        for await (const warning of warnings) {
            str += `ID: ${warning.get().id}\n`;
            str += `Reason: ${warning.get().reason ?? '*No reason provided*'}\n`;

            try {
                str += `Warned by: ${(await client.users.fetch(warning.get().mod_id)).tag}\n`;
            }
            catch (e) {
                str += `Warned by: ${warning.get().mod_id}\n`;
            }
            
            str += `Date: ${warning.get().createdAt}\n\n`;
        }

        await msg.reply({
            embeds: [
                new MessageEmbed()
                .setAuthor({
                    name: user.tag,
                    iconURL: user.displayAvatarURL()
                })
                .setDescription(`**All warnings**\n\n${str}`)
            ]
        });
    }

    async clear(client: DiscordClient, msg: Message | CommandInteraction, options: CommandOptions | InteractionOptions) {
        if (!options.isInteraction && typeof options.args[0] === 'undefined') {
            await msg.reply({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setDescription(`This command requires an argument.`)
                ]
            });

            return;
        }

        let user: User;

        try {
            user = await (options.isInteraction ? options.options.getUser('user') : (await getUser(client, msg as Message, options)))!;

            if (!user)
                throw new Error();
        }
        catch (e) {
            await msg.reply({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setDescription(`Invalid user given.`)
                ]
            });

            return;
        }

        const warning = await Punishment.destroy({
            where: {
                guild_id: msg.guild!.id,
                user_id: user.id,
                type: PunishmentType.WARNING
            },
        });

        if (warning < 1) {
            await msg.reply({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setDescription(`No warnings found for that user.`)
                ]
            });

            return;
        }

        await msg.reply({
            embeds: [
                new MessageEmbed()
                .setColor('GREEN')
                .setDescription(`${(await fetchEmoji('check'))?.toString()} Cleared ${warning} warnings for ${user.tag}`)
            ]
        });
    }

    async remove(client: DiscordClient, msg: Message | CommandInteraction, options: CommandOptions | InteractionOptions) {
        if (!options.isInteraction && typeof options.args[0] === 'undefined') {
            await msg.reply({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setDescription(`This command requires an argument.`)
                ]
            });

            return;
        }

        const id = options.isInteraction ? options.options.getNumber('id') : parseInt(options.args[0]);

        const warning = await Punishment.findOne({
            where: {
                id,
                guild_id: msg.guild!.id,
                type: PunishmentType.WARNING
            },
            order: [
                ['id', 'DESC']
            ],
        });

        if (!warning) {
            await msg.reply({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setDescription(`Invalid warning ID given.`)
                ]
            });

            return;
        }

        await warning.destroy();

        await msg.reply({
            embeds: [
                new MessageEmbed()
                .setColor('GREEN')
                .setDescription(`${(await fetchEmoji('check'))?.toString()} Warning removed successfully!`)
            ]
        });
    }

    async view(client: DiscordClient, msg: Message | CommandInteraction, options: CommandOptions | InteractionOptions) {
        if (!options.isInteraction && typeof options.args[0] === 'undefined') {
            await msg.reply({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setDescription(`This command requires an argument.`)
                ]
            });

            return;
        }

        const id = options.isInteraction ? options.options.getNumber('id') : parseInt(options.args[0]);

        const warning = await Punishment.findOne({
            where: {
                id,
                guild_id: msg.guild!.id,
                type: PunishmentType.WARNING
            },
            order: [
                ['id', 'DESC']
            ],
        });

        if (!warning) {
            await msg.reply({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setDescription(`Invalid warning ID given.`)
                ]
            });

            return;
        }

        let mod: string = warning.get('mod_id') as string; 
        
        try {
            const m = await client.users.fetch(mod);
            mod = m.tag;
        }
        catch (e) {
            
        }

        let user: User | string = warning.get('user_id') as string; 
        
        try {
            user = await client.users.fetch(user);
        }
        catch (e) {
            
        }

        const fields = [
            {
                name: 'Warning ID',
                value: (warning.get('id') as number) + ''
            },
            {
                name: 'Reason',
                value: warning.get('reason') as string|null ?? '*No reason provided*'
            }, 
            {
                name: 'Warned by',
                value: mod
            },
        ];

        console.log(fields);
        

        await msg.reply({
            embeds: [
                new MessageEmbed({
                    author: {
                        name: typeof user === 'string' ? user : user.tag,
                        iconURL: typeof user === 'string' ? undefined : user.displayAvatarURL()
                    },
                    fields,
                })
                .setTimestamp(warning.get('createdAt') as Date)
            ]
        });
    }

    async run(client: DiscordClient, msg: Message | CommandInteraction, options: CommandOptions | InteractionOptions) {
        if (!options.isInteraction && typeof options.args[0] === 'undefined') {
            await msg.reply({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setDescription(`This command requires a subcommand.`)
                ]
            });

            return;
        }

        const subcmd = options.isInteraction ? options.options.getSubcommand(true) : options.args[0];

        if (!['view', 'remove', 'clear', 'list'].includes(subcmd)) {
            await msg.reply({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setDescription(`Invalid subcommand given.`)
                ]
            });

            return;
        }

        if (!options.isInteraction)
            options.args.shift();
        
        await (this as any)[subcmd](client, msg, options);
    }
}
1	rakinar2	577	import { BanOptions, CommandInteraction, Guild, GuildMember, Interaction, Message, User } from 'discord.js';
2			import BaseCommand from '../../utils/structures/BaseCommand';
3			import DiscordClient from '../../client/Client';
4			import CommandOptions from '../../types/CommandOptions';
5			import InteractionOptions from '../../types/InteractionOptions';
6			import MessageEmbed from '../../client/MessageEmbed';
7			import getUser from '../../utils/getUser';
8			import History from '../../automod/History';
9			import getMember from '../../utils/getMember';
10			import ms from 'ms';
11			import Punishment from '../../models/Punishment';
12			import { fetchEmoji } from '../../utils/Emoji';
13			import PunishmentType from '../../types/PunishmentType';
14
15			export default class WarningCommand extends BaseCommand {
16			supportsInteractions: boolean = true;
17
18			constructor() {
19			super('warning', 'moderation', []);
20			}
21
22			async list(client: DiscordClient, msg: Message \| CommandInteraction, options: CommandOptions \| InteractionOptions) {
23			if (!options.isInteraction && typeof options.args[0] === 'undefined') {
24			await msg.reply({
25			embeds: [
26			new MessageEmbed()
27			.setColor('#f14a60')
28			.setDescription(`This command requires an argument.`)
29			]
30			});
31
32			return;
33			}
34
35			let user: User;
36
37			try {
38			user = await (options.isInteraction ? options.options.getUser('user') : (await getUser(client, msg as Message, options)))!;
39
40			if (!user)
41			throw new Error();
42			}
43			catch (e) {
44			await msg.reply({
45			embeds: [
46			new MessageEmbed()
47			.setColor('#f14a60')
48			.setDescription(`Invalid user given.`)
49			]
50			});
51
52			return;
53			}
54
55			const warnings = await Punishment.findAll({
56			where: {
57			guild_id: msg.guild!.id,
58			user_id: user.id,
59			type: PunishmentType.WARNING
60			},
61			});
62
63			if (warnings.length < 1) {
64			await msg.reply({
65			embeds: [
66			new MessageEmbed()
67			.setColor('#f14a60')
68			.setDescription(`No warnings found for that user.`)
69			]
70			});
71
72			return;
73			}
74
75			let str = '';
76
77			for await (const warning of warnings) {
78			str += `ID: ${warning.get().id}\n`;
79			str += `Reason: ${warning.get().reason ?? 'No reason provided'}\n`;
80
81			try {
82			str += `Warned by: ${(await client.users.fetch(warning.get().mod_id)).tag}\n`;
83			}
84			catch (e) {
85			str += `Warned by: ${warning.get().mod_id}\n`;
86			}
87
88			str += `Date: ${warning.get().createdAt}\n\n`;
89			}
90
91			await msg.reply({
92			embeds: [
93			new MessageEmbed()
94			.setAuthor({
95			name: user.tag,
96			iconURL: user.displayAvatarURL()
97			})
98			.setDescription(`All warnings\n\n${str}`)
99			]
100			});
101			}
102
103			async clear(client: DiscordClient, msg: Message \| CommandInteraction, options: CommandOptions \| InteractionOptions) {
104			if (!options.isInteraction && typeof options.args[0] === 'undefined') {
105			await msg.reply({
106			embeds: [
107			new MessageEmbed()
108			.setColor('#f14a60')
109			.setDescription(`This command requires an argument.`)
110			]
111			});
112
113			return;
114			}
115
116			let user: User;
117
118			try {
119			user = await (options.isInteraction ? options.options.getUser('user') : (await getUser(client, msg as Message, options)))!;
120
121			if (!user)
122			throw new Error();
123			}
124			catch (e) {
125			await msg.reply({
126			embeds: [
127			new MessageEmbed()
128			.setColor('#f14a60')
129			.setDescription(`Invalid user given.`)
130			]
131			});
132
133			return;
134			}
135
136			const warning = await Punishment.destroy({
137			where: {
138			guild_id: msg.guild!.id,
139			user_id: user.id,
140			type: PunishmentType.WARNING
141			},
142			});
143
144			if (warning < 1) {
145			await msg.reply({
146			embeds: [
147			new MessageEmbed()
148			.setColor('#f14a60')
149			.setDescription(`No warnings found for that user.`)
150			]
151			});
152
153			return;
154			}
155
156			await msg.reply({
157			embeds: [
158			new MessageEmbed()
159			.setColor('GREEN')
160			.setDescription(`${(await fetchEmoji('check'))?.toString()} Cleared ${warning} warnings for ${user.tag}`)
161			]
162			});
163			}
164
165			async remove(client: DiscordClient, msg: Message \| CommandInteraction, options: CommandOptions \| InteractionOptions) {
166			if (!options.isInteraction && typeof options.args[0] === 'undefined') {
167			await msg.reply({
168			embeds: [
169			new MessageEmbed()
170			.setColor('#f14a60')
171			.setDescription(`This command requires an argument.`)
172			]
173			});
174
175			return;
176			}
177
178			const id = options.isInteraction ? options.options.getNumber('id') : parseInt(options.args[0]);
179
180			const warning = await Punishment.findOne({
181			where: {
182			id,
183			guild_id: msg.guild!.id,
184			type: PunishmentType.WARNING
185			},
186			order: [
187			['id', 'DESC']
188			],
189			});
190
191			if (!warning) {
192			await msg.reply({
193			embeds: [
194			new MessageEmbed()
195			.setColor('#f14a60')
196			.setDescription(`Invalid warning ID given.`)
197			]
198			});
199
200			return;
201			}
202
203			await warning.destroy();
204
205			await msg.reply({
206			embeds: [
207			new MessageEmbed()
208			.setColor('GREEN')
209			.setDescription(`${(await fetchEmoji('check'))?.toString()} Warning removed successfully!`)
210			]
211			});
212			}
213
214			async view(client: DiscordClient, msg: Message \| CommandInteraction, options: CommandOptions \| InteractionOptions) {
215			if (!options.isInteraction && typeof options.args[0] === 'undefined') {
216			await msg.reply({
217			embeds: [
218			new MessageEmbed()
219			.setColor('#f14a60')
220			.setDescription(`This command requires an argument.`)
221			]
222			});
223
224			return;
225			}
226
227			const id = options.isInteraction ? options.options.getNumber('id') : parseInt(options.args[0]);
228
229			const warning = await Punishment.findOne({
230			where: {
231			id,
232			guild_id: msg.guild!.id,
233			type: PunishmentType.WARNING
234			},
235			order: [
236			['id', 'DESC']
237			],
238			});
239
240			if (!warning) {
241			await msg.reply({
242			embeds: [
243			new MessageEmbed()
244			.setColor('#f14a60')
245			.setDescription(`Invalid warning ID given.`)
246			]
247			});
248
249			return;
250			}
251
252			let mod: string = warning.get('mod_id') as string;
253
254			try {
255			const m = await client.users.fetch(mod);
256			mod = m.tag;
257			}
258			catch (e) {
259
260			}
261
262			let user: User \| string = warning.get('user_id') as string;
263
264			try {
265			user = await client.users.fetch(user);
266			}
267			catch (e) {
268
269			}
270
271			const fields = [
272			{
273			name: 'Warning ID',
274			value: (warning.get('id') as number) + ''
275			},
276			{
277			name: 'Reason',
278			value: warning.get('reason') as string\|null ?? 'No reason provided'
279			},
280			{
281			name: 'Warned by',
282			value: mod
283			},
284			];
285
286			console.log(fields);
287
288
289			await msg.reply({
290			embeds: [
291			new MessageEmbed({
292			author: {
293			name: typeof user === 'string' ? user : user.tag,
294			iconURL: typeof user === 'string' ? undefined : user.displayAvatarURL()
295			},
296			fields,
297			})
298			.setTimestamp(warning.get('createdAt') as Date)
299			]
300			});
301			}
302
303			async run(client: DiscordClient, msg: Message \| CommandInteraction, options: CommandOptions \| InteractionOptions) {
304			if (!options.isInteraction && typeof options.args[0] === 'undefined') {
305			await msg.reply({
306			embeds: [
307			new MessageEmbed()
308			.setColor('#f14a60')
309			.setDescription(`This command requires a subcommand.`)
310			]
311			});
312
313			return;
314			}
315
316			const subcmd = options.isInteraction ? options.options.getSubcommand(true) : options.args[0];
317
318			if (!['view', 'remove', 'clear', 'list'].includes(subcmd)) {
319			await msg.reply({
320			embeds: [
321			new MessageEmbed()
322			.setColor('#f14a60')
323			.setDescription(`Invalid subcommand given.`)
324			]
325			});
326
327			return;
328			}
329
330			if (!options.isInteraction)
331			options.args.shift();
332
333			await (this as any)[subcmd](client, msg, options);
334			}
335			}