@voicenter-team/events-sdk 0.0.10 → 0.0.12

package/dist/classes/auth/auth.class.d.ts

@@ -0,0 +1,20 @@
+import EventsSdkClass from '../events-sdk/events-sdk.class';
+import { EventsSdkOptions } from '../events-sdk/events-sdk.types';
+declare class AuthClass {
+    private readonly eventsSdkClass;
+    constructor(eventsSdkClass: EventsSdkClass);
+    private delay;
+    lastLoginTimestamp: number | undefined;
+    token: string | undefined;
+    private storageKey;
+    login(options: EventsSdkOptions): Promise<void>;
+    updateLastLoginTimestamp(): void;
+    private checkLoginStatus;
+    private userLoginFunction;
+    private onLoginResponse;
+    handleTokenExpiry(): void;
+    private externalLogin;
+    private getSettings;
+    private refreshToken;
+}
+export default AuthClass;

package/dist/classes/auth/auth.urls.d.ts

@@ -0,0 +1,4 @@
+declare const newLoginUrl = "https://loginapidev.voicenter.co.il/Auth/Login/Voicenter/Monitor";
+declare const getSettingsUrl = "https://loginapidev.voicenter.co.il/Application/GetSettings";
+declare const refreshTokenUrl = "https://loginapidev.voicenter.co.il/Auth/RefreshToken";
+export { newLoginUrl, getSettingsUrl, refreshTokenUrl };

package/dist/classes/events-sdk/events-sdk-default-options.d.ts

@@ -0,0 +1,2 @@
+import { EventsSdkOptions } from './events-sdk.types';
+export declare const eventsSdkDefaultOptions: EventsSdkOptions;

package/dist/classes/events-sdk/events-sdk.class.d.ts

@@ -0,0 +1,35 @@
+import AuthClass from '../auth/auth.class';
+import { SocketIoClass } from '../socket-io/socket-io.class';
+import { EventsSdkOptions, ReconnectOptions, Server, ServerParameter } from './events-sdk.types';
+import { SocketTyped } from '../../types/socket';
+import { GenericEventWrapper, EventSpecificCallback, EventTypeData, EventTypeNames } from '../../types/events';
+declare class EventsSdkClass {
+    constructor(options: EventsSdkOptions);
+    private argumentOptions;
+    readonly options: EventsSdkOptions;
+    servers: Server[];
+    server: Server;
+    socket: SocketTyped | undefined;
+    authClass: AuthClass;
+    socketIoClass: SocketIoClass;
+    reconnectOptions: ReconnectOptions;
+    retryConnection: import("lodash").DebouncedFuncLeading<(server?: ServerParameter, skipLogin?: boolean) => void>;
+    private listeners;
+    private allListeners;
+    on<T extends EventTypeNames>(event: T, callback: EventSpecificCallback<T>): void;
+    on(event: '*', callback: (data: GenericEventWrapper) => void): void;
+    off<T extends EventTypeNames>(event: T, callback: EventSpecificCallback<T>): void;
+    off(event: '*', callback: (data: GenericEventWrapper) => void): void;
+    emit<T extends EventTypeNames>(event: T, data: EventTypeData<T>): void;
+    connect(server?: ServerParameter, skipLogin?: boolean): void;
+    disconnect(): void;
+    clearKeepAliveInterval(): void;
+    private findCurrentServer;
+    private findNextAvailableServer;
+    private findMaxPriorityServer;
+    private findMinPriorityServer;
+    getServerWithHighestPriority(servers: Server[]): Server;
+    init(): Promise<boolean>;
+    private getServers;
+}
+export default EventsSdkClass;

package/dist/classes/events-sdk/events-sdk.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/classes/events-sdk/events-sdk.types.d.ts

@@ -0,0 +1,63 @@
+import { LoginType } from '../../enum/auth.enum';
+export interface EventsSdkOptions {
+    fallbackServer: Server;
+    refreshTokenUrl?: string;
+    refreshToken?: string;
+    servers?: 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 declare enum ServerParameter {
+    DEFAULT = "default",
+    NEXT = "next",
+    PREVIOUS = "previous"
+}

package/dist/classes/socket-io/socket-io.class.d.ts

@@ -0,0 +1,23 @@
+import EventsSdkClass from '../events-sdk/events-sdk.class';
+import { TypedSocketIo } from './versions';
+import { SocketTyped } from '../../types/socket';
+export declare class SocketIoClass {
+    private readonly eventsSdkClass;
+    constructor(eventsSdkClass: EventsSdkClass);
+    io: SocketTyped | undefined;
+    ioFunction: TypedSocketIo | undefined;
+    lastEventTimestamp: number;
+    doReconnect: boolean;
+    private keepAliveInterval;
+    private keepReconnectInterval;
+    private connected;
+    getSocketIoFunction(Client: string): void;
+    initSocketConnection(): void;
+    initSocketEvents(): void;
+    clearKeepAliveInterval(): void;
+    initKeepAlive(): void;
+    closeAllConnections(): void;
+    private onKeepAliveResponse;
+    private onConnect;
+    private onDisconnect;
+}

package/dist/classes/socket-io/socket-io.d.ts

@@ -0,0 +1,10 @@
+export interface SocketIoOptions {
+    reconnection: boolean,
+    perMessageDeflate: boolean,
+    upgrade: boolean,
+    transports: string[],
+    debug: boolean,
+    query: {
+        token: string
+    }
+}

package/dist/classes/socket-io/versions/index.d.ts

@@ -0,0 +1,8 @@
+import { io } from 'socket.io-client';
+import { SocketTyped } from '../../../types/socket';
+export type TypedSocketIo = (...args: Parameters<typeof io>) => SocketTyped;
+declare const _default: {
+    getSocketVersion: (version: string) => TypedSocketIo;
+    makeSocketVersion: (version: string, uri: string, opts?: Partial<import("socket.io-client").ManagerOptions & import("socket.io-client").SocketOptions> | undefined) => SocketTyped;
+};
+export default _default;

package/dist/classes/storage/storage.class.d.ts

@@ -0,0 +1,6 @@
+import { LoginSessionData } from '../../types/auth';
+export declare class StorageClass {
+    static getSessionStorageDataByKey(key: string): Promise<LoginSessionData | undefined>;
+    static updateSessionStorageKey(key: string, storageData: LoginSessionData): Promise<void>;
+    static clearSessionStorage(): void;
+}

package/dist/enum/auth.enum.d.ts

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

package/dist/enum/events.enum.d.ts

@@ -0,0 +1,77 @@
+/**
+ * All events that can be received from the server.
+ */
+export declare enum EventsEnum {
+    ALL_DIALER_STATUS = "AllDialersStatus",
+    ALL_EXTENSION_STATUS = "AllExtensionsStatus",
+    ALL_USERS_STATUS = "AllUsersStatus",
+    CONNECT = "connect",
+    DISCONNECT = "disconnect",
+    EXTENSION_EVENT = "ExtensionEvent",
+    KEEP_ALIVE = "keepalive",
+    KEEP_ALIVE_RESPONSE = "keepaliveResponse",
+    LOGIN_STATUS = "loginStatus",
+    LOGIN_SUCCESS = "loginSuccess",
+    QUEUE_EVENT = "QueueEvent",
+    ONLINE_STATUS_EVENT = "onlineStatusEvent",
+    DIALER_EVENT = "DialerEvent"
+}
+/**
+ * All the reasons for the extension event, e.g. a new call is ringing or dialing from an extension.
+ */
+export declare enum ExtensionEventReasonEnum {
+    NEW_CALL = "NEWCALL",
+    ANSWER = "ANSWER",
+    HOLD = "HOLD",
+    UNHOLD = "UNHOLD",
+    HANGUP = "HANGUP",
+    USER_STATUS_UPDATE = "userStatusUpdate"
+}
+export declare enum QueueEventReasonEnum {
+    ANSWER = "ANSWER",
+    ABANDONED = "ABANDONED",
+    EXIT = "EXIT",
+    JOIN = "JOIN"
+}
+export declare enum DialerType {
+    AUTOMATIC = "Automatic",
+    IVR = "IVR"
+}
+/**
+ * All the eventNames that can be received from the server. Exists only in EXTENSION_EVENT and QueueEvent
+ */
+export declare enum EventNameEnum {
+    EXTENSION = "extension",
+    QUEUE = "queue",
+    DIALER = "dialer"
+}
+export declare enum ExtensionHangupCauseEnum {
+    NORMAL_HANGUP = "Normal hangup",
+    USER_BUSY = "User busy",
+    CALL_REJECTED = "Call Rejected",
+    UNALLOCATED_NUMBER = "Unallocated (unassigned) number",
+    UNKNOWN = "Unknown",
+    NO_USER_RESPONDING = "No user responding",
+    USER_ALERTING = "User alerting, no answer",
+    ANSWERED_ELSEWHERE = "Answered elsewhere"
+}
+export declare enum CallStatusEnum {
+    RINGING = "Ringing",
+    TALKING = "Talking",
+    DIALING = "Dialing",
+    HOLD = "Hold"
+}
+export declare enum CallTypeEnum {
+    INCOMING = "Incoming",
+    OUTGOING = "Outgoing"
+}
+export declare enum DoNotCallMeStatusCodeEnum {
+    RESPONSE_FROM_API_VALID = "RESPONSE_FROM_API_VALID",
+    RESPONSE_FROM_API_INVALID = "RESPONSE_FROM_API_INVALID"
+}
+export declare enum DirectionEnum {
+    INCOMING = "Incoming",
+    OUTGOING = "Outgoing",
+    SPY = "Spy",
+    CLICK2CALL = "Click2call"
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import EventsSdkClass from './classes/events-sdk/events-sdk.class';
+import { EventsEnum } from './enum/events.enum';
+export type * from './types/auth';
+export type * from './types/events.common';
+export type * from './types/events';
+export type * from './types/listeners';
+export type * from './types/public-api';
+export type * from './types/socket';
+export type * from './classes/events-sdk/events-sdk.types';
+export { EventsEnum };
+export default EventsSdkClass;

package/dist/types/auth.d.ts

@@ -0,0 +1,49 @@
+import { Server } from '../classes/events-sdk/events-sdk.types'
+import { LoginType } from '../enum/auth.enum'
+
+export interface LoginSessionPayload {
+    token: string,
+    email: string,
+    password: string
+}
+
+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,
+    RefreshTokenExpiry: Date,
+    Token: string,
+    TokenExpiry: Date,
+    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/dist/types/events.common.d.ts

@@ -0,0 +1,110 @@
+import { CallStatusEnum, CallTypeEnum, DialerType, DirectionEnum, DoNotCallMeStatusCodeEnum } from '../enum/events.enum'
+
+export interface Dialer {
+    campaignID: number,
+    name: string,
+    typeID: number,
+    type: DialerType,
+    code: string,
+    calls: unknown,
+    statistics: unknown
+}
+
+export interface User {
+    userID: number,
+    userName: string,
+    accountID: number
+
+}
+
+export interface Extension {
+    calls: ExtensionCall[],
+    userID: number,
+    userName: string,
+    number: number,
+    extenUser: string,
+    accountID: number,
+    topAccountID: number,
+    summery: Summery,
+    onlineUserID: number,
+    representative: number,
+    representativeStatus: number,
+    lastCallEventEpoch: number,
+    lastAnsweredCallEventEpoch: number,
+    lastHangupCallEpoch: number,
+    representativeUpdated: number,
+    peerStatus: unknown,
+    currentCall?: ExtensionCall,
+}
+
+export interface Queue {
+    QueueID: number,
+    QueueName: string,
+    Calls: QueueCall[],
+    UserId?: number,
+    DistributorID?: number,
+    IsDistributedQueue?: boolean,
+    AnsweredAgent?: string,
+}
+
+export interface ExtensionCall {
+    callStarted: number,
+    calldurationinterval: number,
+    callAnswered: number,
+    answered: number,
+    callername: string,
+    callerphone: string,
+    outgoingcallername?: string,
+    outgoingcallerphone?: string,
+    callstatus: CallStatusEnum,
+    customdata: CustomData,
+    direction: DirectionEnum,
+    ivrid: string,
+    recording: Recording,
+    did: string,
+    relatedIvrUniqueIDs?: string[],
+    callType?: CallTypeEnum,
+    ip: string,
+    isInternal: boolean
+    blcServerID: number,
+    isOpensips: boolean,
+    channel: string,
+    channel2: string,
+    queueID?: number,
+    isSpyed?: boolean,
+    blcServerId?: number,
+    originalCallerID?: string,
+    originalCallerName?: string,
+    actualDialedNumber?: number
+}
+
+interface QueueCall {
+    CallerID: string,
+    CallerName: string,
+    IvrUniqueID: string,
+    JoinTimeStamp: number,
+    calldurationinterval: number,
+    ivrid: string,
+    isDistributedQueue?: boolean
+}
+
+interface Summery {
+    representative: string
+}
+
+interface CustomData {
+    DoNotCallMeStatus?: string,
+    DoNotCallMeStatusCode?: DoNotCallMeStatusCodeEnum,
+    DoNotCallMeTokenName?: string,
+    DoNotCallMetransactionId?: string,
+    IsDoNotCallMe?: string
+}
+
+interface Recording {
+    Filename: string,
+    Options: string,
+    ApproximateURL: string,
+    IsMuted: number
+}
+
+

package/dist/types/events.d.ts

@@ -0,0 +1,175 @@
+import {
+    EventNameEnum,
+    EventsEnum,
+    ExtensionEventReasonEnum,
+    ExtensionHangupCauseEnum,
+    QueueEventReasonEnum
+} from '@/enum/events.enum'
+import { Queue, Extension, Dialer, User } from './events.common'
+
+/**
+ * Base structure for all event types, containing common properties.
+ */
+interface CommonEventProperties {
+    // Error code, 0 indicates no error
+    errorCode?: number
+    // Description of the error, "Ok" indicates successful connection
+    errorDesc?: string
+    // Server time at the moment of the event
+    serverTime: number
+    // Difference in time between server and client
+    serverTimeOffset: number
+}
+
+// Inherits properties from CommonEventProperties
+type LoginSuccessEvent = CommonEventProperties
+
+/**
+ * Data structure for login status event.
+ */
+export interface LoginStatusEvent extends CommonEventProperties {
+    // Array of Queue objects
+    queues: Queue[]
+}
+
+/**
+ * Data structure for all extension status event.
+ */
+export interface AllExtensionStatusEvent extends CommonEventProperties {
+    // Array of Extension objects
+    extensions: Extension[]
+}
+
+/**
+ * Data structure for all dialers status event.
+ */
+export interface AllDialersStatusEvent extends CommonEventProperties {
+    // Array of Dialer objects
+    dialers: Dialer[]
+}
+
+/**
+ * Data structure for all users status event.
+ */
+export interface AllUsersStatusEvent extends CommonEventProperties {
+    // Array of User objects
+    users: User[]
+}
+
+/**
+ * Data structure for queue event.
+ */
+export interface QueueEvent extends CommonEventProperties {
+    eventName: EventNameEnum.QUEUE,
+    reason: QueueEventReasonEnum,
+    telephonyServerTime: number,
+    ivrUniqueId: string,
+    data: Queue
+}
+
+/**
+ * Data structure for extension event.
+ */
+export interface ExtensionEvent extends CommonEventProperties {
+    data: Extension
+    eventName: EventNameEnum.EXTENSION
+    reason: ExtensionEventReasonEnum
+    telephonyServerTime?: number
+    callerID?: string
+    ivrUniqueId?: string
+    dialStatus?: string
+    cause?: ExtensionHangupCauseEnum
+}
+
+/**
+ * Data structure for dialer event.
+ */
+export interface DialerEvent extends CommonEventProperties {
+    data: Dialer
+    eventName: EventNameEnum.DIALER
+    //reason: ExtensionEventReasonEnum // TODO: do research for dialer 'reason' prop
+    telephonyServerTime?: number
+    callerID?: string
+    ivrUniqueId?: string
+    dialStatus?: string
+    //cause?: ExtensionHangupCauseEnum // TODO: do research for dialer 'cause' prop
+}
+
+/**
+ * Data structure for keep alive response event.
+ */
+export interface KeepAliveResponseEvent extends CommonEventProperties {
+    isOk: boolean
+}
+
+export interface OnlineStatusEvent {
+    isSocketConnected: boolean
+}
+
+/**
+ * Mapping of event names to their respective data structures.
+ */
+export interface EventDataMap {
+    [EventsEnum.ALL_EXTENSION_STATUS]: AllExtensionStatusEvent
+    [EventsEnum.ALL_DIALER_STATUS]: AllDialersStatusEvent
+    [EventsEnum.ALL_USERS_STATUS]: AllUsersStatusEvent
+    [EventsEnum.QUEUE_EVENT]: QueueEvent
+    [EventsEnum.EXTENSION_EVENT]: ExtensionEvent
+    [EventsEnum.DIALER_EVENT]: DialerEvent
+    [EventsEnum.LOGIN_SUCCESS]: LoginSuccessEvent
+    [EventsEnum.LOGIN_STATUS]: LoginStatusEvent
+    [EventsEnum.KEEP_ALIVE_RESPONSE]: KeepAliveResponseEvent
+    [EventsEnum.ONLINE_STATUS_EVENT]: OnlineStatusEvent
+}
+
+/**
+ * Represents the set of all possible event type names as keys from the EventDataMap.
+ * This type is used to define event listeners and handlers.
+ */
+type EventTypeNames = keyof EventDataMap
+
+// Generic structure for wrapped socket event data
+type WrappedSocketEvent<T extends EventsEnum> = {
+    name: T
+    data: EventDataMap[T]
+}
+
+// Generic type for event type data
+export type EventTypeData<T extends EventsEnum> = EventDataMap[T]
+
+/**
+ * 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.
+ */
+export type EventCallbackRegistry = {
+    [K in EventTypeNames]: (data: EventDataMap[K]) => void
+}
+
+/**
+ * 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.
+ */
+export type EventSpecificCallback<T extends EventTypeNames> = (data: WrappedSocketEvent<T>) => void
+
+/**
+ * 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 type EventCallbackListenersMap = {
+    [K in EventTypeNames]: Array<EventSpecificCallback<K>>
+}
+
+/**
+ * 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
+ */
+type EventWrappedSocketDataMap = {
+    [K in EventTypeNames]: WrappedSocketEvent<K>
+}
+
+/**
+ * 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.
+ */
+export type GenericEventWrapper = EventWrappedSocketDataMap[EventTypeNames]

package/dist/types/listeners.d.ts

@@ -0,0 +1,37 @@
+export type readyListener = (value: boolean) => void
+export type changeActiveCallsListener = (event: { [key: string]: string }) => void
+export type TestEventListener = (event: { test: string }) => void
+export type ActiveRoomListener = (event: number | undefined) => void
+export type CallAddingProgressListener = (callId: string | undefined) => void
+export type RoomDeletedListener = (roomId: number) => void
+export type changeActiveInputMediaDeviceListener = (event: string) => void
+export type changeActiveOutputMediaDeviceListener = (event: string) => void
+export type changeMuteWhenJoinListener = (value: boolean) => void
+export type changeIsDNDListener = (value: boolean) => void
+export type changeIsMutedListener = (value: boolean) => void
+export type addRoomListener = (value: string) => void
+export type updateRoomListener = (value: string) => void
+export type removeRoomListener = (value: string) => void
+export type changeCallStatusListener = (event: { [key: string]: number }) => void
+
+export 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 type ListenersKeyType = keyof OpenSIPSEventMap
+export type ListenersCallbackFnType = OpenSIPSEventMap[ListenersKeyType]
+export type ListenerCallbackFnType<T extends ListenersKeyType> = OpenSIPSEventMap[T]