commands/moderation/InfractionCreateCommand.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 { InfractionType } from "@prisma/client";
import { ChatInputCommandInteraction, GuildMember, PermissionsBitField } from "discord.js";
import Command, { CommandReturn, ValidationRule } from "../../core/Command";
import { logError } from "../../utils/Logger";
import { stringToTimeInterval } from "../../utils/datetime";

export default class InfractionCreateCommand extends Command {
    public readonly name = "infraction__create";
    public readonly validationRules: ValidationRule[] = [];
    public readonly permissions = [
        PermissionsBitField.Flags.ModerateMembers,
        PermissionsBitField.Flags.ViewAuditLog
    ];
    public readonly supportsLegacy: boolean = false;
    public readonly permissionMode = "or";

    public readonly description = "Create infractions.";
    public readonly detailedDescription = "Create and assign an infraction to someone.";
    public readonly argumentSyntaxes = ["<user> <type> [reason] [duration]"];

    async execute(interaction: ChatInputCommandInteraction): Promise<CommandReturn> {
        const user = interaction.options.getUser("user", true);
        const type = interaction.options.getString("type", true).toUpperCase();
        let reason = interaction.options.getString("reason");
        const duration = interaction.options.getString("duration");
        const parsedDuration = duration ? stringToTimeInterval(duration) : null;

        if (parsedDuration && parsedDuration.error) {
            await interaction.editReply(
                `${this.emoji("error")} ${parsedDuration.error} provided in the \`duration\` field`
            );
            return;
        }

        if (!(type in InfractionType)) {
            await interaction.editReply(
                `${this.emoji("error")} Invalid infraction type provided in the \`type\` field`
            );
            return;
        }

        try {
            const member =
                interaction.guild!.members.cache.get(user.id) ??
                (await interaction.guild!.members.fetch(user.id));

            if (
                !(await this.client.permissionManager.shouldModerate(
                    member,
                    interaction.member! as GuildMember
                ))
            ) {
                await this.error(
                    interaction,
                    "You don't have permission to create infractions for this user!"
                );
                return;
            }
        } catch (e) {
            logError(e);
        }

        if (reason) {
            reason = this.client.infractionManager.processInfractionReason(
                interaction.guildId!,
                reason,
                true
            );
        }

        const infraction = await this.client.prisma.infraction.create({
            data: {
                userId: user.id,
                guildId: interaction.guildId!,
                moderatorId: interaction.user.id,
                type: type as InfractionType,
                reason,
                metadata: parsedDuration?.result
                    ? {
                          duration: parsedDuration.result * 1000
                      }
                    : undefined,
                expiresAt: parsedDuration?.result
                    ? new Date(parsedDuration?.result * 1000 + Date.now())
                    : undefined
            }
        });

        await this.client.loggerService.logInfractionCreate(infraction, user, interaction.user);

        await interaction.editReply({
            embeds: [
                this.client.infractionManager
                    .generateInfractionDetailsEmbed(user, infraction)
                    .setTitle("Infraction Created")
            ]
        });
    }
}
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 { InfractionType } from "@prisma/client";
21	import { ChatInputCommandInteraction, GuildMember, PermissionsBitField } from "discord.js";
22	import Command, { CommandReturn, ValidationRule } from "../../core/Command";
23	import { logError } from "../../utils/Logger";
24	import { stringToTimeInterval } from "../../utils/datetime";
25
26	export default class InfractionCreateCommand extends Command {
27	public readonly name = "infraction__create";
28	public readonly validationRules: ValidationRule[] = [];
29	public readonly permissions = [
30	PermissionsBitField.Flags.ModerateMembers,
31	PermissionsBitField.Flags.ViewAuditLog
32	];
33	public readonly supportsLegacy: boolean = false;
34	public readonly permissionMode = "or";
35
36	public readonly description = "Create infractions.";
37	public readonly detailedDescription = "Create and assign an infraction to someone.";
38	public readonly argumentSyntaxes = ["<user> <type> [reason] [duration]"];
39
40	async execute(interaction: ChatInputCommandInteraction): Promise<CommandReturn> {
41	const user = interaction.options.getUser("user", true);
42	const type = interaction.options.getString("type", true).toUpperCase();
43	let reason = interaction.options.getString("reason");
44	const duration = interaction.options.getString("duration");
45	const parsedDuration = duration ? stringToTimeInterval(duration) : null;
46
47	if (parsedDuration && parsedDuration.error) {
48	await interaction.editReply(
49	`${this.emoji("error")} ${parsedDuration.error} provided in the \`duration\` field`
50	);
51	return;
52	}
53
54	if (!(type in InfractionType)) {
55	await interaction.editReply(
56	`${this.emoji("error")} Invalid infraction type provided in the \`type\` field`
57	);
58	return;
59	}
60
61	try {
62	const member =
63	interaction.guild!.members.cache.get(user.id) ??
64	(await interaction.guild!.members.fetch(user.id));
65
66	if (
67	!(await this.client.permissionManager.shouldModerate(
68	member,
69	interaction.member! as GuildMember
70	))
71	) {
72	await this.error(
73	interaction,
74	"You don't have permission to create infractions for this user!"
75	);
76	return;
77	}
78	} catch (e) {
79	logError(e);
80	}
81
82	if (reason) {
83	reason = this.client.infractionManager.processInfractionReason(
84	interaction.guildId!,
85	reason,
86	true
87	);
88	}
89
90	const infraction = await this.client.prisma.infraction.create({
91	data: {
92	userId: user.id,
93	guildId: interaction.guildId!,
94	moderatorId: interaction.user.id,
95	type: type as InfractionType,
96	reason,
97	metadata: parsedDuration?.result
98	? {
99	duration: parsedDuration.result * 1000
100	}
101	: undefined,
102	expiresAt: parsedDuration?.result
103	? new Date(parsedDuration?.result * 1000 + Date.now())
104	: undefined
105	}
106	});
107
108	await this.client.loggerService.logInfractionCreate(infraction, user, interaction.user);
109
110	await interaction.editReply({
111	embeds: [
112	this.client.infractionManager
113	.generateInfractionDetailsEmbed(user, infraction)
114	.setTitle("Infraction Created")
115	]
116	});
117	}
118	}