@wizai/agent-sip-sdk 0.1.5-alpha → 0.1.6-alpha

package/lib/types/api/index.d.ts

@@ -0,0 +1,48 @@
+import type { IApiProps, IRespones, IAgentStatusListResponse, IAgentStatusResponse, IGetAgentSettingParams, IGetAgentSettingResponse, IUpdateAgentTicketParams, IRegisterSSEParams, ICloseSSEParams, ISwitchAgentStatusParams, IOutboundCallParams, IOutboundCallResponse, IAgentResponseTimeParams, IGetCallTaskInfoParams, IGetCallTaskInfoResponse, ISendBeaconParams } from './types';
+import { EApiCode } from '../enums/common';
+declare class Api {
+    private baseUrl;
+    private readonly id;
+    private static instance;
+    private eventSource;
+    private retryCount;
+    private retryMap;
+    private token;
+    private getSystemToken;
+    private resetSSE;
+    constructor(props: IApiProps);
+    validateToken(id: string, token: string): Promise<IRespones<boolean>>;
+    initToken(): Promise<{
+        code: EApiCode;
+        data: null;
+        message: string;
+    }>;
+    refreshToken(): Promise<void>;
+    getAgentStatusList(): Promise<IRespones<IAgentStatusListResponse>>;
+    getAgentInfo(): Promise<IRespones<IAgentStatusResponse>>;
+    getAgentSetting(params: IGetAgentSettingParams): Promise<IGetAgentSettingResponse>;
+    updateAgentHangup(agentId: number): Promise<IGetAgentSettingResponse>;
+    updateAgentTicket(data: IUpdateAgentTicketParams): Promise<IRespones<any>>;
+    registerSSE(data: IRegisterSSEParams): Promise<unknown>;
+    closeSSE(data: ICloseSSEParams): Promise<void>;
+    switchAgentStatus(data: ISwitchAgentStatusParams): Promise<IRespones<IAgentStatusResponse>>;
+    outboundCall(data: IOutboundCallParams): Promise<IRespones<IOutboundCallResponse>>;
+    saveAgentResponseTime(data: IAgentResponseTimeParams): Promise<IRespones<any>>;
+    getCallTaskInfo(data: IGetCallTaskInfoParams): Promise<IGetCallTaskInfoResponse>;
+    getAfterCallProcessTime(data: IGetCallTaskInfoParams): Promise<IRespones<number>>;
+    formatFormData<T = Record<string, any>>(params: T): FormData;
+    sendBeacon<T extends ISendBeaconParams>(params: T): void;
+    clearnSendBeaconQueue(): Promise<void>;
+    /**
+     * 获取token，支持降级策略
+     * 1. 优先使用内存中的token
+     * 2. 如果内存为空，从sessionStorage读取
+     * @returns token字符串
+     */
+    private getTokenWithFallback;
+    waitToken(timeout?: number, duration?: number): Promise<unknown>;
+    private request;
+    private executePeriodically;
+    static getInstance(options?: IApiProps): Api;
+}
+export default Api;

package/lib/types/api/types.d.ts

@@ -0,0 +1,144 @@
+import { EApiCode } from '../enums/common';
+import { EAgentStatus, EAgentAction } from '../enums/agent';
+export interface IRequestOptionsType<T = any> {
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD';
+    url: string;
+    data?: T;
+    headers?: Record<string, string>;
+}
+export interface IApiProps {
+    id: string;
+    getSystemToken: () => Promise<string>;
+    resetSSE: () => Promise<void>;
+    baseUrl?: string;
+    retryCount?: number;
+}
+export interface IRespones<T> {
+    code: EApiCode;
+    data: T;
+    message: string;
+    msg?: string;
+}
+export interface IRefreshTokenResponse {
+    token: string;
+    expire: string;
+    refreshToken: null;
+    refreshExpire: null;
+    userId: string;
+    userName: string;
+    renderLocale: null;
+    logout: null;
+    entExpireTips: null;
+    entExpire: null;
+    firstLogin: null;
+    initPassword: null;
+    userCacheVO: null;
+    entId: string;
+}
+interface IAgentStatusItem {
+    id: number;
+    entId: number;
+    name: string;
+    status: number;
+    isSystemDefault: boolean;
+    description: string;
+    createTime: string;
+    updateTime: string;
+}
+export type IAgentStatusListResponse = Array<IAgentStatusItem>;
+export interface IAgentStatus {
+    id: number;
+    number: string;
+    name: null;
+    enterpriseId: string;
+    userId: string;
+    outboundLineId: string;
+    outboundLineName: null;
+    groupId: number;
+    status: number;
+    username: string;
+    password: string;
+    realm: string;
+    outboundLineNames: null;
+    type: number;
+    sipServer: null;
+    statusName: string;
+    ticket: string;
+}
+export type IAgentStatusResponse = Array<IAgentStatus>;
+export interface IGetAgentSettingParams {
+    key: string;
+}
+export interface IGetAgentSettingResponse {
+    callType: string;
+    transferWaitingTime: number;
+    transferWaitingRingtone: string;
+    agentWaitingTime: number;
+    agentRingtone: string;
+}
+export interface IUpdateAgentTicketParams {
+    agentId: number;
+    ticket: string;
+    type: EAgentStatus;
+}
+export interface IRegisterSSEParams {
+    agentId: number;
+    onMessage: (_e: any) => void;
+}
+export interface ICloseSSEParams {
+    agentId: number;
+    clearTicket: 0 | 1;
+}
+export interface ISwitchAgentStatusParams {
+    id: number;
+    groupId: number;
+    status: EAgentStatus;
+    subStatus?: string;
+}
+export interface IOutboundCallParams {
+    phone: string;
+    line: string;
+}
+export interface IOutboundCallResponse {
+    callId: string;
+    callType: number;
+}
+export interface IAgentResponseTimeParams {
+    callId: string;
+    agentResponseTime: number;
+    agentId: number;
+    agentGroupId: number;
+    resultType: EAgentAction;
+}
+export interface IGetCustomerInfoParams {
+    customerId: string;
+}
+export interface IGetCustomerInfoResponse {
+    phone: string;
+    name: string;
+    email: string;
+    gender: number;
+    address: string;
+    companyName: string;
+    source: string;
+    customerStatus: number;
+    userName: string;
+    extraJson: string;
+}
+export interface IGetCallTaskInfoParams {
+    callTaskId: string;
+}
+export interface IGetCallTaskInfoResponse {
+    callTaskId: string;
+    name: string;
+    templateName: string;
+}
+export interface ISendBeaconParams {
+    url: string;
+    lastSendResult?: boolean;
+    createTime?: string;
+    sendTime?: string;
+    Authentication?: string;
+    trace?: string;
+}
+export {};

package/lib/types/enums/agent.d.ts

@@ -0,0 +1,9 @@
+export declare enum EAgentStatus {
+    OFFLINE = 0,
+    ONLINE = 1,
+    HANGUP = 4
+}
+export declare enum EAgentAction {
+    ANSWER = 1,
+    HANGUP = 2
+}

package/lib/types/enums/common.d.ts

@@ -0,0 +1,19 @@
+export declare enum EApiCode {
+    SUCCESS = 0,
+    FAILED = -1,
+    TIMEOUT = -2,
+    UNAUTHORIZED = 401,
+    UNAVAILABLE = 403,
+    SYSTEMBUSY = 450,
+    NOENOUGNCHARACTER = 10001
+}
+export declare enum ECode {
+    SUCCESS = 200,
+    UNAUTHORIZED = 401,
+    UNAVAILABLE = 403,
+    TIMEOUT = 408,
+    LOCKED = 423,
+    SYSTEMBUSY = 450,
+    FAILED = 500,
+    NOENOUGNCHARACTER = 10001
+}

package/lib/types/index.d.ts

@@ -0,0 +1,57 @@
+import { ECode } from './enums/common';
+import type { IAnswerFnType, INewMessageFnType, ISessionType, ISessionEventListener } from './sip/types';
+import type { IAgentSipSDKOptions, IAgentStatusParams, IInitType, IInitFnType, IAgentType, IAgentFnType, IGetAgentStatus, IGetAgentStatusList, ISwitchAgentStatus, IOutboundCall } from './types';
+declare class AgentSipSDK {
+    private sip;
+    private api;
+    private agentInfo;
+    private initEvent;
+    private agentEvent;
+    private agentWaitingTime;
+    private agentResponseTime;
+    private timer;
+    private callDetails;
+    constructor(props: IAgentSipSDKOptions);
+    private init;
+    getAgentStatusList(): Promise<IGetAgentStatusList>;
+    private getTicket;
+    private getHostName;
+    private processSSEMessage;
+    private resetSSE;
+    private createSSEAndOpensips;
+    getAgentStatus(): Promise<IGetAgentStatus>;
+    private onlineAgent;
+    private offlineAgent;
+    switchAgentStatus(data: IAgentStatusParams): Promise<ISwitchAgentStatus>;
+    outboundCall(phoneNumber: string): Promise<IOutboundCall>;
+    finshACW(): Promise<{
+        code: ECode;
+        data: null;
+        message: string;
+    }>;
+    private sessionEnded;
+    private sessionFailed;
+    private openOnunload;
+    private cancelOnunload;
+    private saveAgentResponseTime;
+    hangup(): void;
+    private timingResTime;
+    private incomingCall;
+    answer(): void;
+    ignore(): void;
+    mute(): void;
+    unmute(): void;
+    attachInitEvent(type: IInitType, listener: IInitFnType): void;
+    removeInitEvent(type: IInitType, listener: IInitFnType): void;
+    private emitInitEvent;
+    attachAgentEvent(type: IAgentType, listener: IAgentFnType): void;
+    removeAgentEvent(type: IAgentType, listener: IAgentFnType): void;
+    private emitAgentEvent;
+    attachAnswerEvent(listener: IAnswerFnType): void;
+    removeAnswerEvent(listener: IAnswerFnType): void;
+    attachNewMessageEvent(listener: INewMessageFnType): void;
+    removeNewMessageEvent(listener: INewMessageFnType): void;
+    attchSessionEvent<T extends ISessionType>(type: T, listener: ISessionEventListener<T>): void;
+    removeSessionEvent<T extends ISessionType>(type: T, listener: ISessionEventListener<T>): void;
+}
+export default AgentSipSDK;

package/lib/types/sip/index.d.ts

@@ -0,0 +1,68 @@
+import type { UAEventMap, IncomingRTCSessionEvent } from 'jssip/lib/UA.d.ts';
+import type { RTCSession, RTCSessionEventMap } from 'jssip/lib/RTCSession.d.ts';
+import type { IAnswerFnType, IAnswerEventPayload, INewMessageFnType, INewMessageEventPayload, ISessionType, ISessionEventListener, ISessionEventPayload } from './types';
+declare class SIP {
+    private callType;
+    private ua;
+    private socket;
+    private isManualStop;
+    private pingTimerId;
+    private newRTCSession;
+    incomingSession: RTCSession;
+    private outgoingSession;
+    private stream;
+    private audio;
+    private ringAudio;
+    private answerEvent;
+    private newMessageEvent;
+    private sessionEvent;
+    private callDetails;
+    private readonly incomingCallCallback;
+    private readonly getMediaStream;
+    constructor(props: {
+        incomingCallCallback: (_e: IncomingRTCSessionEvent) => Promise<IAnswerEventPayload>;
+        getMediaStream?: () => Promise<MediaStream>;
+    });
+    /**
+     *
+     *
+     * @memberof AgentSipClient
+     */
+    initMicrophone(): void;
+    destroyMicrophone(): void;
+    reset(): void;
+    setCallType(type: 'inboundCall' | 'outboundCall' | ''): void;
+    getCallType(): 'inboundCall' | 'outboundCall' | '';
+    init(options: {
+        wssuri: string;
+        password: string;
+        uri: string;
+    }): Promise<void>;
+    start(): void;
+    stop(isManualStop?: boolean): void;
+    destroy(): void;
+    getSocketWS(): any;
+    sendPing(): void;
+    playRing(): void;
+    stopRing(): void;
+    call(sipPhoneNumber: string, eventHandlers: any, _stream: any, _muteAudio: boolean): void;
+    hangup(): void;
+    ignore(): void;
+    answer(): void;
+    attachAnswerEvent(listener: IAnswerFnType): void;
+    removeAnswerEvent(listener: IAnswerFnType): void;
+    emitAnswerEvent(data: IAnswerEventPayload): void;
+    attachNewMessageEvent(listener: INewMessageFnType): void;
+    removeNewMessageEvent(listener: INewMessageFnType): void;
+    emitNewMessageEvent(data: INewMessageEventPayload): void;
+    attchSessionEvent<T extends ISessionType>(type: T, listener: ISessionEventListener<T>): void;
+    removeSessionEvent<T extends ISessionType>(type: T, listener: ISessionEventListener<T>): void;
+    emitSessionEvent<T extends ISessionType>(type: T, data: ISessionEventPayload<T>): void;
+    on<T extends keyof UAEventMap>(type: T, listener: UAEventMap[T]): this;
+    RTCSessionOn<T extends keyof RTCSessionEventMap>(type: T, listener: RTCSessionEventMap[T]): void;
+    mute(): void;
+    unmute(): void;
+    isMuted(): MediaConstraints;
+    getIsRegistered(): boolean;
+}
+export default SIP;

package/lib/types/sip/types.d.ts

@@ -0,0 +1,28 @@
+import type { IResponse, ICallDetails } from '../types';
+export interface ISipOptions {
+    getSystemToken: () => Promise<string>;
+    retryCount?: number;
+}
+export interface IRequestOptionsType {
+    method: string;
+    url: string;
+    headers: {
+        Authorization: string;
+    };
+}
+export type IAnswerEventPayload = IResponse<ICallDetails | null>;
+export type IAnswerFnType = (_data: IAnswerEventPayload) => void;
+export type INewMessageEventPayload = IResponse<{
+    agentId: string;
+    callId: string;
+    data: Array<any>;
+    state: string;
+    type: string;
+} | null>;
+export type INewMessageFnType = (_data: INewMessageEventPayload) => void;
+export type ISessionType = 'success' | 'failed' | 'ended';
+export type ISessionEventPayload<T extends ISessionType> = IResponse<ICallDetails | null>;
+export type ISessionEventListener<T extends ISessionType> = (_data: ISessionEventPayload<T>) => void;
+export type ISessionEventType<T extends ISessionType> = {
+    [K in T]: Array<ISessionEventListener<K>>;
+};

package/lib/types/types.d.ts

@@ -0,0 +1,85 @@
+import { ECode } from './enums/common';
+import { EAgentStatus } from './enums/agent';
+import type { IAgentStatusListResponse, IOutboundCallResponse } from './api/types';
+export interface IResponse<T = any> {
+    code: ECode;
+    data: T;
+    message: string;
+}
+export interface IAgentSipSDKOptions {
+    id: string;
+    getSystemToken: () => Promise<string>;
+    baseUrl?: string;
+    retryCount?: number;
+    getMediaStream?: () => Promise<MediaStream>;
+}
+export interface IAgentStatusParams {
+    status: EAgentStatus;
+    subStatus: string;
+}
+export type IInitType = 'success' | 'failed';
+export type IInitEventPayload = IResponse;
+export type IInitFnType = (_data: IInitEventPayload) => void;
+export type IAgentType = 'online' | 'offline';
+export type IAgentEventPayload = IResponse<IAgentStatusParams>;
+export type IAgentFnType = (_data: IAgentEventPayload) => void;
+export interface ICallDetails {
+    callId: string;
+    callType: string;
+    taskName: string;
+    afterCallProcessTime: string;
+    extraJson: any;
+}
+export interface IGetAgentStatusSuccess {
+    code: ECode.SUCCESS | ECode.LOCKED;
+    data: {
+        id: number;
+        groupId: number;
+        status: number;
+        subStatus: string;
+    };
+    message: string;
+}
+interface IGetAgentStatusFailed {
+    code: ECode.FAILED;
+    data: null;
+    message: string;
+}
+export type IGetAgentStatus = IGetAgentStatusSuccess | IGetAgentStatusFailed;
+interface IGetAgentStatusListSuccess {
+    code: ECode.SUCCESS;
+    data: IAgentStatusListResponse;
+    message: string;
+}
+interface IGetAgentStatusListFailed {
+    code: ECode.FAILED;
+    data: null;
+    message: string;
+}
+export type IGetAgentStatusList = IGetAgentStatusListSuccess | IGetAgentStatusListFailed;
+export interface ISwitchAgentStatusSuccess {
+    code: ECode.SUCCESS;
+    data: {
+        status: EAgentStatus;
+        subStatus: string;
+    };
+    message: string;
+}
+interface ISwitchAgentStatusFailed {
+    code: ECode.FAILED;
+    data: null;
+    message: string;
+}
+export type ISwitchAgentStatus = ISwitchAgentStatusSuccess | ISwitchAgentStatusFailed;
+interface IOutboundCallSuccess {
+    code: ECode.SUCCESS;
+    data: IOutboundCallResponse;
+    message: string | undefined;
+}
+interface IOutboundCallFailed {
+    code: ECode.FAILED;
+    data: null;
+    message: string | undefined;
+}
+export type IOutboundCall = IOutboundCallSuccess | IOutboundCallFailed;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wizai/agent-sip-sdk",
-  "version": "0.1.5-alpha",
+  "version": "0.1.6-alpha",
   "description": "Manages SIP clients and agent status, simplifying calls and events.",
   "main": "lib/agent-sip-sdk-cjs.js",
   "module": "lib/agent-sip-sdk-es.js",