x25 3.0.0 → 17.0.0

package/Account/Load.js

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _react = require("react");
+
+var _react2 = _interopRequireDefault(_react);
+
+var _reactRedux = require("react-redux");
+
+var _reducer = require("./reducer");
+
+var _actions = require("./actions");
+
+var _Messages = require("../Messages");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var mapStateToProps = function mapStateToProps(state) {
+  return {
+    data: _reducer.selectors.getCurrentAccount(state),
+    hasError: _reducer.selectors.getCurrentAccountHasError(state),
+    fetched: _reducer.selectors.getCurrentAccountIsFetched(state),
+    isFetching: _reducer.selectors.getCurrentAccountIsFetching(state),
+    shouldFetch: _reducer.selectors.getCurrentAccountShouldFetch(state)
+  };
+},
+    mapDispatchToProps = function mapDispatchToProps(dispatch, _ref) {
+  var appName = _ref.appName;
+  return {
+    fetchInitialInformation: function fetchInitialInformation() {
+      setTimeout(function () {
+        dispatch((0, _actions.fetchInitialInformation)(appName));
+      });
+    }
+  };
+};
+/* eslint-disable react/require-optimization */
+
+var LoadAccount = function LoadAccount(props) {
+  var children = props.children,
+      data = props.data,
+      isFetching = props.isFetching,
+      shouldFetch = props.shouldFetch,
+      hasError = props.hasError,
+      fetchInitialInformation = props.fetchInitialInformation;
+
+
+  _react2.default.useEffect(function () {
+    if (shouldFetch) {
+      fetchInitialInformation();
+    }
+  }, [shouldFetch, isFetching, hasError]);
+
+  if (isFetching) {
+    return _react2.default.createElement(_Messages.LoadingMessage, { message: "A\u0219teapt\u0103..." });
+  }
+
+  if (hasError) {
+    return _react2.default.createElement(_Messages.LargeErrorMessage, {
+      message: "Nu am putut stabili conexiunea cu server-ul",
+      onRetry: fetchInitialInformation
+    });
+  }
+
+  if (data.size === 0) {
+    return null;
+  }
+
+  return children;
+};
+
+exports.default = (0, _reactRedux.connect)(mapStateToProps, mapDispatchToProps)(LoadAccount);

package/Account/actions.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fetchInitialInformation = undefined;
+
+var _request = require("./request");
+
+var fetchInitialInformation = exports.fetchInitialInformation = function fetchInitialInformation(appName) {
+  return {
+    type: "FETCH_INITIAL_INFORMATION",
+    payload: (0, _request.fetchInitialInformation)(appName)
+  };
+};

package/Account/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LoadAccount = exports.accountReducer = exports.accountSelectors = undefined;
+
+var _reducer = require("./reducer");
+
+var _reducer2 = _interopRequireDefault(_reducer);
+
+var _Load = require("./Load");
+
+var _Load2 = _interopRequireDefault(_Load);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+exports.accountSelectors = _reducer.selectors;
+exports.accountReducer = _reducer2.default;
+exports.LoadAccount = _Load2.default;

package/Account/reducer.js

@@ -0,0 +1,122 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.selectors = undefined;
+
+var _reselect = require("reselect");
+
+var _immutable = require("immutable");
+
+var Immutable = _interopRequireWildcard(_immutable);
+
+var _utility = require("../utility");
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+var initialState = Immutable.Map({
+  error: _utility.noError,
+  fetched: false,
+  fetching: false,
+
+  info: Immutable.Map(),
+  companies: Immutable.Map()
+});
+
+var fetchCurrentAccountPending = function fetchCurrentAccountPending(state) {
+  return state.merge({
+    error: _utility.noError,
+    fetching: true
+  });
+},
+    fetchCurrentAccountRejected = function fetchCurrentAccountRejected(state, _ref) {
+  var error = _ref.payload.error;
+  return state.merge({
+    error: error,
+    fetching: false
+  });
+},
+    fetchCurrentAccountFulfilled = function fetchCurrentAccountFulfilled(state, _ref2) {
+  var payload = _ref2.payload;
+  return state.mergeDeep({
+    fetched: true,
+    fetching: false,
+
+    info: payload.Account,
+    companies: payload.Companies
+  });
+},
+    accountChangePassword = function accountChangePassword(state) {
+  return state.setIn(["info", "RequireChange"], false);
+},
+    accountGaveConsent = function accountGaveConsent(state) {
+  return state.setIn(["info", "HasToGiveConsent"], false);
+};
+
+var reducer = function reducer() {
+  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;
+  var action = arguments[1];
+
+
+  switch (action.type) {
+    case "FETCH_INITIAL_INFORMATION_PENDING":
+      return fetchCurrentAccountPending(state);
+
+    case "FETCH_INITIAL_INFORMATION_REJECTED":
+      return fetchCurrentAccountRejected(state, action);
+
+    case "FETCH_INITIAL_INFORMATION_FULFILLED":
+      return fetchCurrentAccountFulfilled(state, action);
+
+    case "ACCOUNT_CHANGE_PASSWORD":
+      return accountChangePassword(state);
+
+    case "ACCOUNT_GAVE_CONSENT":
+      return accountGaveConsent(state);
+
+    default:
+      return state;
+  }
+};
+
+var getFetched = function getFetched(state) {
+  return state.getIn(["account", "fetched"]);
+},
+    getError = function getError(state) {
+  return state.getIn(["account", "error"]);
+};
+
+var getCurrentAccount = function getCurrentAccount(state) {
+  return state.getIn(["account", "info"]);
+},
+    getCurrentAccountCompanies = function getCurrentAccountCompanies(state) {
+  return state.getIn(["account", "companies"]);
+},
+    getCurrentAccountIsFetching = function getCurrentAccountIsFetching(state) {
+  return state.getIn(["account", "fetching"]);
+},
+    getCurrentAccountShouldFetch = (0, _reselect.createSelector)(getCurrentAccountIsFetching, getFetched, getError, function (isFetching, isFetched, error) {
+  return !isFetching && !isFetched && error === _utility.noError;
+}),
+    getCurrentAccountIsFetched = (0, _reselect.createSelector)(getCurrentAccountIsFetching, getFetched, getError, function (isFetching, isFetched, error) {
+  return !isFetching && isFetched && error === _utility.noError;
+}),
+    getCurrentAccountHasError = (0, _reselect.createSelector)(getError, function (error) {
+  return error !== _utility.noError;
+}),
+    getIsCurrentAccountAdministrator = (0, _reselect.createSelector)(getCurrentAccount, function (account) {
+  return (0, _utility.isAdministratorAccount)(account.get("Type"));
+});
+
+var selectors = exports.selectors = {
+  getCurrentAccountCompanies: getCurrentAccountCompanies,
+  getCurrentAccount: getCurrentAccount,
+  getCurrentAccountIsFetching: getCurrentAccountIsFetching,
+  getCurrentAccountShouldFetch: getCurrentAccountShouldFetch,
+  getCurrentAccountIsFetched: getCurrentAccountIsFetched,
+  getCurrentAccountHasError: getCurrentAccountHasError,
+  getIsCurrentAccountAdministrator: getIsCurrentAccountAdministrator
+};
+
+exports.default = reducer;

package/Account/request.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fetchInitialInformation = undefined;
+
+var _superagent = require("superagent");
+
+var _superagent2 = _interopRequireDefault(_superagent);
+
+var _immutable = require("immutable");
+
+var Immutable = _interopRequireWildcard(_immutable);
+
+var _utility = require("../utility");
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var normalizeInitialInformation = function normalizeInitialInformation(info) {
+  var Account = info.Account,
+      IsConnected = info.IsConnected,
+      Counties = info.Counties,
+      Companies = info.Companies;
+
+
+  return {
+    Account: Immutable.Map(Account || {}),
+    IsConnected: IsConnected,
+    Error: IsConnected ? _utility.noError : "Not connected",
+    Counties: typeof Counties === "undefined" ? Immutable.List() : (0, _utility.normalizeArrayByField)(Counties, "Short").entities,
+    Companies: typeof Companies === "undefined" ? Immutable.List() : (0, _utility.normalizeArray)(Companies).entities
+  };
+};
+
+var fetchInitialInformation = exports.fetchInitialInformation = function fetchInitialInformation(app) {
+  return new Promise(function (resolve, reject) {
+    return _superagent2.default.get("/api/extern/get-initial-information").type("form").query({ app: app }).end((0, _utility.withPromiseCallback)(function (reponse) {
+      return resolve(normalizeInitialInformation(reponse));
+    }, reject));
+  });
+};

package/Async/InitModule.js

@@ -0,0 +1,190 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _react = require("react");
+
+var React = _interopRequireWildcard(_react);
+
+var _Loading = require("../Messages/Loading");
+
+var _util = require("../Modal/util");
+
+var _reduxInjector = require("redux-injector");
+
+var _utility = require("../utility");
+
+var _reactRedux = require("react-redux");
+
+var _module = require("../reducer/module");
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+var injectPaginator = function injectPaginator(_ref) {
+  var key = _ref.key,
+      itemsReducer = _ref.itemsReducer,
+      pagesReducer = _ref.pagesReducer;
+
+  (0, _reduxInjector.injectReducer)("entities." + key, itemsReducer);
+  (0, _reduxInjector.injectReducer)("paginations." + key, pagesReducer);
+};
+
+var mapStateToProps = function mapStateToProps(state, _ref2) {
+  var module = _ref2.route.default.module;
+  return {
+    ready: (0, _module.getIsModuleReady)(state, module)
+  };
+},
+    mapDispatchToProps = function mapDispatchToProps(dispatch, _ref3) {
+  var route = _ref3.route;
+  return {
+    initModule: function initModule() {
+      var _route$default = route.default,
+          reducers = _route$default.reducers,
+          modals = _route$default.modals,
+          paginators = _route$default.paginators,
+          module = _route$default.module;
+
+
+      (0, _utility.delay)().then(function () {
+        if (reducers) {
+          if (Array.isArray(reducers)) {
+            var _iteratorNormalCompletion = true;
+            var _didIteratorError = false;
+            var _iteratorError = undefined;
+
+            try {
+              for (var _iterator = reducers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                var _ref4 = _step.value;
+                var key = _ref4.key,
+                    func = _ref4.func;
+
+                (0, _reduxInjector.injectReducer)(key, func);
+              }
+            } catch (err) {
+              _didIteratorError = true;
+              _iteratorError = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion && _iterator.return) {
+                  _iterator.return();
+                }
+              } finally {
+                if (_didIteratorError) {
+                  throw _iteratorError;
+                }
+              }
+            }
+          } else {
+            var _key = reducers.key,
+                _func = reducers.func;
+
+
+            (0, _reduxInjector.injectReducer)(_key, _func);
+          }
+        }
+      }).then(function () {
+        if (modals) {
+          (0, _util.injectModals)(modals);
+        }
+      }).then(function () {
+        if (paginators) {
+          if (Array.isArray(paginators)) {
+            var _iteratorNormalCompletion2 = true;
+            var _didIteratorError2 = false;
+            var _iteratorError2 = undefined;
+
+            try {
+              for (var _iterator2 = paginators[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+                var paginator = _step2.value;
+
+                injectPaginator(paginator);
+              }
+            } catch (err) {
+              _didIteratorError2 = true;
+              _iteratorError2 = err;
+            } finally {
+              try {
+                if (!_iteratorNormalCompletion2 && _iterator2.return) {
+                  _iterator2.return();
+                }
+              } finally {
+                if (_didIteratorError2) {
+                  throw _iteratorError2;
+                }
+              }
+            }
+          } else {
+            injectPaginator(paginators);
+          }
+        }
+      }).then(function () {
+        dispatch((0, _module.moduleIsReadyAction)(module));
+      });
+    }
+  };
+};
+
+var InitModule = function (_React$Component) {
+  _inherits(InitModule, _React$Component);
+
+  function InitModule() {
+    _classCallCheck(this, InitModule);
+
+    return _possibleConstructorReturn(this, (InitModule.__proto__ || Object.getPrototypeOf(InitModule)).apply(this, arguments));
+  }
+
+  _createClass(InitModule, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      if (!this.props.ready) {
+        this.props.initModule();
+      }
+    }
+  }, {
+    key: "shouldComponentUpdate",
+    value: function shouldComponentUpdate() {
+      return true;
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _props = this.props,
+          route = _props.route,
+          ready = _props.ready,
+          props = _props.props;
+      var Component = route.default.Component;
+
+
+      if (ready) {
+        return React.createElement(Component, props);
+      }
+
+      return React.createElement(
+        "div",
+        { className: "mt-3" },
+        React.createElement(_Loading.LoadingMessage, { message: "A\u0219teapt\u0103 un pic..." })
+      );
+    }
+  }]);
+
+  return InitModule;
+}(React.Component);
+
+var WrapInitModule = (0, _reactRedux.connect)(mapStateToProps, mapDispatchToProps)(InitModule);
+
+var createWrap = function createWrap(route, props) {
+  return React.createElement(WrapInitModule, { props: props, route: route });
+};
+
+exports.default = createWrap;

package/Async/RouteLoading.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _react = require("react");
+
+var _react2 = _interopRequireDefault(_react);
+
+var _Loading = require("../Messages/Loading");
+
+var _SimulatedException = require("./SimulatedException");
+
+var _SimulatedException2 = _interopRequireDefault(_SimulatedException);
+
+var _index = require("./index");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var IgnoreThisNode = function IgnoreThisNode(_ref) {
+  var _ref$error = _ref.error,
+      message = _ref$error.message,
+      stack = _ref$error.stack;
+
+  throw new _SimulatedException2.default(message, stack);
+};
+
+var RouteLoading = function RouteLoading(_ref2) {
+  var error = _ref2.error,
+      retry = _ref2.retry,
+      timedOut = _ref2.timedOut;
+
+  if (error) {
+    return _react2.default.createElement(
+      _index.ErrorBoundary,
+      null,
+      _react2.default.createElement(IgnoreThisNode, { error: error })
+    );
+  }
+
+  if (timedOut) {
+    return _react2.default.createElement(
+      "div",
+      null,
+      "Se pare că se încarcă mai greu ca de obicei ",
+      _react2.default.createElement(
+        "button",
+        {
+          className: "btn btn-primary btn-block",
+          onClick: retry, type: "button" },
+        "Încearcă din nou"
+      )
+    );
+  }
+
+  return _react2.default.createElement(
+    "div",
+    { className: "mt-3" },
+    _react2.default.createElement(_Loading.LoadingMessage, { message: "A\u0219teapt\u0103 un pic..." })
+  );
+};
+
+exports.default = RouteLoading;

package/Async/SimulatedException.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+/* eslint-disable max-classes-per-file */
+
+var CustomError = function (_Error) {
+  _inherits(CustomError, _Error);
+
+  function CustomError(message, stack) {
+    _classCallCheck(this, CustomError);
+
+    var _this = _possibleConstructorReturn(this, (CustomError.__proto__ || Object.getPrototypeOf(CustomError)).call(this, message));
+
+    _this.message = message;
+    _this.name = message;
+    _this.stack = stack;
+    return _this;
+  }
+
+  return CustomError;
+}(Error);
+
+var SimulatedException = function (_CustomError) {
+  _inherits(SimulatedException, _CustomError);
+
+  function SimulatedException() {
+    _classCallCheck(this, SimulatedException);
+
+    return _possibleConstructorReturn(this, (SimulatedException.__proto__ || Object.getPrototypeOf(SimulatedException)).apply(this, arguments));
+  }
+
+  return SimulatedException;
+}(CustomError);
+
+exports.default = SimulatedException;

package/Async/index.js

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createAsyncRoute = exports.setErrorBoundary = exports.ErrorBoundary = undefined;
+
+var _reactLoadable = require("react-loadable");
+
+var _reactLoadable2 = _interopRequireDefault(_reactLoadable);
+
+var _react = require("react");
+
+var React = _interopRequireWildcard(_react);
+
+var _RouteLoading = require("./RouteLoading");
+
+var _RouteLoading2 = _interopRequireDefault(_RouteLoading);
+
+var _InitModule = require("./InitModule");
+
+var _InitModule2 = _interopRequireDefault(_InitModule);
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// type injectPaginatorTypes = {
+//   key: string,
+//   itemsReducer: any;
+//   pagesReducer: any;
+// };
+// import { injectReducer } from "redux-injector";
+// import { injectModals } from "../Modal/util";
+
+var timeout = 15000;
+/* eslint-disable new-cap, react/prefer-stateless-function, react/require-optimization */
+
+var ErrorBoundary = exports.ErrorBoundary = function ErrorBoundary() {
+  return React.createElement(
+    "div",
+    null,
+    "No ErrorBoundary passed to x25"
+  );
+};
+
+// const injectPaginator = ({ key, itemsReducer, pagesReducer } : injectPaginatorTypes) => {
+//   injectReducer(`entities.${key}`, itemsReducer);
+//   injectReducer(`paginations.${key}`, pagesReducer);
+// };
+
+// const renderWithReducer = (route, props) => {
+//   const { Component, reducers, modals, paginators } = route.default;
+//
+//   if (reducers) {
+//     if (Array.isArray(reducers)) {
+//       for (const { key, func } of reducers) {
+//         injectReducer(key, func);
+//       }
+//     } else {
+//       const { key, func } = reducers;
+//
+//       injectReducer(key, func);
+//     }
+//   }
+//
+//   if (modals) {
+//     injectModals(modals);
+//   }
+//
+//   if (paginators) {
+//     if (Array.isArray(paginators)) {
+//       for (const paginator of paginators) {
+//         injectPaginator(paginator);
+//       }
+//     } else {
+//       injectPaginator(paginators);
+//     }
+//   }
+//
+//   return <Component {...props} />;
+// };
+
+var setErrorBoundary = exports.setErrorBoundary = function setErrorBoundary(theError) {
+  exports.ErrorBoundary = ErrorBoundary = theError;
+};
+
+var createAsyncRoute = exports.createAsyncRoute = function createAsyncRoute(loader) {
+  return (0, _reactLoadable2.default)({
+    loader: loader,
+    loading: _RouteLoading2.default,
+    render: _InitModule2.default,
+    timeout: timeout
+  });
+};

package/Async/types.js

@@ -0,0 +1 @@
+"use strict";