commands/moderation/SendCommand.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 { APIEmbed, AttachmentPayload, Message, PermissionsBitField, SlashCommandBuilder } from "discord.js";
import Command, { ArgumentType, BasicCommandContext, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
import EmbedSchemaParser from "../../utils/EmbedSchemaParser";
import { userInfo } from "../../utils/embed";
import { logError } from "../../utils/logger";

export default class EchoCommand extends Command {
    public readonly name = "send";
    public readonly validationRules: ValidationRule[] = [
        {
            types: [ArgumentType.User],
            name: "user",
            entity: true,
            errors: {
                "entity:null": "This user does not exist!",
                "type:invalid": "Please provide a valid user to DM!",
                required: "Please provide a user to DM!"
            }
        },
        {
            types: [ArgumentType.StringRest],
            name: "content",
            errors: {
                required: "Please provide the message content!"
            },
            optional: true
        }
    ];
    public readonly permissions = [PermissionsBitField.Flags.ManageMessages];
    public readonly aliases = ["s", "dm", "message", "msg"];

    public readonly description = "Send a DM to a user.";
    public readonly slashCommandBuilder = new SlashCommandBuilder()
        .addUserOption(option => option.setName("user").setDescription("The user to DM"))
        .addStringOption(option => option.setName("content").setDescription("Message content"));

    async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
        await this.deferIfInteraction(message, {
            ephemeral: true
        });

        const user = !context.isLegacy ? context.options.getUser("user") : context.parsedNamedArgs.user;
        const content: string | undefined = !context.isLegacy
            ? context.options.getString("content", true)
            : context.parsedNamedArgs.content;
        const deleteReply =
            this.client.configManager.config[message.guildId!]?.commands?.moderation_command_behaviour === "delete";

        if (!content && message instanceof Message && message.attachments.size === 0) {
            await this.error(message, "Please provide the message content or attachments!");
            return;
        }

        const options = {
            content,
            files:
                message instanceof Message
                    ? message.attachments.map(
                          a =>
                              ({
                                  attachment: a.proxyURL,
                                  name: a.name,
                                  description: a.description
                              } as AttachmentPayload)
                      )
                    : undefined
        };

        let sentMessage: Message<boolean> | undefined = undefined;

        try {
            if (user) {
                sentMessage = await EmbedSchemaParser.sendMessage(user, options);
            }

            if (message instanceof Message) {
                deleteReply && message.deletable
                    ? await message.delete().catch(logError)
                    : await message.react(this.emoji("check"));
            } else {
                await this.deferredReply(message, {
                    content: `Message sent.`
                });
            }
        } catch (e) {
            logError(e);
            await this.error(
                message,
                `Could not deliver DM. Maybe the user does not share any server with me or has blocked me or disabled DMs?`
            );
        }

        const embed: APIEmbed = {};

        await this.sendCommandRanLog(message, embed, {
            previews: [options],
            url: null,
            async before(channel, sentMessages) {
                embed.description = `The message preview is [above](${sentMessages[0]?.url}).`;
            },
            fields(fields) {
                return [
                    ...fields,
                    {
                        name: "User (The person who received the DM)",
                        value: userInfo(user),
                        inline: true
                    }
                ];
            }
        });
    }
}
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 { APIEmbed, AttachmentPayload, Message, PermissionsBitField, SlashCommandBuilder } from "discord.js";
21			import Command, { ArgumentType, BasicCommandContext, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
22			import EmbedSchemaParser from "../../utils/EmbedSchemaParser";
23			import { userInfo } from "../../utils/embed";
24			import { logError } from "../../utils/logger";
25
26			export default class EchoCommand extends Command {
27			public readonly name = "send";
28			public readonly validationRules: ValidationRule[] = [
29			{
30			types: [ArgumentType.User],
31			name: "user",
32			entity: true,
33			errors: {
34			"entity:null": "This user does not exist!",
35			"type:invalid": "Please provide a valid user to DM!",
36			required: "Please provide a user to DM!"
37			}
38			},
39			{
40			types: [ArgumentType.StringRest],
41			name: "content",
42			errors: {
43			required: "Please provide the message content!"
44			},
45			optional: true
46			}
47			];
48			public readonly permissions = [PermissionsBitField.Flags.ManageMessages];
49			public readonly aliases = ["s", "dm", "message", "msg"];
50
51			public readonly description = "Send a DM to a user.";
52			public readonly slashCommandBuilder = new SlashCommandBuilder()
53			.addUserOption(option => option.setName("user").setDescription("The user to DM"))
54			.addStringOption(option => option.setName("content").setDescription("Message content"));
55
56			async execute(message: CommandMessage, context: BasicCommandContext): Promise<CommandReturn> {
57			await this.deferIfInteraction(message, {
58			ephemeral: true
59			});
60
61			const user = !context.isLegacy ? context.options.getUser("user") : context.parsedNamedArgs.user;
62			const content: string \| undefined = !context.isLegacy
63			? context.options.getString("content", true)
64			: context.parsedNamedArgs.content;
65			const deleteReply =
66			this.client.configManager.config[message.guildId!]?.commands?.moderation_command_behaviour === "delete";
67
68			if (!content && message instanceof Message && message.attachments.size === 0) {
69			await this.error(message, "Please provide the message content or attachments!");
70			return;
71			}
72
73			const options = {
74			content,
75			files:
76			message instanceof Message
77			? message.attachments.map(
78			a =>
79			({
80			attachment: a.proxyURL,
81			name: a.name,
82			description: a.description
83			} as AttachmentPayload)
84			)
85			: undefined
86			};
87
88			let sentMessage: Message<boolean> \| undefined = undefined;
89
90			try {
91			if (user) {
92			sentMessage = await EmbedSchemaParser.sendMessage(user, options);
93			}
94
95			if (message instanceof Message) {
96			deleteReply && message.deletable
97			? await message.delete().catch(logError)
98			: await message.react(this.emoji("check"));
99			} else {
100			await this.deferredReply(message, {
101			content: `Message sent.`
102			});
103			}
104			} catch (e) {
105			logError(e);
106			await this.error(
107			message,
108			`Could not deliver DM. Maybe the user does not share any server with me or has blocked me or disabled DMs?`
109			);
110			}
111
112			const embed: APIEmbed = {};
113
114			await this.sendCommandRanLog(message, embed, {
115			previews: [options],
116			url: null,
117			async before(channel, sentMessages) {
118			embed.description = `The message preview is [above](${sentMessages[0]?.url}).`;
119			},
120			fields(fields) {
121			return [
122			...fields,
123			{
124			name: "User (The person who received the DM)",
125			value: userInfo(user),
126			inline: true
127			}
128			];
129			}
130			});
131			}
132			}