@configuratorware/configurator-admingui 1.28.3 → 1.29.1

package/App/Data.js

@@ -0,0 +1,473 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getErrorsFromValidatedDataObject = exports.validateDataObject = exports.DataValidator = exports["default"] = void 0;
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _validate = require("validate.js");
+
+var _isArray = _interopRequireDefault(require("lodash/isArray"));
+
+var _i18n = require("./i18n");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+_validate.validate.validators.nonEmptyArray = function (value, options) {
+  if (options && options === true && (0, _isArray["default"])(value) && value.length !== 0) {
+    return null;
+  }
+
+  return (0, _i18n.t)('customValidators.nonEmptyArray');
+};
+
+_validate.validate.validators.emptyOrPositive = function (value, options) {
+  if (options && options === true && (!isNaN(+value) && +value > 0 || !value)) {
+    return null;
+  }
+
+  return (0, _i18n.t)('customValidators.numericality');
+};
+
+_validate.validate.validators.numericOrEmpty = function (value, options) {
+  if (value === '' || value === null) {
+    return null;
+  } else {
+    return _validate.validate.validators.numericality(value, options);
+  }
+};
+
+_validate.validate.validators.identifier = function (value, options) {
+  var pattern = /^[A-za-z0-9_.-]+$/;
+
+  if (options && options === true && typeof value === 'string' && value.match(pattern) && value.match(pattern)[0] === value) {
+    return null;
+  }
+
+  return (0, _i18n.t)('customValidators.identifier');
+};
+
+_validate.validate.validators.decimalPoint = function (value, options) {
+  if (options === true && (!value || !value.length || /^[\d]+\.?[\d]*$/.test(value))) {
+    return null;
+  }
+
+  return (0, _i18n.t)('customValidators.decimalPoint');
+};
+
+_validate.validate.validators.color = function (value, options) {
+  if (value === '' || value === undefined) {
+    return (0, _i18n.t)('customValidators.balnkError');
+  }
+
+  var pattern = /^#[0-9a-fA-F]{6}$/i;
+  var s = new Option().style;
+  s.color = value;
+  var isValidColorText = s.color == value;
+
+  if (options && options === true && typeof value === 'string' && (isValidColorText || value.match(pattern) && value.match(pattern)[0] === value)) {
+    return null;
+  }
+
+  return true;
+};
+
+var Data = /*#__PURE__*/function () {
+  function Data(dataObject) {
+    var mutate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+
+    _classCallCheck(this, Data);
+
+    Data.instances++;
+    this._listeners = {};
+
+    if (dataObject) {
+      this.init(dataObject, mutate);
+    }
+  }
+
+  _createClass(Data, [{
+    key: "value",
+    get: function get() {
+      return this.getData();
+    },
+    set: function set(data) {
+      this.init(data);
+    }
+  }, {
+    key: "addListener",
+    value: function addListener(event, fn) {
+      if (!this._listeners[event]) {
+        this._listeners[event] = [];
+      }
+
+      this._listeners[event].push(fn);
+    }
+  }, {
+    key: "removeListener",
+    value: function removeListener(event, fn) {
+      if (!_lodash["default"].isArray(this._listeners[event])) {
+        return;
+      }
+
+      this._listeners[event] = this._listeners[event].filter(function (item) {
+        if (item !== fn) {
+          return item;
+        }
+      });
+    }
+  }, {
+    key: "_trigger",
+    value: function _trigger(event, data) {
+      var _this = this;
+
+      if (this._listeners[event]) {
+        this._listeners[event].forEach(function (item) {
+          return item({
+            data: _this,
+            event: _objectSpread({
+              type: event
+            }, data)
+          });
+        });
+      }
+    }
+    /*** *** ***/
+
+  }, {
+    key: "init",
+    value: function init(dataObject) {
+      var _this2 = this;
+
+      var mutate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      this._data = dataObject ? mutate ? dataObject : _lodash["default"].cloneDeep(dataObject) : _lodash["default"].cloneDeep(this);
+      this._initialObject = _lodash["default"].cloneDeep(this._data);
+      this._validator = new DataValidator(this._data);
+
+      var _loop = function _loop(prop) {
+        Object.defineProperty(_this2, prop, {
+          get: function get() {
+            return _this2._data[prop];
+          },
+          set: function set(value) {
+            if (_this2._data[prop].value !== value) {
+              _this2._data[prop].value = value;
+
+              _this2._validator.invalidate();
+
+              _this2._trigger(Data.EventTypes.setValue, {
+                prop: prop,
+                value: value
+              });
+            }
+          }
+        });
+      };
+
+      for (var prop in this._data) {
+        _loop(prop);
+      }
+
+      this._trigger(Data.EventTypes.init);
+
+      return this;
+    }
+  }, {
+    key: "updateSchemaObject",
+    value: function updateSchemaObject(schemaObject) {
+      for (var p in this._data) {
+        if (p in schemaObject) {
+          this._data[p] = _lodash["default"].cloneDeep(schemaObject[p]);
+        }
+      }
+    }
+  }, {
+    key: "updateValues",
+    value: function updateValues(dataObject) {
+      var _this3 = this;
+
+      // skip if dataObject is not a real object
+      if (!_lodash["default"].isPlainObject(dataObject)) {
+        return this;
+      }
+
+      var modifiedProps = [];
+
+      for (var p in this._data) {
+        if (p in dataObject && this._data[p].value !== dataObject[p]) {
+          this._data[p].value = dataObject[p];
+          modifiedProps.push(p);
+        }
+      } // trigger setValue event for each modified property
+
+
+      modifiedProps.forEach(function (prop) {
+        return _this3._trigger(Data.EventTypes.setValue, {
+          prop: prop,
+          value: _this3[prop]
+        });
+      }); // trigger the update event
+
+      if (modifiedProps.length > 0) {
+        this._trigger(Data.EventTypes.update);
+      }
+
+      return this;
+    }
+  }, {
+    key: "reset",
+    value: function reset(evtData) {
+      this._data = _lodash["default"].cloneDeep(this._initialObject);
+
+      this._validator.setDataObject(this._data);
+
+      this._trigger(Data.EventTypes.reset, evtData);
+    }
+  }, {
+    key: "getValue",
+    value: function getValue(prop) {
+      return this._data[prop].value;
+    }
+  }, {
+    key: "setValue",
+    value: function setValue(prop, value) {
+      if (this._data[prop].value !== value) {
+        this._data[prop].value = value;
+
+        this._trigger(Data.EventTypes.setValue, {
+          prop: prop,
+          value: value
+        });
+      }
+    }
+  }, {
+    key: "getError",
+    value: function getError(prop) {
+      return this._data[prop].error;
+    }
+  }, {
+    key: "setError",
+    value: function setError(prop, error) {
+      this._data[prop].error = error;
+    }
+  }, {
+    key: "validate",
+    value: function validate() {
+      var isValid = this._validator.validate();
+
+      this._trigger(Data.EventTypes.validate, {
+        isValid: isValid
+      });
+
+      return isValid;
+    }
+  }, {
+    key: "getErrors",
+    value: function getErrors() {
+      return this._validator.getErrors();
+    }
+  }, {
+    key: "setErrors",
+    value: function setErrors(errorObject) {
+      if (!_lodash["default"].isObject(errorObject)) {
+        errorObject = {};
+      }
+
+      for (var p in this._data) {
+        if (p in errorObject) {
+          this._data[p].error = errorObject[p];
+        } else {
+          delete this._data[p].error;
+        }
+      }
+
+      this._trigger(Data.EventTypes.setErrors, errorObject);
+    }
+  }, {
+    key: "getData",
+    value: function getData() {
+      var data = {};
+
+      for (var p in this._data) {
+        data[p] = this._data[p].value;
+      }
+
+      return data;
+    }
+  }]);
+
+  return Data;
+}();
+
+exports["default"] = Data;
+
+_defineProperty(Data, "EventTypes", {
+  init: 'init',
+  update: 'update',
+  reset: 'reset',
+  validate: 'validate',
+  setValue: 'setValue',
+  setErrors: 'setErrors'
+});
+
+_defineProperty(Data, "instances", 0);
+
+var DataValidator = /*#__PURE__*/function () {
+  function DataValidator(dataObject) {
+    var mutate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+
+    _classCallCheck(this, DataValidator);
+
+    this.setDataObject(dataObject, mutate);
+  }
+
+  _createClass(DataValidator, [{
+    key: "setDataObject",
+    value: function setDataObject(dataObject) {
+      var mutate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      this._data = mutate ? dataObject : _lodash["default"].cloneDeep(dataObject);
+      this._validation = {
+        isDone: false
+      };
+    }
+  }, {
+    key: "invalidate",
+    value: function invalidate() {
+      this._validation.isDone = false;
+    }
+  }, {
+    key: "isValidated",
+    value: function isValidated() {
+      return this._validation.isDone;
+    }
+  }, {
+    key: "validate",
+    value: function validate() {
+      var isValid = true;
+
+      for (var prop in this._data) {
+        var dataSchema = _lodash["default"].get(this._data[prop], 'schema');
+
+        if (dataSchema instanceof Data) {
+          isValid = dataSchema.validate() && isValid;
+        }
+      }
+
+      isValid = validateDataObject(this._data) && isValid;
+      this._validation.isDone = true;
+      return isValid;
+    }
+  }, {
+    key: "getValidatedData",
+    value: function getValidatedData() {
+      if (!this._validation.isDone) {
+        this.validate();
+      }
+
+      return this._data;
+    }
+  }, {
+    key: "getErrors",
+    value: function getErrors() {
+      if (!this._validation.isDone) {
+        this.validate();
+      }
+
+      return getErrorsFromValidatedDataObject(this._data);
+    }
+  }]);
+
+  return DataValidator;
+}();
+
+exports.DataValidator = DataValidator;
+
+var validateField = function validateField(prop, valueToValidate, idx) {
+  var valid = true;
+
+  if (prop.constraints) {
+    var result = _validate.validate.single(valueToValidate, prop.constraints);
+
+    if (idx !== undefined) {
+      prop.error = prop.error || [];
+      prop.error[idx] = result ? result.join(', ') : undefined;
+    } else {
+      if (result) {
+        prop.error = result.join(', ');
+      } else if (prop.error) {
+        delete prop.error;
+      }
+    }
+
+    valid = valid && !result;
+  }
+
+  return valid;
+};
+
+var validateDataObject = function validateDataObject(dataObject, valueObject, idx) {
+  var valid = true;
+
+  var _loop2 = function _loop2(p) {
+    var prop = dataObject[p];
+    var valueToValidate = valueObject ? valueObject[p] : prop.value;
+    valid = validateField(prop, valueToValidate, idx) && valid;
+
+    if (prop.schema) {
+      if (_lodash["default"].isArray(prop.value)) {
+        // validate all values against the schema rules
+        prop.value.forEach(function (value, idx) {
+          valid = validateDataObject(prop.schema, value, idx) && valid;
+        });
+      } else if (prop.value === null) {// skip validation, if the value is null
+      } else {
+        valid = validateDataObject(prop.schema, prop.value) && valid;
+      }
+    }
+  };
+
+  for (var p in dataObject) {
+    _loop2(p);
+  }
+
+  return valid;
+};
+
+exports.validateDataObject = validateDataObject;
+
+var getErrorsFromValidatedDataObject = function getErrorsFromValidatedDataObject(dataObject) {
+  var errors = [];
+
+  for (var p in dataObject) {
+    var prop = dataObject[p];
+
+    if (prop.error) {
+      errors.push({
+        property: p,
+        message: prop.error
+      });
+    }
+
+    if (prop.schema) {
+      errors = errors.concat(getErrorsFromValidatedDataObject(prop.schema));
+    }
+  }
+
+  return errors;
+};
+
+exports.getErrorsFromValidatedDataObject = getErrorsFromValidatedDataObject;

package/App/Entity.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _reactRedux = require("react-redux");
+
+var _Dialog = _interopRequireDefault(require("../UIComponents/Dialog"));
+
+var _FlatButton = _interopRequireDefault(require("../UIComponents/FlatButton"));
+
+var _i18n = require("./i18n");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var Styles = {
+  dialog: {
+    zIndex: 99999999999
+  }
+};
+/**
+ * A component to show the Entity related modal dialogs
+ *  - connected with redux, uses the Entity reducer
+ * Responsibilities:
+ *  - renders a dialog when an unsaved entity is present during the navigation
+ *  - renders a dialog to confirm the deletion of entities
+ * @param props
+ * @constructor
+ */
+
+var Entity = function Entity(props) {
+  function handleUnsavedEntityClose() {
+    props.unsavedEntity && props.unsavedEntity.cancel();
+  }
+
+  function handleDeleteEntityClose() {
+    props.deleteEntities && props.deleteEntities.cancel();
+  }
+
+  return /*#__PURE__*/_react["default"].createElement("div", null, /*#__PURE__*/_react["default"].createElement(_Dialog["default"], {
+    title: (0, _i18n.T)('Leaving edit view'),
+    onClose: handleUnsavedEntityClose,
+    actions: /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, /*#__PURE__*/_react["default"].createElement(_FlatButton["default"], {
+      label: (0, _i18n.T)('Save and leave'),
+      primary: true,
+      onClick: props.unsavedEntity && props.unsavedEntity.saveAndHide
+    }), /*#__PURE__*/_react["default"].createElement(_FlatButton["default"], {
+      label: (0, _i18n.T)('Leave without saving'),
+      onClick: props.unsavedEntity && props.unsavedEntity.hide
+    }), /*#__PURE__*/_react["default"].createElement(_FlatButton["default"], {
+      label: (0, _i18n.T)('Cancel'),
+      onClick: props.unsavedEntity && props.unsavedEntity.cancel
+    })),
+    open: props.unsavedEntityDialog,
+    style: Styles.dialog
+  }, (0, _i18n.T)('entity.modificationsNotSaved')), /*#__PURE__*/_react["default"].createElement(_Dialog["default"], {
+    title: (0, _i18n.T)('entity.deleteTitle'),
+    onClose: handleDeleteEntityClose,
+    actions: /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, /*#__PURE__*/_react["default"].createElement(_FlatButton["default"], {
+      label: (0, _i18n.T)('entity.deleteTitle'),
+      primary: true,
+      onClick: props.deleteEntities && props.deleteEntities.onDelete
+    }), /*#__PURE__*/_react["default"].createElement(_FlatButton["default"], {
+      label: (0, _i18n.T)('Cancel'),
+      onClick: props.deleteEntities && props.deleteEntities.cancel
+    })),
+    open: props.deleteEntitiesDialog,
+    style: Styles.dialog
+  }, (0, _i18n.T)('entity.deleteConfirm')));
+};
+
+var mapStateToProps = function mapStateToProps(_ref) {
+  var entity = _ref.entity;
+  return {
+    unsavedEntity: entity.unsavedEntity,
+    unsavedEntityDialog: entity.unsavedEntity.showDialog,
+    deleteEntities: entity.deleteEntities,
+    deleteEntitiesDialog: entity.deleteEntities.showDialog
+  };
+};
+
+var _default = (0, _reactRedux.connect)(mapStateToProps)(Entity);
+
+exports["default"] = _default;

package/App/ErrorBoundary.js

@@ -0,0 +1,126 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var styles = {
+  wrapper: {
+    textAlign: 'center'
+  },
+  title: {
+    paddingTop: 50,
+    paddingBottom: 25
+  },
+  button: {
+    display: 'block',
+    margin: 'auto'
+  },
+  error: {
+    display: 'inline-block',
+    textAlign: 'left',
+    paddingTop: 25
+  },
+  errorText: {
+    color: 'red'
+  },
+  label: {
+    fontWeight: 'bold',
+    marginTop: 15
+  }
+};
+
+var ErrorBoundary = /*#__PURE__*/function (_React$Component) {
+  _inherits(ErrorBoundary, _React$Component);
+
+  var _super = _createSuper(ErrorBoundary);
+
+  function ErrorBoundary(props) {
+    var _this;
+
+    _classCallCheck(this, ErrorBoundary);
+
+    _this = _super.call(this, props);
+
+    _defineProperty(_assertThisInitialized(_this), "reload", function () {
+      location.reload();
+    });
+
+    _this.state = {
+      hasError: false,
+      error: null,
+      info: null
+    };
+    return _this;
+  }
+
+  _createClass(ErrorBoundary, [{
+    key: "componentDidCatch",
+    value: function componentDidCatch(error, info) {
+      this.setState({
+        hasError: true,
+        error: error,
+        info: info
+      }); // eslint-disable-next-line no-console
+
+      console.error(error, info);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      if (this.state.hasError) {
+        return /*#__PURE__*/_react["default"].createElement("div", {
+          style: styles.wrapper
+        }, /*#__PURE__*/_react["default"].createElement("h1", {
+          style: styles.title
+        }, "Something went wrong."), /*#__PURE__*/_react["default"].createElement("button", {
+          style: styles.button,
+          onClick: this.reload
+        }, "Reload"), /*#__PURE__*/_react["default"].createElement("pre", {
+          style: styles.error
+        }, /*#__PURE__*/_react["default"].createElement("span", {
+          style: styles.errorText
+        }, this.state.error.toString()), /*#__PURE__*/_react["default"].createElement("div", {
+          style: styles.label
+        }, "JS Stack:"), this.state.error.stack && this.state.error.stack.match(/((^.+\n){6})/m)[0], /*#__PURE__*/_react["default"].createElement("div", {
+          style: styles.label
+        }, "Component Stack:"), this.state.info.componentStack.replace(/^\n+/, '')));
+      }
+
+      return this.props.children;
+    }
+  }]);
+
+  return ErrorBoundary;
+}(_react["default"].Component);
+
+exports["default"] = ErrorBoundary;