enigma-bbs/core/file_base_filter.js

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

const UserProps = require('./user_property.js');

//  deps
const _ = require('lodash');
const { v4: UUIDv4 } = require('uuid');

module.exports = class FileBaseFilters {
    constructor(client) {
        this.client = client;

        this.load();
    }

    static get OrderByValues() {
        return ['descending', 'ascending'];
    }

    static get SortByValues() {
        return [
            'upload_timestamp',
            'upload_by_username',
            'dl_count',
            'user_rating',
            'est_release_year',
            'byte_size',
            'file_name',
        ];
    }

    toArray() {
        return _.map(this.filters, (filter, uuid) => {
            return Object.assign({ uuid: uuid }, filter);
        });
    }

    get(filterUuid) {
        return this.filters[filterUuid];
    }

    add(filterInfo) {
        const filterUuid = UUIDv4();

        filterInfo.tags = this.cleanTags(filterInfo.tags);

        this.filters[filterUuid] = filterInfo;

        return filterUuid;
    }

    replace(filterUuid, filterInfo) {
        const filter = this.get(filterUuid);
        if (!filter) {
            return false;
        }

        filterInfo.tags = this.cleanTags(filterInfo.tags);
        this.filters[filterUuid] = filterInfo;
        return true;
    }

    remove(filterUuid) {
        delete this.filters[filterUuid];
    }

    load() {
        let filtersProperty = this.client.user.properties[UserProps.FileBaseFilters];
        let defaulted;
        if (!filtersProperty) {
            filtersProperty = JSON.stringify(FileBaseFilters.getBuiltInSystemFilters());
            defaulted = true;
        }

        try {
            this.filters = JSON.parse(filtersProperty);
        } catch (e) {
            this.filters = FileBaseFilters.getBuiltInSystemFilters(); //  something bad happened; reset everything back to defaults :(
            defaulted = true;
            this.client.log.error(
                { error: e.message, property: filtersProperty },
                'Failed parsing file base filters property'
            );
        }

        if (defaulted) {
            this.persist(err => {
                if (!err) {
                    const defaultActiveUuid = this.toArray()[0].uuid;
                    this.setActive(defaultActiveUuid);
                }
            });
        }
    }

    persist(cb) {
        return this.client.user.persistProperty(
            UserProps.FileBaseFilters,
            JSON.stringify(this.filters),
            cb
        );
    }

    cleanTags(tags) {
        return tags
            .toLowerCase()
            .replace(/,?\s+|,/g, ' ')
            .trim();
    }

    setActive(filterUuid) {
        const activeFilter = this.get(filterUuid);

        if (activeFilter) {
            this.activeFilter = activeFilter;
            this.client.user.persistProperty(
                UserProps.FileBaseFilterActiveUuid,
                filterUuid
            );
            return true;
        }

        return false;
    }

    static getBuiltInSystemFilters() {
        const U_LATEST = '7458b09d-40ab-4f9b-a0d7-0cf866646329';

        const filters = {
            [U_LATEST]: {
                name: 'By Date Added',
                areaTag: '', //  all
                terms: '', //  *
                tags: '', //  *
                order: 'descending',
                sort: 'upload_timestamp',
                uuid: U_LATEST,
                system: true,
            },
        };

        return filters;
    }

    static getActiveFilter(client) {
        return new FileBaseFilters(client).get(
            client.user.properties[UserProps.FileBaseFilterActiveUuid]
        );
    }

    static getFileBaseLastViewedFileIdByUser(user) {
        return parseInt(user.properties[UserProps.FileBaseLastViewedId] || 0);
    }

    static setFileBaseLastViewedFileIdForUser(user, fileId, allowOlder, cb) {
        if (!cb && _.isFunction(allowOlder)) {
            cb = allowOlder;
            allowOlder = false;
        }

        const current = FileBaseFilters.getFileBaseLastViewedFileIdByUser(user);
        if (!allowOlder && fileId < current) {
            if (cb) {
                cb(null);
            }
            return;
        }

        return user.persistProperty(UserProps.FileBaseLastViewedId, fileId, cb);
    }
};