@resolveio/server-lib 9.0.34 → 9.0.35

package/managers/method.manager.js

@@ -1,31 +1,78 @@
-import { loadCollectionMethods } from '../methods/collections';
-import { loadLogMethods } from '../methods/logs';
-import { loadCounterMethods } from '../methods/counters';
-import { loadPDFMethods } from '../methods/pdf';
-import { loadAWSMethods } from '../methods/aws';
-import { loadCloudConvertMethods } from '../methods/cloudconvert';
-import * as path from 'path';
-import * as fs from 'fs';
-import * as nodemailer from 'nodemailer';
-import * as aws from 'aws-sdk';
-import { loadAccountMethods } from '../methods/accounts';
-import { loadServerInit } from '../fixtures/init';
-import { loadServerCronJobs } from '../fixtures/cron-jobs';
-import { loadCronJobMethods } from '../methods/cron-jobs';
-import { loadFlagMethods } from '../methods/flags';
-import { MethodResponses } from '../collections/method-response.collection';
-import { deepCopy, getBinarySize } from '../util/common';
-import { Logs } from '../collections/log.collection';
-import { LogMethodLatencies } from '../collections/log-method-latency.collection';
-import * as moment from 'moment';
-import { loadReportBuilderMethods } from '../methods/report-builder';
-import { loadSupportMethods } from '../methods/support';
-import { loadMonitorMethods } from '../methods/monitor';
-import { EmailHistories } from '../collections/email-history.collection';
-import { objectIdHexString } from './mongo.manager';
-const Verifier = require('email-verifier');
-export class MethodManager {
-    constructor(mainServer, serverConfig, clientDir) {
+"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 (_) 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 __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MethodManager = void 0;
+var collections_1 = require("../methods/collections");
+var logs_1 = require("../methods/logs");
+var counters_1 = require("../methods/counters");
+var pdf_1 = require("../methods/pdf");
+var aws_1 = require("../methods/aws");
+var cloudconvert_1 = require("../methods/cloudconvert");
+var path = require("path");
+var fs = require("fs");
+var nodemailer = require("nodemailer");
+var aws = require("aws-sdk");
+var accounts_1 = require("../methods/accounts");
+var init_1 = require("../fixtures/init");
+var cron_jobs_1 = require("../fixtures/cron-jobs");
+var cron_jobs_2 = require("../methods/cron-jobs");
+var flags_1 = require("../methods/flags");
+var method_response_collection_1 = require("../collections/method-response.collection");
+var common_1 = require("../util/common");
+var log_collection_1 = require("../collections/log.collection");
+var log_method_latency_collection_1 = require("../collections/log-method-latency.collection");
+var moment = require("moment");
+var report_builder_1 = require("../methods/report-builder");
+var support_1 = require("../methods/support");
+var monitor_1 = require("../methods/monitor");
+var email_history_collection_1 = require("../collections/email-history.collection");
+var mongo_manager_1 = require("./mongo.manager");
+var Verifier = require('email-verifier');
+var MethodManager = /** @class */ (function () {
+    function MethodManager(mainServer, serverConfig, clientDir) {
+        var _this = this;
         this._methods = {};
         this._sendQueue = [];
         this._runningQueue = false;
@@ -33,21 +80,21 @@ export class MethodManager {
         this.serverConfig = serverConfig;
         this.clientDir = clientDir;
         // Fixtures
-        loadServerInit();
-        loadServerCronJobs();
+        init_1.loadServerInit();
+        cron_jobs_1.loadServerCronJobs();
         // Methods
-        loadAccountMethods(this);
-        loadAWSMethods(this);
-        loadCloudConvertMethods(this);
-        loadCollectionMethods(this);
-        loadCounterMethods(this);
-        loadLogMethods(this);
-        loadPDFMethods(this);
-        loadCronJobMethods(this);
-        loadFlagMethods(this);
-        loadReportBuilderMethods(this);
-        loadSupportMethods(this);
-        loadMonitorMethods(this);
+        accounts_1.loadAccountMethods(this);
+        aws_1.loadAWSMethods(this);
+        cloudconvert_1.loadCloudConvertMethods(this);
+        collections_1.loadCollectionMethods(this);
+        counters_1.loadCounterMethods(this);
+        logs_1.loadLogMethods(this);
+        pdf_1.loadPDFMethods(this);
+        cron_jobs_2.loadCronJobMethods(this);
+        flags_1.loadFlagMethods(this);
+        report_builder_1.loadReportBuilderMethods(this);
+        support_1.loadSupportMethods(this);
+        monitor_1.loadMonitorMethods(this);
         if (mainServer.sesMail) {
             this._mailer = nodemailer.createTransport({
                 SES: new aws.SES({
@@ -171,28 +218,28 @@ export class MethodManager {
             secretAccessKey: serverConfig.AWSSECRETACCESSKEY,
             region: serverConfig.AWSREGION
         });
-        setInterval(() => {
-            if (!this._runningQueue) {
-                if (this._sendQueue.length) {
-                    this._runningQueue = true;
-                    for (let i = this._sendQueue.length - 1; i >= 0; i--) {
-                        let ws = this._mainServer.getWS(this._sendQueue[i].id_ws);
+        setInterval(function () {
+            if (!_this._runningQueue) {
+                if (_this._sendQueue.length) {
+                    _this._runningQueue = true;
+                    var _loop_1 = function (i) {
+                        var ws = _this._mainServer.getWS(_this._sendQueue[i].id_ws);
                         if (ws && ws.readyState === ws.OPEN) {
                             if (ws.bufferedAmount < 20480) {
-                                let sendItem = this._sendQueue.pop();
-                                ws.send(JSON.stringify(sendItem.data), (error) => {
+                                var sendItem = _this._sendQueue.pop();
+                                ws.send(JSON.stringify(sendItem.data), function (error) {
                                     if (error) {
                                         console.log('Error on WS: ', error);
-                                        this._mainServer.unsubscribeWS(ws);
+                                        _this._mainServer.unsubscribeWS(ws);
                                     }
                                 });
                                 if (sendItem.method !== 'reportBuilderGetResults' && sendItem.method !== 'reportBuilderGetDistinctValue' && sendItem.method !== 'reportBuilderBuildTree' && sendItem.method !== 'generatePDF' && sendItem.method !== 'getWOOfflineData' && sendItem.method !== 'countQuery' && sendItem.method !== 'countWithQuery' && sendItem.method !== 'countCollectionWithQuery' && sendItem.method !== 'find' && sendItem.method !== 'findOne' && sendItem.method !== 'findWithOptions' && sendItem.method !== 'setWSAppVersion' && sendItem.method !== 'uploadFileAndSave' && sendItem.method !== 'getDrivers') {
-                                    Logs.create({
-                                        _id: objectIdHexString(),
+                                    log_collection_1.Logs.create({
+                                        _id: mongo_manager_1.objectIdHexString(),
                                         type: 'client-response',
                                         collection: '',
                                         id_document: '',
-                                        payload: getBinarySize(JSON.stringify([sendItem.methodData, sendItem.data])) < 200000 ? JSON.stringify([sendItem.methodData, sendItem.data], null, 2) : 'Too Big',
+                                        payload: common_1.getBinarySize(JSON.stringify([sendItem.methodData, sendItem.data])) < 200000 ? JSON.stringify([sendItem.methodData, sendItem.data], null, 2) : 'Too Big',
                                         method: sendItem.method,
                                         id_user: ws['id_user'],
                                         user: ws['user'],
@@ -200,35 +247,43 @@ export class MethodManager {
                                         route: ''
                                     });
                                 }
-                                MethodResponses.create({
-                                    _id: objectIdHexString(),
+                                method_response_collection_1.MethodResponses.create({
+                                    _id: mongo_manager_1.objectIdHexString(),
                                     __v: 0,
                                     id_user: ws['id_user'],
                                     message_id: sendItem.data.messageId,
-                                    response: getBinarySize(JSON.stringify(sendItem.data)) < 200000 ? sendItem.data : 'Too Big',
+                                    response: common_1.getBinarySize(JSON.stringify(sendItem.data)) < 200000 ? sendItem.data : 'Too Big',
                                     method: sendItem.method,
                                     date: sendItem.date
                                 });
                             }
                         }
                         else {
-                            this._sendQueue.splice(i, 1);
+                            _this._sendQueue.splice(i, 1);
                         }
+                    };
+                    for (var i = _this._sendQueue.length - 1; i >= 0; i--) {
+                        _loop_1(i);
                     }
-                    this._runningQueue = false;
+                    _this._runningQueue = false;
                 }
             }
         }, 10);
     }
-    getMainServer() {
+    MethodManager.prototype.getMainServer = function () {
         return this._mainServer;
-    }
+    };
     // Add methods to private methods object
-    methods(method) {
+    MethodManager.prototype.methods = function (method) {
         this._methods = Object.assign(this._methods, method);
-    }
-    callMethodCron(method, ...methodData) {
-        let that = this;
+    };
+    MethodManager.prototype.callMethodCron = function (method) {
+        var _a;
+        var methodData = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            methodData[_i - 1] = arguments[_i];
+        }
+        var that = this;
         if (!that._methods[method]) {
             console.log('No Method: ' + method);
             that.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + that.serverConfig['CLIENT_NAME'], 'No Method: ' + method);
@@ -246,10 +301,10 @@ export class MethodManager {
                 return;
             }
             else {
-                let valObj = {};
-                let valKeys = Object.keys(that._methods[method].check._schema);
-                let rootKeys = valKeys.filter(a => !a.includes('.'));
-                for (let i = 0; i < methodData.length; i++) {
+                var valObj = {};
+                var valKeys = Object.keys(that._methods[method].check._schema);
+                var rootKeys = valKeys.filter(function (a) { return !a.includes('.'); });
+                for (var i = 0; i < methodData.length; i++) {
                     valObj[rootKeys[i]] = methodData[i];
                 }
                 try {
@@ -264,57 +319,59 @@ export class MethodManager {
                 }
             }
         }
-        that._methods[method].function.call(Object.assign({}, that, MethodManager.prototype, { id_user: '', user: '', id_ws: '' }), ...methodData).catch(methodErrs => {
+        (_a = that._methods[method].function).call.apply(_a, __spreadArrays([Object.assign({}, that, MethodManager.prototype, { id_user: '', user: '', id_ws: '' })], methodData)).catch(function (methodErrs) {
             that.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + that.serverConfig['CLIENT_NAME'], 'Error Detected During Method ' + method + ' - (callMethodCron)\n\nData \n' + JSON.stringify(methodData, null, 2) + '\n\nErrors\n' + JSON.stringify(methodErrs, null, 2));
         });
-    }
-    callMethodQueue(update) {
+    };
+    MethodManager.prototype.callMethodQueue = function (update) {
+        var _this = this;
         // console.log('Call Method Queue', update);
-        return new Promise((resolve, reject) => {
-            let updateCopy = deepCopy(update);
-            let that = this;
+        return new Promise(function (resolve, reject) {
+            var _a;
+            var updateCopy = common_1.deepCopy(update);
+            var that = _this;
             if (!that._methods[update.method]) {
                 console.log('No Method: ' + update.method);
                 that.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + that.serverConfig['CLIENT_NAME'], 'No Method: ' + update.method);
-                let serverRes = {
+                var serverRes = {
                     messageId: update.messageId,
                     hasError: true,
                     data: 'Internal Error'
                 };
-                this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
-                LogMethodLatencies.deleteOne({ _id: update.id_methodLatency });
+                _this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
+                log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: update.id_methodLatency });
                 return resolve('No Method: ' + update.method);
             }
             if ((update.method_data.length > 1 || update.method_data[0]) && !that._methods[update.method].skipValidation) {
                 if (!that._methods[update.method].check) {
                     console.error('No Check Function For Method ' + update.method);
                     that.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + that.serverConfig['CLIENT_NAME'], 'No Check Function For Method ' + update.method);
-                    let serverRes = {
+                    var serverRes = {
                         messageId: update.messageId,
                         hasError: true,
                         data: 'Internal Error'
                     };
-                    this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
-                    LogMethodLatencies.deleteOne({ _id: update.id_methodLatency });
+                    _this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
+                    log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: update.id_methodLatency });
                     return resolve('No Check Function For Method ' + update.method);
                 }
                 else if (!that._methods[update.method].check._schema) {
                     console.error('No Check Schema For Method ' + update.method);
                     that.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + that.serverConfig['CLIENT_NAME'], 'No Check Function For Method ' + update.method);
-                    let serverRes = {
+                    var serverRes = {
                         messageId: update.messageId,
                         hasError: true,
                         data: 'Internal Error'
                     };
-                    this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
-                    LogMethodLatencies.deleteOne({ _id: update.id_methodLatency });
+                    _this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
+                    log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: update.id_methodLatency });
                     return resolve('No Check Schema For Method ' + update.method);
                 }
                 else {
-                    let valObj = {};
-                    let valKeys = Object.keys(that._methods[update.method].check._schema);
-                    let rootKeys = valKeys.filter(a => !a.includes('.'));
-                    for (let i = 0; i < update.method_data.length; i++) {
+                    var valObj = {};
+                    var valKeys = Object.keys(that._methods[update.method].check._schema);
+                    var rootKeys = valKeys.filter(function (a) { return !a.includes('.'); });
+                    for (var i = 0; i < update.method_data.length; i++) {
                         valObj[rootKeys[i]] = update.method_data[i];
                     }
                     try {
@@ -324,97 +381,112 @@ export class MethodManager {
                         if (errors) {
                             console.error('Error in Method Check (' + update.method + ')', errors);
                             that.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + that.serverConfig['CLIENT_NAME'], 'Match Error On Method ' + update.method + '\n\nData Being Checked\n' + JSON.stringify(valObj, null, 2) + '\n\nErrors\n' + JSON.stringify(errors, null, 2));
-                            let serverRes = {
+                            var serverRes = {
                                 messageId: update.messageId,
                                 hasError: true,
                                 data: 'Internal Error'
                             };
-                            this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
-                            LogMethodLatencies.deleteOne({ _id: update.id_methodLatency });
+                            _this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
+                            log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: update.id_methodLatency });
                             return resolve('Error in Method Check (' + update.method + ')');
                         }
                     }
                 }
             }
-            let timeout = setTimeout(() => {
+            var timeout = setTimeout(function () {
                 console.error('Timeout on method', update);
-                this.callMethodInternal('insertErrorLog', 'Timeout on method: ', [update]);
+                _this.callMethodInternal('insertErrorLog', 'Timeout on method: ', [update]);
                 resolve('Timeout');
             }, 5000);
             // console.log('Run Method', update.method);
-            that._methods[update.method].function.call(Object.assign({}, that, MethodManager.prototype, { id_user: update.id_user, user: update.user, id_ws: update.id_ws }), ...update.method_data).catch(methodErrs => {
+            (_a = that._methods[update.method].function).call.apply(_a, __spreadArrays([Object.assign({}, that, MethodManager.prototype, { id_user: update.id_user, user: update.user, id_ws: update.id_ws })], update.method_data)).catch(function (methodErrs) {
                 that.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + that.serverConfig['CLIENT_NAME'], 'Error Detected During Method ' + update.method + ' - (callMethodQueue)\n\nData \n' + JSON.stringify(update.method_data, null, 2) + '\n\nErrors\n' + JSON.stringify(methodErrs, null, 2));
-            }).then(async (res) => {
-                let serverRes = {
-                    messageId: update.messageId,
-                    hasError: false,
-                    data: res
-                };
-                this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
-                clearTimeout(timeout);
-                let latency = await LogMethodLatencies.findById(update.id_methodLatency);
-                if (latency) {
-                    LogMethodLatencies.updateOne({ _id: update.id_methodLatency }, { $set: { date_end: new Date(), latency_ms: moment().diff(moment(latency.date_start), 'milliseconds', true) } });
-                }
-                resolve(serverRes);
-            }, err => {
-                let serverRes = {
+            }).then(function (res) { return __awaiter(_this, void 0, void 0, function () {
+                var serverRes, latency;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            serverRes = {
+                                messageId: update.messageId,
+                                hasError: false,
+                                data: res
+                            };
+                            this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
+                            clearTimeout(timeout);
+                            return [4 /*yield*/, log_method_latency_collection_1.LogMethodLatencies.findById(update.id_methodLatency)];
+                        case 1:
+                            latency = _a.sent();
+                            if (latency) {
+                                log_method_latency_collection_1.LogMethodLatencies.updateOne({ _id: update.id_methodLatency }, { $set: { date_end: new Date(), latency_ms: moment().diff(moment(latency.date_start), 'milliseconds', true) } });
+                            }
+                            resolve(serverRes);
+                            return [2 /*return*/];
+                    }
+                });
+            }); }, function (err) {
+                var serverRes = {
                     messageId: update.messageId,
                     hasError: true,
                     data: err
                 };
-                this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
+                _this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
                 clearTimeout(timeout);
-                LogMethodLatencies.deleteOne({ _id: update.id_methodLatency });
+                log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: update.id_methodLatency });
                 resolve(serverRes);
             });
         });
-    }
+    };
     // Call/run method (Emit on Socket)
-    callMethod(id_methodLatency, ws, messageDate, messageId, method, ...methodData) {
-        let that = this;
+    MethodManager.prototype.callMethod = function (id_methodLatency, ws, messageDate, messageId, method) {
+        var _a;
+        var _this = this;
+        var methodData = [];
+        for (var _i = 5; _i < arguments.length; _i++) {
+            methodData[_i - 5] = arguments[_i];
+        }
+        var that = this;
         if (!that._methods[method]) {
             console.log('No Method: ' + method);
             that.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + that.serverConfig['CLIENT_NAME'], 'No Method: ' + method);
-            let serverRes = {
+            var serverRes = {
                 messageId: messageId,
                 hasError: true,
                 data: 'Internal Error'
             };
             this.sendWS(ws, messageDate, method, methodData, serverRes);
-            LogMethodLatencies.deleteOne({ _id: id_methodLatency });
+            log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: id_methodLatency });
             return;
         }
         if ((methodData.length > 1 || methodData[0]) && !that._methods[method].skipValidation) {
             if (!that._methods[method].check) {
                 console.error('No Check Function For Method ' + method);
                 that.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + that.serverConfig['CLIENT_NAME'], 'No Check Function For Method ' + method);
-                let serverRes = {
+                var serverRes = {
                     messageId: messageId,
                     hasError: true,
                     data: 'Internal Error'
                 };
                 this.sendWS(ws, messageDate, method, methodData, serverRes);
-                LogMethodLatencies.deleteOne({ _id: id_methodLatency });
+                log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: id_methodLatency });
                 return;
             }
             else if (!that._methods[method].check._schema) {
                 console.error('No Check Schema For Method ' + method);
                 that.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + that.serverConfig['CLIENT_NAME'], 'No Check Function For Method ' + method);
-                let serverRes = {
+                var serverRes = {
                     messageId: messageId,
                     hasError: true,
                     data: 'Internal Error'
                 };
-                LogMethodLatencies.deleteOne({ _id: id_methodLatency });
+                log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: id_methodLatency });
                 this.sendWS(ws, messageDate, method, methodData, serverRes);
                 return;
             }
             else {
-                let valObj = {};
-                let valKeys = Object.keys(that._methods[method].check._schema);
-                let rootKeys = valKeys.filter(a => !a.includes('.'));
-                for (let i = 0; i < methodData.length; i++) {
+                var valObj = {};
+                var valKeys = Object.keys(that._methods[method].check._schema);
+                var rootKeys = valKeys.filter(function (a) { return !a.includes('.'); });
+                for (var i = 0; i < methodData.length; i++) {
                     valObj[rootKeys[i]] = methodData[i];
                 }
                 try {
@@ -424,44 +496,58 @@ export class MethodManager {
                     if (errors) {
                         console.error('Error in Method Check (' + method + ')', errors);
                         that.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + that.serverConfig['CLIENT_NAME'], 'Match Error On Method ' + method + '\n\nData Being Checked\n' + JSON.stringify(valObj, null, 2) + '\n\nErrors\n' + JSON.stringify(errors, null, 2));
-                        let serverRes = {
+                        var serverRes = {
                             messageId: messageId,
                             hasError: true,
                             data: 'Internal Error'
                         };
                         this.sendWS(ws, messageDate, method, methodData, serverRes);
-                        LogMethodLatencies.deleteOne({ _id: id_methodLatency });
+                        log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: id_methodLatency });
                         return;
                     }
                 }
             }
         }
-        that._methods[method].function.call(Object.assign({}, that, MethodManager.prototype, { id_user: ws['id_user'], user: ws['user'], id_ws: ws['id_socket'] }), ...methodData).catch(methodErrs => {
+        (_a = that._methods[method].function).call.apply(_a, __spreadArrays([Object.assign({}, that, MethodManager.prototype, { id_user: ws['id_user'], user: ws['user'], id_ws: ws['id_socket'] })], methodData)).catch(function (methodErrs) {
             that.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + that.serverConfig['CLIENT_NAME'], 'Error Detected During Method ' + method + ' - (callMethod)\n\nData \n' + JSON.stringify(methodData, null, 2) + '\n\nErrors\n' + JSON.stringify(methodErrs, null, 2));
-        }).then(async (res) => {
-            let serverRes = {
-                messageId: messageId,
-                hasError: false,
-                data: res
-            };
-            this.sendWS(ws, messageDate, method, methodData, serverRes);
-            let latency = await LogMethodLatencies.findById(id_methodLatency);
-            if (latency) {
-                LogMethodLatencies.updateOne({ _id: id_methodLatency }, { $set: { date_end: new Date(), latency_ms: moment().diff(moment(latency.date_start), 'milliseconds', true) } });
-            }
-        }, err => {
-            let serverRes = {
+        }).then(function (res) { return __awaiter(_this, void 0, void 0, function () {
+            var serverRes, latency;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        serverRes = {
+                            messageId: messageId,
+                            hasError: false,
+                            data: res
+                        };
+                        this.sendWS(ws, messageDate, method, methodData, serverRes);
+                        return [4 /*yield*/, log_method_latency_collection_1.LogMethodLatencies.findById(id_methodLatency)];
+                    case 1:
+                        latency = _a.sent();
+                        if (latency) {
+                            log_method_latency_collection_1.LogMethodLatencies.updateOne({ _id: id_methodLatency }, { $set: { date_end: new Date(), latency_ms: moment().diff(moment(latency.date_start), 'milliseconds', true) } });
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        }); }, function (err) {
+            var serverRes = {
                 messageId: messageId,
                 hasError: true,
                 data: err
             };
-            this.sendWS(ws, messageDate, method, methodData, serverRes);
-            LogMethodLatencies.deleteOne({ _id: id_methodLatency });
+            _this.sendWS(ws, messageDate, method, methodData, serverRes);
+            log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: id_methodLatency });
         });
-    }
+    };
     // Call/run method internal (No Emit on Socket)
-    callMethodInternal(method, ...methodData) {
-        let that = this;
+    MethodManager.prototype.callMethodInternal = function (method) {
+        var _a;
+        var methodData = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            methodData[_i - 1] = arguments[_i];
+        }
+        var that = this;
         if (!that._methods[method]) {
             console.log('No Method: ' + method);
             return null;
@@ -476,15 +562,15 @@ export class MethodManager {
                 return null;
             }
         }
-        let promise = that._methods[method].function.call(Object.assign({}, that, MethodManager.prototype), ...methodData).catch(methodErrs => {
+        var promise = (_a = that._methods[method].function).call.apply(_a, __spreadArrays([Object.assign({}, that, MethodManager.prototype)], methodData)).catch(function (methodErrs) {
             that.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + that.serverConfig['CLIENT_NAME'], 'Error Detected During Method ' + method + ' - (callMethodInternal)\n\nData \n' + JSON.stringify(methodData, null, 2) + '\n\nErrors\n' + JSON.stringify(methodErrs, null, 2));
         });
         if (methodData[methodData.length - 1] && typeof (methodData[methodData.length - 1]) === 'function') {
-            promise.then(res => methodData[methodData.length - 1](null, res), err => methodData[methodData.length - 1](err, null));
+            promise.then(function (res) { return methodData[methodData.length - 1](null, res); }, function (err) { return methodData[methodData.length - 1](err, null); });
         }
         return promise;
-    }
-    sendWS(ws, messageDate, method, methodData, data) {
+    };
+    MethodManager.prototype.sendWS = function (ws, messageDate, method, methodData, data) {
         this._sendQueue.splice(0, 0, {
             id_ws: ws['id_socket'],
             method: method,
@@ -492,165 +578,64 @@ export class MethodManager {
             data: data,
             date: messageDate
         });
-    }
-    sendEmail(sendTo, subject, text, html, attachments, send_from) {
-        return new Promise(async (resolve, reject) => {
-            if ((this.serverConfig['ROOT_URL'].match(new RegExp(/https\:\/\/dev\./)) || this.serverConfig['ROOT_URL'].match(new RegExp(/https\:\/\/www\.dev\./)) || this.serverConfig['ROOT_URL'] === 'http://localhost:4200') && !sendTo.match(new RegExp(/\@resolveio\.com/))) {
-                sendTo = 'dev@resolveio.com';
-            }
-            // if (this.serverConfig['ROOT_URL'].match(new RegExp(/https\:\/\/dev\./)) || this.serverConfig['ROOT_URL'].match(new RegExp(/https\:\/\/www\.dev\./)) || this.serverConfig['ROOT_URL'] === 'http://localhost:4200' || sendTo.endsWith('@resolveio.com')) {
-            this._mailer.sendMail({
-                replyTo: undefined,
-                from: send_from ? send_from : this.serverConfig.MAIL_FROM,
-                to: sendTo,
-                subject: (this.serverConfig['ROOT_URL'].match(new RegExp(/https\:\/\/dev\./)) || this.serverConfig['ROOT_URL'].match(new RegExp(/https\:\/\/www\.dev\./)) ? '(DEV SERVER) - ' : '') + subject,
-                text: text,
-                html: html,
-                attachments: attachments
-            }, (err, info) => {
-                if (err) {
-                    console.log(err);
-                    EmailHistories.create({
-                        _id: objectIdHexString(),
-                        __v: 0,
-                        date: new Date(),
-                        id_user: this['id_user'],
-                        user: this['user'],
-                        email: sendTo,
-                        success: false,
-                        verified: false
-                    });
+    };
+    MethodManager.prototype.sendEmail = function (sendTo, subject, text, html, attachments, send_from) {
+        var _this = this;
+        return new Promise(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                if ((this.serverConfig['ROOT_URL'].match(new RegExp(/https\:\/\/dev\./)) || this.serverConfig['ROOT_URL'].match(new RegExp(/https\:\/\/www\.dev\./)) || this.serverConfig['ROOT_URL'] === 'http://localhost:4200') && !sendTo.match(new RegExp(/\@resolveio\.com/))) {
+                    sendTo = 'dev@resolveio.com';
                 }
-                else {
-                    EmailHistories.create({
-                        _id: objectIdHexString(),
-                        __v: 0,
-                        date: new Date(),
-                        id_user: this['id_user'],
-                        user: this['user'],
-                        email: sendTo,
-                        success: true,
-                        verified: false
-                    });
-                }
-                resolve();
+                // if (this.serverConfig['ROOT_URL'].match(new RegExp(/https\:\/\/dev\./)) || this.serverConfig['ROOT_URL'].match(new RegExp(/https\:\/\/www\.dev\./)) || this.serverConfig['ROOT_URL'] === 'http://localhost:4200' || sendTo.endsWith('@resolveio.com')) {
+                this._mailer.sendMail({
+                    replyTo: undefined,
+                    from: send_from ? send_from : this.serverConfig.MAIL_FROM,
+                    to: sendTo,
+                    subject: (this.serverConfig['ROOT_URL'].match(new RegExp(/https\:\/\/dev\./)) || this.serverConfig['ROOT_URL'].match(new RegExp(/https\:\/\/www\.dev\./)) ? '(DEV SERVER) - ' : '') + subject,
+                    text: text,
+                    html: html,
+                    attachments: attachments
+                }, function (err, info) {
+                    if (err) {
+                        console.log(err);
+                        email_history_collection_1.EmailHistories.create({
+                            _id: mongo_manager_1.objectIdHexString(),
+                            __v: 0,
+                            date: new Date(),
+                            id_user: _this['id_user'],
+                            user: _this['user'],
+                            email: sendTo,
+                            success: false,
+                            verified: false
+                        });
+                    }
+                    else {
+                        email_history_collection_1.EmailHistories.create({
+                            _id: mongo_manager_1.objectIdHexString(),
+                            __v: 0,
+                            date: new Date(),
+                            id_user: _this['id_user'],
+                            user: _this['user'],
+                            email: sendTo,
+                            success: true,
+                            verified: false
+                        });
+                    }
+                    resolve();
+                });
+                return [2 /*return*/];
             });
-            // }
-            // else {
-            // 	let oldVerfication = await EmailVerifies.findOne({email: sendTo});
-            // 	if (oldVerfication) {
-            // 		this._mailer.sendMail({
-            // 			replyTo: undefined,
-            // 			from: send_from ? send_from : this.serverConfig.MAIL_FROM,
-            // 			to: sendTo,
-            // 			subject: (this.serverConfig['ROOT_URL'].match(new RegExp(/https\:\/\/dev\./)) ? '(DEV SERVER) - ' : '') + subject,
-            // 			text: text,
-            // 			html: html,
-            // 			attachments: attachments
-            // 		}, (err, info) => {
-            // 			if (err) {
-            // 				console.log(err);
-            // 				EmailHistories.create({
-            // 					_id: objectIdHexString(),
-            // 					__v: 0,
-            // 					date: new Date(),
-            // 					id_user: this['id_user'],
-            // 					user: this['user'],
-            // 					email: sendTo,
-            // 					success: false,
-            // 					verified: true
-            // 				});
-            // 			}
-            // 			else {
-            // 				EmailHistories.create({
-            // 					_id: objectIdHexString(),
-            // 					__v: 0,
-            // 					date: new Date(),
-            // 					id_user: this['id_user'],
-            // 					user: this['user'],
-            // 					email: sendTo,
-            // 					success: true,
-            // 					verified: true
-            // 				});
-            // 			}
-            // 			resolve();
-            // 		});
-            // 	}
-            // 	else {
-            // 		let verifier = new Verifier(this.serverConfig['WHOISXMLAPI']);
-            // 		verifier.verify(sendTo, {hardRefresh: true}, (errVerify, resVerify) => {
-            // 			if (errVerify) {
-            // 				console.log(errVerify);
-            // 				EmailHistories.create({
-            // 					_id: objectIdHexString(),
-            // 					__v: 0,
-            // 					date: new Date(),
-            // 					id_user: this['id_user'],
-            // 					user: this['user'],
-            // 					email: sendTo,
-            // 					success: false,
-            // 					verified: false
-            // 				});
-            // 				resolve();
-            // 			}
-            // 			else {
-            // 				EmailVerifies.create({
-            // 					_id: objectIdHexString(),
-            // 					__v: 0,
-            // 					date: new Date(),
-            // 					id_user: this['id_user'],
-            // 					user: this['user'],
-            // 					email: sendTo
-            // 				});
-            // 				this._mailer.sendMail({
-            // 					replyTo: undefined,
-            // 					from: send_from ? send_from : this.serverConfig.MAIL_FROM,
-            // 					to: sendTo,
-            // 					subject: (this.serverConfig['ROOT_URL'].match(new RegExp(/https\:\/\/dev\./)) ? '(DEV SERVER) - ' : '') + subject,
-            // 					text: text,
-            // 					html: html,
-            // 					attachments: attachments
-            // 				}, (err, info) => {
-            // 					if (err) {
-            // 						console.log(err);
-            // 						EmailHistories.create({
-            // 							_id: objectIdHexString(),
-            // 							__v: 0,
-            // 							date: new Date(),
-            // 							id_user: this['id_user'],
-            // 							user: this['user'],
-            // 							email: sendTo,
-            // 							success: false,
-            // 							verified: true
-            // 						});
-            // 					}
-            // 					else {
-            // 						EmailHistories.create({
-            // 							_id: objectIdHexString(),
-            // 							__v: 0,
-            // 							date: new Date(),
-            // 							id_user: this['id_user'],
-            // 							user: this['user'],
-            // 							email: sendTo,
-            // 							success: true,
-            // 							verified: true
-            // 						});
-            // 					}
-            // 					resolve();
-            // 				});
-            // 			}
-            // 		});
-            // 	}
-            // }
-        });
-    }
-    getAWS() {
+        }); });
+    };
+    MethodManager.prototype.getAWS = function () {
         return this._aws;
-    }
-    readFile(fileName) {
-        return new Promise((resolve, reject) => {
+    };
+    MethodManager.prototype.readFile = function (fileName) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
             if (fs.existsSync(path.join(__dirname, ('../private/' + fileName)))) {
-                fs.readFile(path.join(__dirname, ('../private/' + fileName)), 'utf-8', (err, res) => {
+                fs.readFile(path.join(__dirname, ('../private/' + fileName)), 'utf-8', function (err, res) {
                     if (err) {
                         reject(err);
                     }
@@ -660,8 +645,8 @@ export class MethodManager {
                 });
             }
             else {
-                if (fs.existsSync(path.join(this.clientDir, ('./private/' + fileName)))) {
-                    fs.readFile(path.join(this.clientDir, ('./private/' + fileName)), 'utf-8', (err, res) => {
+                if (fs.existsSync(path.join(_this.clientDir, ('./private/' + fileName)))) {
+                    fs.readFile(path.join(_this.clientDir, ('./private/' + fileName)), 'utf-8', function (err, res) {
                         if (err) {
                             reject(err);
                         }
@@ -672,11 +657,12 @@ export class MethodManager {
                 }
             }
         });
-    }
-    readImage(fileName) {
-        return new Promise((resolve, reject) => {
+    };
+    MethodManager.prototype.readImage = function (fileName) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
             if (fs.existsSync(path.join(__dirname, ('../private/' + fileName)))) {
-                fs.readFile(path.join(__dirname, ('../private/' + fileName)), 'base64', (err, res) => {
+                fs.readFile(path.join(__dirname, ('../private/' + fileName)), 'base64', function (err, res) {
                     if (err) {
                         reject(err);
                     }
@@ -686,8 +672,8 @@ export class MethodManager {
                 });
             }
             else {
-                if (fs.existsSync(path.join(this.clientDir, ('./private/' + fileName)))) {
-                    fs.readFile(path.join(this.clientDir, ('./private/' + fileName)), 'base64', (err, res) => {
+                if (fs.existsSync(path.join(_this.clientDir, ('./private/' + fileName)))) {
+                    fs.readFile(path.join(_this.clientDir, ('./private/' + fileName)), 'base64', function (err, res) {
                         if (err) {
                             reject(err);
                         }
@@ -698,7 +684,9 @@ export class MethodManager {
                 }
             }
         });
-    }
-}
+    };
+    return MethodManager;
+}());
+exports.MethodManager = MethodManager;
 
 //# sourceMappingURL=method.manager.js.map