enigma-bbs/core/node_msg.js

/* jslint node: true */
'use strict';

//  ENiGMA½
const { MenuModule } = require('./menu_module.js');
const {
    getActiveConnectionList,
    getConnectionByNodeId,
    UserMessageableConnections,
} = require('./client_connections.js');
const UserInterruptQueue = require('./user_interrupt_queue.js');
const { getThemeArt } = require('./theme.js');
const { pipeToAnsi } = require('./color_codes.js');
const stringFormat = require('./string_format.js');
const { renderStringLength } = require('./string_util.js');
const Events = require('./events.js');

//  deps
const series = require('async/series');
const _ = require('lodash');
const async = require('async');
const moment = require('moment');

exports.moduleInfo = {
    name: 'Node Message',
    desc: 'Multi-node messaging',
    author: 'NuSkooler',
};

const FormIds = {
    sendMessage: 0,
};

const MciViewIds = {
    sendMessage: {
        nodeSelect: 1,
        message: 2,
        preview: 3,

        customRangeStart: 10,
    },
};

exports.getModule = class NodeMessageModule extends MenuModule {
    constructor(options) {
        super(options);
        this.config = Object.assign({}, _.get(options, 'menuConfig.config'), {
            extraArgs: options.extraArgs,
        });

        this.menuMethods = {
            sendMessage: (formData, extraArgs, cb) => {
                const nodeId = this.nodeList[formData.value.node].node; //  index from from -> node!
                const message = _.get(formData.value, 'message', '').trim();

                if (0 === renderStringLength(message)) {
                    return this.prevMenu(cb);
                }

                this.createInterruptItem(message, (err, interruptItem) => {
                    if (-1 === nodeId) {
                        //  ALL nodes
                        UserInterruptQueue.queue(interruptItem, { omit: this.client });
                    } else {
                        const conn = getConnectionByNodeId(nodeId);
                        if (conn) {
                            UserInterruptQueue.queue(interruptItem, { clients: conn });
                        }
                    }

                    Events.emit(Events.getSystemEvents().UserSendNodeMsg, {
                        user: this.client.user,
                        global: -1 === nodeId,
                    });

                    return this.prevMenu(cb);
                });
            },
        };
    }

    mciReady(mciData, cb) {
        super.mciReady(mciData, err => {
            if (err) {
                return cb(err);
            }

            series(
                [
                    callback => {
                        return this.prepViewController(
                            'sendMessage',
                            FormIds.sendMessage,
                            mciData.menu,
                            callback
                        );
                    },
                    callback => {
                        return this.validateMCIByViewIds(
                            'sendMessage',
                            [
                                MciViewIds.sendMessage.nodeSelect,
                                MciViewIds.sendMessage.message,
                            ],
                            callback
                        );
                    },
                    callback => {
                        const nodeSelectView = this.viewControllers.sendMessage.getView(
                            MciViewIds.sendMessage.nodeSelect
                        );
                        this.prepareNodeList();

                        nodeSelectView.on('index update', idx => {
                            this.nodeListSelectionIndexUpdate(idx);
                        });

                        nodeSelectView.setItems(this.nodeList);
                        nodeSelectView.redraw();
                        this.nodeListSelectionIndexUpdate(0);
                        return callback(null);
                    },
                    callback => {
                        const previewView = this.viewControllers.sendMessage.getView(
                            MciViewIds.sendMessage.preview
                        );
                        if (!previewView) {
                            return callback(null); //  preview is optional
                        }

                        const messageView = this.viewControllers.sendMessage.getView(
                            MciViewIds.sendMessage.message
                        );
                        let timerId;
                        messageView.on(
                            'key press',
                            () => {
                                clearTimeout(timerId);
                                const focused =
                                    this.viewControllers.sendMessage.getFocusedView();
                                if (focused === messageView) {
                                    previewView.setText(messageView.getData());
                                    focused.setFocus(true);
                                }
                            },
                            500
                        );
                    },
                ],
                err => {
                    return cb(err);
                }
            );
        });
    }

    createInterruptItem(message, cb) {
        const dateTimeFormat =
            this.config.dateTimeFormat ||
            this.client.currentTheme.helpers.getDateTimeFormat();

        const textFormatObj = {
            fromUserName: this.client.user.username,
            fromRealName: this.client.user.properties.real_name,
            fromNodeId: this.client.node,
            message: message,
            timestamp: moment().format(dateTimeFormat),
        };

        const messageFormat =
            this.config.messageFormat ||
            'Message from {fromUserName} on node {fromNodeId}:\r\n{message}';

        const item = {
            text: stringFormat(messageFormat, textFormatObj),
            pause: true,
        };

        const getArt = (name, callback) => {
            const spec = _.get(this.config, `art.${name}`);
            if (!spec) {
                return callback(null);
            }
            const getArtOpts = {
                name: spec,
                client: this.client,
                random: false,
            };
            getThemeArt(getArtOpts, (err, artInfo) => {
                //  ignore errors
                return callback(artInfo ? artInfo.data : null);
            });
        };

        async.waterfall(
            [
                callback => {
                    getArt('header', headerArt => {
                        return callback(null, headerArt);
                    });
                },
                (headerArt, callback) => {
                    getArt('footer', footerArt => {
                        return callback(null, headerArt, footerArt);
                    });
                },
                (headerArt, footerArt, callback) => {
                    if (headerArt || footerArt) {
                        item.contents = `${headerArt || ''}\r\n${pipeToAnsi(
                            item.text
                        )}\r\n${footerArt || ''}`;
                    }
                    return callback(null);
                },
            ],
            err => {
                return cb(err, item);
            }
        );
    }

    prepareNodeList() {
        //  standard node list with {text} field added for compliance
        this.nodeList = [
            {
                text: '-ALL-',
                //  dummy fields:
                node: -1,
                authenticated: false,
                userId: 0,
                action: 'N/A',
                userName: 'Everyone',
                realName: 'All Users',
                location: 'N/A',
                affils: 'N/A',
                timeOn: 'N/A',
            },
        ]
            .concat(
                getActiveConnectionList(UserMessageableConnections).map(node =>
                    Object.assign(node, {
                        text: -1 == node.node ? '-ALL-' : node.node.toString(),
                    })
                )
            )
            .filter(node => node.node !== this.client.node); //  remove our client's node
        this.nodeList.sort((a, b) => a.node - b.node); //  sort by node
    }

    nodeListSelectionIndexUpdate(idx) {
        const node = this.nodeList[idx];
        if (!node) {
            return;
        }
        this.updateCustomViewTextsWithFilter(
            'sendMessage',
            MciViewIds.sendMessage.customRangeStart,
            node
        );
    }
};