@configuratorware/configurator-admingui 1.28.4 → 1.29.0

package/App/Reducers/Entity/Actions.js

@@ -0,0 +1,660 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateDeleteAction = exports.generateListActions = exports.generateDefaultActions = exports.SET_VALIDATED_DATA = exports.MOUNT_NEXT = exports.SET_DATA_SOURCE = exports.SET_VALIDATION_ERRORS = exports.ENTITY_WILL_UNMOUNT = exports.ENTITY_WILL_MOUNT = exports.MOUNT_ENTITY = exports.UNMOUNT_ENTITY = exports.SET_DATA = exports.HIDE_DETAILS = exports.SHOW_DETAILS = exports.cancelDeleteEntitiesDialog = exports.reportDeleteEntities = exports.dataIsModified = exports.initUnsavedEntity = exports.cancelUnsavedEntityDialog = exports.releaseUnsavedEntity = exports.reportUnsavedEntity = exports.CANCEL_DELETE_ENTITIES_DIALOG = exports.REPORT_DELETE_ENTITIES = exports.MODIFIED_UNSAVED_ENTITY = exports.INIT_UNSAVED_ENTITY = exports.CANCEL_UNSAVED_ENTITY_DIALOG = exports.RELEASE_UNSAVED_ENTITY = exports.REPORT_UNSAVED_ENTITY = void 0;
+
+var _Helpers = require("../Api/Helpers");
+
+var _Actions = require("../Api/Actions");
+
+var _Data = require("../../Data");
+
+var _Actions2 = require("../Frame/Actions");
+
+var _i18n = require("../../i18n");
+
+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 REPORT_UNSAVED_ENTITY = 'REPORT_UNSAVED_ENTITY';
+exports.REPORT_UNSAVED_ENTITY = REPORT_UNSAVED_ENTITY;
+var RELEASE_UNSAVED_ENTITY = 'RELEASE_UNSAVED_ENTITY';
+exports.RELEASE_UNSAVED_ENTITY = RELEASE_UNSAVED_ENTITY;
+var CANCEL_UNSAVED_ENTITY_DIALOG = 'CANCEL_UNSAVED_ENTITY_DIALOG';
+exports.CANCEL_UNSAVED_ENTITY_DIALOG = CANCEL_UNSAVED_ENTITY_DIALOG;
+var INIT_UNSAVED_ENTITY = 'INIT_UNSAVED_ENTITY';
+exports.INIT_UNSAVED_ENTITY = INIT_UNSAVED_ENTITY;
+var MODIFIED_UNSAVED_ENTITY = 'MODIFIED_UNSAVED_ENTITY';
+exports.MODIFIED_UNSAVED_ENTITY = MODIFIED_UNSAVED_ENTITY;
+var REPORT_DELETE_ENTITIES = 'REPORT_DELETE_ENTITIES';
+exports.REPORT_DELETE_ENTITIES = REPORT_DELETE_ENTITIES;
+var CANCEL_DELETE_ENTITIES_DIALOG = 'CANCEL_DELETE_ENTITIES_DIALOG';
+exports.CANCEL_DELETE_ENTITIES_DIALOG = CANCEL_DELETE_ENTITIES_DIALOG;
+
+var reportUnsavedEntity = function reportUnsavedEntity(reducerName, entityState, saveAndHide, hide, cancel) {
+  return {
+    type: REPORT_UNSAVED_ENTITY,
+    reducerName: reducerName,
+    entityState: entityState,
+    saveAndHide: saveAndHide,
+    hide: hide,
+    cancel: cancel
+  };
+};
+
+exports.reportUnsavedEntity = reportUnsavedEntity;
+
+var releaseUnsavedEntity = function releaseUnsavedEntity() {
+  return function (dispatch, getState) {
+    var state = getState();
+    var entity = state.entity;
+    var reducerName = entity.unsavedEntity.reducerName;
+
+    if (reducerName) {
+      if (state[reducerName].showDetails) {
+        dispatch({
+          type: HIDE_DETAILS,
+          key: state[reducerName].actionKey
+        });
+      }
+    }
+
+    dispatch({
+      type: RELEASE_UNSAVED_ENTITY
+    });
+  };
+};
+
+exports.releaseUnsavedEntity = releaseUnsavedEntity;
+
+var cancelUnsavedEntityDialog = function cancelUnsavedEntityDialog() {
+  return {
+    type: CANCEL_UNSAVED_ENTITY_DIALOG
+  };
+};
+
+exports.cancelUnsavedEntityDialog = cancelUnsavedEntityDialog;
+
+var initUnsavedEntity = function initUnsavedEntity(reducerName) {
+  return {
+    type: INIT_UNSAVED_ENTITY,
+    reducerName: reducerName
+  };
+};
+
+exports.initUnsavedEntity = initUnsavedEntity;
+
+var dataIsModified = function dataIsModified(reducerName, entityState) {
+  return {
+    type: MODIFIED_UNSAVED_ENTITY,
+    reducerName: reducerName,
+    entityState: entityState
+  };
+};
+
+exports.dataIsModified = dataIsModified;
+
+var reportDeleteEntities = function reportDeleteEntities(key, onDelete, cancel) {
+  return {
+    type: REPORT_DELETE_ENTITIES,
+    key: key,
+    onDelete: onDelete,
+    cancel: cancel
+  };
+};
+
+exports.reportDeleteEntities = reportDeleteEntities;
+
+var cancelDeleteEntitiesDialog = function cancelDeleteEntitiesDialog() {
+  return {
+    type: CANCEL_DELETE_ENTITIES_DIALOG
+  };
+};
+/*** DEFAULT ENTITY ACTIONS***/
+
+
+exports.cancelDeleteEntitiesDialog = cancelDeleteEntitiesDialog;
+var SHOW_DETAILS = 'SHOW_DETAILS';
+exports.SHOW_DETAILS = SHOW_DETAILS;
+var HIDE_DETAILS = 'HIDE_DETAILS';
+exports.HIDE_DETAILS = HIDE_DETAILS;
+var SET_DATA = 'SET_DATA';
+exports.SET_DATA = SET_DATA;
+var UNMOUNT_ENTITY = 'UNMOUNT_ENTITY';
+exports.UNMOUNT_ENTITY = UNMOUNT_ENTITY;
+var MOUNT_ENTITY = 'MOUNT_ENTITY';
+exports.MOUNT_ENTITY = MOUNT_ENTITY;
+var ENTITY_WILL_MOUNT = 'ENTITY_WILL_MOUNT';
+exports.ENTITY_WILL_MOUNT = ENTITY_WILL_MOUNT;
+var ENTITY_WILL_UNMOUNT = 'ENTITY_WILL_UNMOUNT';
+exports.ENTITY_WILL_UNMOUNT = ENTITY_WILL_UNMOUNT;
+var SET_VALIDATION_ERRORS = 'SET_VALIDATION_ERRORS';
+exports.SET_VALIDATION_ERRORS = SET_VALIDATION_ERRORS;
+var SET_DATA_SOURCE = 'SET_DATA_SOURCE';
+exports.SET_DATA_SOURCE = SET_DATA_SOURCE;
+var MOUNT_NEXT = 'MOUNT_NEXT';
+exports.MOUNT_NEXT = MOUNT_NEXT;
+var SET_VALIDATED_DATA = 'SET_VALIDATED_DATA';
+exports.SET_VALIDATED_DATA = SET_VALIDATED_DATA;
+
+/**
+ *
+ * @param listKey
+ * @param dataKey
+ * @param reducerName
+ * @param url
+ * @returns {{listAction: (function(*): function(*=)), showDetails: (function(*=, *=): function(*, *)), hideDetails: (function(*=): function(*, *)), detailsAction: (function(*=): function(*=)), setFieldData: (function(*, *): function(*, *)), postData: (function(*): function(*=, *)), createEntity: (function(): function(*, *)), deleteEntities: (function(*=): function(*=)), triggerUnsavedEntity: (function(): function(*=, *)), invalidateList: (function(): function(*))}}
+ */
+var generateDefaultActions = function generateDefaultActions(listKey, dataKey, reducerName, url) {
+  var ctx = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+  var lastListParams;
+
+  var listAction = function listAction(params) {
+    return function (dispatch) {
+      lastListParams = params;
+      return (0, _Helpers.dispatchFetchData)(dispatch)(listKey, params ? {
+        url: url,
+        params: params
+      } : url);
+    };
+  };
+
+  var refreshListAction = function refreshListAction() {
+    return function (dispatch) {
+      return dispatch(listAction(lastListParams));
+    };
+  };
+
+  var triggerUnsavedEntity = function triggerUnsavedEntity() {
+    var hideSilent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    return function (dispatch, getState) {
+      return new Promise(function (resolve) {
+        var state = getState();
+
+        if (state[reducerName].isModified) {
+          dispatch(reportUnsavedEntity(reducerName, state[reducerName], function () {
+            // saveAndHide callback
+            dispatch(postData(true)).then(function (apiAction) {
+              if (apiAction.type === _Actions.RECEIVE_DATA) {
+                dispatch(hideDetails(false, hideSilent)).then(function () {
+                  dispatch(releaseUnsavedEntity());
+                  resolve();
+                });
+              } else {
+                // there might be some validation problems
+                dispatch(cancelUnsavedEntityDialog());
+              }
+            });
+          }, function () {
+            // hide callback
+            dispatch(hideDetails(false, hideSilent)).then(function () {
+              dispatch(releaseUnsavedEntity());
+              resolve();
+            });
+          }, function () {
+            // cancel callback
+            dispatch(cancelUnsavedEntityDialog());
+          }));
+        } else {
+          resolve();
+        }
+      });
+    };
+  };
+
+  var showDetails = function showDetails() {
+    var showDetails = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+    var reportUnsaved = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    return function (dispatch, getState) {
+      var state = getState();
+
+      if (reportUnsaved && state[reducerName].isModified) {
+        dispatch(triggerUnsavedEntity());
+      } else {
+        dispatch({
+          type: SHOW_DETAILS,
+          key: dataKey,
+          showDetails: showDetails
+        });
+      }
+    };
+  };
+
+  var hideDetails = function hideDetails() {
+    var reportUnsaved = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+    var silent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    return function (dispatch, getState) {
+      dispatch(mountNext(false));
+      dispatch((0, _Helpers.dismissRequest)(dataKey));
+      var state = getState();
+      var p = null;
+
+      if (reportUnsaved && state[reducerName].isModified) {
+        p = dispatch(triggerUnsavedEntity());
+      } else {
+        p = Promise.resolve();
+      }
+
+      return p.then(function () {
+        if (!silent) {
+          dispatch({
+            type: HIDE_DETAILS,
+            key: dataKey
+          });
+        }
+
+        dispatch(unmountEntity());
+      });
+    };
+  };
+
+  var unmountEntity = function unmountEntity() {
+    return function (dispatch, getState) {
+      var state = getState();
+
+      if (state[reducerName].isReady) {
+        dispatch({
+          type: ENTITY_WILL_UNMOUNT,
+          key: dataKey
+        });
+        dispatch({
+          type: UNMOUNT_ENTITY,
+          key: dataKey
+        });
+      }
+    };
+  };
+
+  var mountEntity = function mountEntity() {
+    var data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var isSaved = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    return function (dispatch) {
+      dispatch({
+        type: ENTITY_WILL_MOUNT,
+        key: dataKey,
+        data: data
+      });
+      dispatch({
+        type: MOUNT_ENTITY,
+        key: dataKey,
+        data: data,
+        isSaved: isSaved
+      });
+    };
+  };
+
+  var mountNewEntity = function mountNewEntity() {
+    return {
+      type: MOUNT_ENTITY,
+      key: dataKey,
+      isNew: true
+    };
+  };
+
+  var createEntity = function createEntity() {
+    return function (dispatch) {
+      return dispatch(triggerUnsavedEntity()).then(function () {
+        dispatch(unmountEntity());
+        dispatch(initUnsavedEntity(reducerName));
+        dispatch(mountNewEntity());
+        dispatch(loadDependencies());
+        dispatch(showDetails());
+      });
+    };
+  };
+
+  var setValidationErrors = function setValidationErrors(errors) {
+    return {
+      type: SET_VALIDATION_ERRORS,
+      key: dataKey,
+      errors: errors
+    };
+  };
+
+  var apiStateHandler = function apiStateHandler(apiAction) {
+    var hideDetailsAfterSave = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    return function (dispatch, getState) {
+      switch (apiAction && apiAction.type) {
+        case _Actions.RECEIVE_DATA:
+          {
+            var state = getState();
+            var source = state.dataBySource[apiAction.key];
+
+            if (!source.data) {
+              // eslint-disable-next-line no-console
+              console.error('There is no entity data, entity will not be mounted!');
+              return false;
+            }
+
+            if (!state[reducerName].mountNext) {
+              // eslint-disable-next-line no-console
+              console.warn('Mounting is interrupted by the user.');
+              return false;
+            } // the data should be mounted in every case
+
+
+            dispatch(mountEntity(source.data, source.isPosted));
+
+            if (source.isPosted) {
+              // data is saved
+              if (ctx.stayAfterSave || !hideDetailsAfterSave) {
+                // the data should be re-fetched in the original way to make sure it is correct
+                // (since the response for the post request can contain the previous version)
+                source.source && (0, _Helpers.dispatchFetchData)(dispatch)(dataKey, source.source).then(function (result) {
+                  dispatch(apiStateHandler(result));
+                });
+              } else if (hideDetailsAfterSave) {
+                dispatch(releaseUnsavedEntity());
+                dispatch(hideDetails(false));
+              }
+
+              dispatch((0, _Actions2.showInfoMessage)((0, _i18n.t)('entity.saveOk')));
+              dispatch((0, _Helpers.invalidateSource)(listKey));
+            } else {// data is loaded by its id (not from a post request), so it can be mounted
+            }
+
+            return true;
+          }
+
+        case _Actions.HANDLED_NETWORK_ERROR:
+          dispatch(setValidationErrors(apiAction.error.response.data.errors));
+          return false;
+
+        case _Actions.NETWORK_ERROR:
+          {
+            var _state = getState();
+
+            var _source = _state.dataBySource[apiAction.key];
+
+            if (_source.isPosted) {
+              // data is saved
+              dispatch((0, _Actions2.showErrorMessage)((0, _i18n.t)('entity.saveError'), apiAction.error));
+            } else {
+              dispatch((0, _Actions2.showErrorMessage)((0, _i18n.t)('entity.loadError'), apiAction.error));
+            }
+
+            return false;
+          }
+      }
+    };
+  };
+
+  var loadDependencies = function loadDependencies() {
+    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return function (dispatch, getState) {
+      var state = getState();
+      var config = state[reducerName].config;
+      var dependencies = config.dependencies;
+
+      if (params.filter) {
+        dependencies = dependencies.filter(params.filter);
+      }
+
+      return Promise.all(dependencies.map(function (dep) {
+        var dataKey = dep.dataKey,
+            source = dep.source,
+            name = dep.name,
+            transform = dep.transform;
+        return (0, _Helpers.dispatchFetchData)(dispatch)(dataKey, source).then(function (apiAction) {
+          if (apiAction.type === _Actions.NETWORK_ERROR) {
+            throw new Error('Cannot load dependency: ' + dataKey);
+          }
+
+          var state = getState();
+          var dataState = state.dataBySource[apiAction.key];
+
+          if (!dataState.data) {
+            // eslint-disable-next-line no-console
+            console.error('Cannot load data for dependency: ' + dataKey, apiAction, dataState);
+            return;
+          }
+
+          var data = transform ? transform(dataState.data) : dataState.data;
+          dispatch(setDataSource(name, data));
+        });
+      }));
+    };
+  };
+
+  var setDataSource = function setDataSource(name, data) {
+    return {
+      type: SET_DATA_SOURCE,
+      key: dataKey,
+      name: name,
+      data: data
+    };
+  };
+
+  var detailsAction = function detailsAction(params) {
+    return function (dispatch) {
+      return dispatch(triggerUnsavedEntity()).then(function () {
+        dispatch(unmountEntity());
+        dispatch(initUnsavedEntity(reducerName));
+        dispatch((0, _Helpers.invalidateSource)(dataKey));
+        return dispatch(loadEntity(params));
+      });
+    };
+  };
+
+  var mountNext = function mountNext(mount) {
+    return {
+      type: MOUNT_NEXT,
+      key: dataKey,
+      mount: mount
+    };
+  };
+
+  var loadEntity = function loadEntity(params) {
+    return function (dispatch) {
+      var _showDetailsWhenLoade = _objectSpread({
+        showDetailsWhenLoaded: true
+      }, params),
+          showDetailsWhenLoaded = _showDetailsWhenLoade.showDetailsWhenLoaded;
+
+      dispatch(mountNext(true));
+      var detailsURL = ctx.getDetailsURL instanceof Function ? ctx.getDetailsURL(params, url) : url + '/' + params.id;
+      return Promise.all([(0, _Helpers.dispatchFetchData)(dispatch)(dataKey, detailsURL), dispatch(loadDependencies())]).then(function (results) {
+        var success = dispatch(apiStateHandler(results[0]));
+
+        if (success && results && results[0] && results[0].type !== _Actions.NETWORK_ERROR) {
+          showDetailsWhenLoaded && dispatch(showDetails(true));
+        } else if (!results || !results[0]) {
+          // eslint-disable-next-line no-console
+          console.error('There are no results, check the call stack!');
+        }
+
+        return results;
+      });
+    };
+  };
+
+  var setFieldData = function setFieldData(field, value) {
+    return function (dispatch, getState) {
+      var state = getState();
+
+      if (!state[reducerName].isModified) {
+        dispatch(dataIsModified(reducerName, state[reducerName]));
+      }
+
+      dispatch({
+        type: SET_DATA,
+        key: dataKey,
+        field: field,
+        value: value
+      });
+    };
+  };
+
+  var validateData = function validateData() {
+    return function (dispatch, getState) {
+      var state = getState();
+      var data = new _Data.DataValidator(state[reducerName].data, false);
+
+      if (data.validate()) {
+        return true;
+      } else {
+        dispatch({
+          type: SET_VALIDATED_DATA,
+          key: dataKey,
+          data: data.getValidatedData()
+        });
+        return false;
+      }
+    };
+  };
+
+  var postData = ctx.postData || function () {
+    var hideDetails = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    return function (dispatch, getState) {
+      if (!dispatch(validateData())) {
+        return new Promise(function () {});
+      }
+
+      dispatch(mountNext(true));
+      var state = getState();
+      var newData = state[reducerName].data;
+      var data = {};
+
+      for (var k in newData) {
+        data[k] = newData[k].value;
+      }
+
+      var p = (0, _Helpers.dispatchPostData)(dispatch)(dataKey, url, data).then(function (action) {
+        if (action && action.type === _Actions.RECEIVE_DATA) {
+          // Mount the data from the post response immediately
+          var _state2 = getState();
+
+          var source = _state2.dataBySource[dataKey];
+          source.data && dispatch(mountEntity(source.data, source.isPosted));
+        }
+
+        return action;
+      });
+
+      if (ctx.beforeApiStateHandler) {
+        p = p.then(function (s) {
+          return dispatch(ctx.beforeApiStateHandler(s));
+        });
+      }
+
+      p.then(function (s) {
+        return dispatch(apiStateHandler(s, hideDetails));
+      });
+      return p;
+    };
+  };
+
+  var deleteEntities = function deleteEntities(ids) {
+    return function (dispatch) {
+      dispatch(reportDeleteEntities(listKey, function () {
+        // onDelete callback
+        (0, _Helpers.dispatchDeleteData)(dispatch)(listKey, url, ids).then(function () {
+          dispatch(hideDetails(false));
+          dispatch(releaseUnsavedEntity());
+          dispatch((0, _Helpers.invalidateSource)(listKey));
+          dispatch(cancelDeleteEntitiesDialog());
+          ctx.afterDelete && dispatch(ctx.afterDelete(ids));
+        });
+      }, function () {
+        // cancel callback
+        dispatch(cancelDeleteEntitiesDialog());
+      }));
+    };
+  };
+
+  var invalidateList = function invalidateList() {
+    return function (dispatch) {
+      dispatch(releaseUnsavedEntity());
+      dispatch((0, _Helpers.invalidateSource)(listKey));
+    };
+  };
+
+  var customAction = function customAction(type, data) {
+    return function (dispatch) {
+      if (ctx.customDispatchHandler) {
+        var _customAction = ctx.customDispatchHandler(type, data);
+
+        if (_customAction) {
+          dispatch(_customAction);
+        }
+      }
+    };
+  };
+
+  return {
+    listAction: listAction,
+    refreshListAction: refreshListAction,
+    showDetails: showDetails,
+    hideDetails: hideDetails,
+    detailsAction: detailsAction,
+    setFieldData: setFieldData,
+    postData: postData,
+    createEntity: createEntity,
+    deleteEntities: deleteEntities,
+    triggerUnsavedEntity: triggerUnsavedEntity,
+    invalidateList: invalidateList,
+    customAction: customAction,
+    loadEntity: loadEntity
+  };
+};
+
+exports.generateDefaultActions = generateDefaultActions;
+
+var generateListActions = function generateListActions(listKey, url) {
+  var lastListParams;
+
+  var listAction = function listAction(params) {
+    return function (dispatch) {
+      lastListParams = params;
+      return (0, _Helpers.dispatchFetchData)(dispatch)(listKey, params ? {
+        url: url,
+        params: params
+      } : url);
+    };
+  };
+
+  var invalidateList = function invalidateList() {
+    return function (dispatch) {
+      dispatch((0, _Helpers.invalidateSource)(listKey));
+    };
+  };
+
+  var refreshListAction = function refreshListAction() {
+    return function (dispatch) {
+      return dispatch(listAction(lastListParams));
+    };
+  };
+
+  return {
+    listAction: listAction,
+    invalidateList: invalidateList,
+    refreshListAction: refreshListAction
+  };
+};
+
+exports.generateListActions = generateListActions;
+
+var generateDeleteAction = function generateDeleteAction(listKey, url) {
+  return function (ids) {
+    return function (dispatch) {
+      dispatch(reportDeleteEntities(listKey, function () {
+        // onDelete callback
+        (0, _Helpers.dispatchDeleteData)(dispatch)(listKey, url, ids).then(function () {
+          dispatch(releaseUnsavedEntity());
+          dispatch((0, _Helpers.invalidateSource)(listKey));
+          dispatch(cancelDeleteEntitiesDialog());
+        });
+      }, function () {
+        // cancel callback
+        dispatch(cancelDeleteEntitiesDialog());
+      }));
+    };
+  };
+};
+
+exports.generateDeleteAction = generateDeleteAction;