enigma-bbs/core/achievement.js

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

//  ENiGMA½
const Events = require('./events.js');
const Config = require('./config.js').get;
const ConfigLoader = require('./config_loader');
const { getConfigPath } = require('./config_util');
const UserDb = require('./database.js').dbs.user;
const { getISOTimestampString } = require('./database.js');
const UserInterruptQueue = require('./user_interrupt_queue.js');
const { getConnectionByUserId } = require('./client_connections.js');
const UserProps = require('./user_property.js');
const { Errors, ErrorReasons } = require('./enig_error.js');
const { getThemeArt } = require('./theme.js');
const { pipeToAnsi, stripMciColorCodes } = require('./color_codes.js');
const stringFormat = require('./string_format.js');
const StatLog = require('./stat_log.js');
const Log = require('./logger.js').log;

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

exports.getAchievementsEarnedByUser = getAchievementsEarnedByUser;

class Achievement {
    constructor(data) {
        this.data = data;

        //  achievements are retroactive by default
        this.data.retroactive = _.get(this.data, 'retroactive', true);
    }

    static factory(data) {
        if (!data) {
            return;
        }
        let achievement;
        switch (data.type) {
            case Achievement.Types.UserStatSet:
            case Achievement.Types.UserStatInc:
            case Achievement.Types.UserStatIncNewVal:
                achievement = new UserStatAchievement(data);
                break;

            default:
                return;
        }

        if (achievement.isValid()) {
            return achievement;
        }
    }

    static get Types() {
        return {
            UserStatSet: 'userStatSet',
            UserStatInc: 'userStatInc',
            UserStatIncNewVal: 'userStatIncNewVal',
        };
    }

    isValid() {
        switch (this.data.type) {
            case Achievement.Types.UserStatSet:
            case Achievement.Types.UserStatInc:
            case Achievement.Types.UserStatIncNewVal:
                if (!_.isString(this.data.statName)) {
                    return false;
                }
                if (!_.isObject(this.data.match)) {
                    return false;
                }
                break;

            default:
                return false;
        }
        return true;
    }

    getMatchDetails(/*matchAgainst*/) {}

    isValidMatchDetails(details) {
        if (
            !details ||
            !_.isString(details.title) ||
            !_.isString(details.text) ||
            !_.isNumber(details.points)
        ) {
            return false;
        }
        return _.isString(details.globalText) || !details.globalText;
    }
}

class UserStatAchievement extends Achievement {
    constructor(data) {
        super(data);

        //  sort match keys for quick match lookup
        this.matchKeys = Object.keys(this.data.match || {})
            .map(k => parseInt(k))
            .sort((a, b) => b - a);
    }

    isValid() {
        if (!super.isValid()) {
            return false;
        }
        return !Object.keys(this.data.match).some(k => !parseInt(k));
    }

    getMatchDetails(matchValue) {
        let ret = [];
        let matchField = this.matchKeys.find(v => matchValue >= v);
        if (matchField) {
            const match = this.data.match[matchField];
            matchField = parseInt(matchField);
            if (this.isValidMatchDetails(match) && !isNaN(matchField)) {
                ret = [match, matchField, matchValue];
            }
        }
        return ret;
    }
}

class Achievements {
    constructor(events) {
        this.events = events;
        this.enabled = false;
    }

    getAchievementByTag(tag) {
        return this.config.get().achievements[tag];
    }

    isEnabled() {
        return this.enabled;
    }

    init(cb) {
        const configPath = this._getConfigPath();
        if (!configPath) {
            Log.info('Achievements are not configured');
            return cb(null);
        }

        const configLoaded = () => {
            if (true !== this.config.get().enabled) {
                Log.info('Achievements are not enabled');
                this.enabled = false;
                this.stopMonitoringUserStatEvents();
            } else {
                Log.info('Achievements are enabled');
                this.enabled = true;
                this.monitorUserStatEvents();
            }
        };

        this.config = new ConfigLoader({
            onReload: err => {
                if (!err) {
                    configLoaded();
                }
            },
        });

        this.config.init(configPath, err => {
            if (err) {
                return cb(err);
            }

            configLoaded();
            return cb(null);
        });
    }

    _getConfigPath() {
        const path = _.get(Config(), 'general.achievementFile');
        if (!path) {
            return;
        }
        return getConfigPath(path); //  qualify
    }

    loadAchievementHitCount(user, achievementTag, field, cb) {
        UserDb.get(
            `SELECT COUNT() AS count
            FROM user_achievement
            WHERE user_id = ? AND achievement_tag = ? AND match = ?;`,
            [user.userId, achievementTag, field],
            (err, row) => {
                return cb(err, row ? row.count : 0);
            }
        );
    }

    record(info, localInterruptItem, cb) {
        StatLog.incrementUserStat(info.client.user, UserProps.AchievementTotalCount, 1);
        StatLog.incrementUserStat(
            info.client.user,
            UserProps.AchievementTotalPoints,
            info.details.points
        );

        const cleanTitle = stripMciColorCodes(localInterruptItem.title);
        const cleanText = stripMciColorCodes(localInterruptItem.achievText);

        const recordData = [
            info.client.user.userId,
            info.achievementTag,
            getISOTimestampString(info.timestamp),
            info.matchField,
            cleanTitle,
            cleanText,
            info.details.points,
        ];

        UserDb.run(
            `INSERT OR IGNORE INTO user_achievement (user_id, achievement_tag, timestamp, match, title, text, points)
            VALUES (?, ?, ?, ?, ?, ?, ?);`,
            recordData,
            err => {
                if (err) {
                    return cb(err);
                }

                this.events.emit(Events.getSystemEvents().UserAchievementEarned, {
                    user: info.client.user,
                    achievementTag: info.achievementTag,
                    points: info.details.points,
                    title: cleanTitle,
                    text: cleanText,
                });

                return cb(null);
            }
        );
    }

    display(info, interruptItems, cb) {
        if (interruptItems.local) {
            UserInterruptQueue.queue(interruptItems.local, { clients: info.client });
        }

        if (interruptItems.global) {
            UserInterruptQueue.queue(interruptItems.global, { omit: info.client });
        }

        return cb(null);
    }

    recordAndDisplayAchievement(info, cb) {
        async.waterfall(
            [
                callback => {
                    return this.createAchievementInterruptItems(info, callback);
                },
                (interruptItems, callback) => {
                    this.record(info, interruptItems.local, err => {
                        return callback(err, interruptItems);
                    });
                },
                (interruptItems, callback) => {
                    return this.display(info, interruptItems, callback);
                },
            ],
            err => {
                return cb(err);
            }
        );
    }

    monitorUserStatEvents() {
        if (this.userStatEventListeners) {
            return; //  already listening
        }

        const listenEvents = [
            Events.getSystemEvents().UserStatSet,
            Events.getSystemEvents().UserStatIncrement,
        ];

        this.userStatEventListeners = this.events.addMultipleEventListener(
            listenEvents,
            userStatEvent => {
                if (
                    [
                        UserProps.AchievementTotalCount,
                        UserProps.AchievementTotalPoints,
                    ].includes(userStatEvent.statName)
                ) {
                    return;
                }

                if (
                    !_.isNumber(userStatEvent.statValue) &&
                    !_.isNumber(userStatEvent.statIncrementBy)
                ) {
                    return;
                }

                //  :TODO: Make this code generic - find + return factory created object
                const achievementTags = Object.keys(
                    _.pickBy(
                        _.get(this.config.get(), 'achievements', {}),
                        achievement => {
                            if (false === achievement.enabled) {
                                return false;
                            }
                            const acceptedTypes = [
                                Achievement.Types.UserStatSet,
                                Achievement.Types.UserStatInc,
                                Achievement.Types.UserStatIncNewVal,
                            ];
                            return (
                                acceptedTypes.includes(achievement.type) &&
                                achievement.statName === userStatEvent.statName
                            );
                        }
                    )
                );

                if (0 === achievementTags.length) {
                    return;
                }

                async.eachSeries(
                    achievementTags,
                    (achievementTag, nextAchievementTag) => {
                        const achievement = Achievement.factory(
                            this.getAchievementByTag(achievementTag)
                        );
                        if (!achievement) {
                            return nextAchievementTag(null);
                        }

                        const statValue = parseInt(
                            [
                                Achievement.Types.UserStatSet,
                                Achievement.Types.UserStatIncNewVal,
                            ].includes(achievement.data.type)
                                ? userStatEvent.statValue
                                : userStatEvent.statIncrementBy
                        );
                        if (isNaN(statValue)) {
                            return nextAchievementTag(null);
                        }

                        const [details, matchField, matchValue] =
                            achievement.getMatchDetails(statValue);
                        if (!details) {
                            return nextAchievementTag(null);
                        }

                        async.waterfall(
                            [
                                callback => {
                                    this.loadAchievementHitCount(
                                        userStatEvent.user,
                                        achievementTag,
                                        matchField,
                                        (err, count) => {
                                            if (err) {
                                                return callback(err);
                                            }
                                            return callback(
                                                count > 0
                                                    ? Errors.General(
                                                          'Achievement already acquired',
                                                          ErrorReasons.TooMany
                                                      )
                                                    : null
                                            );
                                        }
                                    );
                                },
                                callback => {
                                    const client = getConnectionByUserId(
                                        userStatEvent.user.userId
                                    );
                                    if (!client) {
                                        return callback(
                                            Errors.UnexpectedState(
                                                'Failed to get client for user ID'
                                            )
                                        );
                                    }

                                    const info = {
                                        achievementTag,
                                        achievement,
                                        details,
                                        client,
                                        matchField, //  match - may be in odd format
                                        matchValue, //  actual value
                                        achievedValue: matchField, //  achievement value met
                                        user: userStatEvent.user,
                                        timestamp: moment(),
                                    };

                                    const achievementsInfo = [info];
                                    return callback(null, achievementsInfo, info);
                                },
                                (achievementsInfo, basicInfo, callback) => {
                                    if (true !== achievement.data.retroactive) {
                                        return callback(null, achievementsInfo);
                                    }

                                    const index = achievement.matchKeys.findIndex(
                                        v => v < matchField
                                    );
                                    if (
                                        -1 === index ||
                                        !Array.isArray(achievement.matchKeys)
                                    ) {
                                        return callback(null, achievementsInfo);
                                    }

                                    //  For userStat, any lesser match keys(values) are also met. Example:
                                    //  matchKeys: [ 500, 200, 100, 20, 10, 2 ]
                                    //                    ^---- we met here
                                    //                         ^------------^ retroactive range
                                    //
                                    async.eachSeries(
                                        achievement.matchKeys.slice(index),
                                        (k, nextKey) => {
                                            const [det, fld, val] =
                                                achievement.getMatchDetails(k);
                                            if (!det) {
                                                return nextKey(null);
                                            }

                                            this.loadAchievementHitCount(
                                                userStatEvent.user,
                                                achievementTag,
                                                fld,
                                                (err, count) => {
                                                    if (!err || (count && 0 === count)) {
                                                        achievementsInfo.push(
                                                            Object.assign({}, basicInfo, {
                                                                details: det,
                                                                matchField: fld,
                                                                achievedValue: fld,
                                                                matchValue: val,
                                                            })
                                                        );
                                                    }

                                                    return nextKey(null);
                                                }
                                            );
                                        },
                                        () => {
                                            return callback(null, achievementsInfo);
                                        }
                                    );
                                },
                                (achievementsInfo, callback) => {
                                    //  reverse achievementsInfo so we display smallest > largest
                                    achievementsInfo.reverse();

                                    async.eachSeries(
                                        achievementsInfo,
                                        (achInfo, nextAchInfo) => {
                                            return this.recordAndDisplayAchievement(
                                                achInfo,
                                                err => {
                                                    return nextAchInfo(err);
                                                }
                                            );
                                        },
                                        err => {
                                            return callback(err);
                                        }
                                    );
                                },
                            ],
                            err => {
                                if (err && ErrorReasons.TooMany !== err.reasonCode) {
                                    Log.warn(
                                        { error: err.message, userStatEvent },
                                        'Error handling achievement for user stat event'
                                    );
                                }
                                return nextAchievementTag(null); //  always try the next, regardless
                            }
                        );
                    }
                );
            }
        );
    }

    stopMonitoringUserStatEvents() {
        if (this.userStatEventListeners) {
            this.events.removeMultipleEventListener(this.userStatEventListeners);
            delete this.userStatEventListeners;
        }
    }

    getFormatObject(info) {
        return {
            userName: info.user.username,
            userRealName: info.user.properties[UserProps.RealName],
            userLocation: info.user.properties[UserProps.Location],
            userAffils: info.user.properties[UserProps.Affiliations],
            nodeId: info.client.node,
            title: info.details.title,
            //text            : info.global ? info.details.globalText : info.details.text,
            points: info.details.points,
            achievedValue: info.achievedValue,
            matchField: info.matchField,
            matchValue: info.matchValue,
            timestamp: moment(info.timestamp).format(info.dateTimeFormat),
            boardName: Config().general.boardName,
        };
    }

    getFormattedTextFor(info, textType, defaultSgr = '|07') {
        const themeDefaults = _.get(
            info.client.currentTheme,
            'achievements.defaults',
            {}
        );
        const textTypeSgr = themeDefaults[`${textType}SGR`] || defaultSgr;

        const formatObj = this.getFormatObject(info);

        const wrap = input => {
            const re = new RegExp(`{(${Object.keys(formatObj).join('|')})([^}]*)}`, 'g');
            return input.replace(re, (m, formatVar, formatOpts) => {
                const varSgr = themeDefaults[`${formatVar}SGR`] || textTypeSgr;
                let r = `${varSgr}{${formatVar}`;
                if (formatOpts) {
                    r += formatOpts;
                }
                return `${r}}${textTypeSgr}`;
            });
        };

        return stringFormat(`${textTypeSgr}${wrap(info.details[textType])}`, formatObj);
    }

    createAchievementInterruptItems(info, cb) {
        info.dateTimeFormat =
            info.details.dateTimeFormat ||
            info.achievement.dateTimeFormat ||
            info.client.currentTheme.helpers.getDateTimeFormat();

        const title = this.getFormattedTextFor(info, 'title');
        const text = this.getFormattedTextFor(info, 'text');

        let globalText;
        if (info.details.globalText) {
            globalText = this.getFormattedTextFor(info, 'globalText');
        }

        const getArt = (name, callback) => {
            const spec =
                _.get(info.details, `art.${name}`) ||
                _.get(info.achievement, `art.${name}`) ||
                _.get(this.config.get(), `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);
            });
        };

        const interruptItems = {};
        let itemTypes = ['local'];
        if (globalText) {
            itemTypes.push('global');
        }

        async.each(
            itemTypes,
            (itemType, nextItemType) => {
                async.waterfall(
                    [
                        callback => {
                            getArt(`${itemType}Header`, headerArt => {
                                return callback(null, headerArt);
                            });
                        },
                        (headerArt, callback) => {
                            getArt(`${itemType}Footer`, footerArt => {
                                return callback(null, headerArt, footerArt);
                            });
                        },
                        (headerArt, footerArt, callback) => {
                            const itemText = 'global' === itemType ? globalText : text;
                            interruptItems[itemType] = {
                                title,
                                achievText: itemText,
                                text: `${title}\r\n${itemText}`,
                                pause: true,
                            };
                            if (headerArt || footerArt) {
                                const themeDefaults = _.get(
                                    info.client.currentTheme,
                                    'achievements.defaults',
                                    {}
                                );
                                const defaultContentsFormat = '{title}\r\n{message}';
                                const contentsFormat =
                                    'global' === itemType
                                        ? themeDefaults.globalFormat ||
                                          defaultContentsFormat
                                        : themeDefaults.format || defaultContentsFormat;

                                const formatObj = Object.assign(
                                    this.getFormatObject(info),
                                    {
                                        title: this.getFormattedTextFor(
                                            info,
                                            'title',
                                            ''
                                        ), //  ''=defaultSgr
                                        message: itemText,
                                    }
                                );

                                const contents = pipeToAnsi(
                                    stringFormat(contentsFormat, formatObj)
                                );

                                interruptItems[itemType].contents = `${
                                    headerArt || ''
                                }\r\n${contents}\r\n${footerArt || ''}`;
                            }
                            return callback(null);
                        },
                    ],
                    err => {
                        return nextItemType(err);
                    }
                );
            },
            err => {
                return cb(err, interruptItems);
            }
        );
    }
}

let achievementsInstance;

function getAchievementsEarnedByUser(userId, cb) {
    if (!achievementsInstance) {
        return cb(Errors.UnexpectedState('Achievements not initialized'));
    }

    UserDb.all(
        `SELECT achievement_tag, timestamp, match, title, text, points
        FROM user_achievement
        WHERE user_id = ?
        ORDER BY DATETIME(timestamp);`,
        [userId],
        (err, rows) => {
            if (err) {
                return cb(err);
            }

            const earned = rows
                .map(row => {
                    const achievement = Achievement.factory(
                        achievementsInstance.getAchievementByTag(row.achievement_tag)
                    );
                    if (!achievement) {
                        return;
                    }

                    const earnedInfo = {
                        achievementTag: row.achievement_tag,
                        type: achievement.data.type,
                        retroactive: achievement.data.retroactive,
                        title: row.title,
                        text: row.text,
                        points: row.points,
                        timestamp: moment(row.timestamp),
                    };

                    switch (earnedInfo.type) {
                        case [Achievement.Types.UserStatSet]:
                        case [Achievement.Types.UserStatInc]:
                        case [Achievement.Types.UserStatIncNewVal]:
                            earnedInfo.statName = achievement.data.statName;
                            break;
                    }

                    return earnedInfo;
                })
                .filter(a => a); //  remove any empty records (ie: no achievement.hjson entry exists anymore).

            return cb(null, earned);
        }
    );
}

exports.moduleInitialize = (initInfo, cb) => {
    achievementsInstance = new Achievements(initInfo.events);
    achievementsInstance.init(err => {
        if (err) {
            return cb(err);
        }

        return cb(null);
    });
};