@voicenter-team/events-sdk 0.0.5 → 0.0.7

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

@@ -26,6 +26,7 @@ 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'
+import {LoginType} from "@/enum/auth.enum";
 
 /* Data */
 const token = ref('QMSVU9dwNYC9Le9VCBqx24AB9TYyWj9Xn5aCPV0GFHIWoShQqfPtnAPmnw24xpJIUSsDDtlac2OPpjx0t3MSkxH3AhiQGHCeGZ8e')
@@ -44,6 +45,7 @@ async function login() {
     const sdk = new EventsSdkClass({
         ...eventsSdkDefaultOptions,
         token: token.value,
+        loginType: LoginType.USER,
     })
 
     await sdk.init()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voicenter-team/events-sdk",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "",
   "main": "dist/voicenter-events-sdk.cjs.js",
   "jsdelivr": "dist/voicenter-events-sdk.umd.js",
@@ -26,29 +26,29 @@
   "author": "",
   "license": "ISC",
   "devDependencies": {
-    "@types/chrome": "^0.0.253",
-    "@types/jest": "^29.5.10",
+    "@types/chrome": "0.0.259",
+    "@types/jest": "29.5.11",
     "@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",
+    "@types/node": "20.11.13",
+    "@typescript-eslint/eslint-plugin": "6.20.0",
+    "@typescript-eslint/parser": "6.20.0",
     "@voicenter-team/eslint-config-ts": "^1.0.22",
-    "dotenv": "^16.0.3",
-    "eslint": "^8.35.0",
-    "eslint-plugin-jest": "^27.6.0",
+    "dotenv": "16.4.1",
+    "eslint": "8.56.0",
+    "eslint-plugin-jest": "27.6.3",
     "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",
+    "socket.io-client": "4.7.4",
+    "swagger-axios-codegen": "0.16.8",
+    "ts-jest": "29.1.2",
     "tsc-alias": "^1.8.6",
-    "typescript": "^4.9.5",
-    "vite": "4.3.9",
-    "vite-plugin-dts": "^3.6.0"
+    "typescript": "5.3.3",
+    "vite": "5.0.12",
+    "vite-plugin-dts": "3.7.2"
   },
   "dependencies": {
-    "js-md5": "^0.7.3",
+    "js-md5": "0.8.3",
     "lodash": "^4.17.21"
   }
 }

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

@@ -1,27 +1,39 @@
 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'
+import { EventsSdkOptions, ServerParameter } from '@/classes/events-sdk/events-sdk.types'
+import {
+    ExternalLoginRequestBody,
+    ExternalLoginResponse,
+    LoginSessionData,
+    LoginSessionPayload,
+    Settings
+} from '@/types/auth'
+import { LoginType } from '@/enum/auth.enum'
+import { getSettingsUrl, newLoginUrl, refreshTokenUrl } from '@/classes/auth/auth.urls'
+import { StorageClass } from '@/classes/storage/storage.class'
 
 class AuthClass{
     constructor (private readonly eventsSdkClass: EventsSdkClass) {
         this.eventsSdkClass = eventsSdkClass
+
+        this.storageKey = ''
     }
-    
+
     private delay = 1000
     public lastLoginTimestamp: number | undefined
     public token: string | undefined
 
+    private storageKey: string
+
     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))
+        this.storageKey = md5(JSON.stringify(payload))
 
         if (this.lastLoginTimestamp && this.lastLoginTimestamp + this.delay > new Date().getTime()) {
             return
@@ -29,10 +41,10 @@ class AuthClass{
 
         this.updateLastLoginTimestamp()
 
-        const isLoggedIn = await this.checkLoginStatus(options, key)
+        const isLoggedIn = await this.checkLoginStatus(this.storageKey)
 
         if (!isLoggedIn) {
-            await this.userLoginFunction(payload, key)
+            await this.userLoginFunction(payload, this.storageKey, options.loginType)
         }
     }
 
@@ -40,78 +52,62 @@ class AuthClass{
         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)
+    private async checkLoginStatus (key: string): Promise<boolean> {
+        const loginSessionData = await StorageClass.getSessionStorageDataByKey(key)
 
-            if (loginSessionKey) {
-                loginSessionData = JSON.parse(loginSessionKey)
+        if (loginSessionData) {
+            this.onLoginResponse(loginSessionData)
 
-                this.onLoginResponse(loginSessionData)
-
-                return true
-            }
+            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])
+        return false
+    }
 
-                this.onLoginResponse(loginSessionData)
+    private async userLoginFunction (
+        payload: LoginSessionPayload,
+        key: string,
+        loginType: LoginType,
+    ) {
+        const externalLoginResponse = await this.externalLogin(
+            newLoginUrl,
+            payload,
+            loginType,
+        )
 
-                return true
-            }
+        const settings = await this.getSettings(externalLoginResponse.Data.AccessToken)
+
+        const loginSessionData: LoginSessionData = {
+            ...externalLoginResponse.Data,
+            ...settings
         }
-        return false
+
+        this.onLoginResponse(loginSessionData)
+
+        await StorageClass.updateSessionStorageKey(key, loginSessionData)
     }
 
     private onLoginResponse (loginSessionData: LoginSessionData) {
-        if (loginSessionData.Client) {
-            this.eventsSdkClass.socketIoClass.getSocketIoFunction(loginSessionData.Client)
+        if (loginSessionData.MonitorList && loginSessionData.MonitorList.length) {
+            this.eventsSdkClass.servers = [ ...loginSessionData.MonitorList ]
+            this.eventsSdkClass.server = this.eventsSdkClass.servers.reduce((prev, current) =>
+                (prev.Priority > current.Priority) ? prev : current
+            )
         }
-        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 (this.eventsSdkClass.server) {
+            this.eventsSdkClass.socketIoClass.getSocketIoFunction(`v=${this.eventsSdkClass.server.Version}`)
         }
-        if (loginSessionData.Token) {
-            // this.options.token = loginSessionData.Token
-            this.token = loginSessionData.Token
+        if (loginSessionData.IdentityCode) {
+            this.token = loginSessionData.IdentityCode
             this.eventsSdkClass.connect(ServerParameter.DEFAULT, true)
         }
-        if (loginSessionData.RefreshToken && loginSessionData.TokenExpiry && this.eventsSdkClass.options.loginType === 'user') {
+        if (loginSessionData.RefreshToken && loginSessionData.IdentityCodeExpiry && this.eventsSdkClass.options.loginType === LoginType.USER) {
             this.eventsSdkClass.options.refreshToken = loginSessionData.RefreshToken
-            this.eventsSdkClass.options.tokenExpiry = loginSessionData.TokenExpiry
+            this.eventsSdkClass.options.tokenExpiry = loginSessionData.IdentityCodeExpiry
             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
 
@@ -127,41 +123,44 @@ class AuthClass{
 
         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 (refreshTokenUrl && this.eventsSdkClass.options.refreshToken) {
+                    this.eventsSdkClass.socketIoClass.closeAllConnections()
+
+                    const refreshTokenResponse = await this.refreshToken(refreshTokenUrl, this.eventsSdkClass.options.refreshToken)
 
-                    if (res.Data) {
-                        Socket = res.Data.Socket
-                        return this.onLoginResponse(Socket)
+                    const settings = await this.getSettings(refreshTokenResponse.Data.AccessToken)
+
+                    const loginSessionData: LoginSessionData = {
+                        ...refreshTokenResponse.Data,
+                        ...settings
                     }
 
-                    throw new Error('Error on refreshToken')
+                    this.onLoginResponse(loginSessionData)
+
+                    await StorageClass.updateSessionStorageKey(this.storageKey, loginSessionData)
                 }
             },
             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 })
+    private async externalLogin (
+        url: string,
+        { password, token, email }: LoginSessionPayload,
+        loginType: LoginType,
+    ): Promise<ExternalLoginResponse> {
+        let body: ExternalLoginRequestBody
+
+        if (loginType === LoginType.TOKEN) {
+            body = {
+                identityType: LoginType.TOKEN,
+                token
+            }
         } else {
-            body = JSON.stringify({
-                email,
-                pin: password
-            })
+            body = {
+                identityType: LoginType.USER,
+                username: email,
+                password,
+            }
         }
 
         const res = await fetch(url, {
@@ -169,7 +168,7 @@ class AuthClass{
             headers: {
                 'Content-Type': 'application/json'
             },
-            body,
+            body: JSON.stringify(body),
         })
 
         const data = await res.json()
@@ -177,10 +176,20 @@ class AuthClass{
         if (data.error) {
             throw new Error(data.error)
         }
-        return data.Data.Socket
+        return data
+    }
+
+    private async getSettings (token: string): Promise<Settings> {
+        const res = await fetch(getSettingsUrl, {
+            headers: {
+                Authorization: `Bearer ${token}`
+            }
+        })
+
+        return res.json()
     }
 
-    private async refreshToken (refreshTokenUrl: string, oldRefreshToken: string) {
+    private async refreshToken (refreshTokenUrl: string, oldRefreshToken: string): Promise<ExternalLoginResponse> {
         const res = await fetch(refreshTokenUrl, {
             method: 'GET',
 

package/src/classes/auth/auth.urls.ts

@@ -0,0 +1,10 @@
+const newLoginUrl = 'http://loginapidev.voicenter.co.il/Auth/Login/Voicenter/Monitor'
+const getSettingsUrl = 'http://loginapidev.voicenter.co.il/Application/GetSettings'
+const refreshTokenUrl = 'http://loginapidev.voicenter.co.il/Auth/RefreshToken'
+
+
+export {
+    newLoginUrl,
+    getSettingsUrl,
+    refreshTokenUrl
+}

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

@@ -1,17 +1,15 @@
-import { EventsSdkOptions, Environment } from '@/classes/events-sdk/events-sdk.types'
+import { EventsSdkOptions } from '@/classes/events-sdk/events-sdk.types'
+import { LoginType } from '@/enum/auth.enum'
 
 export const eventsSdkDefaultOptions: EventsSdkOptions = {
-    url: 'https://monitorapi.voicenter.co.il/monitorAPI/getMonitorUrls',
-    environment: Environment.BROWSER,
     fallbackServer: {
         Domain: 'monitor5.voicenter.co.il',
         Priority: 0,
+        Version: '1.3.7',
+        URLID: 1
     },
-    loginUrl: 'https://loginapi.voicenter.co.il/monitorAPI/Login',
-    refreshTokenUrl: 'https://loginapi.voicenter.co.il/monitorAPI/RefreshIdentityToken',
-    // servers: defaultServers, // commented temporary
     token: '',
-    loginType: 'token',
+    loginType: LoginType.TOKEN,
     forceNew: true,
     reconnectionDelay: 10000,
     reconnectionDelayMax: 10000,
@@ -22,10 +20,6 @@ export const eventsSdkDefaultOptions: EventsSdkOptions = {
     protocol: 'https',
     transports: [ 'websocket' ],
     upgrade: false,
-    store: '',
-    extensionsModuleName: 'sdkExtensions',
-    queuesModuleName: 'sdkQueues',
-    dialersModuleName: 'sdkDialers',
     serverFetchStrategy: 'static',
     serverType: 0,
     useLogger: false,
@@ -47,6 +41,6 @@ export const eventsSdkDefaultOptions: EventsSdkOptions = {
         debug: false
     },
     username: 'username',
-    password: '53070875445',
-    email: 'FreshTest@Voicenter.com',
+    password: '78253050510',
+    email: 'test2@status.com',
 }

package/src/classes/events-sdk/events-sdk.types.ts

@@ -1,14 +1,13 @@
+import { LoginType } from 'enum/auth.enum'
+
 export interface EventsSdkOptions {
-    url?: string,
-    environment?: string,
     fallbackServer: Server,
-    loginUrl: string,
     refreshTokenUrl?: string,
     refreshToken?: string,
     servers?: string,
     token: string,
     tokenExpiry?: Date,
-    loginType: string,
+    loginType: LoginType,
     forceNew?: boolean,
     reconnectionDelay: number,
     reconnectionDelayMax?: number,
@@ -19,10 +18,6 @@ export interface EventsSdkOptions {
     protocol: string,
     transports?: string[],
     upgrade?: boolean,
-    store?: string,
-    extensionsModuleName?: string,
-    queuesModuleName?: string,
-    dialersModuleName?: string,
     serverFetchStrategy?: string,
     serverType?: number,
     useLogger?: boolean,
@@ -32,17 +27,14 @@ export interface EventsSdkOptions {
     loggerConnectOptions?: LoggerConnectOptions,
     email: string,
     password: string,
-    username: string
-}
-
-export enum Environment {
-    BROWSER = 'browser',
-    CHROME_EXTENSION = 'chrome-extension'
+    username: string,
 }
 
 export interface Server {
     Priority: number,
-    Domain: string
+    Domain: string,
+    URLID: number,
+    Version: string,
 }
 
 export interface LoggerConfig {
@@ -74,4 +66,4 @@ export enum ServerParameter {
     DEFAULT = 'default',
     NEXT = 'next',
     PREVIOUS = 'previous'
-}
+}

package/src/classes/socket-io/socket-io.class.ts

@@ -2,9 +2,10 @@ import { ManagerOptions, SocketOptions } from 'socket.io-client'
 import EventsSdkClass from '@/classes/events-sdk/events-sdk.class'
 import sockets, { TypedSocketIo } from '@/classes/socket-io/versions'
 import { SocketTyped } from '@/types/socket'
-import { Environment, ServerParameter } from '@/classes/events-sdk/events-sdk.types'
+import { ServerParameter } from '@/classes/events-sdk/events-sdk.types'
 import { EventsEnum } from '@/enum/events.enum'
 import { KeepAliveResponseEvent } from '@/types/events'
+import { StorageClass } from '@/classes/storage/storage.class'
 
 export class SocketIoClass{
     constructor (private readonly eventsSdkClass: EventsSdkClass) {
@@ -125,12 +126,7 @@ export class SocketIoClass{
             this.io = undefined
         }
 
-        if (this.eventsSdkClass.options.environment === Environment.BROWSER && window) {
-            window.sessionStorage.clear()
-        }
-        if (this.eventsSdkClass.options.environment === Environment.CHROME_EXTENSION && chrome) {
-            chrome.storage.session.clear()
-        }
+        StorageClass.clearSessionStorage()
     }
 
     private onKeepAliveResponse (data: KeepAliveResponseEvent) {

package/src/classes/storage/storage.class.ts

@@ -0,0 +1,43 @@
+import { LoginSessionData } from '@/types/auth'
+
+export class StorageClass{
+    public static async getSessionStorageDataByKey (key: string): Promise<LoginSessionData | undefined> {
+        if (typeof chrome !== 'undefined' && typeof chrome.storage !== 'undefined') {
+            const loginSessionKey = await chrome.storage.session.get(key)
+
+            if (loginSessionKey[key]) {
+                return JSON.parse(loginSessionKey[key])
+            }
+        }
+
+        if (typeof window !== 'undefined') {
+            const loginSessionKey = window.sessionStorage.getItem(key)
+
+            if (loginSessionKey) {
+                return JSON.parse(loginSessionKey)
+            }
+        }
+    }
+
+    public static async updateSessionStorageKey (key: string, storageData: LoginSessionData) {
+        if (typeof chrome !== 'undefined' && typeof chrome.storage !== 'undefined') {
+            await chrome.storage.session.set({
+                [key]: JSON.stringify(storageData)
+            })
+        }
+
+        if (typeof window !== 'undefined') {
+            window.sessionStorage.setItem(key, JSON.stringify(storageData))
+        }
+    }
+
+    public static clearSessionStorage () {
+        if (typeof chrome !== 'undefined' && typeof chrome.storage !== 'undefined') {
+            chrome.storage.session.clear()
+        }
+
+        if (typeof window !== 'undefined') {
+            window.sessionStorage.clear()
+        }
+    }
+}

package/src/enum/auth.enum.ts

@@ -0,0 +1,4 @@
+export enum LoginType {
+    USER = 'User',
+    TOKEN = 'Token'
+}

package/src/index.ts

@@ -1,9 +1,6 @@
 import EventsSdkClass from '@/classes/events-sdk/events-sdk.class'
-import { Environment } from '@/classes/events-sdk/events-sdk.types'
 import { EventsEnum } from '@/enum/events.enum'
 
-export {
-    Environment,
-    EventsEnum
-}
+export { EventsEnum }
+
 export default EventsSdkClass

package/src/types/auth.d.ts

@@ -1,11 +1,31 @@
+import { Server } from '@/classes/events-sdk/events-sdk.types'
+import { LoginType } from '@/enum/auth.enum'
+
 export interface LoginSessionPayload {
     token: string,
     email: string,
-    username: string,
     password: string
 }
 
-export interface LoginSessionData {
+export interface ExternalLoginRequestBody {
+    identityType: LoginType,
+    username?: string,
+    password?: string,
+    token?: string
+}
+
+interface ExternalLoginResponseData {
+    AccessToken: string,
+    RefreshToken: string
+}
+
+export interface ExternalLoginResponse {
+    StatusCode: number,
+    Status: string,
+    Data: ExternalLoginResponseData
+}
+
+export interface Socket {
     Client: string,
     PersonId: number,
     RefreshToken: string,
@@ -15,4 +35,15 @@ export interface LoginSessionData {
     URLList: string[],
     Url: string,
     Version: string
-}
+}
+
+export interface Settings {
+    IdentityCode: string,
+    IdentityCodeExpiry: Date,
+    PersonID: number,
+    PersonType: number,
+    ExtensionMonitorID: number,
+    MonitorList: Server[]
+}
+
+export interface LoginSessionData extends Settings, ExternalLoginResponseData {}

package/src/types/events.common.d.ts

@@ -47,7 +47,7 @@ export interface Queue {
     AnsweredAgent?: string,
 }
 
-interface ExtensionCall {
+export interface ExtensionCall {
     callStarted: number,
     calldurationinterval: number,
     callAnswered: number,

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

@@ -1,14 +0,0 @@
-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')
-    })
-})