@voicenter-team/events-sdk 0.0.12 → 0.0.14

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

@@ -0,0 +1,272 @@
+import md5 from 'js-md5'
+
+import EventsSdkClass from '@/classes/events-sdk/events-sdk.class'
+import { EventsSdkOptions, ServerParameter } from '@/classes/events-sdk/events-sdk.types'
+import {
+    ExternalLoginNewStackResponseData,
+    ExternalLoginOldStackResponseData,
+    ExternalLoginResponse,
+    LoginSessionData,
+    LoginSessionPayload,
+    Settings
+} from '@/types/auth'
+import { LoginType } from '@/enum/auth.enum'
+import { getSettingsUrl } 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,
+            password: options.password
+        }
+
+        this.storageKey = md5(JSON.stringify(payload))
+
+        if (this.lastLoginTimestamp && this.lastLoginTimestamp + this.delay > new Date().getTime()) {
+            return
+        }
+
+        this.updateLastLoginTimestamp()
+
+        const isLoggedIn = await this.checkLoginStatus(this.storageKey)
+
+        if (!isLoggedIn) {
+            await this.userLoginFunction(payload, this.storageKey, options.loginType)
+        }
+    }
+
+    public updateLastLoginTimestamp () {
+        this.lastLoginTimestamp = new Date().getTime()
+    }
+
+    private async checkLoginStatus (key: string): Promise<boolean> {
+        const loginSessionData = await StorageClass.getSessionStorageDataByKey(key)
+
+        if (loginSessionData) {
+            this.onLoginResponse(loginSessionData)
+
+            return true
+        }
+
+        return false
+    }
+
+    private async userLoginFunction (
+        payload: LoginSessionPayload,
+        key: string,
+        loginType: LoginType,
+    ) {
+        let externalLoginResponse
+
+        let settings
+
+        let loginSessionData: Partial<LoginSessionData>
+
+        if (this.eventsSdkClass.options.isNewStack) {
+            externalLoginResponse = await this.externalLogin<ExternalLoginNewStackResponseData>(
+                this.eventsSdkClass.options.loginUrl,
+                payload,
+                loginType,
+            )
+
+            settings = await this.getSettings(externalLoginResponse.Data.AccessToken)
+
+            loginSessionData = {
+                ...externalLoginResponse.Data,
+                ...settings
+            }
+        } else {
+            externalLoginResponse = await this.externalLogin<ExternalLoginOldStackResponseData>(
+                this.eventsSdkClass.options.loginUrl,
+                payload,
+                loginType,
+            )
+
+            loginSessionData = {
+                ...externalLoginResponse.Data.Socket,
+            }
+        }
+
+        this.onLoginResponse(loginSessionData)
+
+        await StorageClass.updateSessionStorageKey(key, loginSessionData)
+    }
+
+    private onLoginResponse (loginSessionData: Partial<LoginSessionData>) {
+        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 (!this.eventsSdkClass.options.isNewStack && this.eventsSdkClass.options.servers) {
+            this.eventsSdkClass.servers = [ ...this.eventsSdkClass.options.servers ]
+            this.eventsSdkClass.server = this.eventsSdkClass.servers.reduce((prev, current) =>
+                (prev.Priority > current.Priority) ? prev : current
+            )
+        }
+        if (this.eventsSdkClass.server) {
+            this.eventsSdkClass.socketIoClass.getSocketIoFunction(`v=${this.eventsSdkClass.server.Version}`)
+        }
+        if (loginSessionData.IdentityCode) {
+            this.token = loginSessionData.IdentityCode
+            this.eventsSdkClass.connect(ServerParameter.DEFAULT, true)
+        }
+        if (loginSessionData.Token) {
+            this.token = loginSessionData.Token
+            this.eventsSdkClass.connect(ServerParameter.DEFAULT, true)
+        }
+        if (loginSessionData.RefreshToken && loginSessionData.IdentityCodeExpiry && this.eventsSdkClass.options.loginType === LoginType.USER) {
+            this.eventsSdkClass.options.refreshToken = loginSessionData.RefreshToken
+            this.eventsSdkClass.options.tokenExpiry = loginSessionData.IdentityCodeExpiry
+            this.handleTokenExpiry()
+        }
+        if (loginSessionData.RefreshToken && loginSessionData.TokenExpiry) {
+            this.eventsSdkClass.options.refreshToken = loginSessionData.RefreshToken
+            this.eventsSdkClass.options.tokenExpiry = loginSessionData.TokenExpiry
+            this.handleTokenExpiry()
+        }
+    }
+
+    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.refreshToken) {
+                    this.eventsSdkClass.socketIoClass.closeAllConnections()
+
+                    let settings
+
+                    let loginSessionData: Partial<LoginSessionData>
+
+                    if (this.eventsSdkClass.options.isNewStack) {
+                        const refreshTokenResponse = await this.refreshToken<ExternalLoginNewStackResponseData>(
+                            this.eventsSdkClass.options.refreshTokenUrl,
+                            this.eventsSdkClass.options.refreshToken
+                        )
+
+                        settings = await this.getSettings(refreshTokenResponse.Data.AccessToken)
+
+                        loginSessionData = {
+                            ...refreshTokenResponse.Data,
+                            ...settings
+                        }
+                    } else {
+                        const refreshTokenResponse = await this.refreshToken<ExternalLoginOldStackResponseData>(
+                            this.eventsSdkClass.options.refreshTokenUrl,
+                            this.eventsSdkClass.options.refreshToken
+                        )
+
+                        loginSessionData = {
+                            ...refreshTokenResponse.Data.Socket,
+                        }
+                    }
+
+                    this.onLoginResponse(loginSessionData)
+
+                    await StorageClass.updateSessionStorageKey(this.storageKey, loginSessionData)
+                }
+            },
+            maxAllowedTimeout)
+    }
+
+    private async externalLogin<T> (
+        url: string,
+        { password, token, email }: LoginSessionPayload,
+        loginType: LoginType,
+    ): Promise<ExternalLoginResponse<T>> {
+        let body: string
+
+        if (this.eventsSdkClass.options.isNewStack) {
+            if (loginType === LoginType.TOKEN) {
+                body = JSON.stringify({
+                    identityType: LoginType.TOKEN,
+                    token
+                })
+            } else {
+                body = JSON.stringify({
+                    identityType: LoginType.USER,
+                    username: email,
+                    password,
+                })
+            }
+        } else {
+            if (token) {
+                body = JSON.stringify({ token })
+
+                url = `${url}/Token`
+            } else {
+                body = JSON.stringify({
+                    email,
+                    pin: password
+                })
+
+                url = `${url}/User`
+            }
+        }
+
+        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
+    }
+
+    private async getSettings (token: string): Promise<Settings> {
+        const res = await fetch(getSettingsUrl, {
+            headers: {
+                Authorization: `Bearer ${token}`
+            }
+        })
+
+        return res.json()
+    }
+
+    private async refreshToken<T> (refreshTokenUrl: string, oldRefreshToken: string): Promise<ExternalLoginResponse<T>> {
+        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.urls.ts

@@ -0,0 +1,8 @@
+const getSettingsUrl = 'https://loginapidev.voicenter.co.il/Application/GetSettings'
+const refreshTokenUrl = 'https://loginapidev.voicenter.co.il/Auth/RefreshToken'
+
+
+export {
+    getSettingsUrl,
+    refreshTokenUrl
+}

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

@@ -0,0 +1,60 @@
+import { EventsSdkOptions } from '@/classes/events-sdk/events-sdk.types'
+import { LoginType } from '@/enum/auth.enum'
+
+export const eventsSdkDefaultOptions: EventsSdkOptions = {
+    isNewStack: false,
+    servers: [ {
+        URLID: 1,
+        Priority: 5,
+        Version: '1.3.7',
+        Domain: 'monitor1.comms24x7.com' 
+    },{
+        URLID: 2,
+        Priority: 4,
+        Version: '1.3.7',
+        Domain: 'monitor2.comms24x7.com' 
+    } ],
+    loginUrl: 'https://loginapi.comms24x7.com/monitorAPI/Login',
+    refreshTokenUrl: 'https://loginapi.comms24x7.com/monitorAPI/RefreshIdentityToken',
+    fallbackServer: {
+        Domain: 'monitor5.voicenter.co.il',
+        Priority: 0,
+        Version: '1.3.7',
+        URLID: 1
+    },
+    token: '',
+    loginType: LoginType.TOKEN,
+    forceNew: true,
+    reconnectionDelay: 10000,
+    reconnectionDelayMax: 10000,
+    maxReconnectAttempts: 5,
+    timeout: 10000,
+    keepAliveTimeout: 60000,
+    idleInterval: 60000 * 5,
+    protocol: 'https',
+    transports: [ 'websocket' ],
+    upgrade: false,
+    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: '92455783085',
+    email: 'sasha.za@starkey.co.il',
+}

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

@@ -0,0 +1,250 @@
+import AuthClass from '@/classes/auth/auth.class'
+import { debounce } from 'lodash'
+import { eventsSdkDefaultOptions } from '@/classes/events-sdk/events-sdk-default-options'
+import { SocketIoClass } from '@/classes/socket-io/socket-io.class'
+import { EventsSdkOptions, ReconnectOptions, Server, ServerParameter } from '@/classes/events-sdk/events-sdk.types'
+import { SocketTyped } from '@/types/socket'
+import {
+    GenericEventWrapper,
+    EventSpecificCallback,
+    EventCallbackListenersMap,
+    EventTypeData,
+    EventTypeNames,
+} from '@/types/events'
+import { EventsEnum } from '@/enum/events.enum'
+
+class EventsSdkClass{
+    constructor (options: EventsSdkOptions) {
+        this.options = {
+            ...eventsSdkDefaultOptions,
+            ...options
+        }
+
+        this.server = this.options.fallbackServer
+
+        this.argumentOptions = {
+            ...options
+        }
+    }
+
+    private argumentOptions: EventsSdkOptions
+    public readonly options: EventsSdkOptions = {
+        ...eventsSdkDefaultOptions
+    }
+    public servers: Server[] = []
+    public server: Server
+    public socket: SocketTyped | undefined
+
+    public authClass = new AuthClass(this)
+    public socketIoClass = new SocketIoClass(this)
+
+    public reconnectOptions: ReconnectOptions = {
+        retryCount: 1,
+        maxReconnectAttempts: this.options.maxReconnectAttempts,
+        reconnectionDelay: this.options.reconnectionDelay, // 10 seconds. After each re-connection attempt this number will increase (minReconnectionDelay * attempts) => 10, 20, 30, 40 seconds ... up to 5min
+        minReconnectionDelay: this.options.reconnectionDelay, // 10 seconds
+        maxReconnectionDelay: 60000 * 5 // 5 minutes
+    }
+
+    public retryConnection = debounce(this.connect.bind(this), this.reconnectOptions.reconnectionDelay, {
+        leading: true,
+        trailing: false
+    })
+
+    private listeners: EventCallbackListenersMap = {
+        [EventsEnum.ALL_EXTENSION_STATUS]: [],
+        [EventsEnum.ALL_DIALER_STATUS]: [],
+        [EventsEnum.ALL_USERS_STATUS]: [],
+        [EventsEnum.QUEUE_EVENT]: [],
+        [EventsEnum.EXTENSION_EVENT]: [],
+        [EventsEnum.DIALER_EVENT]: [],
+        [EventsEnum.LOGIN_SUCCESS]: [],
+        [EventsEnum.LOGIN_STATUS]: [],
+        [EventsEnum.KEEP_ALIVE_RESPONSE]: [],
+        [EventsEnum.ONLINE_STATUS_EVENT]: []
+    }
+    private allListeners: Array<(data: GenericEventWrapper) => void> = []
+
+    public on<T extends EventTypeNames> (event: T, callback: EventSpecificCallback<T>): void
+    public on (event: '*', callback: (data: GenericEventWrapper) => void): void
+    public on (event: unknown, callback: unknown) {
+        if (event === '*') {
+            this.allListeners.push(callback as (data: GenericEventWrapper) => void)
+        } else {
+            // Handle specific event type with strong typing
+            this.listeners[event as EventTypeNames].push(callback as EventSpecificCallback<EventTypeNames>)
+        }
+    }
+
+    public off<T extends EventTypeNames> (event: T, callback: EventSpecificCallback<T>): void
+    public off (event: '*', callback: (data: GenericEventWrapper) => void): void
+    public off (event: unknown, callback: unknown) {
+        if (event === '*') {
+            this.allListeners = this.allListeners.filter(item => item !== callback)
+        } else {
+            const data = this.listeners[event as EventTypeNames] as Array<EventSpecificCallback<EventTypeNames>>
+            const filtered = data.filter(item => item !== callback)
+
+            this.listeners = {
+                ...this.listeners,
+                [event as EventTypeNames]: filtered
+            }
+        }
+    }
+
+    public emit <T extends EventTypeNames> (event: T, data: EventTypeData<T>) {
+        this.socketIoClass.lastEventTimestamp = new Date().getTime()
+
+        this.listeners[event].forEach(callback => callback({
+            name: event,
+            data
+        }))
+
+        const allEventData: GenericEventWrapper = {
+            name: event,
+            data: data as any
+        }
+
+        this.allListeners.forEach((callback) => callback(allEventData))
+    }
+
+    public connect (server: ServerParameter = ServerParameter.DEFAULT, skipLogin = false) {
+        let serverToConnect: Server | undefined
+
+        if (server === ServerParameter.DEFAULT) {
+            serverToConnect = this.findCurrentServer()
+        }
+
+        if (server === ServerParameter.NEXT) {
+            serverToConnect = this.findNextAvailableServer()
+        }
+
+        if (server === ServerParameter.PREVIOUS) {
+            serverToConnect = this.findMaxPriorityServer()
+        }
+
+        if (!serverToConnect) {
+            this.server = this.findCurrentServer()
+        }
+
+        this.socketIoClass.doReconnect = true
+
+        this.socketIoClass.initSocketConnection()
+
+        this.socketIoClass.initSocketEvents()
+
+        this.socketIoClass.initKeepAlive()
+
+        // TODO: check if it is needed here
+        if (skipLogin) {
+            return
+        }
+    }
+
+    public disconnect () {
+        this.socketIoClass.doReconnect = false
+        this.socketIoClass.closeAllConnections()
+    }
+
+    public clearKeepAliveInterval () {
+        this.socketIoClass.clearKeepAliveInterval()
+    }
+
+    private findCurrentServer (): Server {
+        if (this.servers.length) {
+            this.server = this.servers[0]
+        }
+        if (!this.server) {
+            this.server = this.options.fallbackServer
+        }
+        return this.server
+    }
+
+    private findNextAvailableServer (): Server {
+        // this.log(INFO, 'Failover -> Trying to find another server');
+
+        const currentServerPriority = this.server.Priority
+
+        const nextServerPriority = currentServerPriority + 1
+
+        const nextServer = this.servers.find(server => server.Priority === nextServerPriority) || this.findMinPriorityServer()
+
+        this.server = { ...nextServer }
+
+        // this.log(INFO, 'Failover -> Found new server. Connecting to it...', this.server);
+
+        return this.server
+    }
+
+    private findMaxPriorityServer (): Server {
+        // this.log(INFO, 'Fallback -> Trying to find previous server');
+
+        const maxPriorityServer = this.getServerWithHighestPriority(this.servers)
+
+        if (!this.server) {
+            this.server = maxPriorityServer
+
+            return this.server
+        }
+
+        if (this.server && maxPriorityServer.Domain !== this.server.Domain) {
+            this.server = maxPriorityServer
+
+            // this.log(INFO, 'Fallback -> Trying to find previous server');
+
+            return this.server
+        }
+
+        return this.server
+    }
+
+    private findMinPriorityServer (): Server {
+        const minPriority = Math.min(...this.servers.map(server => server.Priority))
+
+        const server = this.servers.find(server => server.Priority === minPriority)
+
+        if (server) {
+            this.server = server
+
+            return this.server
+        }
+
+        return this.server
+    }
+
+    public getServerWithHighestPriority (servers: Server[]): Server {
+        let chosenServer: Server | undefined
+
+        let maxPriority = Number.MAX_SAFE_INTEGER
+
+        chosenServer = servers.find(server => {
+            if (server.Priority < maxPriority) {
+                maxPriority = server.Priority
+
+                chosenServer = server
+            }
+        })
+
+        return chosenServer ? chosenServer : this.server
+    }
+
+    public async init () {
+        if (this.socket) {
+            // this.emit(eventTypes.CLOSE);
+        }
+
+        await this.authClass.login(this.options)
+
+        this.getServers()
+
+        return true
+    }
+
+    private getServers () {
+        if (this.options.serverFetchStrategy === 'static' && this.argumentOptions.servers && Array.isArray(this.argumentOptions.servers) && this.argumentOptions.servers.length > 1) {
+            this.servers = this.argumentOptions.servers
+        }
+    }
+}
+
+export default EventsSdkClass

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

@@ -0,0 +1,9 @@
+import EventsSdkClass from '@/classes/events-sdk/events-sdk.class'
+import { eventsSdkDefaultOptions } from '@/classes/events-sdk/events-sdk-default-options'
+
+describe('EventsSdkClass', () => {
+    it('should be true', () => {
+        const eventsSdkClass = new EventsSdkClass(eventsSdkDefaultOptions)
+        expect(eventsSdkClass.init()).toBe(true)
+    })
+})

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

@@ -0,0 +1,71 @@
+import { LoginType } from '@/enum/auth.enum'
+
+export interface EventsSdkOptions {
+    isNewStack?: boolean,
+    servers: Server[],
+    loginUrl: string,
+    fallbackServer: Server,
+    refreshTokenUrl: string,
+    refreshToken?: string,
+    token: string,
+    tokenExpiry?: Date,
+    loginType: LoginType,
+    forceNew?: boolean,
+    reconnectionDelay: number,
+    reconnectionDelayMax?: number,
+    maxReconnectAttempts: number,
+    timeout?: number,
+    keepAliveTimeout: number,
+    idleInterval?: number,
+    protocol: string,
+    transports?: string[],
+    upgrade?: boolean,
+    serverFetchStrategy?: string,
+    serverType?: number,
+    useLogger?: boolean,
+    loggerSocketConnection?: string,
+    loggerServer?: string,
+    loggerConfig?: LoggerConfig,
+    loggerConnectOptions?: LoggerConnectOptions,
+    email: string,
+    password: string,
+    username: string,
+}
+
+export interface Server {
+    Priority: number,
+    Domain: string,
+    URLID: number,
+    Version: string,
+}
+
+export interface LoggerConfig {
+    logToConsole?: boolean,
+    overloadGlobalConsole?: boolean,
+    namespace?: string,
+    socketEmitInterval?: number
+}
+
+export interface LoggerConnectOptions {
+    reconnection?: boolean,
+    reconnectionDelay?: number,
+    reconnectionAttempts?: number,
+    perMessageDeflate?: boolean,
+    upgrade?: boolean,
+    transports?: string[],
+    debug?: boolean
+}
+
+export interface ReconnectOptions {
+    retryCount: number,
+    maxReconnectAttempts: number,
+    reconnectionDelay: number,
+    minReconnectionDelay: number,
+    maxReconnectionDelay: number
+}
+
+export enum ServerParameter {
+    DEFAULT = 'default',
+    NEXT = 'next',
+    PREVIOUS = 'previous'
+}