@trapcode/codebase/vue/extensions/ObjectValidator.js

For TrapCode

let validators = {
    must(value) {
        return value.length > 0;
    },
    min(value, option) {
        console.log(value);
        value = parseFloat(value);
        option = parseFloat(option);
        return value >= option;
    },
    max(value, option) {
        value = parseFloat(value);
        option = parseFloat(option);
        return value <= option;
    },
    minLength(value, option) {
        value = validators._trimIfString_(value);
        return value.length >= option;
    },
    maxLength(value, option) {
        value = validators._trimIfString_(value);
        return value.length <= option;
    },

    selectMin(value, option) {
        return validators.minLength(value, option)
    },

    _trimIfString_(value) {
        return typeof value === 'string' ? value.trim() : value
    }
};

let validatorExtenders = {};


let errorMessages = {
    default: ':param returned :false',
    must: ':param is required.',
    min: ':param is too small. (Min. :option)',
    max: ':param is too big. (Max. :option)',
    minLength: ':param is too short. (Min. :option characters)',
    maxLength: ':param is too long. (Max. :option characters)',
    selectMin: 'Select at-least :option :param.',
    selectMax: 'Select at-most :option :param.',
};

let ObjectValidatorFunctions = {
    yes() {
    },
    beforeValidation() {
    },
    onEachError(param, msg) {
        alert(msg);
        console.log([param, msg])
    }
};


let ObjectValidatorEngine = {
    parseMessage($rule, $name, $option) {
        let msg = errorMessages.default;

        if (errorMessages.hasOwnProperty($rule)) {
            msg = errorMessages[$rule];
        }

        msg = msg.replace(':param', $name);

        if (typeof $option != 'function') {
            msg = msg.replace(':option', $option);
        }

        return msg;
    }
};

let ObjectValidatorEditor = {
    addValidators($validators) {
        if (!Array.isArray($validators) && typeof $validators === 'object') {
            $validators = [$validators];
        }
        for (let i = 0; i < $validators.length; i++) {
            let validator = $validators[i];

            if (validator.hasOwnProperty('error')) {
                errorMessages[validator.name] = validator.error
            }

            if (validator.hasOwnProperty('extendValidator') &&
                validators.hasOwnProperty(validator.name)) {
                validatorExtenders[validator.name] = validator.extendValidator;
            } else if (validator.hasOwnProperty('validator')) {
                validators[validator.name] = validator.validator;
            }
        }
    },

    overrideDefaultFunction(key, value) {
        if (ObjectValidatorFunctions.hasOwnProperty(key)) {
            ObjectValidatorFunctions[key] = value
        }
    },

    overrideDefaultFunctions(functions) {
        let keys = Object.keys(functions);
        for (let i = 0; i < keys.length; i++) {
            let _function = keys[i];
            ObjectValidatorEditor.overrideDefaultFunction(_function, functions[_function]);
        }
    }
};


class ObjectValidator {
    constructor(form) {
        return this.setObject(form);
    }

    rules(validateWith) {
        this.validateWith = validateWith;
        return this;
    }

    setObject(form) {
        this.form = form;
        return this;
    }

    then(functions) {
        if (typeof functions === 'function') {
            ObjectValidatorEditor.overrideDefaultFunction('yes', functions)
        } else {
            let functionKeys = Object.keys(functions);

            for (let i = 0; i < functionKeys.length; i++) {
                let config = functionKeys[i];
                ObjectValidatorEditor.overrideDefaultFunction(config, functions[config])
            }
        }
        return this
    }

    validate(functions = null) {
        if (functions !== null) {
            return this.then(functions).validate();
        }

        return this.runValidation();
    }

    runValidation() {
        let vm;
        let form = this.form;
        let validateWith = this.validateWith;
        let functions = ObjectValidatorFunctions;

        // Set Found Error to stop once true. One Error at a time.
        let foundError = false;
        let totalParams = Object.keys(validateWith).length;
        let paramsChecked = 0;

        vm = this;

        // Run before validation function
        functions.beforeValidation();


        if (Array.isArray(validateWith) && this.usingFormValidator != null) {
            let newValidation = {};

            validateWith.forEach(function (field) {

                if (vm.usingFormValidator.hasOwnProperty(field)) {

                    newValidation[field] = vm.usingFormValidator[field];

                }

            });

            validateWith = newValidation
        }

        _.each(validateWith, function (rules, param) {
            if (!foundError) {
                _.each(rules, function (options, rule) {
                    let isValid, msg, checkThis;

                    checkThis = true;
                    if (rules.hasOwnProperty('if')) {
                        checkThis = rules['if'];

                        if (typeof checkThis == 'function') {
                            checkThis = checkThis(form[param])
                        }
                    }

                    if (checkThis && !foundError && validators.hasOwnProperty(rule)) {
                        if (validatorExtenders.hasOwnProperty(rule)) {
                            isValid = validatorExtenders[rule](validators[rule], form[param], options);
                        } else {
                            isValid = validators[rule](form[param], options);
                        }


                        if (!isValid) {
                            foundError = true;
                            if (functions.hasOwnProperty('onEachError')) {
                                if (!rules.hasOwnProperty('name')) {
                                    rules['name'] = _.startCase(param)
                                }
                                msg = ObjectValidatorEngine.parseMessage(rule, rules.name, options);
                                functions.onEachError(param, msg);
                            }
                        }
                    }
                });
                paramsChecked++;
                if (paramsChecked === totalParams && !foundError) {
                    if (functions.hasOwnProperty('yes')) {
                        functions.yes(form);
                    }
                }
            }
        });
        return foundError;
    }
}

ObjectValidator.prototype.form = {};
ObjectValidator.prototype.validateWith = [];

export {ObjectValidator, ObjectValidatorEditor};