@voicenter-team/events-sdk 0.0.13 → 0.0.14

package/TODELETE_TEMP/temphelper.cjs

@@ -0,0 +1,101 @@
+const { ExtensionEvent, loginStatus, AllExtensionsStatus, QueueEvent } = require('./events.json')
+
+function get (obj, path) {
+    const pathArray = path.split('.')
+    let result = obj
+
+    for (const key of pathArray) {
+        if (result === undefined || result === null) {
+            return undefined
+        }
+
+        result = result[key]
+    }
+
+    return result
+}
+function getUniquePropertyValues (array, propertyPath) {
+    return array.reduce(
+        (acc, item) => {
+            const value = get(item, propertyPath)
+
+            if (value && !acc.includes(value)) {
+                acc.push(value)
+            }
+
+            return acc
+        },
+        []
+    )
+}
+
+function allPresent (array, propertyPath) {
+    return array.every(item => {
+        const value = get(item, propertyPath)
+
+        return value !== undefined && value !== null
+    })
+}
+
+function getObjectWithMostProperties (array) {
+    return array.reduce((curr, prev) => {
+        return Object.keys(curr).length > Object.keys(prev).length ? curr : prev
+    })
+}
+
+function getPropertiesWhichExistInAllObjects (array) {
+    if (array.length === 0) {
+        return []
+    }
+
+    const firstObjectKeys = Object.keys(array[0])
+
+    return array.reduce((commonKeys, currentObject) => {
+        const currentObjectKeys = Object.keys(currentObject)
+
+        return commonKeys.filter(key => currentObjectKeys.includes(key))
+    }, firstObjectKeys)
+}
+
+// console.log(getUniquePropertyValues(ExtensionEvent, 'reason'))
+
+// console.log(allPresent(ExtensionEvent, 'dialStatus'))
+
+const extensionCalls = [
+    ...(ExtensionEvent.map(event => event.data.calls).flat() || []),
+    ...(ExtensionEvent.filter(event => event.data.currentCall).map(event => event.data.currentCall) || [])
+]
+
+
+const extensionEventExpectedCallsParameters = Object
+    .keys(
+        getObjectWithMostProperties(extensionCalls)
+    )
+    .filter(
+        key => [ 'c2cdirection', 'callerID', 'Ivruniqueid', 'campaignID' ].includes(key)
+    )
+
+const extensionEventDataExpectedCParameters = Object
+    .keys(
+        getObjectWithMostProperties(ExtensionEvent.map(event => event.data))
+    )
+    .filter(
+        key => [ 'c2cdirection', 'callerID', 'Ivruniqueid', 'campaignID' ].includes(key)
+    )
+
+const extensionEventExpectedCParameters = Object
+    .keys(
+        getObjectWithMostProperties(ExtensionEvent)
+    )
+    .filter(
+        key => [ 'c2cdirection', 'callerID', 'Ivruniqueid', 'campaignID' ].includes(key)
+    )
+
+const extensionDirectionValues = getUniquePropertyValues(extensionCalls, 'direction').filter(value => [ 'Spy', 'Click2call' ].includes(value))
+
+console.log('Extension callstatus values (expect to get "Spying")', getUniquePropertyValues(extensionCalls, 'callstatus'))
+console.log('Extension cause values (expect to get "Answered elsewhere")', getUniquePropertyValues(ExtensionEvent, 'cause'))
+console.log('Extension event calls expected parameters (expect to get c2cdirection, callerID, Ivruniqueid or campaignID)', extensionEventExpectedCallsParameters)
+console.log('Extension event data expected parameters (expect to get c2cdirection, callerID, Ivruniqueid or campaignID)', extensionEventDataExpectedCParameters)
+console.log('Extension event expected parameters (expect to get c2cdirection, callerID, Ivruniqueid or campaignID)', extensionEventExpectedCParameters)
+console.log('Extension direction values (expect to get "Spy" and "Click2call")', extensionDirectionValues)

package/dist/{voicenter-events-sdk.d.ts → index.d.ts}

@@ -1,11 +1,16 @@
 import { DebouncedFuncLeading } from 'lodash';
+import { EventsEnum as EventsEnum_3 } from 'enum/events.enum';
 import { io } from 'socket.io-client';
-import { Socket } from 'socket.io-client';
+import { Socket as Socket_2 } from 'socket.io-client';
+
+export declare type ActiveRoomListener = (event: number | undefined) => void
+
+export declare type addRoomListener = (value: string) => void
 
 /**
  * Data structure for all dialers status event.
  */
-declare interface AllDialersStatusEvent extends CommonEventProperties {
+export declare interface AllDialersStatusEvent extends CommonEventProperties {
     // Array of Dialer objects
     dialers: Dialer[]
 }
@@ -13,7 +18,7 @@ declare interface AllDialersStatusEvent extends CommonEventProperties {
 /**
  * Data structure for all extension status event.
  */
-declare interface AllExtensionStatusEvent extends CommonEventProperties {
+export declare interface AllExtensionStatusEvent extends CommonEventProperties {
     // Array of Extension objects
     extensions: Extension[]
 }
@@ -21,7 +26,7 @@ declare interface AllExtensionStatusEvent extends CommonEventProperties {
 /**
  * Data structure for all users status event.
  */
-declare interface AllUsersStatusEvent extends CommonEventProperties {
+export declare interface AllUsersStatusEvent extends CommonEventProperties {
     // Array of User objects
     users: User[]
 }
@@ -44,6 +49,8 @@ declare class AuthClass {
     private refreshToken;
 }
 
+export declare type CallAddingProgressListener = (callId: string | undefined) => void
+
 declare enum CallStatusEnum {
     RINGING = "Ringing",
     TALKING = "Talking",
@@ -56,10 +63,24 @@ declare enum CallTypeEnum {
     OUTGOING = "Outgoing"
 }
 
+export declare type changeActiveCallsListener = (event: { [key: string]: string }) => void
+
+export declare type changeActiveInputMediaDeviceListener = (event: string) => void
+
+export declare type changeActiveOutputMediaDeviceListener = (event: string) => void
+
+export declare type changeCallStatusListener = (event: { [key: string]: number }) => void
+
+export declare type changeIsDNDListener = (value: boolean) => void
+
+export declare type changeIsMutedListener = (value: boolean) => void
+
+export declare type changeMuteWhenJoinListener = (value: boolean) => void
+
 /**
  * Base structure for all event types, containing common properties.
  */
-declare interface CommonEventProperties {
+export declare interface CommonEventProperties {
     // Error code, 0 indicates no error
     errorCode?: number
     // Description of the error, "Ok" indicates successful connection
@@ -70,7 +91,7 @@ declare interface CommonEventProperties {
     serverTimeOffset: number
 }
 
-declare interface CustomData {
+export declare interface CustomData {
     DoNotCallMeStatus?: string,
     DoNotCallMeStatusCode?: DoNotCallMeStatusCodeEnum,
     DoNotCallMeTokenName?: string,
@@ -78,7 +99,7 @@ declare interface CustomData {
     IsDoNotCallMe?: string
 }
 
-declare interface Dialer {
+export declare interface Dialer {
     campaignID: number,
     name: string,
     typeID: number,
@@ -91,7 +112,7 @@ declare interface Dialer {
 /**
  * Data structure for dialer event.
  */
-declare interface DialerEvent extends CommonEventProperties {
+export declare interface DialerEvent extends CommonEventProperties {
     data: Dialer
     eventName: EventNameEnum.DIALER
     //reason: ExtensionEventReasonEnum // TODO: do research for dialer 'reason' prop
@@ -119,19 +140,27 @@ declare enum DoNotCallMeStatusCodeEnum {
     RESPONSE_FROM_API_INVALID = "RESPONSE_FROM_API_INVALID"
 }
 
+/**
+ * This type defines a map where each key is an event name, and the value is an array of callback functions associated with that event.
+ * This structure is used to manage event listeners for different events
+ */
+export declare type EventCallbackListenersMap = {
+    [K in EventTypeNames]: Array<EventSpecificCallback<K>>
+}
+
 /**
  * Defines a registry of callback functions for each event type.
  * Each key is an event type name, and the value is a function that takes the specific event data type as an argument.
  * This registry is used to manage and invoke event-specific callbacks.
  */
-declare type EventCallbackRegistry = {
+export declare type EventCallbackRegistry = {
     [K in EventTypeNames]: (data: EventDataMap[K]) => void
 }
 
 /**
  * Mapping of event names to their respective data structures.
  */
-declare interface EventDataMap {
+export declare interface EventDataMap {
     [EventsEnum_2.ALL_EXTENSION_STATUS]: AllExtensionStatusEvent
     [EventsEnum_2.ALL_DIALER_STATUS]: AllDialersStatusEvent
     [EventsEnum_2.ALL_USERS_STATUS]: AllUsersStatusEvent
@@ -201,7 +230,7 @@ declare enum EventsEnum_2 {
  * This is a generic type for callback functions used in event handling.
  * It takes a generic event name and defines a callback function that receives wrapped socket event data for that specific event.
  */
-declare type EventSpecificCallback<T extends EventTypeNames> = (data: WrappedSocketEvent<T>) => void
+export declare type EventSpecificCallback<T extends EventTypeNames> = (data: WrappedSocketEvent<T>) => void
 
 declare class EventsSdkClass {
     constructor(options: EventsSdkOptions);
@@ -234,12 +263,12 @@ declare class EventsSdkClass {
 }
 export default EventsSdkClass;
 
-declare interface EventsSdkOptions {
+export declare interface EventsSdkOptions {
     isNewStack?: boolean;
     servers: Server[];
     loginUrl: string;
     fallbackServer: Server;
-    refreshTokenUrl?: string;
+    refreshTokenUrl: string;
     refreshToken?: string;
     token: string;
     tokenExpiry?: Date;
@@ -266,23 +295,58 @@ declare interface EventsSdkOptions {
     username: string;
 }
 
-declare type EventTypeData<T extends EventsEnum_2> = EventDataMap[T]
+export declare type EventTypeData<T extends EventsEnum_2> = EventDataMap[T]
 
 /**
  * Represents the set of all possible event type names as keys from the EventDataMap.
  * This type is used to define event listeners and handlers.
  */
-declare type EventTypeNames = keyof EventDataMap
+export declare type EventTypeNames = keyof EventDataMap
+
+/**
+ * Represents Event Types in Enum
+ */
+export declare enum EventTypesEnum {
+    ALL_DIALERS_STATUS = 'AllDialersStatus',
+    ALL_EXTENSION_STATUS = 'AllExtensionsStatus',
+    CLOSE = 'closeme',
+    CONNECT = 'connect',
+    CONNECT_ERROR = 'connect_error',
+    CONNECT_TIMEOUT = 'connect_timeout',
+    DISCONNECT = 'disconnect',
+    DIALER_EVENT = 'DialerEvent',
+    DIALERS_UPDATED = 'DialersUpdated',
+    ERROR = 'error',
+    EXTENSION_EVENT = 'ExtensionEvent',
+    EXTENSION_UPDATED = 'ExtensionsUpdated',
+    KEEP_ALIVE = 'keepalive',
+    KEEP_ALIVE_RESPONSE = 'keepaliveResponse',
+    LOGIN = 'login',
+    LOGIN_ACCOUNT = 'loginAccount',
+    LOGIN_CODE = 'loginUserCode',
+    LOGIN_RESPONSE = 'loginResponse',
+    LOGIN_STATUS = 'loginStatus',
+    LOGIN_USER = 'loginUser',
+    PONG = 'pong',
+    QUEUE_EVENT = 'QueueEvent',
+    QUEUES_UPDATED = 'QueuesUpdated',
+    RECONNECT = 'reconnect',
+    RECONNECT_ATTEMPT = 'reconnect_attempt',
+    RECONNECT_ERROR = 'reconnect_error',
+    RECONNECT_FAILED = 'reconnect_failed',
+    RECONNECTING = 'reconnecting',
+    RESYNC = 'resync'
+}
 
 /**
  * This type represents a mapping of listener event names to their corresponding wrapped socket event data structures.
  * Each key is an event name, and the value is the wrapped socket event data for that event
  */
-declare type EventWrappedSocketDataMap = {
+export declare type EventWrappedSocketDataMap = {
     [K in EventTypeNames]: WrappedSocketEvent<K>
 }
 
-declare interface Extension {
+export declare interface Extension {
     calls: ExtensionCall[],
     userID: number,
     userName: string,
@@ -302,7 +366,7 @@ declare interface Extension {
     currentCall?: ExtensionCall,
 }
 
-declare interface ExtensionCall {
+export declare interface ExtensionCall {
     callStarted: number,
     calldurationinterval: number,
     callAnswered: number,
@@ -336,7 +400,7 @@ declare interface ExtensionCall {
 /**
  * Data structure for extension event.
  */
-declare interface ExtensionEvent extends CommonEventProperties {
+export declare interface ExtensionEvent extends CommonEventProperties {
     data: Extension
     eventName: EventNameEnum.EXTENSION
     reason: ExtensionEventReasonEnum
@@ -376,27 +440,55 @@ declare enum ExtensionHangupCauseEnum {
     ANSWERED_ELSEWHERE =  'Answered elsewhere'
 }
 
+export declare interface ExternalLoginNewStackResponseData {
+    AccessToken: string,
+    RefreshToken: string
+}
+
+export declare interface ExternalLoginOldStackResponseData {
+    Socket: Socket,
+}
+
+export declare interface ExternalLoginRequestBody {
+    identityType: LoginType,
+    username?: string,
+    password?: string,
+    token?: string
+}
+
+export declare interface ExternalLoginResponse<T> {
+    StatusCode: number,
+    Status: string,
+    Data: T
+}
+
 /**
  * A generic type that represents the structure of any event data wrapped in a socket event format.
  * This type is used in the handling of all event types, providing a consistent structure for event data processing.
  */
-declare type GenericEventWrapper = EventWrappedSocketDataMap[EventTypeNames]
+export declare type GenericEventWrapper = EventWrappedSocketDataMap[EventTypeNames]
 
 /**
  * Data structure for keep alive response event.
  */
-declare interface KeepAliveResponseEvent extends CommonEventProperties {
+export declare interface KeepAliveResponseEvent extends CommonEventProperties {
     isOk: boolean
 }
 
-declare interface LoggerConfig {
+export declare type ListenerCallbackFnType<T extends ListenersKeyType> = OpenSIPSEventMap[T]
+
+export declare type ListenersCallbackFnType = OpenSIPSEventMap[ListenersKeyType]
+
+export declare type ListenersKeyType = keyof OpenSIPSEventMap
+
+export declare interface LoggerConfig {
     logToConsole?: boolean;
     overloadGlobalConsole?: boolean;
     namespace?: string;
     socketEmitInterval?: number;
 }
 
-declare interface LoggerConnectOptions {
+export declare interface LoggerConnectOptions {
     reconnection?: boolean;
     reconnectionDelay?: number;
     reconnectionAttempts?: number;
@@ -406,26 +498,52 @@ declare interface LoggerConnectOptions {
     debug?: boolean;
 }
 
+export declare interface LoginSessionData extends Settings, ExternalLoginNewStackResponseData, Socket {}
+
+export declare interface LoginSessionPayload {
+    token: string,
+    email: string,
+    password: string
+}
+
 /**
  * Data structure for login status event.
  */
-declare interface LoginStatusEvent extends CommonEventProperties {
+export declare interface LoginStatusEvent extends CommonEventProperties {
     // Array of Queue objects
     queues: Queue[]
 }
 
-declare type LoginSuccessEvent = CommonEventProperties
+export declare type LoginSuccessEvent = CommonEventProperties
 
 declare enum LoginType {
     USER = "User",
     TOKEN = "Token"
 }
 
-declare interface OnlineStatusEvent {
+export declare interface OnlineStatusEvent {
     isSocketConnected: boolean
 }
 
-declare interface Queue {
+export declare interface OpenSIPSEventMap {
+    ready: readyListener
+    changeActiveCalls: changeActiveCallsListener
+    callConfirmed: TestEventListener
+    currentActiveRoomChanged: ActiveRoomListener
+    callAddingInProgressChanged: CallAddingProgressListener
+    roomDeleted: RoomDeletedListener
+    changeActiveInputMediaDevice: changeActiveInputMediaDeviceListener
+    changeActiveOutputMediaDevice: changeActiveOutputMediaDeviceListener
+    changeMuteWhenJoin: changeMuteWhenJoinListener
+    changeIsDND: changeIsDNDListener
+    changeIsMuted: changeIsMutedListener
+    addRoom: addRoomListener
+    updateRoom: updateRoomListener
+    removeRoom: removeRoomListener
+    changeCallStatus: changeCallStatusListener
+}
+
+export declare interface Queue {
     QueueID: number,
     QueueName: string,
     Calls: QueueCall[],
@@ -435,7 +553,7 @@ declare interface Queue {
     AnsweredAgent?: string,
 }
 
-declare interface QueueCall {
+export declare interface QueueCall {
     CallerID: string,
     CallerName: string,
     IvrUniqueID: string,
@@ -448,7 +566,7 @@ declare interface QueueCall {
 /**
  * Data structure for queue event.
  */
-declare interface QueueEvent extends CommonEventProperties {
+export declare interface QueueEvent extends CommonEventProperties {
     eventName: EventNameEnum.QUEUE,
     reason: QueueEventReasonEnum,
     telephonyServerTime: number,
@@ -463,7 +581,9 @@ declare enum QueueEventReasonEnum {
     JOIN = 'JOIN'
 }
 
-declare interface ReconnectOptions {
+export declare type readyListener = (value: boolean) => void
+
+export declare interface ReconnectOptions {
     retryCount: number;
     maxReconnectAttempts: number;
     reconnectionDelay: number;
@@ -471,26 +591,56 @@ declare interface ReconnectOptions {
     maxReconnectionDelay: number;
 }
 
-declare interface Recording {
+export declare interface Recording {
     Filename: string,
     Options: string,
     ApproximateURL: string,
     IsMuted: number
 }
 
-declare interface Server {
+export declare type removeRoomListener = (value: string) => void
+
+export declare type RoomDeletedListener = (roomId: number) => void
+
+export declare interface Server {
     Priority: number;
     Domain: string;
     URLID: number;
     Version: string;
 }
 
-declare enum ServerParameter {
+export declare enum ServerParameter {
     DEFAULT = "default",
     NEXT = "next",
     PREVIOUS = "previous"
 }
 
+export declare enum ServerTypesEnum {
+    DEFAULT = 1,
+    CHROME_EXTENSION = 2
+}
+
+export declare interface Settings {
+    IdentityCode: string,
+    IdentityCodeExpiry: Date,
+    PersonID: number,
+    PersonType: number,
+    ExtensionMonitorID: number,
+    MonitorList: Server[]
+}
+
+export declare interface Socket {
+    Client: string,
+    PersonId: number,
+    RefreshToken: string,
+    RefreshTokenExpiry: Date,
+    Token: string,
+    TokenExpiry: Date,
+    URLList: string[],
+    Url: string,
+    Version: string
+}
+
 declare class SocketIoClass {
     private readonly eventsSdkClass;
     constructor(eventsSdkClass: EventsSdkClass);
@@ -512,22 +662,26 @@ declare class SocketIoClass {
     private onDisconnect;
 }
 
-declare type SocketTyped = Socket<EventCallbackRegistry, Record<EventsEnum, any>>
+export declare type SocketTyped = Socket_2<EventCallbackRegistry, Record<EventsEnum_3, any>>
 
-declare interface Summery {
+export declare interface Summery {
     representative: string
 }
 
-declare type TypedSocketIo = (...args: Parameters<typeof io>) => any;
+export declare type TestEventListener = (event: { test: string }) => void
+
+declare type TypedSocketIo = (...args: Parameters<typeof io>) => SocketTyped;
+
+export declare type updateRoomListener = (value: string) => void
 
-declare interface User {
+export declare interface User {
     userID: number,
     userName: string,
     accountID: number
 
 }
 
-declare type WrappedSocketEvent<T extends EventsEnum_2> = {
+export declare type WrappedSocketEvent<T extends EventsEnum_2> = {
     name: T
     data: EventDataMap[T]
 }