asab_webui_shell 25.1.1

package/dist/modules/auth/index.js

@@ -0,0 +1,761 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _react = _interopRequireWildcard(require("react"));
+var _asab_webui_components = require("asab_webui_components");
+var _header = require("./header");
+var _reducer = _interopRequireDefault(require("./reducer"));
+var _actions = require("./actions");
+var _actions2 = require("../../actions");
+var _api = require("./api");
+var _locationReplace = require("../../components/locationReplace");
+var _SessionExpirationAlert = require("./components/SessionExpirationAlert");
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != (0, _typeof2["default"])(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; } // TODO: Use SessionExpirationAlert only after proper fix of the component
+var AccessControlScreen = /*#__PURE__*/(0, _react.lazy)(function () {
+  return Promise.resolve().then(function () {
+    return _interopRequireWildcard(require("./screens/AccessControlScreen"));
+  });
+});
+var InvitationScreen = /*#__PURE__*/(0, _react.lazy)(function () {
+  return Promise.resolve().then(function () {
+    return _interopRequireWildcard(require("./screens/InvitationScreen"));
+  });
+});
+var AuthModule = exports["default"] = /*#__PURE__*/function (_Module) {
+  function AuthModule(app, name) {
+    var _this;
+    (0, _classCallCheck2["default"])(this, AuthModule);
+    _this = _callSuper(this, AuthModule, [app, "AuthModule"]);
+    _this.OAuthToken = JSON.parse(sessionStorage.getItem('SeaCatOAuth2Token'));
+    _this.UserInfo = null;
+    _this.Api = new _api.SeaCatAuthApi(app);
+    _this.RedirectURL = window.location.href;
+    _this.MustAuthenticate = true; // Setting this to false means, that we can operate without authenticated user
+    app.ReduxService.addReducer("auth", _reducer["default"]);
+    _this.App.addSplashScreenRequestor(_this);
+    _this.Authorization = _this.App.Config.get("authorization"); // Get authorization settings from configuration
+
+    _this.SessionExpiration = null; // Session expiration as defined in user info
+    _this.sessionValidationInterval = null; // Initialize session validation interval
+
+    // Access control screen
+    app.Router.addRoute({
+      path: '/auth/access-control',
+      end: true,
+      name: 'Access control',
+      component: AccessControlScreen,
+      resource: "*"
+    });
+
+    // Invitation screen
+    app.Router.addRoute({
+      path: '/auth/invite',
+      end: true,
+      name: 'Invite',
+      component: InvitationScreen,
+      resource: "seacat:tenant:assign"
+    });
+    return _this;
+  }
+  (0, _inherits2["default"])(AuthModule, _Module);
+  return (0, _createClass2["default"])(AuthModule, [{
+    key: "initialize",
+    value: function () {
+      var _initialize = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
+        var headerService, qs, authorization_code, errorType, stateIndex, state, reloadUrl, result, force_login_prompt, tenantAuthorized, _force_login_prompt, currentTenant, resources, _force_login_prompt2, _force_login_prompt3;
+        return _regenerator["default"].wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              headerService = this.App.locateService("HeaderService");
+              headerService.addComponent({
+                component: _header.AuthHeaderInvitation,
+                componentProps: {
+                  AuthModule: this
+                },
+                order: 200
+              });
+              headerService.addComponent({
+                component: _header.AuthHeaderDropdown,
+                componentProps: {
+                  AuthModule: this
+                },
+                order: 700
+              });
+              if (!(typeof MOCK_USERINFO !== 'undefined')) {
+                _context.next = 8;
+                break;
+              }
+              _context.next = 6;
+              return this.simulateUserinfo(MOCK_USERINFO);
+            case 6:
+              _context.next = 63;
+              break;
+            case 8:
+              // Check the query string for 'code'
+              qs = new URLSearchParams(window.location.search);
+              authorization_code = qs.get('code'); // Checking error type in params
+              errorType = qs.get('error');
+              if (!(errorType != undefined && errorType != 'tenant_access_denied')) {
+                _context.next = 13;
+                break;
+              }
+              return _context.abrupt("return");
+            case 13:
+              if (!(authorization_code !== null)) {
+                _context.next = 25;
+                break;
+              }
+              _context.next = 16;
+              return this._updateToken(authorization_code);
+            case 16:
+              // Remove 'code' from a query string
+              qs["delete"]('code');
+              stateIndex = qs.get("state");
+              state = ""; // Check if stateIndex is present, eventually return empty state string
+              if (stateIndex != undefined) {
+                // Check if oauth2_state_ is present, eventually return empty string
+                if (localStorage.getItem("oauth2_state_".concat(stateIndex)) != undefined) {
+                  state = localStorage.getItem("oauth2_state_".concat(stateIndex));
+                }
+              }
+              localStorage.removeItem("oauth2_state_".concat(stateIndex));
+
+              // Remove 'state' from a query string
+              qs["delete"]("state");
+
+              // Construct the new URL without `code` in the query string
+              // For this case, condition on empty qs string is sufficient and tested
+
+              if (qs.toString() == '') {
+                // Remove `?` part from URL completely, if empty
+                reloadUrl = window.location.pathname + state; // part form localstorage instead of hash
+              } else {
+                reloadUrl = window.location.pathname + '?' + qs.toString() + state; // part form localstorage instead of hash
+              }
+
+              // Reload the app with `code` removed
+              _context.next = 25;
+              return (0, _locationReplace.locationReplace)(reloadUrl);
+            case 25:
+              if (!(this.OAuthToken != null)) {
+                _context.next = 58;
+                break;
+              }
+              _context.next = 28;
+              return this.updateUserInfo();
+            case 28:
+              result = _context.sent;
+              if (result) {
+                _context.next = 35;
+                break;
+              }
+              // User info not found - go to login
+              sessionStorage.removeItem('SeaCatOAuth2Token');
+              force_login_prompt = true;
+              _context.next = 34;
+              return this.Api.login(this.RedirectURL, force_login_prompt);
+            case 34:
+              return _context.abrupt("return");
+            case 35:
+              // Add interceptor with Bearer token in the Header into axios calls
+              this.App.addAxiosInterceptor(this.authInterceptor());
+              // Add webSocket interceptor with Bearer token into websocket calls
+              this.App.addWebSocketInterceptor(this.webSocketAuthInterceptor());
+
+              // Authorization of the user based on tenant access
+              if (!(this.App.Config.get("authorization") !== "disabled" && this.App.Services.TenantService)) {
+                _context.next = 44;
+                break;
+              }
+              // Tenant access validation
+              tenantAuthorized = this.validateTenant();
+              if (tenantAuthorized) {
+                _context.next = 44;
+                break;
+              }
+              // If tenant not authorized, redirect to Access denied card
+              _force_login_prompt = false;
+              _context.next = 43;
+              return this.Api.login(this.RedirectURL, _force_login_prompt);
+            case 43:
+              return _context.abrupt("return");
+            case 44:
+              if (!(this.App.Store && this.App.Services.TenantService && this.UserInfo !== null)) {
+                _context.next = 55;
+                break;
+              }
+              currentTenant = this.App.Services.TenantService.getCurrentTenant();
+              resources = this.UserInfo.resources ? this.UserInfo.resources[currentTenant] : [];
+              /*
+              	When switching between tenants,
+              	we need to force authorization to obtain
+              	correct data (resources) for particular
+              	tenant (this is unavailable until auth token is updated)
+              */
+              if (!(resources == undefined)) {
+                _context.next = 52;
+                break;
+              }
+              _force_login_prompt2 = false;
+              _context.next = 51;
+              return this.Api.login(this.RedirectURL, _force_login_prompt2);
+            case 51:
+              return _context.abrupt("return");
+            case 52:
+              if (this.App.Store != null) {
+                this.App.Store.dispatch({
+                  type: _actions.types.AUTH_RESOURCES,
+                  resources: resources
+                });
+              }
+              _context.next = 55;
+              return this.validateNavigation();
+            case 55:
+              if (!(this.UserInfo != null)) {
+                _context.next = 58;
+                break;
+              }
+              _context.next = 58;
+              return this._startSessionExpirationValidation();
+            case 58:
+              if (!(this.UserInfo == null && this.MustAuthenticate)) {
+                _context.next = 63;
+                break;
+              }
+              // TODO: force_login_prompt = true to break authentication failure loop
+              _force_login_prompt3 = false;
+              _context.next = 62;
+              return this.Api.login(this.RedirectURL, _force_login_prompt3);
+            case 62:
+              return _context.abrupt("return");
+            case 63:
+              this.App.removeSplashScreenRequestor(this);
+            case 64:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function initialize() {
+        return _initialize.apply(this, arguments);
+      }
+      return initialize;
+    }()
+  }, {
+    key: "authInterceptor",
+    value: function authInterceptor() {
+      var _this2 = this;
+      var interceptor = function interceptor(config) {
+        config.headers['Authorization'] = 'Bearer ' + _this2.OAuthToken['access_token'];
+        return config;
+      };
+      return interceptor;
+    }
+  }, {
+    key: "webSocketAuthInterceptor",
+    value: function webSocketAuthInterceptor() {
+      return "access_token_".concat(this.OAuthToken['access_token']);
+    }
+  }, {
+    key: "simulateUserinfo",
+    value: function () {
+      var _simulateUserinfo = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2(mock_userinfo) {
+        var mockParams, availableTenants;
+        return _regenerator["default"].wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              /*
+              	This method takes parameters from wepack.dev.js settings
+              		plugins: [
+              		...
+              		new webpack.DefinePlugin({
+              			'MOCK_USERINFO': JSON.stringify({  // Inject mocked UserInfo object, this means the application will NOT require user authorization
+              				"username": "johndev",
+              				"email": "dev@dev.de",
+              				"phone": "123456789",
+              				"resources": ["authz:superuser"],
+              				"roles": ["default/Admin"],
+              				"sub": "devdb:dev:1abc2def3456",
+              				"tenants": ["default"]
+              			})
+              		}),
+              		...
+              	],
+              	*/
+              this.App.addAlert("warning", "ASABAuthModule|You are using MOCK_USERINFO!", 1, true);
+              mockParams = mock_userinfo;
+              if (mockParams.resources) {
+                mockParams["resources"] = Object.values(mockParams.resources);
+              }
+              if (mockParams.roles) {
+                mockParams["roles"] = Object.values(mockParams.roles);
+              }
+              if (mockParams.tenants) {
+                mockParams["tenants"] = Object.values(mockParams.tenants);
+              }
+              if (this.App.Store != null) {
+                this.App.Store.dispatch({
+                  type: _actions.types.AUTH_USERINFO,
+                  payload: mockParams
+                });
+                this.App.Store.dispatch({
+                  type: _actions.types.AUTH_RESOURCES,
+                  resources: mockParams["resources"]
+                });
+              }
+
+              /** Check for TenantService and pass tenants list obtained from userinfo */
+              availableTenants = mockParams.tenants;
+              if (!this.App.Services.TenantService) {
+                _context2.next = 10;
+                break;
+              }
+              _context2.next = 10;
+              return this.App.Services.TenantService.setTenants(availableTenants, this._getAuthorizedTenant(mockParams));
+            case 10:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function simulateUserinfo(_x) {
+        return _simulateUserinfo.apply(this, arguments);
+      }
+      return simulateUserinfo;
+    }()
+  }, {
+    key: "logout",
+    value: function logout() {
+      this.App.addSplashScreenRequestor(this);
+      this._stopSessionExpirationValidation(); // Stop session validation and clear the timeout
+
+      sessionStorage.removeItem('SeaCatOAuth2Token');
+      var promise = this.Api.logout(this.OAuthToken['access_token']);
+      if (promise == null) {
+        window.location.reload();
+      }
+      promise.then(function (response) {
+        window.location.reload();
+      })["catch"](function (error) {
+        window.location.reload();
+      });
+    }
+
+    // TODO: reconsider removing async/await with promise
+  }, {
+    key: "validateNavigation",
+    value: function () {
+      var _validateNavigation = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4() {
+        var _state$navigation,
+          _state$auth,
+          _this3 = this;
+        var state, navItems, resources, authorizedNavItems;
+        return _regenerator["default"].wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              state = this.App.Store.getState();
+              navItems = (_state$navigation = state.navigation) === null || _state$navigation === void 0 ? void 0 : _state$navigation.navItems;
+              resources = (_state$auth = state.auth) === null || _state$auth === void 0 ? void 0 : _state$auth.resources;
+              authorizedNavItems = [];
+              _context4.t0 = navItems;
+              if (!_context4.t0) {
+                _context4.next = 8;
+                break;
+              }
+              _context4.next = 8;
+              return Promise.all(navItems.map(/*#__PURE__*/function () {
+                var _ref = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3(itm, idx) {
+                  var access_auth;
+                  return _regenerator["default"].wrap(function _callee3$(_context3) {
+                    while (1) switch (_context3.prev = _context3.next) {
+                      case 0:
+                        if (!(resources.indexOf('authz:superuser') !== -1)) {
+                          _context3.next = 4;
+                          break;
+                        }
+                        // If user is superuser, validate every navigation item
+                        authorizedNavItems.push(itm);
+                        _context3.next = 18;
+                        break;
+                      case 4:
+                        if (!itm.resource) {
+                          _context3.next = 13;
+                          break;
+                        }
+                        if (!itm.children) {
+                          _context3.next = 9;
+                          break;
+                        }
+                        _context3.next = 8;
+                        return _this3._validateChildrenNav(itm, resources);
+                      case 8:
+                        itm.children = _context3.sent;
+                      case 9:
+                        // Item validation
+                        access_auth = _this3._validateItemNav(itm.resource, resources);
+                        if (access_auth == true) {
+                          authorizedNavItems.push(itm);
+                        }
+                        _context3.next = 18;
+                        break;
+                      case 13:
+                        if (!itm.children) {
+                          _context3.next = 18;
+                          break;
+                        }
+                        _context3.next = 16;
+                        return _this3._validateChildrenNav(itm, resources);
+                      case 16:
+                        itm.children = _context3.sent;
+                        if (itm.children.length > 0) {
+                          authorizedNavItems.push(itm);
+                        }
+                      case 18:
+                      case "end":
+                        return _context3.stop();
+                    }
+                  }, _callee3);
+                }));
+                return function (_x2, _x3) {
+                  return _ref.apply(this, arguments);
+                };
+              }()));
+            case 8:
+              this.App.Store.dispatch({
+                type: _actions2.SET_NAVIGATION_ITEMS,
+                navItems: authorizedNavItems
+              });
+            case 9:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function validateNavigation() {
+        return _validateNavigation.apply(this, arguments);
+      }
+      return validateNavigation;
+    }() // Validate sidebar's item children
+  }, {
+    key: "_validateChildrenNav",
+    value: function () {
+      var _validateChildrenNav2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee6(itm, resources) {
+        var _this4 = this;
+        var authorizedNavChildren;
+        return _regenerator["default"].wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              // Item's children validation
+              authorizedNavChildren = [];
+              _context6.next = 3;
+              return Promise.all(itm.children.map(/*#__PURE__*/function () {
+                var _ref2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee5(child, id) {
+                  var access_auth;
+                  return _regenerator["default"].wrap(function _callee5$(_context5) {
+                    while (1) switch (_context5.prev = _context5.next) {
+                      case 0:
+                        if (child.resource) {
+                          access_auth = _this4._validateItemNav(child.resource, resources);
+                          if (access_auth == true) {
+                            authorizedNavChildren.push(child);
+                          }
+                        }
+                      case 1:
+                      case "end":
+                        return _context5.stop();
+                    }
+                  }, _callee5);
+                }));
+                return function (_x6, _x7) {
+                  return _ref2.apply(this, arguments);
+                };
+              }()));
+            case 3:
+              return _context6.abrupt("return", authorizedNavChildren);
+            case 4:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6);
+      }));
+      function _validateChildrenNav(_x4, _x5) {
+        return _validateChildrenNav2.apply(this, arguments);
+      }
+      return _validateChildrenNav;
+    }() // Validate sidebar items
+  }, {
+    key: "_validateItemNav",
+    value: function _validateItemNav(resource, resources) {
+      var valid = resources ? resources.indexOf(resource) !== -1 : false;
+      // If user is superuser, then item is enabled
+      if (resources.indexOf('authz:superuser') !== -1) {
+        valid = true;
+      }
+      return valid;
+    }
+
+    // Validate tenant access
+  }, {
+    key: "validateTenant",
+    value: function validateTenant() {
+      var resources = [];
+      var tenants = [];
+      var currentTenant = this.App.Services.TenantService.getCurrentTenant();
+      if (this.UserInfo !== null) {
+        resources = this.UserInfo.resources ? this.UserInfo.resources[currentTenant] : [];
+        tenants = this.UserInfo.tenants ? this.UserInfo.tenants : [];
+      }
+      var valid = tenants ? tenants.indexOf(currentTenant) !== -1 : false;
+      // If user is superuser, then tenant access is granted
+      if (resources && resources.indexOf('authz:superuser') !== -1) {
+        valid = true;
+      }
+      return valid;
+    }
+  }, {
+    key: "updateUserInfo",
+    value: function () {
+      var _updateUserInfo = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee7() {
+        var _response$data;
+        var response, availableTenants;
+        return _regenerator["default"].wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              _context7.prev = 0;
+              _context7.next = 3;
+              return this.Api.userinfo(this.OAuthToken.access_token);
+            case 3:
+              response = _context7.sent;
+              _context7.next = 12;
+              break;
+            case 6:
+              _context7.prev = 6;
+              _context7.t0 = _context7["catch"](0);
+              console.error("Failed to update user info", _context7.t0);
+              this.UserInfo = null;
+              if (this.App.Store != null) {
+                this.App.Store.dispatch({
+                  type: _actions.types.AUTH_USERINFO,
+                  payload: this.UserInfo
+                });
+              }
+              return _context7.abrupt("return", false);
+            case 12:
+              this.UserInfo = response.data;
+              this.SessionExpiration = (_response$data = response.data) === null || _response$data === void 0 ? void 0 : _response$data.exp;
+              if (this.App.Store != null) {
+                this.App.Store.dispatch({
+                  type: _actions.types.AUTH_USERINFO,
+                  payload: this.UserInfo
+                });
+              }
+
+              /** Check for TenantService and pass tenants list obtained from userinfo */
+              availableTenants = this.UserInfo.tenants;
+              if (!this.App.Services.TenantService) {
+                _context7.next = 19;
+                break;
+              }
+              _context7.next = 19;
+              return this.App.Services.TenantService.setTenants(availableTenants, this._getAuthorizedTenant(this.UserInfo));
+            case 19:
+              return _context7.abrupt("return", true);
+            case 20:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this, [[0, 6]]);
+      }));
+      function updateUserInfo() {
+        return _updateUserInfo.apply(this, arguments);
+      }
+      return updateUserInfo;
+    }()
+  }, {
+    key: "_updateToken",
+    value: function () {
+      var _updateToken2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee8(authorization_code) {
+        var response;
+        return _regenerator["default"].wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              _context8.prev = 0;
+              _context8.next = 3;
+              return this.Api.token_authorization_code(authorization_code, this.RedirectURL);
+            case 3:
+              response = _context8.sent;
+              _context8.next = 10;
+              break;
+            case 6:
+              _context8.prev = 6;
+              _context8.t0 = _context8["catch"](0);
+              console.error("Failed to update token", _context8.t0);
+              return _context8.abrupt("return", false);
+            case 10:
+              this.OAuthToken = response.data;
+              sessionStorage.setItem('SeaCatOAuth2Token', JSON.stringify(response.data));
+              return _context8.abrupt("return", true);
+            case 13:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8, this, [[0, 6]]);
+      }));
+      function _updateToken(_x8) {
+        return _updateToken2.apply(this, arguments);
+      }
+      return _updateToken;
+    }()
+  }, {
+    key: "_getAuthorizedTenant",
+    value: function _getAuthorizedTenant(userInfo) {
+      /*
+      	Return the authorized tenant ID from userinfo. 
+      	Pick the first one if there are multiple tenants.
+      */
+      if (userInfo !== null && userInfo !== void 0 && userInfo.resources) {
+        for (var tenantId in userInfo.resources) {
+          if (tenantId != '*' && userInfo.resources.hasOwnProperty(tenantId)) {
+            return tenantId;
+          }
+        }
+      } else {
+        return undefined;
+      }
+    }
+
+    // Loop validating session expiration
+  }, {
+    key: "_startSessionExpirationValidation",
+    value: function () {
+      var _startSessionExpirationValidation2 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee10() {
+        var _this5 = this;
+        var warningDisplayed, _validateSession;
+        return _regenerator["default"].wrap(function _callee10$(_context10) {
+          while (1) switch (_context10.prev = _context10.next) {
+            case 0:
+              if (this.SessionExpiration) {
+                _context10.next = 3;
+                break;
+              }
+              console.warn("Session expiration is not set.");
+              return _context10.abrupt("return");
+            case 3:
+              warningDisplayed = false; // Tracks if the "about to expire" warning has been shown
+              _validateSession = /*#__PURE__*/function () {
+                var _ref3 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee9() {
+                  var currentTime, timeRemaining, isUserInfoUpdated;
+                  return _regenerator["default"].wrap(function _callee9$(_context9) {
+                    while (1) switch (_context9.prev = _context9.next) {
+                      case 0:
+                        currentTime = Date.now() / 1000; // Convert milliseconds to seconds
+                        timeRemaining = _this5.SessionExpiration - currentTime; // Time difference for triggering "about to expire" warning
+                        // Prevent glitches on very large time remaining values
+                        if (timeRemaining >= Math.pow(2, 31)) {
+                          // Set timeout to maximum allowed value
+                          timeRemaining = Math.pow(2, 31) - 1;
+                        }
+
+                        // If remaining time is between 1 and 60s, repetitivelly ask for userInfo and trigger "about to expire" warning
+                        if (!(timeRemaining <= 60 && timeRemaining > 0)) {
+                          _context9.next = 7;
+                          break;
+                        }
+                        if (!warningDisplayed) {
+                          _this5.App.addAlert("info", "General|Your session will expire soon", 30, true);
+                          warningDisplayed = true; // Mark the warning as displayed
+                        }
+                        _context9.next = 7;
+                        return _this5.updateUserInfo();
+                      case 7:
+                        if (!(_this5.SessionExpiration <= currentTime)) {
+                          _context9.next = 17;
+                          break;
+                        }
+                        _context9.next = 10;
+                        return _this5.updateUserInfo();
+                      case 10:
+                        isUserInfoUpdated = _context9.sent;
+                        if (isUserInfoUpdated) {
+                          _context9.next = 17;
+                          break;
+                        }
+                        // Stop further checks
+                        clearTimeout(_this5.sessionValidationInterval);
+                        _this5.sessionValidationInterval = null;
+                        _this5.App.addAlert("info", "ASABAuthModule|Your session has expired.", 3600 * 1000, true, function (alert, store) {
+                          return /*#__PURE__*/_react["default"].createElement(_SessionExpirationAlert.SessionExpirationAlert, {
+                            alert: alert,
+                            store: store
+                          });
+                        });
+                        // Disable UI elements
+                        if (_this5.App.Store) {
+                          _this5.App.Store.dispatch({
+                            type: _actions.types.AUTH_SESSION_EXPIRATION,
+                            sessionExpired: true
+                          });
+
+                          // Disable UI elements
+                          (0, _toConsumableArray2["default"])(document.querySelectorAll('#app-sidebar .nav-link, [class^="btn"]:not(.alert-button), [class*=" btn"]:not(.alert-button), .btn-group a, .page-item, input, select')).forEach(function (i) {
+                            i.classList.add("disabled");
+                            i.setAttribute("disabled", "");
+                          });
+
+                          // Reload on navigation actions
+                          window.addEventListener("popstate", function () {
+                            window.location.reload();
+                          });
+                        }
+                        return _context9.abrupt("return");
+                      case 17:
+                        // Re-trigger validation after 10 seconds
+                        _this5.sessionValidationInterval = setTimeout(_validateSession, 10000);
+                      case 18:
+                      case "end":
+                        return _context9.stop();
+                    }
+                  }, _callee9);
+                }));
+                return function validateSession() {
+                  return _ref3.apply(this, arguments);
+                };
+              }(); // Start the first validation cycle
+              _validateSession();
+            case 6:
+            case "end":
+              return _context10.stop();
+          }
+        }, _callee10, this);
+      }));
+      function _startSessionExpirationValidation() {
+        return _startSessionExpirationValidation2.apply(this, arguments);
+      }
+      return _startSessionExpirationValidation;
+    }() // Stop looping on session expiration validation
+  }, {
+    key: "_stopSessionExpirationValidation",
+    value: function _stopSessionExpirationValidation() {
+      if (this.sessionValidationInterval) {
+        clearInterval(this.sessionValidationInterval);
+        this.sessionValidationInterval = null;
+      }
+    }
+  }]);
+}(_asab_webui_components.Module);