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
        );
    }
};