noctbot/src/commands/react.ts

import { client } from "../client";
import { ICommand } from "./command";
import { getRepository } from "typeorm";
import { MessageReaction } from "../entity/MessageReaction";
import { KnownUser } from "../entity/KnownUser";
import { ReactionType, ReactionEmote } from "../entity/ReactionEmote";
import { isAuthorisedAsync } from "../util";

const pattern = /^react to\s+"([^"]+)"\s+with\s+\<:[^:]+:([^\>]+)\>$/i;

async function getRandomEmotes(allowedTypes: ReactionType[], limit: number) {
    let reactionEmotesRepo = getRepository(ReactionEmote);

    let a = await reactionEmotesRepo.query(`
        select reactionId 
        from (  select type, reactionId
                from reaction_emote
                where type in (${allowedTypes.map(s => "?").join(",")})
                order by type, random() )
        group by type
        limit ${limit}`, allowedTypes) as ReactionEmote[];

    return a;
}

export default {
    commands: [
        {
            pattern: "react to",
            action: async (msg, s) => {
                if (!await isAuthorisedAsync(msg.member))
                    return;
                let contents = pattern.exec(s);

                if (contents != null) {
                    let reactable = contents[1].trim().toLowerCase();
                    let reactionEmoji = contents[2];

                    if (!client.emojis.has(reactionEmoji)) {
                        msg.channel.send(`${msg.author.toString()} I cannot react with this emoji :(`);
                        return;
                    }

                    let repo = getRepository(MessageReaction);

                    let message = repo.create({
                        message: reactable,
                        reactionEmoteId: reactionEmoji
                    });
                    await repo.save(message);

                    msg.channel.send(`${msg.author.toString()} Added reaction!`);
                }
            }
        },
        {
            pattern: "remove reaction to",
            action: async (msg, s) => {
                if (!await isAuthorisedAsync(msg.member))
                    return;

                let content = s.substring("remove reaction to ".length).trim().toLowerCase();
                let repo = getRepository(MessageReaction);
                let result = await repo.delete({ message: content });

                if (result.affected == 0) {
                    msg.channel.send(`${msg.author.toString()} No such reaction available!`);
                    return;
                }
                msg.channel.send(`${msg.author.toString()} Removed reaction!`);
            }
        },
        {
            pattern: "reactions",
            action: async msg => {

                let reactionsRepo = getRepository(MessageReaction);
                
                let messages = await reactionsRepo.find({
                    select: [ "message" ]
                });

                let reactions = messages.reduce((p, c) => `${p}\n${c.message}`, "");
                msg.channel.send(`I'll react to the following messages:\n\`\`\`${reactions}\n\`\`\``);
            }
        }
    ],
    documentation: {
        "react to \"<message>\" with <emote>": {
            auth: true,
            description: "React to <message> with <emote>."
        },
        "remove reaction to <message>": {
            auth: true,
            description: "Stops reacting to <message>."
        },
        "reactions": {
            auth: false,
            description: "Lists all known messages this bot can react to."
        }
    },
    onMessage: async (actionsDone, msg, content) => {
        if (actionsDone)
            return false;

        let lowerContent = content.toLowerCase();

        let reactionRepo = getRepository(MessageReaction);
        let usersRepo = getRepository(KnownUser);

        let message = await reactionRepo.findOne({ message: lowerContent });

        if(message) {
            msg.react(client.emojis.get(message.reactionEmoteId));
            return true;
        }

        if (msg.mentions.users.size == 0)
            return false;

        let knownUsers = await usersRepo.find({
            select: [ "mentionReactionType" ],
            where: [...msg.mentions.users.map(u => ({ userID: u.id }))]
        });

        if(knownUsers.length == 0)
            return false;

        let reactionEmoteTypes = new Set<ReactionType>();
        
        for(let user of knownUsers) {
            if(user.mentionReactionType == ReactionType.NONE)
                continue;
            reactionEmoteTypes.add(user.mentionReactionType);
        }

        let randomEmotes = await getRandomEmotes([...reactionEmoteTypes], 5);

        if(randomEmotes.length == 0)
            return false;

        for(let emote of randomEmotes)
            await msg.react(client.emojis.find(e => e.id == emote.reactionId));

        return true;
    },
    onIndirectMention: async (actionsDone, msg) => {
        if (actionsDone)
            return false;
        let emoteType = ReactionType.ANGERY;

        let repo = getRepository(KnownUser);

        let knownUser = await repo.findOne({ 
            select: [ "mentionReactionType" ],
            where: [{userID: msg.id}]
        });

        if(knownUser){
            if(knownUser.mentionReactionType == ReactionType.NONE)
                return false;
            emoteType = knownUser.mentionReactionType;
        }

        let emotes = await getRandomEmotes([ emoteType ], 1);

        if(emotes.length != 1)
            return false;

        let emote = client.emojis.find(e => e.id == emotes[0].reactionId);

        if (!emote) {
            console.log(`WARNING: Emote ${emotes[0]} no longer is valid. Deleting invalid emojis from the list...`);

            let emotesRepo = getRepository(ReactionEmote);
            await emotesRepo.delete({ reactionId: emotes[0].reactionId });
            return false;
        }

        msg.channel.send(emote.toString());
        return true;
    }
} as ICommand;