@jetbrains/ring-ui-built 6.0.32 → 6.0.33

package/components/permissions/permissions.js

@@ -1,4 +1,10 @@
+import { _ as _defineProperty, b as _createClass, f as _classCallCheck } from '../_helpers/_rollupPluginBabelHelpers.js';
+import 'core-js/modules/es.array.index-of.js';
+import 'core-js/modules/es.array.map.js';
+import 'core-js/modules/es.object.to-string.js';
+import 'core-js/modules/es.promise.js';
 import PermissionCache from './permissions__cache.js';
+import 'core-js/modules/es.array.reduce.js';
 
 /**
  * <code>
@@ -24,20 +30,26 @@ import PermissionCache from './permissions__cache.js';
  * <code>serviceId</code> if provided then permissions only for the service are loaded.
  * @constructor
  */
-class Permissions {
-  /**
-   * @const {string}
-   */
-  static API_PERMISSION_CACHE_PATH = 'permissions/cache';
-  query;
-  namesConverter;
-  _auth;
-  _datasource;
-  _promise;
-  _subscribed;
-  _permissionCache;
-  constructor(auth) {
-    let config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+var Permissions = /*#__PURE__*/function () {
+  function Permissions(auth) {
+    var _this = this;
+    var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    _classCallCheck(this, Permissions);
+    _defineProperty(this, "query", void 0);
+    _defineProperty(this, "namesConverter", void 0);
+    _defineProperty(this, "_auth", void 0);
+    _defineProperty(this, "_datasource", void 0);
+    _defineProperty(this, "_promise", void 0);
+    _defineProperty(this, "_subscribed", void 0);
+    _defineProperty(this, "_permissionCache", void 0);
+    _defineProperty(this, "_defaultDatasource", function (query) {
+      return _this._auth.http.get(Permissions.API_PERMISSION_CACHE_PATH, {
+        query: {
+          fields: 'permission/key,global,projects(id)',
+          query
+        }
+      });
+    });
     this.query = Permissions.getPermissionQuery(config.services);
     this.namesConverter = config.prefix ? Permissions.getDefaultNamesConverter(config.prefix) : config.namesConverter;
     if (!auth) {
@@ -49,127 +61,160 @@ class Permissions {
     this._subscribed = false;
     this._permissionCache = new PermissionCache(null, this.namesConverter);
   }
-  _defaultDatasource = query => this._auth.http.get(Permissions.API_PERMISSION_CACHE_PATH, {
-    query: {
-      fields: 'permission/key,global,projects(id)',
-      query
+  return _createClass(Permissions, [{
+    key: "set",
+    value: function set(cachedPermissions) {
+      this._permissionCache.set(cachedPermissions);
+      this._setCache(Promise.resolve(this._permissionCache));
+      return this._permissionCache;
+    }
+  }, {
+    key: "get",
+    value: function get() {
+      return this._permissionCache.get();
+    }
+  }, {
+    key: "_setCache",
+    value: function _setCache(value) {
+      this._promise = value;
     }
-  });
-  /**
-   * Returns function, which cuts off prefix from server-side permission name
-   *
-   * @param {string} prefix
-   * @returns {Function}
-   */
-  static getDefaultNamesConverter(prefix) {
-    return storedName => {
-      if (storedName.indexOf(prefix) !== 0) {
-        return storedName;
-      } else {
-        return storedName.substr(prefix.length);
+  }, {
+    key: "_getCache",
+    value: function _getCache() {
+      return this._promise;
+    }
+  }, {
+    key: "_resetCache",
+    value: function _resetCache() {
+      this._setCache(null);
+    }
+    /**
+     * Loads logged-in user permissions.
+     * @param {object?} options
+     * @return {Promise.<Permissions>} promise that is resolved when the permissions are loaded
+     */
+  }, {
+    key: "load",
+    value: function load(options) {
+      var _this2 = this;
+      if (this._subscribed === false) {
+        this._auth.addListener('userChange', function () {
+          _this2.reload();
+        });
+        this._subscribed = true;
+      }
+      var cache = this._getCache();
+      if (!hasCacheControl('NO_CACHE', options) && cache) {
+        return cache;
+      }
+      if (hasCacheControl('NO_STORE', options)) {
+        return this._loadPermissions().then(function (cachedPermissions) {
+          return new PermissionCache(cachedPermissions, _this2.namesConverter);
+        });
+      }
+      var permissions = this._loadPermissions().then(function (cachedPermissions) {
+        return _this2.set(cachedPermissions);
+      });
+      this._setCache(permissions);
+      return permissions;
+      function hasCacheControl(value, _options) {
+        if (_options && _options.cacheControl) {
+          return _options.cacheControl[value];
+        }
+        return false;
       }
-    };
-  }
-  static getPermissionQuery(services) {
-    if (!services || !services.length) {
-      return undefined;
     }
-    return services.map(service => `service:{${service}}`).join(' or ');
-  }
-  set(cachedPermissions) {
-    this._permissionCache.set(cachedPermissions);
-    this._setCache(Promise.resolve(this._permissionCache));
-    return this._permissionCache;
-  }
-  get() {
-    return this._permissionCache.get();
-  }
-  _setCache(value) {
-    this._promise = value;
-  }
-  _getCache() {
-    return this._promise;
-  }
-  _resetCache() {
-    this._setCache(null);
-  }
-  /**
-   * Loads logged-in user permissions.
-   * @param {object?} options
-   * @return {Promise.<Permissions>} promise that is resolved when the permissions are loaded
-   */
-  load(options) {
-    if (this._subscribed === false) {
-      this._auth.addListener('userChange', () => {
-        this.reload();
+  }, {
+    key: "_loadPermissions",
+    value: function _loadPermissions() {
+      return this._datasource(this.query);
+    }
+    /**
+     * Reloads permission cache from server
+     * @returns {Promise.<Permissions>} promise that is resolved when the permissions are reloaded
+     */
+  }, {
+    key: "reload",
+    value: function reload() {
+      this._resetCache();
+      return this.load();
+    }
+    /**
+     * Waits till the permission cache is loaded then checks if the current user has the
+     * given permissions in the project with the given id.
+     *
+     * @param {string} permissions  space separated list of permissions
+     * @param {string=} projectId     optional projectId. If absent the method checks
+     *  if the given permission is granted in any project.
+     *
+     * @return {Promise.<boolean>}
+     */
+  }, {
+    key: "check",
+    value: function check(permissions, projectId) {
+      return this.load().then(function (permissionCache) {
+        return permissionCache.has(permissions, projectId);
       });
-      this._subscribed = true;
     }
-    const cache = this._getCache();
-    if (!hasCacheControl('NO_CACHE', options) && cache) {
-      return cache;
+    /**
+     * Binds a property with the name <code>propertyName</code> of the <code>object</code>
+     * to a boolean value that is true if user has the permissions and false if she doesn't.
+     *
+     * @example
+     * <code>
+     *   userPermissions.bindVariable($scope, 'canReadRole', 'role-read')
+     * </code>
+     *
+     * @param {object} object       an object which property should be bound
+     * @param {string} propertyName a name of a property to bind
+     * @param {string} permissions  space separated list of permissions
+     * @param {string=} projectId     optional projectId. If absent the method checks
+     *  if the given permissions are granted in any project.
+     *
+     * @return {Promise.<boolean>}
+     */
+  }, {
+    key: "bindVariable",
+    value: function bindVariable(object, propertyName, permissions, projectId) {
+      object[propertyName] = false;
+      return this.check(permissions, projectId).then(function (permitted) {
+        object[propertyName] = permitted;
+        return permitted;
+      });
     }
-    if (hasCacheControl('NO_STORE', options)) {
-      return this._loadPermissions().then(cachedPermissions => new PermissionCache(cachedPermissions, this.namesConverter));
+  }], [{
+    key: "getDefaultNamesConverter",
+    value:
+    /**
+     * Returns function, which cuts off prefix from server-side permission name
+     *
+     * @param {string} prefix
+     * @returns {Function}
+     */
+    function getDefaultNamesConverter(prefix) {
+      return function (storedName) {
+        if (storedName.indexOf(prefix) !== 0) {
+          return storedName;
+        } else {
+          return storedName.substr(prefix.length);
+        }
+      };
     }
-    const permissions = this._loadPermissions().then(cachedPermissions => this.set(cachedPermissions));
-    this._setCache(permissions);
-    return permissions;
-    function hasCacheControl(value, _options) {
-      if (_options && _options.cacheControl) {
-        return _options.cacheControl[value];
+  }, {
+    key: "getPermissionQuery",
+    value: function getPermissionQuery(services) {
+      if (!services || !services.length) {
+        return undefined;
       }
-      return false;
+      return services.map(function (service) {
+        return "service:{".concat(service, "}");
+      }).join(' or ');
     }
-  }
-  _loadPermissions() {
-    return this._datasource(this.query);
-  }
-  /**
-   * Reloads permission cache from server
-   * @returns {Promise.<Permissions>} promise that is resolved when the permissions are reloaded
-   */
-  reload() {
-    this._resetCache();
-    return this.load();
-  }
-  /**
-   * Waits till the permission cache is loaded then checks if the current user has the
-   * given permissions in the project with the given id.
-   *
-   * @param {string} permissions  space separated list of permissions
-   * @param {string=} projectId     optional projectId. If absent the method checks
-   *  if the given permission is granted in any project.
-   *
-   * @return {Promise.<boolean>}
-   */
-  check(permissions, projectId) {
-    return this.load().then(permissionCache => permissionCache.has(permissions, projectId));
-  }
-  /**
-   * Binds a property with the name <code>propertyName</code> of the <code>object</code>
-   * to a boolean value that is true if user has the permissions and false if she doesn't.
-   *
-   * @example
-   * <code>
-   *   userPermissions.bindVariable($scope, 'canReadRole', 'role-read')
-   * </code>
-   *
-   * @param {object} object       an object which property should be bound
-   * @param {string} propertyName a name of a property to bind
-   * @param {string} permissions  space separated list of permissions
-   * @param {string=} projectId     optional projectId. If absent the method checks
-   *  if the given permissions are granted in any project.
-   *
-   * @return {Promise.<boolean>}
-   */
-  bindVariable(object, propertyName, permissions, projectId) {
-    object[propertyName] = false;
-    return this.check(permissions, projectId).then(permitted => {
-      object[propertyName] = permitted;
-      return permitted;
-    });
-  }
-}
+  }]);
+}();
+/**
+ * @const {string}
+ */
+_defineProperty(Permissions, "API_PERMISSION_CACHE_PATH", 'permissions/cache');
 
 export { Permissions as default };