@resolveio/server-lib 12.5.53 → 12.5.54

package/src/http/health.ts

@@ -0,0 +1,7 @@
+import * as bodyParser from 'body-parser';
+
+export function setupHealthRoutes(app, serverConfig) {
+	app.get('/health', bodyParser.json(), function (request, response) {
+		response.sendStatus(200);
+	});
+}

package/src/http/home.ts

@@ -0,0 +1,71 @@
+import ResolveIOMainServer from '../server-app';
+import SimpleSchema from 'simpl-schema';
+import { ResolveIOServer } from '..';
+import * as bodyParser from 'body-parser';
+
+export function setupHomeRoutes(mainServer: ResolveIOMainServer, app, serverConfig) {
+	app.post('/resolveioContactUs', bodyParser.json(), function (request, response) {
+		if (request.headers.origin !== serverConfig['ROOT_URL'] && request.headers.origin !== serverConfig['SEC_ROOT_URL']) {
+			response.send(JSON.stringify({
+				error: true,
+				result: 'Invalid header'
+			}));
+		}
+		else {
+			let body = request.body;
+
+			let schema = new SimpleSchema({
+				form: {
+					type: Object
+				},
+				'form.name': {
+					type: String
+				},
+				'form.email': {
+					type: String
+				},
+				'form.phone': {
+					type: String
+				},
+				'form.subject': {
+					type: String
+				},
+				'form.message': {
+					type: String
+				}
+			});
+	
+			try {
+				schema.validate(body);
+			}
+			catch (errors) {
+				if (errors) {
+					console.error(new Date(), 'Error in HTTP Check (/resolveioContactUs)', errors);
+	
+					ResolveIOServer.getMainServer().getMethodManager().sendEmail('dev@resolveio.com', ResolveIOServer.getClientName() + 'HTTP - Error Detected', 'Match Error On HTTP ' + '/resolveioContactUs' + '\n\nData Being Checked\n' + JSON.stringify(body, null, 2) + '\n\nErrors\n' + JSON.stringify(errors, null, 2));
+	
+					response.send(JSON.stringify({
+						error: true,
+						result: 'Invalid Parameters'
+					}));
+		
+					return;
+				}
+			}
+
+            let form = request.body.form;
+            
+            mainServer.getMethodManager().sendEmail('dustin@resolveio.com', 'ResolveIO - Contact Us', '', 
+            'Name: ' + form.name + '<br>' + 
+            'Email: ' + form.email + '<br>' + 
+            'Phone: ' + form.phone + '<br>' + 
+            'Subject: ' + form.subject + '<br>' + 
+            'Message: ' + form.message + '<br>');
+
+            response.send(JSON.stringify({
+				error: false,
+				result: null
+			}));
+		}
+	});
+}

package/src/index.ts

@@ -0,0 +1,71 @@
+import { Db, MongoClient } from 'mongodb';
+import { MongoManager } from './managers/mongo.manager';
+import ResolveIOMainServer from './server-app';
+
+export class ResolveIOServer {
+	private static _serverConfig = null;
+	private static _clientRoutes = [];
+	private static _mongoConnection: MongoClient = null;
+	private static _mainDB: Db = null;
+	private static _mainServer: ResolveIOMainServer = null;
+	private static _mongoManager: MongoManager = null;
+	private static _client = '';
+	private static _clientDir = '';
+	private static _sesMail = true;
+	private static _standardProgram = false;
+
+	constructor(serverConfig, clientRoutes: string[], client: string, clientDir, sesMail = true, standardProgram = false) {
+		ResolveIOServer._serverConfig = serverConfig;
+		ResolveIOServer._clientRoutes = clientRoutes;
+		ResolveIOServer._client = client;
+		ResolveIOServer._clientDir = clientDir;
+		ResolveIOServer._sesMail = sesMail;
+		ResolveIOServer._standardProgram = standardProgram;
+	}
+
+	public static connectAndRun() {
+		return new Promise((resolve, reject) => {
+			MongoClient.connect(ResolveIOServer._serverConfig['MONGO_URL']).then(dbConnection => {
+				// dbConnection.db().listCollections().toArray().then(collections => {
+					ResolveIOServer._mongoConnection = dbConnection;
+					ResolveIOServer._mainDB = dbConnection.db(ResolveIOServer._serverConfig['DATABASE']);
+					// ResolveIOServer._mongoManager = new MongoManager(collections);
+					ResolveIOServer._mongoManager = new MongoManager();
+					
+					setTimeout(async () => {
+						let serverApp = (await import('./server-app')).default;
+						ResolveIOServer._mainServer = new serverApp(this, ResolveIOServer._serverConfig, ResolveIOServer._clientRoutes, this._clientDir, this._sesMail, this._standardProgram);
+
+						resolve(true);
+					}, 1);
+				// });
+			}, err => {
+				console.error(new Date(), 'MONGO CLIENT CONNECT FAILED', JSON.stringify(err, null, 2));
+				reject();
+				process.exit(1);
+			});
+		});
+	}
+
+	public static getClientName() {
+		return this._client;
+	}
+
+	public static getMainServer() {
+		return ResolveIOServer._mainServer;
+	}
+
+	public static getMongoConnection() {
+		return ResolveIOServer._mongoConnection;
+	}
+
+	public static getMainDB() {
+		return ResolveIOServer._mainDB;
+	}
+
+	public static getMongoManager() {
+		return ResolveIOServer._mongoManager;
+	}
+}
+
+export * from './public_api';

package/src/managers/cron.manager.ts

@@ -0,0 +1,208 @@
+import { CronJobModel } from '../models/cron-job.model';
+import { CronJobs } from '../collections/cron-job.collection';
+import ResolveIOMainServer from '../server-app';
+let CronJobManager = require('../cron/cron');
+import * as moment from 'moment';
+import { ChangeStream, ChangeStreamDocument } from 'mongodb';
+
+export class CronManager {
+
+	private _cronManager;
+	private _mainServer: ResolveIOMainServer;
+	private _watchCrons$: ChangeStream;
+	private _jobs: CronJobModel[] = [];
+
+	constructor(mainServer) {
+		this._mainServer = mainServer;
+		this._cronManager = new CronJobManager();
+
+		this.watchCrons();
+	}
+
+	public async watchCrons() {
+		if (!this._watchCrons$ || this._watchCrons$.closed) {
+			CronJobs.find().then(res => {
+				this._jobs = res;
+
+				this._jobs.forEach(job => {
+					this.addCronJob(job);
+				});
+			});
+
+			this._watchCrons$ = CronJobs.watchCollection([], {fullDocument: 'updateLookup'});
+
+			this._watchCrons$.on('change', async (doc: ChangeStreamDocument<CronJobModel>) => {
+				if (doc.operationType === 'insert') {
+					if (doc.fullDocument) {
+						if (!this._jobs.some(a => a._id === <any>doc.documentKey['_id'])) {
+							this._jobs.push(doc.fullDocument);
+						}
+
+						this.addCronJob(doc.fullDocument);
+					}
+				}
+				else if (doc.operationType === 'replace' || doc.operationType === 'update') {
+					if (doc.fullDocument) {
+						if (this._jobs.some(a => a._id === <any>doc.documentKey['_id'])) {
+							this._jobs.splice(this._jobs.map(a => a._id).indexOf(<any>doc.documentKey['_id']), 1, doc.fullDocument);
+							this.updateCronJob(doc.fullDocument);
+						}
+						else {
+							this._jobs.push(doc.fullDocument);
+							this.addCronJob(doc.fullDocument);
+						}
+					}
+					else {
+						if (this._jobs.some(a => a._id === <any>doc.documentKey['_id'])) {
+							let job = this._jobs.filter(a => a._id === <any>doc.documentKey['_id'])[0];
+							this.removeCronJob(job.name);
+							this._jobs.splice(this._jobs.map(a => a._id).indexOf(<any>doc.documentKey['_id']), 1);
+						}
+					}
+				}
+				else if (doc.operationType === 'delete') {
+					if (this._jobs.some(a => a._id === (<any>doc).documentKey['_id'])) {
+						let job = this._jobs.filter(a => a._id === <any>doc.documentKey['_id'])[0];
+						this.removeCronJob(job.name);
+						this._jobs.splice(this._jobs.map(a => a._id).indexOf(<any>doc.documentKey['_id']), 1);
+					}
+				}
+			})
+			.on('error', (err) => {
+				this._watchCrons$.close();
+			})
+			.on('end', () => {
+				this._watchCrons$.close();
+			})
+			.on('close', () => {
+				this._watchCrons$ = null;
+				this.watchCrons();
+			});
+		}
+		else {
+			this._watchCrons$.close();
+		}
+	}
+
+	private doesCronJobExist(cron: CronJobModel) {
+		return this._cronManager.exists(cron.name);
+	}
+
+	private doesCronJobNameExist(cron_name: string) {
+		return this._cronManager.exists(cron_name);
+	}
+
+	private addCronJob(cron: CronJobModel) {
+		if (cron.running) {
+			CronJobs.updateOne({_id: cron._id}, {$set: {running: false}});
+		}
+		
+		if (!this.doesCronJobExist(cron)) {
+			if (cron.timezone) {
+
+			}
+			else {
+				let cronOptions = {
+					start: true,
+					// onComplete: () => {
+					// 	this.runCronJobCompleted(cron);
+					// },
+					// timeZone: cron.timezone
+				};
+
+				if (cron.timezone) {
+					cronOptions['timeZone'] = cron.timezone;
+				}
+
+				this._cronManager.add(
+					cron.name,
+					cron.time_to_run,
+					() => {
+						this.runCronJob(cron);
+					},
+					cronOptions
+				);
+			}
+		}
+	}
+
+	private updateCronJob(cron: CronJobModel) {
+		if (this.doesCronJobExist(cron)) {
+			this._cronManager.update(cron.name, cron.time_to_run);
+		}
+	}
+
+	private removeCronJob(cron_name: string) {
+		if (this.doesCronJobNameExist(cron_name)) {
+			this._cronManager.deleteJob(cron_name);
+		}
+	}
+
+	private startCronJob(cron: CronJobModel) {
+		if (this.doesCronJobExist(cron)) {
+			this._cronManager.start(cron.name);
+		}
+	}
+
+	private stopCronJob(cron: CronJobModel) {
+		if (this.doesCronJobExist(cron)) {
+			this._cronManager.start(cron.name);
+		}
+	}
+
+	private stopAllCronJobs() {
+		this._cronManager.stopAll();
+	}
+
+	private runCronJob(cron: CronJobModel) {
+		let now = new Date();
+
+		if (!cron.next_run || now.getTime() >= cron.next_run.getTime()) {
+
+			CronJobs.findOneAndUpdate({
+				$and: [
+					{_id: cron._id},
+					{running: false},
+					{
+						$or: [
+							{next_run: {$exists: false}},
+							{next_run: null},
+							{next_run: {$lte: now}}
+						]
+					}
+				]
+			}, {$set: {running: true}}).then(async res => {
+				if (res) {
+					try {
+						if (res.method_run_data) {
+							await this._mainServer.getMethodManager().callMethodCron(res.method_run, res.method_run_data);	
+						}
+						else {
+							await this._mainServer.getMethodManager().callMethodCron(res.method_run);
+						}
+
+						if (res.method_complete) {
+							if (res.method_complete_data) {
+								await this._mainServer.getMethodManager().callMethodCron(res.method_complete, res.method_complete_data);
+							}
+							else {
+								await this._mainServer.getMethodManager().callMethodCron(res.method_complete);
+							}
+						}
+					}
+					catch (err) {
+						console.log(new Date(), 'Cron Error', JSON.stringify(err, null, 2));
+					}
+	
+					if (res.repeat) {
+						let nextDate = (<moment.Moment>this._cronManager.getJob(res.name).nextDates()).second(0).millisecond(0).toDate();
+						CronJobs.updateOne({_id: res._id}, {$set: {running: false, next_run: nextDate}});
+					} 
+					else {
+						CronJobs.deleteOne({_id: res._id});
+					}
+				}
+			}, () => {});
+		}
+	}
+}