enigma-bbs/core/onelinerz.js

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

//  ENiGMA½
const MenuModule            = require('./menu_module.js').MenuModule;

const {
    getModDatabasePath,
    getTransactionDatabase
}                           = require('./database.js');

const ViewController        = require('./view_controller.js').ViewController;
const theme                 = require('./theme.js');
const ansi                  = require('./ansi_term.js');
const stringFormat          = require('./string_format.js');

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

/*
    Module :TODO:
    * Add pipe code support
        - override max length & monitor *display* len as user types in order to allow for actual display len with color
    * Add preview control: Shows preview with pipe codes resolved
    * Add ability to at least alternate formatStrings -- every other
*/


exports.moduleInfo = {
    name        : 'Onelinerz',
    desc        : 'Standard local onelinerz',
    author      : 'NuSkooler',
    packageName : 'codes.l33t.enigma.onelinerz',
};

const MciViewIds = {
    ViewForm    :  {
        Entries     : 1,
        AddPrompt   : 2,
    },
    AddForm : {
        NewEntry        : 1,
        EntryPreview    : 2,
        AddPrompt       : 3,
    }
};

const FormIds = {
    View    : 0,
    Add     : 1,
};

exports.getModule = class OnelinerzModule extends MenuModule {
    constructor(options) {
        super(options);

        const self = this;

        this.menuMethods = {
            viewAddScreen : function(formData, extraArgs, cb) {
                return self.displayAddScreen(cb);
            },

            addEntry : function(formData, extraArgs, cb) {
                if(_.isString(formData.value.oneliner) && formData.value.oneliner.length > 0) {
                    const oneliner = formData.value.oneliner.trim();    //  remove any trailing ws

                    self.storeNewOneliner(oneliner, err => {
                        if(err) {
                            self.client.log.warn( { error : err.message }, 'Failed saving oneliner');
                        }

                        self.clearAddForm();
                        return self.displayViewScreen(true, cb);    //  true=cls
                    });

                } else {
                    //  empty message - treat as if cancel was hit
                    return self.displayViewScreen(true, cb);    //  true=cls
                }
            },

            cancelAdd : function(formData, extraArgs, cb) {
                self.clearAddForm();
                return self.displayViewScreen(true, cb);    //  true=cls
            }
        };
    }

    initSequence() {
        const self = this;
        async.series(
            [
                function beforeDisplayArt(callback) {
                    return self.beforeArt(callback);
                },
                function display(callback) {
                    return self.displayViewScreen(false, callback);
                }
            ],
            err => {
                if(err) {
                    //  :TODO: Handle me -- initSequence() should really take a completion callback
                }
                self.finishedLoading();
            }
        );
    }

    displayViewScreen(clearScreen, cb) {
        const self = this;

        async.waterfall(
            [
                function clearAndDisplayArt(callback) {
                    if(self.viewControllers.add) {
                        self.viewControllers.add.setFocus(false);
                    }

                    if(clearScreen) {
                        self.client.term.rawWrite(ansi.resetScreen());
                    }

                    theme.displayThemedAsset(
                        self.menuConfig.config.art.entries,
                        self.client,
                        { font : self.menuConfig.font, trailingLF : false },
                        (err, artData) => {
                            return callback(err, artData);
                        }
                    );
                },
                function initOrRedrawViewController(artData, callback) {
                    if(_.isUndefined(self.viewControllers.add)) {
                        const vc = self.addViewController(
                            'view',
                            new ViewController( { client : self.client, formId : FormIds.View } )
                        );

                        const loadOpts = {
                            callingMenu     : self,
                            mciMap          : artData.mciMap,
                            formId          : FormIds.View,
                        };

                        return vc.loadFromMenuConfig(loadOpts, callback);
                    } else {
                        self.viewControllers.view.setFocus(true);
                        self.viewControllers.view.getView(MciViewIds.ViewForm.AddPrompt).redraw();
                        return callback(null);
                    }
                },
                function fetchEntries(callback) {
                    const entriesView = self.viewControllers.view.getView(MciViewIds.ViewForm.Entries);
                    const limit = entriesView.dimens.height;
                    let entries = [];

                    self.db.each(
                        `SELECT *
                        FROM (
                            SELECT * 
                            FROM onelinerz
                            ORDER BY timestamp DESC
                            LIMIT ${limit}
                            )
                        ORDER BY timestamp ASC;`,
                        (err, row) => {
                            if(!err) {
                                row.timestamp = moment(row.timestamp);  //  convert -> moment
                                entries.push(row);
                            }
                        },
                        err => {
                            return callback(err, entriesView, entries);
                        }
                    );
                },
                function populateEntries(entriesView, entries, callback) {
                    const listFormat    = self.menuConfig.config.listFormat || '{username}@{ts}: {oneliner}';// :TODO: should be userName to be consistent
                    const tsFormat      = self.menuConfig.config.timestampFormat || 'ddd h:mma';

                    entriesView.setItems(entries.map( e => {
                        return stringFormat(listFormat, {
                            userId      : e.user_id,
                            username    : e.user_name,
                            oneliner    : e.oneliner,
                            ts          : e.timestamp.format(tsFormat),
                        } );
                    }));

                    entriesView.redraw();

                    return callback(null);
                },
                function finalPrep(callback) {
                    const promptView = self.viewControllers.view.getView(MciViewIds.ViewForm.AddPrompt);
                    promptView.setFocusItemIndex(1);    //  default to NO
                    return callback(null);
                }
            ],
            err => {
                if(cb) {
                    return cb(err);
                }
            }
        );
    }

    displayAddScreen(cb) {
        const self = this;

        async.waterfall(
            [
                function clearAndDisplayArt(callback) {
                    self.viewControllers.view.setFocus(false);
                    self.client.term.rawWrite(ansi.resetScreen());

                    theme.displayThemedAsset(
                        self.menuConfig.config.art.add,
                        self.client,
                        { font : self.menuConfig.font },
                        (err, artData) => {
                            return callback(err, artData);
                        }
                    );
                },
                function initOrRedrawViewController(artData, callback) {
                    if(_.isUndefined(self.viewControllers.add)) {
                        const vc = self.addViewController(
                            'add',
                            new ViewController( { client : self.client, formId : FormIds.Add } )
                        );

                        const loadOpts = {
                            callingMenu     : self,
                            mciMap          : artData.mciMap,
                            formId          : FormIds.Add,
                        };

                        return vc.loadFromMenuConfig(loadOpts, callback);
                    } else {
                        self.viewControllers.add.setFocus(true);
                        self.viewControllers.add.redrawAll();
                        self.viewControllers.add.switchFocus(MciViewIds.AddForm.NewEntry);
                        return callback(null);
                    }
                }
            ],
            err => {
                if(cb) {
                    return cb(err);
                }
            }
        );
    }

    clearAddForm() {
        this.setViewText('add', MciViewIds.AddForm.NewEntry, '');
        this.setViewText('add', MciViewIds.AddForm.EntryPreview, '');
    }

    initDatabase(cb) {
        const self = this;

        async.series(
            [
                function openDatabase(callback) {
                    self.db = getTransactionDatabase(new sqlite3.Database(
                        getModDatabasePath(exports.moduleInfo),
                        err => {
                            return callback(err);
                        }
                    ));
                },
                function createTables(callback) {
                    self.db.run(
                        `CREATE TABLE IF NOT EXISTS onelinerz (
                            id              INTEGER PRIMARY KEY,
                            user_id         INTEGER_NOT NULL,
                            user_name       VARCHAR NOT NULL,                               
                            oneliner        VARCHAR NOT NULL,
                            timestamp       DATETIME NOT NULL
                        );`
                        ,
                        err => {
                            return callback(err);
                        });
                }
            ],
            err => {
                return cb(err);
            }
        );
    }

    storeNewOneliner(oneliner, cb) {
        const self  = this;
        const ts    = moment().format('YYYY-MM-DDTHH:mm:ss.SSSZ');

        async.series(
            [
                function addRec(callback) {
                    self.db.run(
                        `INSERT INTO onelinerz (user_id, user_name, oneliner, timestamp)
                        VALUES (?, ?, ?, ?);`,
                        [ self.client.user.userId, self.client.user.username, oneliner, ts ],
                        callback
                    );
                },
                function removeOld(callback) {
                    //  keep 25 max most recent items - remove the older ones
                    self.db.run(
                        `DELETE FROM onelinerz
                        WHERE id IN (
                            SELECT id
                            FROM onelinerz
                            ORDER BY id DESC
                            LIMIT -1 OFFSET 25
                        );`,
                        callback
                    );
                }
            ],
            err => {
                return cb(err);
            }
        );
    }

    beforeArt(cb) {
        super.beforeArt(err => {
            return err ? cb(err) : this.initDatabase(cb);
        });
    }
};