@jibb-open/jssdk 3.5.8 → 3.5.9

package/dist/api/admin.js

@@ -0,0 +1,418 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SendUserActivationEmail = SendUserActivationEmail;
+exports.createDomain = createDomain;
+exports.createOrganizationUser = createOrganizationUser;
+exports.createUsers = createUsers;
+exports.deleteDomain = deleteDomain;
+exports.deleteOrganizationUser = deleteOrganizationUser;
+exports.deleteSAML = deleteSAML;
+exports.getDomainList = getDomainList;
+exports.getOrganizationDetails = getOrganizationDetails;
+exports.getOrganizationList = getOrganizationList;
+exports.getOrganizationUserDetails = getOrganizationUserDetails;
+exports.getSAML = getSAML;
+exports.getUserList = getUserList;
+exports.setSAML = setSAML;
+exports.updateUserType = updateUserType;
+exports.verifyDomain = verifyDomain;
+require("core-js/modules/es.promise.js");
+require("core-js/modules/es.json.stringify.js");
+var _config = require("../config.js");
+var _index = require("../utils/http/index.js");
+var _auth = require("./auth.js");
+var _types = require("../types/types.js");
+/**
+ * 
+ * @module admin
+ * This is an experimental API.
+ */
+
+const accessLevel = _types.AccessLevel.ADMIN;
+
+/**
+ *
+ * 
+ * @async
+ * @returns {array} - list of Organization
+ */
+async function getOrganizationList() {
+  let headers = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-jibb-user-jwt": await _auth.Auth.getUserToken({
+      accessLevel: accessLevel
+    })
+  };
+  let response = await _index.http.get("".concat(_config.Config.apiBaseURL, "/v1/admin/organizations"), headers);
+  return response.data.organizations;
+}
+
+/**
+ * 
+ * @async
+ * @param {number} orgId 
+ * @returns {object}
+ */
+async function getOrganizationDetails(orgId) {
+  if (orgId === "") {
+    throw new Error("organization ID can not be empty");
+  }
+  let headers = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-jibb-user-jwt": await _auth.Auth.getUserToken({
+      accessLevel: accessLevel
+    })
+  };
+  let response = await _index.http.get("".concat(_config.Config.apiBaseURL, "/v1/admin/organizations/").concat(orgId), headers);
+  return response.data;
+}
+
+/**
+ * 
+ * @async
+ * @param {number} orgId 
+ * @param {*} pagination 
+ * @returns {list}
+ */
+async function getUserList(orgId, pagination) {
+  let headers = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-jibb-user-jwt": await _auth.Auth.getUserToken({
+      accessLevel: accessLevel
+    })
+  };
+  if (pagination !== undefined) headers["x-jibb-pagination"] = JSON.stringify(pagination);
+  let response = await _index.http.get("".concat(_config.Config.apiBaseURL, "/v1/admin/organizations/").concat(orgId, "/users"), headers);
+  pagination = response.headers["x-jibb-pagination"];
+  pagination = pagination && JSON.parse(pagination);
+  return {
+    users: response.data.users,
+    pagination: pagination
+  };
+}
+
+/**
+ * 
+ * @async
+ * @param {object} param0  
+ * @param {Number} param0.orgId
+ * @param {list} param0.users - list of user object that contain email, first_name, last_name, user_type. user_type is a number from 0-4 
+ * @returns - http result
+ */
+async function createUsers(_ref) {
+  let {
+    orgId,
+    users
+  } = _ref;
+  let headers = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-jibb-user-jwt": await _auth.Auth.getUserToken({
+      accessLevel: accessLevel
+    })
+  };
+  let body = {
+    users
+  };
+  return _index.http.post("".concat(_config.Config.apiBaseURL, "/v1/admin/organizations/").concat(orgId, "/users"), body, headers);
+}
+
+/**
+ * 
+ * @async
+ * @param {object} param0 
+ * @param {string} param0.orgId 
+ * @param {string} param0.email 
+ * @param {number} param0.userType - UNKNOWN = 0; LIMITED = 1; MEMBER = 2; ADMIN = 3; OWNER = 4;
+ * @returns  - http result
+ */
+async function createOrganizationUser(_ref2) {
+  let {
+    orgId,
+    email,
+    userType
+  } = _ref2;
+  let headers = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-jibb-user-jwt": await _auth.Auth.getUserToken({
+      accessLevel: accessLevel
+    })
+  };
+  let body = {
+    users: [{
+      email: email,
+      user_type: userType
+    }]
+  };
+  return _index.http.post("".concat(_config.Config.apiBaseURL, "/v1/admin/organizations/").concat(orgId, "/users"), body, headers);
+}
+
+/**
+ * 
+ * @async
+ * @param {object} param0 
+ * @param {number} param0.orgId 
+ * @param {number} param0.userId 
+ * @returns - http result
+ */
+async function SendUserActivationEmail(_ref3) {
+  let {
+    orgId,
+    userIds
+  } = _ref3;
+  let headers = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-jibb-user-jwt": await _auth.Auth.getUserToken({
+      accessLevel: accessLevel
+    })
+  };
+  let body = {
+    user_ids: userIds
+  };
+  return _index.http.post("".concat(_config.Config.apiBaseURL, "/v1/admin/organizations/").concat(orgId, "/activation/email"), body, headers);
+}
+/**
+ * 
+ * @async
+ * @param {object} param0 
+ * @param {number} param0.orgId 
+ * @param {number} param0.userId 
+ * @returns - http result
+ */
+async function deleteOrganizationUser(_ref4) {
+  let {
+    orgId,
+    userId
+  } = _ref4;
+  let headers = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-jibb-user-jwt": await _auth.Auth.getUserToken({
+      accessLevel: accessLevel
+    })
+  };
+  return _index.http.delete("".concat(_config.Config.apiBaseURL, "/v1/admin/organizations/").concat(orgId, "/users/").concat(userId), headers);
+}
+/**
+ * 
+ * @async
+ * @param {object} param0 
+ * @param {number} param0.orgId 
+ * @param {number} param0.userId 
+ * @param {number} param0.userType - UNKNOWN = 0; LIMITED = 1; MEMBER = 2; ADMIN = 3; OWNER = 4;
+ * @returns - http result
+ */
+async function updateUserType(_ref5) {
+  let {
+    orgId,
+    userId,
+    userType
+  } = _ref5;
+  let headers = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-jibb-user-jwt": await _auth.Auth.getUserToken({
+      accessLevel: accessLevel
+    })
+  };
+  let body = {
+    user_type: userType
+  };
+  return _index.http.patch("".concat(_config.Config.apiBaseURL, "/v1/admin/organizations/").concat(orgId, "/users/").concat(userId), body, headers);
+}
+/**
+ * 
+ * @async
+ * @param {object} param0 
+ * @param {number} param0.orgId 
+ * @param {number} param0.userId 
+ * @returns {object}
+ */
+async function getOrganizationUserDetails(_ref6) {
+  let {
+    orgId,
+    userId
+  } = _ref6;
+  let headers = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-jibb-user-jwt": await _auth.Auth.getUserToken({
+      accessLevel: accessLevel
+    })
+  };
+  let response = await _index.http.get("".concat(_config.Config.apiBaseURL, "/v1/admin/organizations/").concat(orgId, "/users/").concat(userId), headers);
+  return response.data;
+}
+
+//  error code:401 status:Unauthorized   should we / what token to use ?  , orgId? not sure of the body
+/**
+ * 
+ * @async
+ * @param {object} param0 
+ * @param {number} param0.orgId 
+ * @param {string} [param0.metadata=] 
+ * @param {boolean} [param0.autoAddUsers=false] 
+ * @param {UserType} [param0.defaultUserType=0]  - UNKNOWN = 0; LIMITED = 1; MEMBER = 2; ADMIN = 3; OWNER = 4;
+ * @param {boolean} [param0.enabled=fales] 
+ * @returns - http result
+ */
+async function setSAML(_ref7) {
+  let {
+    orgId,
+    metadata,
+    autoAddUsers,
+    defaultUserType,
+    enabled
+  } = _ref7;
+  if (orgId === "" || orgId === undefined) {
+    throw new Error("organization ID can not be empty");
+  }
+  let headers = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-jibb-user-jwt": await _auth.Auth.getUserToken({
+      accessLevel: accessLevel
+    })
+  };
+  let body = {
+    organization_id: orgId,
+    metadata: metadata || "",
+    auto_add_users: autoAddUsers !== undefined ? autoAddUsers : false,
+    default_user_type: defaultUserType !== undefined ? defaultUserType : _types.UserType.UNKNOWN,
+    enabled: enabled || false
+  };
+  return _index.http.put("".concat(_config.Config.apiBaseURL, "/v1/admin/organizations/").concat(orgId, "/saml"), body, headers);
+}
+
+//  error code:401 status:Unauthorized   should we / what token to use ?  , orgId? not sure of the body
+/**
+ * @async
+ * @param {number} orgId 
+ * @returns - http result
+ */
+async function deleteSAML(orgId) {
+  let headers = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-jibb-user-jwt": await _auth.Auth.getUserToken({
+      accessLevel: accessLevel
+    })
+  };
+  return _index.http.delete("".concat(_config.Config.apiBaseURL, "/v1/admin/organizations/").concat(orgId, "/saml"), headers);
+}
+/**
+ * 
+ * @async
+ * @param {number} orgId 
+ * @returns {object}
+ */
+async function getSAML(orgId) {
+  if (orgId === "") {
+    throw new Error("organization ID can not be empty");
+  }
+  let headers = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-jibb-user-jwt": await _auth.Auth.getUserToken({
+      accessLevel: accessLevel
+    })
+  };
+  let response = await _index.http.get("".concat(_config.Config.apiBaseURL, "/v1/admin/organizations/").concat(orgId, "/saml"), headers);
+  return response.data;
+}
+/**
+ * 
+ * @async
+ * @param {number} orgId 
+ * @returns {object}
+ */
+async function getDomainList(orgId) {
+  let headers = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-jibb-user-jwt": await _auth.Auth.getUserToken({
+      accessLevel: accessLevel
+    })
+  };
+  let response = await _index.http.get("".concat(_config.Config.apiBaseURL, "/v1/admin/organizations/").concat(orgId, "/domains"), headers);
+  return response.data;
+}
+/**
+ * 
+ * @async
+ * @param {object} param0 
+ * @param {object} param0.orgId 
+ * @param {string} param0.domain 
+ * @returns {object}
+ */
+async function createDomain(_ref8) {
+  let {
+    orgId,
+    domain
+  } = _ref8;
+  let headers = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-jibb-user-jwt": await _auth.Auth.getUserToken({
+      accessLevel: accessLevel
+    })
+  };
+  let body = {
+    domain_name: domain
+  };
+  let response = await _index.http.post("".concat(_config.Config.apiBaseURL, "/v1/admin/organizations/").concat(orgId, "/domains"), body, headers);
+  return response.data;
+}
+/**
+ * 
+ * @async
+ * @param {object} param0 
+ * @param {object} param0.orgId 
+ * @param {string} param0.domain 
+ * @returns - http result
+ */
+async function deleteDomain(_ref9) {
+  let {
+    orgId,
+    domainId
+  } = _ref9;
+  let headers = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-jibb-user-jwt": await _auth.Auth.getUserToken({
+      accessLevel: accessLevel
+    })
+  };
+  return _index.http.delete("".concat(_config.Config.apiBaseURL, "/v1/admin/organizations/").concat(orgId, "/domains/").concat(domainId), headers);
+}
+/**
+ * 
+ * @async
+ * @param {object} param0 
+ * @param {object} param0.orgId 
+ * @param {string} param0.domain 
+ * @returns {object}
+ */
+async function verifyDomain(_ref10) {
+  let {
+    orgId,
+    domainId
+  } = _ref10;
+  let headers = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-jibb-user-jwt": await _auth.Auth.getUserToken({
+      accessLevel: accessLevel
+    })
+  };
+  let response = await _index.http.get("".concat(_config.Config.apiBaseURL, "/v1/admin/organizations/").concat(orgId, "/domains/").concat(domainId, "/verify"), headers);
+  return response.data;
+}

package/dist/api/auth.js

@@ -0,0 +1,246 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Auth = void 0;
+require("core-js/modules/web.dom-collections.iterator.js");
+require("core-js/modules/es.promise.js");
+var _config = require("../config.js");
+var _index = require("../utils/logger/index.js");
+var _types = require("../types/types.js");
+var _index2 = require("../utils/http/index.js");
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
+function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
+function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
+function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
+function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
+var _userClaims = /*#__PURE__*/new WeakMap();
+var _getUserTokenFromApiKey = /*#__PURE__*/new WeakSet();
+var _getUserTokenFromIDToken = /*#__PURE__*/new WeakSet();
+var _refreshUserToken = /*#__PURE__*/new WeakSet();
+/**
+ * @module auth
+ */
+
+/**
+ * AuthClass.
+ * @class AuthClass
+ *
+ */
+
+class AuthClass {
+  constructor() {
+    _classPrivateMethodInitSpec(this, _refreshUserToken);
+    _classPrivateMethodInitSpec(this, _getUserTokenFromIDToken);
+    _classPrivateMethodInitSpec(this, _getUserTokenFromApiKey);
+    _classPrivateFieldInitSpec(this, _userClaims, {
+      writable: true,
+      value: void 0
+    });
+    _index.logger.debug("Creating new Auth instance");
+    this.apiKey = undefined;
+    _classPrivateFieldSet(this, _userClaims, new Map());
+    this.getIdToken = undefined;
+  }
+
+  /**
+   * Manually setting userToken
+   * @param {string} token
+   * @param {AccessLevel} accessLevel
+   */
+  setUserToken(token) {
+    let accessLevel = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _types.AccessLevel.USER;
+    let claims = new _types.UserClaims(token);
+    _classPrivateFieldGet(this, _userClaims).set(accessLevel, claims);
+  }
+
+  /**
+   * setting Api key
+   * @param {string} apiKey
+   */
+  setApiKey(apiKey) {
+    this.apiKey = apiKey;
+    _classPrivateFieldGet(this, _userClaims).clear();
+  }
+  /**
+   *
+   * @returns {UserClaims}
+   */
+  async getUserClaims() {
+    await this.getUserToken();
+    return _classPrivateFieldGet(this, _userClaims).get(_types.AccessLevel.USER);
+  }
+
+  /**
+   *
+   * @async
+   * @param {object} [param0={}]
+   * @param {Number} [param0.expiry=3600] - meeting ID.
+   * @param {boolean} [param0.refresh=fales] - 1 Read or 2 Write.
+   * @param {AccessLevel} [param0.accessLevel=AccessLevel.USER]
+   * @returns {string} - user Token.
+   */
+
+  async getUserToken() {
+    let {
+      expiry,
+      refresh,
+      accessLevel
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    let claim = undefined;
+    refresh = refresh || false;
+    accessLevel = accessLevel || _types.AccessLevel.USER;
+    expiry = expiry || 3600;
+    if (refresh === true) {
+      await _classPrivateMethodGet(this, _refreshUserToken, _refreshUserToken2).call(this, {
+        expiry,
+        accessLevel
+      });
+    }
+    claim = _classPrivateFieldGet(this, _userClaims).get(accessLevel);
+    if (claim !== undefined && !claim.isExpired()) return claim.token;
+    await _classPrivateMethodGet(this, _refreshUserToken, _refreshUserToken2).call(this, {
+      expiry,
+      accessLevel
+    });
+    claim = _classPrivateFieldGet(this, _userClaims).get(accessLevel);
+    if (claim !== undefined && !claim.isExpired()) return claim.token;
+    throw new Error("could not create user token");
+  }
+  /**
+   * clear user.
+   */
+
+  logout() {
+    _classPrivateFieldGet(this, _userClaims).clear();
+  }
+
+  /**
+   *
+   * Generate a new API Key, old API KEY will be discareded
+   * It require a userToken to be set.
+   * @returns {string} api key
+   */
+  async generateAPIKey() {
+    let headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "x-jibb-user-jwt": await this.getUserToken()
+    };
+    let response = await _index2.http.get("".concat(_config.Config.apiBaseURL, "/v1/auth/apikey"), headers);
+    return response.data.apiKey;
+  }
+
+  /**
+   *
+   * Generating a one time password.
+   * It require a IdToken to be set.
+   * @async
+   * @returns  {string} - Custom Password.
+   */
+  async generateCustomAuthPassword() {
+    let headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "x-jibb-id-jwt": await this.getIdToken()
+    };
+    let response = await _index2.http.get("".concat(_config.Config.apiBaseURL, "/v1/auth/custom"), headers);
+    return response.data.password;
+  }
+}
+
+/**
+ *   Expotred instance of AuthClass.
+ * @type {AuthClass}
+ */
+async function _getUserTokenFromApiKey2(_ref) {
+  let {
+    expiry,
+    accessLevel
+  } = _ref;
+  let headers = {
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  };
+  let body = {
+    api_key: this.apiKey,
+    expiry: {
+      seconds: expiry
+    }
+  };
+  let url;
+  switch (accessLevel) {
+    case _types.AccessLevel.ADMIN:
+      url = "".concat(_config.Config.apiBaseURL, "/v1/admin/auth/token");
+      break;
+    case _types.AccessLevel.SUPERADMIN:
+      url = "".concat(_config.Config.apiBaseURL, "/v1/superadmin/auth/token");
+      break;
+    default:
+      url = "".concat(_config.Config.apiBaseURL, "/v1/auth/token");
+      break;
+  }
+  let response = await _index2.http.post(url, body, headers);
+  return response.data.token;
+}
+async function _getUserTokenFromIDToken2(_ref2) {
+  let {
+    expiry,
+    accessLevel
+  } = _ref2;
+  let headers = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+    "x-jibb-id-jwt": await this.getIdToken()
+  };
+  let body = {
+    expiry: {
+      seconds: expiry
+    }
+  };
+  let url;
+  switch (accessLevel) {
+    case _types.AccessLevel.ADMIN:
+      url = "".concat(_config.Config.apiBaseURL, "/v1/admin/auth/token");
+      break;
+    case _types.AccessLevel.SUPERADMIN:
+      url = "".concat(_config.Config.apiBaseURL, "/v1/superadmin/auth/token");
+      break;
+    default:
+      url = "".concat(_config.Config.apiBaseURL, "/v1/auth/token");
+      break;
+  }
+  let response = await _index2.http.post(url, body, headers);
+  return response.data.token;
+}
+async function _refreshUserToken2(_ref3) {
+  let {
+    expiry,
+    accessLevel
+  } = _ref3;
+  if (this.apiKey) {
+    let token = await _classPrivateMethodGet(this, _getUserTokenFromApiKey, _getUserTokenFromApiKey2).call(this, {
+      expiry,
+      accessLevel
+    });
+    this.setUserToken(token, accessLevel);
+    return token;
+  }
+  try {
+    let token = await _classPrivateMethodGet(this, _getUserTokenFromIDToken, _getUserTokenFromIDToken2).call(this, {
+      expiry,
+      accessLevel
+    });
+    this.setUserToken(token, accessLevel);
+    return token;
+  } catch (error) {
+    _index.logger.error(error);
+  }
+}
+let Auth = new AuthClass();
+exports.Auth = Auth;