Rocky/command-handler.js at master · Sohel12/Rocky · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
'use strict';

const { sprintf } = require(`sprintf-js`)
    , EventEmitter = require(`eventemitter3`)
    , Discord = require(`discord.js`)
    , BotHelper = require(`./bot-helper`)
    , ConfigProvider = require(`./config/provider`)
    , ConfigParameter = require(`./config/parameter`)
    , CommandHelper = require(`./command-helper`)
    , CommandEventError = require(`./command-event-error`)
    , HelpCommand = require(`./command/help-command`)
    , ConfigCommand = require(`./command/config-command`)
    , UpvoteCommand = require(`./command/upvote-command`)
    , messages = require(`./messages`)
;

const commandEmitter = new EventEmitter();

module.exports = class {

    /**
     * Registers available commands
     */
    static register() {
        commandEmitter.removeAllListeners();

        const commands = [ HelpCommand, ConfigCommand, UpvoteCommand ];
        commands.forEach((command) => {
            command.register(commandEmitter);
        });
    }

    /**
     * @param {string}          commandName
     * @param {Array}           params
     * @param {Discord.Message} message
     */
    static async run(commandName, params, message) {
        const messageAuthorId = BotHelper.getAuthorId(message);
        if (0 === commandEmitter.listenerCount(commandName)) {
            BotHelper.sendMessage(
                message
                , sprintf(
                    messages.unsupportedCommand
                    , messageAuthorId
                    , ConfigProvider.get(ConfigParameter.COMMAND_PREFIX)
                    , commandName
                )
            );
            return;
        }
        try {
            await this.emitEvent(
                commandEmitter
                , CommandHelper.buildPreEventName(commandName)
                , params
                , message
            );
            await this.emitEvent(commandEmitter, commandName, params, message);
            await this.emitEvent(
                commandEmitter
                , CommandHelper.buildPostEventName(commandName)
                , params
                , message
            );
        } catch (err) {
            if (err instanceof CommandEventError) {
                BotHelper.sendMessage(message, err.message);
            } else {
                console.error(err);

                BotHelper.sendMessage(
                    message
                    , sprintf(messages.systemError, messageAuthorId)
                );
            }
        }
    }

    /**
     * Emits events in sync way (wait async one)
     * @param {EventEmitter} emitter
     * @param {string}       eventName
     * @param {Array}        params
     * @returns {Promise<void>}
     */
    static async emitEvent(emitter, eventName, ...params) {
        const events = emitter.listeners(eventName);
        if (0 === events.length) {
            return;
        }

        const commonContext = emitter._events[eventName].context;
        for (let i in events) {
            if (`AsyncFunction` === events[i].constructor.name) {
                await events[i].apply(
                    commonContext || emitter._events[eventName][i].context
                    , params
                );
            } else {
                events[i].apply(
                    commonContext || emitter._events[eventName][i].context
                    , params
                );
            }
        }
    }

};