enigma-bbs/core/predefined_mci.js

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

//  ENiGMA½
const Config                            = require('./config.js').get;
const Log                               = require('./logger.js').log;
const getMessageAreaByTag               = require('./message_area.js').getMessageAreaByTag;
const getMessageConferenceByTag         = require('./message_area.js').getMessageConferenceByTag;
const clientConnections                 = require('./client_connections.js');
const StatLog                           = require('./stat_log.js');
const FileBaseFilters                   = require('./file_base_filter.js');
const formatByteSize                    = require('./string_util.js').formatByteSize;

//  deps
const packageJson           = require('../package.json');
const os                    = require('os');
const _                     = require('lodash');
const moment                = require('moment');

exports.getPredefinedMCIValue   = getPredefinedMCIValue;
exports.init                    = init;

function init(cb) {
    setNextRandomRumor(cb);
}

function setNextRandomRumor(cb) {
    StatLog.getSystemLogEntries('system_rumorz', StatLog.Order.Random, 1, (err, entry) => {
        if(entry) {
            entry = entry[0];
        }
        const randRumor = entry && entry.log_value ? entry.log_value : '';
        StatLog.setNonPeristentSystemStat('random_rumor', randRumor);
        if(cb) {
            return cb(null);
        }
    });
}

function getUserRatio(client, propA, propB) {
    const a = StatLog.getUserStatNum(client.user, propA);
    const b = StatLog.getUserStatNum(client.user, propB);
    const ratio = ~~((a / b) * 100);
    return `${ratio}%`;
}

function userStatAsString(client, statName, defaultValue) {
    return (StatLog.getUserStat(client.user, statName) || defaultValue).toLocaleString();
}

function sysStatAsString(statName, defaultValue) {
    return (StatLog.getSystemStat(statName) || defaultValue).toLocaleString();
}

const PREDEFINED_MCI_GENERATORS = {
    //
    //  Board
    //
    BN  : function boardName() { return Config().general.boardName; },

    //  ENiGMA
    VL  : function versionLabel() { return 'ENiGMA½ v' + packageJson.version; },
    VN  : function version() { return packageJson.version; },

    //  +op info
    SN  : function opUserName() { return StatLog.getSystemStat('sysop_username'); },
    SR  : function opRealName() { return StatLog.getSystemStat('sysop_real_name'); },
    SL  : function opLocation() { return StatLog.getSystemStat('sysop_location'); },
    SA  : function opAffils() { return StatLog.getSystemStat('sysop_affiliation'); },
    SS  : function opSex() { return StatLog.getSystemStat('sysop_sex'); },
    SE  : function opEmail() { return StatLog.getSystemStat('sysop_email_address'); },
    //  :TODO: op age, web, ?????

    //
    //  Current user / session
    //
    UN  : function userName(client) { return client.user.username; },
    UI  : function userId(client) { return client.user.userId.toString(); },
    UG  : function groups(client) { return _.values(client.user.groups).join(', '); },
    UR  : function realName(client) { return userStatAsString(client, 'real_name', ''); },
    LO  : function location(client) { return userStatAsString(client, 'location', ''); },
    UA  : function age(client) { return client.user.getAge().toString(); },
    BD  : function birthdate(client) { return moment(client.user.properties.birthdate).format(client.currentTheme.helpers.getDateFormat()); },  //  iNiQUiTY
    US  : function sex(client) { return userStatAsString(client, 'sex', ''); },
    UE  : function emailAddres(client) { return userStatAsString(client, 'email_address', ''); },
    UW  : function webAddress(client) { return userStatAsString(client, 'web_address', ''); },
    UF  : function affils(client) { return userStatAsString(client, 'affiliation', ''); },
    UT  : function themeId(client) { return userStatAsString(client, 'theme_id', ''); },
    UC  : function loginCount(client) { return userStatAsString(client, 'login_count', 0); },
    ND  : function connectedNode(client) { return client.node.toString(); },
    IP  : function clientIpAddress(client) { return client.remoteAddress.replace(/^::ffff:/, ''); },    //  convert any :ffff: IPv4's to 32bit version
    ST  : function serverName(client) { return client.session.serverName; },
    FN  : function activeFileBaseFilterName(client) {
        const activeFilter = FileBaseFilters.getActiveFilter(client);
        return activeFilter ? activeFilter.name : '';
    },
    DN  : function userNumDownloads(client) { return userStatAsString(client, 'dl_total_count', 0); },      //  Obv/2
    DK  : function userByteDownload(client) {   //  Obv/2 uses DK=downloaded Kbytes
        const byteSize = StatLog.getUserStatNum(client.user, 'dl_total_bytes');
        return formatByteSize(byteSize, true);  //  true=withAbbr
    },
    UP  : function userNumUploads(client) { return userStatAsString(client, 'ul_total_count', 0); },            //  Obv/2
    UK  : function userByteUpload(client) { //  Obv/2 uses UK=uploaded Kbytes
        const byteSize = StatLog.getUserStatNum(client.user, 'ul_total_bytes');
        return formatByteSize(byteSize, true);  //  true=withAbbr
    },
    NR  : function userUpDownRatio(client) {    //  Obv/2
        return getUserRatio(client, 'ul_total_count', 'dl_total_count');
    },
    KR  : function userUpDownByteRatio(client) {    //  Obv/2 uses KR=upload/download Kbyte ratio
        return getUserRatio(client, 'ul_total_bytes', 'dl_total_bytes');
    },

    MS  : function accountCreatedclient(client) { return moment(client.user.properties.account_created).format(client.currentTheme.helpers.getDateFormat()); },
    PS  : function userPostCount(client) { return userStatAsString(client, 'post_count', 0); },
    PC  : function userPostCallRatio(client) { return getUserRatio(client, 'post_count', 'login_count'); },

    MD  : function currentMenuDescription(client) {
        return _.has(client, 'currentMenuModule.menuConfig.desc') ? client.currentMenuModule.menuConfig.desc : '';
    },

    MA  : function messageAreaName(client) {
        const area = getMessageAreaByTag(client.user.properties.message_area_tag);
        return area ? area.name : '';
    },
    MC  : function messageConfName(client) {
        const conf = getMessageConferenceByTag(client.user.properties.message_conf_tag);
        return conf ? conf.name : '';
    },
    ML  : function messageAreaDescription(client) {
        const area = getMessageAreaByTag(client.user.properties.message_area_tag);
        return area ? area.desc : '';
    },
    CM  : function messageConfDescription(client) {
        const conf = getMessageConferenceByTag(client.user.properties.message_conf_tag);
        return conf ? conf.desc : '';
    },

    SH  : function termHeight(client) { return client.term.termHeight.toString(); },
    SW  : function termWidth(client) { return client.term.termWidth.toString(); },

    //
    //  Date/Time
    //
    //  :TODO: change to CD for 'Current Date'
    DT  : function date(client) { return moment().format(client.currentTheme.helpers.getDateFormat()); },
    CT  : function time(client) { return moment().format(client.currentTheme.helpers.getTimeFormat()) ;},

    //
    //  OS/System Info
    //
    OS  : function operatingSystem() {
        return {
            linux   : 'Linux',
            darwin  : 'Mac OS X',
            win32   : 'Windows',
            sunos   : 'SunOS',
            freebsd : 'FreeBSD',
        }[os.platform()] || os.type();
    },

    OA  : function systemArchitecture() { return os.arch(); },

    SC  : function systemCpuModel() {
        //
        //  Clean up CPU strings a bit for better display
        //
        return os.cpus()[0].model
            .replace(/\(R\)|\(TM\)|processor|CPU/g, '')
            .replace(/\s+(?= )/g, '');
    },

    //  :TODO: MCI for core count, e.g. os.cpus().length

    //  :TODO: cpu load average (over N seconds): http://stackoverflow.com/questions/9565912/convert-the-output-of-os-cpus-in-node-js-to-percentage
    NV  : function nodeVersion() { return process.version; },

    AN  : function activeNodes() { return clientConnections.getActiveConnections().length.toString(); },

    TC  : function totalCalls() { return StatLog.getSystemStat('login_count').toLocaleString(); },

    RR  : function randomRumor() {
        //  start the process of picking another random one
        setNextRandomRumor();

        return StatLog.getSystemStat('random_rumor');
    },

    //
    //  System File Base, Up/Download Info
    //
    //  :TODO: DD - Today's # of downloads (iNiQUiTY)
    //
    SD  : function systemNumDownloads() { return sysStatAsString('dl_total_count', 0); },
    SO  : function systemByteDownload() {
        const byteSize = StatLog.getSystemStatNum('dl_total_bytes');
        return formatByteSize(byteSize, true);  //  true=withAbbr
    },
    SU  : function systemNumUploads() { return sysStatAsString('ul_total_count', 0); },
    SP  : function systemByteUpload() {
        const byteSize = StatLog.getSystemStatNum('ul_total_bytes');
        return formatByteSize(byteSize, true);  //  true=withAbbr
    },
    TF  : function totalFilesOnSystem() {
        const areaStats = StatLog.getSystemStat('file_base_area_stats');
        return _.get(areaStats, 'totalFiles', 0).toLocaleString();
    },
    TB  : function totalBytesOnSystem() {
        const areaStats     = StatLog.getSystemStat('file_base_area_stats');
        const totalBytes    = parseInt(_.get(areaStats, 'totalBytes', 0));
        return formatByteSize(totalBytes, true);    //  true=withAbbr
    },

    //  :TODO: PT - Messages posted *today* (Obv/2)
    //      -> Include FTN/etc.
    //  :TODO: NT - New users today (Obv/2)
    //  :TODO: CT - Calls *today* (Obv/2)
    //  :TODO: FT - Files uploaded/added *today* (Obv/2)
    //  :TODO: DD - Files downloaded *today* (iNiQUiTY)
    //  :TODO: TP - total message/posts on the system (Obv/2)
    //      -> Include FTN/etc.
    //  :TODO: LC - name of last caller to system (Obv/2)
    //  :TODO: TZ - Average *system* post/call ratio (iNiQUiTY)


    //
    //  Special handling for XY
    //
    XY  : function xyHack() { return; /* nothing */ },
};

function getPredefinedMCIValue(client, code) {

    if(!client || !code) {
        return;
    }

    const generator = PREDEFINED_MCI_GENERATORS[code];

    if(generator) {
        let value;
        try {
            value = generator(client);
        } catch(e) {
            Log.error( { code : code, exception : e.message }, 'Exception caught generating predefined MCI value' );
        }

        return value;
    }
}