webitel-sdk 0.1.74 → 0.1.78

package/dist/esm5/socket/client.js

@@ -0,0 +1,869 @@
+import { __assign, __awaiter, __extends, __generator } from "tslib";
+// tslint:disable-next-line: match-default-export-name
+import Axios from 'axios';
+import { EventEmitter } from 'ee-ts';
+import { Log } from '../log';
+import { SipPhone } from '../sip/webrtc';
+import { Agent } from './agent';
+import { Call, CallActions, } from './call';
+import { ChatActions, Conversation, } from './conversation';
+import { Socket } from './socket';
+import { ChannelName, Task } from './task';
+import { formatBaseUri } from './utils';
+var API_HEADER_TOKEN = 'X-Webitel-Access';
+var WEBSOCKET_AUTHENTICATION_CHALLENGE = 'authentication_challenge';
+var WEBSOCKET_DEFAULT_DEVICE_CONFIG = 'user_default_device';
+var WEBSOCKET_AGENT_SESSION = 'cc_agent_session';
+// const WEBSOCKET_CALL_BY_USER = 'call_by_user'
+var WEBSOCKET_MAKE_OUTBOUND_CALL = 'call_invite';
+var WEBSOCKET_MAKE_USER_CALL = 'call_user';
+var WEBSOCKET_EVENT_HELLO = 'hello';
+var WEBSOCKET_EVENT_CALL = 'call';
+var WEBSOCKET_EVENT_CHAT = 'chat';
+var WEBSOCKET_EVENT_USER_STATE = 'user_state';
+var WEBSOCKET_EVENT_AGENT_STATUS = 'agent_status';
+var WEBSOCKET_EVENT_CHANNEL_STATUS = 'channel';
+var WEBSOCKET_EVENT_QUEUE_JOIN_MEMBER = 'queue_join_member';
+var TASK_EVENT = 'task';
+var WEBSOCKET_EVENT_SIP = 'sip';
+export var Response;
+(function (Response) {
+    Response["STATUS_FAIL"] = "FAIL";
+    Response["STATUS_OK"] = "OK";
+})(Response || (Response = {}));
+var Client = /** @class */ (function (_super) {
+    __extends(Client, _super);
+    function Client(_config) {
+        var _this = _super.call(this) || this;
+        _this._config = _config;
+        _this.reqSeq = 0;
+        _this.queueRequest = new Map();
+        _this.log = new Log();
+        _this.eventHandler = new EventEmitter();
+        _this.callStore = new Map();
+        _this.conversationStore = new Map();
+        _this.basePath = "" + formatBaseUri(_config.storageEndpoint || _config.endpoint);
+        return _this;
+    }
+    Client.prototype.connect = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.connectToSocket()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Client.prototype.disconnect = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.socket.close();
+                return [2 /*return*/];
+            });
+        });
+    };
+    Client.prototype.subscribeCall = function (handler, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var calls, _i, _a, c, e, call;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.request("subscribe_call", data)];
+                    case 1:
+                        calls = (_b.sent());
+                        this.eventHandler.on(WEBSOCKET_EVENT_CALL, handler);
+                        if (calls.items && calls.items.length) {
+                            for (_i = 0, _a = calls.items; _i < _a.length; _i++) {
+                                c = _a[_i];
+                                if (c.hangup_at && c.hangup_at > 0 && !c.task) {
+                                    continue;
+                                }
+                                e = {
+                                    cc_app_id: '',
+                                    app_id: c.app_id,
+                                    event: c.state,
+                                    id: c.id,
+                                    timestamp: Date.now(),
+                                    data: {
+                                        app_id: c.app_id,
+                                        event: c.state,
+                                        id: c.id,
+                                        timestamp: Date.now(),
+                                        cc_app_id: '',
+                                        sip_id: '',
+                                        parent_id: c.parent_id,
+                                        direction: c.direction,
+                                        destination: c.destination,
+                                        queue: c.queue,
+                                        from: c.from,
+                                        to: c.to,
+                                        payload: c.variables,
+                                    },
+                                };
+                                call = new Call(this, e);
+                                call.createdAt = c.created_at;
+                                call.answeredAt = c.answered_at || 0;
+                                call.bridgedAt = c.bridged_at || 0;
+                                call.hangupAt = c.hangup_at || 0;
+                                call.reportingAt = c.reporting_at || 0;
+                                if (c.task) {
+                                    call.task = new Task(this, {
+                                        attempt_id: c.task.attempt_id,
+                                        channel: c.task.channel,
+                                        status: c.task.status,
+                                        timestamp: Date.now(),
+                                    }, c.task // todo add app_id
+                                    );
+                                    call.queue.reporting = 'true';
+                                }
+                                this.callStore.set(call.id, call);
+                            }
+                        }
+                        return [2 /*return*/, calls];
+                }
+            });
+        });
+    };
+    Client.prototype.subscribeChat = function (handler, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res, _i, _a, conv, messages, c;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.request("subscribe_chat", data)];
+                    case 1:
+                        res = (_b.sent());
+                        this.eventHandler.on(WEBSOCKET_EVENT_CHAT, handler);
+                        if (res && res.items) {
+                            for (_i = 0, _a = res.items; _i < _a.length; _i++) {
+                                conv = _a[_i];
+                                messages = conv.messages.reverse();
+                                c = new Conversation(this, conv.id, conv.title, conv.members, messages, conv.variables);
+                                c.createdAt = conv.created_at;
+                                if (conv.invite_id) {
+                                    c.setInvite(conv.invite_id, conv.created_at);
+                                }
+                                else if (conv.channel_id) {
+                                    c.setAnswered(conv.channel_id, conv.joined_at, {
+                                        id: conv.channel_id,
+                                        name: 'TODO',
+                                        type: 'webitel',
+                                    });
+                                }
+                                else {
+                                    this.log.error("conversation " + conv.id + " not valid");
+                                    continue;
+                                }
+                                this.conversationStore.set(c.id, c);
+                            }
+                        }
+                        return [2 /*return*/, res];
+                }
+            });
+        });
+    };
+    Client.prototype.subscribeUsersStatus = function (handler, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.request("subscribe_users_status", data)];
+                    case 1:
+                        res = _a.sent();
+                        this.eventHandler.on(WEBSOCKET_EVENT_USER_STATE, handler);
+                        return [2 /*return*/, res];
+                }
+            });
+        });
+    };
+    Client.prototype.subscribeAgentsStatus = function (handler, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.request("cc_agent_subscribe_status", data)];
+                    case 1:
+                        res = _a.sent();
+                        this.eventHandler.on(WEBSOCKET_EVENT_AGENT_STATUS, handler);
+                        return [2 /*return*/, res];
+                }
+            });
+        });
+    };
+    Client.prototype.subscribeTask = function (handler) {
+        this.eventHandler.on(TASK_EVENT, handler);
+    };
+    Client.prototype.unSubscribe = function (action, handler, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var res;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.request("un_subscribe_" + action, data)
+                        // this.eventHandler.listeners(action)
+                        // this.eventHandler.removeListener(action, handler)
+                        // this.eventHandler.off(action, handler)
+                    ];
+                    case 1:
+                        res = _a.sent();
+                        // this.eventHandler.listeners(action)
+                        // this.eventHandler.removeListener(action, handler)
+                        // this.eventHandler.off(action, handler)
+                        return [2 /*return*/, res];
+                }
+            });
+        });
+    };
+    Client.prototype.destroy = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.disconnect()];
+                    case 1:
+                        _a.sent();
+                        if (!this.phone) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.phone.unregister()];
+                    case 2:
+                        _a.sent();
+                        this.phone.off('*');
+                        delete this.phone;
+                        _a.label = 3;
+                    case 3:
+                        this.eventHandler.off('*');
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Client.prototype.allCall = function () {
+        return Array.from(this.callStore.values());
+    };
+    Client.prototype.allConversations = function () {
+        return Array.from(this.conversationStore.values());
+    };
+    Client.prototype.allTask = function () {
+        if (!this.agent) {
+            return [];
+        }
+        return Array.from(this.agent.task.values());
+    };
+    Client.prototype.callById = function (id) {
+        if (this.callStore.has(id)) {
+            return this.callStore.get(id);
+        }
+    };
+    Client.prototype.conversationById = function (id) {
+        if (this.conversationStore.has(id)) {
+            return this.conversationStore.get(id);
+        }
+    };
+    Client.prototype.callBySipId = function (id) {
+        for (var _i = 0, _a = this.allCall(); _i < _a.length; _i++) {
+            var call = _a[_i];
+            if (call.sipId && id.startsWith(call.sipId)) {
+                // FIXME
+                return call;
+            }
+        }
+    };
+    Client.prototype.reportingTask = function (attemptId, reporting) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request('cc_reporting', __assign({ attempt_id: attemptId }, reporting))];
+            });
+        });
+    };
+    Client.prototype.agentActiveTasks = function (agentId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request("cc_agent_tasks", {
+                        agent_id: agentId,
+                    })];
+            });
+        });
+    };
+    Client.prototype.auth = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request(WEBSOCKET_AUTHENTICATION_CHALLENGE, {
+                        token: this._config.token,
+                    })];
+            });
+        });
+    };
+    Client.prototype.sessionInfo = function () {
+        return this.connectionInfo.session;
+    };
+    Object.defineProperty(Client.prototype, "version", {
+        get: function () {
+            return this.connectionInfo.server_version;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(Client.prototype, "instanceId", {
+        get: function () {
+            return this.connectionInfo.sock_id;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Client.prototype.agentSession = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var info, taskList, _i, _a, t, task, _b, _c, call;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this.request(WEBSOCKET_AGENT_SESSION)];
+                    case 1:
+                        info = _d.sent();
+                        this.agent = new Agent(this, info);
+                        return [4 /*yield*/, this.agentActiveTasks(this.agent.agentId)];
+                    case 2:
+                        taskList = (_d.sent());
+                        // todo
+                        for (_i = 0, _a = taskList.items; _i < _a.length; _i++) {
+                            t = _a[_i];
+                            task = new Task(this, {
+                                status: t.status,
+                                timestamp: Date.now() - t.duration * 1000,
+                                channel: t.channel,
+                                attempt_id: t.attempt_id,
+                            }, t);
+                            task.postProcessData = {};
+                            task.state = t.state;
+                            if (t.bridged_at) {
+                                task.bridgedAt = t.bridged_at;
+                                task.answeredAt = t.bridged_at;
+                            }
+                            if (t.leaving_at) {
+                                task.closedAt = t.leaving_at;
+                            }
+                            this.agent.task.set(task.id, task);
+                        }
+                        for (_b = 0, _c = this.allCall(); _b < _c.length; _b++) {
+                            call = _c[_b];
+                            if (call.task) {
+                                this.agent.task.set(call.task.id, call.task);
+                            }
+                        }
+                        return [2 /*return*/, this.agent];
+                }
+            });
+        });
+    };
+    Client.prototype.invite = function (req) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request(WEBSOCKET_MAKE_OUTBOUND_CALL, req)];
+            });
+        });
+    };
+    Client.prototype.call = function (req) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.phone) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.phone.call(req)];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, this.invite(req)];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Client.prototype.callRecordId = function (id) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request('call_recordings', { id: id })];
+            });
+        });
+    };
+    Client.prototype.eavesdrop = function (req) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request('call_eavesdrop', req)];
+            });
+        });
+    };
+    Client.prototype.agentSetOnline = function (agentId, channels, onDemand) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request('cc_agent_online', {
+                        agent_id: agentId,
+                        channels: channels,
+                        on_demand: onDemand,
+                    })];
+            });
+        });
+    };
+    Client.prototype.agentSetWaiting = function (agentId, channel) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request('cc_agent_waiting', {
+                        agent_id: agentId,
+                        channel: channel,
+                    })];
+            });
+        });
+    };
+    Client.prototype.agentSetPause = function (agentId, payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request('cc_agent_pause', {
+                        agent_id: agentId,
+                        payload: payload,
+                    })];
+            });
+        });
+    };
+    Client.prototype.agentSetOffline = function (agentId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request('cc_agent_offline', { agent_id: agentId })];
+            });
+        });
+    };
+    Client.prototype.inviteToUser = function (req) {
+        return this.request(WEBSOCKET_MAKE_USER_CALL, req);
+    };
+    Client.prototype.answer = function (id, req) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (this.phone) {
+                    return [2 /*return*/, this.phone.answer(id, req)];
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    Client.prototype.request = function (action, data) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            _this.queueRequest.set(++_this.reqSeq, { resolve: resolve, reject: reject });
+            _this.socket.send({
+                seq: _this.reqSeq,
+                action: action,
+                data: data,
+            });
+        });
+    };
+    Client.prototype.useWebPhone = function () {
+        return this._config.registerWebDevice || false;
+    };
+    Client.prototype.callDestroyed = function (call) {
+        return call.hangupAt > 0 && !this.hasAgentTask(call.task);
+    };
+    Client.prototype.conversationDestroyed = function (conv) {
+        return conv.closedAt > 0 && !this.hasAgentTask(conv.task);
+    };
+    Client.prototype.reportingChannelTask = function (task) {
+        switch (task.channel) {
+            case ChannelName.Call:
+                for (var _i = 0, _a = this.allCall(); _i < _a.length; _i++) {
+                    var call = _a[_i];
+                    if (this.callDestroyed(call)) {
+                        this.destroyCall(call);
+                        return;
+                    }
+                }
+                break;
+            case ChannelName.Chat:
+                if (task.agentChannelId) {
+                    var conv = this.conversationById(task.agentChannelId);
+                    if (conv && this.conversationDestroyed(conv)) {
+                        this.destroyConversation(conv);
+                        return;
+                    }
+                }
+                break;
+            default:
+        }
+    };
+    Client.prototype.registerCallClient = function (phone) {
+        return __awaiter(this, void 0, void 0, function () {
+            var conf, e_1;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.phone = phone;
+                        this.phone.on('peerStreams', function (session, streams) {
+                            var call = _this.callBySession(session);
+                            if (call && !call.peerStreams.length) {
+                                call.setPeerStreams(streams);
+                                _this.eventHandler.emit(WEBSOCKET_EVENT_CALL, CallActions.PeerStream, call);
+                            }
+                        });
+                        this.phone.on('localStreams', function (session, streams) {
+                            var call = _this.callBySession(session);
+                            if (call && !call.localStreams.length) {
+                                call.setLocalStreams(streams);
+                                _this.eventHandler.emit(WEBSOCKET_EVENT_CALL, CallActions.LocalStream, call);
+                            }
+                        });
+                        this.phone.on('newSession', this.onNewCallSession.bind(this));
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 4, , 5]);
+                        return [4 /*yield*/, this.deviceConfig(this.phone.type)];
+                    case 2:
+                        conf = _a.sent();
+                        return [4 /*yield*/, this.phone.register(conf)];
+                    case 3:
+                        _a.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        e_1 = _a.sent();
+                        // FIXME add handle error
+                        this.log.error(e_1);
+                        return [3 /*break*/, 5];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Client.prototype.deviceConfig = function (name) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.request(WEBSOCKET_DEFAULT_DEVICE_CONFIG, { name: name })];
+            });
+        });
+    };
+    Client.prototype.storeFile = function (id, files, cb) {
+        return __awaiter(this, void 0, void 0, function () {
+            var formData, _i, files_1, file, result, data, _a, data_1, f;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!files || files.length < 1) {
+                            throw new Error('no files');
+                        }
+                        formData = new FormData();
+                        for (_i = 0, files_1 = files; _i < files_1.length; _i++) {
+                            file = files_1[_i];
+                            formData.append(file.name, file); // todo name
+                        }
+                        return [4 /*yield*/, Axios.post(this.basePath + "/api/storage/file/" + id + "/upload", formData, {
+                                headers: (_b = {},
+                                    _b[API_HEADER_TOKEN] = this._config.token,
+                                    _b),
+                                onUploadProgress: cb,
+                            })];
+                    case 1:
+                        result = _c.sent();
+                        data = result.data;
+                        for (_a = 0, data_1 = data; _a < data_1.length; _a++) {
+                            f = data_1[_a];
+                            f.shared = this.basePath + f.shared;
+                        }
+                        return [2 /*return*/, data];
+                }
+            });
+        });
+    };
+    Client.prototype.fileUrlDownload = function (fileId) {
+        return this.basePath + "/api/storage/file/" + fileId + "/download?access_token=" + this._config.token;
+    };
+    Client.prototype.fileUrlStream = function (fileId) {
+        return this.basePath + "/api/storage/file/" + fileId + "/stream?access_token=" + this._config.token;
+    };
+    Client.prototype.onMessage = function (message) {
+        return __awaiter(this, void 0, void 0, function () {
+            var promise, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        this.log.debug('receive message: ', message);
+                        if (!(message.seq_reply > 0)) return [3 /*break*/, 1];
+                        if (this.queueRequest.has(message.seq_reply)) {
+                            promise = this.queueRequest.get(message.seq_reply);
+                            this.queueRequest.delete(message.seq_reply);
+                            if (message.status === Response.STATUS_OK) {
+                                promise.resolve(message.data);
+                            }
+                            else {
+                                promise.reject(message.error);
+                            }
+                        }
+                        return [3 /*break*/, 13];
+                    case 1:
+                        _a = message.event;
+                        switch (_a) {
+                            case WEBSOCKET_EVENT_HELLO: return [3 /*break*/, 2];
+                            case WEBSOCKET_EVENT_CALL: return [3 /*break*/, 4];
+                            case WEBSOCKET_EVENT_CHAT: return [3 /*break*/, 6];
+                            case WEBSOCKET_EVENT_USER_STATE: return [3 /*break*/, 8];
+                            case WEBSOCKET_EVENT_SIP: return [3 /*break*/, 9];
+                            case WEBSOCKET_EVENT_AGENT_STATUS: return [3 /*break*/, 10];
+                            case WEBSOCKET_EVENT_CHANNEL_STATUS: return [3 /*break*/, 11];
+                        }
+                        return [3 /*break*/, 12];
+                    case 2: return [4 /*yield*/, this.connected(message.data)];
+                    case 3:
+                        _b.sent();
+                        this.log.debug("opened session " + this.connectionInfo.sock_id + " for userId=" + this.connectionInfo.session.user_id);
+                        return [3 /*break*/, 13];
+                    case 4: return [4 /*yield*/, this.handleCallEvents(message.data.call)];
+                    case 5:
+                        _b.sent();
+                        return [3 /*break*/, 13];
+                    case 6: return [4 /*yield*/, this.handleChatEvents(message.data)];
+                    case 7:
+                        _b.sent();
+                        return [3 /*break*/, 13];
+                    case 8:
+                        this.handleUserStateEvent(message.data.state);
+                        return [3 /*break*/, 13];
+                    case 9:
+                        this.eventHandler.emit(WEBSOCKET_EVENT_SIP, message.data);
+                        return [3 /*break*/, 13];
+                    case 10:
+                        this.handleAgentStatus(message.data);
+                        return [3 /*break*/, 13];
+                    case 11:
+                        this.handleChannelEvents(message.data);
+                        return [3 /*break*/, 13];
+                    case 12:
+                        this.log.error("event " + message.event + " not handler");
+                        _b.label = 13;
+                    case 13: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Client.prototype.handleAgentStatus = function (e) {
+        if (this.agent && e.agent_id === this.agent.agentId) {
+            this.agent.setStatus(e);
+        }
+        this.eventHandler.emit(WEBSOCKET_EVENT_AGENT_STATUS, e, this.agent);
+    };
+    Client.prototype.handleChannelEvents = function (e) {
+        if (this.agent) {
+            e.timestamp = Date.now(); // bug
+            var task = this.agent.onChannelEvent(e) || undefined;
+            this.eventHandler.emit(TASK_EVENT, e.status, task);
+        }
+    };
+    Client.prototype.connected = function (info) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                this.connectionInfo = info;
+                if (!this.useWebPhone()) {
+                    return [2 /*return*/];
+                }
+                return [2 /*return*/, this.registerCallClient(new SipPhone(this.instanceId, this._config.debug))];
+            });
+        });
+    };
+    Client.prototype.callBySession = function (session) {
+        for (var _i = 0, _a = this.allCall(); _i < _a.length; _i++) {
+            var call = _a[_i];
+            if (call.sip === session) {
+                return call;
+            }
+        }
+    };
+    Client.prototype.onNewCallSession = function (session) {
+        return __awaiter(this, void 0, void 0, function () {
+            var call;
+            return __generator(this, function (_a) {
+                if (session.callId) {
+                    call = this.callById(session.callId);
+                }
+                else {
+                    call = this.callBySipId(session.id);
+                }
+                if (call) {
+                    call.setSip(session);
+                    this.checkAutoAnswer(call);
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    Client.prototype.checkAutoAnswer = function (call) {
+        if ( /*!document.hidden && */call.autoAnswer) {
+            return call.answer({
+                video: call.params.video,
+                screen: call.params.screen,
+                disableStun: call.params.disableStun,
+            });
+        }
+    };
+    Client.prototype.connectToSocket = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            try {
+                _this.socket = new Socket(_this._config.endpoint);
+                _this.socket.connect(_this._config.token);
+            }
+            catch (e) {
+                reject(e);
+                return;
+            }
+            _this.socket.on('message', _this.onMessage.bind(_this));
+            _this.socket.on('close', function (code) {
+                _this.log.error('socket close code: ', code);
+                _this.eventHandler.off('*');
+                if (code !== 1000) {
+                    _this.emit('disconnected', code);
+                    reject(new Error("close socket code: " + code));
+                }
+            });
+            _this.socket.on('open', function () {
+                resolve(null);
+                _this.emit('connected');
+            });
+        });
+    };
+    Client.prototype.handleUserStateEvent = function (event) {
+        this.eventHandler.emit(WEBSOCKET_EVENT_USER_STATE, event);
+    };
+    Client.prototype.handleCallEvents = function (event) {
+        return __awaiter(this, void 0, void 0, function () {
+            var call;
+            return __generator(this, function (_a) {
+                event.timestamp = Date.now(); // todo bug
+                switch (event.event) {
+                    case CallActions.Ringing:
+                        call = new Call(this, event);
+                        this.callStore.set(call.id, call);
+                        this.checkAutoAnswer(call);
+                        break;
+                    case CallActions.Active:
+                        call = this.callById(event.id);
+                        if (call) {
+                            call.setActive(event);
+                        }
+                        break;
+                    case CallActions.Bridge:
+                        call = this.callById(event.id);
+                        if (call) {
+                            call.setBridged(event);
+                        }
+                        break;
+                    case CallActions.Execute:
+                        call = this.callById(event.id);
+                        if (call) {
+                            call.setExecute(event.data);
+                        }
+                        break;
+                    case CallActions.DTMF:
+                        call = this.callById(event.id);
+                        if (call) {
+                            call.addDigit(event.data);
+                        }
+                        break;
+                    case CallActions.Voice:
+                        call = this.callById(event.id);
+                        if (call) {
+                            call.setVoice();
+                        }
+                        break;
+                    case CallActions.Silence:
+                        call = this.callById(event.id);
+                        if (call) {
+                            call.setSilence();
+                        }
+                        break;
+                    case CallActions.Hold:
+                        call = this.callById(event.id);
+                        if (call) {
+                            call.setHold(event);
+                        }
+                        break;
+                    case CallActions.Hangup:
+                        call = this.callById(event.id);
+                        if (call) {
+                            call.setHangup(event);
+                        }
+                        break;
+                    default:
+                        throw new Error('Unhandled action');
+                }
+                if (call) {
+                    this.eventHandler.emit(WEBSOCKET_EVENT_CALL, event.event, call);
+                    if (this.callDestroyed(call)) {
+                        this.destroyCall(call);
+                    }
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    Client.prototype.handleChatEvents = function (event) {
+        return __awaiter(this, void 0, void 0, function () {
+            var conversation, timestamp, inv, joined, message, e;
+            return __generator(this, function (_a) {
+                timestamp = Date.now() // todo bug
+                ;
+                switch (event.action) {
+                    case ChatActions.UserInvite:
+                        inv = event.data;
+                        conversation = new Conversation(this, inv.conversation_id, inv.title, inv.members, inv.messages, inv.variables);
+                        conversation.setInvite(inv.invite_id, timestamp);
+                        this.conversationStore.set(conversation.id, conversation);
+                        break;
+                    case ChatActions.Joined:
+                        joined = event.data;
+                        conversation = this.conversationById(joined.conversation_id);
+                        if (conversation) {
+                            conversation.setAnswered(joined.member.id, timestamp, joined.member);
+                        }
+                        break;
+                    case ChatActions.Message:
+                        message = event.data;
+                        message.timestamp = timestamp;
+                        conversation = this.conversationById(message.conversation_id);
+                        if (conversation) {
+                            conversation.newMessage(message);
+                        }
+                        break;
+                    case ChatActions.Close:
+                    case ChatActions.Leave:
+                    case ChatActions.Decline:
+                        e = event.data;
+                        conversation = this.conversationById(e.conversation_id);
+                        if (conversation) {
+                            conversation.setClosed(timestamp);
+                        }
+                        break;
+                    default:
+                }
+                if (conversation) {
+                    this.eventHandler.emit(WEBSOCKET_EVENT_CHAT, event.action, conversation);
+                    if (this.conversationDestroyed(conversation)) {
+                        this.destroyConversation(conversation);
+                    }
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    Client.prototype.hasAgentTask = function (task) {
+        if (!this.agent || !task) {
+            return false;
+        }
+        return this.agent.hasTask(task);
+    };
+    Client.prototype.destroyCall = function (call) {
+        // FIXME sync channel & call event
+        this.callStore.delete(call.id);
+        this.eventHandler.emit(WEBSOCKET_EVENT_CALL, CallActions.Destroy, call);
+    };
+    Client.prototype.destroyConversation = function (conv) {
+        // FIXME sync channel & call event
+        this.conversationStore.delete(conv.id);
+        this.eventHandler.emit(WEBSOCKET_EVENT_CHAT, ChatActions.Destroy, conv);
+    };
+    return Client;
+}(EventEmitter));
+export { Client };
+//# sourceMappingURL=client.js.map