@resolveio/server-lib 22.3.220 → 22.3.221

package/src/collections/user.collection.ts

@@ -0,0 +1,181 @@
+import { MongoManagerModel, MongoManagerUserCollection } from '../managers/mongo.manager';
+import { UserModel } from '../models/user.model';
+import { ResolveIOServer } from '../resolveio-server-app';
+
+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.$.yards': {
+		type: Array,
+		optional: true
+	},
+	'roles.groups.$.yards.$': {
+		type: String
+	},
+	'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,
+		blackbox: true
+	},
+	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
+	},
+	is_customer: {
+		type: Boolean,
+		optional: true
+	}
+};
+
+export let Users: MongoManagerUserCollection<UserModel> = null;
+export let UserVersions: MongoManagerUserCollection<UserModel> = null;
+
+initializeCollection();
+
+function initializeCollection() {
+	if (ResolveIOServer && ResolveIOServer.getMainDB() && MongoManagerModel) {
+		const model = MongoManagerModel.create<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 {
+		setImmediate(() => {
+			initializeCollection();
+		});
+	}
+}

package/src/cron/cron.ts

@@ -0,0 +1,117 @@
+import { CronCommand, CronJob, CronJobParams, CronOnCompleteCommand } from 'cron';
+
+export class CronJobManager {
+	private jobs: { [key: string]: CronJob };
+
+    constructor(key?: string, tab?: string | Date, task?: CronCommand<any, boolean>, onComplete?: CronOnCompleteCommand, start?: boolean, timeZone?: string, context?: CronJobParams, runOnInit?: boolean) {
+        this.jobs = {};
+        if (key && tab && task) {
+			setImmediate(async () => {
+				await this.add(key, tab, task, onComplete, start, timeZone, context, runOnInit);
+			});
+        }
+    }
+
+    getJob(key: string): CronJob {
+        return this.jobs[key];
+    }
+
+    getJobs(): string[] {
+        return Object.keys(this.jobs);
+    }
+
+    async add(key: string, tab: string | Date, task: CronCommand<any, boolean>, onComplete?: CronOnCompleteCommand, start?: boolean, timeZone?: string, context?: CronJobParams, runOnInit?: boolean): Promise<void> {
+		if ((typeof tab === 'string' || tab instanceof Date) && typeof key === 'string' && task instanceof Function) {
+			try {
+				if (this.jobs[key]) {
+					await this.delete(key);
+					console.warn(`${key} already existed and was deleted from the manager...`);
+				}
+				this.jobs[key] = new CronJob(tab, task, onComplete, start, timeZone, context, runOnInit);
+			} catch (fooBaredByUser) {
+				console.error(`crontab: ${tab} possibly not valid, job ${key} not started...${fooBaredByUser.message}`);
+			}
+		} else {
+			console.warn(`couldn't add: ${key} improper arguments`);
+		}
+	}
+
+	async update(key: string, tab: string | Date, task: CronCommand<any, boolean>, onComplete?: () => void, start?: boolean, timeZone?: string, context?: any, runOnInit?: boolean): Promise<void> {
+		// Check if the job exists
+		if (!this.jobs[key]) {
+			console.warn(`Job with key ${key} does not exist.`);
+			return;
+		}
+
+		// Store the running state
+		const wasRunning = this.jobs[key].isActive;
+	
+		// Stop the existing job
+		await this.jobs[key].stop();
+	
+		// Create a new job instance with the updated properties
+		const newJob = new CronJob(
+			tab,
+			task,
+			onComplete,
+			start || wasRunning,
+			timeZone,
+			context,
+			runOnInit
+		);
+
+		delete this.jobs[key];
+	
+		// Replace the old job with the new one
+		this.jobs[key] = newJob;
+	}
+	
+	
+	async delete(key: string) {
+		try {
+			await this.jobs[key].stop();
+			delete this.jobs[key];
+		}
+		catch (err) { 
+			console.error(new Date(), `Error in CronJobManager (delete): Trying to stop job: ${key}: ${err}`);
+		}
+	}
+
+	start(key: string) {
+		try {
+			if (this.jobs[key].isActive) {
+				console.warn(`${key} job already running`);
+			}
+			else {
+				this.jobs[key].start();
+			}
+		}
+		catch (err) {
+			console.error(`couldn't start job: ${key}: ${err}`);
+		}
+	}
+
+	async stop(key: string) {
+		try {
+			if (!this.jobs[key].isActive) {
+				console.warn(`${key} job already stopped`);
+			}
+			else {
+				await this.jobs[key].stop();
+			}
+		}
+		catch (err) {
+			console.error(`couldn't stop job: ${key}: ${err}`);
+		}
+	}
+
+	async stopAll() {
+		for (let jobKey in this.jobs) {
+			await this.jobs[jobKey].stop();
+		}
+	}
+
+	exists(key: string) {
+		return !!this.jobs[key];
+	}
+}

package/src/fixtures/cron-jobs.ts

@@ -0,0 +1,95 @@
+import { CronJobs } from '../collections/cron-job.collection';
+import { objectIdHexString } from '../util/common';
+
+const AI_USAGE_SYNC_JOB_NAME = 'AI Usage Billing Sync';
+const LEGACY_AI_USAGE_SYNC_JOB_NAME = 'OpenAI Usage Billing Sync';
+
+function shouldSkipServerFixtureWrites(): boolean {
+	const readonlyFlag = String(process.env.AI_ASSISTANT_READONLY_MONGO || '').trim().toLowerCase();
+	if (readonlyFlag === 'true' || readonlyFlag === '1' || readonlyFlag === 'yes') {
+		return true;
+	}
+	const mongoUrl = String(process.env.MONGO_URL || '').trim().toLowerCase();
+	return mongoUrl.includes('mongodb://readonly:');
+}
+
+export async function loadServerCronJobs() {
+	if (shouldSkipServerFixtureWrites()) {
+		return;
+	}
+	
+	let cronJobs = await CronJobs.find({});
+
+	if (!cronJobs.some(a => a.name === 'Email Merged Docs Cleanup')) {
+		await 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,
+			timezone: process.env.TZ_CLIENT || 'America/Chicago'
+		});
+	}
+
+	if (!cronJobs.some(a => a.name === 'Stuck Cron Job')) {
+		await CronJobs.create({
+			_id: objectIdHexString(),
+			__v: 0,
+			name : 'Stuck Cron Job', 
+			repeat : true, 
+			time_to_run : '*/5 * * * *', 
+			method_run : 'stuckCronJob', 
+			method_run_data : null, 
+			next_run : new Date(), 
+			running : false,
+			timezone: process.env.TZ_CLIENT || 'America/Chicago'
+		});
+	}
+
+	const aiUsageSyncJob = cronJobs.find(
+		a => a.name === AI_USAGE_SYNC_JOB_NAME || a.name === LEGACY_AI_USAGE_SYNC_JOB_NAME
+	);
+	if (!aiUsageSyncJob) {
+		await CronJobs.create({
+			_id: objectIdHexString(),
+			__v: 0,
+			name : AI_USAGE_SYNC_JOB_NAME,
+			repeat : true,
+			time_to_run : '0 * * * *',
+			method_run : 'cronOpenAIUsageBillingSync',
+			method_run_data : {},
+			next_run : new Date(),
+			running : false,
+			timezone: process.env.TZ_CLIENT || 'America/Chicago'
+		});
+	}
+	else if (aiUsageSyncJob.name === LEGACY_AI_USAGE_SYNC_JOB_NAME) {
+		await CronJobs.updateOne(
+			{ _id: aiUsageSyncJob._id },
+			{ $set: { name: AI_USAGE_SYNC_JOB_NAME } }
+		);
+	}
+
+	if (!cronJobs.some(a => a.name === 'Communication Metrics Sync')) {
+		await CronJobs.create({
+			_id: objectIdHexString(),
+			__v: 0,
+			name : 'Communication Metrics Sync',
+			repeat : true,
+			time_to_run : '15 * * * *',
+			method_run : 'cronCommunicationMetricsSync',
+			method_run_data : {},
+			next_run : new Date(),
+			running : false,
+			timezone: process.env.TZ_CLIENT || 'America/Chicago'
+		});
+	}
+
+	if (cronJobs.some(a => a.running)) {
+		await CronJobs.updateMany({running: true}, {$set: {running: false}});
+	}
+}

package/src/fixtures/init.ts

@@ -0,0 +1,35 @@
+import { EmailHistories } from '../collections/email-history.collection';
+import { Flags } from '../collections/flag.collection';
+import { ResolveIOServer } from '../resolveio-server-app';
+
+function shouldSkipServerFixtureWrites(): boolean {
+	const readonlyFlag = String(process.env.AI_ASSISTANT_READONLY_MONGO || '').trim().toLowerCase();
+	if (readonlyFlag === 'true' || readonlyFlag === '1' || readonlyFlag === 'yes') {
+		return true;
+	}
+	const mongoUrl = String(process.env.MONGO_URL || '').trim().toLowerCase();
+	return mongoUrl.includes('mongodb://readonly:');
+}
+
+export async function loadServerInit() {
+	if (shouldSkipServerFixtureWrites()) {
+		return;
+	}
+
+	await EmailHistories.updateMany({status: 'processing'}, {$set: {status: 'pending'}});
+
+	let enableDebugFlag = await Flags.findOne({type: 'Enable Debug'});
+
+	if (!enableDebugFlag) {
+		await Flags.insertOne({type: 'Enable Debug', value: false});
+	}
+
+	let enableDebugFlagPDF = await Flags.findOne({type: 'Enable Debug PDF'});
+
+	if (!enableDebugFlagPDF) {
+		await Flags.insertOne({type: 'Enable Debug PDF', value: false});
+	}
+	else if (enableDebugFlagPDF.value && ResolveIOServer.getServerConfig()['ROOT_URL'] !== 'http://localhost:4200') {
+		await Flags.updateOne({_id: enableDebugFlagPDF._id}, {$set: {value: false}});
+	}
+}