@resolveio/server-lib 12.5.53 → 12.5.54

package/src/collections/user.collection.ts

@@ -0,0 +1,259 @@
+import { ResolveIOServer } from '../index';
+import { MongoManagerModel, MongoManagerUserCollection } from '../managers/mongo.manager';
+import { UserModel } from '../models/user.model';
+
+let schema: any = {
+	_id: {
+		type: String,
+		optional: true
+	},
+	__v: {
+		type: Number,
+		optional: true
+	},
+	updatedAt: {
+		type: Date,
+		optional: true
+	},
+	createdAt: {
+		type: Date,
+		optional: true
+	},
+	roles: {
+		type: Object
+	},
+	'roles.super_admin': {
+		type: Boolean
+	},
+	'roles.approvals': {
+		type: Array
+	},
+	'roles.approvals.$': {
+		type: Object
+	},
+	'roles.approvals.$.type': {
+		type: String
+	},
+	'roles.approvals.$.key_1': {
+		type: String,
+		optional: true
+	},
+	'roles.approvals.$.key_2': {
+		type: String,
+		optional: true
+	},
+	'roles.approvals.$.key_3': {
+		type: String,
+		optional: true
+	},
+	'roles.approvals.$.name': {
+		type: String
+	},
+	'roles.groups': {
+		type: Array
+	},
+	'roles.groups.$': {
+		type: Object
+	},
+	'roles.groups.$.name': {
+		type: String
+	},
+	'roles.groups.$.views': {
+		type: Array
+	},
+	'roles.groups.$.views.$': {
+		type: String
+	},
+	'roles.groups.$.yard': {
+		type: String,
+		optional: true
+	},
+	'roles.notifications': {
+		type: Array
+	},
+	'roles.notifications.$': {
+		type: String
+	},
+	'roles.miscs': {
+		type: Array
+	},
+	'roles.miscs.$': {
+		type: String
+	},
+	username: {
+		type: String,
+		optional: true
+	},
+	email: {
+		type: String,
+		optional: true
+	},
+	fullname: {
+		type: String
+	},
+	active: {
+		type: Boolean
+	},
+	phonenumber: {
+		type: String,
+		optional: true
+	},
+	readonly: {
+		type: Boolean,
+		optional: true
+	},
+	other: {
+		type: Object,
+		blackbox: true
+	},
+	settings: {
+		type: Object,
+		optional: true
+	},
+	'settings.table_color': {
+		type: String
+	},
+	'settings.table_font_color': {
+		type: String
+	},
+	'settings.secondary_table_color': {
+		type: String
+	},
+	'settings.secondary_table_font_color': {
+		type: String
+	},
+	'settings.tertiary_table_color': {
+		type: String
+	},
+	'settings.tertiary_table_font_color': {
+		type: String
+	},
+	'settings.font_size': {
+		type: Number
+	},
+	'settings.collapsable_menu': {
+		type: Boolean
+	},
+	'settings.entries_per_page': {
+		type: String
+	},
+	'settings.warning_color': {
+		type: String
+	},
+	'settings.warning_font_color': {
+		type: String
+	},
+	'settings.warning_hover_color': {
+		type: String
+	},
+	'settings.success_color': {
+		type: String
+	},
+	'settings.success_font_color': {
+		type: String
+	},
+	'settings.success_hover_color': {
+		type: String
+	},
+	'settings.danger_color': {
+		type: String
+	},
+	'settings.danger_font_color': {
+		type: String
+	},
+	'settings.danger_hover_color': {
+		type: String
+	},
+	'settings.info_color': {
+		type: String
+	},
+	'settings.info_font_color': {
+		type: String
+	},
+	'settings.info_hover_color': {
+		type: String
+	},
+	'settings.primary_color': {
+		type: String
+	},
+	'settings.primary_font_color': {
+		type: String
+	},
+	'settings.primary_hover_color': {
+		type: String
+	},
+	'settings.secondary_color': {
+		type: String
+	},
+	'settings.secondary_font_color': {
+		type: String
+	},
+	'settings.secondary_hover_color': {
+		type: String
+	},
+	'settings.routing_preference': {
+		type: String
+	},
+	'settings.opening_route': {
+		type: String
+	},
+	salt: {
+		type: String
+	},
+	hash: {
+		type: String
+	},
+	attempts: {
+		type: Number
+	},
+	last: {
+		type: Date,
+		optional: true
+	},
+	services: {
+		type: Object,
+		optional: true
+	},
+	'services.enrollment': {
+		type: String,
+		optional: true
+	},
+	'services.forgot_password': {
+		type: String,
+		optional: true
+	},
+	'services.reset_password': {
+		type: String,
+		optional: true
+	},
+};
+
+export let Users: MongoManagerUserCollection<UserModel> = null;
+export let UserVersions: MongoManagerUserCollection<UserModel> = null;
+
+initializeCollection();
+
+function initializeCollection() {
+	if (ResolveIOServer && ResolveIOServer.getMainDB()) {
+		const model = new MongoManagerModel<UserModel>({
+			collectionName: 'users',
+			schema: schema,
+			useVersionCollection: true,
+			useReportBuilder: true,
+			reportBuilderLookupTables: [],
+			timestamps: true,
+			createLogs: true,
+			checkSchema: true,
+			collectionOptions: null
+		});
+		Users = <MongoManagerUserCollection<UserModel>>model.collection_main;
+		Users.createIndex({fullname: 1});
+		Users.createIndex({active: 1});
+		UserVersions = <MongoManagerUserCollection<UserModel>>model.collection_version;
+	}
+	else {
+		setTimeout(() => {
+			initializeCollection();
+		}, 1);
+	}
+}

package/src/cron/cron.ts

@@ -0,0 +1,188 @@
+let CronJobPackage = require('cron').CronJob;
+
+function CrontabManager(key, tab, task, options) {
+	this.jobs = {};
+	if (key && tab && task) {
+		this.add(key, tab, task, options);
+	}
+
+}
+
+CrontabManager.prototype.getJob = function(key) {
+	return this.jobs[key];
+};
+
+CrontabManager.prototype.getJobs = function() {
+	return Object.keys(this.jobs);
+};
+
+CrontabManager.prototype.add = function(key, tab, task, options) {
+	if ((typeof tab === 'string' || tab instanceof Date) && typeof key === 'string' && task instanceof Function) {
+		options = combineOptions(tab, task, options);
+		try {
+			if (this.jobs[key]) {
+				this.deleteJob(key);
+				console.warn(`${key} already existed and was deleted from the manager...`);
+			}
+			
+			this.jobs[key] = new CronJobPackage(options);
+		} 
+		catch (fooBaredByUser) {
+			console.error(`crontab: ${tab} possibly not valid, job ${key} not started...${fooBaredByUser.message}`);
+		}
+	}
+	else {
+		console.warn(`couldn't add: ${key} improper arguments`);
+	}
+};
+
+CrontabManager.prototype.update = function() {
+	if (arguments.length === 2) {
+		if (typeof arguments[1] === 'string' || arguments[1] instanceof Date) {
+			updateTab.call(this, arguments[0], arguments[1]);
+		}
+		else if (arguments[1] instanceof Function) {
+			updateTask.call(this,  arguments[0], arguments[1]);
+		}
+	} 
+	else if (arguments.length === 3) {
+		updateTab.call(this, arguments[0], arguments[1]);
+		updateTask.call(this,  arguments[0], arguments[2]);
+	}
+	else {
+		console.error(`incorrect number of arguents passed to update.. won't update.. ${arguments[0]}`);
+	}
+};
+
+CrontabManager.prototype.deleteJob = function(key) {
+	try {
+		this.jobs[key].stop();
+		delete this.jobs[key];
+	}
+	catch (err) { 
+		console.error(new Date(), `error in trying to stop job: ${key}: ${err}`);
+	}
+};
+
+CrontabManager.prototype.start = function(key) {
+	try {
+		if (this.jobs[key].running) {
+			console.warn(`${key} job already running`);
+		}
+		else {
+			this.jobs[key].start();
+		}
+	}
+	catch (err) {
+		console.error(`couldn't start job: ${key}: ${err}`);
+	}
+};
+
+CrontabManager.prototype.stop = function(key) {
+	try {
+		if (! this.jobs[key].running ) {
+			console.warn(`${key} job already stopped`);
+		}
+		else {
+			this.jobs[key].stop();
+		}
+	}
+	catch (err) {
+		console.error(`couldn't stop job: ${key}: ${err}`);
+	}
+};
+
+CrontabManager.prototype.stopAll = function() {
+	// tslint:disable-next-line:forin
+	for (let jobKey in this.jobs) {
+		try {
+			this.jobs[jobKey].stop();
+		}
+		catch (err) {
+
+		}
+	}
+};
+
+CrontabManager.prototype.toString = function() {
+	let manString = '{\n';
+	// tslint:disable-next-line:forin
+	for (let jobKey in this.jobs) {
+
+		manString += `'${jobKey}': ${this.jobs[jobKey].cronTime.source}: ${this.jobs[jobKey]._callbacks[0]}: ${this.jobs[jobKey].running ? 'Running' : 'Stopped'}`;
+	}
+	manString += '\n}';
+	return manString;
+};
+
+CrontabManager.prototype.listCrons = function() {
+	let manString = '{\n';
+	// tslint:disable-next-line:forin
+	for (let jobKey in this.jobs) {
+		manString += `'${jobKey}': ${this.jobs[jobKey].cronTime.source} status: ${this.jobs[jobKey].running ? 'Running' : 'Stopped'} \n`;
+	}
+	manString += '\n}';
+	return manString;
+};
+
+CrontabManager.prototype.exists = function(tabKey) {
+	if (this.jobs[tabKey]) {
+		return true;
+	}
+
+	return false;
+};
+
+function combineOptions(tab, task, options) {
+	let newOpts = {};
+	newOpts['cronTime'] = tab; 
+	newOpts['onTick'] = task;
+
+	if (options instanceof Object) {
+		// might overwrite... please be careful.
+		// tslint:disable-next-line:forin
+		for (let optionKey in options) {
+			newOpts[optionKey] = options[optionKey];
+		}
+	}
+	return newOpts;
+}
+
+function updateTab(key, cronstring) {
+
+	try {
+		let running = this.jobs[key].running;
+		this.jobs[key].stop();
+
+		if (typeof cronstring === 'string' || cronstring instanceof Date) {
+			this.jobs[key] =  new CronJobPackage(cronstring, this.jobs[key]._callbacks[0], this.jobs[key].onComplete, running, this.jobs[key].zone);
+		}
+		else {
+			throw new Error(`The cron definition passed was not a string or a Date object! ${key} was stopped and not updated`);
+		}
+	}
+	catch (tabErr) {
+		console.error(`error updating tab: ${key} - ${tabErr.message}`);
+	}
+}
+
+function updateTask(key, task) {
+	try {
+		let running = this.jobs[key].running;
+		this.jobs[key].stop();
+
+		if (!(task instanceof Function)) {
+			console.error(`can't update with something that is not a function: ${typeof(task)}`);
+			return;
+		}
+
+		this.jobs[key] =  new CronJobPackage(this.jobs[key].cronTime.source, task, this.jobs[key].onComplete, running, this.jobs[key].zone);
+
+
+	} 
+	catch (tabErr) {
+		console.error(`error updating task: ${key}  - ${tabErr.message}`);
+	}
+}
+
+module.exports = CrontabManager;

package/src/fixtures/cron-jobs.ts

@@ -0,0 +1,25 @@
+import { CronJobs } from '../collections/cron-job.collection';
+import { objectIdHexString } from '../managers/mongo.manager';
+
+export async function loadServerCronJobs() {
+
+	let cronJobs = await CronJobs.find({});
+
+	if (!cronJobs.some(a => a.name === 'Email Merged Docs Cleanup')) {
+		CronJobs.create({
+			_id: objectIdHexString(),
+			__v: 0,
+			name : 'Email Merged Docs Cleanup', 
+			repeat : true, 
+			time_to_run : '0 0 * * *', 
+			method_run : 'cronEmailMergedDocsCleanUp', 
+			method_run_data : null, 
+			next_run : new Date(), 
+			running : false
+		});
+	}
+
+	if (cronJobs.some(a => a.running)) {
+		CronJobs.updateMany({running: true}, {$set: {running: false}});
+	}
+}

package/src/fixtures/init.ts

@@ -0,0 +1,10 @@
+import { objectIdHexString } from '../managers/mongo.manager';
+import { Flags } from '../collections/flag.collection';
+
+export async function loadServerInit() {
+	let enableDebugFlag = await Flags.findOne({type: 'Enable Debug'});
+
+	if (!enableDebugFlag) {
+		Flags.insertOne({type: 'Enable Debug', value: false});
+	}
+}