adminizer 4.2.0 → 4.3.0-build.101

package/lib/notifications/AbstractNotificationService.js

@@ -0,0 +1,353 @@
+import { EventEmitter } from 'events';
+import { Adminizer } from '../Adminizer';
+/**
+ * ░█████╗░██████╗░░██████╗████████╗██████╗░░█████╗░░█████╗░████████╗
+ * ██╔══██╗██╔══██╗██╔════╝╚══██╔══╝██╔══██╗██╔══██╗██╔══██╗╚══██╔══╝
+ * ███████║██████╦╝╚█████╗░░░░██║░░░██████╔╝███████║██║░░╚═╝░░░██║░░░
+ * ██╔══██║██╔══██╗░╚═══██╗░░░██║░░░██╔══██╗██╔══██║██║░░██╗░░░██║░░░
+ * ██║░░██║██████╦╝██████╔╝░░░██║░░░██║░░██║██║░░██║╚█████╔╝░░░██║░░░
+ * ╚═╝░░╚═╝╚═════╝░╚═════╝░░░░╚═╝░░░╚═╝░░╚═╝╚═╝░░╚═╝░╚════╝░░░░╚═╝░░░
+ *
+ * ███╗░░██╗░█████╗░████████╗██╗███████╗██╗░█████╗░░█████╗░████████╗██╗░█████╗░███╗░░██╗
+ * ████╗░██║██╔══██╗╚══██╔══╝██║██╔════╝██║██╔══██╗██╔══██╗╚══██╔══╝██║██╔══██╗████╗░██║
+ * ██╔██╗██║██║░░██║░░░██║░░░██║█████╗░░██║██║░░╚═╝███████║░░░██║░░░██║██║░░██║██╔██╗██║
+ * ██║╚████║██║░░██║░░░██║░░░██║██╔══╝░░██║██║░░██╗██╔══██║░░░██║░░░██║██║░░██║██║╚████║
+ * ██║░╚███║╚█████╔╝░░░██║░░░██║██║░░░░░██║╚█████╔╝██║░░██║░░░██║░░░██║╚█████╔╝██║░╚███║
+ * ╚═╝░░╚══╝░╚════╝░░░░╚═╝░░░╚═╝╚═╝░░░░░╚═╝░╚════╝░╚═╝░░╚═╝░░░╚═╝░░░╚═╝░╚════╝░╚═╝░░╚══╝
+ *
+ * Class: AbstractNotificationService
+ *
+ * Description:
+ * The `AbstractNotificationService` is a base class that provides the fundamental structure and functionality
+ * for implementing notification services in the application. It manages client connections, dispatches notifications,
+ * tracks user notification status, and handles database interactions for storing and retrieving notification data.
+ * This abstract class is intended to be extended by concrete notification service implementations.
+ *
+ * Key Features:
+ * - Manages a registry of clients associated with users using a nested Map structure.
+ * - Provides methods to add, remove, and retrieve clients.
+ * - Dispatches notifications to connected clients via an abstract method to be implemented by subclasses.
+ * - Sends heartbeat (ping) messages to keep client connections alive.
+ * - Creates and retrieves user notification records in the database.
+ * - Fetches paginated and filtered notification lists for a specific user.
+ * - Supports searching notifications by message content.
+ * - Marks notifications as read or all notifications as read for a user.
+ * - Emits events using Node.js EventEmitter for extensibility and integration.
+ *
+ * Usage Example:
+ * Subclasses should override the `dispatchNotification` method to implement custom notification logic.
+ *
+ * @abstract
+ * @extends EventEmitter
+ * @property {Map<number, Map<string, Function>>} clients - A map of user IDs to their client maps.
+ * @property {Adminizer} adminizer - Reference to the Adminizer instance for accessing helpers and models.
+ * @property {string} notificationClass - Abstract property representing the class name of the notification.
+ * @property {string} icon - Abstract property for the notification icon.
+ * @property {string} iconColor - Abstract property for the notification icon color.
+ */
+export class AbstractNotificationService extends EventEmitter {
+    clients = new Map();
+    adminizer;
+    constructor(adminizer) {
+        super();
+        this.adminizer = adminizer;
+        this._bindAccessRight();
+    }
+    _bindAccessRight() {
+        setTimeout(() => {
+            this.adminizer.accessRightsHelper.registerToken({
+                id: `notification-${this.notificationClass}`,
+                name: this.notificationClass,
+                description: `Access to notification ${this.notificationClass}`,
+                department: 'notification',
+            });
+        }, 100);
+    }
+    /**
+     * Registers a client for a user and associates it with a send function.
+     * If the user does not yet have a Map of clients, one is created.
+     * The client is then added to the user's Map with the provided send function.
+     * @param {string} clientId - The unique identifier of the client to be registered.
+     * @param {(event: INotificationEvent) => void} sendFn - The function used to send notifications to the client.
+     * @param {UserAP} user - The user associated with the client.
+     */
+    addClient(clientId, sendFn, user) {
+        const userId = user.id;
+        // Если у пользователя еще нет Map клиентов - создаем
+        if (!this.clients.has(userId)) {
+            this.clients.set(userId, new Map());
+        }
+        // Получаем Map клиентов пользователя и добавляем нового клиента
+        const userClients = this.clients.get(userId);
+        userClients.set(clientId, sendFn);
+        Adminizer.log.info(`[${this.notificationClass}] Client ${clientId} connected for user ${userId}. Total users: ${this.clients.size}, user clients: ${userClients.size}`);
+    }
+    /**
+     * Removes a client from the internal tracking structure.
+     * If the user associated with the client has no more clients after removal, the user's Map is also removed.
+     * @param {string} clientId - The unique identifier of the client to be removed.
+     */
+    removeClient(clientId) {
+        // Ищем клиента во всех пользовательских Map
+        for (const [userId, userClients] of this.clients.entries()) {
+            if (userClients.has(clientId)) {
+                userClients.delete(clientId);
+                // Если у пользователя больше нет клиентов - удаляем его Map
+                if (userClients.size === 0) {
+                    this.clients.delete(userId);
+                }
+                Adminizer.log.info(`[${this.notificationClass}] Client ${clientId} disconnected from user ${userId}. Total users: ${this.clients.size}`);
+                return;
+            }
+        }
+        Adminizer.log.warn(`[${this.notificationClass}] Client ${clientId} not found for removal`);
+    }
+    /**
+     * Retrieves the Map of clients associated with a specific user.
+     * If the user has no clients, an empty Map is returned.
+     * @param {number} userId - The unique identifier of the user whose clients should be retrieved.
+     * @returns {Map<string, (event: INotificationEvent) => void>} A Map where the keys are client IDs and the values are send functions.
+     */
+    getUserClients(userId) {
+        return this.clients.get(userId) || new Map();
+    }
+    /**
+     * Returns the total number of users who have at least one connected client.
+     * @returns {number} The count of users with active clients.
+     */
+    getClientCount() {
+        return this.clients.size;
+    }
+    /**
+     * Aggregates all clients from all users into a single Map for backward compatibility.
+     * Each client is uniquely identified by its ID and mapped to its corresponding send function.
+     * @returns {Map<string, (event: INotificationEvent) => void>} A combined Map of all client IDs and their send functions.
+     */
+    getAllClients() {
+        const allClients = new Map();
+        for (const userClients of this.clients.values()) {
+            for (const [clientId, sendFn] of userClients.entries()) {
+                allClients.set(clientId, sendFn);
+            }
+        }
+        return allClients;
+    }
+    /**
+     * Sends a notification event to all connected clients.
+     * Iterates through each user's client Map and invokes the send function for each client.
+     * If sending fails, logs an error and removes the client.
+     * @param {INotificationEvent} event - The notification event to broadcast.
+     */
+    broadcast(event) {
+        for (const userClients of this.clients.values()) {
+            userClients.forEach((sendFn, clientId) => {
+                try {
+                    sendFn(event);
+                }
+                catch (error) {
+                    Adminizer.log.error(`[${this.notificationClass}] Error sending to client ${clientId}:`, error);
+                    this.removeClient(clientId);
+                }
+            });
+        }
+    }
+    /**
+     * Sends a heartbeat (ping) message to a specific client.
+     * Searches for the client across all user client Maps and sends a heartbeat event if found.
+     * @param {string} clientId - The unique identifier of the client to receive the heartbeat.
+     */
+    sendHeartbeat(clientId) {
+        for (const userClients of this.clients.values()) {
+            const sendFn = userClients.get(clientId);
+            if (sendFn) {
+                const heartbeatEvent = {
+                    type: 'heartbeat',
+                    data: 'ping'
+                };
+                sendFn(heartbeatEvent);
+                return;
+            }
+        }
+    }
+    /**
+     * Creates a new user notification record in the 'usernotificationap' model.
+     * This method is used to associate a notification with a specific user and mark it as unread.
+     * @param {string} notificationId - The unique identifier of the notification.
+     * @param {number} [userId] - The ID of the user to associate the notification with. Optional.
+     * @returns {Promise<void>} A promise that resolves when the record is created or an error is logged.
+     */
+    async createUserNotification(notificationId, userId) {
+        if (this.adminizer.modelHandler.model.has('usernotificationap') && userId) {
+            try {
+                await this.adminizer.modelHandler.model.get('usernotificationap')["_create"]({
+                    userId: userId,
+                    notificationId: notificationId,
+                    read: false
+                });
+            }
+            catch (error) {
+                Adminizer.log.error(`Error creating user notification record:`, error);
+            }
+        }
+    }
+    /**
+     * Retrieves a user notification record from the 'usernotificationap' model.
+     * The record is fetched based on the provided notification ID and user ID.
+     * @param {string} notificationId - The unique identifier of the notification.
+     * @param {number} userId - The ID of the user associated with the notification.
+     * @returns {Promise<any>} A promise that resolves with the found record or null if not found or an error occurs.
+     */
+    async getUserNotification(notificationId, userId) {
+        if (this.adminizer.modelHandler.model.has('usernotificationap')) {
+            try {
+                return await this.adminizer.modelHandler.model.get('usernotificationap')["_findOne"]({
+                    where: { notificationId: notificationId, userId: userId }
+                });
+            }
+            catch (error) {
+                Adminizer.log.error(`Error getting user notification:`, error);
+                return null;
+            }
+        }
+        return null;
+    }
+    /**
+     * Retrieves a paginated list of notifications for a specific user, optionally filtered by read status.
+     * @param {number} userId - The ID of the user whose notifications should be fetched.
+     * @param {number} [limit=20] - The maximum number of notifications to return.
+     * @param {number} [skip=0] - The number of notifications to skip (used for pagination).
+     * @param {boolean} [unreadOnly=false] - Whether to return only unread notifications.
+     * @returns {Promise<INotification[]>} A promise that resolves with an array of notification objects.
+     */
+    async getNotifications(userId, limit = 20, skip = 0, unreadOnly = false) {
+        if (!this.adminizer.modelHandler.model.has('notificationap')) {
+            return [];
+        }
+        try {
+            let query = { notificationClass: this.notificationClass };
+            // Если запрашиваются уведомления для конкретного пользователя получаем ID уведомлений пользователя
+            const userNotifications = await this.adminizer.modelHandler.model.get('usernotificationap')["_find"]({
+                where: {
+                    userId: userId
+                }
+            }, { populate: [['notificationId', {}]] });
+            const notificationIds = userNotifications.map((un) => un.notificationId.id);
+            if (unreadOnly) {
+                // Только непрочитанные
+                query.id = userNotifications
+                    .filter((un) => !un.read)
+                    .map((un) => un.notificationId.id);
+            }
+            else {
+                query.id = notificationIds;
+            }
+            if (query.id.length === 0)
+                return [];
+            const notificationsDB = await this.adminizer.modelHandler.model.get('notificationap')["_find"]({
+                where: query,
+                sort: 'createdAt DESC',
+                limit: limit,
+                skip: skip
+            });
+            return await this.prepareNotification(notificationsDB, userId);
+        }
+        catch (error) {
+            Adminizer.log.error('Error fetching notifications:', error);
+            return [];
+        }
+    }
+    /**
+     * Prepares notification data by enriching it with user-specific read status and icon information.
+     * @param {NotificationAPModel[]} notificationsDB - An array of raw notification records from the database.
+     * @param {number} userId - The ID of the user for whom the read status is determined.
+     * @returns {Promise<INotification[]>} A promise that resolves with an array of enriched notification objects.
+     */
+    async prepareNotification(notificationsDB, userId) {
+        let notifications = [];
+        for (const notification of notificationsDB) {
+            let readStatus = false;
+            // Получаем статус прочтения из UserNotificationAP
+            const userNotification = await this.getUserNotification(notification.id, userId);
+            readStatus = userNotification ? userNotification.read : false;
+            notifications.push({
+                ...notification,
+                read: readStatus,
+                icon: {
+                    icon: this.icon,
+                    iconColor: this.iconColor
+                },
+            });
+        }
+        return notifications;
+    }
+    /**
+     * Searches for notifications for a specific user based on a message keyword.
+     * @param {string} s - The search string used to filter notifications by message content.
+     * @param {number} userId - The ID of the user whose notifications should be searched.
+     * @returns {Promise<INotification[]>} A promise that resolves with an array of matching notification objects.
+     */
+    async search(s, userId) {
+        try {
+            const userNotifications = await this.adminizer.modelHandler.model.get('usernotificationap')["_find"]({
+                where: {
+                    userId: userId
+                }
+            }, { populate: [['notificationId', {}]] });
+            const notificationIds = userNotifications.map((un) => un.notificationId.id);
+            if (notificationIds.length === 0)
+                return [];
+            const notificationsDB = await this.adminizer.modelHandler.model.get('notificationap')["_find"]({
+                where: {
+                    message: { contains: s },
+                    id: notificationIds,
+                    notificationClass: this.notificationClass
+                },
+                sort: "createdAt DESC"
+            });
+            return await this.prepareNotification(notificationsDB, userId);
+        }
+        catch (error) {
+            Adminizer.log.error('Error searching notifications:', error);
+            return [];
+        }
+    }
+    /**
+     * Marks a specific notification as read for a given user.
+     * @param {number} userId - The ID of the user for whom the notification should be marked as read.
+     * @param {string} id - The ID of the notification to mark as read.
+     * @returns {Promise<void>} A promise that resolves when the operation is complete.
+     */
+    async markAsRead(userId, id) {
+        try {
+            const userNotification = await this.getUserNotification(id, userId);
+            if (userNotification) {
+                await this.adminizer.modelHandler.model.get('usernotificationap')["_update"]({
+                    id: userNotification.id
+                }, { read: true });
+            }
+        }
+        catch (error) {
+            Adminizer.log.error('Error marking notification as read:', error);
+        }
+    }
+    /**
+     * Marks all notifications as read for a given user.
+     * @param {number} userId - The ID of the user for whom all notifications should be marked as read.
+     * @returns {Promise<void>} A promise that resolves when the operation is complete.
+     */
+    async markAllAsRead(userId) {
+        try {
+            const userNotifications = await this.adminizer.modelHandler.model.get('usernotificationap')["_find"]({
+                where: { userId: userId }
+            });
+            for (const userNotification of userNotifications) {
+                await this.adminizer.modelHandler.model.get('usernotificationap')["_update"]({
+                    where: { id: userNotification.id },
+                }, { read: true });
+            }
+        }
+        catch (error) {
+            Adminizer.log.error('Error marking all notifications as read:', error);
+        }
+    }
+}

package/lib/notifications/GeneralNotificationService.d.ts

@@ -0,0 +1,8 @@
+import { AbstractNotificationService } from './AbstractNotificationService';
+import { INotification } from '../../interfaces/types';
+export declare class GeneralNotificationService extends AbstractNotificationService {
+    readonly notificationClass = "general";
+    readonly icon: string;
+    readonly iconColor: string;
+    dispatchNotification(notification: Omit<INotification, 'id' | 'createdAt' | 'notificationClass' | 'icon'>): Promise<boolean>;
+}

package/lib/notifications/GeneralNotificationService.js

@@ -0,0 +1,61 @@
+import { AbstractNotificationService } from './AbstractNotificationService';
+import { Adminizer } from '../Adminizer';
+export class GeneralNotificationService extends AbstractNotificationService {
+    notificationClass = 'general';
+    icon = 'info';
+    iconColor = '#5987de';
+    async dispatchNotification(notification) {
+        const fullNotification = {
+            ...notification,
+            notificationClass: this.notificationClass
+        };
+        let notificationDB;
+        // Сохраняем в базу
+        if (this.adminizer.modelHandler.model.has('notificationap')) {
+            try {
+                notificationDB = await this.adminizer.modelHandler.model.get('notificationap')["_create"](fullNotification);
+                if (notification.userId) {
+                    // For specific user
+                    await this.createUserNotification(notificationDB.id, notification.userId);
+                }
+                else {
+                    // For all users
+                    const users = await this.adminizer.modelHandler.model.get('userap')["_find"]({});
+                    for (const user of users) {
+                        try {
+                            if (this.adminizer.accessRightsHelper.hasPermission(`notification-${this.notificationClass}`, user)) {
+                                await this.createUserNotification(notificationDB.id, user.id);
+                            }
+                            else {
+                                Adminizer.log.error(`[${this.notificationClass}] User ${user.id} doesn't have permission to receive this notification`);
+                            }
+                        }
+                        catch (error) {
+                            Adminizer.log.error('Error creating UserNotificationAP:', error);
+                        }
+                    }
+                }
+                const event = {
+                    type: 'notification',
+                    data: {
+                        ...notificationDB,
+                        read: false,
+                        icon: {
+                            icon: this.icon,
+                            iconColor: this.iconColor
+                        },
+                    },
+                    notificationClass: this.notificationClass,
+                    userId: notification.userId ?? null
+                };
+                this.broadcast(event);
+                Adminizer.log.info(`[General] Notification dispatched: ${fullNotification.title}`);
+                return true;
+            }
+            catch (error) {
+                Adminizer.log.error('Error saving notification to database:', error);
+            }
+        }
+        return false;
+    }
+}

package/lib/notifications/NotificationHandler.d.ts

@@ -0,0 +1,27 @@
+import { EventEmitter } from 'events';
+import { AbstractNotificationService } from "./AbstractNotificationService";
+import { INotification } from '../../interfaces/types';
+export declare class NotificationHandler extends EventEmitter {
+    private services;
+    constructor();
+    /**
+     * Register a new notification service
+     * @param service
+     */
+    registerService(service: AbstractNotificationService): void;
+    /**
+     * Get a notification service by class
+     * @param notificationClass
+     */
+    getService(notificationClass: string): AbstractNotificationService | undefined;
+    /**
+     * Get all registered services
+     */
+    getAllServices(): AbstractNotificationService[];
+    /**
+     * Dispatch a notification to a service
+     * @param notificationClass
+     * @param notification
+     */
+    dispatchNotification(notificationClass: string, notification: Omit<INotification, 'id' | 'createdAt' | 'notificationClass' | 'icon'>): Promise<boolean>;
+}

package/lib/notifications/NotificationHandler.js

@@ -0,0 +1,41 @@
+import { EventEmitter } from 'events';
+import { Adminizer } from '../Adminizer';
+export class NotificationHandler extends EventEmitter {
+    services = new Map();
+    constructor() {
+        super();
+    }
+    /**
+     * Register a new notification service
+     * @param service
+     */
+    registerService(service) {
+        this.services.set(service.notificationClass, service);
+        Adminizer.log.info(`Notification service registered: ${service.notificationClass}`);
+    }
+    /**
+     * Get a notification service by class
+     * @param notificationClass
+     */
+    getService(notificationClass) {
+        return this.services.get(notificationClass);
+    }
+    /**
+     * Get all registered services
+     */
+    getAllServices() {
+        return Array.from(this.services.values());
+    }
+    /**
+     * Dispatch a notification to a service
+     * @param notificationClass
+     * @param notification
+     */
+    async dispatchNotification(notificationClass, notification) {
+        const service = this.getService(notificationClass);
+        if (!service) {
+            throw new Error(`Notification service not found: ${notificationClass}`);
+        }
+        return service.dispatchNotification(notification);
+    }
+}

package/lib/notifications/SystemNotificationService.d.ts

@@ -0,0 +1,19 @@
+import { AbstractNotificationService } from './AbstractNotificationService';
+import { INotification } from '../../interfaces/types';
+export declare class SystemNotificationService extends AbstractNotificationService {
+    readonly notificationClass = "system";
+    readonly icon: string;
+    readonly iconColor: string;
+    private crudChannels;
+    dispatchNotification(notification: Omit<INotification, 'id' | 'createdAt' | 'notificationClass' | 'icon'>): Promise<boolean>;
+    private broadcastToChannel;
+    addClientToChannel(clientId: string, channel: string, userId: number): void;
+    removeClientFromChannel(clientId: string, channel: string, userId: number): void;
+    removeClientFromAllChannels(clientId: string, userId: number): void;
+    removeClient(clientId: string): void;
+    logSystemEvent(title: string, message: string, channel?: string, metadata?: Record<string | number, any>): Promise<boolean>;
+    logCreatedEvent(title: string, message: string, metadata?: Record<string | number, any>): Promise<boolean>;
+    logUpdatedEvent(title: string, message: string, metadata?: Record<string | number, any>): Promise<boolean>;
+    logDeletedEvent(title: string, message: string, metadata?: Record<string | number, any>): Promise<boolean>;
+    getUserChannels(userId: number): Map<string, Set<string>>;
+}