adminizer 4.3.0-build.80 → 4.3.0-build.82

package/lib/{v4/model → model}/adapter/sequelize.js

@@ -15,7 +15,11 @@ function generateAssociationsFromSchema(models, schemas) {
                 const targetModel = models[field.collection];
                 const targetSchema = schemas[field.collection];
                 const inverseField = targetSchema?.[field.via];
-                const throughTableName = [modelName, field.collection].sort().join("");
+                // Normalize join table to lowercase for consistency across dialects
+                const throughTableName = [modelName, field.collection]
+                    .sort()
+                    .join("")
+                    .toLowerCase();
                 // 💡 M:N связь
                 if (inverseField && inverseField.collection === modelName) {
                     model.belongsToMany(targetModel, {
@@ -444,7 +448,7 @@ export class SequelizeModel extends AbstractModel {
             where,
             include: Object.values(this.model.associations)
         });
-        return reloaded.map(r => r.get({ plain: true }));
+        return reloaded.map((r) => r.get({ plain: true }));
     }
     // --- DESTROY ONE ---
     async _destroyOne(criteria) {
@@ -514,7 +518,7 @@ export class SequelizeModel extends AbstractModel {
                 }
             }
         }
-        const raw = records.map(r => r.get({ plain: true }));
+        const raw = records.map((r) => r.get({ plain: true }));
         await this.model.destroy({ where });
         return raw;
     }
@@ -529,11 +533,9 @@ export class SequelizeModel extends AbstractModel {
         return Object.keys(this.model.associations).map(key => ({ association: key }));
     }
 }
-/** SequelizeAdapter — адаптер, заменяющий WaterlineAdapter */
 export class SequelizeAdapter extends AbstractAdapter {
     sequelize;
     Model = SequelizeModel;
-    alter = false;
     constructor(sequelize) {
         super("sequelize", sequelize);
         this.sequelize = sequelize;
@@ -552,18 +554,33 @@ export class SequelizeAdapter extends AbstractAdapter {
         const model = this.getModel(modelName);
         return model?.getAttributes();
     }
-    /**Registration of system models*/
+    /** Registration of system models */
     static async registerSystemModels(sequelize, alter = true) {
-        let modelsDir = path.resolve(import.meta.dirname, "../../../../models");
-        if (!fs.existsSync(modelsDir)) {
-            modelsDir = path.resolve(import.meta.dirname, "../../../../src/models");
+        // Try multiple possible model locations
+        const possiblePaths = [
+            path.resolve(import.meta.dirname, "../../../../models"),
+            path.resolve(import.meta.dirname, "../../../../src/models"),
+            path.resolve(import.meta.dirname, "../../../models"),
+            path.resolve(import.meta.dirname, "../../../src/models"),
+            path.resolve(process.cwd(), "node_modules/adminizer/src/models"),
+            path.resolve(process.cwd(), "node_modules/adminizer/models")
+        ];
+        let modelsDir = null;
+        for (const possiblePath of possiblePaths) {
+            if (fs.existsSync(possiblePath)) {
+                modelsDir = possiblePath;
+                break;
+            }
         }
-        let files = fs.readdirSync(modelsDir).filter(f => f.endsWith(".js"));
+        if (!modelsDir) {
+            return;
+        }
+        let files = fs.readdirSync(modelsDir).filter((f) => f.endsWith(".js"));
         if (!files.length) {
-            files = fs.readdirSync(modelsDir).filter(f => f.endsWith(".ts") && !f.endsWith(".d.ts"));
+            files = fs.readdirSync(modelsDir).filter((f) => f.endsWith(".ts") && !f.endsWith(".d.ts"));
         }
         if (!files.length) {
-            throw `Model files not found in dir ${modelsDir}`;
+            return;
         }
         const schemas = {};
         for (const file of files) {
@@ -575,9 +592,12 @@ export class SequelizeAdapter extends AbstractAdapter {
             generateSequelizeModel(sequelize, modelName, definition);
         }
         generateAssociationsFromSchema(sequelize.models, schemas);
-        if (alter === true) {
+        // Check ORM_ALTER environment variable before sync
+        if (process.env.ORM_ALTER !== 'false' && alter) {
             await sequelize.sync();
         }
+        else {
+        }
     }
 }
 /**Generation of the SEQUELIZE model from the definition, analogue of Waterinecollection.extenD*/

package/lib/{v4/notifications → notifications}/AbstractNotificationService.d.ts

@@ -1,22 +1,29 @@
 import { EventEmitter } from 'events';
-import { Adminizer } from '../../Adminizer';
-import { INotification, INotificationEvent } from '../../../interfaces/types';
+import { Adminizer } from '../Adminizer';
+import { INotification, INotificationEvent } from '../../interfaces/types';
+import { NotificationAPModel } from "../../models/NotificationAP";
+import { UserAP } from "../../models/UserAP";
 export declare abstract class AbstractNotificationService extends EventEmitter {
-    protected clients: Map<string, (event: INotificationEvent) => void>;
+    protected clients: Map<number, Map<string, (event: INotificationEvent) => void>>;
     protected adminizer: Adminizer;
     abstract readonly notificationClass: string;
     abstract readonly icon: string;
     abstract readonly iconColor: string;
     constructor(adminizer: Adminizer);
-    addClient(clientId: string, sendFn: (event: INotificationEvent) => void): void;
+    private _bindAccessRight;
+    addClient(clientId: string, sendFn: (event: INotificationEvent) => void, user: UserAP): void;
     removeClient(clientId: string): void;
+    getUserClients(userId: number): Map<string, (event: INotificationEvent) => void>;
+    getClientCount(): number;
+    getAllClients(): Map<string, (event: INotificationEvent) => void>;
     abstract dispatchNotification(notification: Omit<INotification, 'id' | 'createdAt' | 'notificationClass' | 'icon'>): Promise<boolean>;
     protected broadcast(event: INotificationEvent): void;
     sendHeartbeat(clientId: string): void;
-    protected generateId(): string;
-    getClientCount(): number;
     protected createUserNotification(notificationId: string, userId?: number): Promise<void>;
     protected getUserNotification(notificationId: string, userId: number): Promise<any>;
-    getNotifications(userId: number, limit?: number, unreadOnly?: boolean): Promise<INotification[]>;
+    getNotifications(userId: number, limit?: number, skip?: number, unreadOnly?: boolean): Promise<INotification[]>;
+    protected prepareNotification(notificationsDB: NotificationAPModel[], userId: number): Promise<INotification[]>;
+    search(s: string, userId: number): Promise<INotification[]>;
     markAsRead(userId: number, id: string): Promise<void>;
+    markAllAsRead(userId: number): Promise<void>;
 }

package/lib/notifications/AbstractNotificationService.js

@@ -0,0 +1,233 @@
+import { EventEmitter } from 'events';
+import { Adminizer } from '../Adminizer';
+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);
+    }
+    // Добавление клиента
+    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}`);
+    }
+    // Удаление клиента
+    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`);
+    }
+    // Получение клиентов конкретного пользователя
+    getUserClients(userId) {
+        return this.clients.get(userId) || new Map();
+    }
+    // Получение количества подключенных клиентов
+    getClientCount() {
+        return this.clients.size;
+    }
+    // Получение всех клиентов (для обратной совместимости)
+    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;
+    }
+    // Рассылка события всем клиентам
+    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);
+                }
+            });
+        }
+    }
+    // Отправка 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;
+            }
+        }
+    }
+    // Метод для создания записи в UserNotificationAP
+    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);
+            }
+        }
+    }
+    // Метод для получения UserNotificationAP по ID уведомления и пользователя
+    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;
+    }
+    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 [];
+        }
+    }
+    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;
+    }
+    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 [];
+        }
+    }
+    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);
+        }
+    }
+    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/{v4/notifications → notifications}/GeneralNotificationService.d.ts

@@ -1,5 +1,5 @@
 import { AbstractNotificationService } from './AbstractNotificationService';
-import { INotification } from '../../../interfaces/types';
+import { INotification } from '../../interfaces/types';
 export declare class GeneralNotificationService extends AbstractNotificationService {
     readonly notificationClass = "general";
     readonly icon: string;

package/lib/{v4/notifications → notifications}/GeneralNotificationService.js

@@ -1,5 +1,5 @@
 import { AbstractNotificationService } from './AbstractNotificationService';
-import { Adminizer } from '../../Adminizer';
+import { Adminizer } from '../Adminizer';
 export class GeneralNotificationService extends AbstractNotificationService {
     notificationClass = 'general';
     icon = 'info';
@@ -23,7 +23,9 @@ export class GeneralNotificationService extends AbstractNotificationService {
                     const users = await this.adminizer.modelHandler.model.get('userap')["_find"]({});
                     for (const user of users) {
                         try {
-                            await this.createUserNotification(notificationDB.id, user.id);
+                            if (this.adminizer.accessRightsHelper.hasPermission(`notification-${this.notificationClass}`, user)) {
+                                await this.createUserNotification(notificationDB.id, user.id);
+                            }
                         }
                         catch (error) {
                             Adminizer.log.error('Error creating UserNotificationAP:', error);

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/{v4/notifications → notifications}/SystemNotificationService.d.ts

@@ -1,5 +1,5 @@
 import { AbstractNotificationService } from './AbstractNotificationService';
-import { INotification } from '../../../interfaces/types';
+import { INotification } from '../../interfaces/types';
 export declare class SystemNotificationService extends AbstractNotificationService {
     readonly notificationClass = "system";
     readonly icon: string;
@@ -7,12 +7,13 @@ export declare class SystemNotificationService extends AbstractNotificationServi
     private crudChannels;
     dispatchNotification(notification: Omit<INotification, 'id' | 'createdAt' | 'notificationClass' | 'icon'>): Promise<boolean>;
     private broadcastToChannel;
-    addClientToChannel(clientId: string, channel: string): void;
-    removeClientFromChannel(clientId: string, channel: string): void;
-    removeClientFromAllChannels(clientId: string): void;
+    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>>;
 }

package/lib/notifications/SystemNotificationService.js

@@ -0,0 +1,173 @@
+import { AbstractNotificationService } from './AbstractNotificationService';
+import { Adminizer } from '../Adminizer';
+export class SystemNotificationService extends AbstractNotificationService {
+    notificationClass = 'system';
+    icon = 'settings';
+    iconColor = '#1eb707';
+    // Изменяем структуру каналов: храним по userId -> channel -> clientIds
+    crudChannels = new Map();
+    async dispatchNotification(notification) {
+        const fullNotification = {
+            ...notification,
+            notificationClass: this.notificationClass,
+            channel: notification.channel ?? ''
+        };
+        let notificationDB;
+        // Сохраняем в базу
+        if (this.adminizer.modelHandler.model.has('notificationap')) {
+            try {
+                notificationDB = await this.adminizer.modelHandler.model.get('notificationap')["_create"](fullNotification);
+                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);
+                        }
+                    }
+                    catch (error) {
+                        Adminizer.log.error('Error creating UserNotificationAP:', error);
+                    }
+                }
+                const event = {
+                    type: 'notification',
+                    data: {
+                        ...notificationDB,
+                        icon: {
+                            icon: this.icon,
+                            iconColor: this.iconColor
+                        },
+                    },
+                    notificationClass: this.notificationClass,
+                    userId: notification.userId ?? null,
+                    channel: notification.channel ?? 'system'
+                };
+                // Отправляем на все каналы или на конкретный канал
+                if (notification.channel) {
+                    this.broadcastToChannel(notification.channel, event);
+                }
+                else {
+                    this.broadcastToChannel('system', event);
+                }
+                Adminizer.log.info(`[System] Notification dispatched: ${fullNotification.title}`);
+                return true;
+            }
+            catch (error) {
+                Adminizer.log.error('Error saving system notification to database:', error);
+            }
+        }
+        return false;
+    }
+    // Обновляем broadcastToChannel для работы с новой структурой
+    broadcastToChannel(channel, event) {
+        // Отправляем всем пользователям, подписанным на этот канал
+        this.crudChannels.forEach((userChannels, userId) => {
+            const channelClients = userChannels.get(channel);
+            if (channelClients) {
+                const userClients = this.clients.get(userId);
+                if (userClients) {
+                    channelClients.forEach(clientId => {
+                        const sendFn = userClients.get(clientId);
+                        if (sendFn) {
+                            try {
+                                sendFn(event);
+                            }
+                            catch (error) {
+                                Adminizer.log.error(`[${this.notificationClass}] Error sending to client ${clientId} on channel ${channel}:`, error);
+                                this.removeClient(clientId);
+                            }
+                        }
+                    });
+                }
+            }
+        });
+    }
+    // Добавляем клиента к каналу с привязкой к пользователю
+    addClientToChannel(clientId, channel, userId) {
+        if (!this.crudChannels.has(userId)) {
+            this.crudChannels.set(userId, new Map());
+        }
+        const userChannels = this.crudChannels.get(userId);
+        if (!userChannels.has(channel)) {
+            userChannels.set(channel, new Set());
+        }
+        userChannels.get(channel).add(clientId);
+        Adminizer.log.info(`[${this.notificationClass}] Client ${clientId} (user ${userId}) added to channel ${channel}`);
+    }
+    // Удаляем клиента из канала конкретного пользователя
+    removeClientFromChannel(clientId, channel, userId) {
+        const userChannels = this.crudChannels.get(userId);
+        if (userChannels) {
+            const channelClients = userChannels.get(channel);
+            if (channelClients) {
+                channelClients.delete(clientId);
+                Adminizer.log.info(`[${this.notificationClass}] Client ${clientId} (user ${userId}) removed from channel ${channel}`);
+                // Если в канале больше нет клиентов - удаляем канал
+                if (channelClients.size === 0) {
+                    userChannels.delete(channel);
+                }
+            }
+            // Если у пользователя больше нет каналов - удаляем запись пользователя
+            if (userChannels.size === 0) {
+                this.crudChannels.delete(userId);
+            }
+        }
+    }
+    // Удаляем клиента из всех каналов пользователя
+    removeClientFromAllChannels(clientId, userId) {
+        const userChannels = this.crudChannels.get(userId);
+        if (userChannels) {
+            userChannels.forEach((clients, channel) => {
+                clients.delete(clientId);
+                Adminizer.log.info(`[${this.notificationClass}] Client ${clientId} (user ${userId}) removed from channel ${channel}`);
+                // Если в канале больше нет клиентов - удаляем канал
+                if (clients.size === 0) {
+                    userChannels.delete(channel);
+                }
+            });
+            // Если у пользователя больше нет каналов - удаляем запись пользователя
+            if (userChannels.size === 0) {
+                this.crudChannels.delete(userId);
+            }
+        }
+    }
+    // Переопределяем removeClient для очистки каналов
+    removeClient(clientId) {
+        // Находим userId по clientId
+        let foundUserId = null;
+        for (const [userId, userClients] of this.clients.entries()) {
+            if (userClients.has(clientId)) {
+                foundUserId = userId;
+                break;
+            }
+        }
+        // Удаляем клиента из основного хранилища
+        super.removeClient(clientId);
+        // Удаляем клиента из каналов
+        if (foundUserId !== null) {
+            this.removeClientFromAllChannels(clientId, foundUserId);
+        }
+    }
+    // Специальный метод для системных событий с указанием канала
+    async logSystemEvent(title, message, channel, metadata) {
+        return this.dispatchNotification({
+            title: title,
+            message: message,
+            metadata: metadata,
+            channel: channel
+        });
+    }
+    // Методы для CRUD операций
+    async logCreatedEvent(title, message, metadata) {
+        return this.logSystemEvent(title, message, 'created', metadata);
+    }
+    async logUpdatedEvent(title, message, metadata) {
+        return this.logSystemEvent(title, message, 'updated', metadata);
+    }
+    async logDeletedEvent(title, message, metadata) {
+        return this.logSystemEvent(title, message, 'deleted', metadata);
+    }
+    // Новый метод для получения каналов пользователя
+    getUserChannels(userId) {
+        return this.crudChannels.get(userId) || new Map();
+    }
+}

package/lib/{v4/widgets → widgets}/abstractCustom.d.ts

@@ -1,4 +1,4 @@
-import { MaterialIcon } from "../../../interfaces/MaaterialIcons";
+import { MaterialIcon } from "../../interfaces/MaaterialIcons";
 export declare abstract class CustomBase {
     /** Widget unique id */
     abstract readonly id: string;