choerodon-ui/pro/lib/validator/Validator.js

An enterprise-class UI design language and React-based implementation

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));

var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));

var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));

var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

var _tslib = require("tslib");

var _react = _interopRequireDefault(require("react"));

var _mobx = require("mobx");

var _isString = _interopRequireDefault(require("lodash/isString"));

var _omitBy = _interopRequireDefault(require("lodash/omitBy"));

var _isUndefined = _interopRequireDefault(require("lodash/isUndefined"));

var _configure = require("../../../lib/configure");

var _Validity = _interopRequireDefault(require("./Validity"));

var _ValidationResult = _interopRequireDefault(require("./ValidationResult"));

var _rules = _interopRequireDefault(require("./rules"));

var _valueMissing = _interopRequireDefault(require("./rules/valueMissing"));

var _getReactNodeText = _interopRequireDefault(require("../_util/getReactNodeText"));

var _utils = require("../data-set/utils");

var Validator =
/*#__PURE__*/
function () {
  function Validator(field, control) {
    var _this = this;

    (0, _classCallCheck2["default"])(this, Validator);
    (0, _mobx.runInAction)(function () {
      _this.field = field;
      _this.control = control;
    });
  }

  (0, _createClass2["default"])(Validator, [{
    key: "reset",
    value: function reset() {
      this.clearErrors();
      var uniqueRefFields = this.uniqueRefFields;

      if (uniqueRefFields.length) {
        uniqueRefFields.forEach(function (uniqueRefField) {
          var validator = uniqueRefField.validator;

          if (validator) {
            validator.clearErrors();
          }
        });
      }
    }
  }, {
    key: "report",
    value: function () {
      var _report = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee(ret) {
        var _this$props, name, dataSet, record, _console, validationMessage, value, reportMessage, dsName, id;

        return _regenerator["default"].wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _this$props = this.props, name = _this$props.name, dataSet = _this$props.dataSet, record = _this$props.record;

                if (!(process.env.NODE_ENV !== 'production' && typeof console !== 'undefined')) {
                  _context.next = 16;
                  break;
                }

                validationMessage = ret.validationMessage, value = ret.value;

                if (!(0, _isString["default"])(validationMessage)) {
                  _context.next = 7;
                  break;
                }

                _context.t0 = validationMessage;
                _context.next = 10;
                break;

              case 7:
                _context.next = 9;
                return (0, _getReactNodeText["default"])(_react["default"].createElement("span", null, validationMessage));

              case 9:
                _context.t0 = _context.sent;

              case 10:
                _context.t1 = _context.t0;
                reportMessage = ['validation:', _context.t1];

                if (dataSet) {
                  dsName = dataSet.name, id = dataSet.id;

                  if (dsName || id) {
                    reportMessage.push("\n[dataSet<".concat(dsName || id, ">]:"), dataSet);
                  } else {
                    reportMessage.push('\n[dataSet]:', dataSet);
                  }
                }

                if (record) {
                  if (dataSet) {
                    reportMessage.push("\n[record<".concat(dataSet.indexOf(record), ">]:"), record);
                  } else {
                    reportMessage.push("\n[record]:", record);
                  }

                  reportMessage.push("\n[field<".concat(name, ">]:"), record.getField(name));
                } else {
                  reportMessage.push('[field]:', name);
                }

                reportMessage.push('\n[value]:', value);

                (_console = console).warn.apply(_console, reportMessage);

              case 16:
              case "end":
                return _context.stop();
            }
          }
        }, _callee, this);
      }));

      function report(_x) {
        return _report.apply(this, arguments);
      }

      return report;
    }()
  }, {
    key: "clearErrors",
    value: function clearErrors() {
      this.innerValidationResults = undefined;
    }
  }, {
    key: "addError",
    value: function addError(result) {
      var innerValidationResults = (0, _utils.getIf)(this, 'innerValidationResults', []);
      innerValidationResults.push(result);
      this.report(result);
    }
  }, {
    key: "execute",
    value: function () {
      var _execute = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee2(rules, value) {
        var _this2 = this;

        var props, method, results;
        return _regenerator["default"].wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                props = this.props;
                method = rules.shift();

                if (!method) {
                  _context2.next = 10;
                  break;
                }

                _context2.next = 5;
                return Promise.all(value.map(function (item) {
                  return method(item, props);
                }));

              case 5:
                results = _context2.sent;
                results.forEach(function (result) {
                  if (result instanceof _ValidationResult["default"]) {
                    _this2.addError(result);

                    var index = value.indexOf(result.value);

                    if (index !== -1) {
                      value.splice(index, 1);
                    }
                  }
                });

                if (!value.length) {
                  _context2.next = 10;
                  break;
                }

                _context2.next = 10;
                return this.execute(rules, value);

              case 10:
              case "end":
                return _context2.stop();
            }
          }
        }, _callee2, this);
      }));

      function execute(_x2, _x3) {
        return _execute.apply(this, arguments);
      }

      return execute;
    }()
  }, {
    key: "checkValidity",
    value: function () {
      var _checkValidity = (0, _asyncToGenerator2["default"])(
      /*#__PURE__*/
      _regenerator["default"].mark(function _callee3() {
        var value,
            valueMiss,
            multiple,
            _args3 = arguments;
        return _regenerator["default"].wrap(function _callee3$(_context3) {
          while (1) {
            switch (_context3.prev = _context3.next) {
              case 0:
                value = _args3.length > 0 && _args3[0] !== undefined ? _args3[0] : null;
                valueMiss = (0, _valueMissing["default"])(value, this.props);
                this.clearErrors();

                if (!(valueMiss !== true)) {
                  _context3.next = 7;
                  break;
                }

                this.addError(valueMiss);
                _context3.next = 10;
                break;

              case 7:
                multiple = this.props.multiple;
                _context3.next = 10;
                return this.execute(_rules["default"].slice(), multiple && (0, _mobx.isArrayLike)(value) ? value.slice() : [value]);

              case 10:
                return _context3.abrupt("return", this.validity.valid);

              case 11:
              case "end":
                return _context3.stop();
            }
          }
        }, _callee3, this);
      }));

      function checkValidity() {
        return _checkValidity.apply(this, arguments);
      }

      return checkValidity;
    }()
  }, {
    key: "props",
    get: function get() {
      var control = this.control,
          field = this.field;
      var controlProps = control && (0, _omitBy["default"])(control.getValidatorProps(), _isUndefined["default"]);
      var fieldProps = field && field.getValidatorProps();
      return (0, _objectSpread2["default"])({}, fieldProps, {}, controlProps, {
        defaultValidationMessages: (0, _objectSpread2["default"])({}, controlProps && controlProps.defaultValidationMessages, {}, (0, _configure.getConfig)('defaultValidationMessages'), {}, fieldProps && fieldProps.defaultValidationMessages)
      });
    }
  }, {
    key: "uniqueRefFields",
    get: function get() {
      var _this$props2 = this.props,
          name = _this$props2.name,
          unique = _this$props2.unique,
          record = _this$props2.record;

      if (record && (0, _isString["default"])(unique)) {
        return (0, _toConsumableArray2["default"])(record.fields.values()).filter(function (field) {
          return field.name !== name && field.get('unique') === unique && !field.get('multiple') && !field.get('range');
        });
      }

      return [];
    } // @computed
    // private get bindingFieldWithValidationResult(): Field | undefined {
    //   const { name, record, type } = this.props;
    //   if (record && name && type === FieldType.object) {
    //     return findBindField(name, record.fields, field => !field.isValid());
    //   }
    //   return undefined;
    // }

  }, {
    key: "uniqueRefValidationResult",
    get: function get() {
      var validationResult;
      var uniqueRefFields = this.uniqueRefFields,
          innerValidationResults = this.innerValidationResults;

      if (uniqueRefFields.length && (!innerValidationResults || innerValidationResults.every(function (result) {
        return result.ruleName !== 'uniqueError';
      }))) {
        uniqueRefFields.some(function (uniqueRefField) {
          var validator = uniqueRefField.validator;

          if (validator) {
            var validatorInnerValidationResults = validator.innerValidationResults;
            validationResult = validatorInnerValidationResults && validatorInnerValidationResults.find(function (result) {
              return result.ruleName === 'uniqueError';
            });
          }

          return !!validationResult;
        });
      }

      return validationResult;
    }
  }, {
    key: "validationResults",
    get: function get() {
      var uniqueRefValidationResult = this.uniqueRefValidationResult;

      if (uniqueRefValidationResult) {
        return [uniqueRefValidationResult];
      }

      var innerValidationResults = this.innerValidationResults;

      if (innerValidationResults && innerValidationResults.length) {
        return innerValidationResults;
      } // const { bindingFieldWithValidationResult } = this;
      // if (bindingFieldWithValidationResult) {
      //   return bindingFieldWithValidationResult.getValidationErrorValues();
      // }


      return [];
    }
  }, {
    key: "currentValidationResult",
    get: function get() {
      var validationResults = this.validationResults;
      return validationResults.length ? validationResults[0] : undefined;
    }
  }, {
    key: "validity",
    get: function get() {
      var currentValidationResult = this.currentValidationResult;
      return new _Validity["default"](currentValidationResult ? (0, _defineProperty2["default"])({}, currentValidationResult.ruleName, true) : undefined);
    }
  }, {
    key: "injectionOptions",
    get: function get() {
      var currentValidationResult = this.currentValidationResult;
      return currentValidationResult && currentValidationResult.injectionOptions || {};
    }
  }, {
    key: "validationMessage",
    get: function get() {
      var currentValidationResult = this.currentValidationResult;
      return currentValidationResult && currentValidationResult.validationMessage;
    }
  }]);
  return Validator;
}();

exports["default"] = Validator;
(0, _tslib.__decorate)([_mobx.observable], Validator.prototype, "field", void 0);
(0, _tslib.__decorate)([_mobx.observable], Validator.prototype, "control", void 0);
(0, _tslib.__decorate)([_mobx.observable], Validator.prototype, "innerValidationResults", void 0);
(0, _tslib.__decorate)([_mobx.computed], Validator.prototype, "props", null);
(0, _tslib.__decorate)([_mobx.computed], Validator.prototype, "uniqueRefValidationResult", null);
(0, _tslib.__decorate)([_mobx.computed], Validator.prototype, "validity", null);
(0, _tslib.__decorate)([_mobx.action], Validator.prototype, "reset", null);
(0, _tslib.__decorate)([_mobx.action], Validator.prototype, "report", null);
(0, _tslib.__decorate)([_mobx.action], Validator.prototype, "clearErrors", null);
(0, _tslib.__decorate)([_mobx.action], Validator.prototype, "addError", null);
//# sourceMappingURL=Validator.js.map