@resolveio/server-lib 12.5.54 → 12.5.56

package/server-app.js

@@ -0,0 +1,739 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var http_1 = require("http");
+var express = require("express");
+var bodyParser = require("body-parser");
+var xmlParser = require("express-xml-bodyparser");
+var WebSocket = require("ws");
+var jwt = require("jsonwebtoken");
+var uuid_1 = require("uuid");
+// import * as SegfaultHandler from 'segfault-handler';
+var moment = require("moment");
+var common_1 = require("./util/common");
+var mongo_manager_1 = require("./managers/mongo.manager");
+var cron_manager_1 = require("./managers/cron.manager");
+var method_manager_1 = require("./managers/method.manager");
+var subscription_manager_1 = require("./managers/subscription.manager");
+var monitor_manager_1 = require("./managers/monitor.manager");
+var method_response_collection_1 = require("./collections/method-response.collection");
+var log_collection_1 = require("./collections/log.collection");
+var log_method_latency_collection_1 = require("./collections/log-method-latency.collection");
+var user_collection_1 = require("./collections/user.collection");
+var home_1 = require("./http/home");
+var auth_1 = require("./http/auth");
+var health_1 = require("./http/health");
+var index_1 = require("./index");
+var ResolveIOMainServer = /** @class */ (function () {
+    function ResolveIOMainServer(mainServer, serverConfig, clientRoutes, clientDir, sesMail, standardProgram, publicProgram) {
+        if (publicProgram === void 0) { publicProgram = false; }
+        var _this = this;
+        this._offlineUpdates = [];
+        this._msgQueue = [];
+        this._msgQueueRunning = false;
+        this.sesMail = false;
+        this.standardProgram = false;
+        this.publicProgram = false;
+        this._rebootFlag = false;
+        this.LOGGER = 'ERROR'; //ERROR / DEBUG
+        this._clientRoutes = [];
+        this._lastErrorMsg = null;
+        this._debugMsgRecv = 0;
+        this._debugMsgQueue = 0;
+        this._serverConfig = serverConfig;
+        this._clientRoutes = clientRoutes;
+        this._clientDir = clientDir;
+        this.sesMail = sesMail;
+        this.standardProgram = standardProgram;
+        this.publicProgram = publicProgram;
+        this._serverStartTime = new Date();
+        this._lastErrorMsg = null;
+        this._monitorManager = new monitor_manager_1.MonitorManager(mainServer, serverConfig);
+        this._monitorManagerFunction = new monitor_manager_1.MonitorManagerFunction();
+        setInterval(function () {
+            if (_this._subscriptionManager.getEnableDebug()) {
+                console.log(new Date(), 'Server App', 'Msg Queue Length', _this._msgQueue.length);
+                console.log(new Date(), 'Server App', 'Msg Recv Hits', _this._debugMsgRecv);
+                console.log(new Date(), 'Server App', 'Msg Queue Hits', _this._debugMsgQueue);
+            }
+            _this._debugMsgQueue = 0;
+            _this._debugMsgRecv = 0;
+        }, 60000);
+        process.on('unhandledRejection', function (error, rej) { return __awaiter(_this, void 0, void 0, function () {
+            var diffTimeSec;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        console.error(new Date(), 'Unhandled Rejection at Promise', [error, rej]);
+                        diffTimeSec = moment().diff(this._serverStartTime, 'seconds');
+                        if (!(error && error['name'] === 'MongoError' && error['message'] === 'not master')) return [3 /*break*/, 3];
+                        if (!(diffTimeSec > 60 && !this._lastErrorMsg)) return [3 /*break*/, 2];
+                        this._lastErrorMsg = new Date();
+                        setTimeout(function () {
+                            _this._lastErrorMsg = null;
+                        }, 60000);
+                        return [4 /*yield*/, this._methodManager.sendEmail('dev@resolveio.com', 'SERVER - Unhandled Rejection - Quitting NodeJS - ' + this._serverConfig['CLIENT_NAME'], JSON.stringify([error['name'], error['message'], error['stack']], null, 2))];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        process.exit(1);
+                        return [3 /*break*/, 7];
+                    case 3:
+                        if (!(error && error['name'] === 'MongoError' && error['message'] === 'not master and slaveOk=false')) return [3 /*break*/, 6];
+                        if (!(diffTimeSec > 60 && !this._lastErrorMsg)) return [3 /*break*/, 5];
+                        this._lastErrorMsg = new Date();
+                        setTimeout(function () {
+                            _this._lastErrorMsg = null;
+                        }, 60000);
+                        return [4 /*yield*/, this._methodManager.sendEmail('dev@resolveio.com', 'SERVER - Unhandled Rejection - Quitting NodeJS - ' + this._serverConfig['CLIENT_NAME'], JSON.stringify([error['name'], error['message'], error['stack']], null, 2))];
+                    case 4:
+                        _a.sent();
+                        _a.label = 5;
+                    case 5:
+                        process.exit(1);
+                        return [3 /*break*/, 7];
+                    case 6:
+                        if (error) {
+                            if (error['name'] !== 'StatusError' && error['message'] !== '') {
+                                if (diffTimeSec > 60 && !this._lastErrorMsg) {
+                                    this._lastErrorMsg = new Date();
+                                    setTimeout(function () {
+                                        _this._lastErrorMsg = null;
+                                    }, 60000);
+                                    this._methodManager.sendEmail('dev@resolveio.com', 'SERVER - Unhandled Rejection - ' + this._serverConfig['CLIENT_NAME'], JSON.stringify([error['name'], error['message'], error['stack']], null, 2));
+                                }
+                            }
+                        }
+                        _a.label = 7;
+                    case 7: return [2 /*return*/];
+                }
+            });
+        }); });
+        process.on('uncaughtException', function (error) { return __awaiter(_this, void 0, void 0, function () {
+            var diffTimeSec;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        console.error(error, 'Uncaught Exception thrown');
+                        diffTimeSec = moment().diff(this._serverStartTime, 'seconds');
+                        if (!(diffTimeSec > 60 && !this._lastErrorMsg)) return [3 /*break*/, 2];
+                        this._lastErrorMsg = new Date();
+                        setTimeout(function () {
+                            _this._lastErrorMsg = null;
+                        }, 60000);
+                        return [4 /*yield*/, this._methodManager.sendEmail('dev@resolveio.com', 'SERVER - Unhandled Exception - ' + this._serverConfig['CLIENT_NAME'], JSON.stringify([error['name'], error['message'], error['stack']], null, 2))];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        }); });
+        //PM2 wants to reboot/restart
+        process.on('SIGINT', function () {
+            _this._rebootFlag = true;
+            _this._serverHTTP.close();
+            _this.safeShutdown();
+        });
+        process.on('SIGTERM', function () {
+            _this._rebootFlag = true;
+            _this._serverHTTP.close();
+            _this.safeShutdown();
+        });
+        process.on('SIGQUIT', function () {
+            _this._rebootFlag = true;
+            _this._serverHTTP.close();
+            _this.safeShutdown();
+        });
+        if (this.LOGGER === 'DEBUG') {
+            console.log('Starting ResolveIO Server');
+        }
+        // Start express app
+        this._app = express();
+        // Use body parser for http call (login)
+        this._app.use(bodyParser.json({ limit: '50mb', reviver: common_1.dateReviver }));
+        this._app.use(bodyParser.urlencoded({ limit: '50mb', extended: true, parameterLimit: 1000000 }));
+        this._app.use(xmlParser());
+        // Set port
+        this._portHTTP = process.env.PORT_HTTP || serverConfig['PORT_HTTP'] || 8080;
+        this._portWSS = process.env.PORT_WSS || serverConfig['PORT_WSS'] || 8081;
+        if (this.LOGGER === 'DEBUG') {
+            console.log('Setup ports');
+        }
+        // Create http server and websock server
+        this.createServer();
+        if (this.LOGGER === 'DEBUG') {
+            console.log('Create server');
+        }
+        // Set CORS
+        this._app.use(function (req, res, next) {
+            // Website you wish to allow to connect
+            // res.setHeader('Access-Control-Allow-Origin', serverConfig['ROOT_URL']);
+            res.setHeader('Access-Control-Allow-Origin', '*');
+            // Request methods you wish to allow
+            // res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, PUT, PATCH, DELETE');
+            res.setHeader('Access-Control-Allow-Methods', 'GET, POST');
+            // Request headers you wish to allow
+            res.setHeader('Access-Control-Allow-Headers', 'X-Requested-With,content-type');
+            // Set to true if you need the website to include cookies in the requests sent
+            // to the API (e.g. in case you use sessions)
+            res.setHeader('Access-Control-Allow-Credentials', 'false');
+            // Pass to next layer of middleware
+            next();
+        });
+        if (this.LOGGER === 'DEBUG') {
+            console.log('Setup cors');
+        }
+        // Set up http login route
+        (0, auth_1.setupAuthRoutes)(this, this._app, serverConfig);
+        (0, health_1.setupHealthRoutes)(this._app, serverConfig);
+        if (serverConfig['CLIENT_NAME'] === 'ResolveIO' || this.standardProgram) {
+            (0, home_1.setupHomeRoutes)(this, this._app, serverConfig);
+        }
+        if (this.LOGGER === 'DEBUG') {
+            console.log('Setup express routes');
+        }
+    }
+    ResolveIOMainServer.prototype.safeShutdown = function () {
+        var _this = this;
+        console.log(new Date(), 'Safe Shutdown Command Received');
+        if (!this._monitorManagerFunction.getActiveMonitorFunctions().length &&
+            // (!this._monitorManagerFunction.getLastCompletedMonitorFunction() ||
+            // Date.now() >= this._monitorManagerFunction.getLastCompletedMonitorFunction().endTime.getTime() + 1500) &&
+            !this._msgQueue.length &&
+            !this._msgQueueRunning &&
+            !this._offlineUpdates.length) {
+            index_1.ResolveIOServer.getMongoConnection().close(false, function () {
+                console.log(new Date(), 'Safe Exit Complete, Process Exit');
+                process.exit(0);
+            });
+        }
+        else {
+            console.log(new Date(), 'Safe Exit In Progress', this._monitorManagerFunction.getActiveMonitorFunctions().length, 
+            // this._monitorManagerFunction.getLastCompletedMonitorFunction() ? this._monitorManagerFunction.getLastCompletedMonitorFunction().endTime : '',
+            this._msgQueue.length, this._msgQueueRunning, this._offlineUpdates.length);
+            setImmediate(function () {
+                _this.safeShutdown();
+            });
+        }
+    };
+    ResolveIOMainServer.prototype.getWS = function (id_ws) {
+        return Array.from(this._serverWSS.clients).filter(function (a) { return a['id_socket'] === id_ws; })[0];
+    };
+    ResolveIOMainServer.prototype.getWSList = function () {
+        var res = [];
+        this._serverWSS.clients.forEach(function (ws) {
+            res.push(ws['id_socket']);
+        });
+        return res;
+    };
+    ResolveIOMainServer.prototype.getWSUserList = function () {
+        var res = [];
+        this._serverWSS.clients.forEach(function (ws) {
+            res.push(ws['id_user']);
+        });
+        return res;
+    };
+    ResolveIOMainServer.prototype.getHTTPServer = function () {
+        return this._serverHTTP;
+    };
+    ResolveIOMainServer.prototype.getCronManager = function () {
+        return this._cronManager;
+    };
+    ResolveIOMainServer.prototype.getMethodManager = function () {
+        return this._methodManager;
+    };
+    ResolveIOMainServer.prototype.getSubscriptionManager = function () {
+        return this._subscriptionManager;
+    };
+    ResolveIOMainServer.prototype.getMonitorManager = function () {
+        return this._monitorManager;
+    };
+    ResolveIOMainServer.prototype.getRebootFlag = function () {
+        return this._rebootFlag;
+    };
+    ResolveIOMainServer.prototype.createServer = function () {
+        var _this = this;
+        // Start express server
+        this._serverHTTP = (0, http_1.createServer)(this._app);
+        this._serverHTTP.keepAliveTimeout = 65000;
+        this._serverHTTP.headersTimeout = 66000; // This should be bigger than `keepAliveTimeout + your server's expected response time`
+        // Start websocket server
+        // Verify client with token before opening socket
+        this._serverWSS = new WebSocket.Server({
+            port: this._portWSS,
+            verifyClient: this.publicProgram ? null : function (info, cb) { return __awaiter(_this, void 0, void 0, function () {
+                var infoData, token;
+                var _this = this;
+                return __generator(this, function (_a) {
+                    if (this._rebootFlag) {
+                        cb(false, 409, 'Unable To Process');
+                    }
+                    else {
+                        if (this.LOGGER === 'DEBUG') {
+                            console.log('Verify Client', info, cb);
+                        }
+                        infoData = info.req.headers['sec-websocket-protocol'].split(/,/);
+                        if (info.origin !== this._serverConfig['ROOT_URL'] && info.origin !== this._serverConfig['SEC_ROOT_URL'] && info.origin !== this._serverConfig['RESOLVEIO_URL'] && info.origin !== this._serverConfig['RESOLVEIO_SECONDARY_URL']) {
+                            cb(false, 401, 'Unauthorized');
+                        }
+                        else {
+                            token = infoData[0];
+                            if (!token) {
+                                cb(false, 401, 'Unauthorized');
+                            }
+                            else {
+                                jwt.verify(token, this._serverConfig['JWT_SECRET'], function (err, decoded) { return __awaiter(_this, void 0, void 0, function () {
+                                    var user, err_1;
+                                    return __generator(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0:
+                                                if (!err) return [3 /*break*/, 1];
+                                                cb(false, 401, 'Unauthorized');
+                                                return [3 /*break*/, 5];
+                                            case 1:
+                                                info.req['id_user'] = decoded['id_user'];
+                                                _a.label = 2;
+                                            case 2:
+                                                _a.trys.push([2, 4, , 5]);
+                                                return [4 /*yield*/, user_collection_1.Users.findById(decoded['id_user'])];
+                                            case 3:
+                                                user = _a.sent();
+                                                if (user) {
+                                                    info.req['user'] = user.fullname;
+                                                    info.req['user_readonly'] = user.readonly || false;
+                                                    info.req['doc_user'] = user;
+                                                    cb(true);
+                                                }
+                                                else {
+                                                    cb(false);
+                                                }
+                                                return [3 /*break*/, 5];
+                                            case 4:
+                                                err_1 = _a.sent();
+                                                cb(false);
+                                                return [3 /*break*/, 5];
+                                            case 5: return [2 /*return*/];
+                                        }
+                                    });
+                                }); });
+                            }
+                        }
+                    }
+                    return [2 /*return*/];
+                });
+            }); }
+        });
+        // Start MongoDB Connection
+        this.setUpMongo();
+    };
+    ResolveIOMainServer.prototype.setUpMongo = function () {
+        if (this.LOGGER === 'DEBUG') {
+            console.log('Start Managers');
+        }
+        // Start Managers
+        this._subscriptionManager = new subscription_manager_1.SubscriptionManager(this, this._serverWSS, this._serverConfig, this._monitorManagerFunction);
+        this._methodManager = new method_manager_1.MethodManager(this, this._serverConfig, this._clientDir, this._monitorManagerFunction);
+        this._cronManager = new cron_manager_1.CronManager(this);
+        if (this.LOGGER === 'DEBUG') {
+            console.log('End Managers');
+        }
+        this.listen();
+    };
+    // Listen to port for websocket
+    ResolveIOMainServer.prototype.listen = function () {
+        var _this = this;
+        this._serverHTTP.listen(this._portHTTP, function () {
+            console.log('Running server on port %s', _this._portHTTP);
+        });
+        this._serverWSS.on('listening', function () {
+            console.log('Running server on port %s', _this._portWSS);
+        });
+        // On websocket connection (already verified)
+        this._serverWSS.on('connection', function (ws, req) {
+            if (!_this.publicProgram) {
+                // Get user from token
+                ws['id_user'] = req['id_user'];
+                ws['user'] = req['user'];
+                ws['user_readonly'] = req['user_readonly'];
+                ws['doc_user'] = req['doc_user'];
+                if (ws['user'] !== 'Admin' && _this._serverConfig['CLIENT_NAME'] !== 'ResolveIO') {
+                    _this.getMethodManager().callMethodInternal.call(_this.getMethodManager(), 'supportCreateBillingUser', {
+                        id_user: ws['id_user'],
+                        user: ws['user'],
+                        date: new Date(),
+                        client: index_1.ResolveIOServer.getClientName()
+                    });
+                }
+            }
+            var idSocket = '';
+            while (!idSocket || Array.from(_this._serverWSS.clients).some(function (a) { return a['id_socket'] === idSocket; })) {
+                idSocket = (0, uuid_1.v4)();
+            }
+            ws['id_socket'] = idSocket;
+            ws['retryCnt'] = 0;
+            _this._subscriptionManager.createLoggedInUser(idSocket).then(function () {
+                setTimeout(function () {
+                    ws['pingTime'] = new Date();
+                    ws.ping(function () { });
+                }, 5000);
+            });
+            if (_this.LOGGER === 'DEBUG') {
+                console.log('Connection from: ' + req['user']);
+            }
+            // Use for keeping connection alive (ping/pong)
+            ws['isAlive'] = true;
+            ws.on('pong', function () {
+                ws['isAlive'] = true;
+                ws['pongTime'] = new Date();
+                ws['latency'] = moment.duration(moment(ws['pongTime']).diff(ws['pingTime'])).asMilliseconds();
+                _this._subscriptionManager.loggedInLatency(ws);
+            });
+            // On data received (message)
+            ws.on('message', function (message) { return __awaiter(_this, void 0, void 0, function () {
+                var parseErrorFound, socketData, messageRoute_1, messageDate, messageId, type, subType, pub, serverRes, offlineUpdates, i, update, data, serverResMethod, updateRoute, updateDate, updateMessageId, updateType, method, methodLatencyId, err_2;
+                var _a;
+                var _this = this;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            if (this.LOGGER === 'DEBUG') {
+                                console.log('Message from: ' + ws['user'], message);
+                            }
+                            this._debugMsgRecv += 1;
+                            parseErrorFound = false;
+                            socketData = [];
+                            try {
+                                socketData = JSON.parse(message, common_1.dateReviver);
+                            }
+                            catch (e) {
+                                console.log('Error - JSON.parse', message);
+                                this._methodManager.sendEmail('dev@resolveio.com', 'SERVER - JSON Parse Error - ' + this._serverConfig['CLIENT_NAME'], JSON.stringify([message, e]));
+                                parseErrorFound = true;
+                            }
+                            if (!!parseErrorFound) return [3 /*break*/, 11];
+                            if (socketData[0] === 'ping') {
+                                if (ws && ws.readyState === ws.OPEN) {
+                                    ws.send('pong', function (error) {
+                                        if (error) {
+                                            console.log('Error on WS: ', error);
+                                            if (_this._subscriptionManager.getEnableDebug()) {
+                                                console.log(new Date(), 'Server App', 'Error WS Pong');
+                                            }
+                                            _this.unsubscribeWS(ws);
+                                        }
+                                    });
+                                }
+                                return [2 /*return*/];
+                            }
+                            messageRoute_1 = socketData[0];
+                            if (!this.publicProgram && this._clientRoutes.some(function (a) { return messageRoute_1.includes(a); }) && !ws['doc_user'].roles.groups.some(function (a) { return a.views.some(function (b) { return messageRoute_1.includes(b); }); }) && !ws['doc_user'].roles.super_admin) {
+                                return [2 /*return*/];
+                            }
+                            messageDate = socketData[1];
+                            messageId = socketData[2];
+                            type = socketData[3];
+                            if (!(type === 'subscription')) return [3 /*break*/, 1];
+                            subType = socketData[4];
+                            pub = socketData[5];
+                            // Subscribe
+                            if (subType === 'sub') {
+                                this._subscriptionManager.subscribe(messageRoute_1, messageDate, ws, messageId, pub, socketData.slice(6));
+                            }
+                            // Unsubscribe
+                            else {
+                                this._subscriptionManager.unsubscribe(messageRoute_1, messageDate, ws, messageId, pub, socketData.slice(6));
+                            }
+                            return [3 /*break*/, 11];
+                        case 1:
+                            if (!(!this.publicProgram && type === 'offline')) return [3 /*break*/, 10];
+                            serverRes = {
+                                messageId: messageId,
+                                hasError: false,
+                                data: 'ACK'
+                            };
+                            if (ws && ws.readyState === ws.OPEN) {
+                                ws.send(JSON.stringify(serverRes), function (error) {
+                                    if (error) {
+                                        console.log('Error on WS: ', error);
+                                        if (_this._subscriptionManager.getEnableDebug()) {
+                                            console.log(new Date(), 'Server App', 'Error WS Offline Ack Main');
+                                        }
+                                        _this.unsubscribeWS(ws);
+                                    }
+                                });
+                            }
+                            this._offlineUpdates.push(ws);
+                            offlineUpdates = socketData[4];
+                            i = 0;
+                            _b.label = 2;
+                        case 2:
+                            if (!(i < offlineUpdates.length)) return [3 /*break*/, 9];
+                            update = offlineUpdates[i];
+                            data = update.data;
+                            serverResMethod = {
+                                messageId: update.data[2],
+                                hasError: false,
+                                data: 'ACK'
+                            };
+                            if (ws && ws.readyState === ws.OPEN) {
+                                ws.send(JSON.stringify(serverResMethod), function (error) {
+                                    if (error) {
+                                        console.log('Error on WS: ', error);
+                                        if (_this._subscriptionManager.getEnableDebug()) {
+                                            console.log(new Date(), 'Server App', 'Error WS Offline Ack Each');
+                                        }
+                                        _this.unsubscribeWS(ws);
+                                    }
+                                });
+                            }
+                            updateRoute = data.shift();
+                            updateDate = data.shift();
+                            updateMessageId = data.shift();
+                            updateType = data.shift();
+                            method = data.shift();
+                            methodLatencyId = (0, mongo_manager_1.objectIdHexString)();
+                            log_method_latency_collection_1.LogMethodLatencies.create({
+                                _id: methodLatencyId,
+                                __v: 0,
+                                date_start: new Date(),
+                                date_end: null,
+                                latency_ms: 0,
+                                method: method
+                            });
+                            if (method !== 'reportBuilderGetResults' && method !== 'reportBuilderGetDistinctValue' && method !== 'reportBuilderBuildTree' && method !== 'generatePDF' && method !== 'getWOOfflineData' && method !== 'countQuery' && method !== 'countWithQuery' && method !== 'countCollectionWithQuery' && method !== 'find' && method !== 'findOne' && method !== 'findWithOptions' && method !== 'getDrivers' && method !== 'processAirdropDistribution') {
+                                log_collection_1.Logs.insertOne({
+                                    _id: (0, mongo_manager_1.objectIdHexString)(),
+                                    type: 'client-request',
+                                    collection: '',
+                                    id_document: '',
+                                    payload: (0, common_1.getBinarySize)(JSON.stringify(data)) < 200000 ? JSON.stringify(data, null, 2) : 'Too Big',
+                                    method: method,
+                                    id_user: ws['id_user'] || '',
+                                    user: ws['user'] || '',
+                                    messageId: messageId,
+                                    route: messageRoute_1
+                                });
+                            }
+                            if (!this._methodManager._methods[method]) return [3 /*break*/, 7];
+                            _b.label = 3;
+                        case 3:
+                            _b.trys.push([3, 5, , 6]);
+                            return [4 /*yield*/, (_a = this._methodManager.callMethodInternal).call.apply(_a, __spreadArray([Object.assign({}, this._methodManager, { id_user: ws['id_user'], user: ws['user'], id_ws: ws['id_socket'] }), method], data, false))];
+                        case 4:
+                            _b.sent();
+                            return [3 /*break*/, 6];
+                        case 5:
+                            err_2 = _b.sent();
+                            console.log(new Date(), 'Offline Error', JSON.stringify(err_2, null, 2));
+                            return [3 /*break*/, 6];
+                        case 6:
+                            if (method === 'updateDocumentOffline' || method === 'updateDocumentPropsOffline') {
+                                index_1.ResolveIOServer.getMongoManager().invalidateQueryCache(data[0]);
+                            }
+                            return [3 /*break*/, 8];
+                        case 7:
+                            console.log('Offline - Could not find method: ' + method);
+                            _b.label = 8;
+                        case 8:
+                            i++;
+                            return [3 /*break*/, 2];
+                        case 9:
+                            this._offlineUpdates.splice(this._offlineUpdates.map(function (a) { return a['id_socket']; }).indexOf(ws['id_socket']), 1);
+                            return [3 /*break*/, 11];
+                        case 10:
+                            this._msgQueue.splice(0, 0, {
+                                ws: ws,
+                                data: socketData
+                            });
+                            _b.label = 11;
+                        case 11: return [2 /*return*/];
+                    }
+                });
+            }); });
+            ws.on('close', function () {
+                _this.unsubscribeWS(ws);
+                if (_this._subscriptionManager.getEnableDebug()) {
+                    console.log(new Date(), 'Server App', 'WS Close');
+                }
+            });
+            ws.on('error', function (error) {
+                console.log(new Date(), ws['user'], ws['id_socket'], 'WS Error');
+                _this.unsubscribeWS(ws);
+            });
+        });
+        // Keep alive timer to ping/pong
+        setInterval(function () {
+            _this._serverWSS.clients.forEach(function (ws) {
+                if (ws['pingTime'] && Date.now() - ws['pingTime'].getTime() >= 20000) {
+                    if (ws['isAlive'] === false) {
+                        ws['retryCnt']++;
+                        if (ws['retryCnt'] >= 3) {
+                            _this.unsubscribeWS(ws);
+                            console.log(new Date(), ws['user'], ws['id_socket'], 'Ping Retry', ws['retryCnt'], ws['pingTime'], ws['pongTime']);
+                        }
+                        else {
+                            ws['pingTime'] = new Date();
+                            ws.ping(function () { });
+                        }
+                    }
+                    else {
+                        ws['retryCnt'] = 0;
+                        ws['isAlive'] = false;
+                        ws['pingTime'] = new Date();
+                        ws.ping(function () { });
+                    }
+                }
+            });
+        }, 20000);
+        setInterval(function () {
+            var _a;
+            if (!_this._msgQueueRunning) {
+                if (_this._msgQueue.length) {
+                    _this._msgQueueRunning = true;
+                    _this._debugMsgQueue += 1;
+                    var msg = _this._msgQueue.pop();
+                    var data = msg.data;
+                    var ws_1 = msg.ws;
+                    var messageRoute = data.shift();
+                    var messageDate = data.shift();
+                    var messageId = data.shift();
+                    var type = data.shift();
+                    // Method call
+                    if (type === 'method') {
+                        var method = data.shift();
+                        if (ws_1['user_readonly']) {
+                            return;
+                        }
+                        var methodLatencyId = (0, mongo_manager_1.objectIdHexString)();
+                        log_method_latency_collection_1.LogMethodLatencies.create({
+                            _id: methodLatencyId,
+                            __v: 0,
+                            date_start: new Date(),
+                            date_end: null,
+                            latency_ms: 0,
+                            method: method
+                        });
+                        if (method !== 'reportBuilderGetResults' && method !== 'reportBuilderGetDistinctValue' && method !== 'reportBuilderBuildTree' && method !== 'generatePDF' && method !== 'getWOOfflineData' && method !== 'countQuery' && method !== 'countWithQuery' && method !== 'countCollectionWithQuery' && method !== 'find' && method !== 'findOne' && method !== 'findWithOptions' && method !== 'getDrivers' && method !== 'processAirdropDistribution') {
+                            log_collection_1.Logs.insertOne({
+                                _id: (0, mongo_manager_1.objectIdHexString)(),
+                                type: 'client-request',
+                                collection: '',
+                                id_document: '',
+                                payload: (0, common_1.getBinarySize)(JSON.stringify(data)) < 200000 ? JSON.stringify(data, null, 2) : 'Too Big',
+                                method: method,
+                                id_user: ws_1['id_user'] || '',
+                                user: ws_1['user'] || '',
+                                messageId: messageId,
+                                route: messageRoute
+                            });
+                        }
+                        var serverRes = {
+                            messageId: messageId,
+                            hasError: false,
+                            data: 'ACK'
+                        };
+                        if (ws_1 && ws_1.readyState === ws_1.OPEN) {
+                            ws_1.send(JSON.stringify(serverRes), function (error) {
+                                if (error) {
+                                    console.log('Error on WS: ', error);
+                                    _this.unsubscribeWS(ws_1);
+                                }
+                            });
+                        }
+                        if (_this._methodManager._methods[method]) {
+                            (_a = _this._methodManager).callMethod.apply(_a, __spreadArray([methodLatencyId, ws_1, messageDate, messageId, method], data, false));
+                        }
+                        else {
+                            console.log('Could not find method: ' + method);
+                        }
+                    }
+                    else if (type === 'methodResponse') {
+                        var method = data.shift();
+                        method_response_collection_1.MethodResponses.findOne({ $and: [
+                                { id_user: ws_1['id_user'] },
+                                { message_id: messageId },
+                                { method: method },
+                                { date: messageDate }
+                            ] }).then(function (res) {
+                            if (res) {
+                                if (ws_1 && ws_1.readyState === ws_1.OPEN) {
+                                    ws_1.send(JSON.stringify(res.response), function (error) {
+                                        if (error) {
+                                            console.log('Error on WS: ', error);
+                                            _this.unsubscribeWS(ws_1);
+                                        }
+                                    });
+                                }
+                            }
+                        }, function (err) { });
+                    }
+                    _this._msgQueueRunning = false;
+                }
+            }
+        }, 25);
+    };
+    ResolveIOMainServer.prototype.unsubscribeWS = function (ws) {
+        if (this._subscriptionManager.getEnableDebug()) {
+            console.log(new Date(), 'Server App', 'Unsub WS', ws['user'], ws['id_socket']);
+        }
+        this._subscriptionManager.unsubscribeAll(ws);
+    };
+    ResolveIOMainServer.prototype.getApp = function () {
+        return this._app;
+    };
+    ResolveIOMainServer.prototype.getServerConfig = function () {
+        return this._serverConfig;
+    };
+    return ResolveIOMainServer;
+}());
+exports.default = ResolveIOMainServer;
+
+//# sourceMappingURL=server-app.js.map