commands/automation/BallotCommand.ts

/**
* This file is part of SudoBot.
* 
* Copyright (C) 2021-2022 OSN Inc.
*
* 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 { CommandInteraction, EmojiIdentifierResolvable, GuildMember, Message, TextChannel, User } from 'discord.js';
import BaseCommand from '../../utils/structures/BaseCommand';
import DiscordClient from '../../client/Client';
import MessageEmbed from '../../client/MessageEmbed';
import CommandOptions from '../../types/CommandOptions';
import InteractionOptions from '../../types/InteractionOptions';
import { fetchEmoji } from '../../utils/Emoji';
import Ballot from '../../models/Ballot';

export default class BallotCommand extends BaseCommand {
    supportsInteractions = true;

    constructor() {
        super('ballot', 'automation', []);
    }

    async ballotCreate(client: DiscordClient, msg: Message | CommandInteraction, options: CommandOptions | InteractionOptions) {
        if (!options.isInteraction && typeof options.args[0] === 'undefined') {
            await msg.reply({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setDescription(`This command requires at least one argument.`)
                ]
            });

            return;
        }

        if (msg instanceof CommandInteraction)
            await msg.deferReply({
                ephemeral: true
            });

        let content: string;
        let channel: TextChannel = msg.channel as TextChannel;
        let anonymous = false;

        if (options.isInteraction) {
            content = <string> await options.options.getString('content');

            if (options.options.getChannel('channel'))
                channel = <TextChannel> await options.options.getChannel('channel');

            if (options.options.getBoolean('anonymous'))
                anonymous = <boolean> await options.options.getBoolean('anonymous');
        }
        else {
            if ((msg as Message).mentions.channels.last() && /\<#(\d+)\>/g.test([...options.args].pop()!)) {
                channel = <TextChannel> (msg as Message).mentions.channels.last();
                options.args.pop();
            }

            content = await options.args.join(' ').trim();
        }

        if (!channel.send) {
            await this.deferReply(msg, {
                content: 'Invalid text channel.'
            });

            return;
        }
        
        const message = await channel.send({
            embeds: [
                new MessageEmbed()
                .setAuthor({
                    name: anonymous ? 'Staff' : (msg.member?.user as User).tag!,
                    iconURL: anonymous ? msg.guild!.iconURL()! : (msg.member as GuildMember)?.displayAvatarURL()
                })
                .setDescription(content)
                .setTimestamp()
            ]
        });

        const ballot = new Ballot({
            content,
            author: anonymous ? null : msg.member?.user.id,
            msg_id: message.id,
            guild_id: msg.guild!.id,
            date: new Date(),
            channel_id: msg.channel!.id
        });

        await ballot.save();
        
        await message.react(<EmojiIdentifierResolvable> await fetchEmoji('check'));
        await message.react(<EmojiIdentifierResolvable> await fetchEmoji('error'));

        await this.deferReply(msg, {
            content: `${(await fetchEmoji('check'))!.toString()} Your message has been delivered. The ballot ID is ${ballot.get('id')}.`,
        });
    }

    async ballotView(client: DiscordClient, msg: Message | CommandInteraction, options: CommandOptions | InteractionOptions) {
        if (!options.isInteraction && typeof options.args[0] === 'undefined') {
            await msg.reply({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setDescription(`This command requires at least one argument.`)
                ]
            });

            return;
        }
        
        try {
            const id = options.isInteraction ? options.options.getString('id') : options.args[0];
            //const ballot = await client.db.getAsync("SELECT * FROM ballots WHERE id = ? ORDER BY id DESC LIMIT 0, 1", [id]);
            const ballot = await Ballot.findById(id);

            if (!ballot)
                throw new Error();

            const ballotAuthor = ballot.author ? (await msg.guild!.members.fetch(ballot.author)) : null;

            const channel = <TextChannel> await msg.guild?.channels.fetch(ballot.channel_id);
            
            if (!channel)
                throw new Error();

            const message = await channel.messages.fetch(ballot.msg_id);

            if (!message)
                throw new Error();

            const upEmote = await fetchEmoji('check');
            const downEmote = await fetchEmoji('error');
            const upVotes = message.reactions.cache.find(r => r.emoji.id === upEmote!.id)!.count - 1;
            const downVotes = message.reactions.cache.find(r => r.emoji.id === downEmote!.id)!.count - 1;

            await msg.reply({
                embeds: [
                    new MessageEmbed()
                    .setAuthor({
                        name: ballot.author ? ballotAuthor!.user!.tag! : 'Staff',
                        iconURL: ballot.author ? ballotAuthor?.displayAvatarURL()! : msg.guild!.iconURL()!
                    })
                    .setDescription(ballot.content)
                    .addFields([
                        {
                            name: 'Upvotes',
                            value: `${upVotes}`
                        },
                        {
                            name: 'Downvotes',
                            value: `${downVotes}`
                        }
                    ])
                    .setTimestamp()
                ]
            });
        }
        catch (e) {
            console.log(e);
            
            await msg.reply({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setDescription(`Invalid ID or failed to fetch data.`)
                ]
            });
        }
    }

    async run(client: DiscordClient, msg: Message | CommandInteraction, options: CommandOptions | InteractionOptions) {
        if (!options.isInteraction && typeof options.args[0] === 'undefined') {
            await msg.reply({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setDescription(`This command requires at least one subcommand.`)
                ]
            });

            return;
        }

        const subcmd = options.isInteraction ? options.options.getSubcommand(true) : options.args[0];

        if (!options.isInteraction)
            await options.args.shift();

        if (subcmd === 'create') 
            await this.ballotCreate(client, msg, options);
        else if (subcmd === 'view')
            await this.ballotView(client, msg, options);
        else {
            await msg.reply({
                embeds: [
                    new MessageEmbed()
                    .setColor('#f14a60')
                    .setDescription(`Invalid subcommand provided.`)
                ]
            });
        }
    }
}
1	/**
2	* This file is part of SudoBot.
3	*
4	* Copyright (C) 2021-2022 OSN Inc.
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 { CommandInteraction, EmojiIdentifierResolvable, GuildMember, Message, TextChannel, User } from 'discord.js';
21	import BaseCommand from '../../utils/structures/BaseCommand';
22	import DiscordClient from '../../client/Client';
23	import MessageEmbed from '../../client/MessageEmbed';
24	import CommandOptions from '../../types/CommandOptions';
25	import InteractionOptions from '../../types/InteractionOptions';
26	import { fetchEmoji } from '../../utils/Emoji';
27	import Ballot from '../../models/Ballot';
28
29	export default class BallotCommand extends BaseCommand {
30	supportsInteractions = true;
31
32	constructor() {
33	super('ballot', 'automation', []);
34	}
35
36	async ballotCreate(client: DiscordClient, msg: Message \| CommandInteraction, options: CommandOptions \| InteractionOptions) {
37	if (!options.isInteraction && typeof options.args[0] === 'undefined') {
38	await msg.reply({
39	embeds: [
40	new MessageEmbed()
41	.setColor('#f14a60')
42	.setDescription(`This command requires at least one argument.`)
43	]
44	});
45
46	return;
47	}
48
49	if (msg instanceof CommandInteraction)
50	await msg.deferReply({
51	ephemeral: true
52	});
53
54	let content: string;
55	let channel: TextChannel = msg.channel as TextChannel;
56	let anonymous = false;
57
58	if (options.isInteraction) {
59	content = <string> await options.options.getString('content');
60
61	if (options.options.getChannel('channel'))
62	channel = <TextChannel> await options.options.getChannel('channel');
63
64	if (options.options.getBoolean('anonymous'))
65	anonymous = <boolean> await options.options.getBoolean('anonymous');
66	}
67	else {
68	if ((msg as Message).mentions.channels.last() && /\<#(\d+)\>/g.test([...options.args].pop()!)) {
69	channel = <TextChannel> (msg as Message).mentions.channels.last();
70	options.args.pop();
71	}
72
73	content = await options.args.join(' ').trim();
74	}
75
76	if (!channel.send) {
77	await this.deferReply(msg, {
78	content: 'Invalid text channel.'
79	});
80
81	return;
82	}
83
84	const message = await channel.send({
85	embeds: [
86	new MessageEmbed()
87	.setAuthor({
88	name: anonymous ? 'Staff' : (msg.member?.user as User).tag!,
89	iconURL: anonymous ? msg.guild!.iconURL()! : (msg.member as GuildMember)?.displayAvatarURL()
90	})
91	.setDescription(content)
92	.setTimestamp()
93	]
94	});
95
96	const ballot = new Ballot({
97	content,
98	author: anonymous ? null : msg.member?.user.id,
99	msg_id: message.id,
100	guild_id: msg.guild!.id,
101	date: new Date(),
102	channel_id: msg.channel!.id
103	});
104
105	await ballot.save();
106
107	await message.react(<EmojiIdentifierResolvable> await fetchEmoji('check'));
108	await message.react(<EmojiIdentifierResolvable> await fetchEmoji('error'));
109
110	await this.deferReply(msg, {
111	content: `${(await fetchEmoji('check'))!.toString()} Your message has been delivered. The ballot ID is ${ballot.get('id')}.`,
112	});
113	}
114
115	async ballotView(client: DiscordClient, msg: Message \| CommandInteraction, options: CommandOptions \| InteractionOptions) {
116	if (!options.isInteraction && typeof options.args[0] === 'undefined') {
117	await msg.reply({
118	embeds: [
119	new MessageEmbed()
120	.setColor('#f14a60')
121	.setDescription(`This command requires at least one argument.`)
122	]
123	});
124
125	return;
126	}
127
128	try {
129	const id = options.isInteraction ? options.options.getString('id') : options.args[0];
130	//const ballot = await client.db.getAsync("SELECT * FROM ballots WHERE id = ? ORDER BY id DESC LIMIT 0, 1", [id]);
131	const ballot = await Ballot.findById(id);
132
133	if (!ballot)
134	throw new Error();
135
136	const ballotAuthor = ballot.author ? (await msg.guild!.members.fetch(ballot.author)) : null;
137
138	const channel = <TextChannel> await msg.guild?.channels.fetch(ballot.channel_id);
139
140	if (!channel)
141	throw new Error();
142
143	const message = await channel.messages.fetch(ballot.msg_id);
144
145	if (!message)
146	throw new Error();
147
148	const upEmote = await fetchEmoji('check');
149	const downEmote = await fetchEmoji('error');
150	const upVotes = message.reactions.cache.find(r => r.emoji.id === upEmote!.id)!.count - 1;
151	const downVotes = message.reactions.cache.find(r => r.emoji.id === downEmote!.id)!.count - 1;
152
153	await msg.reply({
154	embeds: [
155	new MessageEmbed()
156	.setAuthor({
157	name: ballot.author ? ballotAuthor!.user!.tag! : 'Staff',
158	iconURL: ballot.author ? ballotAuthor?.displayAvatarURL()! : msg.guild!.iconURL()!
159	})
160	.setDescription(ballot.content)
161	.addFields([
162	{
163	name: 'Upvotes',
164	value: `${upVotes}`
165	},
166	{
167	name: 'Downvotes',
168	value: `${downVotes}`
169	}
170	])
171	.setTimestamp()
172	]
173	});
174	}
175	catch (e) {
176	console.log(e);
177
178	await msg.reply({
179	embeds: [
180	new MessageEmbed()
181	.setColor('#f14a60')
182	.setDescription(`Invalid ID or failed to fetch data.`)
183	]
184	});
185	}
186	}
187
188	async run(client: DiscordClient, msg: Message \| CommandInteraction, options: CommandOptions \| InteractionOptions) {
189	if (!options.isInteraction && typeof options.args[0] === 'undefined') {
190	await msg.reply({
191	embeds: [
192	new MessageEmbed()
193	.setColor('#f14a60')
194	.setDescription(`This command requires at least one subcommand.`)
195	]
196	});
197
198	return;
199	}
200
201	const subcmd = options.isInteraction ? options.options.getSubcommand(true) : options.args[0];
202
203	if (!options.isInteraction)
204	await options.args.shift();
205
206	if (subcmd === 'create')
207	await this.ballotCreate(client, msg, options);
208	else if (subcmd === 'view')
209	await this.ballotView(client, msg, options);
210	else {
211	await msg.reply({
212	embeds: [
213	new MessageEmbed()
214	.setColor('#f14a60')
215	.setDescription(`Invalid subcommand provided.`)
216	]
217	});
218	}
219	}
220	}