commands/moderation/InfractionEditCommand.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 { ChatInputCommandInteraction, EmbedBuilder, PermissionsBitField } from "discord.js";
import Command, { CommandReturn, ValidationRule } from "../../core/Command";
import { ChatInputCommandContext } from "../../services/CommandManager";
import { stringToTimeInterval } from "../../utils/datetime";
import { safeUserFetch } from "../../utils/fetch";

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

    public readonly description = "Edit infractions.";
    public readonly detailedDescription = "Update an infraction with a new reason or duration or both.";
    public readonly argumentSyntaxes = ["<infraction_id> [new_reason] [new_duration]"];

    async execute(interaction: ChatInputCommandInteraction, context: ChatInputCommandContext): Promise<CommandReturn> {
        const id = interaction.options.getInteger("id", true);
        const newReason = interaction.options.getString("new_reason");
        const newDuration = interaction.options.getString("new_duration");

        if (!newReason && !newDuration) {
            await interaction.editReply(
                `${this.emoji("error")} Either provide a reason or duration or both to update this infraction, if it exists!`
            );
            return;
        }

        const newDurationSeconds = newDuration ? stringToTimeInterval(newDuration) : undefined;
        const silent = interaction.options.getBoolean("silent") ?? true;

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

        const infraction = await this.client.prisma.infraction.findFirst({
            where: { id, guildId: interaction.guildId! }
        });

        if (!infraction) {
            await interaction.editReply(`${this.emoji("error")} Could not find an infraction with that ID!`);
            return;
        }

        if (newDurationSeconds?.result && infraction.expiresAt && infraction.expiresAt.getTime() <= Date.now()) {
            await interaction.editReply(`${this.emoji("error")} That infraction is expired, so you can't change it's duration!`);
            return;
        }

        if (newDurationSeconds?.result && infraction.createdAt.getTime() + newDurationSeconds?.result * 1000 <= Date.now()) {
            await interaction.editReply(
                `${this.emoji(
                    "error"
                )} That duration makes the infraction expire in the past, which is not possible! Please make sure the time of infraction creation plus the new duration is greater than the current time!`
            );
            return;
        }

        if (newDurationSeconds?.result && infraction.expiresAt === null) {
            await interaction.editReply(
                `${this.emoji("error")} This infraction did not have a duration in the first place, so you can't set one now.`
            );

            return;
        }

        const user = await safeUserFetch(this.client, infraction.userId);

        if (newDurationSeconds && infraction.queueId) {
            const queue = this.client.queueManager.queues.get(`${infraction.queueId}`);

            if (queue) {
                await queue.updateTime(new Date(infraction.createdAt.getTime() + newDurationSeconds.result * 1000));
            }
        }

        if (!silent) {
            await user?.send({
                embeds: [
                    new EmbedBuilder({
                        author: {
                            icon_url: interaction.guild?.iconURL() ?? undefined,
                            name: "Your infraction has been updated in " + interaction.guild!.name
                        },
                        color: 0xf14a60,
                        fields: [
                            ...(newReason
                                ? [
                                      {
                                          name: "Reason",
                                          value: newReason
                                      }
                                  ]
                                : []),
                            ...(newDurationSeconds?.result
                                ? [
                                      {
                                          name: "Duration",
                                          value: formatDistanceToNowStrict(
                                              new Date(infraction.createdAt.getTime() + newDurationSeconds.result * 1000)
                                          )
                                      }
                                  ]
                                : []),
                            {
                                name: "Infraction ID",
                                value: id.toString()
                            }
                        ]
                    }).setTimestamp()
                ]
            });
        }

        await this.client.prisma.infraction.update({
            data: {
                reason: newReason ?? undefined,
                expiresAt: newDurationSeconds
                    ? new Date(infraction.createdAt.getTime() + newDurationSeconds.result * 1000)
                    : undefined
            },
            where: { id }
        });

        await interaction.editReply({
            embeds: [
                new EmbedBuilder({
                    title: "Infraction update",
                    description: "Updated successfully!",
                    color: 0x007bff,
                    fields: [
                        ...(newReason
                            ? [
                                  {
                                      name: "New Reason",
                                      value: newReason
                                  }
                              ]
                            : []),
                        ...(newDurationSeconds?.result
                            ? [
                                  {
                                      name: "New Duration",
                                      value: formatDistanceToNowStrict(
                                          new Date(infraction.createdAt.getTime() + newDurationSeconds.result * 1000)
                                      )
                                  }
                              ]
                            : []),
                        {
                            name: "ID",
                            value: id.toString()
                        },
                        {
                            name: "Notifying User?",
                            value: silent ? "No" : "Yes",
                            inline: true
                        }
                    ],
                    footer: {
                        text: "Updated"
                    }
                }).setTimestamp()
            ]
        });
    }
}
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 { ChatInputCommandInteraction, EmbedBuilder, PermissionsBitField } from "discord.js";
22	import Command, { CommandReturn, ValidationRule } from "../../core/Command";
23	import { ChatInputCommandContext } from "../../services/CommandManager";
24	import { stringToTimeInterval } from "../../utils/datetime";
25	import { safeUserFetch } from "../../utils/fetch";
26
27	export default class InfractionEditCommand extends Command {
28	public readonly name = "infraction__edit";
29	public readonly validationRules: ValidationRule[] = [];
30	public readonly permissions = [PermissionsBitField.Flags.ModerateMembers, PermissionsBitField.Flags.ViewAuditLog];
31	public readonly permissionMode = "or";
32	public readonly supportsLegacy: boolean = false;
33
34	public readonly description = "Edit infractions.";
35	public readonly detailedDescription = "Update an infraction with a new reason or duration or both.";
36	public readonly argumentSyntaxes = ["<infraction_id> [new_reason] [new_duration]"];
37
38	async execute(interaction: ChatInputCommandInteraction, context: ChatInputCommandContext): Promise<CommandReturn> {
39	const id = interaction.options.getInteger("id", true);
40	const newReason = interaction.options.getString("new_reason");
41	const newDuration = interaction.options.getString("new_duration");
42
43	if (!newReason && !newDuration) {
44	await interaction.editReply(
45	`${this.emoji("error")} Either provide a reason or duration or both to update this infraction, if it exists!`
46	);
47	return;
48	}
49
50	const newDurationSeconds = newDuration ? stringToTimeInterval(newDuration) : undefined;
51	const silent = interaction.options.getBoolean("silent") ?? true;
52
53	if (newDurationSeconds && newDurationSeconds.error) {
54	await interaction.editReply(
55	`${this.emoji("error")} ${newDurationSeconds.error} provided in the \`new_duration\` field`
56	);
57	return;
58	}
59
60	const infraction = await this.client.prisma.infraction.findFirst({
61	where: { id, guildId: interaction.guildId! }
62	});
63
64	if (!infraction) {
65	await interaction.editReply(`${this.emoji("error")} Could not find an infraction with that ID!`);
66	return;
67	}
68
69	if (newDurationSeconds?.result && infraction.expiresAt && infraction.expiresAt.getTime() <= Date.now()) {
70	await interaction.editReply(`${this.emoji("error")} That infraction is expired, so you can't change it's duration!`);
71	return;
72	}
73
74	if (newDurationSeconds?.result && infraction.createdAt.getTime() + newDurationSeconds?.result * 1000 <= Date.now()) {
75	await interaction.editReply(
76	`${this.emoji(
77	"error"
78	)} That duration makes the infraction expire in the past, which is not possible! Please make sure the time of infraction creation plus the new duration is greater than the current time!`
79	);
80	return;
81	}
82
83	if (newDurationSeconds?.result && infraction.expiresAt === null) {
84	await interaction.editReply(
85	`${this.emoji("error")} This infraction did not have a duration in the first place, so you can't set one now.`
86	);
87
88	return;
89	}
90
91	const user = await safeUserFetch(this.client, infraction.userId);
92
93	if (newDurationSeconds && infraction.queueId) {
94	const queue = this.client.queueManager.queues.get(`${infraction.queueId}`);
95
96	if (queue) {
97	await queue.updateTime(new Date(infraction.createdAt.getTime() + newDurationSeconds.result * 1000));
98	}
99	}
100
101	if (!silent) {
102	await user?.send({
103	embeds: [
104	new EmbedBuilder({
105	author: {
106	icon_url: interaction.guild?.iconURL() ?? undefined,
107	name: "Your infraction has been updated in " + interaction.guild!.name
108	},
109	color: 0xf14a60,
110	fields: [
111	...(newReason
112	? [
113	{
114	name: "Reason",
115	value: newReason
116	}
117	]
118	: []),
119	...(newDurationSeconds?.result
120	? [
121	{
122	name: "Duration",
123	value: formatDistanceToNowStrict(
124	new Date(infraction.createdAt.getTime() + newDurationSeconds.result * 1000)
125	)
126	}
127	]
128	: []),
129	{
130	name: "Infraction ID",
131	value: id.toString()
132	}
133	]
134	}).setTimestamp()
135	]
136	});
137	}
138
139	await this.client.prisma.infraction.update({
140	data: {
141	reason: newReason ?? undefined,
142	expiresAt: newDurationSeconds
143	? new Date(infraction.createdAt.getTime() + newDurationSeconds.result * 1000)
144	: undefined
145	},
146	where: { id }
147	});
148
149	await interaction.editReply({
150	embeds: [
151	new EmbedBuilder({
152	title: "Infraction update",
153	description: "Updated successfully!",
154	color: 0x007bff,
155	fields: [
156	...(newReason
157	? [
158	{
159	name: "New Reason",
160	value: newReason
161	}
162	]
163	: []),
164	...(newDurationSeconds?.result
165	? [
166	{
167	name: "New Duration",
168	value: formatDistanceToNowStrict(
169	new Date(infraction.createdAt.getTime() + newDurationSeconds.result * 1000)
170	)
171	}
172	]
173	: []),
174	{
175	name: "ID",
176	value: id.toString()
177	},
178	{
179	name: "Notifying User?",
180	value: silent ? "No" : "Yes",
181	inline: true
182	}
183	],
184	footer: {
185	text: "Updated"
186	}
187	}).setTimestamp()
188	]
189	});
190	}
191	}