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 { 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): Promise<CommandReturn> {
        const id = interaction.options.getInteger("id", true);
        let 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()
                ]
            });
        }

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

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