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	/**
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	}