@voicenter-team/events-sdk 0.0.1

package/docs/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "voicneter-events-sdk",
+  "version": "0.0.1",
+  "description": "",
+  "main": "index.js",
+  "authors": {
+    "name": "",
+    "email": "bohdan.ko@voicenter.com"
+  },
+  "scripts": {
+    "dev": "vuepress dev src",
+    "build": "vuepress build src"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@vuepress/plugin-register-components": "^2.0.0-beta.62",
+    "typedoc": "^0.24.8",
+    "typedoc-plugin-markdown": "^3.15.3",
+    "vuepress": "^2.0.0-beta.62",
+    "vuepress-plugin-typedoc": "^0.12.1"
+  },
+  "dependencies": {
+    "dotenv": "^16.3.1"
+  }
+}

package/docs/src/.vuepress/client.js

@@ -0,0 +1,8 @@
+import { defineClientConfig } from '@vuepress/client'
+import './styles/index.scss'
+
+export default defineClientConfig({
+    enhance({ app, router, siteData }) {},
+    setup() {},
+    rootComponents: [],
+})

package/docs/src/.vuepress/components/Demo.vue

@@ -0,0 +1,181 @@
+<template>
+    <div>
+        <p v-if="loading">
+            Loading...
+        </p>
+
+        <template v-else>
+            <div>
+                <pre><code style="color: black">{{ JSON.stringify(events, null, 4) }}</code></pre>
+            </div>
+
+            <div>
+                <form @submit.prevent="login">
+                    <input type="text" v-model="token" placeholder="token"/>
+
+                    <button type="submit">Login</button>
+                </form>
+            </div>
+        </template>
+    </div>
+</template>
+
+<script lang="ts" setup>
+import {reactive, ref} from 'vue'
+import EventsSdkClass from '@/index'
+import {eventsSdkDefaultOptions} from '@/classes/events-sdk/events-sdk-default-options'
+import {EventsEnum} from '@/enum/events.enum'
+import {EventTypeData} from '@/types/events'
+
+/* Data */
+const token = ref('QMSVU9dwNYC9Le9VCBqx24AB9TYyWj9Xn5aCPV0GFHIWoShQqfPtnAPmnw24xpJIUSsDDtlac2OPpjx0t3MSkxH3AhiQGHCeGZ8e')
+const loading = ref(false)
+const loggedId = ref(false)
+const events = reactive<{ [K in EventsEnum]?: Array<EventTypeData<K>> }>({})
+
+/* Methods */
+async function login() {
+    if (!token.value) {
+        return alert('Token is required')
+    }
+
+    loading.value = true
+
+    const sdk = new EventsSdkClass({
+        ...eventsSdkDefaultOptions,
+        token: token.value,
+    })
+
+    await sdk.init()
+
+    sdk.on(
+        EventsEnum.ALL_DIALER_STATUS,
+        ({ data }) => {
+
+            if (!events[EventsEnum.ALL_DIALER_STATUS]) {
+                events[EventsEnum.ALL_DIALER_STATUS] = []
+            }
+
+            events[EventsEnum.ALL_DIALER_STATUS]?.push(data)
+        }
+    )
+
+    sdk.on(
+        EventsEnum.ALL_EXTENSION_STATUS,
+        ({ data }) => {
+
+            if (!events[EventsEnum.ALL_EXTENSION_STATUS]) {
+                events[EventsEnum.ALL_EXTENSION_STATUS] = []
+            }
+
+            events[EventsEnum.ALL_EXTENSION_STATUS]?.push(data)
+        }
+    )
+
+    sdk.on(
+        EventsEnum.ALL_USERS_STATUS,
+        ({ data }) => {
+
+            if (!events[EventsEnum.ALL_USERS_STATUS]) {
+                events[EventsEnum.ALL_USERS_STATUS] = []
+            }
+
+            events[EventsEnum.ALL_USERS_STATUS]?.push(data)
+        }
+    )
+
+    sdk.on(
+        EventsEnum.QUEUE_EVENT,
+        ({ data }) => {
+
+            if (!events[EventsEnum.QUEUE_EVENT]) {
+                events[EventsEnum.QUEUE_EVENT] = []
+            }
+
+            events[EventsEnum.QUEUE_EVENT]?.push(data)
+        }
+    )
+
+    sdk.on(
+        EventsEnum.EXTENSION_EVENT,
+        ({ data }) => {
+
+            if (!events[EventsEnum.EXTENSION_EVENT]) {
+                events[EventsEnum.EXTENSION_EVENT] = []
+            }
+
+            events[EventsEnum.EXTENSION_EVENT]?.push(data)
+        }
+    )
+
+    sdk.on(
+        EventsEnum.LOGIN_SUCCESS,
+        ({ data }) => {
+            if (!events[EventsEnum.LOGIN_SUCCESS]) {
+                events[EventsEnum.LOGIN_SUCCESS] = []
+            }
+
+            loggedId.value = true
+            loading.value = false
+
+            events[EventsEnum.LOGIN_SUCCESS]?.push(data)
+        }
+    )
+
+    sdk.on(
+        EventsEnum.LOGIN_STATUS,
+        ({ data }) => {
+            if (!events[EventsEnum.LOGIN_STATUS]) {
+                events[EventsEnum.LOGIN_STATUS] = []
+            }
+
+            events[EventsEnum.LOGIN_STATUS]?.push(data)
+        }
+    )
+
+    sdk.on(
+        '*',
+        (data) => {
+            switch (data.name) {
+                case EventsEnum.ALL_DIALER_STATUS:
+                    console.log(`FROM ALL ${EventsEnum.ALL_DIALER_STATUS}`, data)
+                    break
+                case EventsEnum.ALL_EXTENSION_STATUS:
+                    console.log(`FROM ALL ${EventsEnum.ALL_EXTENSION_STATUS}`, data)
+                    break
+                case EventsEnum.ALL_USERS_STATUS:
+                    console.log(`FROM ALL ${EventsEnum.ALL_USERS_STATUS}`, data)
+                    break
+                case EventsEnum.QUEUE_EVENT:
+                    console.log(`FROM ALL ${EventsEnum.QUEUE_EVENT}`, data)
+                    break
+                case EventsEnum.EXTENSION_EVENT:
+                    console.log(`FROM ALL ${EventsEnum.EXTENSION_EVENT}`, data)
+                    break
+                case EventsEnum.LOGIN_SUCCESS:
+                    console.log(`FROM ALL ${EventsEnum.LOGIN_SUCCESS}`, data)
+                    break
+                case EventsEnum.LOGIN_STATUS:
+                    console.log(`FROM ALL ${EventsEnum.LOGIN_STATUS}`, data)
+                    break
+                case EventsEnum.ONLINE_STATUS_EVENT:
+                    console.log(`FROM ALL ${EventsEnum.ONLINE_STATUS_EVENT}`, data)
+                    break
+                default:
+                    console.log('Unknown event', data)
+
+            }
+        }
+    )
+
+    setTimeout(
+        () => {
+            if (!loggedId.value) {
+                loading.value = false
+                alert('Login failed')
+            }
+        },
+        5000
+    )
+}
+</script>

package/docs/src/.vuepress/config.js

@@ -0,0 +1,60 @@
+import { defineUserConfig, defaultTheme } from 'vuepress'
+import { description } from '../../package'
+import { registerComponentsPlugin } from '@vuepress/plugin-register-components'
+import { getDirname, path } from '@vuepress/utils'
+import { typedocPlugin } from 'vuepress-plugin-typedoc/next';
+import * as dotenv from 'dotenv'
+dotenv.config()
+
+const __dirname = getDirname(import.meta.url)
+
+export default defineUserConfig({
+    description: description,
+
+    head: [
+        ['link', {rel: 'icon', href: '/favicon.ico'}],
+        ['meta', {name: 'theme-color', content: '#2675FF'}],
+        ['meta', {name: 'apple-mobile-web-app-capable', content: 'yes'}],
+        ['meta', {name: 'apple-mobile-web-app-status-bar-style', content: '#2675FF'}]
+    ],
+
+    theme: defaultTheme({
+        repo: '',
+        editLinks: false,
+        logo: '/images/logo.png',
+        docsDir: '',
+        editLinkText: '',
+        colorMode: 'light',
+        lastUpdated: false,
+        sidebar: [
+            {
+                text: 'General',
+                link: '/',
+                collapsible: false,
+                children: [
+                    'demo',
+                    {
+                        text: 'API',
+                        link: 'api',
+                        rel: 'api'
+                    }
+                ]
+            }
+        ]
+    }),
+
+    plugins: [
+        registerComponentsPlugin({
+            componentsDir: path.resolve(__dirname, './components')
+        }),
+        typedocPlugin({
+            entryPoints: ['../src/types/public-api.d.ts'],
+            tsconfig: '../tsconfig.json'
+        })
+    ],
+
+    alias: {
+        '@': path.resolve(__dirname, '../', '../', '../', 'src'),
+        'root': path.resolve(__dirname, '../', '../', '../'),
+    }
+})

package/docs/src/.vuepress/styles/index.styl

@@ -0,0 +1,8 @@
+/**
+ * Custom Styles here.
+ *
+ * ref：https://v1.vuepress.vuejs.org/config/#index-styl
+ */
+
+.home .hero img
+  max-width 450px!important

package/docs/src/.vuepress/styles/palette.styl

@@ -0,0 +1,10 @@
+/**
+ * Custom palette here.
+ *
+ * ref：https://v1.vuepress.vuejs.org/zh/config/#palette-styl
+ */
+
+$accentColor = #a5c544
+$textColor = #2c3e50
+$borderColor = #eaecef
+$codeBgColor = #282c34

package/docs/src/demo.md

@@ -0,0 +1,7 @@
+# Demo
+
+<ClientOnly>
+<div class="py-5">
+    <Demo />
+</div>
+</ClientOnly>

package/docs/src/index.md

@@ -0,0 +1,4 @@
+# Voicenter Events SDK
+
+- [Demo](demo.md)
+- [API](api/modules.md)

package/jest.config.js

@@ -0,0 +1,11 @@
+// jest.config.js
+module.exports = {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+    roots: [ '<rootDir>/src' ],
+    transform: {
+        '^.+\\.tsx?$': 'ts-jest',
+    },
+    testRegex: '(/__tests__/.*|(\\.|/)(test|spec))\\.tsx?$',
+    moduleFileExtensions: [ 'ts', 'tsx', 'js', 'jsx', 'json', 'node' ],
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@voicenter-team/events-sdk",
+  "version": "0.0.1",
+  "description": "",
+  "main": "dist/voicenter-events-sdk.cjs.js",
+  "jsdelivr": "dist/voicenter-events-sdk.umd.js",
+  "module": "dist/voicenter-events-sdk.es.js",
+  "unpkg": "dist/voicenter-events-sdk.umd.js",
+  "types": "dist/voicenter-events-sdk.d.ts",
+  "type": "module",
+  "scripts": {
+    "build": "vite build",
+    "dev": "cd docs && yarn && yarn run dev",
+    "build:documentation": "cd docs && npm install && npm run build",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "ts-check": "tsc --noEmit",
+    "lint": "eslint . --ext .js,.jsx,.cjs,.mjs,.ts --fix --ignore-path .gitignore"
+  },
+  "engines": {
+    "node": ">= 16",
+    "npm": ">= 9.6.7",
+    "yarn": ">= 1.22.4"
+  },
+  "precommit": "ts-check, lint",
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/chrome": "^0.0.253",
+    "@types/jest": "^29.5.10",
+    "@types/js-md5": "^0.7.2",
+    "@types/lodash": "^4.14.200",
+    "@types/node": "^18.14.2",
+    "@typescript-eslint/eslint-plugin": "^5.53.0",
+    "@typescript-eslint/parser": "^5.53.0",
+    "@voicenter-team/eslint-config-ts": "^1.0.22",
+    "dotenv": "^16.0.3",
+    "eslint": "^8.35.0",
+    "eslint-plugin-jest": "^27.6.0",
+    "jest": "^29.7.0",
+    "pre-commit": "^1.2.2",
+    "socket.io-client": "^4.7.2",
+    "swagger-axios-codegen": "^0.14.0",
+    "ts-jest": "^29.1.1",
+    "tsc-alias": "^1.8.6",
+    "typescript": "^4.9.5",
+    "vite": "4.3.9",
+    "vite-plugin-dts": "^3.6.0"
+  },
+  "dependencies": {
+    "js-md5": "^0.7.3",
+    "lodash": "^4.17.21"
+  }
+}

package/src/classes/auth/auth.class.ts

@@ -0,0 +1,196 @@
+import md5 from 'js-md5'
+
+import EventsSdkClass from '@/classes/events-sdk/events-sdk.class'
+import { Environment, EventsSdkOptions, ServerParameter } from '@/classes/events-sdk/events-sdk.types'
+import { LoginSessionData, LoginSessionPayload } from '@/types/auth'
+
+class AuthClass{
+    constructor (private readonly eventsSdkClass: EventsSdkClass) {
+        this.eventsSdkClass = eventsSdkClass
+    }
+    
+    private delay = 1000
+    public lastLoginTimestamp: number | undefined
+    public token: string | undefined
+
+    public async login (options: EventsSdkOptions) {
+        const payload: LoginSessionPayload = {
+            token: options.token,
+            email: options.email,
+            username: options.username,
+            password: options.password
+        }
+
+        const key = md5(JSON.stringify(payload))
+
+        if (this.lastLoginTimestamp && this.lastLoginTimestamp + this.delay > new Date().getTime()) {
+            return
+        }
+
+        this.updateLastLoginTimestamp()
+
+        const isLoggedIn = await this.checkLoginStatus(options, key)
+
+        if (!isLoggedIn) {
+            await this.userLoginFunction(payload, key)
+        }
+    }
+
+    public updateLastLoginTimestamp () {
+        this.lastLoginTimestamp = new Date().getTime()
+    }
+
+    private async checkLoginStatus (options: EventsSdkOptions, key: string): Promise<boolean> {
+        let loginSessionData: LoginSessionData
+        if (options.environment === Environment.BROWSER && window) {
+            const loginSessionKey = window.sessionStorage.getItem(key)
+
+            if (loginSessionKey) {
+                loginSessionData = JSON.parse(loginSessionKey)
+
+                this.onLoginResponse(loginSessionData)
+
+                return true
+            }
+        }
+        if (options.environment === Environment.CHROME_EXTENSION && chrome) {
+            const loginSessionKey = await chrome.storage.session.get(key)
+
+            if (loginSessionKey[key]) {
+                loginSessionData = JSON.parse(loginSessionKey[key])
+
+                this.onLoginResponse(loginSessionData)
+
+                return true
+            }
+        }
+        return false
+    }
+
+    private onLoginResponse (loginSessionData: LoginSessionData) {
+        if (loginSessionData.Client) {
+            this.eventsSdkClass.socketIoClass.getSocketIoFunction(loginSessionData.Client)
+        }
+        if (loginSessionData.Url) {
+            this.eventsSdkClass.server = {
+                Priority: 0,
+                Domain: loginSessionData.Url.replace('https://', '')
+            }
+        }
+        if (loginSessionData.URLList) {
+            this.eventsSdkClass.servers = loginSessionData.URLList.map((url, index) => {
+                return {
+                    Priority: index,
+                    Domain: url.replace('https://', '')
+                }
+            })
+        }
+        if (loginSessionData.Token) {
+            // this.options.token = loginSessionData.Token
+            this.token = loginSessionData.Token
+            this.eventsSdkClass.connect(ServerParameter.DEFAULT, true)
+        }
+        if (loginSessionData.RefreshToken && loginSessionData.TokenExpiry && this.eventsSdkClass.options.loginType === 'user') {
+            this.eventsSdkClass.options.refreshToken = loginSessionData.RefreshToken
+            this.eventsSdkClass.options.tokenExpiry = loginSessionData.TokenExpiry
+            this.handleTokenExpiry()
+        }
+    }
+
+    private async userLoginFunction (payload: LoginSessionPayload, key: string) {
+        const externalLoginUrl = this.getExternalLoginUrl(this.eventsSdkClass.options.loginUrl, this.eventsSdkClass.options.loginType)
+
+        const externalLoginResponse = await this.externalLogin(externalLoginUrl, payload, this.eventsSdkClass.options.loginType)
+
+        this.onLoginResponse(externalLoginResponse)
+
+        if (this.eventsSdkClass.options.environment === Environment.BROWSER) {
+            window.sessionStorage.setItem(key, JSON.stringify(externalLoginResponse))
+        }
+        if (this.eventsSdkClass.options.environment === Environment.CHROME_EXTENSION) {
+            await chrome.storage.session.set({ [key]: JSON.stringify(externalLoginResponse) })
+        }
+    }
+
+    public handleTokenExpiry () {
+        let date: Date
+
+        if (this.eventsSdkClass.options.tokenExpiry) {
+            date = new Date(this.eventsSdkClass.options.tokenExpiry)
+        } else {
+            return
+        }
+
+        const timeout = date.getTime() - new Date().getTime() - 5000 // 5 seconds before expire
+
+        const maxAllowedTimeout = Math.min(timeout, 0x7FFFFFFF)
+
+        setTimeout(
+            async () => {
+                if (this.eventsSdkClass.options.refreshTokenUrl && this.eventsSdkClass.options.refreshToken) {
+                    let Socket = null
+                    const res = await this.refreshToken(this.eventsSdkClass.options.refreshTokenUrl, this.eventsSdkClass.options.refreshToken)
+
+                    if (res.Data) {
+                        Socket = res.Data.Socket
+                        return this.onLoginResponse(Socket)
+                    }
+
+                    throw new Error('Error on refreshToken')
+                }
+            },
+            maxAllowedTimeout)
+    }
+
+    private getExternalLoginUrl (baseUrl: string, loginType: string) {
+        if (loginType === 'user') {
+            return `${baseUrl}/User`
+        }
+        if (loginType === 'token') {
+            return `${baseUrl}/Token`
+        }
+        return baseUrl
+    }
+
+    private async externalLogin (url: string, { password, token, email }: LoginSessionPayload, loginType: string) {
+        let body: string
+
+        if (loginType === 'token') {
+            body = JSON.stringify({ token })
+        } else {
+            body = JSON.stringify({
+                email,
+                pin: password
+            })
+        }
+
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body,
+        })
+
+        const data = await res.json()
+
+        if (data.error) {
+            throw new Error(data.error)
+        }
+        return data.Data.Socket
+    }
+
+    private async refreshToken (refreshTokenUrl: string, oldRefreshToken: string) {
+        const res = await fetch(refreshTokenUrl, {
+            method: 'GET',
+
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${oldRefreshToken}`
+            }
+        })
+        return res.json()
+    }
+}
+
+export default AuthClass

package/src/classes/auth/auth.test.ts

@@ -0,0 +1,14 @@
+import AuthClass from '@/classes/auth/auth.class'
+import { eventsSdkDefaultOptions } from '@/classes/events-sdk/events-sdk-default-options'
+import EventsSdkClass from '@/classes/events-sdk/events-sdk.class'
+
+describe('AuthClass', () => {
+    const sdk = new EventsSdkClass(eventsSdkDefaultOptions)
+
+    const authClass = new AuthClass(sdk)
+
+    it('should be cypher', () => {
+        const key = authClass.login(eventsSdkDefaultOptions)
+        expect(typeof key).toBe('string')
+    })
+})

package/src/classes/events-sdk/events-sdk-default-options.ts

@@ -0,0 +1,52 @@
+import { EventsSdkOptions, Environment } from '@/classes/events-sdk/events-sdk.types'
+
+export const eventsSdkDefaultOptions: EventsSdkOptions = {
+    url: 'https://monitorapi.voicenter.co.il/monitorAPI/getMonitorUrls',
+    environment: Environment.BROWSER,
+    fallbackServer: {
+        Domain: 'monitor5.voicenter.co.il',
+        Priority: 0,
+    },
+    loginUrl: 'https://loginapi.voicenter.co.il/monitorAPI/Login',
+    refreshTokenUrl: 'https://loginapi.voicenter.co.il/monitorAPI/RefreshIdentityToken',
+    // servers: defaultServers, // commented temporary
+    token: '',
+    loginType: 'token',
+    forceNew: true,
+    reconnectionDelay: 10000,
+    reconnectionDelayMax: 10000,
+    maxReconnectAttempts: 5,
+    timeout: 10000,
+    keepAliveTimeout: 60000,
+    idleInterval: 60000 * 5,
+    protocol: 'https',
+    transports: [ 'websocket' ],
+    upgrade: false,
+    store: '',
+    extensionsModuleName: 'sdkExtensions',
+    queuesModuleName: 'sdkQueues',
+    dialersModuleName: 'sdkDialers',
+    serverFetchStrategy: 'static',
+    serverType: 0,
+    useLogger: false,
+    loggerSocketConnection: '',
+    loggerServer: 'http://127.0.0.1:3000/',
+    loggerConfig: {
+        logToConsole: true,
+        overloadGlobalConsole: false,
+        namespace: 'events-sdk',
+        socketEmitInterval: 10000,
+    },
+    loggerConnectOptions: {
+        reconnection: true,
+        reconnectionDelay: 5000,
+        reconnectionAttempts: 10,
+        perMessageDeflate: false,
+        upgrade: false,
+        transports: [ 'websocket' ],
+        debug: false
+    },
+    username: 'username',
+    password: '53070875445',
+    email: 'FreshTest@Voicenter.com',
+}