nodbot/CustomModules/NodBot.js

module.exports = {
    CommandData: class {
        constructor(message) {
            // Get the location of the final period in the message
            this.finalPeriod = message.content.lastIndexOf('.');
            this.isCommand = this.finalPeriod >= 0 ? true : false; // Check if there is a period somewhere in the message to flag as a possible command
            this.isValid = false;
            this.args = message.content.slice(0,this.finalPeriod).toLowerCase(); // Grab everything leading up to the final period
            this.command = message.content.slice(this.finalPeriod + 1).toLowerCase(); // Grab everything after the final period
            this.author = message.author.username;
            this.message = message;

            return this;
        }

        validate(dotCommands) {
            if (this.args.startsWith('http')) return false;
            if (this.args.startsWith('www')) return false;

            const indices = {
                curlyBrace: {
                    start: -1,
                    end: -1
                },
                bracket: {
                    start: -1,
                    end: -1
                },
                parenthesis: {
                    start: -1,
                    end: -1
                }
            }

            // Check for and extract the part of the message that's
            // wrapped in any type of brackets or quotes eg. ([{``''""}])
            const curlyBraceStart = this.message.content.match(/[\{]/g);
            const curlyBraceEnd = this.message.content.match(/[\}]/g);
            if (curlyBraceStart && curlyBraceEnd) {
                indices.curlyBrace.start = this.message.content.indexOf(curlyBraceStart[0]) + 1;
                indices.curlyBrace.end = this.message.content.lastIndexOf(curlyBraceEnd[0]);
            }

            const bracketStart = this.message.content.match(/[\[]/g);
            const bracketEnd = this.message.content.match(/[\]]/g);
            if (bracketStart && bracketEnd) {
                indices.bracket.start = this.message.content.indexOf(bracketStart[0]) + 1;
                indices.bracket.end = this.message.content.lastIndexOf(bracketEnd[0]);
            }

            const parenthesisStart = this.message.content.match(/[\(]/g);
            const parenthesisEnd = this.message.content.match(/[\)]/g);
            if (parenthesisStart && parenthesisEnd) {
                indices.parenthesis.start = this.message.content.indexOf(parenthesisStart[0]) + 1;
                indices.parenthesis.end = this.message.content.lastIndexOf(parenthesisEnd[0]);
            }

            let nestedText = new String();

            if (indices.curlyBrace.start >= 0 && indices.curlyBrace.end > 0) {
                nestedText = this.message.content.slice(indices.curlyBrace.start, indices.curlyBrace.end);
            }

            if (indices.bracket.start >= 0 && indices.bracket.end > 0) {
                nestedText = this.message.content.slice(indices.bracket.start, indices.bracket.end);
            }

            if (indices.parenthesis.start >= 0 && indices.parenthesis.end > 0) {
                nestedText = this.message.content.slice(indices.parenthesis.start, indices.parenthesis.end);
            }

            console.log(nestedText);

            if (nestedText !== "") {
                this.nestedCommand = {
                    finalPeriod: nestedText.lastIndexOf('.'),
                    isCommand: nestedText.lastIndexOf('.') >= 0 ? true : false,
                    args: nestedText.slice(0, nestedText.lastIndexOf('.')).toLowerCase(),
                    command: nestedText.slice(nestedText.lastIndexOf('.') + 1).toLowerCase()
                }

                for (const [key, value] of dotCommands) {
                    if (key === this.nestedCommand.command) {
                        this.isValid = true;
                        this.args = this.nestedCommand.args;
                        this.command = key;
                        this.isCommand = this.nestedCommand.isCommand;
                        this.finalPeriod = this.nestedCommand.finalPeriod;
                        return this;
                    } else if (value.alias) {
                        if (typeof value.alias === 'string' && value.alias === this.nestedCommand.command) {
                            this.command = key
                            this.args = this.nestedCommand.args;
                            this.isValid = true;
                            this.isCommand = this.nestedCommand.isCommand;
                            this.finalPeriod = this.nestedCommand.finalPeriod;
                            return this;
                        } else if (typeof value.alias === 'object' && value.alias.includes(this.nestedCommand.command)) {
                            this.command = key
                            this.args = this.nestedCommand.args;
                            this.isValid = true;
                            this.isCommand = this.nestedCommand.isCommand;
                            this.finalPeriod = this.nestedCommand.finalPeriod;
                            return this;
                        }
                    }
                }
            }

            for (const [key, value] of dotCommands) {
                if (key === this.command) {
                    this.isValid = true;
                    return this;
                } else if (value.alias) {
                    if (typeof value.alias === 'string' && value.alias === this.command) {
                        this.command = key;
                        this.isValid = true;
                        return this;
                    } else if (typeof value.alias === 'object' && value.alias.includes(this.command)) {
                        this.command = key;
                        this.isValid = true;
                        return this;
                    }
                }
            }
            return this;
        }
    },
    GifData: class {
        constructor() {
            this.id = 0;
            this.name = "";
            this.url = "";
        }

        // Initial GifData configuration
        // Can also be used to update the data piecemeal
        setInfo(name, url, id) {
            // Check for existing or incoming name
            if ((this.name === "") && (typeof name !== 'string')) throw `Error: This Gif doesn't have existing name, and no name is going to be set.`;
            // Check for existing content or incoming content
            if ((this.url === "") && (typeof url !== 'string')) throw `Error: This Gif doesn't have existing url, and no url is going to be set.`;
            
            // Property is set if the variable is the right type,
            // otherwise it keeps the existing property
            this.id = typeof id === 'number' ? id : this.id;
            this.name = typeof name === 'string' ? name : this.name;
            this.url = typeof url === 'string' ? url : this.url;

            return this; // For chaining
        }
    },
    PastaData: class {
        constructor() {
            this.id = 0;
            this.name = "";
            this.content = "";
            this.iconUrl = "";
        }

        // Initial PastaData configuration
        // Can also be used to update the data piecemeal
        setInfo(name, content, iconUrl, id) {
            // Check for existing or incoming name
            if ((this.name === "") && (typeof name !== 'string')) throw `Error: This Pasta doesn't have existing name, and no name is going to be set.`;
            // Check for existing content or incoming content
            if ((this.content === "") && (typeof content !== 'string')) throw `Error: This Pasta doesn't have existing content, and no content is going to be set.`;

            // Property is set if the variable is the right type,
            // otherwise it keeps the existing property
            this.id = typeof id === 'number' ? id : this.id;
            this.name = typeof name === 'string' ? name : this.name;
            this.content = typeof content === 'string' ? content : this.content;
            this.iconUrl = typeof iconUrl === 'string' ? iconUrl : this.iconUrl;

            return this; // For chaining
        }
    }
}