@resolveio/server-lib 12.5.53 → 12.5.54

package/src/managers/method.manager.ts

@@ -0,0 +1,607 @@
+import { ServerResponseModel } from '../models/server-response.model';
+import { loadCollectionMethods } from '../methods/collections';
+import { MethodModel } from '../models/method.model';
+import { loadLogMethods } from '../methods/logs';
+import { loadCounterMethods } from '../methods/counters';
+import { loadPDFMethods } from '../methods/pdf';
+import { loadAWSMethods } from '../methods/aws';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as nodemailer from 'nodemailer';
+import * as sesTransport from 'nodemailer-ses-transport';
+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 { getBinarySize } from '../util/common';
+import { Logs } from '../collections/log.collection';
+import ResolveIOMainServer from '../server-app';
+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';
+import { MonitorManagerFunction } from './monitor.manager';
+import { S3 } from '@aws-sdk/client-s3';
+
+export class AWS {
+	private _serverConfig = null;
+	private _s3: S3 = null;
+	private _s3USEast1: S3 = null;
+
+	constructor(serverConfig) {
+		this._serverConfig = serverConfig;
+	}
+
+	public s3() : S3 {
+		if (this._s3) {
+			return this._s3;
+		}
+
+		this._s3 = new S3({
+			credentials: {
+				accessKeyId: process.env.AWS_ACCESS_KEY,
+				secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
+			},
+			region: process.env.AWS_REGION,
+			apiVersion: '2006-03-01'
+		});
+
+		return this._s3;
+	}
+
+	public s3USEast1() : S3 {
+		if (process.env.AWS_REGION === 'us-east-1') {
+			return this.s3();
+		}
+		else {
+			if (this._s3USEast1) {
+				return this._s3USEast1;
+			}
+			
+			this._s3USEast1 = new S3({
+				credentials: {
+					accessKeyId: process.env.AWS_ACCESS_KEY,
+					secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
+				},
+				region: 'us-east-1',
+				apiVersion: '2006-03-01'
+			});
+	
+			return this._s3USEast1;
+		}
+	}
+}
+
+export class MethodManager {
+	private _mainServer: ResolveIOMainServer;
+	public _methods: MethodModel = {};
+	private _mailer: nodemailer.Transporter;
+	private _aws: AWS;
+	private serverConfig;
+	private clientDir;
+	private _sendQueue = [];
+	private _runningQueue = false;
+	private _monitorManagerFunction: MonitorManagerFunction;
+
+	private _debugCallMethodInternalHits = 0;
+	private _debugCallMethodHits = 0;
+	private _debugCallMethodCronJobHits = 0;
+	private _debugSendQueueHits = 0;
+
+	constructor(mainServer, serverConfig, clientDir, monitorManagerFunction: MonitorManagerFunction) {
+		this._mainServer = mainServer;
+		this.serverConfig = serverConfig;
+		this.clientDir = clientDir;
+		this._monitorManagerFunction = monitorManagerFunction;
+
+		// Fixtures
+		loadServerInit();
+		loadServerCronJobs();
+
+		// Methods
+		loadAccountMethods(this);
+		loadAWSMethods(this);
+		loadCollectionMethods(this);
+		loadCounterMethods(this);
+		loadLogMethods(this);
+		loadPDFMethods(this);
+		loadCronJobMethods(this);
+		loadFlagMethods(this);
+		loadReportBuilderMethods(this);
+		loadSupportMethods(this);
+		loadMonitorMethods(this);
+
+		this._aws = new AWS(serverConfig);		
+
+		if (mainServer.sesMail) {
+			this._mailer = nodemailer.createTransport(sesTransport({
+				accessKeyId: process.env.AWS_ACCESS_KEY,
+				secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+				region: process.env.AWS_SES_REGION
+			}));
+		}
+		else {
+			this._mailer = nodemailer.createTransport({
+				host: this.serverConfig['MAIL_HOST'], // 'smtp.office365.com', // Office 365 server
+				port: this.serverConfig['MAIL_PORT'], //587,     // secure SMTP
+				secure: false, // false for TLS - as a boolean not string - but the default is false so just remove this completely
+				auth: {
+					user: this.serverConfig['MAIL_USERNAME'],
+					pass: this.serverConfig['MAIL_PASSWORD']
+				},
+				tls: {
+					ciphers: 'SSLv3'
+				}
+			});
+		}
+
+		setInterval(() => {
+			if (this._mainServer.getSubscriptionManager().getEnableDebug()) {
+				console.log(new Date(), 'Method Manager', 'Send Queue Length', this._sendQueue.length);
+				console.log(new Date(), 'Method Manager', 'Send Queue Hits', this._debugSendQueueHits);
+				console.log(new Date(), 'Method Manager', 'Call Method Internal Hits', this._debugCallMethodInternalHits);
+				console.log(new Date(), 'Method Manager', 'Call Method Hits', this._debugCallMethodHits);
+				console.log(new Date(), 'Method Manager', 'Call Method Cron Hits', this._debugCallMethodCronJobHits);
+			}
+
+			this._debugCallMethodInternalHits = 0;
+			this._debugCallMethodHits = 0;
+			this._debugCallMethodCronJobHits = 0;
+			this._debugSendQueueHits = 0;
+			this._debugSendQueueHits = 0;
+		}, 60000);
+
+		setInterval(() => {
+			if (!this._runningQueue) {
+				if (this._sendQueue.length) {
+					this._runningQueue = true;
+
+					for (let i = this._sendQueue.length - 1; i >= 0; i--) {
+						this._debugSendQueueHits += 1;
+
+						let 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) => {
+									if (error) {
+										console.log('Error on WS: ', error);
+										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 !== 'uploadFileAndSave' && sendItem.method !== 'getDrivers' && sendItem.method !== 'processAirdropDistribution') {
+									Logs.insertOne({
+										_id: 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',
+										method: sendItem.method,
+										id_user: ws['id_user'] || '',
+										user: ws['user'] || '',
+										messageId: sendItem.data.messageId,
+										route: ''
+									});
+								}
+
+								MethodResponses.create({
+									_id: objectIdHexString(),
+									__v: 0,
+									id_user: ws['id_user'] || '',
+									message_id: sendItem.data.messageId,
+									response: getBinarySize(JSON.stringify(sendItem.data)) < 200000 ? sendItem.data : {error: 'Too Big'},
+									method: sendItem.method,
+									date: sendItem.date
+								});
+							}
+						}
+						else {
+							this._sendQueue.splice(i, 1);
+						}
+					}
+
+					this._runningQueue = false;
+				}
+			}
+		}, 25);
+	}
+
+	public getMainServer() {
+		return this._mainServer;
+	}
+
+	// Add methods to private methods object
+	public methods(method: MethodModel) {
+		this._methods = Object.assign(this._methods, method);
+	}
+
+	public callMethodCron(method: string, ...methodData: any[]) {
+		this._debugCallMethodCronJobHits += 1;
+
+		if (!this._methods[method]) {
+			console.log('No Method: ' + method);
+
+			this.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + this.serverConfig['CLIENT_NAME'], 'No Method: ' + method);
+
+			return;
+		}
+		
+		if ((methodData.length > 1 || methodData[0]) && !this._methods[method].skipValidation) {
+			if (!this._methods[method].check) {
+				console.error(new Date(), 'No Check Function For Method ' + method);
+
+				this.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + this.serverConfig['CLIENT_NAME'], 'No Check Function For Method ' + method);
+	
+				return;
+			}
+			else if (!this._methods[method].check._schema) {
+				console.error(new Date(), 'No Check Schema For Method ' + method);
+
+				this.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + this.serverConfig['CLIENT_NAME'], 'No Check Function For Method ' + method);
+	
+				return;
+			}
+			else {
+				let valObj = {};
+				let valKeys = Object.keys(this._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 {
+					this._methods[method].check.validate(valObj);
+				}
+				catch (errors) {
+					if (errors) {
+						console.error(new Date(), 'Error in Method Check (' + method + ')', errors);
+
+						this.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + this.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));
+			
+						return;
+					}
+				}
+			}
+		}
+		
+		let monitor = this._monitorManagerFunction.startMonitorFunction('Cron Method', method, '', '', methodData);
+		let promise = this._methods[method].function.call(Object.assign({}, this, MethodManager.prototype, {id_user: '', user: '', id_ws: ''}), ...methodData)
+		.then(res => {
+			this._monitorManagerFunction.finishMonitorFunction(monitor);
+			return res;
+		}, methodErrs => {
+			this._monitorManagerFunction.finishMonitorFunction(monitor);
+			this.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + this.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));
+			return methodErrs;
+		});
+
+		return promise;
+	}
+
+	// Call/run method (Emit on Socket)
+	public callMethod(id_methodLatency: string, ws: WebSocket, messageDate: Date, messageId: number, method: string, ...methodData: any[]) {
+		this._debugCallMethodHits += 1;
+		
+		if (!this._methods[method]) {
+			console.log('No Method: ' + method);
+
+			this.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + this.serverConfig['CLIENT_NAME'], 'No Method: ' + method);
+			
+			let serverRes: ServerResponseModel = {
+				messageId: messageId,
+				hasError: true,
+				data: 'Internal Error'
+			};
+
+			this.sendWS(ws, messageDate, method, methodData, serverRes);
+
+			if (id_methodLatency) {
+				LogMethodLatencies.deleteOne({_id: id_methodLatency});
+			}
+
+			return;
+		}
+
+		if ((methodData.length > 1 || methodData[0]) && !this._methods[method].skipValidation) {
+			if (!this._methods[method].check) {
+				console.error(new Date(), 'No Check Function For Method ' + method);
+
+				this.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + this.serverConfig['CLIENT_NAME'], 'No Check Function For Method ' + method);
+				
+				let serverRes: ServerResponseModel = {
+					messageId: messageId,
+					hasError: true,
+					data: 'Internal Error'
+				};
+	
+				this.sendWS(ws, messageDate, method, methodData, serverRes);
+
+				if (id_methodLatency) {
+					LogMethodLatencies.deleteOne({_id: id_methodLatency});
+				}
+	
+				return;
+			}
+			else if (!this._methods[method].check._schema) {
+				console.error(new Date(), 'No Check Schema For Method ' + method);
+
+				this.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + this.serverConfig['CLIENT_NAME'], 'No Check Function For Method ' + method);
+				
+				let serverRes: ServerResponseModel = {
+					messageId: messageId,
+					hasError: true,
+					data: 'Internal Error'
+				};
+
+				if (id_methodLatency) {
+					LogMethodLatencies.deleteOne({_id: id_methodLatency});
+				}
+	
+				this.sendWS(ws, messageDate, method, methodData, serverRes);
+	
+				return;
+			}
+			else {
+				let valObj = {};
+				let valKeys = Object.keys(this._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 {
+					this._methods[method].check.validate(valObj);
+				}
+				catch (errors) {
+					if (errors) {
+						console.error(new Date(), 'Error in Method Check (' + method + ')', errors);
+
+						if (method !== 'processAirdropDistribution') {
+							this.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + this.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: ServerResponseModel = {
+							messageId: messageId,
+							hasError: true,
+							data: 'Internal Error'
+						};
+						
+						this.sendWS(ws, messageDate, method, methodData, serverRes);
+
+						if (id_methodLatency) {
+							LogMethodLatencies.deleteOne({_id: id_methodLatency});
+						}
+			
+						return;
+					}
+				}
+			}
+		}
+		
+		let monitor = this._monitorManagerFunction.startMonitorFunction('Method', method, ws['user'] || '', ws['id_socket'] || '', methodData);
+		this._methods[method].function.call(Object.assign({}, this, MethodManager.prototype, {id_user: ws['id_user'], user: ws['user'], id_ws: ws['id_socket']}), ...methodData)
+		.then(async (res) => {
+			this._monitorManagerFunction.finishMonitorFunction(monitor);
+
+			let serverRes: ServerResponseModel = {
+				messageId: messageId,
+				hasError: false,
+				data: res
+			};
+
+			this.sendWS(ws, messageDate, method, methodData, serverRes);
+
+			if (id_methodLatency) {
+				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 => {
+			this._monitorManagerFunction.finishMonitorFunction(monitor);
+			let serverRes: ServerResponseModel = {
+				messageId: messageId,
+				hasError: true,
+				data: err
+			};
+
+			this.sendWS(ws, messageDate, method, methodData, serverRes);
+
+			if (id_methodLatency) {
+				LogMethodLatencies.deleteOne({_id: id_methodLatency});
+			}
+
+			if (method !== 'processAirdropDistribution') {
+				this.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + this.serverConfig['CLIENT_NAME'], 'Error Detected During Method ' + method + ' - (callMethod)\n\nData \n' + JSON.stringify(methodData, null, 2) + '\n\nErrors\n' + JSON.stringify(err, null, 2));
+			}
+		});
+	}
+
+	// Call/run method internal (No Emit on Socket)
+	public callMethodInternal(method, ...methodData: any[]): Promise<any> {
+		this._debugCallMethodInternalHits += 1;
+		
+		if (!this._methods[method]) {
+			console.log('No Method: ' + method);
+			return null;
+		}
+
+		if ((methodData.length > 1 || (methodData[0] && typeof(methodData[0]) !== 'function')) && !this._methods[method].skipValidation) {
+			if (!this._methods[method].check) {
+				console.error(new Date(), 'No Check Function For Method ' + method);
+				return null;
+			}
+			else if (!this._methods[method].check._schema) {
+				console.error(new Date(), 'No Check Schema For Method ' + method);
+				return null;
+			}
+		}
+
+		if (method !== 'insertSubscriptionLog' && method !== 'getDataURIfromURL' && method !== 'processAirdropDistribution') {
+			Logs.insertOne({
+				_id: objectIdHexString(),
+				type: 'callMethodInternal',
+				collection: '',
+				id_document: '',
+				payload: getBinarySize(JSON.stringify([methodData])) < 200000 ? JSON.stringify([methodData], null, 2) : 'Too Big',
+				method: method,
+				id_user: this['id_user'] || '',
+				user: this['user'] || '',
+				messageId: 0,
+				route: ''
+			});
+		}
+
+		let functionMethodData = typeof(methodData[methodData.length - 1]) === 'function' ? methodData.slice(0, -1) : methodData;
+
+		let monitor = this._monitorManagerFunction.startMonitorFunction('Internal Method', method, this['user'] || '', '', functionMethodData);
+		let promise = this._methods[method].function.call(Object.assign({}, this, MethodManager.prototype), ...functionMethodData)
+		.then(res => {
+			this._monitorManagerFunction.finishMonitorFunction(monitor);
+			return res;
+		}, methodErrs => {
+			this._monitorManagerFunction.finishMonitorFunction(monitor);
+			this.sendEmail('dev@resolveio.com', 'SERVER - Error Detected - ' + this.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));
+			return methodErrs;
+		});
+
+		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));
+		}
+		
+		return promise;
+	}
+
+	private sendWS(ws: WebSocket, messageDate: Date, method: string, methodData: any[], data: ServerResponseModel) {
+		this._sendQueue.splice(0, 0, {
+			id_ws: ws['id_socket'],
+			method: method,
+			methodData: methodData,
+			data: data,
+			date: messageDate
+		});
+	}
+
+	public sendEmail(sendTo: string, subject: string, text?: string, html?: string, attachments?: any[], send_from?: string, reply_to?: string) {
+		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 (sendTo) {
+				if (this.serverConfig['ROOT_URL'] !== 'http://localhost:4200') {
+					this._mailer.sendMail({
+						replyTo: reply_to !== null && reply_to !== undefined ? reply_to : (this.serverConfig['MAIL_REPLY_TO'] || undefined), //orders@acefluids.com
+						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
+							});
+						}
+						else {
+							EmailHistories.create({
+								_id: objectIdHexString(),
+								__v: 0,
+								date: new Date(),
+								id_user: this['id_user'] || '',
+								user: this['user'] || '',
+								email: sendTo,
+								success: true,
+								verified: false
+							});
+						}
+					});
+				}
+				else {
+					console.log('Send email', sendTo, subject, text, html, attachments, send_from);
+				}
+
+				resolve(true);
+			}
+		});
+	}
+
+	public getAWS(): AWS {
+		return this._aws;
+	}
+
+	public readFile(fileName) {
+		return new Promise((resolve, reject) => {
+			if (fs.existsSync(path.join(__dirname, ('../private/' + fileName)))) {
+				fs.readFile(path.join(__dirname, ('../private/' + fileName)), 'utf-8', (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', (err, res) => { 
+						if (err) {
+							reject(err);
+						}
+						else {
+							resolve(res);
+						}
+					});
+				}
+			}
+		});
+	}
+
+	public readImage(fileName) {
+		return new Promise((resolve, reject) => {
+			if (fs.existsSync(path.join(__dirname, ('../private/' + fileName)))) {
+				fs.readFile(path.join(__dirname, ('../private/' + fileName)), 'base64', (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', (err, res) => { 
+						if (err) {
+							reject(err);
+						}
+						else {
+							resolve(res);
+						}
+					});
+				}
+			}
+		});
+	}
+}