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	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 { 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			}