enigma-bbs/core/message_base_search.js

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

//  ENiGMA½
const MenuModule                    = require('./menu_module.js').MenuModule;
const {
    getSortedAvailMessageConferences,
    getAvailableMessageAreasByConfTag,
    getSortedAvailMessageAreasByConfTag,
    hasMessageConfAndAreaRead,
    filterMessageListByReadACS,
}                                   = require('./message_area.js');
const Errors                        = require('./enig_error.js').Errors;
const Message                       = require('./message.js');

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

exports.moduleInfo = {
    name    : 'Message Base Search',
    desc    : 'Module for quickly searching the message base',
    author  : 'NuSkooler',
};

const MciViewIds = {
    search : {
        searchTerms : 1,
        search      : 2,
        conf        : 3,
        area        : 4,
        to          : 5,
        from        : 6,
        advSearch   : 7,
    }
};

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

        this.menuMethods = {
            search : (formData, extraArgs, cb) => {
                return this.searchNow(formData, cb);
            }
        };
    }

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

            this.prepViewController('search', 0, mciData.menu, (err, vc) => {
                if(err) {
                    return cb(err);
                }

                const confView  = vc.getView(MciViewIds.search.conf);
                const areaView  = vc.getView(MciViewIds.search.area);

                if(!confView || !areaView) {
                    return cb(Errors.DoesNotExist('Missing one or more required views'));
                }

                const availConfs = [ { text : '-ALL-', data : '' } ].concat(
                    getSortedAvailMessageConferences(this.client).map(conf => Object.assign(conf, { text : conf.conf.name, data : conf.confTag } )) || []
                );

                let availAreas = [ { text : '-ALL-', data : '' } ]; //  note: will populate if conf changes from ALL

                confView.setItems(availConfs);
                areaView.setItems(availAreas);

                confView.setFocusItemIndex(0);
                areaView.setFocusItemIndex(0);

                confView.on('index update', idx => {
                    availAreas = [ { text : '-ALL-', data : '' } ].concat(
                        getSortedAvailMessageAreasByConfTag(availConfs[idx].confTag, { client : this.client }).map(
                            area => Object.assign(area, { text : area.area.name, data : area.areaTag } )
                        )
                    );
                    areaView.setItems(availAreas);
                    areaView.setFocusItemIndex(0);
                });

                vc.switchFocus(MciViewIds.search.searchTerms);
                return cb(null);
            });
        });
    }

    searchNow(formData, cb) {
        const isAdvanced    = formData.submitId === MciViewIds.search.advSearch;
        const value         = formData.value;

        const filter = {
            resultType      : 'messageList',
            sort            : 'modTimestamp',
            terms           : value.searchTerms,
            //extraFields       : [ 'area_tag', 'message_uuid', 'reply_to_message_id', 'to_user_name', 'from_user_name', 'subject', 'modified_timestamp' ],
            limit           : 2048, //  :TODO: best way to handle this? we should probably let the user know if some results are returned
        };

        const returnNoResults = () => {
            return this.gotoMenu(
                this.menuConfig.config.noResultsMenu || 'messageSearchNoResults',
                { menuFlags : [ 'popParent' ] },
                cb
            );
        };

        if(isAdvanced) {
            filter.toUserName   = value.toUserName;
            filter.fromUserName = value.fromUserName;

            if(value.confTag && !value.areaTag) {
                //  areaTag may be a string or array of strings
                //  getAvailableMessageAreasByConfTag() returns a obj - we only need tags
                filter.areaTag = _.map(
                    getAvailableMessageAreasByConfTag(value.confTag, { client : this.client } ),
                    (area, areaTag) => areaTag
                );
            } else if(value.areaTag) {
                if(hasMessageConfAndAreaRead(this.client, value.areaTag)) {
                    filter.areaTag = value.areaTag; //  specific conf + area
                } else {
                    return returnNoResults();
                }
            }
        }

        Message.findMessages(filter, (err, messageList) => {
            if(err) {
                return cb(err);
            }

            //  don't include results without ACS -- if the user searched by
            //  explicit conf/area tag, we should have already filtered (above)
            if(!value.confTag && !value.areaTag) {
                messageList = filterMessageListByReadACS(this.client, messageList);
            }

            if(0 === messageList.length) {
                return returnNoResults();
            }

            const menuOpts = {
                extraArgs : {
                    messageList,
                    noUpdateLastReadId  : true
                },
                menuFlags   : [ 'popParent' ],
            };

            return this.gotoMenu(
                this.menuConfig.config.messageListMenu || 'messageAreaMessageList',
                menuOpts,
                cb
            );
        });
    }
};