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