@configuratorware/configurator-admingui 1.28.5 → 1.29.2

package/Screens/Creator/Components/BaseConfigurationEditor.js

@@ -0,0 +1,241 @@
+"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"));
+
+var _reactRedux = require("react-redux");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _network = _interopRequireDefault(require("../../../App/Config/network"));
+
+var _RaisedButton = _interopRequireDefault(require("../../../UIComponents/RaisedButton"));
+
+var _InfoOutlineIcon = _interopRequireDefault(require("../../../UIComponents/icons/InfoOutlineIcon"));
+
+var _Image = _interopRequireDefault(require("../../../Components/GeneralFragments/Image"));
+
+var _i18n = require("../../../App/i18n");
+
+var _ConfigurationActions = require("../Reducers/ConfigurationActions");
+
+var _Actions = require("../../Creator/Reducers/Actions");
+
+var _ConfigurationEditor = _interopRequireDefault(require("../../../Components/GeneralFragments/ConfigurationEditor"));
+
+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 BaseConfigurationEditor = /*#__PURE__*/function (_React$Component) {
+  _inherits(BaseConfigurationEditor, _React$Component);
+
+  var _super = _createSuper(BaseConfigurationEditor);
+
+  function BaseConfigurationEditor() {
+    var _this;
+
+    _classCallCheck(this, BaseConfigurationEditor);
+
+    for (var _len = arguments.length, _args = new Array(_len), _key = 0; _key < _len; _key++) {
+      _args[_key] = arguments[_key];
+    }
+
+    _this = _super.call.apply(_super, [this].concat(_args));
+
+    _defineProperty(_assertThisInitialized(_this), "closeConfigurator", function () {
+      _this.props.closeConfigurator();
+
+      _this.props.loadBaseConfiguration(_this.props.identifier);
+    });
+
+    _defineProperty(_assertThisInitialized(_this), "configurationSaved", function () {
+      var _this$props;
+
+      (_this$props = _this.props).configurationSaved.apply(_this$props, arguments);
+
+      _this.closeConfigurator();
+    });
+
+    return _this;
+  }
+
+  _createClass(BaseConfigurationEditor, [{
+    key: "componentWillMount",
+    value: function componentWillMount() {
+      var identifier = _lodash["default"].get(this.props.baseConfiguration, 'option.identifier');
+
+      if ((!identifier || identifier !== this.props.identifier) && this.props.identifier) {
+        this.props.loadBaseConfiguration(this.props.identifier);
+      }
+    }
+  }, {
+    key: "componentWillReceiveProps",
+    value: function componentWillReceiveProps(props) {
+      if (props.identifier && props.identifier !== this.props.identifier) {
+        this.props.loadBaseConfiguration(props.identifier);
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props2 = this.props,
+          identifier = _this$props2.identifier,
+          optionclassifications = _this$props2.optionclassifications,
+          baseConfigurationState = _this$props2.baseConfigurationState,
+          constructionPatternsReady = _this$props2.constructionPatternsReady,
+          configuratorUrl = _this$props2.configuratorUrl;
+      var stateText = constructionPatternsReady ? baseConfigurationState && baseConfigurationState !== 'ready' ? (0, _i18n.T)("constructionPatterns.baseConfiguration.state.".concat(baseConfigurationState)) : '' : (0, _i18n.T)('constructionPatterns.baseConfiguration.noOptionclassificationsAdded');
+      return /*#__PURE__*/_react["default"].createElement("div", null, /*#__PURE__*/_react["default"].createElement("div", {
+        className: "baseConfigurationEditor-info"
+      }, (0, _i18n.T)('constructionPatterns.baseConfiguration.infoText')), baseConfigurationState === 'ready' && /*#__PURE__*/_react["default"].createElement("div", {
+        className: "options-wrapper"
+      }, /*#__PURE__*/_react["default"].createElement("ul", null, optionclassifications.map(function (oc) {
+        var option = _lodash["default"].get(oc, 'selectedoptions[0]');
+
+        if (!option) {
+          return null;
+        }
+
+        return /*#__PURE__*/_react["default"].createElement("li", {
+          key: oc.identifier
+        }, /*#__PURE__*/_react["default"].createElement(OptionclassificationTile, {
+          optionclassification: oc,
+          options: oc.selectedoptions
+        }));
+      }))), stateText && /*#__PURE__*/_react["default"].createElement("div", {
+        className: "baseConfigurationEditor-state"
+      }, /*#__PURE__*/_react["default"].createElement(_InfoOutlineIcon["default"], null), stateText), /*#__PURE__*/_react["default"].createElement(_RaisedButton["default"], {
+        label: (0, _i18n.T)('constructionPatterns.baseConfiguration.openConfiguratorButtonText'),
+        onClick: this.props.openConfigurator,
+        disabled: !constructionPatternsReady
+      }), /*#__PURE__*/_react["default"].createElement(_ConfigurationEditor["default"], {
+        adminMode: "defaultoptions",
+        show: this.props.showConfigurator && identifier,
+        configuratorUrl: configuratorUrl,
+        onSaved: this.configurationSaved,
+        onClose: this.closeConfigurator
+      }));
+    }
+  }]);
+
+  return BaseConfigurationEditor;
+}(_react["default"].Component);
+
+var OptionclassificationTile = /*#__PURE__*/function (_React$Component2) {
+  _inherits(OptionclassificationTile, _React$Component2);
+
+  var _super2 = _createSuper(OptionclassificationTile);
+
+  function OptionclassificationTile() {
+    _classCallCheck(this, OptionclassificationTile);
+
+    return _super2.apply(this, arguments);
+  }
+
+  _createClass(OptionclassificationTile, [{
+    key: "render",
+    value: function render() {
+      var _this$props3 = this.props,
+          optionclassification = _this$props3.optionclassification,
+          options = _this$props3.options;
+      return /*#__PURE__*/_react["default"].createElement("div", {
+        className: "baseConfigurationEditor-optionclassification"
+      }, /*#__PURE__*/_react["default"].createElement("div", {
+        className: "optionclassificationTitle"
+      }, optionclassification.title), /*#__PURE__*/_react["default"].createElement("div", {
+        className: "optionListContainer"
+      }, options.map(function (option) {
+        return /*#__PURE__*/_react["default"].createElement("div", {
+          key: option.identifier,
+          className: "optionListItem"
+        }, /*#__PURE__*/_react["default"].createElement("div", {
+          className: "optionImg"
+        }, /*#__PURE__*/_react["default"].createElement(_Image["default"], {
+          src: option.thumbnail
+        })), /*#__PURE__*/_react["default"].createElement("div", {
+          className: "optionIdentifier",
+          title: option.identifier
+        }, option.identifier), /*#__PURE__*/_react["default"].createElement("div", {
+          className: "optionTitle"
+        }, option.title), option.amount > 1 && /*#__PURE__*/_react["default"].createElement("div", {
+          className: "optionAmount"
+        }, option.amount, "x"));
+      })));
+    }
+  }]);
+
+  return OptionclassificationTile;
+}(_react["default"].Component);
+
+function mapStateToProps(state) {
+  var i18n = state.i18n;
+
+  var itemData = _lodash["default"].get(state[_Actions.CREATOR_REDUCER_NAME], 'source');
+
+  var baseConfigurationData = state[_ConfigurationActions.CONFIGURATION_REDUCER_NAME];
+
+  var identifier = _lodash["default"].get(itemData, 'identifier');
+
+  var locale = i18n.locale.replace('-', '_');
+  var configuratorUrl = _network["default"].configuratorBasePath + 'identifier:' + identifier + '?_adminmode=defaultoptions&_hidevariantselection=true&_deliverycountry=de' + '&_language=' + locale + '&_admin_mode_hash=' + baseConfigurationData.adminModeHash;
+
+  var optionclassifications = _lodash["default"].get(baseConfigurationData.baseConfiguration, 'optionclassifications', []);
+
+  return {
+    baseConfiguration: baseConfigurationData.baseConfiguration,
+    baseConfigurationState: baseConfigurationData.baseConfigurationState,
+    showConfigurator: baseConfigurationData.showConfigurator,
+    constructionPatternsReady: _lodash["default"].get(baseConfigurationData, 'data.selectableComponents.value.length', 0) > 0,
+    optionclassifications: optionclassifications,
+    identifier: identifier,
+    configuratorUrl: configuratorUrl
+  };
+}
+
+function mapDispatchToProps(dispatch) {
+  return {
+    loadBaseConfiguration: function loadBaseConfiguration(identifier) {
+      return dispatch((0, _ConfigurationActions.fetchBaseConfiguration)(identifier));
+    },
+    openConfigurator: function openConfigurator() {
+      return dispatch((0, _ConfigurationActions.saveConstructionPattern)());
+    },
+    closeConfigurator: function closeConfigurator() {
+      return dispatch((0, _ConfigurationActions.showConfigurator)(false));
+    },
+    configurationSaved: function configurationSaved(apiAction) {
+      return dispatch((0, _ConfigurationActions.saveConfigurationSuccess)(apiAction.data));
+    }
+  };
+}
+
+var _default = (0, _reactRedux.connect)(mapStateToProps, mapDispatchToProps)(BaseConfigurationEditor);
+
+exports["default"] = _default;

package/Screens/Creator/Components/CheckData/ApiCalls.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.checkItemData = void 0;
+
+var _lazyFetch = require("../../../../Utils/Request/lazyFetch");
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+var DATA_CHECK_URL = 'data_checks/{identifier}';
+
+var checkItemData = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee(identifier) {
+    return regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return (0, _lazyFetch.lazyFetch)(DATA_CHECK_URL, {
+              identifier: identifier
+            });
+
+          case 2:
+            return _context.abrupt("return", _context.sent.data);
+
+          case 3:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function checkItemData(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+exports.checkItemData = checkItemData;

package/Screens/Creator/Components/CheckData/CheckData.js

@@ -0,0 +1,332 @@
+"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 _withStyles = _interopRequireDefault(require("@material-ui/core/styles/withStyles"));
+
+var _react = _interopRequireWildcard(require("react"));
+
+var _i18n = require("../../../../App/i18n");
+
+var _CircularProgress = _interopRequireDefault(require("@material-ui/core/CircularProgress"));
+
+var _Dialog = _interopRequireDefault(require("../../../../UIComponents/Dialog"));
+
+var _ApiCalls = require("./ApiCalls");
+
+var _Typography = _interopRequireDefault(require("@material-ui/core/Typography"));
+
+var _icons = require("@material-ui/icons");
+
+require("./Translations");
+
+var _FlatButton = _interopRequireDefault(require("../../../../UIComponents/FlatButton"));
+
+var _RaisedButton = _interopRequireDefault(require("../../../../UIComponents/RaisedButton"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+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 _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; }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+var asyncDialogStyles = function asyncDialogStyles() {
+  return {
+    dialog: {
+      display: 'flex',
+      flexDirection: 'column'
+    },
+    buttonProgress: {
+      position: 'absolute'
+    }
+  };
+};
+
+var AsyncDialog = (0, _withStyles["default"])(asyncDialogStyles)(function (_ref) {
+  var classes = _ref.classes,
+      asyncTask = _ref.asyncTask,
+      buttonLabel = _ref.buttonLabel,
+      dialogTitle = _ref.dialogTitle,
+      buttonDisabled = _ref.buttonDisabled,
+      children = _ref.children,
+      buttonProps = _ref.buttonProps,
+      dialogProps = _ref.dialogProps;
+
+  var _useState = (0, _react.useState)(false),
+      _useState2 = _slicedToArray(_useState, 2),
+      open = _useState2[0],
+      setOpen = _useState2[1];
+
+  var _useState3 = (0, _react.useState)(false),
+      _useState4 = _slicedToArray(_useState3, 2),
+      loading = _useState4[0],
+      setLoading = _useState4[1];
+
+  (0, _react.useEffect)(function () {
+    _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+      return regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              if (!open) {
+                _context.next = 8;
+                break;
+              }
+
+              setLoading(true);
+              _context.prev = 2;
+              _context.next = 5;
+              return asyncTask();
+
+            case 5:
+              _context.prev = 5;
+              setLoading(false);
+              return _context.finish(5);
+
+            case 8:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee, null, [[2,, 5, 8]]);
+    }))();
+  }, [open]);
+
+  var _onClose = function onClose() {
+    setOpen(false);
+  };
+
+  return /*#__PURE__*/_react["default"].createElement(_react["default"].Fragment, null, /*#__PURE__*/_react["default"].createElement(_RaisedButton["default"], _extends({
+    variant: "contained",
+    onClick: function onClick() {
+      return setOpen(true);
+    },
+    disabled: loading || buttonDisabled
+  }, buttonProps), buttonLabel, loading && /*#__PURE__*/_react["default"].createElement(_CircularProgress["default"], {
+    className: classes.buttonProgress,
+    size: 24
+  })), /*#__PURE__*/_react["default"].createElement(_Dialog["default"], _extends({
+    title: dialogTitle,
+    modal: 'true',
+    open: !loading && open,
+    scroll: 'body',
+    onClose: function onClose() {
+      return _onClose;
+    },
+    maxWidth: "sm",
+    classes: {
+      dialogContentTextRoot: classes.dialog
+    },
+    actions: [/*#__PURE__*/_react["default"].createElement(_FlatButton["default"], {
+      label: (0, _i18n.T)('Ok'),
+      key: "closeButton",
+      primary: false,
+      onClick: _onClose
+    })]
+  }, dialogProps), children));
+});
+var styles = {
+  messageTypeLabel: {
+    display: 'inline-flex',
+    alignItems: 'center',
+    alignSelf: 'flex-end',
+    marginLeft: 'auto',
+    fontWeight: 'bold',
+    '&.type-neutral': {},
+    '&.type-notice': {
+      color: 'orange',
+      paddingRight: 5
+    },
+    '&.type-error': {
+      color: 'red',
+      paddingRight: 5
+    }
+  },
+  icon: {
+    marginLeft: 10,
+    marginRight: 5,
+    position: 'relative',
+    top: -1
+  },
+  items: {
+    display: 'inline-flex',
+    flexDirection: 'column',
+    paddingTop: 15
+  },
+  item: {
+    display: 'inline-flex',
+    whiteSpace: 'nowrap'
+  },
+  error: {
+    color: 'red'
+  }
+};
+var CheckData = (0, _withStyles["default"])(styles)(function (_ref3) {
+  var itemIdentifier = _ref3.itemIdentifier,
+      itemId = _ref3.itemId,
+      checkItemData = _ref3.checkItemData,
+      area = _ref3.area,
+      license = _ref3.license,
+      classes = _ref3.classes;
+
+  var _useState5 = (0, _react.useState)(null),
+      _useState6 = _slicedToArray(_useState5, 2),
+      data = _useState6[0],
+      setData = _useState6[1];
+
+  var _useState7 = (0, _react.useState)(null),
+      _useState8 = _slicedToArray(_useState7, 2),
+      error = _useState8[0],
+      setError = _useState8[1];
+
+  var loadData = /*#__PURE__*/function () {
+    var _ref4 = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2() {
+      var result;
+      return regeneratorRuntime.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.prev = 0;
+              setError(null);
+              _context2.next = 4;
+              return checkItemData(itemIdentifier);
+
+            case 4:
+              result = _context2.sent;
+              result && result.length > 0 ? filterResult(result) : setError('dataCheck.dataCheckFailed');
+              _context2.next = 11;
+              break;
+
+            case 8:
+              _context2.prev = 8;
+              _context2.t0 = _context2["catch"](0);
+              setError('dataCheck.dataCheckFailed');
+
+            case 11:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2, null, [[0, 8]]);
+    }));
+
+    return function loadData() {
+      return _ref4.apply(this, arguments);
+    };
+  }(); // item level: show results for item, creator & designer - unless you have a license for creator/designer only
+  // creator level: show results for item and creator
+  // designer level: show results for item and designer
+
+
+  var areasCreatorDesigner = area ? [area] : license ? license.split('+') : ['creator', 'designer'];
+  var areas = ['item'].concat(_toConsumableArray(areasCreatorDesigner));
+
+  var filterResult = function filterResult(result) {
+    var filteredResult = {};
+    areas.forEach(function (area) {
+      filteredResult[area] = result.filter(function (element) {
+        return element.element && element.element.startsWith(area);
+      });
+    });
+    setData(filteredResult);
+  };
+
+  var renderResult = function renderResult(result) {
+    return Object.keys(result).map(function (key) {
+      return /*#__PURE__*/_react["default"].createElement("div", {
+        style: styles.items,
+        key: key
+      }, /*#__PURE__*/_react["default"].createElement(_Typography["default"], {
+        variant: "h6"
+      }, (0, _i18n.T)("dataCheck.".concat(key))), renderElements(result[key]));
+    });
+  };
+
+  var renderElements = function renderElements(elements) {
+    var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    return elements.map(function (_ref5, idx) {
+      var element = _ref5.element,
+          type = _ref5.type,
+          placeholders = _ref5.placeholders,
+          children = _ref5.children;
+      var Icon = {
+        neutral: function neutral() {
+          return null;
+        },
+        notice: _icons.ErrorOutline,
+        error: _icons.Cancel
+      }[type];
+      var bulletPoint = ['○', '•', '⁃', '◘', '◙', '‣'][depth];
+      var termKey = "dataCheck.messages.".concat(element.replaceAll('.', '_'), "_").concat(type);
+      return /*#__PURE__*/_react["default"].createElement("div", {
+        style: _objectSpread(_objectSpread({}, styles.items), {
+          paddingLeft: depth * 10,
+          paddingTop: depth === 0 ? 5 : 0
+        }),
+        key: idx
+      }, /*#__PURE__*/_react["default"].createElement("div", {
+        style: styles.item
+      }, bulletPoint, /*#__PURE__*/_react["default"].createElement("span", null, "\xA0\xA0"), (0, _i18n.T)(termKey, placeholders.reduce(function (keys, _ref6) {
+        var key = _ref6.key,
+            value = _ref6.value;
+        return _objectSpread(_objectSpread({}, keys), {}, _defineProperty({}, key, value));
+      }, {})), /*#__PURE__*/_react["default"].createElement("span", {
+        className: classes.messageTypeLabel + ' type-' + type
+      }, /*#__PURE__*/_react["default"].createElement(Icon, {
+        fontSize: 'inherit',
+        className: classes.icon
+      }), (0, _i18n.T)("dataCheck.types.".concat(type)))), children && children.length > 0 && renderElements(children, depth + 1));
+    });
+  };
+
+  return /*#__PURE__*/_react["default"].createElement(AsyncDialog, {
+    buttonLabel: (0, _i18n.T)('dataCheck.buttonLabel'),
+    dialogTitle: (0, _i18n.T)('dataCheck.dialogTitle'),
+    buttonDisabled: !itemId,
+    asyncTask: loadData
+  }, data && renderResult(data), error && /*#__PURE__*/_react["default"].createElement("div", {
+    className: classes.error
+  }, (0, _i18n.T)(error)));
+});
+CheckData.defaultProps = {
+  checkItemData: _ApiCalls.checkItemData
+};
+var _default = CheckData;
+exports["default"] = _default;