@jibb-open/jssdk 3.5.5

package/src/types/proto.js

@@ -0,0 +1,7 @@
+const root = require("./jibb.pb.js");
+
+export const ipsa = root.lookup("jibb.ipsa.v1")
+export const types = root.lookup("types")
+export const cilix = root.lookup("cilix")
+export const meeting = root.lookup("meeting")
+

package/src/types/types.js

@@ -0,0 +1,64 @@
+import jwt_decode from "jwt-decode";
+
+export const MeetingTypes = {
+	DEFAULT: 0,
+	WHITEBOARD: 1,
+}
+
+export const AccessLevel = {
+	USER: "USER",
+	ADMIN: "ADMIN",
+	SUPERADMIN: "SUPERADMIN",
+};
+
+export const UserType = {
+	UNKNOWN: 0,
+	LIMITED: 1,
+	MEMBER: 2,
+	ADMIN: 3,
+	OWNER: 4,
+};
+
+export class MeetingClaims {
+	constructor(token) {
+		this.claims = jwt_decode(token)
+		this.expiryTime = new Date(this.claims.exp * 1000)
+		this.owner = this.claims.data.owner
+		this.meetindId = this.claims.data.meeting_id
+		this.title = this.claims.data.title
+		this.capacity = this.claims.data.capacity
+		this.permission = this.claims.data.permission
+		this.meetingType = this.claims.data.meeting_type
+		this.isTemporary = this.claims.data.is_temporary
+	}
+
+	getSecondsUntilExpiry() {
+		return this.expiryTime - Date.now() - 60
+	}
+
+	isExpired() {
+		return this.getSecondsUntilExpiry() <= 0
+	}
+}
+
+export class UserClaims {
+	constructor(token) {
+		this.token = token
+		this.claims = jwt_decode(token)
+		this.expiryTime = new Date(this.claims.exp * 1000)
+		this.email = this.claims.data?.email
+		this.userId = this.claims.sub
+	}
+
+	getSecondsUntilExpiry() {
+		return this.expiryTime - Date.now() - 60
+	}
+
+	isExpired() {
+		return this.getSecondsUntilExpiry() <= 0
+	}
+
+	getUserId() {
+		return this.userId
+	}
+}

package/src/utils/cached_variable.js

@@ -0,0 +1,23 @@
+export class CachedVariable {
+	constructor(expirySeconds = 60) {
+		this.value = null
+		this.expirySeconds = expirySeconds
+		this.expiryTime = Date.now()
+	}
+
+	isExpired() {
+		return (this.value == null) || (Date.now() > this.expiryTime)
+	}
+
+	get() {
+		if (this.isExpired())
+			return undefined
+		else
+			return this.value
+	}
+
+	set(value) {
+		this.value = value
+		this.expiryTime = Date.now() + (this.expirySeconds * 1000)
+	}
+}

package/src/utils/future.js

@@ -0,0 +1,24 @@
+export class Future {
+	constructor() {
+		let self = this
+		this.resolve = undefined
+		this.reject = undefined
+		this.promise = new Promise((resolve, reject) => {
+			self.resolve = resolve
+			self.reject = reject
+		})
+		this.promise.catch(() => {return undefined})
+	}
+
+	get() {
+		return this.promise
+	}
+
+	reject(val) {
+		this.reject(val)
+	}
+
+	set(val) {
+		this.resolve(val)
+	}
+}

package/src/utils/http/http.axios.js

@@ -0,0 +1,34 @@
+import axios from "axios"
+
+class HttpClient {
+	async get(url, headers, options = {}) {
+		options.headers = headers
+		return axios.get(url, options)
+	}
+
+	async post(url, body = {}, headers = {}) {
+		return axios.post(url, body, {
+			headers: headers,
+		})
+	}
+
+	async patch(url, body = {}, headers = {}) {
+		return axios.patch(url, body, {
+			headers: headers,
+		})
+	}
+
+	async put(url, body = {}, headers = {}) {
+		return axios.put(url, body, {
+			headers: headers,
+		})
+	}
+
+	async delete(url, headers = {}) {
+		return axios.delete(url, {
+			headers: headers,
+		})
+	}
+}
+
+globalThis.http = new HttpClient()

package/src/utils/http/http.xapi.js

@@ -0,0 +1,87 @@
+import xapi from "xapi";
+
+class HttpClient {
+	async get(url, headers) {
+		let response = await xapi.Command.HttpClient.Get({
+			AllowInsecureHTTPS: "True",
+			Header: this.#makeStringHeader(headers),
+			Url: url,
+			ResultBody: "PlainText",
+		})
+
+		return this.#parseAndChangeResponseKeyName(response)
+	}
+
+	async post(url, body = {}, headers = {}) {
+		let response = await xapi.Command.HttpClient.Post(
+			{
+				AllowInsecureHTTPS: "True",
+				Header: this.#makeStringHeader(headers),
+				Url: url,
+				ResultBody: "PlainText",
+			},
+			JSON.stringify(body)
+		)
+		return this.#parseAndChangeResponseKeyName(response)
+	}
+
+	async patch(url, body = {}, headers = {}) {
+		let response = await xapi.Command.HttpClient.Patch(
+			{
+				AllowInsecureHTTPS: "True",
+				Header: this.#makeStringHeader(headers),
+				Url: url,
+				ResultBody: "PlainText",
+			},
+			JSON.stringify(body)
+		)
+
+		return this.#parseAndChangeResponseKeyName(response)
+	}
+
+	async put(url, body = {}, headers = {}) {
+		let response = await xapi.Command.HttpClient.Put(
+			{
+				AllowInsecureHTTPS: "True",
+				Header: this.#makeStringHeader(headers),
+				Url: url,
+				ResultBody: "PlainText",
+			},
+			JSON.stringify(body)
+		)
+
+		return this.#parseAndChangeResponseKeyName(response)
+	}
+
+	async delete(url, headers = {}) {
+		let response = await xapi.Command.HttpClient.Delete({
+			AllowInsecureHTTPS: "True",
+			Header: this.#makeStringHeader(headers),
+			Url: url,
+			ResultBody: "PlainText",
+		})
+
+		return this.#parseAndChangeResponseKeyName(response)
+	}
+
+	#makeStringHeader(header) {
+		let result = []
+		for (const [k, v] of Object.entries(header)) {
+			result.push(`${k}: ${v}`)
+		}
+		return result
+	}
+
+	#parseAndChangeResponseKeyName(obj) {
+		let result = obj
+		result["data"] = JSON.parse(result.Body)
+		delete result["Body"]
+		return result
+	}
+}
+
+// webex devices running enviroment dose not have globalThis object, creating global.globalThis.http in this file enable the value assingment index.js line 4
+
+global.globalThis = {}
+global.globalThis.http = new HttpClient()
+

package/src/utils/http/index.js

@@ -0,0 +1,8 @@
+import './http.axios.js'
+import "./http.xapi.js"
+
+let http = globalThis.http
+
+export {
+	http
+}

package/src/utils/index.js

@@ -0,0 +1,5 @@
+import {logger} from './logger.js'
+
+export default {
+    logger,
+}

package/src/utils/logger/index.js

@@ -0,0 +1,11 @@
+import {logger as emptyLogger} from "./logger.empty.js"
+
+let logger = emptyLogger;
+
+const initPinoLogger = () => {
+	import("./logger.pino.js").then((exports) => {
+		logger = exports.logger
+	})
+}
+
+export {logger, initPinoLogger}

package/src/utils/logger/logger.empty.js

@@ -0,0 +1,25 @@
+class EmptyLoggerr {
+	error() {
+		// This is intentional
+	}
+
+	debug() {
+		// This is intentional
+	}
+
+	warn() {
+		// This is intentional
+	}
+
+	info() {
+		// This is intentional
+	}
+
+	setLevel() {
+		// This is intentional
+	}
+}
+
+let logger = new EmptyLoggerr()
+
+export {logger}

package/src/utils/logger/logger.pino.js

@@ -0,0 +1,15 @@
+import Pino from "pino"
+
+let logger = new Pino({
+	browser: {
+		asObject: false,
+	},
+	timestamp: false,
+	level: "warn",
+})
+
+logger.setLevel = (level) => {
+	logger.level = level
+}
+
+export { logger }

package/src/ws/connection_base.js

@@ -0,0 +1,81 @@
+import { logger } from "../utils/logger/index.js"
+import { Future } from "../utils/future.js"
+
+export const ConnectionStatus = {
+	CONNECTED: "CONNECTED",
+	DISCONNECTED: "DISCONNECTED",
+	CONNECTING: "CONNECTING",
+}
+
+export class ConnectionBase {
+	#name
+	#connectionStatus
+	#connectionFuture
+
+	constructor(name) {
+		this.#name = name
+		this.#connectionStatus = ConnectionStatus.DISCONNECTED
+		this.#connectionFuture = new Future()
+		this.#connectionFuture.reject("disconnected")
+	}
+
+	getName() {
+		return this.#name
+	}
+
+	connect() {
+		switch (this.#connectionStatus) {
+			case ConnectionStatus.CONNECTED:
+				logger.error(`${this.getName()}: already connected`)
+				break
+			case ConnectionStatus.CONNECTING:
+				logger.error(`${this.getName()}: connection already in progress`)
+				break
+			case ConnectionStatus.DISCONNECTED:
+				logger.info(`${this.getName()}: connecting ...`)
+				this.#connectionStatus = ConnectionStatus.CONNECTING
+				this.#connectionFuture = new Future()
+				break
+		}
+	}
+
+	disconnect() {
+		this.onDisconnected()
+	}
+
+	onConnected() {
+		logger.info(`${this.getName()}: connected`)
+		this.#connectionStatus = ConnectionStatus.CONNECTED
+		this.#connectionFuture.set("connected")
+	}
+
+	onDisconnected() {
+		logger.warn(`${this.getName()}: disconnected`)
+		this.#connectionStatus = ConnectionStatus.DISCONNECTED
+		this.#connectionFuture.reject("disconnected")
+	}
+
+	isConnected() {
+		return this.#connectionStatus == ConnectionStatus.CONNECTED
+	}
+
+	waitForConnection() {
+		return this.#connectionFuture.get()
+	}
+
+	getConnectionStatus() {
+		return this.#connectionStatus
+	}
+
+	onErrorMessage(code, reason) {
+		logger.warn(`${this.getName()}: onErrorMessage, code: ${code}, reason: ${reason}`)
+	}
+
+	onWarningMessage(code, reason) {
+		logger.warn(`${this.getName()}: onWarningMessage, code: ${code}, reason: ${reason}`)
+	}
+
+	onInfoMessage(code, reason) {
+		logger.info(`${this.getName()}: onInfoMessage, code: ${code}, reason: ${reason}`)
+	}
+}