@configuratorware/configurator-admingui 1.28.1 → 1.29.0

package/Screens/Creator/Components/Rules/Containers/RuleForms/RuleForm.js

@@ -0,0 +1,240 @@
+"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"] = exports.createTextDescriptor = exports.createDataContainerDescriptor = exports.createDataFieldDescriptor = exports.createOptionFieldDescriptor = exports.RuleForm = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _Form = require("../../../../../../Components/Form");
+
+var _Actions = require("../../../../Reducers/Rules/Actions");
+
+var _SimpleNestedData = _interopRequireDefault(require("../../../../../../Components/FormFragments/SimpleNestedData"));
+
+var _i18n = require("../../../../../../App/i18n");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+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 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 _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 RuleForm = /*#__PURE__*/function (_React$Component) {
+  _inherits(RuleForm, _React$Component);
+
+  var _super = _createSuper(RuleForm);
+
+  function RuleForm() {
+    var _this;
+
+    _classCallCheck(this, RuleForm);
+
+    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), "onSubmit", function () {
+      _this.checkDefaultValues();
+
+      _this.props.onSubmit();
+    });
+
+    return _this;
+  }
+
+  _createClass(RuleForm, [{
+    key: "checkDefaultValues",
+    value: function checkDefaultValues() {
+      var data = this.props.data;
+      var dataSchema = data.data.schema; // set all the values that are not in the entity state yet (default values)
+
+      var defaultValues = {};
+      var shouldUpdate = false;
+
+      for (var p in dataSchema) {
+        if (!_lodash["default"].has(data.data.value, p)) {
+          defaultValues[p] = dataSchema[p].value;
+          shouldUpdate = true;
+        }
+      }
+
+      if (shouldUpdate) {
+        this.props.onChange('data', _objectSpread(_objectSpread({}, data.data.value), defaultValues));
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/_react["default"].createElement(_Form.ConfigurableForm, _extends({}, this.props, {
+        onSubmit: this.onSubmit
+      }));
+    }
+  }]);
+
+  return RuleForm;
+}(_react["default"].Component);
+
+exports.RuleForm = RuleForm;
+
+var labelMapper = function labelMapper(item) {
+  return _objectSpread(_objectSpread({}, item), {}, {
+    label: "".concat(item.translated_title, " (").concat(item.identifier, ")")
+  });
+};
+
+var createOptionFieldDescriptor = function createOptionFieldDescriptor(params) {
+  return _objectSpread({
+    name: 'option',
+    label: 'Option A',
+    type: 'dynSource',
+    sourceConfig: {
+      value: 'id',
+      text: 'label'
+    },
+    dynSource: {
+      type: 'autocomplete',
+      listKey: _Actions.OPTION_LIST_KEY,
+      url: _Actions.OPTION_LIST_URL,
+      autoLoad: false,
+      mapItems: labelMapper
+    },
+    useObjects: true
+  }, params);
+};
+
+exports.createOptionFieldDescriptor = createOptionFieldDescriptor;
+
+var createDataFieldDescriptor = function createDataFieldDescriptor(type, params) {
+  var typeParams;
+
+  switch (type) {
+    case 'option':
+      {
+        typeParams = {
+          name: 'option_identifier',
+          label: 'Option B',
+          type: 'dynSource',
+          sourceConfig: {
+            value: 'identifier',
+            text: 'label'
+          },
+          dynSource: {
+            type: 'autocomplete',
+            listKey: _Actions.OPTION_LIST_KEY,
+            url: _Actions.OPTION_LIST_URL,
+            autoLoad: false,
+            mapItems: labelMapper
+          }
+        };
+        break;
+      }
+
+    case 'optionClassification':
+      {
+        typeParams = {
+          name: 'optionclassification_identifier',
+          label: 'Option classification',
+          type: 'dynSource',
+          sourceConfig: {
+            value: 'identifier',
+            text: 'label'
+          },
+          dynSource: {
+            type: 'autocomplete',
+            listKey: _Actions.OPTIONCLASSIFICATION_LIST_KEY,
+            url: _Actions.OPTIONCLASSIFICATION_LIST_URL,
+            mapItems: labelMapper
+          }
+        };
+        break;
+      }
+
+    case 'attribute':
+      {
+        typeParams = {
+          name: 'attribute_identifier',
+          label: 'Attribute',
+          type: 'dynSource',
+          sourceConfig: {
+            value: 'identifier',
+            text: 'label'
+          },
+          dynSource: {
+            type: 'autocomplete',
+            listKey: _Actions.ATTRIBUTE_LIST_KEY,
+            url: _Actions.ATTRIBUTE_LIST_URL,
+            autoLoad: false,
+            mapItems: labelMapper
+          }
+        };
+        break;
+      }
+
+    default:
+      {
+        typeParams = {
+          type: type
+        };
+      }
+  }
+
+  return _objectSpread(_objectSpread({}, typeParams), params);
+};
+
+exports.createDataFieldDescriptor = createDataFieldDescriptor;
+
+var createDataContainerDescriptor = function createDataContainerDescriptor() {
+  for (var _len2 = arguments.length, fields = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    fields[_key2] = arguments[_key2];
+  }
+
+  return {
+    name: 'data',
+    type: _SimpleNestedData["default"],
+    fields: fields
+  };
+};
+
+exports.createDataContainerDescriptor = createDataContainerDescriptor;
+
+var createTextDescriptor = function createTextDescriptor(key) {
+  return function () {
+    return (0, _i18n.T)(key);
+  };
+};
+
+exports.createTextDescriptor = createTextDescriptor;
+var _default = RuleForm;
+exports["default"] = _default;

package/Screens/Creator/Components/Rules/Containers/RuleForms/index.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formsByType = void 0;
+
+var _OptionDependency = _interopRequireDefault(require("./OptionDependency"));
+
+var _OptionExclusion = _interopRequireDefault(require("./OptionExclusion"));
+
+var _OptionClassificationMinAmount = _interopRequireDefault(require("./OptionClassificationMinAmount"));
+
+var _OptionClassificationMaxAmount = _interopRequireDefault(require("./OptionClassificationMaxAmount"));
+
+var _ItemAttributeMatch = _interopRequireDefault(require("./ItemAttributeMatch"));
+
+var _ItemAttributeMaxSum = _interopRequireDefault(require("./ItemAttributeMaxSum"));
+
+var _OptionMaxAmount = _interopRequireDefault(require("./OptionMaxAmount"));
+
+var _DefaultOption = _interopRequireDefault(require("./DefaultOption"));
+
+var _AdditionalOption = _interopRequireDefault(require("./AdditionalOption"));
+
+var _AttributeValueGroupAutoSwitch = _interopRequireDefault(require("./AttributeValueGroupAutoSwitch"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var formsByType = {
+  optiondependency: _OptionDependency["default"],
+  optionexclusion: _OptionExclusion["default"],
+  optionclassificationminamount: _OptionClassificationMinAmount["default"],
+  optionclassificationmaxamount: _OptionClassificationMaxAmount["default"],
+  itemattributematch: _ItemAttributeMatch["default"],
+  itemattributemaxsum: _ItemAttributeMaxSum["default"],
+  optionmaxamount: _OptionMaxAmount["default"],
+  defaultoption: _DefaultOption["default"],
+  additionaloption: _AdditionalOption["default"],
+  attribute_value_group_auto_switch: _AttributeValueGroupAutoSwitch["default"]
+};
+exports.formsByType = formsByType;

package/Screens/Creator/Components/Rules/Styles.scss

@@ -0,0 +1,38 @@
+.rules {
+  .listHeadline {
+    margin-bottom: 15px;
+  }
+  .editorHeadline {
+    font-weight: normal;
+    margin: 0 0 5px 0;
+    color: black;
+    font-size: 1.2em;
+  }
+  .headlineWrapper {
+    margin: 0 0 30px 0;
+    min-height: 57px;
+  }
+  .ruleTypeList {
+    margin-left: -10px;
+    > div {
+      padding: 10px 10px;
+      cursor: pointer;
+      &.selected {
+        //background-color: rgb(0, 188, 212);
+        //color: white;
+      }
+    }
+  }
+  .hintText {
+    margin-bottom: 20px;
+    color: black;
+  }
+  .split-right {
+    padding-bottom: 74px;
+    .action-buttons {
+      position: absolute;
+      bottom: 24px;
+      right: 24px;
+    }
+  }
+}

package/Screens/Creator/Components/Rules/Translations.js

@@ -0,0 +1,178 @@
+"use strict";
+
+require("../../../../App/i18n").use({
+  en: {
+    rules: 'Rules',
+    ruleEditor: {
+      addRule: 'Add rule',
+      selectRuleTypeHint: 'Select the desired rule',
+      listHeadline: 'The following rules applied to this product:',
+      ruleTypes: {
+        optiondependency: {
+          name: 'Prerequisite',
+          optionText: 'This option',
+          optionLabel: 'option a',
+          dataOptionText: 'requires the following option',
+          dataOptionLabel: 'option b',
+          description: 'If the user chooses %{optionA}, %{optionB} will be selected automatically. A hint is displayed.<br/>' + 'If the user deselects %{optionA}, %{optionB} stays in the configuration. No hint is displayed.<br/>' + 'If the user deselects %{optionB}, %{optionA} is deselected, if possible, or the default option for the component is selected automatically. A hint is displayed.'
+        },
+        optionexclusion: {
+          name: 'Direct incompatibility',
+          optionText: 'These two options cannot be combined',
+          optionLabel: 'option a',
+          dataOptionLabel: 'option b',
+          description: 'If the user chooses %{optionA}, %{optionB} will be removed, if possible, or the default option for the component is selected automatically. ' + 'Reversely, %{optionA} will be removed if possible or the default option for the component is selected, if the user chooses %{optionB}.'
+        },
+        optionclassificationminamount: {
+          name: 'Component, minimum quantity',
+          componentsText: 'For the following component, the user has to select a minimum quantity of options.',
+          componentsLabel: 'Component',
+          minAmountText: 'The minimum quantity of options is',
+          minAmountLabel: 'Minimum quantity',
+          description: 'If the minimum amount is deceeded, there is not hint. Only when sending the configuration to the shopping cart, a hint is displayed.'
+        },
+        optionclassificationmaxamount: {
+          name: 'Component, maximum quantity',
+          componentsText: 'For the following component, the user can only select a predetermined quantity of options.',
+          componentsLabel: 'Component',
+          maxAmountText: 'The maximum quantity of options is',
+          maxAmountLabel: 'Maximum quantity',
+          description: 'If the maximum quantity is exceeded when selecting options, a hint is displayed and the option is not added to the configuration.'
+        },
+        itemattributematch: {
+          name: 'Attribute incompatibility',
+          attributeText: 'The following attribute is used to determine incompatibilities',
+          attributeLabel: 'attribute',
+          description: 'If multiple options have this attribute, they are only compatible, if the attribute values for the options match.<br/>' + 'If the user selects an option b that has the attribute %{attribute} with the attribute value x and has already selected option a, that also has the %{attribute} but with a deviant attribute value y, then option b is incompatible. A hint is displayed.'
+        },
+        itemattributemaxsum: {
+          name: 'Add up attribute values',
+          attributeText: 'The sum of all values for the selected options must not exceed the provided maximum sum. The numeric attribute values of the attribute selected for the rule will be summed up.',
+          attributeLabel: 'attribute',
+          maxAmountText: 'The maximum sum is',
+          maxAmountLabel: 'Maximum sum'
+        },
+        optionmaxamount: {
+          name: 'Option, maximum quantity',
+          optionText: 'For the following option, there’s a restriction that defines how many times the option can be added to the configuration.',
+          optionLabel: 'option',
+          maxAmountText: 'The maximum quantity is',
+          maxAmountLabel: 'Maximum quantity',
+          description: 'If the maximum amount is exceeded when selecting the option, a hint gets displayed and the option is not added to the configuration.'
+        },
+        defaultoption: {
+          name: 'Default option',
+          optionText: 'The following option is a default part and always has to be in the configuration.',
+          optionLabel: 'option default part',
+          description: 'If the user selects an option that is incompatible with %{option}, the %{option} is removed from the configuration. If the user deselects the incompatible option, %{option} is automatically added to the configuration again.<br/><br/>' + 'No hint is displayed.'
+        },
+        additionaloption: {
+          name: 'Dependent options',
+          optionText: 'To the option',
+          optionLabel: 'option a',
+          dataOptionText: 'there always belongs an',
+          dataOptionLabel: 'option b',
+          description: 'When configuring %{optionA}, %{optionB} is selected automatically. When removing %{optionA}, %{optionB} is removed automatically without a hint being shown.'
+        },
+        attribute_value_group_auto_switch: {
+          name: 'Joint change',
+          attributeText: 'This rule allows for options that share a common attribute, to be switched simultaneously. This attribute is',
+          attributeLabel: 'attribute',
+          switchText: 'The rule is applied per component, not across all components.',
+          description: 'The rule is applied to grouped options, when an option has different variants (e.g. standard and premium). ' + 'All the variants of the option need to have the attribute %{attribute} with different attribute values (e.g. standard and premium).<br/>' + 'If the user chooses one option that has the attribute value premium, the variants that also have the attribute value are automatically configured for every selected option group. No hint is displayed.'
+        }
+      }
+    },
+    Attribute: 'Attributes',
+    rule: {
+      addButtonLabel: 'Add Rule'
+    }
+  },
+  de: {
+    rule: {
+      addButtonLabel: ' Regel hinzufügen'
+    },
+    Attribute: 'Attribute',
+    rules: 'Regeln',
+    ruleEditor: {
+      addRule: 'Regel hinzufügen',
+      selectRuleTypeHint: 'Wähle die gewünschte Regel aus',
+      listHeadline: 'Folgende Regeln gelten für dieses Produkt:',
+      ruleTypes: {
+        optiondependency: {
+          name: 'Voraussetzung',
+          optionText: 'Diese Option',
+          optionLabel: 'Option A',
+          dataOptionText: 'setzt die folgende Option voraus',
+          dataOptionLabel: 'Option B',
+          description: 'Wählt der Nutzer %{optionA} wird %{optionB} automatisch ausgewählt. Dabei wird ein Hinweis ausgegeben.<br/>' + 'Wählt der Nutzer %{optionA} ab, bleibt %{optionB} Teil der Konfiguration. Es wird kein Hinweis ausgegeben.<br/>' + 'Wählt der Nutzer %{optionB} ab, wird %{optionA} falls möglich abgewählt oder es wird die Standardoption der Kategorie automatisch gewählt. Es wird ein Hinweis ausgegeben.'
+        },
+        optionexclusion: {
+          name: 'Direkte Inkompatibilität',
+          optionText: 'Diese beiden Optionen können nicht kombiniert werden',
+          optionLabel: 'Option A',
+          dataOptionLabel: 'Option B',
+          description: 'Wählt der Nutzer %{optionA} wird %{optionB} falls möglich entfernt oder es wird die Standardoption in der Kategorie gewählt. ' + 'Umgekehrt wird %{optionA} falls möglich entfernt oder es wird die Standardoption in der Kategorie gewählt, wenn der Nutzer %{optionB} wählt.'
+        },
+        optionclassificationminamount: {
+          name: 'Komponente, Minimalmenge',
+          componentsText: 'In der folgenden Komponente muss der Nutzer minimal eine bestimmte Menge an Optionen wählen',
+          componentsLabel: 'Komponente',
+          minAmountText: 'Die Minimalmenge an Optionen ist',
+          minAmountLabel: 'Minimalmenge',
+          description: 'Beim Unterschreiten der Minimalmenge erscheint kein Hinweis. Erst beim Abschicken der Konfiguration zum Warenkorb, wird ein Hinweis ausgegeben.'
+        },
+        optionclassificationmaxamount: {
+          name: 'Komponente, Maximalmenge',
+          componentsText: 'In der folgenden Komponente kann der Nutzer maximal nur eine bestimmte Menge an Optionen wählen',
+          componentsLabel: 'Komponente',
+          maxAmountText: 'Die Maximalmenge an Optionen ist',
+          maxAmountLabel: 'Maximalmenge',
+          description: 'Wird die Maximalmenge bei der Auswahl einer Option überschritten erscheint ein Hinweis und die Option wird nicht in die Konfiguration übernommen.'
+        },
+        itemattributematch: {
+          name: 'Attribut-Inkompatibilität',
+          attributeText: 'Folgendes Attribut wird für das Feststellen von Inkompatibiliäten verwendet',
+          attributeLabel: 'Attribut',
+          description: 'Wenn mehrere Optionen dieses Attribut besitzen sind sie nur dann miteinander kompatibel, wenn die Attributwerte an den Optionen übereinstimmen.<br/>' + 'Falls der Nutzer eine Option B mit dem Attribut %{attribute} mit dem Wert X wählt und eine andere bereits gewählte Option A das Attribut ebenfalls besitzt, aber mit einem abweichenden Wert Y, dann ist Option B inkompatibel. Es wird ein Hinweis ausgegeben.'
+        },
+        itemattributemaxsum: {
+          name: 'Attributwerte aufsummieren',
+          attributeText: 'Die Summe der Zahlenwerte an allen gewählten Optionen dürfen die Maximalsumme nicht überschreiten. Die Zahlenwerte des folgenden Attributs werden addiert.',
+          attributeLabel: 'Attribut',
+          maxAmountText: 'Die Maximalsumme ist',
+          maxAmountLabel: 'Maximalsumme'
+        },
+        optionmaxamount: {
+          name: 'Option, Maximalmenge',
+          optionText: 'Für folgende Option gibt es eine Beschränkung, wie oft die Option in die Konfiguration gelegt werden kann',
+          optionLabel: 'Option',
+          maxAmountText: 'Die Maximalmenge ist',
+          maxAmountLabel: 'Maximalmenge',
+          description: 'Wird die Maximalmenge bei der Auswahl einer Option überschritten erscheint ein Hinweis und die Option wird nicht in die Konfiguration übernommen.'
+        },
+        defaultoption: {
+          name: 'Standardteil',
+          optionText: 'Die folgende Option ist ein Standardteil und muss immer Teil der Konfiguration sein',
+          optionLabel: 'Option Standardteil',
+          description: 'Wählt der Nutzer eine zu %{option} inkompatible Option, wird %{option} entfernt. Wählt der Nutzer die inkompatible Option wieder ab, wird %{option} automatisch wieder Teil der Konfiguration.<br/><br/>' + 'Dabei wird kein Hinweis ausgegeben.'
+        },
+        additionaloption: {
+          name: 'Abhängige Optionen',
+          optionText: 'Zu folgender Option',
+          optionLabel: 'Option A',
+          dataOptionText: 'gehört immer auch',
+          dataOptionLabel: 'Option B',
+          description: 'Bei der Auswahl von %{optionA} wird %{optionB} automatisch gewählt. Wählt der Nutzer %{optionA} ab, wird %{optionB} ebenfalls automatisch abgewählt.<br/><br/>' + 'Dabei wird kein Hinweis ausgegeben.'
+        },
+        attribute_value_group_auto_switch: {
+          name: 'Gemeinsamer Wechsel',
+          attributeText: 'Diese Regel ermöglicht, dass Optionen, die ein bestimmtes gemeinsames Attribut haben gemeinsam getauscht werden. Dieses Attribut ist',
+          attributeLabel: 'Attribut',
+          switchText: 'Die Regel wird pro Komponente angewendet, nicht über alle Komponenten hinweg',
+          description: 'Die Regel wird auf gruppierte Optionen angewendet, wenn es also zu einer Option mehrere Varianten gibt (z.B. standard und premium). ' + 'Die Varianten der Optionen müssen das Attribut %{attribute} mit unterschiedlichen Werten besitzen (z.B. standard und premium).<br/>' + 'Wählt der Nutzer eine Option mit dem Attributwert premium, werden pro gewählter Optionsgruppierung diejenigen Varianten eingetauscht, die auch den Attributwert premium besitzen. Es wird kein Hinweis ausgegeben.'
+        }
+      }
+    }
+  }
+}, true);

package/Screens/Creator/Components/Rules/index.js

@@ -0,0 +1,80 @@
+"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 _Actions = _interopRequireWildcard(require("../../Reducers/Rules/Actions"));
+
+var _List = _interopRequireDefault(require("./Containers/List"));
+
+var _Edit = _interopRequireDefault(require("./Containers/Edit"));
+
+require("./Translations");
+
+require("./Styles.scss");
+
+var _DefaultScreen = require("../../../../Components/DefaultScreen");
+
+var _DefaultConnectedScreen = require("../../../../Components/DefaultConnectedScreen");
+
+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 _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 _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); }
+
+var ScreenContainer = /*#__PURE__*/function (_React$Component) {
+  _inherits(ScreenContainer, _React$Component);
+
+  var _super = _createSuper(ScreenContainer);
+
+  function ScreenContainer() {
+    _classCallCheck(this, ScreenContainer);
+
+    return _super.apply(this, arguments);
+  }
+
+  _createClass(ScreenContainer, [{
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/_react["default"].createElement(_DefaultScreen.ModalScreen, _extends({}, this.props, {
+        headlineText: false,
+        className: "rules"
+      }));
+    }
+  }]);
+
+  return ScreenContainer;
+}(_react["default"].Component);
+
+var _default = (0, _DefaultConnectedScreen.connectDefault)((0, _DefaultScreen.generateCustomScreen)('rules', _List["default"], _Edit["default"], ScreenContainer), _Actions.REDUCER_NAME, _Actions["default"].invalidateList, _Actions["default"].unsavedEntity, _Actions["default"].hideDetails);
+
+exports["default"] = _default;

package/Screens/Creator/Components/ShowPreviewErrorDialog.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _Dialog = _interopRequireDefault(require("../../../UIComponents/Dialog"));
+
+var _withStyles = _interopRequireDefault(require("@material-ui/core/styles/withStyles"));
+
+var _FlatButton = _interopRequireDefault(require("../../../UIComponents/FlatButton"));
+
+var _i18n = require("../../../App/i18n");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var styles = function styles() {
+  return {
+    paperRoot: {
+      minWidth: '450px'
+    },
+    dialogContentRoot: {
+      overflow: 'hidden',
+      display: 'flex'
+    },
+    dialogContentTextRoot: {
+      width: '100%'
+    }
+  };
+};
+
+var ShowPreviewErrorDialog = (0, _withStyles["default"])(styles)(function (_ref) {
+  var classes = _ref.classes,
+      dialogTitle = _ref.dialogTitle,
+      open = _ref.open,
+      onClose = _ref.onClose,
+      children = _ref.children;
+  return /*#__PURE__*/_react["default"].createElement(_Dialog["default"], {
+    title: dialogTitle,
+    open: open,
+    maxWidth: "sm",
+    classes: {
+      dialogContentTextRoot: classes.dialog
+    },
+    actions: [/*#__PURE__*/_react["default"].createElement(_FlatButton["default"], {
+      label: (0, _i18n.T)('Ok'),
+      key: "closeButton",
+      primary: false,
+      onClick: onClose
+    })]
+  }, children);
+});
+
+var _default = (0, _withStyles["default"])(styles)(ShowPreviewErrorDialog);
+
+exports["default"] = _default;