@resolveio/server-lib 22.3.221 → 22.3.223

package/src/collections/user.collection.ts

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

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

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

@@ -1,35 +0,0 @@
-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}});
-	}
-}