enigma-bbs/core/file_base_search.js

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

//	ENiGMA½
const MenuModule					= require('./menu_module.js').MenuModule;
const ViewController				= require('./view_controller.js').ViewController;
const getSortedAvailableFileAreas	= require('./file_base_area.js').getSortedAvailableFileAreas;
const FileBaseFilters				= require('./file_base_filter.js');

//	deps
const async							= require('async');

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

const MciViewIds = {
    search : {
        searchTerms	: 1,
        search		: 2,
        tags		: 3,
        area		: 4,
        orderBy		: 5,
        sort		: 6,
        advSearch	: 7,
    }
};

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

        this.menuMethods = {
            search : (formData, extraArgs, cb) => {
                const isAdvanced = formData.submitId === MciViewIds.search.advSearch;
                return this.searchNow(formData, isAdvanced, cb);
            },
        };
    }

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

            const self	= this;
            const vc	= self.addViewController( 'search', new ViewController( { client : this.client } ) );

            async.series(
                [
                    function loadFromConfig(callback) {
                        return vc.loadFromMenuConfig( { callingMenu : self, mciMap : mciData.menu }, callback);
                    },
                    function populateAreas(callback) {
                        self.availAreas = [ { name : '-ALL-' } ].concat(getSortedAvailableFileAreas(self.client) || []);

                        const areasView = vc.getView(MciViewIds.search.area);
                        areasView.setItems( self.availAreas.map( a => a.name ) );
                        areasView.redraw();
                        vc.switchFocus(MciViewIds.search.searchTerms);

                        return callback(null);
                    }
                ],
                err => {
                    return cb(err);
                }
            );
        });
    }

    getSelectedAreaTag(index) {
        if(0 === index) {
            return '';	//	-ALL-
        }
        const area = this.availAreas[index];
        if(!area) {
            return '';
        }
        return area.areaTag;
    }

    getOrderBy(index) {
        return FileBaseFilters.OrderByValues[index] || FileBaseFilters.OrderByValues[0];
    }

    getSortBy(index) {
        return FileBaseFilters.SortByValues[index] || FileBaseFilters.SortByValues[0];
    }

    getFilterValuesFromFormData(formData, isAdvanced) {
        const areaIndex		= isAdvanced ? formData.value.areaIndex : 0;
        const orderByIndex	= isAdvanced ? formData.value.orderByIndex : 0;
        const sortByIndex	= isAdvanced ? formData.value.sortByIndex : 0;

        return {
            areaTag		: this.getSelectedAreaTag(areaIndex),
            terms		: formData.value.searchTerms,
            tags		: isAdvanced ? formData.value.tags : '',
            order		: this.getOrderBy(orderByIndex),
            sort		: this.getSortBy(sortByIndex),
        };
    }

    searchNow(formData, isAdvanced, cb) {
        const filterCriteria = this.getFilterValuesFromFormData(formData, isAdvanced);

        const menuOpts = {
            extraArgs	: {
                filterCriteria	: filterCriteria,
            },
            menuFlags	: [ 'popParent' ],
        };

        return this.gotoMenu(this.menuConfig.config.fileBaseListEntriesMenu || 'fileBaseListEntries', menuOpts, cb);
    }
};