@configuratorware/configurator-frontendgui 1.28.3 → 1.29.1

package/App/Reducers/Configurator/Reducer.js

@@ -0,0 +1,639 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configurationHandler = configurationHandler;
+exports.optionAndOptionclassificationHandler = optionAndOptionclassificationHandler;
+exports.calculationHandler = calculationHandler;
+exports.dataHandler = dataHandler;
+exports.uiHandler = uiHandler;
+exports.baseHandler = baseHandler;
+exports.configurationModifierHandler = configurationModifierHandler;
+exports.filterOptionclassifications = filterOptionclassifications;
+exports["default"] = configuratorReducer;
+exports.setStateChangeReducers = exports.setSubReducers = void 0;
+
+var actionTypes = _interopRequireWildcard(require("./Actions"));
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _get = _interopRequireDefault(require("lodash/get"));
+
+var _omit = _interopRequireDefault(require("lodash/omit"));
+
+var _forEach = _interopRequireDefault(require("lodash/forEach"));
+
+var _reduce = _interopRequireDefault(require("lodash/reduce"));
+
+var _set = _interopRequireDefault(require("../../../Utils/Immutable/set"));
+
+var _Reducer = require("../DesignData/Reducer");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+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 _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); }
+
+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; }
+
+var initialState = {
+  configuration: {
+    item: {},
+    optionclassifications: []
+  },
+  options: [],
+  optionsWithDetails: [],
+  selectedoptionclassification: {},
+  calculation: null,
+  calculationAutoResolve: true,
+  optiondetails: {},
+  validation: null,
+  configurationvariants: [],
+  codesnippets: [],
+  client: null,
+  inspirations: {},
+  profile: {},
+  loadCode: null,
+  loadIdentifier: null,
+  resetCode: null,
+  // this code is only set at initial loading and load by code - we reset to those configurations
+  stockInformationOption: null,
+  inspirationsIdentifier: null,
+  calculationIsEnabled: true,
+  checkedOptionclassifications: {},
+  filteredOptionclassifications: [],
+  selectedVariantIdentifier: null,
+  selectedAmountsUpdated: false
+};
+
+function configurationHandler(state, action) {
+  switch (action.type) {
+    case actionTypes.RECEIVE_CONFIGURATION:
+      {
+        var configuration = action.data;
+
+        if (!_lodash["default"].isObject(configuration)) {
+          throw new Error("Server side error! The configuration must be a JSON structure! Data: ".concat(configuration));
+        } // update the selected option classification
+
+
+        var selectedoptionclassification = state.selectedoptionclassification;
+
+        if (selectedoptionclassification.identifier) {
+          selectedoptionclassification = _lodash["default"].find(configuration.optionclassifications, {
+            identifier: selectedoptionclassification.identifier
+          }) || selectedoptionclassification;
+        } // set validation from the received configuration
+
+
+        var validation = _lodash["default"].get(configuration, 'information.validation_result');
+
+        return _objectSpread(_objectSpread({}, state), {}, {
+          selectedoptionclassification: selectedoptionclassification,
+          configuration: configuration,
+          validation: validation,
+          resetCode: configuration.code,
+          inspirationsIdentifier: configuration.item.identifier,
+          checkedOptionclassifications: {}
+        });
+      }
+
+    case actionTypes.RECEIVE_SWITCHOPTIONSRESULT:
+      {
+        var _configuration = action.data; // the selectedoptionclassification should be updated with the optionclassification data from the response
+        // eg. to keep the selectedoptions updated
+
+        var _selectedoptionclassification = state.selectedoptionclassification,
+            options = state.options;
+        var optionclassifications = _configuration.optionclassifications;
+
+        if (_selectedoptionclassification.identifier) {
+          var optionclassificationData = _lodash["default"].find(optionclassifications, {
+            identifier: _selectedoptionclassification.identifier
+          });
+
+          if (optionclassificationData) {
+            _selectedoptionclassification = optionclassificationData; // the options should be updated with the data from the selectedoptions
+
+            var _selectedoptionclassi = _selectedoptionclassification,
+                selectedoptions = _selectedoptionclassi.selectedoptions;
+
+            for (var soi in selectedoptions) {
+              for (var oi in options) {
+                if (selectedoptions[soi].identifier === options[oi].identifier) {
+                  options[oi] = _lodash["default"].mergeWith(options[oi], // dst
+                  selectedoptions[soi], // src
+                  function (dstValue, srcValue) {
+                    // if the value present in the src, then copy it from there
+                    // selectedoption always rules
+                    if (srcValue !== null && srcValue !== undefined) {
+                      return srcValue;
+                    }
+
+                    return dstValue;
+                  });
+                }
+              }
+            }
+          }
+        }
+
+        var optionsWithDetails = filterOptionsWithDetails(options);
+        return _objectSpread(_objectSpread({}, state), {}, {
+          configuration: _configuration,
+          options: options,
+          optionsWithDetails: optionsWithDetails,
+          selectedoptionclassification: _selectedoptionclassification
+        });
+      }
+
+    case actionTypes.RECEIVE_SAVEDCONFIGURATION:
+      {
+        var _configuration2 = action.data; // update the selected option classification
+
+        var _selectedoptionclassification2 = state.selectedoptionclassification;
+
+        if (_selectedoptionclassification2.identifier) {
+          _selectedoptionclassification2 = _lodash["default"].find(_configuration2.optionclassifications, {
+            identifier: _selectedoptionclassification2.identifier
+          }) || _selectedoptionclassification2;
+        }
+
+        return _objectSpread(_objectSpread({}, state), {}, {
+          configuration: _configuration2,
+          selectedoptionclassification: _selectedoptionclassification2
+        });
+      }
+
+    default:
+      return state;
+  }
+}
+
+function optionAndOptionclassificationHandler(state, action) {
+  switch (action.type) {
+    case actionTypes.SELECT_OPTIONCLASSIFICATION:
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          selectedoptionclassification: action.optionclassification || {},
+          options: [],
+          // clear options
+          optionsWithDetails: []
+        });
+      }
+
+    case actionTypes.RECEIVE_OPTIONS:
+      {
+        var _ret = function () {
+          var options = _lodash["default"].cloneDeep(action.data); // the selected options of the selected optionclassification should be updated
+          // eg. after the switchoption call added a partial object (it contains only the identifier and amount)
+          // but only missing values are updated
+
+
+          var keepDstProps = ['amount'];
+
+          var selectedoptionclassification = _lodash["default"].cloneDeep(state.selectedoptionclassification);
+
+          for (var oi in options) {
+            var option = options[oi];
+            var _selectedoptions = selectedoptionclassification.selectedoptions;
+
+            for (var os in _selectedoptions) {
+              var selectedoption = _selectedoptions[os];
+
+              if (selectedoption.identifier === option.identifier) {
+                options[oi] = _selectedoptions[os] = _lodash["default"].mergeWith(_selectedoptions[os], // dst
+                option, // src
+                function (dstValue, srcValue, key) {
+                  // update only when there is a real value in the source, otherwise use the original
+                  if (keepDstProps.indexOf(key) === -1 && srcValue !== null && srcValue !== undefined) {
+                    return srcValue;
+                  }
+
+                  return dstValue;
+                });
+              }
+            }
+          }
+
+          var selectedoptions = selectedoptionclassification.selectedoptions; // update the option data with the selected group item
+
+          for (var _os in selectedoptions) {
+            var _selectedoption = selectedoptions[_os];
+
+            for (var _oi in options) {
+              var itemGroupChildren = _lodash["default"].get(options[_oi], 'option_group.children');
+
+              if (itemGroupChildren instanceof Array) {
+                for (var ci in itemGroupChildren) {
+                  if (itemGroupChildren[ci].identifier === _selectedoption.identifier) {
+                    options[_oi] = _lodash["default"].mergeWith(_lodash["default"].cloneDeep(options[_oi]), // dst
+                    itemGroupChildren[ci], // src
+                    function (dstValue, srcValue) {
+                      return (// if the value is present in the src then use it, otherwise leave the original
+                        srcValue !== null && srcValue !== undefined ? srcValue : dstValue
+                      );
+                    });
+                  }
+                }
+              }
+            }
+          }
+
+          var optionsWithDetails = filterOptionsWithDetails(options);
+          return {
+            v: _objectSpread(_objectSpread({}, state), {}, {
+              selectedoptionclassification: selectedoptionclassification,
+              options: options,
+              optionsWithDetails: optionsWithDetails
+            })
+          };
+        }();
+
+        if (_typeof(_ret) === "object") return _ret.v;
+      }
+
+    case actionTypes.SET_OPTIONCLASSIFICATION_CHECKED:
+      {
+        if (_typeof(action.optionclassification) === 'object') {
+          return _objectSpread(_objectSpread({}, state), {}, {
+            checkedOptionclassifications: _objectSpread(_objectSpread({}, state.checkedOptionclassifications), {}, _defineProperty({}, action.optionclassification.identifier, true))
+          });
+        }
+
+        return state;
+      }
+
+    case actionTypes.SET_CONFLICTING_SWITCHOPTION_DATA:
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          conflictingSwitchOptionData: action.switchOptionData
+        });
+      }
+
+    default:
+      return state;
+  }
+}
+
+function calculationHandler(state, action) {
+  switch (action.type) {
+    case actionTypes.RECEIVE_CALCULATION:
+      {
+        var calculation = action.data;
+        return _objectSpread(_objectSpread({}, state), {}, {
+          calculation: calculation,
+          calculationAutoResolve: state.calculationAutoResolve === 'skipNext' && !calculation.errors || state.calculationAutoResolve
+        });
+      }
+
+    case actionTypes.INVALIDATE_CALCULATION:
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          calculation: _objectSpread(_objectSpread({}, state.calculation), {}, {
+            invalidated: true
+          })
+        });
+      }
+
+    case actionTypes.SET_CALCULATION_ENABLED:
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          calculationIsEnabled: action.enabled
+        });
+      }
+
+    case actionTypes.SET_CALCULATION_ERRORS_RESOLVED:
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          calculation: state.calculation.errors ? null : state.calculation
+        });
+      }
+
+    case actionTypes.SET_CALCULATION_AUTO_RESOLVE_ENABLED:
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          calculationAutoResolve: action.enabled
+        });
+      }
+
+    default:
+      return state;
+  }
+}
+
+function dataHandler(state, action) {
+  switch (action.type) {
+    case actionTypes.RECEIVE_OPTIONDETAILS:
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          optiondetails: action.data
+        });
+      }
+
+    case actionTypes.RECEIVE_VALIDATION:
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          validation: action.data
+        });
+      }
+
+    case actionTypes.RECEIVE_CONFIGURATIONVARIANTS:
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          configurationvariants: action.data
+        });
+      }
+
+    case actionTypes.RECEIVE_CODESNIPPETS:
+      {
+        if (!_lodash["default"].isArray(action.data)) {
+          throw new Error("Server side error! The code snippets must be a JSON array! Data: ".concat(action.data));
+        }
+
+        return _objectSpread(_objectSpread({}, state), {}, {
+          codesnippets: action.data || []
+        });
+      }
+
+    case actionTypes.RECEIVE_CLIENT_DATA:
+      {
+        if (action.data.success === false) {
+          return state;
+        }
+
+        var clientData = action.data;
+        var color = (0, _get["default"])(clientData, 'theme.highlightColor');
+
+        if (/^[0-9a-fA-F]{6}$/i.test(color)) {
+          // if color is hex with missing '#'
+          color = '#' + color;
+        } else if (color.charAt(0) !== '#') {
+          // if color string to get rgb color code
+          var element = document.createElement('div');
+          document.body.appendChild(element);
+          element.style.color = color;
+          var styles = window.getComputedStyle(element);
+          color = styles.color;
+          document.body.removeChild(element);
+        }
+
+        return _objectSpread(_objectSpread({}, state), {}, {
+          client: _objectSpread(_objectSpread({}, clientData), {}, {
+            theme: _objectSpread(_objectSpread({}, clientData.theme), {}, {
+              highlightColor: color
+            })
+          })
+        });
+      }
+
+    case actionTypes.RECEIVE_INSPIRATIONS:
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          inspirations: action.data
+        });
+      }
+
+    default:
+      return state;
+  }
+}
+
+function uiHandler(state, action) {
+  switch (action.type) {
+    case actionTypes.SET_STOCK_INFORMATION_OPTION:
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          stockInformationOption: action.stockInformationOption
+        });
+      }
+
+    case actionTypes.SET_SELECTED_VARIANT_IDENTIFIER:
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          selectedVariantIdentifier: action.selectedVariantIdentifier
+        });
+      }
+
+    default:
+      return state;
+  }
+}
+
+function baseHandler(state, action) {
+  switch (action.type) {
+    case actionTypes.SET_LOAD_CODE:
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          loadCode: action.loadCode,
+          loadIdentifier: null
+        });
+      }
+
+    case actionTypes.SET_LOAD_IDENTIFIER:
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          loadIdentifier: action.loadIdentifier,
+          loadCode: null
+        });
+      }
+
+    case actionTypes.SET_SELECTED_AMOUNT:
+      {
+        var selectedAmountsPath = 'customdata.selectedAmounts';
+        var selectedAmounts = (0, _get["default"])(state.configuration, selectedAmountsPath, {});
+        var configuration = (0, _set["default"])(state.configuration, selectedAmountsPath, action.amount === 0 ? (0, _omit["default"])(selectedAmounts, action.identifier) : _objectSpread(_objectSpread({}, selectedAmounts), {}, _defineProperty({}, action.identifier, action.amount)));
+        return _objectSpread(_objectSpread({}, state), {}, {
+          selectedAmountsUpdated: !!action.isUpdatedByUser,
+          configuration: configuration
+        });
+      }
+
+    case actionTypes.SWITCH_SELECTED_AMOUNT:
+      {
+        var srcIdentifier = action.srcIdentifier,
+            dstIdentifier = action.dstIdentifier;
+        var _selectedAmountsPath = 'customdata.selectedAmounts';
+
+        var _selectedAmounts = (0, _get["default"])(state.configuration, _selectedAmountsPath, {});
+
+        if (!(srcIdentifier in _selectedAmounts)) {
+          return state;
+        }
+
+        var _configuration3 = (0, _set["default"])(state.configuration, _selectedAmountsPath, (0, _omit["default"])(_objectSpread(_objectSpread({}, _selectedAmounts), {}, _defineProperty({}, dstIdentifier, _selectedAmounts[srcIdentifier])), srcIdentifier));
+
+        return _objectSpread(_objectSpread({}, state), {}, {
+          configuration: _configuration3
+        });
+      }
+
+    case actionTypes.SET_SELECTED_AMOUNTS:
+      {
+        var _selectedAmountsPath2 = 'configuration.customdata.selectedAmounts';
+
+        var _selectedAmounts2 = (0, _get["default"])(state, _selectedAmountsPath2, {});
+
+        var nextAmounts = _objectSpread(_objectSpread({}, _selectedAmounts2), action.sizes);
+
+        var newState = _objectSpread(_objectSpread({}, state), {}, {
+          selectedAmountsUpdated: !!action.isUpdatedByUser
+        });
+
+        return (0, _set["default"])(newState, _selectedAmountsPath2, _objectSpread({}, (0, _reduce["default"])(nextAmounts, function (selectedAmounts, amount, identifier) {
+          if (amount !== 0) {
+            return _objectSpread(_objectSpread({}, selectedAmounts), {}, _defineProperty({}, identifier, amount));
+          } else {
+            return selectedAmounts;
+          }
+        }, {})));
+      }
+
+    case actionTypes.DELETE_SELECTED_AMOUNTS:
+      {
+        var _selectedAmountsPath3 = 'configuration.customdata.selectedAmounts';
+
+        var _selectedAmounts3 = _lodash["default"].cloneDeep((0, _get["default"])(state, _selectedAmountsPath3, {}));
+
+        (0, _forEach["default"])(_selectedAmounts3, function (selectedAmount, identifier) {
+          var variantIdentifier = _lodash["default"].find(action.variant.sizes, {
+            identifier: identifier
+          });
+
+          if (variantIdentifier) {
+            delete _selectedAmounts3[variantIdentifier.identifier];
+          }
+        });
+        return (0, _set["default"])(state, _selectedAmountsPath3, _selectedAmounts3);
+      }
+
+    default:
+      return state;
+  }
+}
+
+function configurationModifierHandler(state, action) {
+  switch (action.type) {
+    case actionTypes.SET_CUSTOM_TITLE:
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          configuration: _objectSpread(_objectSpread({}, state.configuration), {}, {
+            customdata: _objectSpread(_objectSpread({}, state.configuration.customdata), {}, {
+              title: action.title
+            })
+          })
+        });
+      }
+
+    case actionTypes.SET_COMMENT:
+      {
+        return _objectSpread(_objectSpread({}, state), {}, {
+          configuration: _objectSpread(_objectSpread({}, state.configuration), {}, {
+            customdata: _objectSpread(_objectSpread({}, state.configuration.customdata), {}, {
+              comment: action.comment
+            })
+          })
+        });
+      }
+
+    case actionTypes.CLEAR_BULKNAMES:
+      {
+        return (0, _set["default"])(state, 'configuration.customdata.bulkNames', {});
+      }
+
+    case actionTypes.SAVE_BULKNAMES:
+      {
+        var bulkNamesPath = 'configuration.customdata.bulkNames';
+        var bulkNames = (0, _get["default"])(state, bulkNamesPath, {});
+        return (0, _set["default"])(state, bulkNamesPath, _objectSpread(_objectSpread({}, bulkNames), {}, _defineProperty({}, action.identifier, action.bulkNamesData)));
+      }
+
+    case actionTypes.DELETE_SELECTED_AMOUNT:
+      {
+        var selectedAmountsPath = 'configuration.customdata.selectedAmounts';
+
+        var selectedAmounts = _lodash["default"].cloneDeep((0, _get["default"])(state, selectedAmountsPath, {}));
+
+        delete selectedAmounts[action.identifier];
+        return (0, _set["default"])(state, selectedAmountsPath, selectedAmounts);
+      }
+
+    case actionTypes.SET_SELECTED_CALCULATION:
+      {
+        return (0, _set["default"])(state, "configuration.customdata.userSelectedCalculation.".concat(action.identifier), action.value);
+      }
+
+    default:
+      return state;
+  }
+}
+
+function filterOptionclassifications(state, prevState) {
+  // if the optionclassifications has changed it should be re-filtered
+  if (prevState.configuration.optionclassifications !== state.configuration.optionclassifications) {
+    return _objectSpread(_objectSpread({}, state), {}, {
+      filteredOptionclassifications: state.configuration.optionclassifications
+    });
+  }
+}
+
+var subReducers = {
+  baseHandler: baseHandler,
+  configurationHandler: configurationHandler,
+  optionAndOptionclassificationHandler: optionAndOptionclassificationHandler,
+  calculationHandler: calculationHandler,
+  dataHandler: dataHandler,
+  uiHandler: uiHandler,
+  configurationModifierHandler: configurationModifierHandler,
+  designDataHandler: _Reducer.designDataHandler
+};
+var stateChangeReducers = {
+  filterOptionclassifications: filterOptionclassifications
+};
+var reducerArray = Object.values(subReducers);
+var stateReducerArray = Object.values(stateChangeReducers);
+
+var setSubReducers = function setSubReducers(customSubReducers) {
+  _lodash["default"].merge(subReducers, customSubReducers);
+
+  reducerArray = Object.values(subReducers);
+};
+
+exports.setSubReducers = setSubReducers;
+
+var setStateChangeReducers = function setStateChangeReducers(customStateChangeReducers) {
+  _lodash["default"].merge(stateChangeReducers, customStateChangeReducers);
+
+  stateReducerArray = Object.values(stateChangeReducers);
+};
+
+exports.setStateChangeReducers = setStateChangeReducers;
+
+function configuratorReducer() {
+  var prevState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+  var action = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  // apply the reducers after each other (from left to right)
+  // the idea comes from reduce-reducers package (https://github.com/redux-utilities/reduce-reducers)
+  var nextState = reducerArray.reduce(function (newState, reducer) {
+    return reducer(newState, action) || newState;
+  }, prevState); // apply the state change reducers after each other (from left to right)
+
+  var state = stateReducerArray.reduce(function (newState, reducer) {
+    return reducer(newState, prevState, action) || newState;
+  }, nextState);
+  return state;
+}
+
+function filterOptionsWithDetails(options) {
+  return _lodash["default"].filter(options, function (option) {
+    return !!(option["abstract"] || option.description || option.detailImageExists === true);
+  });
+}