@resolveio/server-lib 1.0.17 → 1.0.19

package/managers/support.manager.d.ts

@@ -6,13 +6,17 @@ export declare class SupportManager {
     private _mailer;
     private _aws;
     private serverConfig;
+    private clientDir;
     private _sendQueue;
     private _runningQueue;
-    constructor(mainServer: any, serverConfig: any);
+    constructor(mainServer: any, serverConfig: any, clientDir: any);
     getMainServer(): ResolveIOMainServer;
     supportMethods(supportMethod: SupportMethodModel): void;
     callSupportMethod(ws: WebSocket, messageId: any, supportMethod: any, ...methodData: any[]): void;
-    callMethodInternal(supportMethod: any, ...methodData: any[]): Promise<any>;
+    callSupportMethodInternal(supportMethod: any, ...methodData: any[]): Promise<any>;
+    callMethodInternal(method: any, ...methodData: any[]): Promise<any>;
     private sendWS;
     sendEmail(sendTo: string, subject: string, text?: string, html?: string, attachments?: any[]): void;
+    readFile(fileName: any): Promise<{}>;
+    readImage(fileName: any): Promise<{}>;
 }

package/managers/support.manager.js

@@ -8,14 +8,18 @@ var counters_1 = require("../support-methods/counters");
 var mongoose_1 = require("mongoose");
 var common_1 = require("../util/common");
 var log_collection_1 = require("../collections/log.collection");
+var method_manager_1 = require("./method.manager");
+var path = require("path");
+var fs = require("fs");
 var SupportManager = /** @class */ (function () {
-    function SupportManager(mainServer, serverConfig) {
+    function SupportManager(mainServer, serverConfig, clientDir) {
         var _this = this;
         this._supportMethods = {};
         this._sendQueue = [];
         this._runningQueue = false;
         this._mainServer = mainServer;
         this.serverConfig = serverConfig;
+        this.clientDir = clientDir;
         collections_1.loadSupportCollectionMethods(this);
         support_1.loadSupportMethods(this);
         counters_1.loadCounterMethods(this);
@@ -180,7 +184,7 @@ var SupportManager = /** @class */ (function () {
             _this.sendWS(ws, supportMethod, methodData, serverRes);
         });
     };
-    SupportManager.prototype.callMethodInternal = function (supportMethod) {
+    SupportManager.prototype.callSupportMethodInternal = function (supportMethod) {
         var methodData = [];
         for (var _i = 1; _i < arguments.length; _i++) {
             methodData[_i - 1] = arguments[_i];
@@ -207,6 +211,33 @@ var SupportManager = /** @class */ (function () {
         }
         return promise;
     };
+    SupportManager.prototype.callMethodInternal = function (method) {
+        var methodData = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            methodData[_i - 1] = arguments[_i];
+        }
+        var _a;
+        var that = this;
+        if (!that._mainServer.getMethodManager()._methods[method]) {
+            console.log('No Method: ' + method);
+            return;
+        }
+        if ((methodData.length > 1 || (methodData[0] && typeof (methodData[0]) !== 'function')) && !that._mainServer.getMethodManager()._methods[method].skipValidation) {
+            if (!that._mainServer.getMethodManager()._methods[method].check) {
+                console.error('No Check Function For Method ' + method);
+                return;
+            }
+            else if (!that._mainServer.getMethodManager()._methods[method].check._schema) {
+                console.error('No Check Schema For Method ' + method);
+                return;
+            }
+        }
+        var promise = (_a = that._mainServer.getMethodManager()._methods[method].function).call.apply(_a, [Object.assign({}, that, method_manager_1.MethodManager.prototype)].concat(methodData));
+        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); });
+        }
+        return promise;
+    };
     SupportManager.prototype.sendWS = function (ws, method, methodData, data) {
         this._sendQueue.splice(0, 0, {
             id_ws: ws['id_socket'],
@@ -230,6 +261,60 @@ var SupportManager = /** @class */ (function () {
             }
         });
     };
+    SupportManager.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', function (err, res) {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(res);
+                    }
+                });
+            }
+            else {
+                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);
+                        }
+                        else {
+                            resolve(res);
+                        }
+                    });
+                }
+            }
+        });
+    };
+    SupportManager.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', function (err, res) {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(res);
+                    }
+                });
+            }
+            else {
+                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);
+                        }
+                        else {
+                            resolve(res);
+                        }
+                    });
+                }
+            }
+        });
+    };
     return SupportManager;
 }());
 exports.SupportManager = SupportManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@resolveio/server-lib",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "description": "",
   "main": "index.ts",
   "scripts": {

package/server-app.js

@@ -206,7 +206,7 @@ var ResolveIOMainServer = /** @class */ (function () {
         // Start Managers
         this._subscriptionManager = new subscription_manager_1.SubscriptionManager(this, this._wss, this._serverConfig);
         this._methodManager = new method_manager_1.MethodManager(this, this._serverConfig, this._clientDir);
-        this._supportManager = new support_manager_1.SupportManager(this, this._serverConfig);
+        this._supportManager = new support_manager_1.SupportManager(this, this._serverConfig, this._clientDir);
         this._cronManager = new cron_manager_1.CronManager(this);
         this._queueManager = new queue_method_manager_1.QueueMethodManager(this);
         this.listen();

package/support-methods/cron-jobs.js

@@ -59,7 +59,7 @@ function loadSupportCronJobMethods(methodManager) {
                                 count = 0;
                                 interval = setInterval(function () {
                                     var updateChunk = users.slice(count * 10, Math.min(users.length, (count + 1) * 10));
-                                    _this.callMethodInternal.call(_this, 'updateClientUserChunk', updateChunk);
+                                    _this.callSupportMethodInternal.call(_this, 'updateClientUserChunk', updateChunk);
                                     count++;
                                     if (count * 10 > users.length) {
                                         clearInterval(interval);