va-validation-behavior.html

<script>
  VA.ValidationBehavior = {
    
    observers: [
      '_validateByPath(data.*)'
    ],
    
    properties: {
      
      data: {
        type: Object
      },
      
      fields: {
        type: Object,
        readOnly: true
      },
      
      messages: {
        type: Object,
        readOnly: true
      },
      
      valid: {
        notify: true,
        type: Boolean,
        value: false
      },
      
      validation: {
        notify: true,
        type: Object,
        value: function () {
          return {};
        }
      },
      
      errorMessages: {
        notify: true,
        type: Object,
        value: function () {
          return {};
        }
      }
    },
    
    ready: function () {
      if (this.fields) {
        for (var field in this.fields) {
          if (this.fields[field].empty === true) {
            this.validation[field] = true;
          } else {
            this.validation[field] = false;
          }
          this.errorMessages[field] = null;
        }
      }
    },
    
    reset: function () {
      this.valid = false;
    },
    
    validate: function (name, value, notRecheck) {
      var result = true;
      var field = this.fields[name];
      
      if (!field) {
        throw new Error("There is no rule for '" + field + "'");
      }
      
      if (!this.validation[name]) {
        this._unsetErrorMessage(name);
      }
      
      var target = this.data[name];
      
      if (field.required) {
        result = target !== undefined && target !== null && target !== '';
        
        if (!result) {
          this._setErrorMessage(name, 'required');
        }
      }
      
      if (result && field.empty === false) {
        result = target !== '';
      }
      
      if (result && field.rules) {
        for (var i in field.rules) {
          var rule = field.rules[i];
          result = this._validateForRule(rule, target);
          if (!result) {
            this._setErrorMessage(name, rule);
            break;
          }
        }
      }
      
      if (field.recheck && !notRecheck) {
        this.validate(field.recheck, this.data[field.recheck], true);
      }
      
      this._setValidation(name, result);
    },
    
    forceInvalid: function (name, ruleForMsg) {
      if (this.validation[name]) {
        this._setValidation(name, false);
        if (!ruleForMsg) {
          this._unsetErrorMessage(name);
        } else {
          this._setErrorMessage(name, ruleForMsg);
        }
      }
    },
    
    forceInvalidAll: function () {
      for (var name in this.validation) {
        if (this.validation[name]) {
          this._setValidation(name, false);
          this._unsetErrorMessage(name);
        }
      }
    },
    
    _validateForRule: function (rule, target) {
      if (this[rule] && typeof this[rule] === 'function') {
        return this[rule](target);
      }
      console.warn('Trying to validate but no rule is found. [rule]:' + rule);
      return true;
    },
    
    _setValidation: function (name, value) {
      this.set(['validation', name], value);
      this.valid = this._validAll();
    },
    
    _setErrorMessage: function (name, rule) {
      if (this.messages && this.messages[name] && this.messages[name][rule]) {
        this.set(['errorMessages', name], this.messages[name][rule]);
      }
    },
    
    _unsetErrorMessage: function (name) {
      this.set(['errorMessages', name], '');
    },
    
    _validateByPath: function (data) {
      var matched;
      
      if (data.path === 'data') {
        Object.getOwnPropertyNames(this.fields).forEach(function (key) {
          var value = this.get(['data', key]);
          if (value !== undefined) {
            this.validate(key, value);
          }
        }.bind(this));
      } else {
        matched = data.path.match('^data\.(.*)');
        var key = matched[1];
        var value = this.get(matched[0]);
        if (this.fields.hasOwnProperty(key) && value !== undefined) {
          this.validate(key, value);
        }
      }
    },
    
    _validAll: function () {
      var keys = Object.getOwnPropertyNames(this.validation);
      
      for(var key in this.validation) {
        if (!this.validation[key]) {
          return false;
        }
      }
      
      return true;
    }
      
  };
</script>