Creating Polls

In Seyfert, the ability to create polls is just around the corner!
This section shows the basic creation of polls, events and examples.

Note

In order to receive poll events, some new intents are required.

Gateway Intents

This is an extended section of the configuration file.

seyfert.config.js

module.exports = config.bot({
   //... other options
   intents: ['GuildMessagePolls', 'DirectMessagePolls'],
});

Receiving Events

Currently there are 2 events for polls: messagePollVoteAdd and messagePollVoteRemove.

Caution

If you do not have the specified intents the bot will not be able to receive poll events.

events/addVote.ts

addVote.ts

export default createEvent({
    data: { name: 'messagePollVoteAdd' },
    run: (data) => {
        //You can do whatever you want with the data
        console.log(`The user: ${data.userId} added a vote to the poll: ${data.messageId}`);
    },
});

events/removeVote.ts

removeVote.ts

export default createEvent({
    data: { name: 'messagePollVoteRemove' },
    run: (data) => {
        //You can do whatever you want with the data
        console.log(`The user: ${data.userId} removed a vote to the poll: ${data.messageId}`);
    },
});

Ending Event

The way to check when a poll is ended is to use the messageUpdate event.

Here is a quick example that edits the message when a poll is completed:

messageUpdate.ts

export default createEvent({
    data: { name: 'messageUpdate' },
    //This is [oldMessage, newMessage]
    //But in this example we only need newMessage
    run: ([, newMessage]) => {
        if (newMessage.poll?.results?.isFinalized) {
            console.log(`The poll with the id: ${newMessage.id}'s ended`)
        }
    },
});

Commands

Quick examples on how to create a poll and how to end it.

Caution

The data to obtain from the polls seems to be unstable.
Consider reading the official documentation to learn more.

Note

This goes together with the Commands section.

It’s suppose you have the following directory structure:

• src
• Directorycommands

  • Directorypoll

    • start.command.ts
    • end.command.ts
    • parent.ts
• index.ts
• seyfert.config.js
• package.json
• tsconfig.json

Tip

You can learn more about the PollBuilder.

parent.ts

poll.parent.ts

import { AutoLoad, Declare, Command } from 'seyfert';

@Declare({
    name: 'poll',
    description: 'Poll command!',
})
@AutoLoad()
export default class PollCommand extends Command {}

start.command.ts

start.command.ts

import {
    type CommandContext,
    Declare,
    type OKFunction,
    Options,
    PollBuilder,
    SubCommand,
    createStringOption,
    createNumberOption,
} from 'seyfert';
import { MessageFlags } from 'seyfert/lib/types';

const options = {
    question: createStringOption({
        description: 'Poll question.',
        required: true,
    }),
    answers: createStringOption({
        description: 'Poll answers separated by commas.',
        required: true,
        //This can be improved, but is a quick example
        value: ({ value }, ok: OKFunction<string[] | null>) => {
            //This is to have more options in the poll
            //Example: ganyu, supremacy
            const answers = value.split(', ');
            if (!answers.length) return ok(null);

            return ok(answers);
        },
    }),
    //The poll duration in hours.
    //Example: 1, 2, 5...
    hours: createNumberOption({
        description: 'The duration of the poll.'
    }),
};

@Declare({
    name: 'start',
    description: 'Create a new poll.',
})
@Options(options)
export default class StartPoll extends SubCommand {
    async run(ctx: CommandContext<typeof options>) {
        const { options, channel } = ctx;
        const { question, answers } = options;

        if (!channel?.isTextGuild()) return;
        if (!answers)
            return ctx.editOrReply({
                flags: MessageFlags.Ephemeral,
                content: 'Answers needs to be separed by commas!',
            });

        const hours = options.hours ?? 1;

        //We have a new Builder!
        //PollBuilder will make easier for us to create Polls.
        const newPoll = new PollBuilder()
            .allowMultiselect(true)
            .setQuestion({ text: question })
            .setAnswers(
                //The poll answers
                //With a maximum of 10 answers
                answers.map((text) => ({
                    text,
                    //You can add emojis too!
                    emoji: '🐐'
                }))
            )
            .setDuration(hours);

        await channel.messages.write({
            content: 'New poll started.',
            poll: newPoll
        });

        await ctx.editOrReply({
            flags: MessageFlags.Ephemeral,
            content: `Poll started in the channel: ${channel.toString()}`,
        });
    }
}

end.command.ts

start.command.ts

import {
    type CommandContext,
    Declare,
    Options,
    SubCommand,
    createStringOption
} from 'seyfert';
import { MessageFlags } from 'seyfert/lib/types';

const options = {
    message: createStringOption({
        description: 'The poll\'s message id',
        required: true,
    }),
};

@Declare({
    name: 'end',
    description: 'End a poll.',
})
@Options(options)
export default class EndPoll extends SubCommand {
    async run(ctx: CommandContext<typeof options>) {
        const { options, client } = ctx;
        const { message: messageId } = options;

        await client.messages.endPoll(ctx.channelId, messageId);
        await ctx.editOrReply({
            flags: MessageFlags.Ephemeral,
            content: 'Poll ended.',
        });
    }
}