@resolveio/server-lib 9.0.32 → 9.0.34

package/managers/method.manager.js

@@ -1,78 +1,31 @@
-"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;
+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) {
         this._methods = {};
         this._sendQueue = [];
         this._runningQueue = false;
@@ -80,21 +33,21 @@ var MethodManager = /** @class */ (function () {
         this.serverConfig = serverConfig;
         this.clientDir = clientDir;
         // Fixtures
-        init_1.loadServerInit();
-        cron_jobs_1.loadServerCronJobs();
+        loadServerInit();
+        loadServerCronJobs();
         // Methods
-        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);
+        loadAccountMethods(this);
+        loadAWSMethods(this);
+        loadCloudConvertMethods(this);
+        loadCollectionMethods(this);
+        loadCounterMethods(this);
+        loadLogMethods(this);
+        loadPDFMethods(this);
+        loadCronJobMethods(this);
+        loadFlagMethods(this);
+        loadReportBuilderMethods(this);
+        loadSupportMethods(this);
+        loadMonitorMethods(this);
         if (mainServer.sesMail) {
             this._mailer = nodemailer.createTransport({
                 SES: new aws.SES({
@@ -218,28 +171,28 @@ var MethodManager = /** @class */ (function () {
             secretAccessKey: serverConfig.AWSSECRETACCESSKEY,
             region: serverConfig.AWSREGION
         });
-        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);
+        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);
                         if (ws && ws.readyState === ws.OPEN) {
                             if (ws.bufferedAmount < 20480) {
-                                var sendItem = _this._sendQueue.pop();
-                                ws.send(JSON.stringify(sendItem.data), function (error) {
+                                let sendItem = this._sendQueue.pop();
+                                ws.send(JSON.stringify(sendItem.data), (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') {
-                                    log_collection_1.Logs.create({
-                                        _id: mongo_manager_1.objectIdHexString(),
+                                    Logs.create({
+                                        _id: objectIdHexString(),
                                         type: 'client-response',
                                         collection: '',
                                         id_document: '',
-                                        payload: common_1.getBinarySize(JSON.stringify([sendItem.methodData, sendItem.data])) < 200000 ? JSON.stringify([sendItem.methodData, sendItem.data], null, 2) : 'Too Big',
+                                        payload: 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'],
@@ -247,43 +200,35 @@ var MethodManager = /** @class */ (function () {
                                         route: ''
                                     });
                                 }
-                                method_response_collection_1.MethodResponses.create({
-                                    _id: mongo_manager_1.objectIdHexString(),
+                                MethodResponses.create({
+                                    _id: objectIdHexString(),
                                     __v: 0,
                                     id_user: ws['id_user'],
                                     message_id: sendItem.data.messageId,
-                                    response: common_1.getBinarySize(JSON.stringify(sendItem.data)) < 200000 ? sendItem.data : 'Too Big',
+                                    response: 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);
     }
-    MethodManager.prototype.getMainServer = function () {
+    getMainServer() {
         return this._mainServer;
-    };
+    }
     // Add methods to private methods object
-    MethodManager.prototype.methods = function (method) {
+    methods(method) {
         this._methods = Object.assign(this._methods, method);
-    };
-    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;
+    }
+    callMethodCron(method, ...methodData) {
+        let 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);
@@ -301,10 +246,10 @@ var MethodManager = /** @class */ (function () {
                 return;
             }
             else {
-                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++) {
+                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++) {
                     valObj[rootKeys[i]] = methodData[i];
                 }
                 try {
@@ -319,57 +264,57 @@ var MethodManager = /** @class */ (function () {
                 }
             }
         }
-        (_a = that._methods[method].function).call.apply(_a, __spreadArrays([Object.assign({}, that, MethodManager.prototype, { id_user: '', user: '', id_ws: '' })], methodData));
-    };
-    MethodManager.prototype.callMethodQueue = function (update) {
-        var _this = this;
+        that._methods[method].function.call(Object.assign({}, that, MethodManager.prototype, { id_user: '', user: '', id_ws: '' }), ...methodData).catch(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) {
         // console.log('Call Method Queue', update);
-        return new Promise(function (resolve, reject) {
-            var _a;
-            var updateCopy = common_1.deepCopy(update);
-            var that = _this;
+        return new Promise((resolve, reject) => {
+            let updateCopy = deepCopy(update);
+            let 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);
-                var serverRes = {
+                let serverRes = {
                     messageId: update.messageId,
                     hasError: true,
                     data: 'Internal Error'
                 };
-                _this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
-                log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: update.id_methodLatency });
+                this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
+                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);
-                    var serverRes = {
+                    let serverRes = {
                         messageId: update.messageId,
                         hasError: true,
                         data: 'Internal Error'
                     };
-                    _this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
-                    log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: update.id_methodLatency });
+                    this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
+                    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);
-                    var serverRes = {
+                    let serverRes = {
                         messageId: update.messageId,
                         hasError: true,
                         data: 'Internal Error'
                     };
-                    _this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
-                    log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: update.id_methodLatency });
+                    this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
+                    LogMethodLatencies.deleteOne({ _id: update.id_methodLatency });
                     return resolve('No Check Schema For Method ' + update.method);
                 }
                 else {
-                    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++) {
+                    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++) {
                         valObj[rootKeys[i]] = update.method_data[i];
                     }
                     try {
@@ -379,110 +324,97 @@ var MethodManager = /** @class */ (function () {
                         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));
-                            var serverRes = {
+                            let serverRes = {
                                 messageId: update.messageId,
                                 hasError: true,
                                 data: 'Internal Error'
                             };
-                            _this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
-                            log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: update.id_methodLatency });
+                            this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
+                            LogMethodLatencies.deleteOne({ _id: update.id_methodLatency });
                             return resolve('Error in Method Check (' + update.method + ')');
                         }
                     }
                 }
             }
-            var timeout = setTimeout(function () {
+            let timeout = setTimeout(() => {
                 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);
-            (_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)).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 = {
+            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 => {
+                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 = {
                     messageId: update.messageId,
                     hasError: true,
                     data: err
                 };
-                _this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
+                this._mainServer.getQueueManager().addMethodResponse(updateCopy, serverRes);
                 clearTimeout(timeout);
-                log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: update.id_methodLatency });
+                LogMethodLatencies.deleteOne({ _id: update.id_methodLatency });
                 resolve(serverRes);
             });
         });
-    };
+    }
     // Call/run method (Emit on Socket)
-    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;
+    callMethod(id_methodLatency, ws, messageDate, messageId, method, ...methodData) {
+        let 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);
-            var serverRes = {
+            let serverRes = {
                 messageId: messageId,
                 hasError: true,
                 data: 'Internal Error'
             };
             this.sendWS(ws, messageDate, method, methodData, serverRes);
-            log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: id_methodLatency });
+            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);
-                var serverRes = {
+                let serverRes = {
                     messageId: messageId,
                     hasError: true,
                     data: 'Internal Error'
                 };
                 this.sendWS(ws, messageDate, method, methodData, serverRes);
-                log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: id_methodLatency });
+                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);
-                var serverRes = {
+                let serverRes = {
                     messageId: messageId,
                     hasError: true,
                     data: 'Internal Error'
                 };
-                log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: id_methodLatency });
+                LogMethodLatencies.deleteOne({ _id: id_methodLatency });
                 this.sendWS(ws, messageDate, method, methodData, serverRes);
                 return;
             }
             else {
-                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++) {
+                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++) {
                     valObj[rootKeys[i]] = methodData[i];
                 }
                 try {
@@ -492,77 +424,67 @@ var MethodManager = /** @class */ (function () {
                     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));
-                        var serverRes = {
+                        let serverRes = {
                             messageId: messageId,
                             hasError: true,
                             data: 'Internal Error'
                         };
                         this.sendWS(ws, messageDate, method, methodData, serverRes);
-                        log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: id_methodLatency });
+                        LogMethodLatencies.deleteOne({ _id: id_methodLatency });
                         return;
                     }
                 }
             }
         }
-        (_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)).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 = {
+        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 => {
+            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 = {
                 messageId: messageId,
                 hasError: true,
                 data: err
             };
-            _this.sendWS(ws, messageDate, method, methodData, serverRes);
-            log_method_latency_collection_1.LogMethodLatencies.deleteOne({ _id: id_methodLatency });
+            this.sendWS(ws, messageDate, method, methodData, serverRes);
+            LogMethodLatencies.deleteOne({ _id: id_methodLatency });
         });
-    };
+    }
     // Call/run method internal (No Emit on Socket)
-    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;
+    callMethodInternal(method, ...methodData) {
+        let that = this;
         if (!that._methods[method]) {
             console.log('No Method: ' + method);
-            return;
+            return null;
         }
         if ((methodData.length > 1 || (methodData[0] && typeof (methodData[0]) !== 'function')) && !that._methods[method].skipValidation) {
             if (!that._methods[method].check) {
                 console.error('No Check Function For Method ' + method);
-                return;
+                return null;
             }
             else if (!that._methods[method].check._schema) {
                 console.error('No Check Schema For Method ' + method);
-                return;
+                return null;
             }
         }
-        var promise = (_a = that._methods[method].function).call.apply(_a, __spreadArrays([Object.assign({}, that, MethodManager.prototype)], methodData));
+        let promise = that._methods[method].function.call(Object.assign({}, that, MethodManager.prototype), ...methodData).catch(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(function (res) { return methodData[methodData.length - 1](null, res); }, function (err) { return methodData[methodData.length - 1](err, null); });
+            promise.then(res => methodData[methodData.length - 1](null, res), err => methodData[methodData.length - 1](err, null));
         }
         return promise;
-    };
-    MethodManager.prototype.sendWS = function (ws, messageDate, method, methodData, data) {
+    }
+    sendWS(ws, messageDate, method, methodData, data) {
         this._sendQueue.splice(0, 0, {
             id_ws: ws['id_socket'],
             method: method,
@@ -570,64 +492,165 @@ var MethodManager = /** @class */ (function () {
             data: data,
             date: messageDate
         });
-    };
-    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';
+    }
+    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
+                    });
                 }
-                // 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 {
+                    EmailHistories.create({
+                        _id: objectIdHexString(),
+                        __v: 0,
+                        date: new Date(),
+                        id_user: this['id_user'],
+                        user: this['user'],
+                        email: sendTo,
+                        success: true,
+                        verified: false
+                    });
+                }
+                resolve();
             });
-        }); });
-    };
-    MethodManager.prototype.getAWS = function () {
+            // }
+            // 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() {
         return this._aws;
-    };
-    MethodManager.prototype.readFile = function (fileName) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
+    }
+    readFile(fileName) {
+        return new Promise((resolve, reject) => {
             if (fs.existsSync(path.join(__dirname, ('../private/' + fileName)))) {
-                fs.readFile(path.join(__dirname, ('../private/' + fileName)), 'utf-8', function (err, res) {
+                fs.readFile(path.join(__dirname, ('../private/' + fileName)), 'utf-8', (err, res) => {
                     if (err) {
                         reject(err);
                     }
@@ -637,8 +660,8 @@ var MethodManager = /** @class */ (function () {
                 });
             }
             else {
-                if (fs.existsSync(path.join(_this.clientDir, ('./private/' + fileName)))) {
-                    fs.readFile(path.join(_this.clientDir, ('./private/' + fileName)), 'utf-8', function (err, res) {
+                if (fs.existsSync(path.join(this.clientDir, ('./private/' + fileName)))) {
+                    fs.readFile(path.join(this.clientDir, ('./private/' + fileName)), 'utf-8', (err, res) => {
                         if (err) {
                             reject(err);
                         }
@@ -649,12 +672,11 @@ var MethodManager = /** @class */ (function () {
                 }
             }
         });
-    };
-    MethodManager.prototype.readImage = function (fileName) {
-        var _this = this;
-        return new Promise(function (resolve, reject) {
+    }
+    readImage(fileName) {
+        return new Promise((resolve, reject) => {
             if (fs.existsSync(path.join(__dirname, ('../private/' + fileName)))) {
-                fs.readFile(path.join(__dirname, ('../private/' + fileName)), 'base64', function (err, res) {
+                fs.readFile(path.join(__dirname, ('../private/' + fileName)), 'base64', (err, res) => {
                     if (err) {
                         reject(err);
                     }
@@ -664,8 +686,8 @@ var MethodManager = /** @class */ (function () {
                 });
             }
             else {
-                if (fs.existsSync(path.join(_this.clientDir, ('./private/' + fileName)))) {
-                    fs.readFile(path.join(_this.clientDir, ('./private/' + fileName)), 'base64', function (err, res) {
+                if (fs.existsSync(path.join(this.clientDir, ('./private/' + fileName)))) {
+                    fs.readFile(path.join(this.clientDir, ('./private/' + fileName)), 'base64', (err, res) => {
                         if (err) {
                             reject(err);
                         }
@@ -676,9 +698,7 @@ var MethodManager = /** @class */ (function () {
                 }
             }
         });
-    };
-    return MethodManager;
-}());
-exports.MethodManager = MethodManager;
+    }
+}
 
 //# sourceMappingURL=method.manager.js.map