discord-starboard-plus/dist/handlers/ReactionAddHandler.js

Discord Starboard Plus: A clean, maintainable starboard system for Discord.js bots. Features per-guild configuration, TypeScript support. Highlight your community's favorite messages with customizable starboards.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ReactionAddHandler = void 0;
const BaseHandler_1 = require("./BaseHandler");
/**
 * Handler for messageReactionAdd events.
 * Creates or updates starboard messages when reactions are added.
 */
class ReactionAddHandler extends BaseHandler_1.BaseHandler {
    /**
     * Handle the messageReactionAdd event.
     */
    async handle(reaction, user) {
        try {
            const message = reaction.message;
            if (!message.guild)
                return;
            const options = this.getOptionsForGuild(message.guild.id);
            if (!this.validation.shouldProcessReaction(reaction, user, options)) {
                return;
            }
            if (message.partial) {
                try {
                    await message.fetch();
                }
                catch (error) {
                    this.logger.error('Failed to fetch partial message', error, {
                        messageId: message.id
                    });
                    return;
                }
            }
            if (!this.validation.isMessageValid(message, options)) {
                return;
            }
            await this.processReaction(reaction, message, options);
        }
        catch (error) {
            this.logger.error('Error handling reaction add', error, {
                messageId: reaction.message?.id
            });
        }
    }
    /**
     * Process a valid reaction.
     */
    async processReaction(reaction, message, options) {
        const starboardChannel = this.validation.getStarboardChannel(message.guild.id, options, this.client);
        if (!starboardChannel)
            return;
        const reactionCount = await this.validation.getValidReactionCount(reaction, options);
        if (reactionCount < options.requiredReactions) {
            return;
        }
        const searchResult = await this.messageSearch.findStarboardMessage(starboardChannel, message.id, options.maxSearchDepth);
        if (searchResult.found && searchResult.message) {
            await this.updateExisting(searchResult.message, reactionCount, options);
        }
        else {
            await this.createNew(starboardChannel, message, reactionCount, options);
        }
    }
    /**
     * Create a new starboard message.
     */
    async createNew(starboardChannel, message, reactionCount, options) {
        try {
            const embedData = this.embedBuilder.createStarboardEmbed(message, reactionCount, options);
            // Build message options based on format
            const messageOptions = {};
            if (embedData.content) {
                messageOptions.content = embedData.content;
            }
            if (embedData.embeds.length > 0) {
                messageOptions.embeds = embedData.embeds;
            }
            if (embedData.components && embedData.components.length > 0) {
                messageOptions.components = embedData.components;
            }
            if (embedData.flags) {
                messageOptions.flags = embedData.flags;
            }
            const starboardMessage = await starboardChannel.send(messageOptions);
            this.logger.success('Message added to starboard', {
                originalId: message.id,
                starboardId: starboardMessage.id,
                reactionCount
            });
        }
        catch (error) {
            this.logger.error('Failed to send starboard message', error, {
                originalId: message.id
            });
        }
    }
    /**
     * Update an existing starboard message.
     */
    async updateExisting(starboardMessage, reactionCount, options) {
        if (!options.updateOnReaction)
            return;
        try {
            const newContent = this.embedBuilder.updateReactionCount(starboardMessage.content, reactionCount);
            await starboardMessage.edit({ content: newContent });
            this.logger.info('Starboard message updated', {
                starboardId: starboardMessage.id,
                newCount: reactionCount
            });
        }
        catch (error) {
            if (error.code === 10008) {
                this.logger.warn('Starboard message was deleted externally', {
                    starboardId: starboardMessage.id
                });
                return;
            }
            this.logger.error('Failed to update starboard message', error, {
                starboardId: starboardMessage.id
            });
        }
    }
}
exports.ReactionAddHandler = ReactionAddHandler;
//# sourceMappingURL=ReactionAddHandler.js.map