commands/moderation/SnipeCommand.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 { EmbedBuilder, Message, PartialMessage, PermissionsBitField, Snowflake } from "discord.js";
import Command, { AnyCommandContext, ArgumentType, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
import { GatewayEventListener } from "../../decorators/GatewayEventListener";
import { HasEventListeners } from "../../types/HasEventListeners";
import { isTextableChannel } from "../../utils/utils";

interface MessageInfo<T extends boolean = false> extends Message<T> {
    deletedAt?: Date;
}

export default class SnipeCommand extends Command implements HasEventListeners {
    public readonly name = "snipe";
    public readonly validationRules: ValidationRule[] = [
        {
            types: [ArgumentType.Integer],
            optional: true,
            errors: {
                "type:invalid": "You must provide a valid message index/number between 1-10!",
                "number:range": "You must provide a valid message index/number between 1-10!"
            },
            number: {
                max: 11,
                min: 1
            },
            default: null,
            name: "index"
        }
    ];
    public readonly permissions = [PermissionsBitField.Flags.ManageMessages];
    public readonly argumentSyntaxes = ["[index=1]"];
    public readonly aliases = ["clearsnipe", "cs", "delsnipe", "csnipe", "s", "ces", "ceditsnipe", "es", "editsnipe", "esnipe"];
    public readonly since: string = "4.4.0";
    protected readonly lastDeletedMessages = new Map<Snowflake, Array<MessageInfo<boolean>>>();
    protected readonly lastEditedMessages = new Map<Snowflake, Array<[MessageInfo<boolean>, MessageInfo<boolean>]>>();

    public readonly description = "Reposts the last deleted/edited message.";

    @GatewayEventListener("messageDelete")
    onMessageDelete(message: Message<boolean> | PartialMessage) {
        if (message.author?.bot || !message.content || !isTextableChannel(message.channel)) {
            return;
        }

        const deletedMessages = this.lastDeletedMessages.get(message.guildId!);

        if (deletedMessages === undefined) {
            this.lastDeletedMessages.set(message.guildId!, [{ ...message, deletedAt: new Date() } as MessageInfo]);
        } else {
            if (deletedMessages.length > 10) deletedMessages.pop();
            deletedMessages.unshift({ ...message, deletedAt: new Date() } as MessageInfo);
        }
    }

    @GatewayEventListener("messageUpdate")
    onMessageUpdate(oldMessage: Message<boolean> | PartialMessage, newMessage: Message<boolean> | PartialMessage) {
        if (
            newMessage.author?.bot ||
            !newMessage.content ||
            !isTextableChannel(newMessage.channel) ||
            oldMessage.content === newMessage.content
        ) {
            return;
        }

        const editedMessages = this.lastEditedMessages.get(newMessage.guildId!);

        if (editedMessages === undefined) {
            this.lastEditedMessages.set(newMessage.guildId!, [[oldMessage as MessageInfo, newMessage as MessageInfo]]);
        } else {
            if (editedMessages.length > 10) editedMessages.pop();
            editedMessages.unshift([oldMessage as MessageInfo, newMessage as MessageInfo]);
        }
    }

    async execute(message: CommandMessage, context: AnyCommandContext): Promise<CommandReturn> {
        const index = context.isLegacy ? (context.parsedNamedArgs.index ?? 1) - 1 : 0;
        const editSnipe = context.isLegacy && ["es", "editsnipe", "esnipe", "ces", "ceditsnipe"].includes(context.argv[0]);
        const messages = (editSnipe ? this.lastEditedMessages : this.lastDeletedMessages).get(message.guildId!);
        const lastMessage = editSnipe
            ? (messages?.[index] as [MessageInfo, MessageInfo])?.[1]
            : (messages?.[index] as MessageInfo);

        if (messages?.length && index >= messages?.length) {
            await this.error(
                message,
                `Invalid message index - only ${messages.length} ${editSnipe ? "edited" : "deleted"} message${
                    messages.length === 1 ? " is" : "s are"
                } have been recorded so far.`
            );
            return;
        }

        if (!lastMessage) {
            await this.error(message, `No ${editSnipe ? "edited" : "deleted"} message was recorded yet.`);
            return;
        }

        if (context.isLegacy && ["clearsnipe", "cs", "delsnipe", "csnipe", "ces", "ceditsnipe"].includes(context.argv[0])) {
            const hasValue = context.args[0] !== undefined;

            if (!hasValue) {
                messages?.splice(0, messages.length);
                await this.success(message, "Cleared sniped messages for this server.");
            } else {
                messages?.splice(index, 1);
                await this.success(message, "Removed the given sniped message for this server.");
            }

            return;
        }

        const date = editSnipe ? (messages?.[index] as [Message, Message])[1].editedAt! : lastMessage.deletedAt;

        return {
            __reply: true,
            embeds: [
                new EmbedBuilder({
                    author: {
                        name: lastMessage.author?.username ?? "Unknown",
                        iconURL: lastMessage.author?.displayAvatarURL()
                    },
                    color: Math.floor(Math.random() * 0xffffff),
                    footer: {
                        text: `Sniped${
                            date
                                ? ` • ${editSnipe ? "Edited" : "Deleted"} ${formatDistanceToNowStrict(date, { addSuffix: true })}`
                                : ""
                        } • ${messages?.length ?? 0} ${editSnipe ? "edited" : "deleted"} message${
                            messages?.length === 1 ? "" : "s"
                        } total`
                    },
                    ...(editSnipe
                        ? {
                              fields: [
                                  {
                                      name: "Before",
                                      value: (messages?.[index] as [Message, Message])[0].content || "*No content*"
                                  },
                                  {
                                      name: "After",
                                      value: (messages?.[index] as [Message, Message])[1].content || "*No content*"
                                  }
                              ]
                          }
                        : {
                              description: lastMessage.content!
                          })
                })
            ]
        };
    }
}
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 { EmbedBuilder, Message, PartialMessage, PermissionsBitField, Snowflake } from "discord.js";
22			import Command, { AnyCommandContext, ArgumentType, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
23			import { GatewayEventListener } from "../../decorators/GatewayEventListener";
24			import { HasEventListeners } from "../../types/HasEventListeners";
25			import { isTextableChannel } from "../../utils/utils";
26
27			interface MessageInfo<T extends boolean = false> extends Message<T> {
28			deletedAt?: Date;
29			}
30
31			export default class SnipeCommand extends Command implements HasEventListeners {
32			public readonly name = "snipe";
33			public readonly validationRules: ValidationRule[] = [
34			{
35			types: [ArgumentType.Integer],
36			optional: true,
37			errors: {
38			"type:invalid": "You must provide a valid message index/number between 1-10!",
39			"number:range": "You must provide a valid message index/number between 1-10!"
40			},
41			number: {
42			max: 11,
43			min: 1
44			},
45			default: null,
46			name: "index"
47			}
48			];
49			public readonly permissions = [PermissionsBitField.Flags.ManageMessages];
50			public readonly argumentSyntaxes = ["[index=1]"];
51			public readonly aliases = ["clearsnipe", "cs", "delsnipe", "csnipe", "s", "ces", "ceditsnipe", "es", "editsnipe", "esnipe"];
52			public readonly since: string = "4.4.0";
53			protected readonly lastDeletedMessages = new Map<Snowflake, Array<MessageInfo<boolean>>>();
54			protected readonly lastEditedMessages = new Map<Snowflake, Array<[MessageInfo<boolean>, MessageInfo<boolean>]>>();
55
56			public readonly description = "Reposts the last deleted/edited message.";
57
58			@GatewayEventListener("messageDelete")
59			onMessageDelete(message: Message<boolean> \| PartialMessage) {
60			if (message.author?.bot \|\| !message.content \|\| !isTextableChannel(message.channel)) {
61			return;
62			}
63
64			const deletedMessages = this.lastDeletedMessages.get(message.guildId!);
65
66			if (deletedMessages === undefined) {
67			this.lastDeletedMessages.set(message.guildId!, [{ ...message, deletedAt: new Date() } as MessageInfo]);
68			} else {
69			if (deletedMessages.length > 10) deletedMessages.pop();
70			deletedMessages.unshift({ ...message, deletedAt: new Date() } as MessageInfo);
71			}
72			}
73
74			@GatewayEventListener("messageUpdate")
75			onMessageUpdate(oldMessage: Message<boolean> \| PartialMessage, newMessage: Message<boolean> \| PartialMessage) {
76			if (
77			newMessage.author?.bot \|\|
78			!newMessage.content \|\|
79			!isTextableChannel(newMessage.channel) \|\|
80			oldMessage.content === newMessage.content
81			) {
82			return;
83			}
84
85			const editedMessages = this.lastEditedMessages.get(newMessage.guildId!);
86
87			if (editedMessages === undefined) {
88			this.lastEditedMessages.set(newMessage.guildId!, [[oldMessage as MessageInfo, newMessage as MessageInfo]]);
89			} else {
90			if (editedMessages.length > 10) editedMessages.pop();
91			editedMessages.unshift([oldMessage as MessageInfo, newMessage as MessageInfo]);
92			}
93			}
94
95			async execute(message: CommandMessage, context: AnyCommandContext): Promise<CommandReturn> {
96			const index = context.isLegacy ? (context.parsedNamedArgs.index ?? 1) - 1 : 0;
97			const editSnipe = context.isLegacy && ["es", "editsnipe", "esnipe", "ces", "ceditsnipe"].includes(context.argv[0]);
98			const messages = (editSnipe ? this.lastEditedMessages : this.lastDeletedMessages).get(message.guildId!);
99			const lastMessage = editSnipe
100			? (messages?.[index] as [MessageInfo, MessageInfo])?.[1]
101			: (messages?.[index] as MessageInfo);
102
103			if (messages?.length && index >= messages?.length) {
104			await this.error(
105			message,
106			`Invalid message index - only ${messages.length} ${editSnipe ? "edited" : "deleted"} message${
107			messages.length === 1 ? " is" : "s are"
108			} have been recorded so far.`
109			);
110			return;
111			}
112
113			if (!lastMessage) {
114			await this.error(message, `No ${editSnipe ? "edited" : "deleted"} message was recorded yet.`);
115			return;
116			}
117
118			if (context.isLegacy && ["clearsnipe", "cs", "delsnipe", "csnipe", "ces", "ceditsnipe"].includes(context.argv[0])) {
119			const hasValue = context.args[0] !== undefined;
120
121			if (!hasValue) {
122			messages?.splice(0, messages.length);
123			await this.success(message, "Cleared sniped messages for this server.");
124			} else {
125			messages?.splice(index, 1);
126			await this.success(message, "Removed the given sniped message for this server.");
127			}
128
129			return;
130			}
131
132			const date = editSnipe ? (messages?.[index] as [Message, Message])[1].editedAt! : lastMessage.deletedAt;
133
134			return {
135			__reply: true,
136			embeds: [
137			new EmbedBuilder({
138			author: {
139			name: lastMessage.author?.username ?? "Unknown",
140			iconURL: lastMessage.author?.displayAvatarURL()
141			},
142			color: Math.floor(Math.random() * 0xffffff),
143			footer: {
144			text: `Sniped${
145			date
146			? ` • ${editSnipe ? "Edited" : "Deleted"} ${formatDistanceToNowStrict(date, { addSuffix: true })}`
147			: ""
148			} • ${messages?.length ?? 0} ${editSnipe ? "edited" : "deleted"} message${
149			messages?.length === 1 ? "" : "s"
150			} total`
151			},
152			...(editSnipe
153			? {
154			fields: [
155			{
156			name: "Before",
157			value: (messages?.[index] as [Message, Message])[0].content \|\| "No content"
158			},
159			{
160			name: "After",
161			value: (messages?.[index] as [Message, Message])[1].content \|\| "No content"
162			}
163			]
164			}
165			: {
166			description: lastMessage.content!
167			})
168			})
169			]
170			};
171			}
172			}