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 { logError } from "../../utils/Logger";
import { userInfo } from "../../utils/embed";
import { getEmojiObject } from "../../utils/utils";

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

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

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