@resolveio/server-lib 22.3.221 → 22.3.222

package/src/methods/accounts.ts

@@ -1,532 +0,0 @@
-import * as handlebars from 'handlebars';
-import * as jwt from 'jsonwebtoken';
-import SimpleSchema from 'simpl-schema';
-import { Users } from '../collections/user.collection';
-import { MethodManager } from '../managers/method.manager';
-import { StickySelectOption, StickySelectPreference, UserModel } from '../models/user.model';
-import { ResolveIOServer } from '../resolveio-server-app';
-import { deepCopy, objectIdHexString } from '../util/common';
-import { getDecryptedCustomerPortalPassword, isCustomerPortalUser, saveCustomerPortalPassword } from '../util/customer-portal-password';
-import { ErrorReporter } from '../util/error-reporter';
-
-export function loadAccountMethods(methodManager: MethodManager) {
-	methodManager.methods({
-		incorrectUser: {
-			check: new SimpleSchema({
-				old_user: {
-					type: Object,
-					blackbox: true
-				},
-				new_user: {
-					type: Object,
-					blackbox: true
-				},
-				client_subs: {
-					type: Array
-				},
-				'client_subs.$': {
-					type: Object,
-					blackbox: true
-				}
-			}),
-			function: async function(old_user, new_user, client_subs) {
-				if (ResolveIOServer.getMainServer()) {
-					let ws = ResolveIOServer.getMainServer().getWebSocketManager().getWebSocket(this.id_ws);
-					const correlationId = objectIdHexString();
-					await ErrorReporter.report({
-						sourceApp: 'method-accounts',
-						message: 'SERVER - WRONG USER Detected - ' + this.serverConfig['CLIENT_NAME'],
-						environment: this.serverConfig?.ROOT_URL,
-						clientSlug: ResolveIOServer.getClientName(),
-						clientName: this.serverConfig['CLIENT_NAME'],
-						context: {
-							ws,
-							userMethod: this.user,
-							id_user: this.id_user,
-							activeSubs: ResolveIOServer.getMainServer().getSubscriptionManager().getActiveSubscriptions(),
-							old_user,
-							new_user,
-							client_subs
-						},
-						metadata: {
-							context: 'incorrectUser',
-							correlationId
-						},
-						correlationId
-					});
-				}
-
-				return Promise.resolve(null);
-			}
-		},
-		reloadWS: {
-			check: new SimpleSchema({
-				id_ws: String
-			}),
-			function: async function(id_ws) {
-				let ws = ResolveIOServer.getMainServer().getWebSocketManager().getWebSocket(id_ws);
-
-				if (ws) {
-					await ResolveIOServer.getMainServer().unsubscribeWS(ws);
-					return true;
-				}
-				else {
-					throw new Error('Error in Reload WS: No WS');
-				}
-			}
-		},
-		reconnectWS: {
-			check: new SimpleSchema({
-				id_ws: String
-			}),
-			function: async function(id_ws) {
-				let ws = ResolveIOServer.getMainServer().getWebSocketManager().getWebSocket(id_ws);
-
-				if (ws) {
-					await ResolveIOServer.getMainServer().unsubscribeWS(ws);
-					return true;
-				}
-				else {
-					throw new Error('Error in Reconnect WS: No WS');
-				}
-			}
-		},
-		disconnectWS: {
-			check: new SimpleSchema({
-				id_ws: String
-			}),
-			function: async function(id_ws) {
-				let ws = ResolveIOServer.getMainServer().getWebSocketManager().getWebSocket(id_ws);
-
-				if (ws) {
-					await ResolveIOServer.getMainServer().unsubscribeWS(ws);
-					return true
-				}
-				else {
-					throw new Error('Error in Disconnect WS: No WS');
-				}
-			}
-		},
-		createUserAndEmailEnrollment: {
-			check: new SimpleSchema({
-				newUser: {
-					type: Users['simplschema']
-				},
-				sendEnrollmentEmail: {
-					type: Boolean,
-					optional: true
-				}
-			}),
-			function: async function(newUser: UserModel, sendEnrollmentEmail = true) {
-				if (newUser.username.toLocaleLowerCase() === 'admin') {
-					throw new Error('Error in Create User And Email Enrollment: Username can not be admin');
-				}
-				else {
-					let otherUser = await Users.findOne({
-						$or: [
-							{username: newUser.username.toLocaleLowerCase()},
-							{email: newUser.email.toLocaleLowerCase()}
-						]
-					});
-
-					if (otherUser) {
-						throw new Error('Error in Create User And Email Enrollment: Username/Email is already used');
-					}
-				}
-				
-				newUser._id = objectIdHexString();
-
-				newUser.services = {
-					enrollment: jwt.sign({id_user: newUser._id}, this.serverConfig['JWT_SECRET'], {
-						expiresIn : 3 * 24 * 60 * 60 * 1000 // 3 days
-					})
-				};
-
-				newUser.is_customer = false;
-				await Users.insertOne(newUser);
-
-				if (sendEnrollmentEmail) {
-					let emailData = {
-						fullname: newUser.fullname,
-						user: this.user,
-						url: (this.serverConfig['ROOT_URL'] + '/enroll-account?' + encodeURIComponent(this.serverConfig['SERVER_URL']) + '&' + newUser.services['enrollment'])
-					};
-
-					try {
-						let html = this.readFile('email-templates/enrollment.html');
-						let template = handlebars.compile(html);
-						handlebars.registerHelper('equals', (a, b) => {
-							return a === b;
-						});
-
-						await this.sendEmail(newUser.email, 'ResolveIO (' + ResolveIOServer.getClientName() + ') - Enrollment Email', '', template(emailData), null, null, '');
-
-						return newUser;
-					}
-					catch (err) {
-						err.message = `Error in Create User And Email Enrollment: email-templates/enrollment.html - ${err.message}`;
-						throw err;
-					}
-				}
-				else {
-					return newUser;
-				}
-			}
-		},
-		resetUserPassword: {
-			check: new SimpleSchema({
-				userId: {
-					type: String
-				}
-			}),
-			function: async function(userId: string) {
-				let user = await Users.findOne({_id: userId});
-	
-				if (user) {
-					if (!user.services) {
-						user.services = {};
-					}
-
-					user.services['forgot_password'] = jwt.sign({id_user: userId}, this.serverConfig['JWT_SECRET']);
-
-					let emailData = {
-						userToChangePassword: user.fullname,
-						userWhoResetPassword: this.user,
-						url: (this.serverConfig['ROOT_URL'] + '/forgot-password?' + encodeURIComponent(this.serverConfig['SERVER_URL']) + '&' + user.services['forgot_password'])
-					};
-
-					try {
-						await Users.updateOne({_id: user._id}, {$set: {services: user.services, attempts: 0}});
-						let html = this.readFile('email-templates/forgot-password.html');
-						let template = handlebars.compile(html);
-						handlebars.registerHelper('equals', (a, b) => {
-							return a === b;
-						});
-	
-						await this.sendEmail(user.email, 'ResolveIO (' + ResolveIOServer.getClientName() + ') - Forgot Password', '', template(emailData), null, null, '');
-	
-						return true;
-					}
-					catch (err) {
-						err.message = `Error in Reset User Password: email-templates/forgot-password.html - ${err.message}`;
-						throw err;
-					}
-				}
-
-				throw new Error('Error in Reset User Password: Invalid User');
-			}
-		},
-		setUserPassword: {
-			check: new SimpleSchema({
-				userId: {
-					type: String
-				},
-				password: {
-					type: String
-				}
-			}),
-			function: async function(userId: string, password: string) {
-				let user = await Users.findOne({_id: userId});
-	
-				if (user && !user.roles.super_admin) {
-					await Users.setPassword(user, password);
-					await saveCustomerPortalPassword(user, password, {
-						updatedByUserId: this.id_user,
-						updatedByUser: this.user
-					});
-
-					return true;
-				}
-				else {
-					throw new Error('Error in Set User Password: Invalid User');
-				}
-			}
-		},
-		getCustomerPortalUserPassword: {
-			check: new SimpleSchema({
-				userId: {
-					type: String
-				}
-			}),
-			function: async function(userId: string) {
-				const methodUser = await resolveMethodUser(this.id_user, this.user);
-				if (!canViewCustomerPortalPasswords(methodUser)) {
-					throw new Error('Error in Get Customer Portal User Password: Unauthorized');
-				}
-
-				const targetUser = await Users.findOne({_id: userId});
-				if (!targetUser) {
-					throw new Error('Error in Get Customer Portal User Password: Invalid User');
-				}
-
-				if (!isCustomerPortalUser(targetUser)) {
-					throw new Error('Error in Get Customer Portal User Password: User is not a customer portal user');
-				}
-
-				const result = await getDecryptedCustomerPortalPassword(userId);
-				return {
-					password: result.password,
-					last_set_at: result.lastSetAt || null
-				};
-			}
-		},
-		saveUserStickySelects: {
-			check: new SimpleSchema({
-				stickySelects: {
-					type: Array
-				},
-				'stickySelects.$': {
-					type: Object,
-					blackbox: true
-				},
-				id_user: {
-					type: String,
-					optional: true
-				}
-			}),
-			function: async function(stickySelects: any[], id_user?: string) {
-				const targetUserId = id_user || this.id_user;
-				if (!targetUserId) {
-					throw new Error('Error in Save User Sticky Selects: Invalid User');
-				}
-
-				let attempts = 0;
-				let mergedStickySelects: StickySelectPreference[] = [];
-				let nextVersion = 0;
-
-				while (attempts < 5) {
-					const user = await Users.findOne({_id: targetUserId});
-					if (!user) {
-						throw new Error('Error in Save User Sticky Selects: Invalid User');
-					}
-
-					mergedStickySelects = mergeStickySelects(user.other?.stickySelects, stickySelects);
-					const nextUser: UserModel = deepCopy(user);
-					nextUser.other = {...(nextUser.other || {}), stickySelects: mergedStickySelects};
-
-					const res: any = await Users.replaceOne({_id: nextUser._id, __v: user.__v} as any, nextUser, {}, false, false, user);
-					if (res && res.modifiedCount) {
-						nextVersion = (user.__v || 0) + 1;
-						break;
-					}
-
-					attempts += 1;
-				}
-
-				if (attempts >= 5) {
-					throw new Error('Error in Save User Sticky Selects: Could not acquire latest version');
-				}
-
-				return {
-					stickySelects: mergedStickySelects,
-					__v: nextVersion
-				};
-			}
-		}
-	});
-}
-
-function mergeStickySelects(existingList: any, incomingList: StickySelectPreference[]): StickySelectPreference[] {
-	const existingMap = new Map<string, StickySelectPreference>();
-
-	if (Array.isArray(existingList)) {
-		existingList.forEach(entry => {
-			const normalized = normalizeStickyPreference(entry);
-			if (normalized && normalized.key) {
-				existingMap.set(normalized.key, normalized);
-			}
-		});
-	}
-
-	for (let i = 0; i < incomingList.length; i++) {
-		const normalized = normalizeStickyPreference(incomingList[i]);
-		if (!normalized || !normalized.key) {
-			continue;
-		}
-
-		const prev = existingMap.get(normalized.key);
-		const mergedOptions = trimOptions(normalized.options && normalized.options.length
-			? mergeOptions(prev?.options || [], normalized.options)
-			: (prev?.options || []));
-
-		let defaultValue = normalized.defaultValue !== undefined ? normalized.defaultValue : (prev ? prev.defaultValue : null);
-		if (defaultValue === undefined) {
-			defaultValue = null;
-		}
-
-		let defaultLabel = cleanStickyLabel(normalized.defaultLabel);
-		if (!defaultLabel && prev?.defaultLabel) {
-			defaultLabel = cleanStickyLabel(prev.defaultLabel);
-		}
-
-		if (defaultValue !== null && !defaultLabel) {
-			const optionLabel = mergedOptions.find(opt => valuesMatch(opt.value, defaultValue, !!normalized.multiple))?.label || '';
-			defaultLabel = cleanStickyLabel(optionLabel);
-		}
-
-		existingMap.set(normalized.key, {
-			key: normalized.key,
-			defaultValue,
-			defaultLabel,
-			multiple: normalized.multiple !== undefined ? normalized.multiple : !!prev?.multiple,
-			options: mergedOptions,
-			updatedAt: new Date().toISOString()
-		});
-	}
-
-	return Array.from(existingMap.values());
-}
-
-function mergeOptions(existing: StickySelectOption[], incoming: StickySelectOption[]): StickySelectOption[] {
-	const map = new Map<string, StickySelectOption>();
-
-	normalizeStickyOptions(existing).forEach(opt => {
-		const key = buildOptionKey(opt.value);
-		map.set(key, opt);
-	});
-
-	normalizeStickyOptions(incoming).forEach(opt => {
-		const key = buildOptionKey(opt.value);
-		map.set(key, opt);
-	});
-
-	return Array.from(map.values());
-}
-
-function trimOptions(options: StickySelectOption[]): StickySelectOption[] {
-	if (!Array.isArray(options)) {
-		return [];
-	}
-
-	if (options.length <= STICKY_MAX_OPTIONS) {
-		return options;
-	}
-
-	return options.slice(0, STICKY_MAX_OPTIONS);
-}
-
-function normalizeStickyPreference(entry: any): StickySelectPreference | null {
-	if (!entry || !entry.key) {
-		return null;
-	}
-
-	const normalized: StickySelectPreference = {
-		key: `${entry.key}`,
-		defaultValue: entry.defaultValue !== undefined ? entry.defaultValue : null,
-		defaultLabel: cleanStickyLabel(entry.defaultLabel),
-		multiple: !!entry.multiple,
-		options: normalizeStickyOptions(entry.options),
-		updatedAt: entry.updatedAt
-	};
-
-	return normalized;
-}
-
-function normalizeStickyOptions(options: any): StickySelectOption[] {
-	if (Array.isArray(options)) {
-		return options
-			.map(opt => normalizeStickyOption(opt))
-			.filter(opt => !!opt) as StickySelectOption[];
-	}
-
-	if (options && typeof options === 'object') {
-		return Object.keys(options)
-			.sort()
-			.map(key => normalizeStickyOption(options[key]))
-			.filter(opt => !!opt) as StickySelectOption[];
-	}
-
-	return [];
-}
-
-function normalizeStickyOption(option: any): StickySelectOption | null {
-	if (!option || option.value === undefined) {
-		return null;
-	}
-
-	return {
-		value: option.value,
-		label: cleanStickyLabel(option.label)
-	};
-}
-
-function cleanStickyLabel(label: string | undefined): string {
-	if (!label) {
-		return '';
-	}
-
-	const trimmed = `${label}`.trim();
-	if (!trimmed || trimmed.toLowerCase() === 'loading...') {
-		return '';
-	}
-
-	return trimmed;
-}
-
-function buildOptionKey(value: any): string {
-	if (value === null) {
-		return 'null';
-	}
-
-	if (value === undefined) {
-		return 'undefined';
-	}
-
-	if (typeof value === 'object') {
-		try {
-			return JSON.stringify(value);
-		}
-		catch {
-			return `${value}`;
-		}
-	}
-
-	return `${value}`;
-}
-
-function valuesMatch(a: any, b: any, multiple: boolean): boolean {
-	if (multiple) {
-		const arrA = Array.isArray(a) ? a : [];
-		const arrB = Array.isArray(b) ? b : [];
-
-		if (arrA.length !== arrB.length) {
-			return false;
-		}
-
-		return arrA.every(item => arrB.some(candidate => buildOptionKey(candidate) === buildOptionKey(item)));
-	}
-
-	return buildOptionKey(a) === buildOptionKey(b);
-}
-const STICKY_MAX_OPTIONS = 200;
-
-async function resolveMethodUser(id_user?: string, username?: string): Promise<UserModel | null> {
-	if (id_user) {
-		const userById = await Users.findById(id_user);
-		if (userById) {
-			return userById;
-		}
-	}
-
-	if (username) {
-		const userByUsername = await Users.findOne({username});
-		if (userByUsername) {
-			return userByUsername;
-		}
-	}
-
-	return null;
-}
-
-function canViewCustomerPortalPasswords(user: UserModel | null): boolean {
-	if (!user || !user.roles) {
-		return false;
-	}
-
-	if (user.roles.super_admin) {
-		return true;
-	}
-
-	const groups = Array.isArray(user.roles.groups) ? user.roles.groups : [];
-	return groups.some(group => Array.isArray(group?.views) && group.views.includes('/admin/customer-user'));
-}