@resolveio/server-lib 22.3.60 → 22.3.62

package/src/methods/customer-notifications.ts

@@ -0,0 +1,458 @@
+import SimpleSchema from 'simpl-schema';
+import { CustomerNotifications } from '../collections/customer-notification.collection';
+import { Users } from '../collections/user.collection';
+import { MethodManager } from '../managers/method.manager';
+import { objectIdHexString } from '../util/common';
+
+const DEFAULT_LIST_LIMIT = 100;
+const MAX_LIST_LIMIT = 500;
+const DEDUPE_WINDOW_MS = 30 * 60 * 1000;
+const MAX_TARGET_USERS = 5000;
+
+type CreateCustomerNotificationPayload = {
+	title: string;
+	message: string;
+	details?: string;
+	category?: string;
+	severity?: string;
+	target_type?: 'client' | 'users' | 'all_active' | 'client_admins' | 'client_internal';
+	id_client?: string;
+	client_name?: string;
+	id_users?: string[];
+	source?: string;
+	source_id?: string;
+	action_label?: string;
+	action_route?: string;
+	dedupe_key?: string;
+	expires_at?: Date;
+	metadata?: Record<string, any>;
+};
+
+function normalizeString(value: any, maxLength = 500): string {
+	const normalized = String(value || '').trim();
+	if (!normalized) {
+		return '';
+	}
+	if (normalized.length <= maxLength) {
+		return normalized;
+	}
+	return normalized.slice(0, maxLength);
+}
+
+function normalizeNotificationCategory(value?: string): string {
+	const normalized = normalizeString(value, 40).toLowerCase();
+	if (!normalized) {
+		return 'system';
+	}
+	if (['autofix', 'slow-query', 'system', 'manual'].includes(normalized)) {
+		return normalized;
+	}
+	return 'system';
+}
+
+function normalizeNotificationSeverity(value?: string): string {
+	const normalized = normalizeString(value, 20).toLowerCase();
+	if (!normalized) {
+		return 'info';
+	}
+	if (['info', 'success', 'warning', 'error'].includes(normalized)) {
+		return normalized;
+	}
+	return 'info';
+}
+
+function normalizeListLimit(value?: number): number {
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed) || parsed <= 0) {
+		return DEFAULT_LIST_LIMIT;
+	}
+	return Math.min(Math.floor(parsed), MAX_LIST_LIMIT);
+}
+
+function isSystemMethodUser(methodUser: any): boolean {
+	return !methodUser || methodUser === 'Internal System';
+}
+
+async function resolveMethodUser(methodUser: any, methodUserId?: any): Promise<any | null> {
+	if (isSystemMethodUser(methodUser)) {
+		return null;
+	}
+
+	if (typeof methodUser === 'object' && methodUser?._id && methodUser?.roles) {
+		return methodUser;
+	}
+
+	const idUser = normalizeString(
+		typeof methodUserId === 'string'
+			? methodUserId
+			: (
+				methodUserId?._id ||
+				methodUserId?.id_user ||
+				(typeof methodUser === 'string'
+					? methodUser
+					: (methodUser?._id || methodUser?.id_user || ''))
+			),
+		80
+	);
+	if (!idUser) {
+		return null;
+	}
+	return await Users.findById(idUser);
+}
+
+function isSuperAdmin(user: any): boolean {
+	return !!user?.roles?.super_admin;
+}
+
+function uniqueUserIds(input: string[]): string[] {
+	const unique = new Set<string>();
+	for (const entry of (Array.isArray(input) ? input : [])) {
+		const id = normalizeString(entry, 80);
+		if (id) {
+			unique.add(id);
+		}
+		if (unique.size >= MAX_TARGET_USERS) {
+			break;
+		}
+	}
+	return Array.from(unique);
+}
+
+function buildClientMembershipCriteria(idClient: string): Record<string, any> {
+	return {
+		$or: [
+			{'other.id_client': idClient},
+			{'other.idClient': idClient},
+			{id_client: idClient}
+		]
+	};
+}
+
+function buildInternalUserCriteria(): Record<string, any> {
+	return {
+		$and: [
+			{
+				is_customer: {
+					$ne: true
+				}
+			},
+			{
+				$nor: [
+					{
+						'other.id_customer': {
+							$exists: true,
+							$nin: ['', null]
+						}
+					},
+					{
+						id_customer: {
+							$exists: true,
+							$nin: ['', null]
+						}
+					}
+				]
+			}
+		]
+	};
+}
+
+function buildAdminUserCriteria(): Record<string, any> {
+	return {
+		$or: [
+			{
+				'roles.super_admin': true
+			},
+			{
+				'roles.groups.name': {
+					$regex: 'admin',
+					$options: 'i'
+				}
+			},
+			{
+				'roles.groups.views': {
+					$regex: '^/manage'
+				}
+			},
+			{
+				'roles.groups.views': '/manage'
+			}
+		]
+	};
+}
+
+async function resolveTargetUsers(payload: CreateCustomerNotificationPayload): Promise<string[]> {
+	const targetType = normalizeString(payload?.target_type || 'client', 20).toLowerCase() || 'client';
+	if (targetType === 'users') {
+		return uniqueUserIds(payload?.id_users || []);
+	}
+
+	if (targetType === 'all_active') {
+		const users = await Users.find({
+			active: true,
+			username: {
+				$exists: true
+			}
+		}, {
+			projection: {
+				_id: 1
+			},
+			limit: MAX_TARGET_USERS
+		});
+		return uniqueUserIds(users.map((user: any) => user?._id));
+	}
+
+	const idClient = normalizeString(payload?.id_client, 80);
+	if (!idClient) {
+		return [];
+	}
+
+	const andClauses: Record<string, any>[] = [
+		{
+			active: true
+		},
+		{
+			username: {
+				$exists: true
+			}
+		},
+		buildClientMembershipCriteria(idClient)
+	];
+
+	if (targetType === 'client_internal' || targetType === 'client_admins') {
+		andClauses.push(buildInternalUserCriteria());
+	}
+
+	if (targetType === 'client_admins') {
+		andClauses.push(buildAdminUserCriteria());
+	}
+
+	const users = await Users.find({
+		$and: andClauses
+	}, {
+		projection: {
+			_id: 1
+		},
+		limit: MAX_TARGET_USERS
+	});
+
+	return uniqueUserIds(users.map((user: any) => user?._id));
+}
+
+export function loadCustomerNotificationMethods(methodManager: MethodManager) {
+	methodManager.methods({
+		createCustomerNotification: {
+			check: new SimpleSchema({
+				payload: {
+					type: Object,
+					blackbox: true
+				}
+			}),
+			function: async function(payload) {
+				const methodUser = await resolveMethodUser(this.user, this.id_user);
+				const systemUser = isSystemMethodUser(this.user);
+				if (!systemUser && !isSuperAdmin(methodUser)) {
+					throw new Error('Only super admins can create notifications.');
+				}
+
+				const title = normalizeString(payload?.title, 160);
+				const message = normalizeString(payload?.message, 1500);
+				if (!title || !message) {
+					throw new Error('Notification title and message are required.');
+				}
+
+				const idClient = normalizeString(payload?.id_client, 80);
+				const clientName = normalizeString(payload?.client_name, 200);
+				const category = normalizeNotificationCategory(payload?.category);
+				const severity = normalizeNotificationSeverity(payload?.severity);
+				const details = normalizeString(payload?.details, 6000);
+				const source = normalizeString(payload?.source, 120);
+				const sourceId = normalizeString(payload?.source_id, 120);
+				const actionLabel = normalizeString(payload?.action_label, 80);
+				const actionRoute = normalizeString(payload?.action_route, 500);
+				const dedupeKey = normalizeString(payload?.dedupe_key, 160);
+				const expiresAt = payload?.expires_at instanceof Date && !Number.isNaN(payload.expires_at.getTime())
+					? payload.expires_at
+					: undefined;
+				const metadata = payload?.metadata && typeof payload.metadata === 'object'
+					? payload.metadata
+					: undefined;
+
+				const targetUsers = await resolveTargetUsers(payload);
+				if (!targetUsers.length) {
+					return {
+						created: 0,
+						reason: 'no_target_users'
+					};
+				}
+
+				const now = new Date();
+				const createById = systemUser ? 'Internal System' : normalizeString(methodUser?._id, 80);
+				const createByName = systemUser
+					? 'Internal System'
+					: normalizeString(methodUser?.fullname || methodUser?.username, 200);
+
+				let skippedByDedupe = new Set<string>();
+				if (dedupeKey) {
+					const cutoff = new Date(now.getTime() - DEDUPE_WINDOW_MS);
+					const existing = await CustomerNotifications.find({
+						id_user: {
+							$in: targetUsers
+						},
+						dedupe_key: dedupeKey,
+						createdAt: {
+							$gte: cutoff
+						}
+					}, {
+						projection: {
+							id_user: 1
+						},
+						limit: MAX_TARGET_USERS
+					});
+					skippedByDedupe = new Set(existing.map(entry => normalizeString(entry?.id_user, 80)).filter(Boolean));
+				}
+
+				const docs = targetUsers
+					.filter(idUser => !skippedByDedupe.has(idUser))
+					.map((idUser) => ({
+						_id: objectIdHexString(),
+						__v: 0,
+						id_user: idUser,
+						id_client: idClient || undefined,
+						client_name: clientName || undefined,
+						title,
+						message,
+						details: details || undefined,
+						category,
+						severity,
+						status: 'unread',
+						read_at: undefined,
+						read_by: '',
+						source: source || undefined,
+						source_id: sourceId || undefined,
+						action_label: actionLabel || undefined,
+						action_route: actionRoute || undefined,
+						dedupe_key: dedupeKey || undefined,
+						metadata,
+						expires_at: expiresAt,
+						created_by: createById || undefined,
+						created_by_name: createByName || undefined,
+						createdAt: now,
+						updatedAt: now
+					}));
+
+				if (!docs.length) {
+					return {
+						created: 0,
+						reason: 'dedupe_suppressed'
+					};
+				}
+
+				await CustomerNotifications.insertMany(docs as any[]);
+
+				return {
+					created: docs.length,
+					targeted: targetUsers.length
+				};
+			}
+		},
+		markUserNotificationRead: {
+			check: new SimpleSchema({
+				id_notification: {
+					type: String
+				}
+			}),
+			function: async function(id_notification: string) {
+				const methodUser = await resolveMethodUser(this.user, this.id_user);
+				const idUser = normalizeString(methodUser?._id, 80);
+				if (!idUser) {
+					throw new Error('You must be logged in to mark notifications as read.');
+				}
+
+				await CustomerNotifications.updateOne({
+					_id: id_notification,
+					id_user: idUser
+				}, {
+					$set: {
+						status: 'read',
+						read_at: new Date(),
+						read_by: idUser
+					}
+				});
+
+				return true;
+			}
+		},
+		markAllUserNotificationsRead: {
+			check: new SimpleSchema({
+				id_client: {
+					type: String,
+					optional: true
+				}
+			}),
+			function: async function(id_client?: string) {
+				const methodUser = await resolveMethodUser(this.user, this.id_user);
+				const idUser = normalizeString(methodUser?._id, 80);
+				if (!idUser) {
+					throw new Error('You must be logged in to mark notifications as read.');
+				}
+
+				const idClient = normalizeString(id_client, 80);
+				const query: Record<string, any> = {
+					id_user: idUser,
+					status: 'unread'
+				};
+				if (idClient) {
+					query.id_client = idClient;
+				}
+
+				await CustomerNotifications.updateMany(query, {
+					$set: {
+						status: 'read',
+						read_at: new Date(),
+						read_by: idUser
+					}
+				});
+
+				return true;
+			}
+		},
+		listCustomerNotifications: {
+			check: new SimpleSchema({
+				payload: {
+					type: Object,
+					optional: true,
+					blackbox: true
+				}
+			}),
+			function: async function(payload?) {
+				const methodUser = await resolveMethodUser(this.user, this.id_user);
+				const systemUser = isSystemMethodUser(this.user);
+				if (!systemUser && !isSuperAdmin(methodUser)) {
+					throw new Error('Only super admins can list all notifications.');
+				}
+
+				const query: Record<string, any> = {};
+				const idUser = normalizeString(payload?.id_user, 80);
+				const idClient = normalizeString(payload?.id_client, 80);
+				const status = normalizeString(payload?.status, 20).toLowerCase();
+				if (idUser) {
+					query.id_user = idUser;
+				}
+				if (idClient) {
+					query.id_client = idClient;
+				}
+				if (status === 'unread' || status === 'read') {
+					query.status = status;
+				}
+
+				const limit = normalizeListLimit(payload?.limit);
+				return await CustomerNotifications.find(query, {
+					sort: {
+						createdAt: -1
+					},
+					limit
+				});
+			}
+		}
+	});
+}