galactic-bot/structure/interfaces/Setting.js

const Component = require('./Component.js');
const { stripIndents } = require('common-tags');

class Setting extends Component {

    constructor(client, opts = {}) {

        if(!opts) return null;

        super(client, {
            id: opts.name,
            type: 'setting',
            guarded: opts.guarded,
            disabled: opts.disabled
        });

        this.name = opts.name;
        this.module = opts.module;
        this.restricted = Boolean(opts.restricted);
        this.premium = opts.premium || 0;

        this.description = opts.description || `S_${opts.name.toUpperCase()}_DESCRIPTION`;
        this.examples = opts.examples || [];
        this.rawExamples = Boolean(opts.rawExamples);
        this.usage = opts.usage || '';
        this.archivable = opts.archivable === undefined ? true : Boolean(opts.archivable);

        this.tags = opts.tags || [];

        this.index = opts.index || opts.name;
        this.aliases = opts.aliases || [];
        this.resolve = opts.resolve && Constants.Resolves.includes(opts.resolve) ? opts.resolve : 'GUILD'; //eslint-disable-line no-use-before-define
        this.default = opts.default;
        this.arguments = opts.arguments || [];
        this.custom = Boolean(opts.custom);
        // this.display = opts.display?.toLowerCase() || opts.name.toLowerCase();

        this.memberPermissions = opts.memberPermissions || [];
        this.clientPermissions = opts.clientPermissions || [];

        this._commandHandler = null;

    }

    async handle() {
        this.client.logger.error(`No handle function found in ${this.moduleResolveable}.`);
    }

    async _parseArguments(params, guild) {
        const response = await this.commandHandler._parseArguments(params, this.arguments, guild);
        if(response.error) return response;
        return { parsedArguments: response.args, params: response.parameters.map((p) => p[0]), error: false };
    }

    /**
     * Resolves methods used primarily for settings, also deals with appending the arguments into existing lists
     *
     * @param {Array<String>} args The incoming arguments with the first element being the method ex. ['add','ban','kick']
     * @param {Array<String>} valid An array of items to compare to, if an argument doesn't exist in this array it'll be skipped over
     * @param {Array<String>} [existing=[]] Existing values in the array, valid elements will be appended to this
     * @param {Function} resolver One of the resolver functions used to resolve the passed values into objects (should always be one of the mass resolvers due to the nature of this method, might break otherwise) NOTE: REMEMBER TO BIND 'this' ARG!
     * @param {Guild} guild The guild for the resolver to use when resolving
     * @param {Boolean} caseSensitive Whether or not the arguments are case sensitive
     * @returns {Object}
     * @memberof Resolver
     */
    resolveMethod() {
        // eslint-disable-next-line prefer-rest-params
        return this.client.resolver.resolveMethod(...arguments);
    }

    reason(executor) {
        return `[${this.moduleResolveable}] Executed by ${executor.tag} (${executor.id}).`;
    }

    async _handleReset(message) {
        const payload = { error: false, response: null };
        try {
            await message.guild._removeSettings(this.index);
            payload.response = message.format('GENERAL_SETTINGRESET', { setting: this.name.toLowerCase() });
        } catch(error) {
            this.client.logger.error(`Error reseting setting data: ${error}`);
            payload.error = true;
        }
        return payload;
    }

    async _processChannelIgnore(args, setting, guild, langIndex) {

        const { resolver } = this.client;
        const langParams = {};

        const resolved = await resolver.resolveMethod(args, {
            existing: setting.ignore,
            resolver: resolver.resolveChannels.bind(resolver),
            guild,
            allowedMethods: ['add', 'remove', 'set', 'reset']
        });
        if (!resolved) return {
            error: true,
            msg: guild.format('ERR_INVALID_METHOD', { method: args[0] })
        };
        else if (args.length < 2 && resolved.method !== 'reset') return {
            error: true,
            msg: guild.format('MISSING_ARGS')
        };

        langParams.index = langIndex + resolved.method.toUpperCase();
        langParams.changed = resolved.resolved.join(', '); //.filter((ch) => !setting.ignore.includes(ch.id))
        setting.ignore = resolved.result;
        return langParams;

    }

    async _processRoleBypass(args, setting, guild, langIndex) {

        const { resolver } = this.client;
        const langParams = {};

        const resolved = await resolver.resolveMethod(args, {
            existing: setting.bypass,
            resolver: resolver.resolveRoles.bind(resolver),
            guild,
            allowedMethods: ['add', 'remove', 'set', 'reset']
        });
        
        if (!resolved) return {
            error: true,
            msg: guild.format('ERR_INVALID_METHOD', { method: args[0] })
        };
        else if (args.length < 2 && resolved.method !== 'reset') return {
            error: true,
            msg: guild.format('MISSING_ARGS')
        };

        langParams.index = langIndex + resolved.method.toUpperCase();
        langParams.changed = resolved.resolved.map((role) => role.name).join(', '); // .filter((ch) => !setting.bypass.includes(ch.id))
        setting.bypass = resolved.result;
        return langParams;

    }

    get commandHandler() {
        if(this._commandHandler) return this._commandHandler;
        this._commandHandler = this.client.registry.components.get('observer:commandHandler');
        return this._commandHandler;
    }

    get moduleResolveable() {
        return `${this.module.id}:${this.id}`;
    }

    get display() {
        return this.name.toLowerCase();
    }

    usageEmbed(message, verbose = false) {

        const { guild } = message;
        const prefix = guild?.prefix || this.client.prefix;
        const fields = [];

        if (this.examples.length) {
            fields.push({
                name: `》 ${message.format('GENERAL_EXAMPLES')}`,
                value: this.examples.map((e) => this.rawExamples ? `\`${prefix}${e}\`` : `\`${prefix}setting ${e}\``).join('\n')
            });
        }
        if (this.aliases.length && verbose) {
            fields.push({
                name: `》 ${message.format('GENERAL_ALIASES')}`,
                value: this.aliases.join(', ')
            });
        }
        if (this.arguments.length && verbose) {
            fields.push({
                name: `》 ${message.format('GENERAL_ARGUMENTS')}`,
                value: this.arguments.map((a) => `\`${a.types.length === 1 && a.types.includes('FLAG') ? '--' : ''}${a.name}${a.usage ? ` ${a.usage}` : ''}\`: ${message.format(`A_${a.name.toUpperCase()}_${this.name.toUpperCase()}_DESCRIPTION`)}`)
            });
        }

        return {
            author: {
                name: `${this.display}${this.module ? ` (${this.module.resolveable})` : ''}`
            },
            description: stripIndents`\`${prefix}setting ${this.display}${this.usage ? ` ${this.usage}` : ''}\`${this.guildOnly ? ' *(guild-only)*' : ''}
                ${message.format(this.description)}`,
            fields
        };

    }
    
}

module.exports = Setting;

const Constants = {
    Resolves: [
        'GUILD',
        'USER'
    ]
};