@resolveio/server-lib 12.5.54 → 12.5.55

package/src/http/health.ts

@@ -1,7 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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

@@ -1,208 +0,0 @@
-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});
-					}
-				}
-			}, () => {});
-		}
-	}
-}