@resolveio/server-lib 22.3.219 → 22.3.221

package/src/methods/accounts.ts

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